Log errors and exit on authentication issues on Hubot plugin initialization

CHANGELOG.rst

@@ -3,6 +3,8 @@ Changelog
 
 in development
 --------------
+* st2chatops now gracefully exits on authentication failures and uncaught exceptions (improvement)
+* code cleanup (improvement)
 
 0.9.3
 -----

lib/slack-messages.js

@@ -16,37 +16,6 @@
 
 var utils = require('./utils.js');
 
-// Polyfill from:
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
-if (typeof Object.assign !== 'function') {
-  // Must be writable: true, enumerable: false, configurable: true
-  Object.defineProperty(Object, "assign", {
-    value: function assign(target, varArgs) { // .length of function is 2
-      if (target === null) { // TypeError if undefined or null
-        throw new TypeError('Cannot convert undefined or null to object');
-      }
-
-      var to = Object(target);
-
-      for (var index = 1; index < arguments.length; index++) {
-        var nextSource = arguments[index];
-
-        if (nextSource !== null) { // Skip over if undefined or null
-          for (var nextKey in nextSource) {
-            // Avoid bugs when hasOwnProperty is shadowed
-            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
-              to[nextKey] = nextSource[nextKey];
-            }
-          }
-        }
-      }
-      return to;
-    },
-    writable: true,
-    configurable: true
-  });
-}
-
 var buildMessagesWithChunkedFieldValue = function (msg) {
   var msgs;
 

lib/slack_monkey_patch.js

@@ -24,6 +24,18 @@ function patchSendMessage(robot) {
   // formatted and parsed on the server side.
   // NOTE / TODO: We can get rid of this nasty patch once our node-slack-client and hubot-slack pull
   // requests are merged.
+  // This code was refactored in https://github.com/StackStorm/hubot-stackstorm/pull/6
+  // which was opened and merged by Kami on 2015-06-04.
+  // As of 2019-05-22, these were the PRs I could find for the node-slack-client
+  // hubot-slack repositories:
+  // * https://github.com/slackapi/node-slack-sdk/pull/42
+  //   - which was closed during a refactor and converted into an issue:
+  //     https://github.com/slackapi/node-slack-sdk/issues/138
+  // * https://github.com/slackapi/hubot-slack/pull/544
+  //   - which was opened on 2018-11-14, which seems to be too late to actually
+  //     apply to this code
+  // So...I'm not entirely sure this monkey patch is still necessary.
+  // End-to-end testing is required to figure out for sure.
   if (robot.adapter && robot.adapter.constructor && robot.adapter.constructor.name === 'SlackBot') {
     for (var channel in robot.adapter.client.channels) {
       robot.adapter.client.channels[channel].sendMessage = sendMessageRaw.bind(robot.adapter.client.channels[channel]);

package.json

@@ -37,6 +37,7 @@
   "devDependencies": {
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
+    "chai-string": "^1.5.0",
     "eslint": "^5.16.0",
     "eslint-plugin-notice": "0.7.8",
     "gulp": "^3.9.1",
@@ -48,6 +49,7 @@
     "hubot-help": "0.2.2",
     "hubot-mock-adapter": "^1.1.1",
     "log": "1.4.0",
+    "mocked-env": "^1.2.4",
     "nock": "^10.0.0",
     "nyc": "^13.0.1",
     "sinon": "^6.3.5",

scripts/stackstorm.js

@@ -99,22 +99,20 @@ var TWOFACTOR_MESSAGE = "This action requires two-factor auth! Waiting for your
 module.exports = function(robot) {
   slack_monkey_patch.patchSendMessage(robot);
 
-  var self = this;
-
-  var promise = Promise.resolve();
-
   if (env.ST2_API) {
     robot.logger.warning("ST2_API is deprecated and will be removed in a future releases. Instead, please use the ST2_API_URL environment variable.");
   }
-  var url = utils.parseUrl(env.ST2_API_URL);
-
-  var opts = {
-    protocol: url.protocol,
-    host: url.hostname,
-    port: url.port,
-    prefix: url.path,
-    rejectUnauthorized: false
-  };
+  var _stream = null,
+    self = this,
+    promise = Promise.resolve(),
+    url = utils.parseUrl(env.ST2_API_URL),
+    opts = {
+      protocol: url.protocol,
+      host: url.hostname,
+      port: url.port,
+      prefix: url.path,
+      rejectUnauthorized: false
+    };
 
   if (env.ST2_STREAM_URL) {
     var stream_url = utils.parseUrl(env.ST2_STREAM_URL);
@@ -126,16 +124,30 @@ module.exports = function(robot) {
     };
   }
 
-  var api = st2client(opts);
+  var api_client = st2client(opts);
 
   if (env.ST2_API_KEY) {
-    api.setKey({ key: env.ST2_API_KEY });
+    api_client.setKey({ key: env.ST2_API_KEY });
   } else if (env.ST2_AUTH_TOKEN) {
-    api.setToken({ token: env.ST2_AUTH_TOKEN });
+    api_client.setToken({ token: env.ST2_AUTH_TOKEN });
+  }
+
+  function logErrorAndExit(err, res) {
+    if (err) {
+      robot.logger.error(err.stack);
+    }
+    if (res) {
+      res.send(JSON.stringify({
+        "status": "failed",
+        "msg": "An error occurred trying to post the message:\n" + err
+      }));
+    }
+
+    stop({shutdown: true});
   }
 
   function authenticate() {
-    api.removeListener('expiry', authenticate);
+    api_client.removeListener('expiry', authenticate);
 
     // API key gets precedence 1
     if (env.ST2_API_KEY) {
@@ -152,7 +164,7 @@ module.exports = function(robot) {
 
     var url = utils.parseUrl(env.ST2_AUTH_URL);
 
-    var client = st2client({
+    var auth_client = st2client({
       auth: {
         protocol: url.protocol,
         host: url.hostname,
@@ -161,26 +173,28 @@ module.exports = function(robot) {
       }
     });
 
-    return client.authenticate(env.ST2_AUTH_USERNAME, env.ST2_AUTH_PASSWORD)
+    return auth_client.authenticate(env.ST2_AUTH_USERNAME, env.ST2_AUTH_PASSWORD)
       .then(function (token) {
         robot.logger.info('Token received. Expiring ' + token.expiry);
-        api.setToken(token);
-        client.on('expiry', authenticate);
+        api_client.setToken(token);
+        auth_client.on('expiry', authenticate);
       })
       .catch(function (err) {
-        robot.logger.error('Failed to authenticate: ' + err.message);
-
-        throw err;
+        // Exit from invalid ST2_AUTH_USERNAME or ST2_AUTH_PASSWORD.
+        robot.logger.error('Failed to authenticate with st2 username and password: ' + err.message);
+        logErrorAndExit(err);
       });
   }
 
   if (env.ST2_API_KEY || env.ST2_AUTH_TOKEN || env.ST2_AUTH_USERNAME || env.ST2_AUTH_PASSWORD) {
     // If using username and password then all are required.
     if ((env.ST2_AUTH_USERNAME || env.ST2_AUTH_PASSWORD) &&
         !(env.ST2_AUTH_USERNAME && env.ST2_AUTH_PASSWORD && env.ST2_AUTH_URL)) {
-      throw new Error('Env variables ST2_AUTH_USERNAME, ST2_AUTH_PASSWORD and ST2_AUTH_URL should only be used together.');
+      robot.logger.error('Environment variables ST2_AUTH_USERNAME, ST2_AUTH_PASSWORD and ST2_AUTH_URL should only be used together.');
+      stop({shutdown: true});
+    } else {
+      promise = authenticate();
     }
-    promise = authenticate();
   }
 
   // Pending 2-factor auth commands
@@ -199,9 +213,9 @@ module.exports = function(robot) {
   var postDataHandler = postData.getDataPostHandler(robot.adapterName, robot, formatter);
 
   var loadCommands = function() {
-    robot.logger.info('Loading commands....');
+    robot.logger.info('Loading commands...');
 
-    api.actionAlias.list()
+    api_client.actionAlias.list()
       .then(function (aliases) {
         // Remove all the existing commands
         command_factory.removeCommands();
@@ -237,6 +251,9 @@ module.exports = function(robot) {
       .catch(function (err) {
         var error_msg = 'Failed to retrieve commands from "%s": %s';
         robot.logger.error(util.format(error_msg, env.ST2_API_URL, err.message));
+        if (err.status === 401 && err.message.includes("Unauthorized")) {
+          logErrorAndExit(err);
+        }
       });
   };
 
@@ -263,7 +280,7 @@ module.exports = function(robot) {
   var sendAliasExecutionRequest = function (msg, payload) {
     robot.logger.debug('Sending command payload:', JSON.stringify(payload));
 
-    api.aliasExecution.create(payload)
+    api_client.aliasExecution.create(payload)
       .then(function (res) { sendAck(msg, res); })
       .catch(function (err) {
         // Compatibility with older StackStorm versions
@@ -307,7 +324,7 @@ module.exports = function(robot) {
       var twofactor_id = uuid.v4();
       robot.logger.debug('Requested an action that requires 2FA. Guid: ' + twofactor_id);
       msg.send(TWOFACTOR_MESSAGE);
-      api.executions.create({
+      api_client.executions.create({
         'action': env.HUBOT_2FA,
         'parameters': {
           'uuid': twofactor_id,
@@ -326,7 +343,7 @@ module.exports = function(robot) {
   };
 
   robot.respond(/([\s\S]+?)$/i, function(msg) {
-    var command, result, command_name, format_string, action_alias;
+    var command, result;
 
     // Normalize the command and remove special handling provided by the chat service.
     // e.g. slack replace quote marks with left double quote which would break behavior.
@@ -339,9 +356,7 @@ module.exports = function(robot) {
       return;
     }
 
-    command_name = result[0];
-    format_string = result[1];
-    action_alias = result[2];
+    var [command_name, format_string, action_alias] = result;
 
     executeCommand(msg, command_name, format_string, command, action_alias);
   });
@@ -357,25 +372,30 @@ module.exports = function(robot) {
       }
       postDataHandler.postData(data);
 
-      res.send('{"status": "completed", "msg": "Message posted successfully"}');
-    } catch (e) {
-      robot.logger.error("Unable to decode JSON: " + e);
-      robot.logger.error(e.stack);
-      res.send('{"status": "failed", "msg": "An error occurred trying to post the message: ' + e + '"}');
+      res.send(JSON.stringify({
+        "status": "completed",
+        "msg": "Message posted successfully"
+      }));
+    } catch (err) {
+      robot.logger.error('Encountered an error when attempting to post ' +
+                         'message to chat provider, execution results for ' +
+                         'chatops.post_message may not be accurate.');
+      robot.logger.error(err);
     }
   });
 
   var commands_load_interval;
 
   function start() {
-    api.stream.listen().catch(function (err) {
-      robot.logger.error('Unable to connect to stream:', err);
-    }).then(function (source) {
-      source.onerror = function (err) {
-        // TODO: squeeze a little bit more info out of evensource.js
-        robot.logger.error('Stream error:', err);
-      };
-      source.addEventListener('st2.announcement__chatops', function (e) {
+    robot.error(logErrorAndExit);
+
+    api_client.stream.listen().then(function (stream) {
+      _stream = stream;  // save stream for use in stop()
+      stream.on('error', function (err) {
+        robot.logger.error('StackStorm event stream error:', err);
+        robot.logger.error('Implicitly attempting to reconnect to StackStorm event stream.');
+      });
+      stream.addEventListener('st2.announcement__chatops', function (e) {
         var data;
 
         robot.logger.debug('Chatops message received:', e.data);
@@ -390,7 +410,7 @@ module.exports = function(robot) {
       });
 
       if (env.HUBOT_2FA) {
-        source.addEventListener('st2.announcement__2fa', function (e) {
+        stream.addEventListener('st2.announcement__2fa', function (e) {
           var data;
 
           robot.logger.debug('Successfull two-factor auth:', e.data);
@@ -408,22 +428,29 @@ module.exports = function(robot) {
       }
     });
 
-    // Add an interval which tries to re-load the commands
-    commands_load_interval = setInterval(loadCommands.bind(self), (env.ST2_COMMANDS_RELOAD_INTERVAL * 1000));
-
     // Initial command loading
     loadCommands();
 
+    // Add an interval which tries to re-load the commands
+    commands_load_interval = setInterval(loadCommands.bind(self), (env.ST2_COMMANDS_RELOAD_INTERVAL * 1000));
+
     // Install SIGUSR2 handler which reloads the command
     install_sigusr2_handler();
   }
 
-  function stop() {
+  function stop(opts) {
+    var default_opts = {shutdown: false},
+      opts = Object.assign(default_opts, (opts || {}));
     clearInterval(commands_load_interval);
-    api.stream.listen().then(function (source) {
-      source.removeAllListeners();
-      source.close();
-    });
+
+    if (opts.shutdown) {
+      if (_stream) {
+        _stream.removeAllListeners();
+        _stream.close();
+      }
+
+      robot.shutdown();
+    }
   }
 
   function install_sigusr2_handler() {
@@ -433,7 +460,7 @@ module.exports = function(robot) {
   }
 
   // Authenticate with StackStorm backend and then call start.
-  // On a failure to authenticate log the error but do not quit.
+  // On a failure to authenticate log the error and quit.
   return promise.then(function () {
     start();
     return stop;