Merge pull request #118 from jitsi/handle-jibri-errors-and-busy

Handle jibri errors and busy status

JitsiMeetJS.js

 var JitsiConferenceErrors = require("./JitsiConferenceErrors");
 var JitsiTrackEvents = require("./JitsiTrackEvents");
 var JitsiTrackErrors = require("./JitsiTrackErrors");
+var JitsiRecorderErrors = require("./JitsiRecorderErrors");
 var Logger = require("jitsi-meet-logger");
 var MediaType = require("./service/RTC/MediaType");
 var RTC = require("./modules/RTC/RTC");
     errors: {
         conference: JitsiConferenceErrors,
         connection: JitsiConnectionErrors,
+        recorder: JitsiRecorderErrors,
         track: JitsiTrackErrors
     },
     logLevels: Logger.levels,

JitsiRecorderErrors.js

      */
     RECORDER_UNAVAILABLE: "recorder.unavailable",
 
+    /**
+     * Indicates that all available recorders are currently busy.
+     */
+    RECORDER_BUSY: "recorder.busy",
+
     /**
      * Indicates that the authentication token is missing.
      */
      */
     STATE_CHANGE_FAILED: "recorder.stateChangeFailed",
 
+    /**
+     * Indicates an invalid state.
+     */
+    INVALID_STATE: "recorder.invalidState"
 };
 
 module.exports = JitsiRecorderErrors;

modules/xmpp/recording.js

     OFF: "off",
     AVAILABLE: "available",
     UNAVAILABLE: "unavailable",
-    PENDING: "pending"
+    PENDING: "pending",
+    BUSY: "busy",
+    FAILED: "failed"
 };
 
 Recording.action = {
     this.eventEmitter.emit(XMPPEvents.RECORDER_STATE_CHANGED, this.state);
 };
 
-Recording.prototype.setRecordingJibri = function (state, callback, errCallback,
-    options) {
+Recording.prototype.setRecordingJibri
+    = function (state, callback, errCallback, options) {
+
     if (state == this.state){
-        errCallback(new Error("Invalid state!"));
+        errCallback(JitsiRecorderErrors.INVALID_STATE);
     }
     options = options || {};
 
     var oldState = this.state;
 
     // If the recorder is currently unavailable we throw an error.
-    if (oldState === Recording.status.UNAVAILABLE)
-        statusChangeHandler("error",
-            new Error(JitsiRecorderErrors.RECORDER_UNAVAILABLE));
+    if (oldState === Recording.status.UNAVAILABLE
+        || oldState === Recording.status.FAILED)
+        statusChangeHandler(Recording.status.FAILED,
+                            JitsiRecorderErrors.RECORDER_UNAVAILABLE);
+    else if (oldState === Recording.status.BUSY)
+        statusChangeHandler(Recording.status.BUSY,
+                            JitsiRecorderErrors.RECORDER_BUSY);
 
     // If we're about to turn ON the recording we need either a streamId or
     // an authentication token depending on the recording type. If we don't
         || oldState === Recording.status.AVAILABLE)
         && ((!options.token && this.type === Recording.types.COLIBRI) ||
         (!options.streamId && this.type === Recording.types.JIBRI))) {
-        statusChangeHandler("error",
-            new Error(JitsiRecorderErrors.NO_TOKEN));
+        statusChangeHandler(Recording.status.FAILED,
+                            JitsiRecorderErrors.NO_TOKEN);
         logger.error("No token passed!");
         return;
     }
                 statusChangeHandler(state);
             }
         }, function (error) {
-            statusChangeHandler("error", error);
+            statusChangeHandler(Recording.status.FAILED, error);
         }, options);
 };