Reload97 / pysate24-xltunai

Download as
Browse Code ยป

Commit 6df004764c39d666a0c9705e4fbf61dd3391f89d

Authored by Adhidarma Hadiwinoto
1 parent 5b4a1904aa
Exists in master

perbaikan nama variabel di adviceLastSN

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