skyquake/plugins/accounts/api/cloud_account/cloudAccount.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 // Cloud-Account APIs
  19
  20
  21 var Cloud = {};
  22 var request = require('request');
  23 var Promise = require('promise');
  24 var _ = require('underscore');
  25 var utils = require('../../../../framework/core/api_utils/utils.js');
  26 var constants = require('../../../../framework/core/api_utils/constants.js');
  27 var APIVersion = '/v1';
  28
  29
  30 Cloud.get = function(req) {
  31   var self = this;
  32
  33   var api_server = req.query["api_server"];
  34   var id = req.params.id || req.params.name;
  35
  36   if (!id) {
  37     // Get all cloud accounts
  38     return new Promise(function(resolve, reject) {
  39
  40       var requestHeaders = {};
  41       _.extend(requestHeaders,
  42         constants.HTTP_HEADERS.accept.collection, {
  43           'Authorization': req.session && req.session.authorization
  44         });
  45
  46       request({
  47           url: utils.projectContextUrl(req, utils.confdPort(api_server) + APIVersion + '/api/operational/cloud/account'),
  48           type: 'GET',
  49           headers: requestHeaders,
  50           forever: constants.FOREVER_ON,
  51           rejectUnauthorized: false
  52         },
  53         function(error, response, body) {
  54           var data;
  55           if (utils.validateResponse('Cloud.get', error, response, body, resolve, reject)) {
  56             try {
  57               data = JSON.parse(response.body).collection['rw-cloud:account']
  58             } catch (e) {
  59               console.log('Problem with "Cloud.get"', e);
  60               var err = {};
  61               err.statusCode = 500;
  62               err.errorMessage = {
  63                 error: 'Problem with "Cloud.get": ' + e // + e.toString()
  64               }
  65               return reject(err);
  66             }
  67             return resolve({
  68               statusCode: response.statusCode,
  69               data: self.poolAggregate(data)
  70             });
  71           };
  72         });
  73     });
  74   } else {
  75     //Get a specific cloud account
  76     return new Promise(function(resolve, reject) {
  77       var requestHeaders = {};
  78       _.extend(requestHeaders,
  79         constants.HTTP_HEADERS.accept.data, {
  80           'Authorization': req.session && req.session.authorization
  81         });
  82
  83       request({
  84           url: utils.projectContextUrl(req, utils.confdPort(api_server) + APIVersion + '/api/operational/cloud/account/' + id),
  85           type: 'GET',
  86           headers: requestHeaders,
  87           forever: constants.FOREVER_ON,
  88           rejectUnauthorized: false
  89         },
  90         function(error, response, body) {
  91           var data;
  92           if (utils.validateResponse('Cloud.get', error, response, body, resolve, reject)) {
  93             try {
  94               data = JSON.parse(response.body)['rw-cloud:account'];
  95             } catch (e) {
  96               console.log('Problem with "Cloud.get"', e);
  97               var err = {};
  98               err.statusCode = 500;
  99               err.errorMessage = {
 100                 error: 'Problem with "Cloud.get": ' + e.toString()
 101               }
 102               return reject(err);
 103             }
 104
 105             return resolve({
 106               statusCode: response.statusCode,
 107               data: data
 108             });
 109           }
 110         });
 111     });
 112   }
 113 };
 114
 115 Cloud.create = function(req) {
 116
 117   var api_server = req.query["api_server"];
 118   var data = req.body;
 119
 120   return new Promise(function(resolve, reject) {
 121     var jsonData = {
 122       "account": Array.isArray(data) ? data : [data]
 123     };
 124
 125     console.log('Creating with', JSON.stringify(jsonData));
 126
 127     var requestHeaders = {};
 128     _.extend(requestHeaders,
 129       constants.HTTP_HEADERS.accept.data,
 130       constants.HTTP_HEADERS.content_type.data, {
 131         'Authorization': req.session && req.session.authorization
 132       });
 133
 134     request({
 135       url: utils.projectContextUrl(req, utils.confdPort(api_server) + APIVersion + '/api/config/cloud'),
 136       method: 'POST',
 137       headers: requestHeaders,
 138       forever: constants.FOREVER_ON,
 139       rejectUnauthorized: false,
 140       json: jsonData,
 141     }, function(error, response, body) {
 142       console.log('Handling Cloud Create response')
 143       if (utils.validateResponse('Cloud.create', error, response, body, resolve, reject)) {
 144         return resolve({
 145           statusCode: response.statusCode,
 146           data: JSON.stringify(response.body)
 147         });
 148       };
 149     });
 150   });
 151 };
 152
 153 Cloud.update = function(req) {
 154
 155   var api_server = req.query["api_server"];
 156   var id = req.params.id || req.params.name;
 157   var data = req.body;
 158
 159   return new Promise(function(resolve, reject) {
 160     var jsonData = {
 161       "rw-cloud:account": data
 162     };
 163
 164     console.log('Updating ', id, ' with', JSON.stringify(jsonData));
 165
 166     var requestHeaders = {};
 167     _.extend(requestHeaders,
 168       constants.HTTP_HEADERS.accept.data,
 169       constants.HTTP_HEADERS.content_type.data, {
 170         'Authorization': req.session && req.session.authorization
 171       });
 172
 173     request({
 174       url: utils.projectContextUrl(req, utils.confdPort(api_server) + APIVersion + '/api/config/cloud/account/' + id),
 175       method: 'PUT',
 176       headers: requestHeaders,
 177       forever: constants.FOREVER_ON,
 178       rejectUnauthorized: false,
 179       json: jsonData,
 180     }, function(error, response, body) {
 181       if (utils.validateResponse('Cloud.update', 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 Cloud.delete = function(req) {
 192
 193   var api_server = req.query["api_server"];
 194   var id = req.params.id || req.params.name;
 195
 196   if (!id || !api_server) {
 197     return new Promise(function(resolve, reject) {
 198       console.log('Must specifiy api_server and id to delete cloud account');
 199       return reject({
 200         statusCode: 500,
 201         errorMessage: {
 202           error: 'Must specifiy api_server and id to delete cloud account'
 203         }
 204       });
 205     });
 206   };
 207
 208   return new Promise(function(resolve, reject) {
 209     var requestHeaders = {};
 210     _.extend(requestHeaders,
 211       constants.HTTP_HEADERS.accept.data, {
 212         'Authorization': req.session && req.session.authorization
 213       });
 214     request({
 215       url: utils.projectContextUrl(req, utils.confdPort(api_server) + APIVersion + '/api/config/cloud/account/' + id),
 216       method: 'DELETE',
 217       headers: requestHeaders,
 218       forever: constants.FOREVER_ON,
 219       rejectUnauthorized: false
 220     }, function(error, response, body) {
 221       if (utils.validateResponse('Cloud.delete', error, response, body, resolve, reject)) {
 222         return resolve({
 223           statusCode: response.statusCode,
 224           data: JSON.stringify(response.body)
 225         });
 226       };
 227     });
 228   });
 229 };
 230
 231 Cloud.getResources = function(req) {
 232
 233   var api_server = req.query["api_server"];
 234   var cloudAccount = req.query["cloud_account"];
 235
 236   return new Promise(function(resolve, reject) {
 237     var requestHeaders = {};
 238     _.extend(requestHeaders,
 239       constants.HTTP_HEADERS.accept.data, {
 240         'Authorization': req.session && req.session.authorization
 241       });
 242
 243     request({
 244         url: utils.projectContextUrl(req, utils.confdPort(api_server) + APIVersion + '/api/operational/cloud/account/' + cloudAccount + '/resources?deep'),
 245         type: 'GET',
 246         headers: requestHeaders,
 247         forever: constants.FOREVER_ON,
 248         rejectUnauthorized: false
 249       },
 250       function(error, response, body) {
 251         var data;
 252         if (utils.validateResponse('Cloud.getResources', error, response, body, resolve, reject)) {
 253           try {
 254             data = JSON.parse(response.body)['rw-cloud:resources']
 255           } catch (e) {
 256             console.log('Problem with "Cloud.getResources"', e);
 257
 258             var err = {};
 259             err.statusCode = 500;
 260             err.errorMessage = {
 261               error: 'Problem with "Cloud.getResources": ' + e.toString()
 262             }
 263
 264             return reject(err);
 265           }
 266
 267           return resolve(data);
 268         };
 269       });
 270   });
 271 };
 272
 273 Cloud.getPools = function(req) {
 274
 275   var api_server = req.query["api_server"];
 276   var cloudAccount = req.query["cloud-account"];
 277
 278   return new Promise(function(resolve, reject) {
 279
 280     var requestHeaders = {};
 281     _.extend(requestHeaders,
 282       constants.HTTP_HEADERS.accept.data, {
 283         'Authorization': req.session && req.session.authorization
 284       });
 285
 286     request({
 287         url: utils.projectContextUrl(req, utils.confdPort(api_server) + APIVersion + '/api/operational/cloud/account/' + cloudAccount + '/pools'),
 288         type: 'GET',
 289         headers: requestHeaders,
 290         forever: constants.FOREVER_ON,
 291         rejectUnauthorized: false
 292       },
 293       function(error, response, body) {
 294         var data;
 295         if (utils.validateResponse('Cloud.getPools', error, response, body, resolve, reject)) {
 296           try {
 297             data = JSON.parse(response.body)['rw-cloud:pools']
 298           } catch (e) {
 299             console.log('Problem with "Cloud.getPools"', e);
 300             var err = {};
 301             err.statusCode = 500;
 302             err.errorMessage = {
 303               error: 'Problem with "Cloud.getPools": ' + e.toString()
 304             }
 305
 306             return reject(err);
 307           }
 308
 309           return resolve({
 310             statusCode: response.statusCode,
 311             data: data
 312           });
 313         }
 314       });
 315   });
 316 }
 317
 318 Cloud.poolAggregate = function(cloudAccounts) {
 319   cloudAccounts.forEach(function(ca) {
 320     var oldPools = ca.pools;
 321     var newPools = [];
 322     for (type in oldPools) {
 323       oldPools[type].forEach(function(pool) {
 324         pool.type = type;
 325         newPools.push(pool);
 326       })
 327     }
 328     ca.pools = newPools;
 329   });
 330   return cloudAccounts;
 331 }
 332
 333
 334
 335 module.exports = Cloud;