Ssh obm service

data/views/ibms.2.0.json

@@ -0,0 +1,8 @@
+{
+  "id" : "<%=id%>",
+  <% if (node !== null) { %>
+  "node": "<%=basepath%>/nodes/<%=node%>",
+  <% } %>
+  "service": "<%= service %>",
+  "config": <%- JSON.stringify(config) %>
+}

data/views/node.2.0.json

@@ -50,5 +50,19 @@
     <% } %>
     <% } %>
     "type": "<%=type%>",
-    "workflows": "<%=basepath %>/nodes/<%=id%>/workflows" 
+    "workflows": "<%=basepath %>/nodes/<%=id%>/workflows",
+    <% if (ibms === null) { %>
+    "ibms": null,
+    <% } else { %>
+    "ibms":[
+    <% ibms.forEach(function (value, i, arr){ %>
+    {
+        "service": "<%=value.service%>",
+        "ref":"<%=basepath %>/ibms/<%=value.id%>"
+    }
+    <%= ( arr.length > 0 && i < arr.length-1 ) ? ',': '' %>
+    <% }); %>
+    ]
+    <% } %>
+
 }

lib/api/1.1/northbound/nodes.js

@@ -19,7 +19,8 @@ di.annotate(nodesRouterFactory, new di.Inject(
         'Logger',
         'Promise',
         '_',
-        'Assert'
+        'Assert',
+        'Errors'
     )
 );
 
@@ -34,28 +35,41 @@ function nodesRouterFactory (
     Logger,
     Promise,
     _,
-    assert
+    assert,
+    Errors
 ) {
     var router = express.Router();
 
     /**
-     * Renders obmSettings property into a node.
+     * Renders obmSettings and sshSettings properties into a node.
      *
      * @param {object} node - node model instance
      * @return {object} Promise that fulfills to the rendered node
      */
-    function _renderNodeObmSettings(node) {
+    function _renderNodeMgmtSettings(node) {
         // This function exists to allow backward compatibility of the 1.1 API
-        // with 2.0 API OBM resources.
+        // with 2.0 API OBM and SSH resources.
         assert.object(node, 'node should be a node model instance.');
         assert.ok(!node.obmSettings, 'node should not have obmSettings property');
 
-        node = _.omit(node.toJSON(), 'obms');
-        return Promise.map(waterline.obms.find({node: node.id}), function(obm) {
-           return _.pick(obm.toJSON(), 'service', 'config');
-        })
-        .then(function(obms) {
+        node = _.omit(node.toJSON(), ['obms', 'ibms']);
+
+        var obms = Promise.map(waterline.obms.find({node: node.id}), function(obm) {
+            return _.pick(obm.toJSON(), 'service', 'config');
+        });
+        var sshSettings = waterline.ibms.findByNode(node.id, 'ssh-ibm-service');
+        return Promise.all([obms, sshSettings])
+        .spread(function(obms, sshSettings) {
             node.obmSettings = obms;
+            if (sshSettings) {
+                node.sshSettings = {
+                    host: sshSettings.config.host,
+                    user: sshSettings.config.user,
+                    password: 'REDACTED'
+                };
+            } else {
+                delete node.sshSettings;
+            }
             return node;
         });
     }
@@ -73,7 +87,7 @@ function nodesRouterFactory (
         return nodeApiService.getAllNodes(req.query)
         .then(function (nodes){
             return Promise.map(nodes, function(node) {
-                return _renderNodeObmSettings(node);
+                return _renderNodeMgmtSettings(node);
             });
         }); 
     }));
@@ -140,7 +154,7 @@ function nodesRouterFactory (
     router.get('/nodes/:identifier', rest(function (req) {
         return nodeApiService.getNodeById(req.params.identifier)
         .then(function (node){
-            return _renderNodeObmSettings(node);
+            return _renderNodeMgmtSettings(node);
         });
     }));
 
@@ -184,7 +198,7 @@ function nodesRouterFactory (
         })
         .then(function() {
             // lastly render obmSettings into the node.
-            return _renderNodeObmSettings(node);
+            return _renderNodeMgmtSettings(node);
         });
     }));
 
@@ -233,7 +247,7 @@ function nodesRouterFactory (
     router.get('/nodes/:identifier/obm', rest(function (req) {
         return nodeApiService.getNodeObmById(req.params.identifier)
         .then(function (node){
-            return _renderNodeObmSettings(node)
+            return _renderNodeMgmtSettings(node)
             .then(function (retNode){
                 return retNode.obmSettings;
             });
@@ -284,7 +298,7 @@ function nodesRouterFactory (
             });
         })
         .then(function() {
-            return _renderNodeObmSettings(node);
+            return _renderNodeMgmtSettings(node);
         });
     }));
 
@@ -328,10 +342,13 @@ function nodesRouterFactory (
      */
 
     router.get('/nodes/:identifier/ssh', rest(function (req) {
-        return nodeApiService.getNodeSshById(req.params.identifier);
-    }, {
-        serializer: 'Serializables.V1.Ssh',
-        isObject: true
+        return nodeApiService.getNodeById(req.params.identifier)
+        .then(function(node) {
+            return _renderNodeMgmtSettings(node)
+            .then(function (retNode){
+                return retNode.sshSettings;
+            });
+        });
     }));
 
 
@@ -353,14 +370,32 @@ function nodesRouterFactory (
      */
 
     router.post('/nodes/:identifier/ssh', rest(function (req) {
-        return nodeApiService.postNodeSshById(req.params.identifier, req.body);
+        var node;
+        var newBody;
+
+        return Promise.try(function() {
+            if (req.body.host && req.body.user && req.body.password) {
+                return waterline.nodes.needByIdentifier(req.params.identifier);
+            } else {
+                throw new Errors.BadRequestError('Invalid SSH body');
+            }
+        })
+        .then(function(queryNode) {
+            node = queryNode;
+            newBody = {
+                nodeId: req.params.identifier,
+                service: 'ssh-ibm-service',
+                config: req.body
+            };
+            return waterline.ibms.upsertByNode(req.params.identifier, newBody);
+        })
+        .then(function() {
+            return _renderNodeMgmtSettings(node);
+        });
     }, {
-        deserializer: 'Serializables.V1.Ssh',
-        serializer: 'Serializables.V1.Node',
         renderOptions: { success: 201 }
     }));
 
-
     /**
      * @api {get} /api/1.1/nodes/:identifier/catalogs GET /:id/catalogs
      * @apiVersion 1.1.0

lib/api/2.0/ibms.js

@@ -0,0 +1,118 @@
+// Copyright 2016, EMC, Inc.
+
+'use strict';
+
+var injector = require('../../../index.js').injector;
+var controller = injector.get('Http.Services.Swagger').controller;
+var schemaApiService = injector.get('Http.Api.Services.Schema');
+var nameSpace = '/api/2.0/ibms/definitions/';
+var waterline = injector.get('Services.Waterline');
+var eventsProtocol = injector.get('Protocol.Events');
+var Errors = injector.get('Errors');
+var _ = injector.get('_'); // jshint ignore:line
+
+
+// GET /api/2.0/ibms
+var ibmsGet = controller(function(req) {
+    return waterline.ibms.find(req.query);
+});
+
+// PUT /api/2.0/ibms
+var ibmsPut = controller({success: 201}, function(req) {
+    var nodeId = req.swagger.params.body.value.nodeId;
+    delete req.swagger.params.body.value.nodeId;
+    return waterline.ibms.upsertByNode(nodeId, req.swagger.params.body.value);
+});
+
+// GET /api/2.0/ibms/identifier
+var ibmsGetById = controller(function(req) {
+    return waterline.ibms.needByIdentifier(req.swagger.params.identifier.value);
+});
+
+// PATCH /api/2.0/ibms/identifier
+var ibmsPatchById = controller( function(req) {
+    var ibmId = req.swagger.params.identifier.value;
+    var values = req.swagger.params.body.value;
+    return waterline.ibms.needByIdentifier(ibmId)
+        .then(function(oldIbm) {
+            /* Get nodes that need to publish events */
+            if (oldIbm.node && !values.nodeId) {
+                return Promise.all([waterline.nodes.getNodeById(oldIbm.node)]);
+            } else if (!oldIbm.node && values.nodeId) {
+                return Promise.all([waterline.nodes.getNodeById(values.node)]);
+            } else if (oldIbm.node && values.nodeId && oldIbm.node === values.nodeId) {
+                return Promise.all([waterline.nodes.getNodeById(oldIbm.node)]);
+            } else if (oldIbm.node && values.nodeId && oldIbm.node !== values.nodeId) {
+                return Promise.all([waterline.nodes.getNodeById(oldIbm.node),
+                        waterline.nodes.getNodeById(values.nodeId)]);
+            }
+        })
+        .then(function(oldNodes) {
+            return waterline.ibms.updateByIdentifier(ibmId, values)
+            .tap(function() {
+                /* Publish events of nodes got beofre update */
+                _.forEach(oldNodes, function(oldNode) {
+                    if (oldNode) {
+                        /* asynchronous, don't wait promise return for performance*/
+                        return waterline.nodes.getNodeById(oldNode.id)
+                        .then(function(newNode) {
+                            return eventsProtocol.publishNodeAttrEvent(oldNode, newNode, 'ibms');
+                        })
+                        .catch(function (error) {
+                            throw new Errors.BaseError('Error Occured', error.message);
+                        });
+                    }
+                });
+            });
+        });
+});
+
+// DELETE /api/2.0/ibms/identifier
+var ibmsDeleteById = controller({success: 204}, function(req) {
+    var ibmId = req.swagger.params.identifier.value;
+    return waterline.ibms.needByIdentifier(ibmId)
+        .then(function (ibm) {
+            return waterline.nodes.getNodeById(ibm.node);
+        })
+        .then(function (oldNode) {
+            return waterline.ibms.destroyByIdentifier(ibmId)
+            .tap(function () {
+                if (oldNode) {
+                    /* asynchronous, don't wait promise return for performance*/
+                    waterline.nodes.getNodeById(oldNode.id)
+                    .then(function (newNode) {
+                        return eventsProtocol.publishNodeAttrEvent(oldNode, newNode, 'ibms');
+                    })
+                    .catch(function (error) {
+                        throw new Errors.BaseError('Error Occured', error.message);
+                    });
+                }
+            });
+        });
+
+});
+
+// GET /ibms/definitions
+var ibmsDefinitionsGetAll = controller(function() {
+    return schemaApiService.getNamespace(nameSpace);
+});
+
+// GET /ibms/definitions/{name}
+var ibmsDefinitionsGetByName = controller(function(req) {
+    var schemaUid = nameSpace + req.swagger.params.name.value;
+    var schema = schemaApiService.getSchema(schemaUid);
+    if (schema) {
+        return schema;
+    }
+    throw new Errors.NotFoundError(schemaUid + ' Not Found');
+});
+
+module.exports = {
+    ibmsGet: ibmsGet,
+    ibmsPut: ibmsPut,
+    ibmsGetById: ibmsGetById,
+    ibmsPatchById: ibmsPatchById,
+    ibmsDeleteById: ibmsDeleteById,     
+    ibmsDefinitionsGetAll: ibmsDefinitionsGetAll,
+    ibmsDefinitionsGetByName: ibmsDefinitionsGetByName
+};

lib/fittings/rackhd_validator.js

@@ -12,15 +12,24 @@ module.exports = function create(fittingDef) {
             var schemaNameKey = fittingDef.schemaNameKey;
             var operation = context.request.swagger.operation;
             var schemaName = operation[schemaNameKey];
+            var suffix = null;
+            var service = null;
             if (schemaName === 'obm') {
-                var suffix = '.json#/definitions/Obm';
-                var service = context.request.body.service;
+                suffix = '.json#/definitions/Obm';
+                service = context.request.body.service;
                 if (service) {
                     schemaName = service + suffix;
                 } else {
                     schemaName = 'noop-obm-service' + suffix;
                 }
             }
+            else if (schemaName === 'ibm') {
+                suffix = '.json#/definitions/Ibm';
+                service = context.request.body.service;
+                if (service) {
+                    schemaName = service + suffix;
+                }
+            }
             validate(schemaName, context.request.body, next);
         }
     };