Reload97 / sate24-neoxmlin

Download as
Browse Code ยป

Commit 0e68a0f2a8d369855782c9d5f970d850813b1256

Authored by Adhidarma Hadiwinoto
1 parent 6cef2ccead
Exists in master

tweak

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