Reload97 / sate24-neoxmlin

Download as
Browse Code ยป

Commit 0ae77a92f048694bdf201c0aea50eaa4582856b5

Authored by Adhidarma Hadiwinoto
1 parent 8df5fc1207
Exists in master

refine logging on topUpReport

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