Reload97 / pysate24-xltunai

Download as
Browse Code ยป

Commit d283cc10d51f78c1e9b8bee72743e9029a9222ff

Authored by Adhidarma Hadiwinoto
1 parent ae722980a5
Exists in master

bf

Showing 1 changed file with 3 additions and 1 deletions Inline Diff

1 #!/usr/bin/env python 1 #!/usr/bin/env python
2 2
3 import logging 3 import logging
4 from logging.handlers import TimedRotatingFileHandler 4 from logging.handlers import TimedRotatingFileHandler
5 import ConfigParser 5 import ConfigParser
6 import json 6 import json
7 from os import getpid 7 from os import getpid
8 import re 8 import re
9 import signal 9 import signal
10 import sys 10 import sys
11 11
12 config = ConfigParser.RawConfigParser() 12 config = ConfigParser.RawConfigParser()
13 config.read('config.ini') 13 config.read('config.ini')
14 14
15 PORT = config.get('globals','PORT') 15 PORT = config.get('globals','PORT')
16 BAUDRATE = config.getint('globals', 'BAUDRATE') 16 BAUDRATE = config.getint('globals', 'BAUDRATE')
17 PIN = None # SIM card PIN (if any) 17 PIN = None # SIM card PIN (if any)
18 PIN_TRX = config.get('globals', 'PIN_TRX') 18 PIN_TRX = config.get('globals', 'PIN_TRX')
19 19
20 BASE_CHIPINFO = config.get('globals', 'BASE_CHIPINFO') 20 BASE_CHIPINFO = config.get('globals', 'BASE_CHIPINFO')
21 CHIPINFO = BASE_CHIPINFO 21 CHIPINFO = BASE_CHIPINFO
22 22
23 AAA_HOST = config.get('globals', 'AAA_HOST') 23 AAA_HOST = config.get('globals', 'AAA_HOST')
24 CITY = config.get('globals', 'CITY') 24 CITY = config.get('globals', 'CITY')
25 PRODUCTS = config.get('globals', 'PRODUCTS') 25 PRODUCTS = config.get('globals', 'PRODUCTS')
26 26
27 REDIS_HOST = config.get('globals', 'REDIS_HOST') 27 REDIS_HOST = config.get('globals', 'REDIS_HOST')
28 REDIS_PORT = config.getint('globals', 'REDIS_PORT') 28 REDIS_PORT = config.getint('globals', 'REDIS_PORT')
29 REDIS_TTL = config.getint('globals', 'REDIS_TTL') 29 REDIS_TTL = config.getint('globals', 'REDIS_TTL')
30 REDIS_DISABLE_PULL_TTL = config.getint('globals', 'REDIS_DISABLE_PULL_TTL') 30 REDIS_DISABLE_PULL_TTL = config.getint('globals', 'REDIS_DISABLE_PULL_TTL')
31 31
32 PULL_INTERVAL = config.getint('globals', 'PULL_INTERVAL') 32 PULL_INTERVAL = config.getint('globals', 'PULL_INTERVAL')
33 SLEEP_AFTER_TOPUP = config.getint('globals', 'SLEEP_AFTER_TOPUP') 33 SLEEP_AFTER_TOPUP = config.getint('globals', 'SLEEP_AFTER_TOPUP')
34 SLEEP_BETWEEN_BALANCE_N_TOPUP = config.getint('globals', 'SLEEP_BETWEEN_BALANCE_N_TOPUP') 34 SLEEP_BETWEEN_BALANCE_N_TOPUP = config.getint('globals', 'SLEEP_BETWEEN_BALANCE_N_TOPUP')
35 TOPUP_USSD_TIMEOUT = config.getint('globals', 'TOPUP_USSD_TIMEOUT') 35 TOPUP_USSD_TIMEOUT = config.getint('globals', 'TOPUP_USSD_TIMEOUT')
36 SLEEP_AFTER_USSD_ERROR = 180 36 SLEEP_AFTER_USSD_ERROR = 180
37 37
38 MIN_SIGNAL_STRENGTH = 13 38 MIN_SIGNAL_STRENGTH = 0
39 try: 39 try:
40 MIN_SIGNAL_STRENGTH = config.getint('globals', 'MIN_SIGNAL_STRENGTH') 40 MIN_SIGNAL_STRENGTH = config.getint('globals', 'MIN_SIGNAL_STRENGTH')
41 except: 41 except:
42 pass 42 pass
43 if not MIN_SIGNAL_STRENGTH:
44 MIN_SIGNAL_STRENGTH = 13
43 45
44 MIN_BALANCE = config.getint('globals', 'MIN_BALANCE') 46 MIN_BALANCE = config.getint('globals', 'MIN_BALANCE')
45 47
46 PULL_COUNT = 0 48 PULL_COUNT = 0
47 MSISDN = '' 49 MSISDN = ''
48 BALANCE = 0 50 BALANCE = 0
49 51
50 DISABLE_SEM=0 52 DISABLE_SEM=0
51 DISABLE_SEM_ON_TRX=60 53 DISABLE_SEM_ON_TRX=60
52 DISABLE_BY_MONTHLY_LIMIT=False 54 DISABLE_BY_MONTHLY_LIMIT=False
53 55
54 TERMINATING=False 56 TERMINATING=False
55 57
56 LAST_REQUEST_ID = None 58 LAST_REQUEST_ID = None
57 LAST_SN = None 59 LAST_SN = None
58 LAST_PRODUCT = '' 60 LAST_PRODUCT = ''
59 61
60 PULSA = 0 62 PULSA = 0
61 MASA_AKTIF = "" 63 MASA_AKTIF = ""
62 64
63 logger = None 65 logger = None
64 66
65 from gsmmodem.modem import GsmModem 67 from gsmmodem.modem import GsmModem
66 from gsmmodem.exceptions import TimeoutException 68 from gsmmodem.exceptions import TimeoutException
67 69
68 from time import sleep 70 from time import sleep
69 from time import strftime 71 from time import strftime
70 72
71 import redis 73 import redis
72 import requests 74 import requests
73 75
74 import sate24 76 import sate24
75 import xltunai 77 import xltunai
76 78
77 redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0) 79 redis_client = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0)
78 80
79 def signalHandler(signum, frame): 81 def signalHandler(signum, frame):
80 global TERMINATING 82 global TERMINATING
81 83
82 if signum == signal.SIGINT or signum == signal.SIGTERM: 84 if signum == signal.SIGINT or signum == signal.SIGTERM:
83 logger.info('Signal ({0}) received, waiting for next loop to terminate. Terminating...'.format(signum)) 85 logger.info('Signal ({0}) received, waiting for next loop to terminate. Terminating...'.format(signum))
84 TERMINATING = True 86 TERMINATING = True
85 87
86 def handleSms(sms): 88 def handleSms(sms):
87 global DISABLE_SEM 89 global DISABLE_SEM
88 global DISABLE_BY_MONTHLY_LIMIT 90 global DISABLE_BY_MONTHLY_LIMIT
89 global PRODUCTS 91 global PRODUCTS
90 global LAST_PRODUCT 92 global LAST_PRODUCT
91 93
92 logger.info(u'Incoming SMS from: {0}; Time: {1}; Message: {2}'.format(sms.number, sms.time, sms.text)) 94 logger.info(u'Incoming SMS from: {0}; Time: {1}; Message: {2}'.format(sms.number, sms.time, sms.text))
93 95
94 if not xltunai.isValidSender(sms.number): 96 if not xltunai.isValidSender(sms.number):
95 logger.info('Ignoring incoming SMS from invalid sender') 97 logger.info('Ignoring incoming SMS from invalid sender')
96 return 98 return
97 99
98 if sms.text.find('Terimakasih, transaksi CASH IN ke akun') >= 0: 100 if sms.text.find('Terimakasih, transaksi CASH IN ke akun') >= 0:
99 logger.info('handleSms: CASH IN, aktivasi pull jika non aktif') 101 logger.info('handleSms: CASH IN, aktivasi pull jika non aktif')
100 enablePull() 102 enablePull()
101 return 103 return
102 104
103 if sms.text.find('Maaf, transaksi gagal') >= 0: 105 if sms.text.find('Maaf, transaksi gagal') >= 0:
104 pushTopupStatus(LAST_REQUEST_ID, '40', sms.text) 106 pushTopupStatus(LAST_REQUEST_ID, '40', sms.text)
105 return 107 return
106 108
107 elif sms.text.find('PIN yang Anda masukkan salah. Silahkan ulangi kembali') >= 0: 109 elif sms.text.find('PIN yang Anda masukkan salah. Silahkan ulangi kembali') >= 0:
108 pushTopupStatus(LAST_REQUEST_ID, '91', sms.text) 110 pushTopupStatus(LAST_REQUEST_ID, '91', sms.text)
109 return 111 return
110 112
111 elif sms.text.find('Maaf, layanan ini hanya untuk nomor tujuan prabayar XL') >= 0: 113 elif sms.text.find('Maaf, layanan ini hanya untuk nomor tujuan prabayar XL') >= 0:
112 pushTopupStatus(LAST_REQUEST_ID, '14', sms.text) 114 pushTopupStatus(LAST_REQUEST_ID, '14', sms.text)
113 return 115 return
114 116
115 elif sms.text.find('Mohon maaf, nomor yang Anda masukkan tidak valid') >= 0: 117 elif sms.text.find('Mohon maaf, nomor yang Anda masukkan tidak valid') >= 0:
116 pushTopupStatus(LAST_REQUEST_ID, '14', sms.text) 118 pushTopupStatus(LAST_REQUEST_ID, '14', sms.text)
117 return 119 return
118 120
119 elif sms.text.find('Mohon maaf, transaksi Anda melebihi limit nominal bulanan') >= 0: 121 elif sms.text.find('Mohon maaf, transaksi Anda melebihi limit nominal bulanan') >= 0:
120 pushTopupStatus(LAST_REQUEST_ID, '40', sms.text) 122 pushTopupStatus(LAST_REQUEST_ID, '40', sms.text)
121 123
122 PRODUCTS = sate24.removeProduct(PRODUCTS, LAST_PRODUCT) 124 PRODUCTS = sate24.removeProduct(PRODUCTS, LAST_PRODUCT)
123 logger.warning('Monthly limit for "{0}" exceeded. New active products: "{1}"'.format(LAST_PRODUCT, PRODUCTS)) 125 logger.warning('Monthly limit for "{0}" exceeded. New active products: "{1}"'.format(LAST_PRODUCT, PRODUCTS))
124 126
125 #logger.warning('PAUSED, monthly limit exceeded') 127 #logger.warning('PAUSED, monthly limit exceeded')
126 #DISABLE_BY_MONTHLY_LIMIT = True 128 #DISABLE_BY_MONTHLY_LIMIT = True
127 return 129 return
128 130
129 elif sms.text.find('Maaf, transaksi Anda masih dalam proses') >= 0: 131 elif sms.text.find('Maaf, transaksi Anda masih dalam proses') >= 0:
130 pushTopupStatus(LAST_REQUEST_ID, '68', sms.text) 132 pushTopupStatus(LAST_REQUEST_ID, '68', sms.text)
131 return 133 return
132 134
133 destination = xltunai.getDestinationFromMessage(sms.text) 135 destination = xltunai.getDestinationFromMessage(sms.text)
134 if destination == '': 136 if destination == '':
135 logger.warning('handleSms: gagal parsing nomor tujuan') 137 logger.warning('handleSms: gagal parsing nomor tujuan')
136 return 138 return
137 139
138 nominal = xltunai.getNominalFromMessage(sms.text) 140 nominal = xltunai.getNominalFromMessage(sms.text)
139 if nominal == '': 141 if nominal == '':
140 logger.warning('handleSms: gagal parsing nominal') 142 logger.warning('handleSms: gagal parsing nominal')
141 return 143 return
142 144
143 sn = xltunai.getSNFromMessage(sms.text) 145 sn = xltunai.getSNFromMessage(sms.text)
144 if sn == '': 146 if sn == '':
145 logger.warning('handleSms: gagal parsing SN') 147 logger.warning('handleSms: gagal parsing SN')
146 148
147 149
148 DISABLE_SEM = 0 150 DISABLE_SEM = 0
149 151
150 response_code = xltunai.getResponseCodeByMessage(sms.text) 152 response_code = xltunai.getResponseCodeByMessage(sms.text)
151 153
152 request_id = getRequestIdByNominalDestination(nominal, destination) 154 request_id = getRequestIdByNominalDestination(nominal, destination)
153 if not request_id: 155 if not request_id:
154 logger.info('Unknown request id for nominal:{0} destination:{1}'.format(nominal, destination)) 156 logger.info('Unknown request id for nominal:{0} destination:{1}'.format(nominal, destination))
155 return 157 return
156 158
157 pushTopupStatus(request_id, response_code, sms.text) 159 pushTopupStatus(request_id, response_code, sms.text)
158 try: 160 try:
159 deleteMultipleStoredSms(2) 161 deleteMultipleStoredSms(2)
160 except: 162 except:
161 #logger.warning('Failed on delete SMS') 163 #logger.warning('Failed on delete SMS')
162 pass 164 pass
163 165
164 166
165 def getRequestIdByNominalDestination(nominal, destination): 167 def getRequestIdByNominalDestination(nominal, destination):
166 redis_key = sate24.keyByNominalDestination(CHIPINFO, nominal, destination) 168 redis_key = sate24.keyByNominalDestination(CHIPINFO, nominal, destination)
167 #return redis_client.spop(redis_key) 169 #return redis_client.spop(redis_key)
168 return redis_client.rpop(redis_key) 170 return redis_client.rpop(redis_key)
169 171
170 def pushTopupStatus(request_id, response_code, _message, dontparsesn = False): 172 def pushTopupStatus(request_id, response_code, _message, dontparsesn = False):
171 global BALANCE 173 global BALANCE
172 global CHIPINFO 174 global CHIPINFO
173 175
174 redis_key = sate24.keyByRequestId(CHIPINFO, request_id) + '.response_code' 176 redis_key = sate24.keyByRequestId(CHIPINFO, request_id) + '.response_code'
175 if response_code == '00': 177 if response_code == '00':
176 redis_client.set(redis_key, response_code) 178 redis_client.set(redis_key, response_code)
177 else: 179 else:
178 redis_response_code = redis_client.get(redis_key) 180 redis_response_code = redis_client.get(redis_key)
179 if redis_response_code == '00': 181 if redis_response_code == '00':
180 logger.info('Ignoring message from success trx ') 182 logger.info('Ignoring message from success trx ')
181 return 183 return
182 184
183 message = "{0} -- Prev balance: {1}".format(_message, BALANCE) 185 message = "{0} -- Prev balance: {1}".format(_message, BALANCE)
184 186
185 timestamp = strftime('%Y%m%d%H%M%S') 187 timestamp = strftime('%Y%m%d%H%M%S')
186 188
187 if response_code == '00' and not dontparsesn: 189 if response_code == '00' and not dontparsesn:
188 sn = xltunai.getSNFromMessage(message) 190 sn = xltunai.getSNFromMessage(message)
189 LAST_SN = sn 191 LAST_SN = sn
190 message = 'SN={0};{1}'.format(sn, message) 192 message = 'SN={0};{1}'.format(sn, message)
191 193
192 push_message = CHIPINFO + '$' + message 194 push_message = CHIPINFO + '$' + message
193 195
194 payload = { 196 payload = {
195 'trans_id': request_id, 197 'trans_id': request_id,
196 'trans_date': timestamp, 198 'trans_date': timestamp,
197 'resp_code': response_code, 199 'resp_code': response_code,
198 'ussd_msg': push_message 200 'ussd_msg': push_message
199 } 201 }
200 202
201 url = AAA_HOST + '/topup' 203 url = AAA_HOST + '/topup'
202 204
203 try: 205 try:
204 logger.info('Sending topup status to AAA') 206 logger.info('Sending topup status to AAA')
205 logger.info(payload) 207 logger.info(payload)
206 r = requests.get(url, params=payload) 208 r = requests.get(url, params=payload)
207 except: 209 except:
208 logger.warning('Error sending topup status to AAA') 210 logger.warning('Error sending topup status to AAA')
209 211
210 try: 212 try:
211 # publish echi topup report ke redis 213 # publish echi topup report ke redis
212 echi_key = 'echi.topup_report.gw:' + BASE_CHIPINFO 214 echi_key = 'echi.topup_report.gw:' + BASE_CHIPINFO
213 215
214 redis_client.publish(echi_key + '.json', json.dumps(payload)) 216 redis_client.publish(echi_key + '.json', json.dumps(payload))
215 217
216 echi_message = timestamp + ' - ' + response_code + ' - ' + message 218 echi_message = timestamp + ' - ' + response_code + ' - ' + message
217 redis_client.publish(echi_key + '.message', echi_message) 219 redis_client.publish(echi_key + '.message', echi_message)
218 except: 220 except:
219 logger.warning('Error publishing topup report to redis') 221 logger.warning('Error publishing topup report to redis')
220 222
221 def getIsDisableRedisKey(): 223 def getIsDisableRedisKey():
222 return CHIPINFO + '.pulldisable' 224 return CHIPINFO + '.pulldisable'
223 225
224 def isPullEnable(): 226 def isPullEnable():
225 redis_key = getIsDisableRedisKey() 227 redis_key = getIsDisableRedisKey()
226 result = 'FALSE' 228 result = 'FALSE'
227 229
228 try: 230 try:
229 result = redis_client.get(redis_key) 231 result = redis_client.get(redis_key)
230 redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL) 232 redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL)
231 except: 233 except:
232 return False 234 return False
233 235
234 if not result: 236 if not result:
235 return True 237 return True
236 238
237 return result == 'FALSE' 239 return result == 'FALSE'
238 240
239 def enablePull(): 241 def enablePull():
240 logger.info('Enabling Pull on products {0}'.format(PRODUCTS)) 242 logger.info('Enabling Pull on products {0}'.format(PRODUCTS))
241 redis_key = getIsDisableRedisKey() 243 redis_key = getIsDisableRedisKey()
242 try: 244 try:
243 redis_client.set(redis_key, 'FALSE') 245 redis_client.set(redis_key, 'FALSE')
244 redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL) 246 redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL)
245 except: 247 except:
246 return 248 return
247 249
248 def disablePull(): 250 def disablePull():
249 global DISABLE_SEM 251 global DISABLE_SEM
250 global DISABLE_SEM_ON_TRX 252 global DISABLE_SEM_ON_TRX
251 253
252 logger.info('Disabling Pull') 254 logger.info('Disabling Pull')
253 redis_key = getIsDisableRedisKey() 255 redis_key = getIsDisableRedisKey()
254 try: 256 try:
255 redis_client.set(redis_key, 'TRUE') 257 redis_client.set(redis_key, 'TRUE')
256 redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL) 258 redis_client.expire(redis_key, REDIS_DISABLE_PULL_TTL)
257 except: 259 except:
258 return 260 return
259 261
260 def adviceLastSN(requestId, modem): 262 def adviceLastSN(requestId, modem):
261 global DISABLE_SEM 263 global DISABLE_SEM
262 global LAST_SN 264 global LAST_SN
263 global TOPUP_USSD_TIMEOUT 265 global TOPUP_USSD_TIMEOUT
264 266
265 ussd_command = xltunai.getHistoryUSSDCommand() 267 ussd_command = xltunai.getHistoryUSSDCommand()
266 268
267 logger.info(u'Executing advice {0}'.format(ussd_command)) 269 logger.info(u'Executing advice {0}'.format(ussd_command))
268 try: 270 try:
269 response = modem.sendUssd(ussd_command, TOPUP_USSD_TIMEOUT) 271 response = modem.sendUssd(ussd_command, TOPUP_USSD_TIMEOUT)
270 272
271 message = response.message.strip() 273 message = response.message.strip()
272 logger.info(u'USSD response: {0}'.format(message)) 274 logger.info(u'USSD response: {0}'.format(message))
273 275
274 lastSNFromHistory = xltunai.getLastSNFromHistoryMessage(message) 276 lastSNFromHistory = xltunai.getLastSNFromHistoryMessage(message)
275 277
276 if response.sessionActive: 278 if response.sessionActive:
277 response.cancel() 279 response.cancel()
278 280
279 if not lastSNFromHistory: 281 if not lastSNFromHistory:
280 if DISABLE_SEM: 282 if DISABLE_SEM:
281 logger.info('Failed to get last sn from history, retrying in 15 secs') 283 logger.info('Failed to get last sn from history, retrying in 15 secs')
282 sleep(15) 284 sleep(15)
283 adviceLastSN(requestid, modem) 285 adviceLastSN(requestid, modem)
284 286
285 elif lastSNFromHistory == LAST_SN: 287 elif lastSNFromHistory == LAST_SN:
286 topupMessage = "Topup gagal berdasarkan advice. {0} = {1}. {2}".format(lastSNFromHistory, LAST_SN, message) 288 topupMessage = "Topup gagal berdasarkan advice. {0} = {1}. {2}".format(lastSNFromHistory, LAST_SN, message)
287 pushTopupStatus(requestId, '40', topupMessage) 289 pushTopupStatus(requestId, '40', topupMessage)
288 DISABLE_SEM = 0 290 DISABLE_SEM = 0
289 291
290 292
291 else: 293 else:
292 topupMessage = "SN={0}; Topup berhasil berdasarkan advice. {1}".format(lastSNFromHistory, message) 294 topupMessage = "SN={0}; Topup berhasil berdasarkan advice. {1}".format(lastSNFromHistory, message)
293 LAST_SN = lastSNFromHistory 295 LAST_SN = lastSNFromHistory
294 pushTopupStatus(requestId, '00', topupMessage, True) 296 pushTopupStatus(requestId, '00', topupMessage, True)
295 DISABLE_SEM = 0 297 DISABLE_SEM = 0
296 298
297 except: 299 except:
298 message = "USSD Error: Something wrong when executing USSD advice" 300 message = "USSD Error: Something wrong when executing USSD advice"
299 logger.warning(message) 301 logger.warning(message)
300 pushTopupStatus(requestId, '68', message) 302 pushTopupStatus(requestId, '68', message)
301 303
302 sleep(60) 304 sleep(60)
303 adviceLastSN(requestid, modem) 305 adviceLastSN(requestid, modem)
304 #waitForResultSmsAfterUssdError(modem, task['requestId'], message) 306 #waitForResultSmsAfterUssdError(modem, task['requestId'], message)
305 return 307 return
306 308
307 309
308 310
309 def topupTask(task, modem): 311 def topupTask(task, modem):
310 global LAST_REQUEST_ID 312 global LAST_REQUEST_ID
311 313
312 if not task: 314 if not task:
313 return 315 return
314 316
315 if task['status'] != 'OK': 317 if task['status'] != 'OK':
316 return 318 return
317 319
318 LAST_REQUEST_ID = task['requestId'] 320 LAST_REQUEST_ID = task['requestId']
319 LAST_PRODUCT = task['product'] 321 LAST_PRODUCT = task['product']
320 322
321 checkSignal(modem) 323 checkSignal(modem)
322 324
323 redis_key = sate24.keyByRequestId(CHIPINFO, task['requestId']) 325 redis_key = sate24.keyByRequestId(CHIPINFO, task['requestId'])
324 redis_client.set(redis_key, task) 326 redis_client.set(redis_key, task)
325 redis_client.expire(redis_key, REDIS_TTL) 327 redis_client.expire(redis_key, REDIS_TTL)
326 328
327 nominal = xltunai.getNominalFromProduct(task['product']) 329 nominal = xltunai.getNominalFromProduct(task['product'])
328 intl_destination = xltunai.toInternationalNumber(task['destination']) 330 intl_destination = xltunai.toInternationalNumber(task['destination'])
329 331
330 redis_key = sate24.keyByNominalDestination(CHIPINFO, nominal, intl_destination) 332 redis_key = sate24.keyByNominalDestination(CHIPINFO, nominal, intl_destination)
331 #redis_client.sadd(redis_key, task['requestId']) 333 #redis_client.sadd(redis_key, task['requestId'])
332 try: 334 try:
333 redis_client.rpush(redis_key, task['requestId']) 335 redis_client.rpush(redis_key, task['requestId'])
334 except: 336 except:
335 redis_client.delete(redis_key) 337 redis_client.delete(redis_key)
336 redis_client.rpush(redis_key, task['requestId']) 338 redis_client.rpush(redis_key, task['requestId'])
337 finally: 339 finally:
338 redis_client.expire(redis_key, REDIS_TTL) 340 redis_client.expire(redis_key, REDIS_TTL)
339 341
340 #pushTopupStatus(task['requestId'], '68', 'Siap mengirimkan trx ke operator') 342 #pushTopupStatus(task['requestId'], '68', 'Siap mengirimkan trx ke operator')
341 343
342 message = 'Executing USSD' 344 message = 'Executing USSD'
343 response_code = '68' 345 response_code = '68'
344 346
345 ussd_command = xltunai.getTopupUSSDCommand(task['destination'], task['product'], PIN_TRX) 347 ussd_command = xltunai.getTopupUSSDCommand(task['destination'], task['product'], PIN_TRX)
346 348
347 logger.info(u'Executing {0}'.format(ussd_command)) 349 logger.info(u'Executing {0}'.format(ussd_command))
348 try: 350 try:
349 response = modem.sendUssd(ussd_command, TOPUP_USSD_TIMEOUT) 351 response = modem.sendUssd(ussd_command, TOPUP_USSD_TIMEOUT)
350 352
351 message = response.message.strip() 353 message = response.message.strip()
352 logger.info(u'USSD response: {0}'.format(message)) 354 logger.info(u'USSD response: {0}'.format(message))
353 355
354 response_code = xltunai.getResponseCodeByUSSDResponse(message) 356 response_code = xltunai.getResponseCodeByUSSDResponse(message)
355 357
356 if response.sessionActive: 358 if response.sessionActive:
357 response.cancel() 359 response.cancel()
358 360
359 except TimeoutException: 361 except TimeoutException:
360 message = "USSD Error: Timeout when executing USSD topup" 362 message = "USSD Error: Timeout when executing USSD topup"
361 logger.warning(message) 363 logger.warning(message)
362 pushTopupStatus(task['requestId'], '68', message) 364 pushTopupStatus(task['requestId'], '68', message)
363 #waitForResultSmsAfterUssdError(modem, task['requestId'], message) 365 #waitForResultSmsAfterUssdError(modem, task['requestId'], message)
364 sleep(15) 366 sleep(15)
365 adviceLastSN(task['requestId'], modem) 367 adviceLastSN(task['requestId'], modem)
366 return 368 return
367 except: 369 except:
368 message = "USSD Error: Something wrong when executing USSD topup" 370 message = "USSD Error: Something wrong when executing USSD topup"
369 logger.warning(message) 371 logger.warning(message)
370 pushTopupStatus(task['requestId'], '68', message) 372 pushTopupStatus(task['requestId'], '68', message)
371 #waitForResultSmsAfterUssdError(modem, task['requestId'], message) 373 #waitForResultSmsAfterUssdError(modem, task['requestId'], message)
372 sleep(15) 374 sleep(15)
373 adviceLastSN(task['requestId'], modem) 375 adviceLastSN(task['requestId'], modem)
374 return 376 return
375 377
376 DISABLE_SEM = DISABLE_SEM_ON_TRX 378 DISABLE_SEM = DISABLE_SEM_ON_TRX
377 pushTopupStatus(task['requestId'], response_code, message) 379 pushTopupStatus(task['requestId'], response_code, message)
378 380
379 def waitForResultSmsAfterUssdError(modem, request_id, last_error_message = ''): 381 def waitForResultSmsAfterUssdError(modem, request_id, last_error_message = ''):
380 logger.info('Sleeping for {0} seconds after an USSD error'.format(SLEEP_AFTER_USSD_ERROR)) 382 logger.info('Sleeping for {0} seconds after an USSD error'.format(SLEEP_AFTER_USSD_ERROR))
381 sleep(SLEEP_AFTER_USSD_ERROR) 383 sleep(SLEEP_AFTER_USSD_ERROR)
382 384
383 redis_key = sate24.keyByRequestId(CHIPINFO, request_id) + '.response_code' 385 redis_key = sate24.keyByRequestId(CHIPINFO, request_id) + '.response_code'
384 response_code = redis_client.get(redis_key) 386 response_code = redis_client.get(redis_key)
385 387
386 if response_code == '68' or response_code == None: 388 if response_code == '68' or response_code == None:
387 389
388 prev_balance = BALANCE 390 prev_balance = BALANCE
389 current_balance = checkBalance(modem, do_not_update = True, return_result = True) 391 current_balance = checkBalance(modem, do_not_update = True, return_result = True)
390 392
391 if current_balance == 0: 393 if current_balance == 0:
392 return 394 return
393 395
394 if current_balance < prev_balance: 396 if current_balance < prev_balance:
395 delta = prev_balance - current_balance 397 delta = prev_balance - current_balance
396 pushTopupStatus( 398 pushTopupStatus(
397 request_id, 399 request_id,
398 '00', 400 '00',
399 'Transaksi dianggap sukses karena saldo berkurang {0}. Last error message: {1}'.format( 401 'Transaksi dianggap sukses karena saldo berkurang {0}. Last error message: {1}'.format(
400 delta, 402 delta,
401 last_error_message 403 last_error_message
402 ) 404 )
403 ) 405 )
404 else: 406 else:
405 pushTopupStatus( 407 pushTopupStatus(
406 request_id, 408 request_id,
407 '40', 409 '40',
408 'Transaksi dianggap gagal karena saldo tidak berkurang. Last error message: {0}'.format(last_error_message) 410 'Transaksi dianggap gagal karena saldo tidak berkurang. Last error message: {0}'.format(last_error_message)
409 ) 411 )
410 412
411 def _saveBalanceToRedis(balance_key, balance_value): 413 def _saveBalanceToRedis(balance_key, balance_value):
412 try: 414 try:
413 redis_client.set(balance_key, balance_value) 415 redis_client.set(balance_key, balance_value)
414 redis_client.expire(balance_key, 3600*24*60) 416 redis_client.expire(balance_key, 3600*24*60)
415 except: 417 except:
416 logger.warning('Failed to save balance to redis') 418 logger.warning('Failed to save balance to redis')
417 419
418 def saveBalanceToRedis(balance): 420 def saveBalanceToRedis(balance):
419 global BASE_CHIPINFO 421 global BASE_CHIPINFO
420 global CHIPINFO 422 global CHIPINFO
421 global MSISDN 423 global MSISDN
422 424
423 try: 425 try:
424 balance = int(balance) 426 balance = int(balance)
425 except ValueError: 427 except ValueError:
426 return 428 return
427 429
428 430
429 data = { 431 data = {
430 'balance.gw:' + BASE_CHIPINFO: balance, 432 'balance.gw:' + BASE_CHIPINFO: balance,
431 'balance.gw:' + CHIPINFO: balance, 433 'balance.gw:' + CHIPINFO: balance,
432 'balance.gw:' + MSISDN: balance 434 'balance.gw:' + MSISDN: balance
433 } 435 }
434 436
435 redis_pipe = redis_client.pipeline() 437 redis_pipe = redis_client.pipeline()
436 438
437 try: 439 try:
438 redis_pipe.mset(data) 440 redis_pipe.mset(data)
439 441
440 for k in data: 442 for k in data:
441 redis_pipe.expire(k, 3600 * 24 * 60) 443 redis_pipe.expire(k, 3600 * 24 * 60)
442 444
443 except: 445 except:
444 logger.warning('Failed to save balance to redis') 446 logger.warning('Failed to save balance to redis')
445 finally: 447 finally:
446 redis_pipe.execute() 448 redis_pipe.execute()
447 449
448 def saveSignalStrengthToRedis(value): 450 def saveSignalStrengthToRedis(value):
449 global BASE_CHIPINFO 451 global BASE_CHIPINFO
450 global CHIPINFO 452 global CHIPINFO
451 global MSISDN 453 global MSISDN
452 454
453 try: 455 try:
454 redis_pipe = redis_client.pipeline() 456 redis_pipe = redis_client.pipeline()
455 redis_client.set('balance.gw:' + BASE_CHIPINFO + '.signal', value) 457 redis_client.set('balance.gw:' + BASE_CHIPINFO + '.signal', value)
456 redis_client.expire('balance.gw:' + BASE_CHIPINFO + '.signal', 3600 * 24 * 60) 458 redis_client.expire('balance.gw:' + BASE_CHIPINFO + '.signal', 3600 * 24 * 60)
457 except: 459 except:
458 logger.warning('Failed to save signal strength to redis') 460 logger.warning('Failed to save signal strength to redis')
459 461
460 462
461 def pull(modem): 463 def pull(modem):
462 global PRODUCTS 464 global PRODUCTS
463 global PULL_COUNT 465 global PULL_COUNT
464 global BALANCE 466 global BALANCE
465 global DISABLE_SEM 467 global DISABLE_SEM
466 global MIN_SIGNAL_STRENGTH 468 global MIN_SIGNAL_STRENGTH
467 469
468 if not PRODUCTS: 470 if not PRODUCTS:
469 return 471 return
470 472
471 signalStrength = modem.signalStrength 473 signalStrength = modem.signalStrength
472 if signalStrength < MIN_SIGNAL_STRENGTH: 474 if signalStrength < MIN_SIGNAL_STRENGTH:
473 logger.warn('Signal strength {0} < {1}, skipping pull'.format(signalStrength, MIN_SIGNAL_STRENGTH)) 475 logger.warn('Signal strength {0} < {1}, skipping pull'.format(signalStrength, MIN_SIGNAL_STRENGTH))
474 return 476 return
475 477
476 pull_per_minute = 60 / PULL_INTERVAL 478 pull_per_minute = 60 / PULL_INTERVAL
477 479
478 PULL_COUNT += 1 480 PULL_COUNT += 1
479 if PULL_COUNT % (5 * pull_per_minute) == 0: 481 if PULL_COUNT % (5 * pull_per_minute) == 0:
480 checkBalance(modem) 482 checkBalance(modem)
481 sleep(15) 483 sleep(15)
482 PULL_COUNT = 0 484 PULL_COUNT = 0
483 485
484 if DISABLE_SEM > 0: 486 if DISABLE_SEM > 0:
485 logger.info('SEMAPHORE is still on, delaying pull') 487 logger.info('SEMAPHORE is still on, delaying pull')
486 DISABLE_SEM -= 1 488 DISABLE_SEM -= 1
487 return 489 return
488 490
489 if not isPullEnable(): 491 if not isPullEnable():
490 return 492 return
491 493
492 r = None 494 r = None
493 url = AAA_HOST + '/pull?city=' + CITY + '&nom=' + PRODUCTS 495 url = AAA_HOST + '/pull?city=' + CITY + '&nom=' + PRODUCTS
494 try: 496 try:
495 r = requests.get(url) 497 r = requests.get(url)
496 except: 498 except:
497 logger.warning("Error requesting to AAA") 499 logger.warning("Error requesting to AAA")
498 return 500 return
499 501
500 if not r: 502 if not r:
501 return 503 return
502 504
503 task = sate24.parsePullMessage(r.text) 505 task = sate24.parsePullMessage(r.text)
504 506
505 if task['status'] == 'OK': 507 if task['status'] == 'OK':
506 508
507 logger.info('PULL ' + url + ' => ' + r.text) 509 logger.info('PULL ' + url + ' => ' + r.text)
508 publishAAATaskToRedis(task) 510 publishAAATaskToRedis(task)
509 511
510 if not checkBalance(modem) or BALANCE == 0: 512 if not checkBalance(modem) or BALANCE == 0:
511 pushTopupStatus(task['requestId'], '91', 'Transaksi dibatalkan karena gagal check balance') 513 pushTopupStatus(task['requestId'], '91', 'Transaksi dibatalkan karena gagal check balance')
512 sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP) 514 sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP)
513 return 515 return
514 516
515 sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP) 517 sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP)
516 518
517 topupTask(task, modem) 519 topupTask(task, modem)
518 sleep(SLEEP_AFTER_TOPUP) 520 sleep(SLEEP_AFTER_TOPUP)
519 521
520 def publishAAATaskToRedis(task): 522 def publishAAATaskToRedis(task):
521 try: 523 try:
522 key = 'kimochi.aaa_pull.gw:' + BASE_CHIPINFO 524 key = 'kimochi.aaa_pull.gw:' + BASE_CHIPINFO
523 plain_text = task['timestamp'] + ' - ' + task['member'] + ' isi ' + task['product'] + ' ke ' + task['destination']; 525 plain_text = task['timestamp'] + ' - ' + task['member'] + ' isi ' + task['product'] + ' ke ' + task['destination'];
524 526
525 redis_client.publish(key + '.json', json.dumps(task)) 527 redis_client.publish(key + '.json', json.dumps(task))
526 redis_client.publish(key + '.text', plain_text); 528 redis_client.publish(key + '.text', plain_text);
527 except: 529 except:
528 logger.warning('Error publishing kimochi') 530 logger.warning('Error publishing kimochi')
529 531
530 def publishMessageToRedis(): 532 def publishMessageToRedis():
531 pass 533 pass
532 534
533 def pullLoop(modem): 535 def pullLoop(modem):
534 global DISABLE_BY_MONTHLY_LIMIT 536 global DISABLE_BY_MONTHLY_LIMIT
535 global TERMINATING 537 global TERMINATING
536 538
537 while not DISABLE_BY_MONTHLY_LIMIT: 539 while not DISABLE_BY_MONTHLY_LIMIT:
538 signalStrength = modem.signalStrength 540 signalStrength = modem.signalStrength
539 saveSignalStrengthToRedis(signalStrength) 541 saveSignalStrengthToRedis(signalStrength)
540 542
541 if TERMINATING: 543 if TERMINATING:
542 logger.info('Terminated by request signal') 544 logger.info('Terminated by request signal')
543 sys.exit(0) 545 sys.exit(0)
544 546
545 sleep(PULL_INTERVAL) 547 sleep(PULL_INTERVAL)
546 548
547 def checkSignal(modem): 549 def checkSignal(modem):
548 logger.info('Signal: {0}'.format(modem.signalStrength)) 550 logger.info('Signal: {0}'.format(modem.signalStrength))
549 try: 551 try:
550 redis_client.set(CHIPINFO + '.signal', modem.signalStrength) 552 redis_client.set(CHIPINFO + '.signal', modem.signalStrength)
551 redis_client.expire(CHIPINFO + '.signal', 3600*24) 553 redis_client.expire(CHIPINFO + '.signal', 3600*24)
552 except: 554 except:
553 logger.warning("Can not save signal strength to redis") 555 logger.warning("Can not save signal strength to redis")
554 556
555 def checkAccount(modem): 557 def checkAccount(modem):
556 try: 558 try:
557 ussd_string = '*123*120*8*3#' 559 ussd_string = '*123*120*8*3#'
558 response = modem.sendUssd(ussd_string, 30) 560 response = modem.sendUssd(ussd_string, 30)
559 logger.info('Account Info: {0}'.format(response.message)) 561 logger.info('Account Info: {0}'.format(response.message))
560 562
561 if response.sessionActive: 563 if response.sessionActive:
562 response.cancel() 564 response.cancel()
563 except: 565 except:
564 logger.warning('Error when requesting account info') 566 logger.warning('Error when requesting account info')
565 return False 567 return False
566 568
567 def checkBalance(modem, do_not_update = False, return_result = False): 569 def checkBalance(modem, do_not_update = False, return_result = False):
568 global BALANCE 570 global BALANCE
569 571
570 _BALANCE = 0 572 _BALANCE = 0
571 573
572 try: 574 try:
573 575
574 ussd_string = '*123*120#' 576 ussd_string = '*123*120#'
575 response = modem.sendUssd(ussd_string, 30) 577 response = modem.sendUssd(ussd_string, 30)
576 _BALANCE = xltunai.getBalanceFromUSSDResponse(response.message) 578 _BALANCE = xltunai.getBalanceFromUSSDResponse(response.message)
577 579
578 if not do_not_update: 580 if not do_not_update:
579 BALANCE = _BALANCE 581 BALANCE = _BALANCE
580 saveBalanceToRedis(BALANCE) 582 saveBalanceToRedis(BALANCE)
581 583
582 logger.info('Balance: {0}'.format(_BALANCE)) 584 logger.info('Balance: {0}'.format(_BALANCE))
583 if response.sessionActive: 585 if response.sessionActive:
584 response.cancel() 586 response.cancel()
585 587
586 if _BALANCE != 0 and _BALANCE < MIN_BALANCE: 588 if _BALANCE != 0 and _BALANCE < MIN_BALANCE:
587 logger.info('Disabling pull, balance {0} < {1}'.format(_BALANCE, MIN_BALANCE)) 589 logger.info('Disabling pull, balance {0} < {1}'.format(_BALANCE, MIN_BALANCE))
588 disablePull() 590 disablePull()
589 591
590 except: 592 except:
591 logger.warning('Error when requesting BALANCE by USSD') 593 logger.warning('Error when requesting BALANCE by USSD')
592 if return_result: 594 if return_result:
593 return 0 595 return 0
594 else: 596 else:
595 return False 597 return False
596 598
597 try: 599 try:
598 redis_client.set(CHIPINFO + '.balance', BALANCE) 600 redis_client.set(CHIPINFO + '.balance', BALANCE)
599 except: 601 except:
600 logger.warning('Failed to save balance to redis') 602 logger.warning('Failed to save balance to redis')
601 603
602 if return_result: 604 if return_result:
603 return _BALANCE 605 return _BALANCE
604 else: 606 else:
605 return True 607 return True
606 608
607 def getPulsaInfo(modem): 609 def getPulsaInfo(modem):
608 global PULSA 610 global PULSA
609 global MASA_AKTIF 611 global MASA_AKTIF
610 612
611 try: 613 try:
612 ussd_string = "*123#" 614 ussd_string = "*123#"
613 response = modem.sendUssd(ussd_string) 615 response = modem.sendUssd(ussd_string)
614 616
615 message = response.message.strip() 617 message = response.message.strip()
616 logger.info('PULSA: {0}'.format(message)) 618 logger.info('PULSA: {0}'.format(message))
617 if response.sessionActive: 619 if response.sessionActive:
618 response.cancel() 620 response.cancel()
619 621
620 PULSA = xltunai.getPulsaFromUssdResponseMessage(message) 622 PULSA = xltunai.getPulsaFromUssdResponseMessage(message)
621 MASA_AKTIF =xltunai.getMasaAktifFromUssdResponseMessage(message) 623 MASA_AKTIF =xltunai.getMasaAktifFromUssdResponseMessage(message)
622 logger.info('PULSA: {0} -- MASA AKTIF: {1}'.format(PULSA, MASA_AKTIF)) 624 logger.info('PULSA: {0} -- MASA AKTIF: {1}'.format(PULSA, MASA_AKTIF))
623 625
624 return message 626 return message
625 627
626 except: 628 except:
627 logger.warning('Error when requesting pulsa info by USSD') 629 logger.warning('Error when requesting pulsa info by USSD')
628 return '' 630 return ''
629 631
630 def getSIMCardInfo(modem): 632 def getSIMCardInfo(modem):
631 try: 633 try:
632 ussd_string = xltunai.getSIMCardInfoUSSDCommand() 634 ussd_string = xltunai.getSIMCardInfoUSSDCommand()
633 response = modem.sendUssd(ussd_string) 635 response = modem.sendUssd(ussd_string)
634 636
635 message = response.message.strip() 637 message = response.message.strip()
636 logger.info('SIM INFO: {0}'.format(message)) 638 logger.info('SIM INFO: {0}'.format(message))
637 if response.sessionActive: 639 if response.sessionActive:
638 response.cancel() 640 response.cancel()
639 641
640 return message 642 return message
641 643
642 except: 644 except:
643 logger.warning('Error when requesting SIM card info by USSD') 645 logger.warning('Error when requesting SIM card info by USSD')
644 return '' 646 return ''
645 647
646 def updateChipInfo(msisdn): 648 def updateChipInfo(msisdn):
647 global BASE_CHIPINFO 649 global BASE_CHIPINFO
648 global CHIPINFO 650 global CHIPINFO
649 global MSISDN 651 global MSISDN
650 652
651 MSISDN = msisdn 653 MSISDN = msisdn
652 if CHIPINFO.find(msisdn) == -1: 654 if CHIPINFO.find(msisdn) == -1:
653 CHIPINFO = BASE_CHIPINFO + '-' + msisdn 655 CHIPINFO = BASE_CHIPINFO + '-' + msisdn
654 656
655 logger.info('CHIPINFO: {0}'.format(CHIPINFO)) 657 logger.info('CHIPINFO: {0}'.format(CHIPINFO))
656 658
657 def main(): 659 def main():
658 global logger 660 global logger
659 661
660 log_format = '%(asctime)s %(levelname)s: %(message)s' 662 log_format = '%(asctime)s %(levelname)s: %(message)s'
661 663
662 logging.basicConfig(format=log_format, level=logging.INFO) 664 logging.basicConfig(format=log_format, level=logging.INFO)
663 logger = logging.getLogger(__name__) 665 logger = logging.getLogger(__name__)
664 666
665 logger_formatter = logging.Formatter(log_format) 667 logger_formatter = logging.Formatter(log_format)
666 logger_handler = TimedRotatingFileHandler('logs/log', when='midnight') 668 logger_handler = TimedRotatingFileHandler('logs/log', when='midnight')
667 logger_handler.setFormatter(logger_formatter) 669 logger_handler.setFormatter(logger_formatter)
668 logger.addHandler(logger_handler) 670 logger.addHandler(logger_handler)
669 671
670 requests_logger = logging.getLogger('requests') 672 requests_logger = logging.getLogger('requests')
671 requests_logger.setLevel(logging.WARNING) 673 requests_logger.setLevel(logging.WARNING)
672 674
673 logger.info('Initializing modem...') 675 logger.info('Initializing modem...')
674 676
675 modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms) 677 modem = GsmModem(PORT, BAUDRATE, smsReceivedCallbackFunc=handleSms)
676 modem.smsTextMode = True 678 modem.smsTextMode = True
677 modem.connect(PIN) 679 modem.connect(PIN)
678 680
679 logger.info('Waiting for network coverage...') 681 logger.info('Waiting for network coverage...')
680 modem.waitForNetworkCoverage(10) 682 modem.waitForNetworkCoverage(10)
681 683
682 logger.info('Modem ready') 684 logger.info('Modem ready')
683 685
684 getPulsaInfo(modem) 686 getPulsaInfo(modem)
685 sleep(2) 687 sleep(2)
686 688
687 simcard_info = getSIMCardInfo(modem) 689 simcard_info = getSIMCardInfo(modem)
688 msisdn = xltunai.getMSISDNFromSIMCardInfo(simcard_info) 690 msisdn = xltunai.getMSISDNFromSIMCardInfo(simcard_info)
689 imsi = modem.imsi 691 imsi = modem.imsi
690 logger.info('MSISDN: {0} -- IMSI: {1}'.format(msisdn, imsi)) 692 logger.info('MSISDN: {0} -- IMSI: {1}'.format(msisdn, imsi))
691 693
692 updateChipInfo(msisdn) 694 updateChipInfo(msisdn)
693 saveSimCardInfoToRedis(imsi, msisdn) 695 saveSimCardInfoToRedis(imsi, msisdn)
694 696
695 sleep(2) 697 sleep(2)
696 698
697 checkSignal(modem) 699 checkSignal(modem)
698 700
699 logger.info('Process stored SMS') 701 logger.info('Process stored SMS')
700 try: 702 try:
701 modem.processStoredSms() 703 modem.processStoredSms()
702 except: 704 except:
703 logger.warning('Failed on Process stored SMS') 705 logger.warning('Failed on Process stored SMS')
704 706
705 logger.info('Delete stored SMS') 707 logger.info('Delete stored SMS')
706 try: 708 try:
707 modem.deleteMultipleStoredSms() 709 modem.deleteMultipleStoredSms()
708 except: 710 except:
709 #logger.warning('Failed on delete SMS') 711 #logger.warning('Failed on delete SMS')
710 pass 712 pass
711 713
712 sleep(2) 714 sleep(2)
713 715
714 checkAccount(modem) 716 checkAccount(modem)
715 sleep(5) 717 sleep(5)
716 718
717 enablePull() 719 enablePull()
718 720
719 checkBalance(modem) 721 checkBalance(modem)
720 sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP) 722 sleep(SLEEP_BETWEEN_BALANCE_N_TOPUP)
721 723
722 pullLoop(modem) 724 pullLoop(modem)
723 logger.info('Waiting for SMS message...') 725 logger.info('Waiting for SMS message...')
724 try: 726 try:
725 modem.rxThread.join(2**31) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal 727 modem.rxThread.join(2**31) # Specify a (huge) timeout so that it essentially blocks indefinitely, but still receives CTRL+C interrupt signal
726 finally: 728 finally:
727 modem.close(); 729 modem.close();
728 730
729 def saveSimCardInfoToRedis(imsi, msisdn): 731 def saveSimCardInfoToRedis(imsi, msisdn):
730 logger.info('Save sim card info to redis') 732 logger.info('Save sim card info to redis')
731 733
732 data = { 734 data = {
733 'gw': BASE_CHIPINFO, 735 'gw': BASE_CHIPINFO,
734 'imsi': imsi, 736 'imsi': imsi,
735 'msisdn': msisdn, 737 'msisdn': msisdn,
736 'pulsa': PULSA, 738 'pulsa': PULSA,
737 'masa_aktif': MASA_AKTIF 739 'masa_aktif': MASA_AKTIF
738 } 740 }
739 741
740 json_data = json.dumps(data) 742 json_data = json.dumps(data)
741 743
742 map_data = { 744 map_data = {
743 BASE_CHIPINFO + '.simcardinfo': json_data, 745 BASE_CHIPINFO + '.simcardinfo': json_data,
744 'simcardinfo.gw:' + BASE_CHIPINFO: json_data, 746 'simcardinfo.gw:' + BASE_CHIPINFO: json_data,
745 'simcardinfo.imsi:' + imsi: json_data, 747 'simcardinfo.imsi:' + imsi: json_data,
746 'simcardinfo.msisdn:' + msisdn: json_data 748 'simcardinfo.msisdn:' + msisdn: json_data
747 } 749 }
748 750
749 logger.info(map_data) 751 logger.info(map_data)
750 752
751 redis_pipe = redis_client.pipeline() 753 redis_pipe = redis_client.pipeline()
752 754
753 try: 755 try:
754 redis_pipe.mset(map_data) 756 redis_pipe.mset(map_data)
755 757
756 for k in data: 758 for k in data:
757 redis_pipe.expire(k, 3600 * 24 * 60) 759 redis_pipe.expire(k, 3600 * 24 * 60)
758 760
759 except: 761 except:
760 logger.warning('Failed to save simcardinfo to redis') 762 logger.warning('Failed to save simcardinfo to redis')
761 finally: 763 finally:
762 redis_pipe.execute() 764 redis_pipe.execute()
763 765
764 if __name__ == '__main__': 766 if __name__ == '__main__':
765 pidfile = open('pid.txt', 'w') 767 pidfile = open('pid.txt', 'w')
766 pidfile.write(str(getpid())) 768 pidfile.write(str(getpid()))
767 pidfile.close() 769 pidfile.close()
768 770
769 # trap CTRL-C 771 # trap CTRL-C
770 signal.signal(signal.SIGINT, signalHandler) 772 signal.signal(signal.SIGINT, signalHandler)
771 # trap supervisor stop 773 # trap supervisor stop
772 signal.signal(signal.SIGTERM, signalHandler) 774 signal.signal(signal.SIGTERM, signalHandler)
773 775
774 main() 776 main()
775 777