def test_broker_smoke():
with Broker('localhost') as client:
client.connect()
client.setup_exchange()
client.declare(output_queue=task_input_queue)
logger.info('Sending task')
for i in test_tasks:
client.push(test_tasks[i])
with Broker('localhost') as agent:
agent.connect()
agent.declare(input_queue=task_input_queue,
output_queue=task_result_queue)
agent._inactivity_timeout = 0.1
logger.info('Processing task')
for task in agent.pulling_generator():
result = process_task(task)
agent.set_task_done(task)
agent.push(result)
with Broker('localhost') as validator:
validator.connect()
validator.declare(input_queue=task_result_queue)
validator._inactivity_timeout = 0.1
logger.info('Validating results')
for task in validator.pulling_generator():
validator_callback(task)
validator.set_task_done(task)
def broker():
host = '*'
with Broker(host) as broker:
broker.connect()
# broker._interrupt = polling_expiration
broker._inactivity_timeout = 0.1 * SECOND
broker.declare(input_queue=task_queue,
output_queue=compose_queue(RoutingKeys.RESULTS))
yield broker
input_queue = broker.input_queue
flush_queue(host, input_queue)
def __init__(self,
ip: str = '*',
port: Union[int, str] = '',
broker_host: str = ''):
logger.info('Starting Dispatcher')
self.socket = ReplyConnection(ip, port)
self.broker = Broker(broker_host if broker_host else ip)
self.agents = {}
self.request_handler = self.default_request_handler
self._next_free_id = INIT_AGENT_ID
self._listen = True
self._interrupt: Union[None, Callable] = None
def get_client_queues(self):
request = deepcopy(Client_queues)
request['name'] = self.name
request['token'] = self.token
reply = self.socket.send(request)
if reply['result']:
self.broker = Broker(reply['broker']['host'])
self.broker.connect()
self.broker.declare(reply['broker']['result'],
reply['broker']['task'])
else:
ConnectionRefusedError('Invalid credentials or resource is busy')
def init_broker(self):
"""
Request Agent queues on Broker from Dispatcher.
"""
request = deepcopy(Agent_queues)
request['token'] = self.token
request['id'] = self.id
reply = self.socket.send(request)
if reply['result']:
self.sync(reply)
self.broker = Broker(reply['broker']['host'])
self.broker.connect()
self.broker.declare(reply['broker']['task'],
reply['broker']['result'])
def flush_queue(broker: str,
queue: dict = task_queue,
assert_non_empty: bool = True):
with Broker(broker) as br:
br.connect()
br.declare(queue)
br._inactivity_timeout = 0.1 # seconds
empty = True
logger.info(f'Flushing queue: {queue}')
for task in br.pulling_generator():
empty = False
br.set_task_done(task)
if assert_non_empty:
assert empty, f'Flushed queue {queue} is not empty'