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)