Commit b8d15334e90dd05bdffa3d8ff3c5002f02b797d7

Authored by Adhidarma Hadiwinoto
1 parent 26deaf2949
Exists in master

maxTopUpReportRetry dan delayBeforeRetryTopUpReport

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