def enable_dispatch_delivery(self):
self._logger.info('[%s] Delivering dispatch' % (
self._cco['charge_id']))
data = {
'dispatch_info': self._dispatch_info,
'dispatch_content': self._dispatch_content
}
rabbit = RabbitHandler(**self._rabbit_cfg)
rabbit.put(data=data, exchange='x', routing_key='putter')
rabbit.disconnect()
def report_charge(self):
try:
data = msgpack.dumps({
'charge_id': self._cco['charge_id'],
'cco_transaction_id': self._cco_result['transaction'],
'cco_response': self._cco_result['response'],
'cco_ws_response_date': datetime.utcnow().strftime(
'%Y-%m-%d %H:%M:%S')
})
rabbit = RabbitHandler(**self._rabbit_sc_cfg)
rabbit.put(data=data, exchange='x', routing_key='charesp')
rabbit.disconnect()
except Exception, e:
self._logger.exception('[%s] Error on make report.' % (
self._cco['charge_id']))
def __init__(self, *args, **kwargs):
super(QueueManager, self).__init__(*args, **kwargs)
self._queue = kwargs['queue']
self._max_queue_gets_per_time = kwargs['max_queue_gets_per_time']
self._queueman_is_running = kwargs['queueman_is_running']
self._rabbit_cfg = kwargs['rabbit_cfg']
self._know_queues = kwargs['know_queues']
self._rabbit = RabbitHandler(**self._rabbit_cfg)
def _process(self):
while True:
self._pipe.send('gimme')
message = self._pipe.recv()
if isinstance(message, Message):
try:
self._logger.info('Processing charge...')
data = msgpack.loads(message.body)
pepe = CollectorProcess(
logger=self._logger,
rabbit_cfg=self._rabbit_cfg,
rabbit_sc_cfg=self._rabbit_sc_cfg,
dispatch_info=data['dispatch_info'],
cco_profile=data['cco_profile'],
notification=data.get('notification'),
dispatch_content=data.get('dispatch_content')
)
except KeyError, TypeError:
self._logger.error('Invalid format')
else:
charge_id = data['cco_profile']['charge_id']
try:
pepe.cco_charge()
if pepe.is_cco_charge_ok():
self._logger.info('[%s] Charge OK' % (charge_id))
if data.get('notification'):
pepe.notify()
else:
self._logger.info('[%s] Charge FAIL' % (charge_id))
if pepe.is_async_fallbackeable():
pepe.sct_async_charge()
self._logger.info('[%s] Reporting to Snoopy ' \
'Charges.' % (charge_id))
pepe.report_charge()
if pepe.ignore_charge_result():
self._logger.info('[%s] Dispatch sended ' \
'ignoring charge result.' % (charge_id))
else:
if pepe.is_dispatch_sendeable():
pepe.enable_dispatch_delivery()
else:
self._logger.info('[%s] Dispatch discarded ' \
'to %s' % (charge_id, pepe.msisdn))
except:
self._logger.exception('[%s] Reinjecting to queue' % (
charge_id))
rabbit = RabbitHandler(**self._rabbit_cfg)
rabbit.reinject(message)
rabbit.disconnect()
finally:
self._logger.info('Done.')
class QueueManager(ThreadWorker):
def __init__(self, *args, **kwargs):
super(QueueManager, self).__init__(*args, **kwargs)
self._queue = kwargs['queue']
self._max_queue_gets_per_time = kwargs['max_queue_gets_per_time']
self._queueman_is_running = kwargs['queueman_is_running']
self._rabbit_cfg = kwargs['rabbit_cfg']
self._know_queues = kwargs['know_queues']
self._rabbit = RabbitHandler(**self._rabbit_cfg)
def run(self):
try:
self._process()
except:
self._logger.exception('Thread failure')
def _process(self):
while self._is_running.value:
queues_puts_sum = 0
for queue in self._know_queues:
self._logger.info('Processing queue %s' % (queue))
queue_puts = 0
for i in range(self._max_queue_gets_per_time):
try:
data = self._rabbit.get(queue)
self._queue.put(queue, data)
except Queue.Full:
self._rabbit.reject()
self._logger.warning('%s Queue full' % (queue))
break
except RabbitEmpty:
self._logger.warning('%s Queue empty' % (queue))
break
except AMQPConnectionException:
self._rabbit.disconnect()
except Exception, e:
self._logger.exception('Error %s' % (e))
self._logger.warning('----------------------------')
else:
self._rabbit.ack()
queue_puts += 1
queues_puts_sum += queue_puts
self._logger.info('%d elements puts' % (queue_puts))
self._logger.info('Switching queue')
if queues_puts_sum == 0:
sleep(5)
self._rabbit.disconnect()
self._queueman_is_running.clear()
self._logger.info('Goodbye!')
