skyquake/plugins/accounts/api/accounts.js

   1 /*
   2  *
   3  *   Copyright 2016 RIFT.IO Inc
   4  *
   5  *   Licensed under the Apache License, Version 2.0 (the "License");
   6  *   you may not use this file except in compliance with the License.
   7  *   You may obtain a copy of the License at
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *   Unless required by applicable law or agreed to in writing, software
  12  *   distributed under the License is distributed on an "AS IS" BASIS,
  13  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *   See the License for the specific language governing permissions and
  15  *   limitations under the License.
  16  *
  17  */
  18
  19 var request = require('request');
  20 var Promise = require('bluebird');
  21 var rp = require('request-promise');
  22 var utils = require('../../../framework/core/api_utils/utils.js');
  23 var constants = require('../../../framework/core/api_utils/constants.js');
  24 var _ = require('underscore');
  25 var Cloud = require('./cloud_account/cloudAccount')
  26 var Sdn = require('./sdn_account/sdnAccount')
  27 var ConfigAgent = require('./config_agent/configAgent')
  28 var Accounts = {};
  29 var nameSpace = {
  30     cloud: 'cloud',
  31     sdn: 'sdn',
  32     'config-agent': 'config-agent',
  33     'resource-orchestrator': 'ro-account'
  34 };
  35 var APIVersion = '/v2'
  36 Accounts.get = function(req) {
  37     return new Promise(function(resolve, reject) {
  38         if (req.params.type || req.params.name) {
  39             getAccount(req)
  40                 .then(function(data) {
  41                     resolve({
  42                         statusCode: 200,
  43                         data: Object.assign(data, {
  44                             type: req.params.type
  45                         })
  46                     });
  47                 }, function(reason) {
  48                     reject(reason);
  49                 })
  50         } else {
  51             getAll(req, resolve, reject);
  52         }
  53     });
  54
  55     function getAll(req, resolve, reject) {
  56         Promise.all([
  57             Cloud.get(req),
  58             Sdn.get(req),
  59             ConfigAgent.get(req),
  60             getResourceOrchestrator(req)
  61         ]).then(function(result) {
  62             var ReturnData = {
  63                 cloud: result[0],
  64                 sdn: result[1],
  65                 'config-agent': result[2],
  66                 'resource-orchestrator': result[3]
  67             };
  68             ReturnData.cloud.type = 'cloud';
  69             ReturnData.sdn.type = 'sdn';
  70             ReturnData['config-agent'].type = 'config';
  71             resolve({
  72                 statusCode: 200,
  73                 data: ReturnData
  74             });
  75         }, function(reason) {
  76             reject(reason);
  77         })
  78     }
  79 }
  80
  81 Accounts.update = updateAccount;
  82 Accounts.create = updateAccount;
  83 Accounts.delete = deleteAccount;
  84 Accounts.refreshAccountConnectionStatus = refreshAccountConnectionStatus
  85
  86 function getAccount(req) {
  87     return new Promise(function(resolve, reject) {
  88         var self = this;
  89         var api_server = req.query["api_server"];
  90         var id = req.params.id || req.params.name;
  91         var requestHeaders = {};
  92         var type = nameSpace[req.params.type];
  93         var url = utils.confdPort(api_server) + '/api/operational/' + type + '/account';
  94         if (id) {
  95             url += '/' + encodeURIComponent(id);
  96         }
  97
  98         _.extend(
  99             requestHeaders,
 100             id ? constants.HTTP_HEADERS.accept.data : constants.HTTP_HEADERS.accept.collection, {
 101                 'Authorization': req.session && req.session.authorization
 102             }
 103         );
 104
 105         request({
 106                 url: utils.projectContextUrl(req, url + '?deep'),
 107                 type: 'GET',
 108                 headers: requestHeaders,
 109                 forever: constants.FOREVER_ON,
 110                 rejectUnauthorized: false
 111             },
 112             function(error, response, body) {
 113                 var data;
 114                 var objKey = 'rw-' + type + ':account';
 115                 //SDN model doesn't follow convention
 116                 if (utils.validateResponse(type.toUpperCase() + '.get', error, response, body, resolve, reject)) {
 117                     try {
 118                         data = JSON.parse(response.body);
 119                         if (!id) {
 120                             data = data.collection;
 121                         }
 122                         data = data[objKey]
 123                     } catch (e) {
 124                         console.log('Problem with "' + type.toUpperCase() + '.get"', e);
 125                         var err = {};
 126                         err.statusCode = 500;
 127                         err.errorMessage = {
 128                             error: 'Problem with "' + type.toUpperCase() + '.get": ' + e
 129                         }
 130                         return reject(err);
 131                     }
 132                     return resolve({
 133                         statusCode: response.statusCode,
 134                         data: data
 135                     });
 136                 };
 137             });
 138     });
 139 }
 140
 141 function updateAccount(req) {
 142     var self = this;
 143     var id = req.params.id || req.params.name;
 144     var api_server = req.query["api_server"];
 145     var type = nameSpace[req.params.type];
 146     var data = req.body;
 147     var requestHeaders = {};
 148     var createData = {};
 149     var url = utils.confdPort(api_server) + '/api/config/' + type //+ '/account';
 150     var method = 'POST'
 151     if (!id) {
 152         createData = {}
 153         if (type == 'ro-account') {
 154             createData['rw-ro-account:account'] = Array.isArray(data) ? data : [data]
 155         } else {
 156             createData['account'] = Array.isArray(data) ? data : [data]
 157         }
 158         console.log('Creating ' + type + ' account: ', createData);
 159     } else {
 160         method = 'PUT';
 161         url += '/account/' + encodeURIComponent(id);
 162         createData['rw-' + type + ':account'] = Array.isArray(data) ? data : [data];
 163     }
 164
 165
 166
 167     return new Promise(function(resolve, reject) {
 168         _.extend(requestHeaders,
 169             constants.HTTP_HEADERS.accept.data,
 170             constants.HTTP_HEADERS.content_type.data, {
 171                 'Authorization': req.session && req.session.authorization
 172             });
 173         request({
 174             url: utils.projectContextUrl(req, url),
 175             method: method,
 176             headers: requestHeaders,
 177             forever: constants.FOREVER_ON,
 178             rejectUnauthorized: false,
 179             json: createData,
 180         }, function(error, response, body) {
 181             if (utils.validateResponse(type.toUpperCase() + '.' + method, error, response, body, resolve, reject)) {
 182                 return resolve({
 183                     statusCode: response.statusCode,
 184                     data: JSON.stringify(response.body)
 185                 });
 186             };
 187         });
 188     })
 189 }
 190
 191 function deleteAccount(req) {
 192     var self = this;
 193     var id = req.params.id || req.params.name;
 194     var api_server = req.query["api_server"];
 195     var type = nameSpace[req.params.type];
 196     var data = req.body;
 197     var requestHeaders = {};
 198     var createData = {};
 199     var url = utils.confdPort(api_server) + '/api/config/' + type;
 200     url += '/account/' + encodeURIComponent(id);
 201     return new Promise(function(resolve, reject) {
 202         _.extend(requestHeaders,
 203             constants.HTTP_HEADERS.accept.data,
 204             constants.HTTP_HEADERS.content_type.data, {
 205                 'Authorization': req.session && req.session.authorization
 206             });
 207         request({
 208             url: utils.projectContextUrl(req, url),
 209             method: 'DELETE',
 210             headers: requestHeaders,
 211             forever: constants.FOREVER_ON,
 212             rejectUnauthorized: false,
 213         }, function(error, response, body) {
 214             if (utils.validateResponse(type.toUpperCase() + '.DELETE', error, response, body, resolve, reject)) {
 215                 return resolve({
 216                     statusCode: response.statusCode,
 217                     data: JSON.stringify(response.body)
 218                 });
 219             };
 220         });
 221     })
 222 }
 223
 224 function refreshAccountConnectionStatus(req) {
 225     var api_server = req.query['api_server'];
 226     var Name = req.params.name;
 227     var Type = req.params.type;
 228     var jsonData = {
 229         input: {}
 230     };
 231     var rpcInfo = {
 232         sdn: {
 233             label: 'sdn-account',
 234             rpc: 'update-sdn-status'
 235         },
 236         'config': {
 237             label: 'cfg-agent-account',
 238             rpc: 'update-cfg-agent-status'
 239         },
 240         cloud: {
 241             label: 'cloud-account',
 242             rpc: 'update-cloud-status'
 243         },
 244         'resource-orchestrator': {
 245             label: 'ro-account',
 246             rpc: 'update-ro-account-status'
 247         }
 248     }
 249     jsonData.input[rpcInfo[Type].label] = Name;
 250     var headers = _.extend({},
 251         constants.HTTP_HEADERS.accept.data,
 252         constants.HTTP_HEADERS.content_type.data, {
 253             'Authorization': req.session && req.session.authorization
 254         }
 255     );
 256     var uri = utils.projectContextUrl(req, utils.confdPort(api_server) + '/api/operations/' + rpcInfo[Type].rpc);
 257
 258     jsonData['input'] = utils.addProjectContextToRPCPayload(req, uri, jsonData['input']);
 259
 260     return new Promise(function(resolve, reject) {
 261
 262         request({
 263             uri: uri,
 264             method: 'POST',
 265             headers: headers,
 266             forever: constants.FOREVER_ON,
 267             rejectUnauthorized: false,
 268             json: jsonData
 269         }, function(error, response, body) {
 270             if (utils.validateResponse('RPC.refreshAccountConnectionStatus', error, response, body, resolve, reject)) {
 271
 272                 resolve({
 273                     statusCode: response.statusCode,
 274                     data: body
 275                 });
 276             }
 277         });
 278     }).catch(function(error) {
 279         console.log('Error refreshing account info');
 280     });
 281 };
 282
 283 function getResourceOrchestrator(req, id) {
 284     var self = this;
 285     var api_server = req.query["api_server"];
 286     var accountID = req.params.id || req.params.name;
 287
 288     return new Promise(function(resolve, reject) {
 289         var requestHeaders = {};
 290         _.extend(requestHeaders,
 291             constants.HTTP_HEADERS.accept.collection, {
 292                 'Authorization': req.session && req.session.authorization
 293             }
 294         );
 295         var urlOp =  utils.projectContextUrl(req, utils.confdPort(api_server) + APIVersion + '/api/operational/ro-account/account');
 296         var urlConfig =  utils.projectContextUrl(req, utils.confdPort(api_server) + APIVersion + '/api/operational/ro-account-state/account');
 297         if(accountID) {
 298             urlOp = url + '/' + encodeURIComponent(accountID);
 299             urlConfig = url + '/' + encodeURIComponent(accountID);
 300         }
 301         var allRequests = [];
 302         var roOpData = new Promise(function(resolve, reject) {
 303             request({
 304                 url: urlOp,
 305                 type: 'GET',
 306                 headers: requestHeaders,
 307                 forever: constants.FOREVER_ON,
 308                 rejectUnauthorized: false
 309                 },
 310                 function(error, response, body) {
 311                     var data;
 312                     if (utils.validateResponse('RoAccount.get', error, response, body, resolve, reject)) {
 313                         try {
 314                             data = JSON.parse(response.body).collection['rw-ro-account:account']
 315                         } catch (e) {
 316                             console.log('Problem with "RoAccount.get"', e);
 317                             var err = {};
 318                             err.statusCode = 500;
 319                             err.errorMessage = {
 320                                 error: 'Problem with "RoAccount.get": ' + e // + e.toString()
 321                             }
 322                             return reject(err);
 323                         }
 324                         return resolve({
 325                             statusCode: response.statusCode,
 326                             data: data
 327                         });
 328                     };
 329                 }
 330             );
 331         });
 332         var roConfigData = new Promise(function(resolve, reject){
 333             request({
 334                 url: urlConfig,
 335                 type: 'GET',
 336                 headers: requestHeaders,
 337                 forever: constants.FOREVER_ON,
 338                 rejectUnauthorized: false
 339                 },
 340                 function(error, response, body) {
 341                     var data;
 342                     if (utils.validateResponse('RoAccount.get', error, response, body, resolve, reject)) {
 343                         try {
 344                             data = JSON.parse(response.body).collection['rw-ro-account:account']
 345                         } catch (e) {
 346                             console.log('Problem with "RoAccount.get"', e);
 347                             var err = {};
 348                             err.statusCode = 500;
 349                             err.errorMessage = {
 350                                 error: 'Problem with "RoAccount.get": ' + e // + e.toString()
 351                             }
 352                             return reject(err);
 353                         }
 354                         return resolve({
 355                             statusCode: response.statusCode,
 356                             data: data
 357                         });
 358                     };
 359                 }
 360             );
 361         });
 362
 363         allRequests.push(roOpData);
 364         allRequests.push(roConfigData);
 365         Promise.all(allRequests).then(function(data) {
 366             var state = data[1].data;
 367             var op = data[0].data;
 368             var result = [];
 369             var dict = {};
 370             if (!accountID) {
 371                 state.map && state.map(function(s){
 372                     if(s.name != "rift") {
 373                         dict[s.name] = s;
 374                     }
 375                 });
 376                 op.map && op.map(function(o) {
 377                     if(o.name != "rift") {
 378                         dict[o.name] = _.extend(dict[o.name], o);
 379                     }
 380                 });
 381                 Object.keys(dict).map(function(d) {
 382                     result.push(dict[d]);
 383                 })
 384             } else {
 385                 result = _.extend(op, state);
 386             }
 387             resolve({
 388                 statusCode: 200,
 389                 data: result
 390             })
 391         })
 392
 393     })
 394 }
 395
 396 module.exports = Accounts;