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');
10 Redundancy
.get = function(req
) {
11 return new Promise(function(resolve
, reject
) {
13 var api_server
= req
.query
["api_server"];
14 var requestHeaders
= {};
15 var url
= utils
.confdPort(api_server
) + '/api/operational/redundancy-config';
19 constants
.HTTP_HEADERS
.accept
.data
, {
20 'Authorization': req
.session
&& req
.session
.authorization
27 headers
: requestHeaders
,
28 forever
: constants
.FOREVER_ON
,
29 rejectUnauthorized
: false
31 function(error
, response
, body
) {
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
)) {
37 data
= JSON
.parse(response
.body
);
40 console
.log('Problem with "Redundancy.get"', e
);
44 error
: 'Problem with "Redundancy.get": ' + e
49 statusCode
: response
.statusCode
,
58 Redundancy
.getState = function(req
) {
59 return new Promise(function(resolve
, reject
) {
61 var api_server
= req
.query
["api_server"];
62 var requestHeaders
= {};
63 var url
= utils
.confdPort(api_server
) + '/api/operational/redundancy-state';
66 constants
.HTTP_HEADERS
.accept
.data
, {
67 'Authorization': req
.session
&& req
.session
.authorization
73 headers
: requestHeaders
,
74 forever
: constants
.FOREVER_ON
,
75 rejectUnauthorized
: false
77 function(error
, response
, body
) {
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
)) {
83 data
= JSON
.parse(response
.body
);
86 console
.log('Problem with "Redundancy.getState"', e
);
90 error
: 'Problem with "Redundancy.getState": ' + e
95 statusCode
: response
.statusCode
,
103 Redundancy
.configUpdate = function(req
) {
105 var id
= req
.params
.id
|| req
.params
.name
;
106 var api_server
= req
.query
["api_server"];
108 var requestHeaders
= {};
110 var updateTasks
= [];
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']
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
124 url
: revertivePreferenceUrl
,
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
)) {
133 statusCode
: response
.statusCode
,
134 data
: JSON
.stringify(response
.body
)
139 updateTasks
.push(revertivePreferencePromise
);
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
152 url
: geoFailDecisionConfigUrl
,
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
)) {
161 statusCode
: response
.statusCode
,
162 data
: JSON
.stringify(response
.body
)
167 updateTasks
.push(geoFailDecisionPromise
);
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
180 url
: userCredentialsUrl
,
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
)) {
189 statusCode
: response
.statusCode
,
190 data
: JSON
.stringify(response
.body
)
195 updateTasks
.push(userCredentialsPromise
);
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
208 url
: pollingConfigUrl
,
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
)) {
217 statusCode
: response
.statusCode
,
218 data
: JSON
.stringify(response
.body
)
223 updateTasks
.push(revertivePreferencePromise
);
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
240 headers
: requestHeaders
,
241 forever
: constants
.FOREVER_ON
,
242 rejectUnauthorized
: false,
244 }, function(error
, response
, body
) {
245 if (utils
.validateResponse('dnsIpFqdnPromise.' + method
, error
, response
, body
, resolve
, reject
)) {
247 statusCode
: response
.statusCode
,
248 data
: JSON
.stringify(response
.body
)
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
262 url
: dnsIpFqdnUrl
+ '/dns-ip-fqdn',
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
)) {
270 statusCode
: response
.statusCode
,
271 data
: JSON
.stringify(response
.body
)
277 updateTasks
.push(dnsIpFqdnPromise
);
279 return new Promise(function(resolve
, reject
) {
280 Promise
.all(updateTasks
).then(function(results
) {
281 if(results
&& results
[0]) {
283 statusCode
: results
[0].statusCode
,
292 Redundancy
.siteUpdate = function(req
) {
294 var id
= req
.params
.id
|| req
.params
.name
;
295 var api_server
= req
.query
["api_server"];
297 var requestHeaders
= {};
299 var url
= utils
.confdPort(api_server
) + '/api/config/redundancy-config/site'
303 createData
= {site
: data
}
306 url
+= '/' + encodeURIComponent(id
);
307 createData
['rw-redundancy:site'] = data
;
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
321 headers
: requestHeaders
,
322 forever
: constants
.FOREVER_ON
,
323 rejectUnauthorized
: false,
325 }, function(error
, response
, body
) {
326 if (utils
.validateResponse('siteUpdate.' + method
, error
, response
, body
, resolve
, reject
)) {
328 statusCode
: response
.statusCode
,
329 data
: JSON
.stringify(response
.body
)
336 Redundancy
.siteDelete = function(req
) {
338 var id
= req
.params
.id
|| req
.params
.name
;
339 var api_server
= req
.query
["api_server"];
341 var requestHeaders
= {};
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
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
)) {
360 statusCode
: response
.statusCode
,
361 data
: JSON
.stringify(response
.body
)
368 module
.exports
= Redundancy
;