JiConOp2 (#1569)

* squash: Extracts parsing disco info in utility method.

* squash: Extracts parsing disco info identities and features in utility method.

* squash: Skip disco-info on reconnection.

Doing disco info queries only once.
If the call is longer than 24-hours turn credentials may be expired.

* feat: Adds handler for early messages with conference info data.

* feat: JiConOp handling for shard name.

* squash: Drops unneeded check.

* squash: Changes message type to service-info.

* squash: Moves utility parseDiscoInfo out of the Caps class.

modules/xmpp/Caps.js

     return b64_sha1(sortedIdentities + sortedFeatures);
 }
 
+/**
+ * Parses the disco-info node and returns the sets of features and identities.
+ * @param {String} node The node with results to parse.
+ * @returns {{features: Set<any>, identities: Set<any>}}
+ */
+export function parseDiscoInfo(node) {
+    const features = new Set();
+    const identities = new Set();
+
+    $(node).find('>query>feature')
+        .each((_, el) => features.add(el.getAttribute('var')));
+    $(node).find('>query>identity')
+        .each((_, el) => identities.add({
+            type: el.getAttribute('type'),
+            name: el.getAttribute('name'),
+            category: el.getAttribute('category')
+        }));
+
+    return {
+        features,
+        identities
+    };
+}
+
 /**
  * Implements xep-0115 ( http://xmpp.org/extensions/xep-0115.html )
  */
     _getDiscoInfo(jid, node, timeout) {
         return new Promise((resolve, reject) =>
             this.disco.info(jid, node, response => {
-                const features = new Set();
-                const identities = new Set();
-
-                $(response)
-                    .find('>query>feature')
-                    .each(
-                        (_, el) => features.add(el.getAttribute('var')));
-                $(response)
-                    .find('>query>identity')
-                    .each(
-                        (_, el) => identities.add({
-                            type: el.getAttribute('type'),
-                            name: el.getAttribute('name'),
-                            category: el.getAttribute('category')
-                        }));
-                resolve({
-                    features,
-                    identities });
+                resolve(parseDiscoInfo(response));
             }, reject, timeout)
         );
     }

modules/xmpp/xmpp.js

 import Listenable from '../util/Listenable';
 import RandomUtil from '../util/RandomUtil';
 
-import Caps from './Caps';
+import Caps, { parseDiscoInfo } from './Caps';
 import XmppConnection from './XmppConnection';
 import MucConnectionPlugin from './strophe.emuc';
 import JingleConnectionPlugin from './strophe.jingle';
 
         this.eventEmitter.emit(XMPPEvents.CONNECTION_STATUS_CHANGED, credentials, status, msg);
         if (status === Strophe.Status.CONNECTED || status === Strophe.Status.ATTACHED) {
-            this.connection.jingle.getStunAndTurnCredentials();
+            this.sendDiscoInfo && this.connection.jingle.getStunAndTurnCredentials();
 
             logger.info(`My Jabber ID: ${this.connection.jid}`);
 
             // XmppConnection emits CONNECTED again on reconnect - a good opportunity to clear any "last error" flags
             this._resetState();
 
-            // FIXME no need to do it again on stream resume
-            this.caps.getFeaturesAndIdentities(this.options.hosts.domain)
+            this.sendDiscoInfo && this.caps.getFeaturesAndIdentities(this.options.hosts.domain)
                 .then(({ features, identities }) => {
                     if (!features.has(Strophe.NS.PING)) {
                         logger.error(`Ping NOT supported by ${
                             this.options.hosts.domain} - please enable ping in your XMPP server config`);
                     }
 
-                    // check for speakerstats
-                    identities.forEach(identity => {
-                        if (identity.type === 'speakerstats') {
-                            this.speakerStatsComponentAddress = identity.name;
-                        }
-
-                        if (identity.type === 'conference_duration') {
-                            this.conferenceDurationComponentAddress = identity.name;
-                        }
-
-                        if (identity.type === 'lobbyrooms') {
-                            this.lobbySupported = true;
-                            identity.name && this.caps.getFeaturesAndIdentities(identity.name, identity.type)
-                                .then(({ features: f }) => {
-                                    f.forEach(fr => {
-                                        if (fr.endsWith('#displayname_required')) {
-                                            this.eventEmitter.emit(
-                                                JitsiConnectionEvents.DISPLAY_NAME_REQUIRED);
-                                        }
-                                    });
-                                })
-                                .catch(e => logger.warn('Error getting features from lobby.', e && e.message));
-                        }
-                    });
-
-                    if (this.speakerStatsComponentAddress
-                        || this.conferenceDurationComponentAddress) {
-                        this.connection.addHandler(
-                            this._onPrivateMessage.bind(this), null,
-                            'message', null, null);
-                    }
+                    this._processDiscoInfoIdentities(
+                        identities, undefined /* when querying we will query for features */);
                 })
                 .catch(error => {
                     const errmsg = 'Feature discovery error';
                     logger.error(errmsg, error);
                 });
 
+            // make sure we don't query again
+            this.sendDiscoInfo = false;
+
             if (credentials.password) {
                 this.authenticatedUser = true;
             }
         }
     }
 
+    /**
+     * Process received identities.
+     * @param {Set<String>} identities The identities to process.
+     * @param {Set<String>} features The features to process, optional. If missing lobby component will be queried
+     * for more features.
+     * @private
+     */
+    _processDiscoInfoIdentities(identities, features) {
+        // check for speakerstats
+        identities.forEach(identity => {
+            if (identity.type === 'speakerstats') {
+                this.speakerStatsComponentAddress = identity.name;
+            }
+
+            if (identity.type === 'conference_duration') {
+                this.conferenceDurationComponentAddress = identity.name;
+            }
+
+            if (identity.type === 'lobbyrooms') {
+                this.lobbySupported = true;
+                const processLobbyFeatures = f => {
+                    f.forEach(fr => {
+                        if (fr.endsWith('#displayname_required')) {
+                            this.eventEmitter.emit(JitsiConnectionEvents.DISPLAY_NAME_REQUIRED);
+                        }
+                    });
+                };
+
+                if (features) {
+                    processLobbyFeatures(features);
+                } else {
+                    identity.name && this.caps.getFeaturesAndIdentities(identity.name, identity.type)
+                        .then(({ features: f }) => processLobbyFeatures(f))
+                        .catch(e => logger.warn('Error getting features from lobby.', e && e.message));
+                }
+            }
+        });
+
+        if (this.speakerStatsComponentAddress
+            || this.conferenceDurationComponentAddress) {
+            this.connection.addHandler(this._onPrivateMessage.bind(this), null, 'message', null, null);
+        }
+    }
+
     /**
     * Parses a raw failure xmpp xml message received on auth failed.
     *
         //  Status.ATTACHED - The connection has been attached
 
         this._resetState();
+
+        this.sendDiscoInfo = true;
+
+        if (this.connection._stropheConn && this.connection._stropheConn._addSysHandler) {
+            this.connection._stropheConn._addSysHandler(msg => {
+                this.sendDiscoInfo = false;
+
+                this.connection.jingle.onReceiveStunAndTurnCredentials(msg);
+
+                const { features, identities } = parseDiscoInfo(msg);
+
+                this._processDiscoInfoIdentities(identities, features);
+
+                // check for shard name in identities
+                identities.forEach(i => {
+                    if (i.type === 'shard') {
+                        this.options.deploymentInfo.shard = i.name;
+                    }
+                });
+            }, null, 'message', 'service-info', null);
+        } else {
+            logger.warn('Cannot attach strophe system handler, jiconop cannot operate');
+        }
+
         this.connection.connect(
             jid,
             password,