async def main(): # Declare the protocol stack used for serialization. # Protocol stacks must match between publishers and subscribers. prot_factory = FProtocolFactory(TBinaryProtocol.TBinaryProtocolFactory()) # Open a aiostomp connection, default stomp port in activemq is 61613 stomp_client = AioStomp('localhost', 61613) await stomp_client.connect() # Create a pub sub scope using the configured transport and protocol transport_factory = FStompPublisherTransportFactory(stomp_client) provider = FScopeProvider(transport_factory, None, prot_factory) # Create a publisher publisher = AlbumWinnersPublisher(provider) await publisher.open() # Publish an album win event album = Album() album.ASIN = str(uuid.uuid4()) album.duration = 12000 album.tracks = [ Track(title="Comme des enfants", artist="Coeur de pirate", publisher="Grosse Boîte", composer="Béatrice Martin", duration=169, pro=PerfRightsOrg.ASCAP) ] await publisher.publish_Winner(FContext(), album) await publisher.publish_ContestStart(FContext(), [album, album]) # Close publisher and nats client await publisher.close() stomp_client.close()
async def create_connection(): client = AioStomp('localhost', 61613, error_handler=StompListener.on_error) client.subscribe('/queue/MLRequest', handler=StompListener.on_message) await client.connect() _info_log.info(f"Subscribe message pool successful")
async def main(): # Declare the protocol stack used for serialization. # Protocol stacks must match between publishers and subscribers. prot_factory = FProtocolFactory(TBinaryProtocol.TBinaryProtocolFactory()) # Open a aiostomp connection, default stomp port in activemq is 61613 stomp_client = AioStomp('localhost', 61613) await stomp_client.connect() # Create a pub sub scope using the configured transport and protocol transport_factory = FStompSubscriberTransportFactory(stomp_client) provider = FScopeProvider(None, transport_factory, prot_factory) subscriber = AlbumWinnersSubscriber(provider) def event_handler(ctx, req): raise ValueError('BLAH') root.info("You won! {}".format(req.ASIN)) def start_contest_handler(ctx, albums): root.info("Contest started, available albums: {}".format(albums)) await subscriber.subscribe_Winner(event_handler) await subscriber.subscribe_ContestStart(start_contest_handler) root.info("Subscriber starting...")
async def run(): client = AioStomp('localhost', 61613, error_handler=report_error) client.subscribe('/queue/test', handler=on_message) await client.connect() await asyncio.sleep(10) client.subscribe('/queue/test', handler=on_message) client.send('/queue/test', body=u'Pedro Kiefer', headers={}) await asyncio.sleep(10)
async def run(): # 测试不同日志级别的颜色 logger.debug('This is debug message') logger.info('This is info message') logger.warning('This is warning message') logger.error('This is error message') logger.critical('This is critical message') # 连接 ActiveMQ client = AioStomp('127.0.0.1', 61613, error_handler=report_error) await client.connect() # 定时发送消息到队列 while True: destination = '/queue/channel' data = datetime.now().strftime('%Y-%m-%d %H:%M:%S') client.send(destination, body=data, headers={}) logger.info('Send a message({0}) to queue({1})'.format( data, destination)) time.sleep(1)
async def run(): ssl_context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile="certificate.pem") client = AioStomp("localhost", 61612, error_handler=report_error, ssl_context=ssl_context) client.subscribe("/queue/test", handler=on_message) await client.connect() await asyncio.sleep(10) client.subscribe("/queue/test", handler=on_message) client.send("/queue/test", body=u"Pedro Kiefer", headers={}) await asyncio.sleep(10)
async def main(): global response_received parser = argparse.ArgumentParser( description='Run a python asyncio stomp publisher') parser.add_argument('--port', dest='port', default='9090') parser.add_argument('--protocol', dest='protocol_type', default='binary', choices='binary, compact, json') parser.add_argument('--transport', dest='transport_type', default=ACTIVEMQ_NAME, choices='activemq') args = parser.parse_args() protocol_factory = get_protocol_factory(args.protocol_type) if args.transport_type == ACTIVEMQ_NAME: stomp_client = AioStomp('localhost', 61613) await stomp_client.connect() pub_transport_factory = FStompPublisherTransportFactory(stomp_client) sub_transport_factory = FStompSubscriberTransportFactory(stomp_client) provider = FScopeProvider( pub_transport_factory, sub_transport_factory, protocol_factory) publisher = EventsPublisher(provider) else: print( 'Unknown transport type: {type}'.format(type=args.transport_type)) sys.exit(1) await publisher.open() def subscribe_handler(context, event): print('Response received {}'.format(event)) global response_received if context: response_received = True # Subscribe to response preamble = 'foo' ramble = 'bar' subscriber = EventsSubscriber(provider) await subscriber.subscribe_EventCreated(preamble, ramble, 'response', '{}'.format(args.port), subscribe_handler) event = Event(Message='Sending Call') context = FContext('Call') context.set_request_header(PREAMBLE_HEADER, preamble) context.set_request_header(RAMBLE_HEADER, ramble) print('Publishing...') await publisher.publish_EventCreated(context, preamble, ramble, 'call', '{}'.format(args.port), event) # Loop with sleep interval. Fail if not received within 3 seconds total_time = 0 interval = 0.1 while total_time < 3: if response_received: break else: await asyncio.sleep(interval) total_time += interval if not response_received: print('publisher did not get a response from subscriber!') exit(1) await publisher.close() exit(0)
async def main(): global message_received parser = argparse.ArgumentParser( description='Run a python asyncio stomp publisher') parser.add_argument('--port', dest='port', default='9090') parser.add_argument('--protocol', dest='protocol_type', default='binary', choices="binary, compact, json") parser.add_argument('--transport', dest='transport_type', default=ACTIVEMQ_NAME, choices='activemq') args = parser.parse_args() protocol_factory = get_protocol_factory(args.protocol_type) if args.transport_type == ACTIVEMQ_NAME: stomp_client = AioStomp('localhost', 61613) await stomp_client.connect() pub_transport_factory = FStompPublisherTransportFactory(stomp_client) sub_transport_factory = FStompSubscriberTransportFactory(stomp_client) else: print( 'Unknown transport type: {type}'.format(type=args.transport_type)) sys.exit(1) provider = FScopeProvider(pub_transport_factory, sub_transport_factory, protocol_factory) # start healthcheck so the test runner knows the server is running threading.Thread(target=healthcheck, args=(args.port, )).start() async def subscribe_handler(context, event): publisher = EventsPublisher(provider) try: await publisher.open() preamble = context.get_request_header(PREAMBLE_HEADER) if preamble is None or preamble == '': print('Client did not provide preamble header') return ramble = context.get_request_header(RAMBLE_HEADER) if ramble is None or ramble == '': print('Client did not provide ramble header') return response_event = Event(Message='Sending Response') response_context = FContext('Call') await publisher.publish_EventCreated(response_context, preamble, ramble, 'response', '{}'.format(args.port), response_event) global message_received message_received = True except Exception as e: print('Error opening publisher to respond:' + repr(e)) subscriber = EventsSubscriber(provider) await subscriber.subscribe_EventCreated('*', '*', 'call', '{}'.format(args.port), subscribe_handler) # Loop with sleep interval. Fail if not received within 3 seconds total_time = 0 interval = 0.1 while total_time < 3: if message_received: break else: await asyncio.sleep(interval) total_time += interval if not message_received: print('subscriber did not received message!') exit(1) exit(0)