skyquake/plugins/redundancy/api/redundancy.js

   1 var request = require('request');
   2 var Promise = require('bluebird');
   3 var rp = require('request-promise');
   4 var utils = require('../../../framework/core/api_utils/utils.js');
   5 var constants = require('../../../framework/core/api_utils/constants.js');
   6 var _ = require('underscore');
   7 var APIVersion = '/v2'
   8 var Redundancy = {};
   9
  10 Redundancy.get = function(req) {
  11     return new Promise(function(resolve, reject) {
  12         var self = this;
  13         var api_server = req.query["api_server"];
  14         var requestHeaders = {};
  15         var url = utils.confdPort(api_server) + '/api/operational/redundancy-config';
  16
  17         _.extend(
  18             requestHeaders,
  19             constants.HTTP_HEADERS.accept.data, {
  20                 'Authorization': req.session && req.session.authorization
  21             }
  22         );
  23
  24         request({
  25                 url: url + '?deep',
  26                 type: 'GET',
  27                 headers: requestHeaders,
  28                 forever: constants.FOREVER_ON,
  29                 rejectUnauthorized: false
  30             },
  31             function(error, response, body) {
  32                 var data;
  33                 var objKey = 'rw-redundancy:redundancy-config';
  34                 //SDN model doesn't follow convention
  35                 if (utils.validateResponse('Redundancy.get', error, response, body, resolve, reject)) {
  36                     try {
  37                         data = JSON.parse(response.body);
  38                         data = data[objKey]
  39                     } catch (e) {
  40                         console.log('Problem with "Redundancy.get"', e);
  41                         var err = {};
  42                         err.statusCode = 500;
  43                         err.errorMessage = {
  44                             error: 'Problem with "Redundancy.get": ' + e
  45                         }
  46                         return reject(err);
  47                     }
  48                     return resolve({
  49                         statusCode: response.statusCode,
  50                         data: data
  51                     });
  52                 };
  53             });
  54     });
  55 }
  56
  57
  58 Redundancy.getState = function(req) {
  59     return new Promise(function(resolve, reject) {
  60         var self = this;
  61         var api_server = req.query["api_server"];
  62         var requestHeaders = {};
  63         var url = utils.confdPort(api_server) + '/api/operational/redundancy-state';
  64         _.extend(
  65             requestHeaders,
  66             constants.HTTP_HEADERS.accept.data, {
  67                 'Authorization': req.session && req.session.authorization
  68             }
  69         );
  70         request({
  71                 url: url + '?deep',
  72                 type: 'GET',
  73                 headers: requestHeaders,
  74                 forever: constants.FOREVER_ON,
  75                 rejectUnauthorized: false
  76             },
  77             function(error, response, body) {
  78                 var data;
  79                 var objKey = 'rw-redundancy:redundancy-state';
  80                 //SDN model doesn't follow convention
  81                 if (utils.validateResponse('Redundancy.getState', error, response, body, resolve, reject)) {
  82                     try {
  83                         data = JSON.parse(response.body);
  84                         data = data[objKey]
  85                     } catch (e) {
  86                         console.log('Problem with "Redundancy.getState"', e);
  87                         var err = {};
  88                         err.statusCode = 500;
  89                         err.errorMessage = {
  90                             error: 'Problem with "Redundancy.getState": ' + e
  91                         }
  92                         return reject(err);
  93                     }
  94                     return resolve({
  95                         statusCode: response.statusCode,
  96                         data: data
  97                     });
  98                 };
  99             });
 100     });
 101 }
 102
 103 Redundancy.configUpdate = function(req) {
 104     var self = this;
 105     var id = req.params.id || req.params.name;
 106     var api_server = req.query["api_server"];
 107     var data = req.body;
 108     var requestHeaders = {};
 109     var createData = {};
 110     var updateTasks = [];
 111     var method = 'PUT';
 112     if(data.hasOwnProperty('revertive-preference')) {
 113         var revertivePreferenceUrl = utils.confdPort(api_server) + '/api/config/redundancy-config/revertive-preference';
 114         var revertuvePreferenceData = {
 115             'preferred-site-name': data['revertive-preference']['preferred-site-name']
 116         };
 117         var revertivePreferencePromise = new Promise(function(resolve, reject) {
 118             _.extend(requestHeaders,
 119                 constants.HTTP_HEADERS.accept.data,
 120                 constants.HTTP_HEADERS.content_type.data, {
 121                     'Authorization': req.session && req.session.authorization
 122                 });
 123             request({
 124                 url: revertivePreferenceUrl,
 125                 method: method,
 126                 headers: requestHeaders,
 127                 forever: constants.FOREVER_ON,
 128                 rejectUnauthorized: false,
 129                 json: revertuvePreferenceData,
 130             }, function(error, response, body) {
 131                 if (utils.validateResponse('revertivePreferencePromise.' + method, error, response, body, resolve, reject)) {
 132                     return resolve({
 133                         statusCode: response.statusCode,
 134                         data: JSON.stringify(response.body)
 135                     });
 136                 };
 137             });
 138         });
 139         updateTasks.push(revertivePreferencePromise);
 140     }
 141
 142     if(data.hasOwnProperty('geographic-failover-decision')) {
 143         var geoFailDecisionConfigUrl = utils.confdPort(api_server) + '/api/config/redundancy-config';
 144         var geoFailDecisionConfigData = {'geographic-failover-decision' : data['geographic-failover-decision']};
 145         var geoFailDecisionPromise = new Promise(function(resolve, reject) {
 146             _.extend(requestHeaders,
 147                 constants.HTTP_HEADERS.accept.data,
 148                 constants.HTTP_HEADERS.content_type.data, {
 149                     'Authorization': req.session && req.session.authorization
 150                 });
 151             request({
 152                 url: geoFailDecisionConfigUrl,
 153                 method: method,
 154                 headers: requestHeaders,
 155                 forever: constants.FOREVER_ON,
 156                 rejectUnauthorized: false,
 157                 json: geoFailDecisionConfigData,
 158             }, function(error, response, body) {
 159                 if (utils.validateResponse('geoFailDecisionPromise.' + method, error, response, body, resolve, reject)) {
 160                     return resolve({
 161                         statusCode: response.statusCode,
 162                         data: JSON.stringify(response.body)
 163                     });
 164                 };
 165             });
 166         });
 167         updateTasks.push(geoFailDecisionPromise);
 168     }
 169
 170     if(data.hasOwnProperty('user-credentials')) {
 171         var userCredentialsUrl = utils.confdPort(api_server) + '/api/config/redundancy-config';
 172         var userCredentialsData = {'user-credentials' : data['user-credentials']};
 173         var userCredentialsPromise = new Promise(function(resolve, reject) {
 174             _.extend(requestHeaders,
 175                 constants.HTTP_HEADERS.accept.data,
 176                 constants.HTTP_HEADERS.content_type.data, {
 177                     'Authorization': req.session && req.session.authorization
 178                 });
 179             request({
 180                 url: userCredentialsUrl,
 181                 method: method,
 182                 headers: requestHeaders,
 183                 forever: constants.FOREVER_ON,
 184                 rejectUnauthorized: false,
 185                 json: userCredentialsData,
 186             }, function(error, response, body) {
 187                 if (utils.validateResponse('userCredentials.' + method, error, response, body, resolve, reject)) {
 188                     return resolve({
 189                         statusCode: response.statusCode,
 190                         data: JSON.stringify(response.body)
 191                     });
 192                 };
 193             });
 194         });
 195         updateTasks.push(userCredentialsPromise);
 196     }
 197
 198     if(data.hasOwnProperty('polling-config')) {
 199         var pollingConfigUrl = utils.confdPort(api_server) + '/api/config/redundancy-config/polling-config';
 200         var pollingConfigData = data['polling-config'];
 201         var revertivePreferencePromise = 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: pollingConfigUrl,
 209                 method: method,
 210                 headers: requestHeaders,
 211                 forever: constants.FOREVER_ON,
 212                 rejectUnauthorized: false,
 213                 json: pollingConfigData,
 214             }, function(error, response, body) {
 215                 if (utils.validateResponse('pollingConfigPromise.' + method, error, response, body, resolve, reject)) {
 216                     return resolve({
 217                         statusCode: response.statusCode,
 218                         data: JSON.stringify(response.body)
 219                     });
 220                 };
 221             });
 222         });
 223         updateTasks.push(revertivePreferencePromise);
 224     }
 225
 226     if(data.hasOwnProperty('dns-ip-fqdn')) {
 227         var dnsIpFqdn = data['dns-ip-fqdn'];
 228         var dnsIpFqdnUrl = utils.confdPort(api_server) + '/api/config/redundancy-config';
 229         if(dnsIpFqdn.trim() != '') {
 230             var dnsIpFqdnData = {'dns-ip-fqdn' : dnsIpFqdn}
 231             var dnsIpFqdnPromise = new Promise(function(resolve, reject) {
 232                 _.extend(requestHeaders,
 233                     constants.HTTP_HEADERS.accept.data,
 234                     constants.HTTP_HEADERS.content_type.data, {
 235                         'Authorization': req.session && req.session.authorization
 236                     });
 237                 request({
 238                     url: dnsIpFqdnUrl,
 239                     method: method,
 240                     headers: requestHeaders,
 241                     forever: constants.FOREVER_ON,
 242                     rejectUnauthorized: false,
 243                     json: dnsIpFqdnData,
 244                 }, function(error, response, body) {
 245                     if (utils.validateResponse('dnsIpFqdnPromise.' + method, error, response, body, resolve, reject)) {
 246                         return resolve({
 247                             statusCode: response.statusCode,
 248                             data: JSON.stringify(response.body)
 249                         });
 250                     };
 251                 });
 252             });
 253         } else {
 254             //Delete config item
 255             var dnsIpFqdnPromise = new Promise(function(resolve, reject) {
 256                 _.extend(requestHeaders,
 257                     constants.HTTP_HEADERS.accept.data,
 258                     constants.HTTP_HEADERS.content_type.data, {
 259                         'Authorization': req.session && req.session.authorization
 260                     });
 261                 request({
 262                     url: dnsIpFqdnUrl + '/dns-ip-fqdn',
 263                     method: 'DELETE',
 264                     headers: requestHeaders,
 265                     forever: constants.FOREVER_ON,
 266                     rejectUnauthorized: false
 267                 }, function(error, response, body) {
 268                     if (utils.validateResponse('dnsIpFqdnDelete.' + method, error, response, body, resolve, reject)) {
 269                         return resolve({
 270                             statusCode: response.statusCode,
 271                             data: JSON.stringify(response.body)
 272                         });
 273                     };
 274                 });
 275             });
 276         }
 277         updateTasks.push(dnsIpFqdnPromise);
 278     }
 279     return new Promise(function(resolve, reject) {
 280         Promise.all(updateTasks).then(function(results) {
 281             if(results && results[0]) {
 282                 resolve({
 283                     statusCode: results[0].statusCode,
 284                     data: {}
 285                 });
 286             }
 287         })
 288     })
 289 }
 290
 291
 292 Redundancy.siteUpdate = function(req) {
 293     var self = this;
 294     var id = req.params.id || req.params.name;
 295     var api_server = req.query["api_server"];
 296     var data = req.body;
 297     var requestHeaders = {};
 298     var createData = {};
 299     var url = utils.confdPort(api_server) + '/api/config/redundancy-config/site'
 300     var method = 'POST'
 301     createData = {};
 302     if (!id) {
 303         createData = {site: data}
 304     } else {
 305         method = 'PUT';
 306         url += '/' + encodeURIComponent(id);
 307         createData['rw-redundancy:site'] = data;
 308     }
 309
 310
 311
 312     return new Promise(function(resolve, reject) {
 313         _.extend(requestHeaders,
 314             constants.HTTP_HEADERS.accept.data,
 315             constants.HTTP_HEADERS.content_type.data, {
 316                 'Authorization': req.session && req.session.authorization
 317             });
 318         request({
 319             url: url,
 320             method: method,
 321             headers: requestHeaders,
 322             forever: constants.FOREVER_ON,
 323             rejectUnauthorized: false,
 324             json: createData,
 325         }, function(error, response, body) {
 326             if (utils.validateResponse('siteUpdate.' + method, error, response, body, resolve, reject)) {
 327                 return resolve({
 328                     statusCode: response.statusCode,
 329                     data: JSON.stringify(response.body)
 330                 });
 331             };
 332         });
 333     })
 334 }
 335
 336 Redundancy.siteDelete = function(req) {
 337     var self = this;
 338     var id = req.params.id || req.params.name;
 339     var api_server = req.query["api_server"];
 340     var data = req.body;
 341     var requestHeaders = {};
 342     var createData = {};
 343     var url = utils.confdPort(api_server) + '/api/config/redundancy-config/site/';
 344     url += encodeURIComponent(id);
 345     return new Promise(function(resolve, reject) {
 346         _.extend(requestHeaders,
 347             constants.HTTP_HEADERS.accept.data,
 348             constants.HTTP_HEADERS.content_type.data, {
 349                 'Authorization': req.session && req.session.authorization
 350             });
 351         request({
 352             url: url,
 353             method: 'DELETE',
 354             headers: requestHeaders,
 355             forever: constants.FOREVER_ON,
 356             rejectUnauthorized: false,
 357         }, function(error, response, body) {
 358             if (utils.validateResponse( 'siteUpdate.DELETE', error, response, body, resolve, reject)) {
 359                 return resolve({
 360                     statusCode: response.statusCode,
 361                     data: JSON.stringify(response.body)
 362                 });
 363             };
 364         });
 365     })
 366 }
 367
 368 module.exports = Redundancy;