Merge pull request #401 from BillyAbildgaard/feature/ibms

Feature/ibms

lib/jobs/base-job.js

@@ -426,8 +426,14 @@ function baseJobFactory(
         taskProtocol.publishRunIpmiCommand(uuid, command, machine);
     };
 
-    BaseJob.prototype._publishPollerAlert = function _publishPollerAlert(id, pollerName, data) {
-        taskProtocol.publishPollerAlert(id, pollerName, data);
+    BaseJob.prototype._publishPollerAlertLegacy =
+        function _publishPollerAlertLegacy(id, pollerName, data) {
+
+        taskProtocol.publishPollerAlertLegacy(id, pollerName, data);
+    };
+
+    BaseJob.prototype._publishPollerAlert = function _publishPollerAlert(data) {
+        eventsProtocol.publishExternalEvent(data);
     };
 
     BaseJob.prototype._subscribeRequestPollerCache =

lib/jobs/install-os.js

@@ -49,6 +49,7 @@ function installOsJobFactory(
         self.nodeId = self.context.target;
         self.profile = self.options.profile;
         self.taskId = taskId;
+        self.options.totalSteps = self.options.totalSteps || 100;
 
         //OS repository analyze job may pass some options via shared context
         //The value from shared context will override the value in self options.
@@ -225,7 +226,9 @@ function installOsJobFactory(
                 taskProgress: {
                     taskId: this.taskId,
                     progress: {
-                        value: value, maximum: this.options.totalSteps, description: descript
+                        value: value, 
+                        maximum: this.options.totalSteps,
+                        description: descript
                     }
                 }
         };

lib/jobs/ipmi-job.js

@@ -415,15 +415,28 @@ function ipmiJobFactory(
      */
      IpmiJob.prototype.powerStateAlerter = Promise.method(function(status, data) {
         var self = this;
+        var tmp = {};
+        tmp.type = 'polleralert';
+        tmp.action = 'chassispower.updated';
+        tmp.typeId = data.workItemId;
+        tmp.nodeId = data.node;
+        tmp.severity = "information";
+        tmp.data = {
+            states: {
+                last: self.cachedPowerState[data.workItemId] ? 'ON' : 'OFF',
+                current: status.power ? 'ON' : 'OFF'
+            }
+        };
         if(self.cachedPowerState[data.workItemId] !== status.power) {
-            self._publishPollerAlert(self.routingKey, 'chassis.power', {
+            self._publishPollerAlertLegacy(self.routingKey, 'chassis.power', {
                 states: {
                     last: self.cachedPowerState[data.workItemId] ? 'ON' : 'OFF',
                     current: status.power ? 'ON' : 'OFF'
                 },
                 nodeRef: '/nodes/' + data.node,
                 dataRef: '/pollers/' + data.workItemId + '/data/current'
             });
+            self._publishPollerAlert(tmp);
             self.cachedPowerState[data.workItemId] = status.power;
         }
         return status;

lib/jobs/ipmi-sdr-alert-job.js

@@ -45,7 +45,46 @@ function ipmiSdrPollerAlertJobFactory(
     }
     util.inherits(IpmiSdrPollerAlertJob, PollerAlertJob);
 
+    IpmiSdrPollerAlertJob.prototype._formatSdrAlert = function _formatSdrAlert(data) {
+        /*
+         * data format:
+           [ { user: 'admin',
+               host: '192.168.188.91',
+               node: '5858c7f7f6f0ce7d08a7298b',
+               inCondition: true,
+               workItemId: '5858c89bca4349fa0409ba8d',
+               pollerName: 'sdr',
+               reading: [Object] } ]
+         * expected event format:
+           [{ type: 'polleralert',
+              action: 'sdr.updated',
+              typeId: '5858c89bca4349fa0409ba8d',
+              nodeId: '5858c7f7f6f0ce7d08a7298b',
+              severity: 'information',
+              data: {
+                 { user: 'admin',
+                   host: '192.168.188.91',
+                   inCondition: true,
+                   reading: [Object] }
+              }} ]
+         */
+        assert.array(data, 'data');
+
+        return _.transform(data, function(result, item){
+            var tmp = {};
+            tmp.type = 'polleralert';
+            tmp.action = 'sdr.updated';
+            tmp.typeId = item.workItemId;
+            tmp.nodeId = item.node;
+            tmp.severity = "information";
+
+            tmp.data = _.omit(item, ['node', 'workItemId', 'pollerName']);
+            result.push(tmp);
+        });
+    };
+
     IpmiSdrPollerAlertJob.prototype._determineAlert = function _determineAlert(data) {
+        var self = this;
         return waterline.workitems.needByIdentifier(data.workItemId)
         .then(function (workitem) {
             var conf = workitem.config;
@@ -160,7 +199,7 @@ function ipmiSdrPollerAlertJobFactory(
             return [alerts, waterline.workitems.update({ id: data.workItemId }, { config: conf })];
         })
         .spread(function (alerts) {
-            return _.isEmpty(alerts) ? undefined : alerts;
+            return _.isEmpty(alerts) ? undefined : [alerts, self._formatSdrAlert(alerts)];
         })
         .catch(function (err) {
             logger.error(err.message, { error: err, data: data });

lib/jobs/ipmi-sel-alert-job.js

@@ -46,7 +46,58 @@ function ipmiSelPollerAlertJobFactory(
     }
     util.inherits(IpmiSelPollerAlertJob, PollerAlertJob);
 
+    IpmiSelPollerAlertJob.prototype._formatSelAlert = function _formatSelAlert(data) {
+        /*
+         * data format:
+           { alerts: [ { data: [Object], matches: [Object], action: 'critical' } ],
+             user: 'admin',
+             host: '192.168.188.91',
+             node: '5858c7f7f6f0ce7d08a7298b',
+             lastPreviouslyReadSelEntry: '0000',
+             lastSelDeleteTimeLastRun: '2017-01-10T01:28:13.000Z',
+             workItemId: '5858c89bca4349fa0409ba8c',
+             pollerName: 'sel' }
+         * expected event format:
+           [{ type: 'polleralert',
+              action: 'sel.updated',
+              typeId: '5858c89bca4349fa0409ba8c',
+              nodeId: '5858c7f7f6f0ce7d08a7298b',
+              severity: 'critical',
+              data: {
+                 { user: 'admin',
+                   host: '192.168.188.91',
+                   alert: { reading: [Object], matches: [Object] }
+                 }}} ]
+         */
+        assert.array(data.alerts, 'alerts');
+
+        var template = {
+            type: 'polleralert',
+            action: 'sel.updated',
+            typeId: data.workItemId,
+            nodeId: data.node,
+            severity: '',
+            data: {
+                user: data.user,
+                host: data.host,
+                alert: {}
+            }
+        };
+
+        return _.transform(data.alerts, function(result, item){
+            var tmp = _.cloneDeep(template);
+
+            tmp.data.alert.matches = _.cloneDeep(item.matches);
+            tmp.data.alert.reading = _.cloneDeep(item.data);
+            tmp.severity = item.action;
+
+            result.push(tmp);
+        });
+    };
+
+
     IpmiSelPollerAlertJob.prototype._determineAlert = function _determineAlert(data) {
+        var self = this;
         var action = "";
         // Code to handle null data
 
@@ -108,7 +159,7 @@ function ipmiSelPollerAlertJobFactory(
                 }
             }));
             if (!_.isEmpty(alertData.alerts)) {
-                return alertData;
+                return [alertData, self._formatSelAlert(alertData)];
             }
         });
     };

lib/jobs/poller-alert-job.js

@@ -10,9 +10,10 @@ di.annotate(pollerAlertJobFactory, new di.Inject(
     'Job.Base',
     'Logger',
     'Util',
-    'Assert'
+    'Assert',
+    'Promise'
 ));
-function pollerAlertJobFactory(BaseJob, Logger, util, assert) {
+function pollerAlertJobFactory(BaseJob, Logger, util, assert, Promise) {
     /**
      *
      * @param {Object} logger
@@ -50,9 +51,20 @@ function pollerAlertJobFactory(BaseJob, Logger, util, assert) {
         var self = this;
         self.subscriptionArgs.push(function(data) {
             return self._determineAlert(data)
-            .then(function(alertData) {
-                if (alertData) {
-                    return self._publishPollerAlert(self.routingKey, data.pollerName, alertData);
+            .then(function(alert) {
+                if (alert) {
+                    return Promise.all([
+                        self._publishPollerAlertLegacy(self.routingKey,
+                                                       data.pollerName,
+                                                       alert[0]),
+
+                        (function(alertData) {
+                            assert.array(alertData);
+                            return Promise.map(alertData, function(item) {
+                                return self._publishPollerAlert(item);
+                            });
+                        })(alert[1])
+                    ]);
                 }
             })
             .catch(function(error) {