def subscribe_producer(
request_queue_name: str, answer_queue_name: str,
request_callback: Callable[[dict, Callable[[any], None]], bool]):
def answer_callback(msg_id: int, answer) -> None:
total_answer = {
'id': msg_id,
'ans': answer,
}
QueueWrapper.send_message(answer_queue_name,
dump_object(total_answer))
def req_callback(ch: BlockingChannel, method: spec.Basic.Deliver,
_: spec.BasicProperties, body: bytes):
body: ReqBody = load_object(body)
ack = request_callback(
body['req'],
lambda answer: answer_callback(body['id'], answer))
if ack is None:
ack = True
if ack:
ch.basic_ack(delivery_tag=method.delivery_tag)
else:
ch.basic_nack(delivery_tag=method.delivery_tag)
QueueWrapper.subscribe_to_queue(callback=req_callback,
queue=request_queue_name,
auto_ack=False)
def answer_callback(msg_id: int, answer) -> None:
total_answer = {
'id': msg_id,
'ans': answer,
}
QueueWrapper.send_message(answer_queue_name,
dump_object(total_answer))
def write_msg(msg_id, request):
message = {
'id': msg_id,
'req': request
}
packed = dump_object(message)
QueueWrapper.send_message(request_queue_name, packed)
def register():
QueueWrapper.clear_queue(config.parse_all_moscow_req_queue, is_publish=True)
GlobalParser.parse_request_function = ConsumerFactory.get_consumer(config.parse_all_moscow_req_queue,
config.parse_all_moscow_ans_queue,
GlobalParser.link_parsed)
GlobalParser.offers_send_function = StraightQueue.get_sender(config.new_offers_queue)
GlobalParser.thread = threading.Thread(target=GlobalParser.work)
GlobalParser.thread.start()
def subscribe_getter(queue_name, callback):
def req_callback(ch, method, properties, body):
body = load_object(body)
ack = callback(body)
if ack is None:
ack = True
if ack:
ch.basic_ack(delivery_tag=method.delivery_tag)
else:
ch.basic_nack(delivery_tag=method.delivery_tag)
QueueWrapper.subscribe_to_queue(callback=req_callback,
queue=queue_name,
no_ack=False)
def subscribe_getter(queue_name, callback):
def req_callback(ch: BlockingChannel, method: spec.Basic.Deliver,
_: spec.BasicProperties, body: bytes):
body = load_object(body)
ack = callback(body)
if ack is None:
ack = True
if ack:
ch.basic_ack(delivery_tag=method.delivery_tag)
else:
ch.basic_nack(delivery_tag=method.delivery_tag)
QueueWrapper.subscribe_to_queue(callback=req_callback,
queue=queue_name,
auto_ack=False)
def get_consumer(request_queue_name, answer_queue_name, answer_callback):
def raw_answer_callback(ch, method, properties, body):
body = load_object(body)
ack = answer_callback(body['id'], body['ans'])
if ack is None:
ack = True
if ack:
ch.basic_ack(delivery_tag=method.delivery_tag)
else:
ch.basic_nack(delivery_tag=method.delivery_tag)
def write_msg(msg_id, request):
message = {'id': msg_id, 'req': request}
packed = dump_object(message)
QueueWrapper.send_message(request_queue_name, packed)
QueueWrapper.subscribe_to_queue(callback=raw_answer_callback,
queue=answer_queue_name,
no_ack=False)
return write_msg
def subscribe_producer(request_queue_name, answer_queue_name, request_callback):
def answer_callback(msg_id, answer):
total_answer = {
'id': msg_id,
'ans': answer,
}
QueueWrapper.send_message(answer_queue_name, dump_object(total_answer))
def req_callback(ch, method, properties, body):
body = load_object(body)
ack = request_callback(body['req'], lambda answer: answer_callback(body['id'], answer))
if ack is None:
ack = True
if ack:
ch.basic_ack(delivery_tag=method.delivery_tag)
else:
ch.basic_nack(delivery_tag=method.delivery_tag)
QueueWrapper.subscribe_to_queue(callback=req_callback,
queue=request_queue_name,
no_ack=False)
def main():
logger = LoggerInit.init_logging(config.log_file)
logger.info('Application started')
QueueWrapper.init()
bot = Telegram(config.api_key)
UserManager.init(bot)
User.init()
QueueWrapper.start(detach=True)
try:
for _ in bot.get_updates():
pass
while True:
logger.debug("Getting updates")
for query in bot.get_updates(timeout=30):
logger.debug(f'==> {query}')
query_type = query['type']
body = query['body']
user_id = query['uid']
user = UserManager.get_or_create_user(user_id)
if query_type == 'message':
logger.debug("Sending message to user {}".format(user_id))
user.process_message(body)
elif query_type == 'inline_req':
logger.debug("Sending inline request to user {}".format(user_id))
user.process_inline_req(body)
elif query_type == 'inline_ans':
logger.debug("Sending inline answer to user {}".format(user_id))
user.process_inline_ans(body)
elif query_type == 'callback':
logger.debug("Sending callback to user {}".format(user_id))
user.process_callback(body)
except KeyboardInterrupt:
logger.debug('QueueWrapper.close')
QueueWrapper.close()
def get_consumer(request_queue_name, answer_queue_name, answer_callback):
def raw_answer_callback(ch, method, properties, body):
body = load_object(body)
ack = answer_callback(body['id'], body['ans'])
if ack is None:
ack = True
if ack:
ch.basic_ack(delivery_tag=method.delivery_tag)
else:
ch.basic_nack(delivery_tag=method.delivery_tag)
def write_msg(msg_id, request):
message = {
'id': msg_id,
'req': request
}
packed = dump_object(message)
QueueWrapper.send_message(request_queue_name, packed)
QueueWrapper.subscribe_to_queue(callback=raw_answer_callback,
queue=answer_queue_name,
no_ack=False)
return write_msg
def get_consumer(request_queue_name: str, answer_queue_name: str,
answer_callback: Callable[[dict, any], Optional[bool]]):
def raw_answer_callback(ch: BlockingChannel,
method: spec.Basic.Deliver,
_: spec.BasicProperties, body: bytes):
body: AnsBody = load_object(body)
ack = answer_callback(body['id'], body['ans'])
if ack is None:
ack = True
if ack:
ch.basic_ack(delivery_tag=method.delivery_tag)
else:
ch.basic_nack(delivery_tag=method.delivery_tag)
def write_msg(msg_id: dict, request: dict):
message = {'id': msg_id, 'req': request}
packed: bytes = dump_object(message)
QueueWrapper.send_message(request_queue_name, packed)
QueueWrapper.subscribe_to_queue(callback=raw_answer_callback,
queue=answer_queue_name,
auto_ack=False)
return write_msg
def main():
LoggerInit.init_logging(config.log_update_manager_file)
QueueWrapper.init()
UpdatesManager.init_manager()
QueueWrapper.start(detach=True)
try:
UpdatesManager.worker()
except KeyboardInterrupt:
QueueWrapper.close()
def main():
LoggerInit.init_logging(config.log_update_manager_file)
QueueWrapper.init()
UpdatesManager.init_manager()
QueueWrapper.start(detach=True)
try:
UpdatesManager.worker()
except KeyboardInterrupt:
QueueWrapper.close()
def main():
QueueWrapper.init()
ProducerFactory.subscribe_producer(config.check_url_req_queue, config.check_url_ans_queue,
check_url_callback)
ProducerFactory.subscribe_producer(config.parse_url_req_queue, config.parse_url_ans_queue,
parse_url_callback)
ProducerFactory.subscribe_producer(config.parse_all_moscow_req_queue, config.parse_all_moscow_ans_queue,
parse_url_callback)
try:
QueueWrapper.start(detach=False)
except KeyboardInterrupt:
QueueWrapper.close()
def main():
QueueWrapper.init()
GlobalParser.register()
SuspiciousChecker.register()
QueueWrapper.start(detach=True)
try:
while True:
time.sleep(60 * 60 * 60)
except KeyboardInterrupt:
GlobalParser.close_thread()
SuspiciousChecker.close_thread()
QueueWrapper.close()
def main():
QueueWrapper.init()
ProducerFactory.subscribe_producer(config.check_url_req_queue,
config.check_url_ans_queue,
check_url_callback)
ProducerFactory.subscribe_producer(config.parse_url_req_queue,
config.parse_url_ans_queue,
parse_url_callback)
ProducerFactory.subscribe_producer(config.parse_all_moscow_req_queue,
config.parse_all_moscow_ans_queue,
parse_url_callback)
try:
QueueWrapper.start(detach=False)
except KeyboardInterrupt:
QueueWrapper.close()
def write_msg(msg_id: dict, request: dict):
message = {'id': msg_id, 'req': request}
packed: bytes = dump_object(message)
QueueWrapper.send_message(request_queue_name, packed)
import LoggerInit
import config
import pytz
from datetime import datetime
import time
import logging
from GlobalManager.GlobalParser import GlobalParser
from GlobalManager.SuspiciousChecker import SuspiciousChecker
from Queues import QueueWrapper
from Queues.ProducerConsumer.ConsumerFactory import ConsumerFactory
LoggerInit.init_logging(config.log_all_moscow_file)
logger = logging.getLogger("AllMoscowParser")
if __name__ == "__main__":
QueueWrapper.init()
GlobalParser.register()
SuspiciousChecker.register()
QueueWrapper.start(detach=True)
try:
while True:
time.sleep(60 * 60 * 60)
except KeyboardInterrupt:
GlobalParser.close_thread()
SuspiciousChecker.close_thread()
QueueWrapper.close()
def write_msg(request):
packed = dump_object(request)
QueueWrapper.send_message(queue_name, packed)
def answer_callback(msg_id, answer):
total_answer = {
'id': msg_id,
'ans': answer,
}
QueueWrapper.send_message(answer_queue_name, dump_object(total_answer))
