Reloads JitsiConnection on prosody or jicofo restart

JitsiConference.js

     }
     this.eventEmitter = new EventEmitter();
     this.settings = new Settings();
+    this.retries = 0;
     this._init(options);
     this.componentsVersions = new ComponentsVersions(this);
     this.rtc = new RTC(this, options);
     // reloaded)
     this.connection = options.connection || this.connection;
     this.xmpp = this.connection.xmpp;
-
+    this.retries++;
     this.room = this.xmpp.createRoom(this.options.name, this.options.config,
-        this.settings);
+        this.settings, (this.retries < 4 ? 3 : null));
 
     //restore previous presence options
     if(options.roomState) {

JitsiConferenceEventManager.js

         JitsiConferenceEvents.CONFERENCE_FAILED,
         JitsiConferenceErrors.FOCUS_DISCONNECTED);
 
-    this.chatRoomForwarder.forward(XMPPEvents.FOCUS_LEFT,
-        JitsiConferenceEvents.CONFERENCE_FAILED,
-        JitsiConferenceErrors.FOCUS_LEFT);
+    conference.room.addListener(XMPPEvents.FOCUS_LEFT,
+        function () {
+            if(!conference.connection.reload())
+                conference.eventEmitter.emit(
+                    JitsiConferenceEvents.CONFERENCE_FAILED,
+                    JitsiConferenceErrors.FOCUS_LEFT);
+        });
+
+    conference.room.addListener(XMPPEvents.ALLOCATE_FOCUS_MAX_RETRIES_ERROR,
+        function () {
+            conference.connection.reload();
+        });
 
     this.chatRoomForwarder.forward(XMPPEvents.CONNECTION_INTERRUPTED,
         JitsiConferenceEvents.CONNECTION_INTERRUPTED);

JitsiConnection.js

 var JitsiConference = require("./JitsiConference");
 var XMPP = require("./modules/xmpp/xmpp");
 var JitsiConnectionEvents = require("./JitsiConnectionEvents");
+var JitsiConnectionErrors = require("./JitsiConnectionErrors");
 
 /**
  * Creates new connection object for the Jitsi Meet server side video conferencing service. Provides access to the
     this.options = options;
     this.xmpp = new XMPP(options, token);
     this.conferences = {};
+    this.retryOnFail = 0;
+    this.addEventListener(JitsiConnectionEvents.CONNECTION_ESTABLISHED,
+        function () {
+            this.retryOnFail = 3;
+        }.bind(this));
+
+    this.addEventListener(JitsiConnectionEvents.CONNECTION_FAILED,
+        function (errType, msg) {
+            if(errType === JitsiConnectionErrors.OTHER_ERROR &&
+                (msg === "item-not-found" || msg === "host-unknown")) {
+                    // FIXME: don't report the error if we are going to reload
+                    this.reload();
+                }
+        }.bind(this));
 }
 
 /**
  * @param options {object} options to be overriden
  */
 JitsiConnection.prototype.reload = function (options) {
+    if(this.retryOnFail === 0)
+        return false;
+    this.retryOnFail--;
     var states = {};
     for(var name in this.conferences) {
         states[name] = this.conferences[name].room.exportState();
         this.conferences[name].leave(true);
     }
     this.connectionEstablishedHandler =
-        this.reloadConferneces.bind(this, states);
+        this.reloadConferences.bind(this, states);
     this.addEventListener(JitsiConnectionEvents.CONNECTION_ESTABLISHED,
         this.connectionEstablishedHandler);
     this.xmpp.reload(options || {});
+    return true;
 }
 
 /**

modules/xmpp/ChatRoom.js

     return res;
 }
 
-function ChatRoom(connection, jid, password, XMPP, options, settings) {
+function ChatRoom(connection, jid, password, XMPP, options, settings,
+    maxRetries) {
     this.eventEmitter = new EventEmitter();
     this.xmpp = XMPP;
     this.connection = connection;
     this.bridgeIsDown = false;
     this.options = options || {};
     this.moderator = new Moderator(this.roomjid, this.xmpp, this.eventEmitter,
-        settings, {connection: this.xmpp.options, conference: this.options});
+        settings, {connection: this.xmpp.options, conference: this.options},
+        maxRetries);
     this.initPresenceMap();
     this.session = null;
     var self = this;
     member.jid = jid;
     member.isFocus
         = jid && jid.indexOf(this.moderator.getFocusUserJid() + "/") === 0;
-
+    console.debug("aaaaa", jid, this.moderator.getFocusUserJid(), pres);
     member.isHiddenDomain
         = jid && jid.indexOf("@") > 0
             && this.options.hiddenDomain

modules/xmpp/JingleSessionPC.js

             error.source = request.tree();
         }
 
+        // FIXME: JSON.stringify(error) exception for
+        // circular dependancies when we print that error. Maybe we can include
+        // part of the session object
         error.session = this;
 
         logger.error("Jingle error", error);

modules/xmpp/moderator.js

     };
 }
 
-function Moderator(roomName, xmpp, emitter, settings, options) {
+function Moderator(roomName, xmpp, emitter, settings, options, maxRetries) {
     this.roomName = roomName;
     this.xmppService = xmpp;
     this.getNextTimeout = createExpBackoffTimer(1000);
     this.externalAuthEnabled = false;
     this.settings = settings;
     this.options = options;
+    this.maxRetries = maxRetries || Infinity;
+    this.retries = 0;
 
     // Sip gateway can be enabled by configuring Jigasi host in config.js or
     // it will be enabled automatically if focus detects the component through
                 });
         return;
     }
+    if(this.retries >= this.maxRetries) {
+        self.eventEmitter.emit(
+                XMPPEvents.ALLOCATE_FOCUS_MAX_RETRIES_ERROR);
+        return;
+    }
+    this.retries++;
     var waitMs = self.getNextErrorTimeout();
     var errmsg = "Focus error, retry after "+ waitMs;
     GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));

modules/xmpp/strophe.emuc.js

             this.connection.addHandler(this.onMute.bind(this),
                 'http://jitsi.org/jitmeet/audio', 'iq', 'set',null,null);
         },
-        createRoom: function (jid, password, options, settings) {
+        createRoom: function (jid, password, options, settings, maxRetries) {
             var roomJid = Strophe.getBareJidFromJid(jid);
             if (this.rooms[roomJid]) {
                 var errmsg = "You are already in the room!";
                 return;
             }
             this.rooms[roomJid] = new ChatRoom(this.connection, jid,
-                password, XMPP, options, settings);
+                password, XMPP, options, settings, maxRetries);
             return this.rooms[roomJid];
         },
         doLeave: function (jid) {

modules/xmpp/xmpp.js

     return this._connect(jid, password);
 };
 
-XMPP.prototype.createRoom = function (roomName, options, settings) {
+XMPP.prototype.createRoom = function (roomName, options, settings, maxRetries) {
     var roomjid = roomName  + '@' + this.options.hosts.muc;
 
     if (options.useNicks) {
         roomjid += '/' + tmpJid;
     }
 
-    return this.connection.emuc.createRoom(roomjid, null, options, settings);
+    return this.connection.emuc.createRoom(roomjid, null, options, settings,
+        maxRetries);
 }
 
 XMPP.prototype.addListener = function(type, listener) {

service/xmpp/XMPPEvents.js

     // audio.
     AUDIO_MUTED_BY_FOCUS: "xmpp.audio_muted_by_focus",
     AUTHENTICATION_REQUIRED: "xmpp.authentication_required",
+    /**
+     * Max retries value of Moderator.allocateConferenceFocus failures is
+     * reached.
+     */
+    ALLOCATE_FOCUS_MAX_RETRIES_ERROR: "xmpp.allocate_focus_max_retries_error",
     BRIDGE_DOWN: "xmpp.bridge_down",
     // Designates an event indicating that an offer (e.g. Jingle
     // session-initiate) was received.