Reload97 / sate24-neoxmlin

Download as
Browse Code ยป

Commit 221c4a38a7cca6fe37e1123b60790984039d285f

Authored by Adhidarma Hadiwinoto
1 parent 2aab9087b9
Exists in master

tune debug log

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