def __init__(self):
super(TopupParser, self).__init__('UNKN', 'INVL', 'TopupParser')
self.agent_manager = ManageAgent(self.dbconn, self.cacheconn)
self.dm = DepositMutation(5, self.dbconn, self.cacheconn)
self.um = UnitMutation(5, self.dbconn, self.cacheconn)
self.hlrmap = HLRMap(self.dbconn, self.cacheconn)
cdf = config.DEFAULT_EXPIRE
self.c_product = DBCache(const.PRODUCT_PREFIX, cdf, const.PRODUCT_SQL)
self.c_price = DBCache(const.AGENTPRICE_PREFIX, cdf, const.AGENTPRICE_SQL)
self.c_operator = DBCache(const.OPERATOR_PREFIX, cdf, const.OPERATOR_SQL,
user_func={'prefix': lambda x: x.split(',')})
map(lambda x: x.setConn(self.dbconn, self.cacheconn), [
self.c_product,
self.c_price,
self.c_operator,
])
self.rx_check, self.rx_topup, self.rx_separator = (None, None, None)
self._init2()
self.log = mylogger('TopupParser', 'topupparser.log')
self.to_db = []
self.parsed = []
self.handler = [
self.check,
]
self.processUNKN = self.process
def __init__(self):
super(LoadBalance, self).__init__("LB")
self.operator = self._loadOperator()
self.c_product = DBCache(const.PRODUCT_PREFIX, config.DEFAULT_EXPIRE, const.PRODUCT_SQL)
self.c_op_product = DBCache(const.OP_PRODUCT_PREFIX, config.DEFAULT_EXPIRE, const.OP_PRODUCT_SQL)
self.c_device = DBCache(const.DEVICES_PREFIX, config.DEFAULT_EXPIRE, const.DEVICES_SQL)
self.c_base_price = DBCache(const.CHIP_BASE_PRICE_PREFIX, config.DEFAULT_EXPIRE, const.CHIP_BASE_PRICE_SQL)
map(
lambda x: x.setConn(self.dbconn, self.cacheconn),
[self.c_product, self.c_op_product, self.c_device, self.c_base_price],
)
# self.hlr_cache = HLRCacheForLB(self.dbconn, self.cacheconn)
# self.hlr_cache.cacheAllTopupDevice()
self.lb = LBTopup(self.dbconn)
self.lb.cleanRebuild()
self.hm = HLRMap(self.dbconn, self.cacheconn)
self.hm.rebuild()
self.dm = DepositMutation(5, self.dbconn, self.cacheconn)
self.last_op_prod = None
self.last_device = None
self.last_hlr_id = None
self.last_tr_id = None
self.last_tr_data = None
self.change_method = None
self.log = mylogger("LoadBalance", "loadbalance.log")
def __init__(self):
BaseComponent.__init__(self, 'YM')
self.c_mutdepo = DBCache(const.MUTATION_PREFIX, config.DEFAULT_EXPIRE,
const.MUTATION_SQL)
self.c_mutdepo.setConn(self.dbconn, self.cacheconn)
self.c_ym_handler = DBCache2(const.YM_HANDLER_PREFIX, config.DEFAULT_EXPIRE,
const.YM_HANDLER_SQL)
self.c_ym_handler.setConn(self.dbconn, self.cacheconn)
self.rrb = {}
self.prepareCache()
self.ymgate = '{0}@{1}'.format(config.IMGATE, config.MSG_SERVER)
self.log = mylogger('YMHandler', 'YMHandler.log')
def __init__(self):
BaseComponent.__init__(self, "AU")
self.c_operator = DBCache(
const.OPERATOR_PREFIX,
config.DEFAULT_EXPIRE,
const.OPERATOR_SQL,
user_func={"prefix": lambda x: x.split(",")},
)
self.c_product = DBCache(const.PRODUCT_PREFIX, config.DEFAULT_EXPIRE, const.PRODUCT_SQL)
self.c_agentprice = DBCache(const.AGENTPRICE_PREFIX, config.DEFAULT_EXPIRE, const.AGENTPRICE_SQL)
self.dm = DepositMutation(5, self.dbconn, self.cacheconn)
self.um = UnitMutation(5, self.dbconn, self.cacheconn)
self.log = mylogger("Authorizer", "authorizer.log")
def __init__(self, username, password, realm, resource, msg_queue=None, prtimeout=10):
self.log = mylogger('XMPPMessaging', 'msg.log')
self.next_keepalive = datetime.now() + timedelta(seconds=15)
self.go = True
self.message_queue = msg_queue
self.username = username
self.password = password
self.realm = realm
self.resource = resource
self.connect(username, password, realm, resource)
# incoming message thread
self.process_thread = threading.Thread(target=self._tprocess,
args=(prtimeout,))
self.process_thread.start()
self.client.sendInitPresence(0)
self.send_lock = threading.Lock()
def __init__(self, port, emulate_type=False, persistent=False):
self.persistent = False
self.port = port
self.log = mylogger("Device", "md_{0}.log".format(port))
self.fail_sms_count = 0
self.saengine = sqlalchemy.create_engine(lconf.DBCONN_URI)
SABase.metadata.create_all(self.saengine)
self.sasession = scoped_session(sessionmaker(bind=self.saengine))
self.persistent = persistent
self.me = device.Device(self.port, emulate_type)
if persistent:
self.ser = serial.Serial(
r"{0}{1}{2}".format(self.me.prefix, self.me.infix, self.me.port),
self.me.baudrate,
timeout=0.5,
writeTimeout=0.5,
rtscts=10,
dsrdtr=0,
)
self.me.setPersistent(self.ser)
self.detectMEType()
self.cmd_handler = {"SMSG": self.commandSMSG, "JBDV": self.commandJBDV, "RCMD": self.reconnect}
def __init__(self, port, emulate_type=True):
if "linux" in sys.platform:
self.prefix = "/dev/"
self.infix = "tty"
else:
self.prefix = "\\\\.\\"
self.infix = "COM"
self.emulate_type = emulate_type
self.persistent = False
self.ser = None
self.baudrate = BAUDRATE.pop(0)
self.valid_port = True
self.log = mylogger("Device", "{0}.log".format(port))
self.port = port
self.buffer = ""
self.pdu = messaging.PDU()
self.modem_type = 0
if not self.confirmBaudRate():
self.valid_port = False
return
self.modem_type = self.getModemType()
self.initModem()
def __init__(self):
XMPPClient.__init__(self, lconf.SERVERNAME, {
'user': lconf.LEAFSERVER,
'pass': lconf.LEAFSERVER_PASS,
'realm': lconf.MSG_SERVER,
})
self.log = mylogger('LeafController', 'leaf.log')
self.shutdown = False
self.notify_in = '{0}@{1}/{2}'.format(lconf.NOTIFYIN, lconf.MSG_SERVER,
lconf.ROOT_SERVER_NAME)
self.rexes.insert(0, (r'^{0}@{1}(/[^:]+)?:(?P<command>\w+)=(?P<param>'
'[^,]*)$'.format(lconf.NOTIFYOUT, lconf.MSG_SERVER),
self.handleLeafCommand))
self.pdu = messaging.PDU()
self.check_sms = False
if 'linux' in sys.platform:
p = '/home/szhan/Dev'
else:
p = sys.path[0]
self.saengine = sqlalchemy.create_engine(lconf.DBCONN_URI)
SABase.metadata.create_all(self.saengine)
self.sasession = scoped_session(sessionmaker(bind=self.saengine))
threading.Thread(target=self.sendMessageToCore).start()
def __init__(self):
BaseComponent.__init__(self, 'MC')
self.logger = mylogger('SanityCheck')
def __init__(self):
BaseComponent.__init__(self, 'MC')
self.c_dev = DBCache(const.DEVICES_PREFIX, config.DEFAULT_EXPIRE,
const.DEVICES_SQL)
self.logger = mylogger('MassStockCheck')
def __init__(self):
BaseComponent.__init__(self, 'OC')
self.log = mylogger('OtherCommand', 'othercommand.log')
self.num = {}
self.dev = {}
def __init__(self):
self.pin = hashlib.md5('!elogic123').hexdigest()
self.device_update = {}
self.c_dev = DBCache(const.DEVICES_PREFIX, config.DEFAULT_EXPIRE,
const.DEVICES_SQL)
self.logger = mylogger('AdminHelper')
import traceback
from datetime import datetime
from pulsa import config
from pulsa.common import const
from pulsa.comp.CheckTicket import CheckTicket
from pulsa.comp.bca import BCA
from pulsa.comp.mandiri import Mandiri
from pulsa.helper.log import mylogger
__BANK_SIGNAL = '__bank_signal'
if __name__ =='__main__':
banklog = mylogger('Bank', 'bank.log')
ct = CheckTicket()
banks = [
BCA(ct.dbconn),
Mandiri(ct.dbconn),
]
while True:
if ct.cacheconn.get(__BANK_SIGNAL) in (0, '0'):
time.sleep(10)
continue
else:
i = datetime.now()
for b in banks:
try:
if ct.cacheconn.get(__BANK_SIGNAL) in (0, '0'):
break
import multiprocessing
import time
import Queue
import traceback
from pulsa import config
from pulsa.comp.NotifyDispatch import NotifyIn, notifyOut
from pulsa.comp.ConfigHandler import ConfigHandler
from pulsa.comp.OtherCmd import OtherCommand
from pulsa.helper.log import mylogger
core1log = mylogger('Core1', 'core1.log')
def prNotifyIn():
global core1log
ni = NotifyIn(config.ROOT_SERVER_NAME,
{'user': config.NOTIFYIN,
'pass': config.NOTIFYIN_PASS,
'realm': config.MSG_SERVER})
while True:
try:
ni.processMsgNoWait()
except Queue.Empty:
if not ni.flushToDB():
time.sleep(1)
ni.dbKeepAlive()
except:
errorstr = traceback.format_exc()
print errorstr
core1log.error('<NotifyIn>\n{0}'.format(errorstr))
# raw_input()
def __init__(self):
self.logger = mylogger('H2HServer', 'h2hserver.log')
from pulsa.comp.Authorizer import Authorizer
from pulsa.comp.NotifyDispatch import NotifyIn, notifyOut
from pulsa.comp.LoadBalance import LoadBalance
from pulsa.comp.IMHandler import IMDispatch
from pulsa.comp.HPSync import BaseSync
from pulsa.comp.Sync import LowPrioritySync
from pulsa.comp.ConfigHandler import ConfigHandler
from pulsa.comp.H2HHandler import H2HHandler
from pulsa.comp.YMHandler import YMHandler
from pulsa.comp.FrameLogic import FrameLogic
from pulsa.comp.Broadcast import Broadcast
from pulsa.comp.Stock import Stock
from pulsa.comp.TopupParser import *
from pulsa.helper.log import mylogger
core2log = mylogger('Core2', 'core2.log')
def prAuthorizer():
global core2log
shutdown = False
auth = Authorizer()
while not shutdown:
try:
job = auth.authorize()
if not job:
time.sleep(1)
except:
errorstr = traceback.format_exc()
print errorstr
core2log.error('<Authorizer>\n{0}'.format(errorstr))
