def main():
parser = argparse.ArgumentParser(description="Broker Test")
parser.add_argument("start_pulseid", type=int, help="start pulseid")
parser.add_argument("stop_pulseid", type=int, help="stop pulseid")
parser.add_argument("-p",
"--pgroup",
help="Example p12345",
default="p18493")
parser.add_argument(
"-o",
"--output_dir",
help=
"Output directory relative to the raw directory in the pgroup or /dev/null (default)",
default="/dev/null")
parser.add_argument("-c",
"--channels_file",
help="Text file with list of channels",
default="channel_list")
parser.add_argument("-e",
"--epics_file",
help="Text file with list of epics channels",
default=None)
parser.add_argument("-d",
"--detectors_file",
help="JSON file with the detector list",
default=None)
parser.add_argument("-s",
"--scan_info_file",
help="JSON file with the scan step information",
default=None)
parser.add_argument(
"-r",
"--rate_multiplicator",
type=int,
help="Rate multiplicator (1(default): 100Hz, 2: 50Hz, ...)",
default=1)
clargs = parser.parse_args()
channels = load_channels(clargs.channels_file)
pvs = load_channels(clargs.epics_file)
detectors = load_json(clargs.detectors_file)
scan_info = load_json(clargs.scan_info_file)
bc = BrokerClient(clargs.pgroup, clargs.rate_multiplicator)
rn = bc.retrieve(clargs.output_dir,
clargs.start_pulseid,
clargs.stop_pulseid,
detectors=detectors,
channels=channels,
pvs=pvs,
scan_info=scan_info)
print(rn)
def test_connect(self):
broker_address = cfg.BROKER_ADDRESS
broker_exchange_name = cfg.EXCHANGE_NAME
broker_queue_name = cfg.QUEUE_NAME
broker_client = BrokerClient(broker_address, broker_exchange_name,
broker_queue_name)
loop = asyncio.get_event_loop()
loop.run_until_complete(broker_client.connect())
self.assertIsInstance(broker_client, BrokerClient)
self.assertTrue(broker_client)
def test_put(self):
broker_address = cfg.BROKER_ADDRESS
broker_exchange_name = cfg.EXCHANGE_NAME
broker_queue_name = cfg.QUEUE_NAME
broker_client = BrokerClient(broker_address, broker_exchange_name,
broker_queue_name)
meter_house_a = Meter("HOUSE_A")
loop = asyncio.get_event_loop()
power_value = loop.run_until_complete(
meter_house_a.generate_power_value())
loop.run_until_complete(broker_client.connect())
loop.run_until_complete(broker_client.put(power_value))
self.assertIsInstance(broker_client, BrokerClient)
self.assertTrue(broker_client)
def setUp(self):
broker_address = cfg.BROKER_ADDRESS
broker_exchange_name = cfg.EXCHANGE_NAME
broker_queue_name = cfg.QUEUE_NAME
broker_client_obj = BrokerClient(broker_address, broker_exchange_name,
broker_queue_name)
self._publisher = Publisher(broker_client_obj)
async def consume() -> None:
broker_address = cfg.BROKER_ADDRESS
broker_exchange_name = cfg.EXCHANGE_NAME
broker_queue_name = cfg.QUEUE_NAME
broker_client = BrokerClient(broker_address, broker_exchange_name,
broker_queue_name)
simulator_log.info(
"Created Broker Client using address %s, exchange %s, queue %s" %
(broker_address, broker_exchange_name, broker_queue_name))
# Initialize the broker to the consumer
consumer = Consumer(broker_client)
try:
# Connect to the broker using the broker client
await consumer.connect_to_broker()
while True:
simulator_log.info("Sleeping for %d seconds" %
cfg.CONSUMER_TIME_INTERVAL)
# Consume messages after every CONSUMER_TIME_INTERVAL
time.sleep(cfg.CONSUMER_TIME_INTERVAL)
simulator_log.info("Receiving message from broker")
# Consume the message from the broker
await consumer.consume(pv_simulator.process_message)
except KeyboardInterrupt:
simulator_log.info("key board interrupted, Exiting the program")
except AMQPConnectionError as e:
simulator_log.error(e)
except Exception as e:
simulator_log.error(e)
finally:
simulator_log.info("Orchestrator disconnecting from the consumer")
await consumer.disconnect_from_broker()
simulator_log.info(
"Finished: Orchestrator disconnected from the consumer")
sys.exit(0)
async def produce() -> None:
broker_address = cfg.BROKER_ADDRESS
broker_exchange_name = cfg.EXCHANGE_NAME
broker_queue_name = cfg.QUEUE_NAME
# Creating a broker client to connect to RabbitMQ
broker_client = BrokerClient(broker_address, broker_exchange_name,
broker_queue_name)
meter_log.info(
"Created Broker Client using address %s, exchange %s, queue %s" %
(broker_address, broker_exchange_name, broker_queue_name))
# Creating meters mocking few houses in a neighbourhood
meter_house_a = meter.Meter("HOUSE_A")
meter_house_b = meter.Meter("HOUSE_B")
meter_house_c = meter.Meter("HOUSE_C")
# Publisher which publishes the message to the RabbitMQ queue
publisher = Publisher(broker_client)
try:
# Connect to the broker using the broker client
await publisher.connect_to_broker()
# publish messages after every PRODUCER_TIME_INTERVAL
while True:
meter_log.info("Sleeping for %d seconds" %
cfg.PRODUCER_TIME_INTERVAL)
time.sleep(cfg.PRODUCER_TIME_INTERVAL)
pv_house_a = await meter_house_a.generate_power_value()
meter_log.info(
"Sending message to broker from house meter HOUSE_A")
await publisher.publish(pv_house_a)
meter_log.info("Sleeping for %d seconds" %
cfg.PRODUCER_TIME_INTERVAL)
time.sleep(cfg.PRODUCER_TIME_INTERVAL)
pv_house_b = await meter_house_b.generate_power_value()
meter_log.info(
"Sending message to broker from house meter HOUSE_B")
await publisher.publish(pv_house_b)
meter_log.info("Sleeping for %d seconds" %
cfg.PRODUCER_TIME_INTERVAL)
time.sleep(cfg.PRODUCER_TIME_INTERVAL)
pv_house_c = await meter_house_c.generate_power_value()
meter_log.info(
"Sending message to broker from house meter HOUSE_C")
await publisher.publish(pv_house_c)
except KeyboardInterrupt:
meter_log.info("key board interrupted, Exiting the program")
except AMQPConnectionError as e:
meter_log.error(e)
except Exception as e:
meter_log.error(e)
finally:
meter_log.info("Orchestrator disconnecting from the publisher")
await publisher.disconnect_from_broker()
meter_log.info(
"Finished: Orchestrator disconnected from the publisher")
sys.exit(0)