Reload97 / sate24-neoxmlin

Download as
Browse Code ยป

Commit 97a8eb629fdeaf7f6225f755dcee34198748fecc

Authored by Adhidarma Hadiwinoto
1 parent b8d15334e9
Exists in master

setting http.globalAgent.maxSockets = Infinity

Showing 1 changed file with 8 additions and 0 deletions Inline Diff

1 var xmlrpc = require('xmlrpc'); 1 var xmlrpc = require('xmlrpc');
2 var request = require('request'); 2 var request = require('request');
3 var neoxmlinutil = require('./neoxmlinutil'); 3 var neoxmlinutil = require('./neoxmlinutil');
4 var http = require('http'); 4 var http = require('http');
5 var https = require('https'); 5 var https = require('https');
6 var fs = require('fs'); 6 var fs = require('fs');
7 var xml2js = new require('xml2js'); 7 var xml2js = new require('xml2js');
8 var xml2jsParser = require('xml2js').parseString; 8 var xml2jsParser = require('xml2js').parseString;
9 var xml2jsBuilder = new xml2js.Builder(); 9 var xml2jsBuilder = new xml2js.Builder();
10 var url = require("url"); 10 var url = require("url");
11 var strftime = require('strftime'); 11 var strftime = require('strftime');
12 12
13 var options; 13 var options;
14 var config; 14 var config;
15 var logger; 15 var logger;
16 16
17 var server; 17 var server;
18 18
19 var delayBeforeRetryTopUpReport = 10 * 1000; 19 var delayBeforeRetryTopUpReport = 10 * 1000;
20 var maxTopUpReportRetry = 5; 20 var maxTopUpReportRetry = 5;
21 21
22 function start(_options) { 22 function start(_options) {
23 options = _options; 23 options = _options;
24 24
25 if (options.config) { 25 if (options.config) {
26 config = options.config; 26 config = options.config;
27 } 27 }
28 else { 28 else {
29 config = require("./config.json"); 29 config = require("./config.json");
30 } 30 }
31 31
32 if (options.logger) { 32 if (options.logger) {
33 logger = options.logger; 33 logger = options.logger;
34 } 34 }
35 else { 35 else {
36 logger = console; 36 logger = console;
37 } 37 }
38 38
39 createResponseServer(); 39 createResponseServer();
40 40
41 createDiyHttpXmlRpcServer(); 41 createDiyHttpXmlRpcServer();
42 //createXmlRpcServer() 42 //createXmlRpcServer()
43 //createExpressXmlRpcServer(); 43 //createExpressXmlRpcServer();
44
45 try {
46 http.globalAgent.maxSockets = Infinity;
47 }
48 catch(e) {
49 logger.warn('Error setting http.globalAgent.maxSockets = Infinity', {err: e});
50 }
51
44 } 52 }
45 53
46 function getXmlRpcParam(values) { 54 function getXmlRpcParam(values) {
47 try { 55 try {
48 56
49 var count = values.length 57 var count = values.length
50 var result = {}; 58 var result = {};
51 for (var i = 0; i < count; i++) { 59 for (var i = 0; i < count; i++) {
52 var value = values[i]; 60 var value = values[i];
53 61
54 var keys = Object.keys(value.value[0]); 62 var keys = Object.keys(value.value[0]);
55 var firstKey = keys[0]; 63 var firstKey = keys[0];
56 result[value.name[0]] = value.value[0][firstKey][0]; 64 result[value.name[0]] = value.value[0][firstKey][0];
57 } 65 }
58 66
59 return result; 67 return result;
60 68
61 } 69 }
62 catch(err) { 70 catch(err) {
63 return null; 71 return null;
64 } 72 }
65 } 73 }
66 74
67 function createDiyHttpXmlRpcServer() { 75 function createDiyHttpXmlRpcServer() {
68 var serverOptions = { 76 var serverOptions = {
69 key: fs.readFileSync('./server.key'), 77 key: fs.readFileSync('./server.key'),
70 cert: fs.readFileSync('./server.crt') 78 cert: fs.readFileSync('./server.crt')
71 } 79 }
72 80
73 var httpServer = https.createServer(serverOptions, function(req, res) { 81 var httpServer = https.createServer(serverOptions, function(req, res) {
74 82
75 logger.verbose("Incoming connection from " + req.connection.remoteAddress); 83 logger.verbose("Incoming connection from " + req.connection.remoteAddress);
76 84
77 var body = ""; 85 var body = "";
78 86
79 req.on('data', function (chunk) { 87 req.on('data', function (chunk) {
80 body += chunk; 88 body += chunk;
81 }); 89 });
82 90
83 req.on('end', function () { 91 req.on('end', function () {
84 92
85 xml2jsParser(body, function(err, message) { 93 xml2jsParser(body, function(err, message) {
86 94
87 if (err) { 95 if (err) {
88 logger.warn('Got XMLRPC invalid XML request body from ' + req.connection.remoteAddress, {body: body, err: err}); 96 logger.warn('Got XMLRPC invalid XML request body from ' + req.connection.remoteAddress, {body: body, err: err});
89 res.end('Invalid XMLRPC request'); 97 res.end('Invalid XMLRPC request');
90 return; 98 return;
91 } 99 }
92 100
93 var method; 101 var method;
94 var _params; 102 var _params;
95 103
96 try { 104 try {
97 method = message.methodCall.methodName[0]; 105 method = message.methodCall.methodName[0];
98 _params = message.methodCall.params[0].param[0].value[0].struct[0].member; 106 _params = message.methodCall.params[0].param[0].value[0].struct[0].member;
99 } 107 }
100 catch(errSelectMethod) { 108 catch(errSelectMethod) {
101 logger.warn('Failed to get method and params on request from ' + req.connection.remoteAddress); 109 logger.warn('Failed to get method and params on request from ' + req.connection.remoteAddress);
102 res.end('Invalid XMLRPC message') 110 res.end('Invalid XMLRPC message')
103 return; 111 return;
104 } 112 }
105 113
106 params = getXmlRpcParam(_params); 114 params = getXmlRpcParam(_params);
107 logger.info('Got XMLRPC request from ' + req.connection.remoteAddress, {method: method, params: params}); 115 logger.info('Got XMLRPC request from ' + req.connection.remoteAddress, {method: method, params: params});
108 116
109 if (method == 'topUpRequest') { 117 if (method == 'topUpRequest') {
110 118
111 sendTopUpRequestToMaster(params, req.connection.remoteAddress, function(forwardError) { 119 sendTopUpRequestToMaster(params, req.connection.remoteAddress, function(forwardError) {
112 if (forwardError) { 120 if (forwardError) {
113 immediateReply(params, res, '40', forwardError.toString()); 121 immediateReply(params, res, '40', forwardError.toString());
114 } else { 122 } else {
115 immediateReply(params, res, '68'); 123 immediateReply(params, res, '68');
116 } 124 }
117 }); 125 });
118 126
119 } 127 }
120 else if (method == 'topUpInquiry') { 128 else if (method == 'topUpInquiry') {
121 129
122 sendTopUpInquryToMaster(params, req.connection.remoteAddress, res); 130 sendTopUpInquryToMaster(params, req.connection.remoteAddress, res);
123 131
124 } 132 }
125 else { 133 else {
126 res.end('Invalid method'); 134 res.end('Invalid method');
127 } 135 }
128 136
129 137
130 }) 138 })
131 }); 139 });
132 140
133 }); 141 });
134 142
135 httpServer.listen(config.server_options.port, function() { 143 httpServer.listen(config.server_options.port, function() {
136 logger.info('HTTP XMLRPC listen on port ' + config.server_options.port); 144 logger.info('HTTP XMLRPC listen on port ' + config.server_options.port);
137 }); 145 });
138 } 146 }
139 147
140 function composeXmlRpcResponse(param) { 148 function composeXmlRpcResponse(param) {
141 149
142 var values = []; 150 var values = [];
143 var keys = Object.keys(param); 151 var keys = Object.keys(param);
144 var keysCount = keys.length; 152 var keysCount = keys.length;
145 153
146 for (var i = 0; i < keysCount; i++) { 154 for (var i = 0; i < keysCount; i++) {
147 var key = keys[i]; 155 var key = keys[i];
148 var value = { 156 var value = {
149 name: key, 157 name: key,
150 value: { 158 value: {
151 string: param[key] 159 string: param[key]
152 } 160 }
153 } 161 }
154 values.push(value); 162 values.push(value);
155 } 163 }
156 164
157 var data = { 165 var data = {
158 methodResponse: { 166 methodResponse: {
159 params: { 167 params: {
160 param: { 168 param: {
161 value: { 169 value: {
162 struct: { 170 struct: {
163 member: values 171 member: values
164 } 172 }
165 } 173 }
166 } 174 }
167 } 175 }
168 } 176 }
169 } 177 }
170 178
171 //logger.info(JSON.stringify(data)); 179 //logger.info(JSON.stringify(data));
172 180
173 return xml2jsBuilder.buildObject(data); 181 return xml2jsBuilder.buildObject(data);
174 } 182 }
175 183
176 function immediateReply(param, requestResponse, responseCode, message) { 184 function immediateReply(param, requestResponse, responseCode, message) {
177 185
178 if (!responseCode) { 186 if (!responseCode) {
179 responseCode = '68'; 187 responseCode = '68';
180 } 188 }
181 189
182 if (!message) { 190 if (!message) {
183 message = "Sementara tidak dapat diproses."; 191 message = "Sementara tidak dapat diproses.";
184 } 192 }
185 193
186 if (responseCode == '68') { 194 if (responseCode == '68') {
187 message = 'ISI ' 195 message = 'ISI '
188 + param.NOM.toUpperCase() 196 + param.NOM.toUpperCase()
189 + ' KE ' 197 + ' KE '
190 + param.NOHP 198 + param.NOHP
191 + ', Transaksi anda sedang diproses' 199 + ', Transaksi anda sedang diproses'
192 } 200 }
193 201
194 var responseData = { 202 var responseData = {
195 'RESPONSECODE': responseCode, 203 'RESPONSECODE': responseCode,
196 'REQUESTID': param.REQUESTID, 204 'REQUESTID': param.REQUESTID,
197 'MESSAGE': message, 205 'MESSAGE': message,
198 'TRANSACTIONID': '0', 206 'TRANSACTIONID': '0',
199 } 207 }
200 208
201 209
202 var responseBody = composeXmlRpcResponse(responseData) 210 var responseBody = composeXmlRpcResponse(responseData)
203 logger.info("Sending immediateReply response", {responseData: responseData}); 211 logger.info("Sending immediateReply response", {responseData: responseData});
204 212
205 requestResponse.writeHead(200, {'Content-Type': 'text/xml'}); 213 requestResponse.writeHead(200, {'Content-Type': 'text/xml'});
206 requestResponse.end(responseBody); 214 requestResponse.end(responseBody);
207 } 215 }
208 216
209 function composeMessage(params, remoteAddress) { 217 function composeMessage(params, remoteAddress) {
210 try { 218 try {
211 var nom = params.NOM.replace(/\./g, '').trim(); 219 var nom = params.NOM.replace(/\./g, '').trim();
212 var destination = params.NOHP.replace(/\./g, '').trim(); 220 var destination = params.NOHP.replace(/\./g, '').trim();
213 var pin = params.PIN.replace(/\./g, '').trim(); 221 var pin = params.PIN.replace(/\./g, '').trim();
214 var requestId = params.REQUESTID.replace(/\./g, '').trim(); 222 var requestId = params.REQUESTID.replace(/\./g, '').trim();
215 223
216 return 'MI.' + nom + '."' + destination + '".' + pin + '.' + requestId + '.NOTRUST."' + remoteAddress + '"'; 224 return 'MI.' + nom + '."' + destination + '".' + pin + '.' + requestId + '.NOTRUST."' + remoteAddress + '"';
217 } 225 }
218 catch(err) { 226 catch(err) {
219 return; 227 return;
220 } 228 }
221 229
222 230
223 } 231 }
224 232
225 function inquiryReply(responseCode, message, responseToClient) { 233 function inquiryReply(responseCode, message, responseToClient) {
226 var responseData = { 234 var responseData = {
227 'RESPONSECODE': responseCode, 235 'RESPONSECODE': responseCode,
228 'MESSAGE': message 236 'MESSAGE': message
229 } 237 }
230 238
231 var responseBody = composeXmlRpcResponse(responseData) 239 var responseBody = composeXmlRpcResponse(responseData)
232 logger.info("Sending inquiry response", {responseData: responseData}); 240 logger.info("Sending inquiry response", {responseData: responseData});
233 241
234 responseToClient.writeHead(200, {'Content-Type': 'text/xml'}); 242 responseToClient.writeHead(200, {'Content-Type': 'text/xml'});
235 responseToClient.end(responseBody); 243 responseToClient.end(responseBody);
236 } 244 }
237 245
238 function parseTopUpInquiryResponse(raw) { 246 function parseTopUpInquiryResponse(raw) {
239 var tokens = raw.split('$'); 247 var tokens = raw.split('$');
240 if (tokens.length < 2) { 248 if (tokens.length < 2) {
241 return { 249 return {
242 responseCode: '68', 250 responseCode: '68',
243 message: 'Gagal parsing hasil inquiry' 251 message: 'Gagal parsing hasil inquiry'
244 } 252 }
245 } 253 }
246 254
247 var responseCode = tokens[0]; 255 var responseCode = tokens[0];
248 var message = ''; 256 var message = '';
249 257
250 for (var i = 1; i < tokens.length; i++) { 258 for (var i = 1; i < tokens.length; i++) {
251 message += '$' + tokens[i]; 259 message += '$' + tokens[i];
252 } 260 }
253 261
254 return { 262 return {
255 responseCode: responseCode, 263 responseCode: responseCode,
256 message: message.replace('$', '') 264 message: message.replace('$', '')
257 } 265 }
258 } 266 }
259 267
260 function sendTopUpInquryToMaster(params, remoteAddress, responseToClient) { 268 function sendTopUpInquryToMaster(params, remoteAddress, responseToClient) {
261 if (!config.inquiry_url) { 269 if (!config.inquiry_url) {
262 inquiryReply('68', 'Inquiry server tidak terdaftar'); 270 inquiryReply('68', 'Inquiry server tidak terdaftar');
263 return; 271 return;
264 } 272 }
265 273
266 var requestOpts = { 274 var requestOpts = {
267 url: config.inquiry_url, 275 url: config.inquiry_url,
268 qs: { 276 qs: {
269 REQUESTID: params.REQUESTID, 277 REQUESTID: params.REQUESTID,
270 MSISDN: param.MSISDN, 278 MSISDN: param.MSISDN,
271 PIN: params.PIN, 279 PIN: params.PIN,
272 NO_HP: params.NO_HP, 280 NO_HP: params.NO_HP,
273 TRUST: 'NO_TRUST', 281 TRUST: 'NO_TRUST',
274 IP_ADDR: remoteAddress 282 IP_ADDR: remoteAddress
275 } 283 }
276 }; 284 };
277 285
278 request(requestOpts, function(requestError, response, body) { 286 request(requestOpts, function(requestError, response, body) {
279 287
280 if (requestError) { 288 if (requestError) {
281 logger.warn('Error requesting to inquiry server: ' + requestError); 289 logger.warn('Error requesting to inquiry server: ' + requestError);
282 inquiryReply('68', 'Gagal konek ke inquiry server', responseToClient); 290 inquiryReply('68', 'Gagal konek ke inquiry server', responseToClient);
283 return; 291 return;
284 } 292 }
285 293
286 logger.info('Got response from inquiry server', {body: body, requestOpts: requestOpts}); 294 logger.info('Got response from inquiry server', {body: body, requestOpts: requestOpts});
287 var params = parseTopUpInquiryResponse(body); 295 var params = parseTopUpInquiryResponse(body);
288 inquiryReply(params.responseCode, params.message, responseToClient); 296 inquiryReply(params.responseCode, params.message, responseToClient);
289 }) 297 })
290 } 298 }
291 299
292 function sendTopUpRequestToMaster(param, remoteAddress, callback) { 300 function sendTopUpRequestToMaster(param, remoteAddress, callback) {
293 301
294 /* 302 /*
295 var smscidSuffix = '99999999999999' + String(Math.round(Math.random() * 99999999999999)); 303 var smscidSuffix = '99999999999999' + String(Math.round(Math.random() * 99999999999999));
296 var smscid = 'XML1' + smscidSuffix.slice(-13); 304 var smscid = 'XML1' + smscidSuffix.slice(-13);
297 */ 305 */
298 306
299 //var smscid = 'XML' + '12345' + strftime('%H%M%S%L'); 307 //var smscid = 'XML' + '12345' + strftime('%H%M%S%L');
300 var smscid = config.smscid;// + Math.round(Math.random() * 9999999999999); 308 var smscid = config.smscid;// + Math.round(Math.random() * 9999999999999);
301 309
302 var message = composeMessage(param, remoteAddress); 310 var message = composeMessage(param, remoteAddress);
303 if (!message) { 311 if (!message) {
304 logger.warn('Invalid message for sendToMaster', {param: param}); 312 logger.warn('Invalid message for sendToMaster', {param: param});
305 return; 313 return;
306 } 314 }
307 315
308 var requestOpts = { 316 var requestOpts = {
309 url: config.master_url, 317 url: config.master_url,
310 qs: { 318 qs: {
311 PhoneNumber: param.MSISDN, 319 PhoneNumber: param.MSISDN,
312 'Text': message, 320 'Text': message,
313 Res_Port: config.res_port, 321 Res_Port: config.res_port,
314 Smscid: smscid 322 Smscid: smscid
315 } 323 }
316 }; 324 };
317 325
318 if (config.res_ip) { 326 if (config.res_ip) {
319 requestOpts.qs.ip_addr = config.res_ip; 327 requestOpts.qs.ip_addr = config.res_ip;
320 } 328 }
321 329
322 logger.info('Forward request to master', {requestOpts: requestOpts}); 330 logger.info('Forward request to master', {requestOpts: requestOpts});
323 331
324 request(requestOpts, function(requestError, response, body) { 332 request(requestOpts, function(requestError, response, body) {
325 333
326 if (requestError) { 334 if (requestError) {
327 logger.warn('Error requesting to master: ' + requestError); 335 logger.warn('Error requesting to master: ' + requestError);
328 } else { 336 } else {
329 logger.info('Got response from master', {body: body, requestOpts: requestOpts}); 337 logger.info('Got response from master', {body: body, requestOpts: requestOpts});
330 } 338 }
331 339
332 callback(requestError); 340 callback(requestError);
333 }) 341 })
334 342
335 } 343 }
336 344
337 function sendReply(response) { 345 function sendReply(response) {
338 /* 346 /*
339 var requestId = neoxmlinutil.getRequestIdFromResponseMessage(response.text); 347 var requestId = neoxmlinutil.getRequestIdFromResponseMessage(response.text);
340 348
341 if (!requestId) { 349 if (!requestId) {
342 logger.warn('No request id found, skipping'); 350 logger.warn('No request id found, skipping');
343 return; 351 return;
344 } 352 }
345 */ 353 */
346 354
347 var params = { 355 var params = {
348 REQUESTID: response.requestid, 356 REQUESTID: response.requestid,
349 MSISDN: response.PhoneNumber, 357 MSISDN: response.PhoneNumber,
350 RESPONSECODE: response.resp_code, 358 RESPONSECODE: response.resp_code,
351 MESSAGE: response.text, 359 MESSAGE: response.text,
352 } 360 }
353 361
354 if (response.new_sn) { 362 if (response.new_sn) {
355 params.SN = response.new_sn.replace(/^SN=/, ''); 363 params.SN = response.new_sn.replace(/^SN=/, '');
356 } 364 }
357 365
358 if (response.new_ending_balance) { 366 if (response.new_ending_balance) {
359 params.BALANCE = response.new_ending_balance; 367 params.BALANCE = response.new_ending_balance;
360 } 368 }
361 369
362 if (response.new_price) { 370 if (response.new_price) {
363 params.PRICE = response.new_price; 371 params.PRICE = response.new_price;
364 } 372 }
365 373
366 logger.info('sendReply', {params: params}); 374 logger.info('sendReply', {params: params});
367 375
368 neoxmlinutil.getReverseUrl(response.PhoneNumber, function(err, reverseUrls) { 376 neoxmlinutil.getReverseUrl(response.PhoneNumber, function(err, reverseUrls) {
369 if (err) { 377 if (err) {
370 logger.warn('Fail to get reverse urls, skipping'); 378 logger.warn('Fail to get reverse urls, skipping');
371 return; 379 return;
372 } 380 }
373 381
374 if (reverseUrls.length <= 0) { 382 if (reverseUrls.length <= 0) {
375 logger.warn('No reverse urls found, skipping'); 383 logger.warn('No reverse urls found, skipping');
376 return; 384 return;
377 } 385 }
378 386
379 sendTopUpReport(reverseUrls, params, 0, 4); 387 sendTopUpReport(reverseUrls, params, 0, 4);
380 }); 388 });
381 } 389 }
382 390
383 function errorOnTopUpReport(topUpReportError, debugInfo) { 391 function errorOnTopUpReport(topUpReportError, debugInfo) {
384 var hasError = false; 392 var hasError = false;
385 393
386 if (!topUpReportError) { 394 if (!topUpReportError) {
387 return false; 395 return false;
388 } 396 }
389 397
390 try { 398 try {
391 if (topUpReportError.body) { 399 if (topUpReportError.body) {
392 logger.verbose('errorOnTopUpReport response body: ' + topUpReportError.body, {req: debugInfo}); 400 logger.verbose('errorOnTopUpReport response body: ' + topUpReportError.body, {req: debugInfo});
393 } 401 }
394 402
395 if (topUpReportError.res && topUpReportError.res.statusCode && topUpReportError.res.statusCode != '200') { 403 if (topUpReportError.res && topUpReportError.res.statusCode && topUpReportError.res.statusCode != '200') {
396 logger.verbose('Partner response with status code:' + topUpReportError.res.statusCode, {req: debugInfo}); 404 logger.verbose('Partner response with status code:' + topUpReportError.res.statusCode, {req: debugInfo});
397 405
398 if (topUpReportError.res.statusCode != '200') { 406 if (topUpReportError.res.statusCode != '200') {
399 logger.warn('Going to resend topUpReport because status code is not 200 (' + topUpReportError.res.statusCode + ')', {req: debugInfo}); 407 logger.warn('Going to resend topUpReport because status code is not 200 (' + topUpReportError.res.statusCode + ')', {req: debugInfo});
400 return true; 408 return true;
401 } 409 }
402 } 410 }
403 } catch(e) {} 411 } catch(e) {}
404 412
405 try { 413 try {
406 if (topUpReportError.toString().indexOf('Invalid XML-RPC message') < 0) { 414 if (topUpReportError.toString().indexOf('Invalid XML-RPC message') < 0) {
407 logger.verbose('errorOnTopUpReport', {error: topUpReportError.toString()}); 415 logger.verbose('errorOnTopUpReport', {error: topUpReportError.toString()});
408 return true; 416 return true;
409 } 417 }
410 } 418 }
411 catch(e) {} 419 catch(e) {}
412 420
413 return false; 421 return false;
414 422
415 } 423 }
416 424
417 function sendTopUpReport(reverseUrls, params, urlIdx, retry) { 425 function sendTopUpReport(reverseUrls, params, urlIdx, retry) {
418 if (retry === null || retry === undefined) { 426 if (retry === null || retry === undefined) {
419 retry = maxTopUpReportRetry; 427 retry = maxTopUpReportRetry;
420 } 428 }
421 429
422 if (urlIdx === null || urlIdx === undefined) { 430 if (urlIdx === null || urlIdx === undefined) {
423 urlIdx = 0; 431 urlIdx = 0;
424 } 432 }
425 433
426 if (urlIdx >= reverseUrls.length) { 434 if (urlIdx >= reverseUrls.length) {
427 logger.warn('No other reverse urls for partner available', {reverseUrls: reverseUrls, params: params}); 435 logger.warn('No other reverse urls for partner available', {reverseUrls: reverseUrls, params: params});
428 436
429 if (retry > 0) { 437 if (retry > 0) {
430 logger.warn('Retrying to send topUpReport to partner first url', {remaining_retry: retry-1, reverseUrls: reverseUrls, params: params}); 438 logger.warn('Retrying to send topUpReport to partner first url', {remaining_retry: retry-1, reverseUrls: reverseUrls, params: params});
431 setTimeout( 439 setTimeout(
432 sendTopUpReport, 440 sendTopUpReport,
433 delayBeforeRetryTopUpReport, 441 delayBeforeRetryTopUpReport,
434 reverseUrls, 442 reverseUrls,
435 params, 443 params,
436 0, 444 0,
437 --retry 445 --retry
438 ) 446 )
439 return; 447 return;
440 } 448 }
441 449
442 logger.warn('topUpReport retry exceed', {reverseUrls: reverseUrls, params: params}); 450 logger.warn('topUpReport retry exceed', {reverseUrls: reverseUrls, params: params});
443 return; 451 return;
444 } 452 }
445 453
446 var partnerUrl = url.parse(reverseUrls[urlIdx]); 454 var partnerUrl = url.parse(reverseUrls[urlIdx]);
447 455
448 var clientOptions = { 456 var clientOptions = {
449 host: partnerUrl.hostname 457 host: partnerUrl.hostname
450 , port: partnerUrl.port 458 , port: partnerUrl.port
451 , path: partnerUrl.pathname 459 , path: partnerUrl.pathname
452 }; 460 };
453 461
454 //logger.verbose('Preparing to send topUpReport', {clientOptions: clientOptions}); 462 //logger.verbose('Preparing to send topUpReport', {clientOptions: clientOptions});
455 463
456 var client; 464 var client;
457 if (partnerUrl.protocol == 'https:') { 465 if (partnerUrl.protocol == 'https:') {
458 client = xmlrpc.createSecureClient(clientOptions); 466 client = xmlrpc.createSecureClient(clientOptions);
459 } else { 467 } else {
460 client = xmlrpc.createClient(clientOptions); 468 client = xmlrpc.createClient(clientOptions);
461 } 469 }
462 470
463 var methodName = 'topUpReport'; 471 var methodName = 'topUpReport';
464 logger.info('Requesting topUpReport', {protocol: partnerUrl.protocol, clientOptions: clientOptions, params: params}); 472 logger.info('Requesting topUpReport', {protocol: partnerUrl.protocol, clientOptions: clientOptions, params: params});
465 473
466 client.methodCall(methodName, [ params ], function (topUpReportError, value) { 474 client.methodCall(methodName, [ params ], function (topUpReportError, value) {
467 475
468 if (errorOnTopUpReport(topUpReportError, {params: params, clientOptions: clientOptions})) { 476 if (errorOnTopUpReport(topUpReportError, {params: params, clientOptions: clientOptions})) {
469 477
470 logger.warn('Error sending topUpReport retrying another url (if available): ' + topUpReportError, 478 logger.warn('Error sending topUpReport retrying another url (if available): ' + topUpReportError,
471 { 479 {
472 error: topUpReportError.toString(), 480 error: topUpReportError.toString(),
473 responseBody: topUpReportError.body, 481 responseBody: topUpReportError.body,
474 params: params, 482 params: params,
475 clientOptions: clientOptions, 483 clientOptions: clientOptions,
476 } 484 }
477 ); 485 );
478 sendTopUpReport(reverseUrls, params, ++urlIdx, retry); 486 sendTopUpReport(reverseUrls, params, ++urlIdx, retry);
479 return; 487 return;
480 488
481 } 489 }
482 490
483 logger.verbose("topUpReport ACK", {params: params, clientOptions: clientOptions}); 491 logger.verbose("topUpReport ACK", {params: params, clientOptions: clientOptions});
484 492
485 }); 493 });
486 } 494 }
487 495
488 function createResponseServer() { 496 function createResponseServer() {
489 var httpServer = http.createServer(function(req, res) { 497 var httpServer = http.createServer(function(req, res) {
490 498
491 res.end(); 499 res.end();
492 500
493 var parsed_url = url.parse(req.url, true, true); 501 var parsed_url = url.parse(req.url, true, true);
494 logger.info("Hit on response server", {qs: parsed_url.query}); 502 logger.info("Hit on response server", {qs: parsed_url.query});
495 503
496 sendReply(parsed_url.query); 504 sendReply(parsed_url.query);
497 505
498 }); 506 });
499 507
500 httpServer.listen(config.res_port, function() { 508 httpServer.listen(config.res_port, function() {
501 logger.info('HTTP Response server listen on port ' + config.res_port); 509 logger.info('HTTP Response server listen on port ' + config.res_port);
502 }); 510 });
503 } 511 }
504 512
505 exports.start = start; 513 exports.start = start;
506 514