ADDRESS = "localhost:5672"
SOURCE = "queue://test"
class Subscriber(MessagingHandler):
def __init__(self, url, source):
super(Subscriber, self).__init__()
self.url = url
self.source = source
def on_start(self, event):
print("on_start()")
connection = event.container.connect(self.url)
event.container.create_receiver(connection, self.source)
def on_message(self, event):
message = event.message
print("Received message '{m}'".format(m=message.body))
if message.body == "exit":
print("Last message for me...good bye")
event.receiver.close()
event.connection.close()
time.sleep(1)
subscriber = Subscriber(ADDRESS, SOURCE)
container = Container(subscriber)
container.run()
except:
pass
def on_accepted(self, event):
if event.sender == self.service_sender:
self.outstanding -= 1
self.send()
def on_rejected(self, event):
if event.sender == self.service_sender:
self.outstanding -= 1
self.send()
def on_released(self, event):
if event.sender == self.service_sender:
self.outstanding -= 1
self.send()
try:
##
## Try to get the message bus hostname from the openshift environment
## Fall back to 127.0.0.1 (loopback)
##
host = os.getenv("MESSAGING_SERVICE_HOST", "127.0.0.1")
container = Container(Client(host))
container.container_id = os.getenv("HOSTNAME", "client")
container.run()
except KeyboardInterrupt:
pass
def run(self):
Container(self).run()
def run(self):
container = Container(self)
container.container_id = 'LRC'
container.run()
def on_start(self, event):
"""Event callback for when the client starts"""
connection = event.container.connect(url=self.broker_url,
sasl_enabled=False)
event.container.create_receiver(connection, source=self.queue_name)
def on_message(self, event):
"""Event callback when a message is received by the client"""
if event.message.id and event.message.id < self.received:
return # ignore duplicate message
if self.received < self.expected:
pass # do something here
if self.received >= self.expected:
event.receiver.close()
event.connection.close()
# --- main ---
# Args: 1: Broker address (ip-addr:port)
# 2: Queue name
# ...
try:
RECEIVER = AmqpDtxTestReceiver(sys.argv[1], sys.argv[2])
Container(RECEIVER).run()
except KeyboardInterrupt:
pass
except Exception as exc:
print os.path.basename(sys.argv[0]), 'EXCEPTION', exc
print format_exc()
body=self.requests[0])
self.sender.send(req)
print("Message '%s' sent" % self.requests.pop(0))
def on_sendable(self, event):
while event.sender.credit and self.requests:
self.next_request()
def on_message(self, event):
self.received += 1
print("Message '%s' received" % event.message.body)
if self.received == self.total:
event.connection.close()
REQUESTS = [
"Twas brillig, and the slithy toves", "Did gire and gymble in the wabe.",
"All mimsy were the borogroves,", "And the mome raths outgrabe."
]
parser = optparse.OptionParser(
usage="usage: %prog [options]",
description="Send requests to the supplied address and print responses.")
parser.add_option("-a",
"--address",
default="localhost:5672/examples",
help="address to which messages are sent (default %default)")
opts, args = parser.parse_args()
Container(Client(opts.address, args or REQUESTS)).run()
# Called once the sender has been created
def on_link_opened(self, event):
if event.link.is_sender:
self.receiver = event.container.create_receiver(
self.conn, self.receive_destination)
# the on_transport_error event catches socket and authentication failures
def on_transport_error(self, event):
print("Transport error:", event.transport.condition)
def on_disconnected(self, event):
print("Disconnected")
# parse arguments and get options
opts = get_options()
"""
The amqp address can be a topic or a queue.
Do not use a prefix or use 'queue://' in the amqp address for
the amqp receiver source address to receiver messages from a queue.
Use the prefix 'topic://' for a topic address
"""
try:
Container(
SendOnReceive(opts.url, opts.username, opts.password,
opts.send_destination, opts.receive_destination)).run()
except KeyboardInterrupt:
pass
if env.throttle > 0:
time.sleep(env.throttle)
def on_accepted(self, event):
self.confirmed += 1
if self.confirmed == self.total:
print("all messages confirmed")
event.connection.close()
def on_disconnected(self, event):
self.sent = self.confirmed
parser = optparse.OptionParser(usage="usage: %prog [options]",
description="Send messages to the supplied address.")
parser.add_option("-u", "--urls", default=env.server_addr,
help="list of URL strings of process to try to connect to. Ex: [host1:5672, host2:5672, host2:5672]")
parser.add_option("-a", "--address", default=env.address,
help="address to which messages are sent (default %default)")
parser.add_option("-m", "--messages", type="int", default=env.num_messages,
help="number of messages to send (default %default)")
opts, args = parser.parse_args()
# From command line string option
if isinstance(opts.urls, str):
opts.urls = opts.urls.strip('[]').split(', ')
try:
Container(Send(opts.urls, opts.address, opts.messages)).run()
except KeyboardInterrupt: pass
def on_start(self, event):
self.container = event.container
self.conn = self.container.connect(self.url)
self.receiver = self.container.create_receiver(self.conn, self.address)
self.acct_sender = self.container.create_sender(
self.conn, self.accounting)
self.anon_sender = self.container.create_sender(self.conn, None)
def on_message(self, event):
reply_to = event.message.reply_to
cid = event.message.correlation_id
msg = Message(address=reply_to,
correlation_id=cid,
body="SubService.A (%s)" % os.uname()[1])
self.anon_sender.send(msg)
if self.acct_sender.credit > 0:
acct_msg = Message(body=reply_to)
self.acct_sender.send(acct_msg)
try:
##
## Try to get the message bus hostname from the openshift environment
## Fall back to 127.0.0.1 (loopback)
##
host = os.getenv("MESSAGING_SERVICE_HOST", "127.0.0.1")
Container(Service(host)).run()
except KeyboardInterrupt:
pass
def _reset_stats(self):
self._received = 0
self._e2e_times = list()
# Main flow for sender app
if __name__ == "__main__":
parsed_opts, args = common.parse_opts(False)
# same message body and properties will be used by all sender instances
expected_body_size = parsed_opts.message_size
expected_properties_size = parsed_opts.properties_size
# initializing logging
common.initialize_logging(parsed_opts.log_level)
# list of spawned sender processes
processes = list()
# spawning receiver processes
for i in range(parsed_opts.processes):
proc = multiprocessing.Process(target=Container(Receiver(parsed_opts)).run)
proc.start()
processes.append(proc)
# waiting on all processes to finish
for proc in processes:
proc.join()
print("Exiting")
self.transaction.commit()
def on_abort(self, event):
self.transaction.abort()
def on_fetch(self, event):
self.receiver.flow(1)
def on_quit(self, event):
c = self.receiver.connection
self.receiver.close()
c.close()
try:
reactor = Container(TxRecv())
events = reactor.get_event_trigger()
thread = threading.Thread(target=reactor.run)
thread.daemon = True
thread.start()
print "Enter 'fetch', 'commit' or 'abort'"
while True:
line = sys.stdin.readline()
if line:
events.trigger(ApplicationEvent(line.strip()))
else:
break
except KeyboardInterrupt:
pass
self.container.declare_transaction(self.conn, handler=self)
def on_disconnected(self, event):
self.current_batch = 0
parser = optparse.OptionParser(
usage="usage: %prog [options]",
description="Send messages transactionally to the supplied address.")
parser.add_option("-a",
"--address",
default="localhost:5672/examples",
help="address to which messages are sent (default %default)")
parser.add_option("-m",
"--messages",
type="int",
default=100,
help="number of messages to send (default %default)")
parser.add_option(
"-b",
"--batch-size",
type="int",
default=10,
help="number of messages in each transaction (default %default)")
opts, args = parser.parse_args()
try:
Container(TxSend(opts.address, opts.messages, opts.batch_size)).run()
except KeyboardInterrupt:
pass
print(event.message.body)
self.received += 1
if self.received == self.expected:
print('received all', self.expected, 'messages')
event.receiver.close()
event.connection.close()
# the on_transport_error event catches socket and authentication failures
def on_transport_error(self, event):
print("Transport error:", event.transport.condition)
MessagingHandler.on_transport_error(self, event)
def on_disconnected(self, event):
print("Disconnected")
# parse arguments and get options
opts = get_options()
"""
The amqp address can be a topic or a queue.
Do not use a prefix or use 'queue://' in the amqp address for
the amqp receiver source address to receiver messages from a queue.
"""
try:
Container(
Recv(opts.url, opts.address, opts.messages, opts.username,
opts.password)).run()
except KeyboardInterrupt:
pass
from proton import Message
from proton.handlers import MessagingHandler
from proton.reactor import Container
class Handler (MessagingHandler):
def __init__ (self, url, target):
super (Handler, self).__init__ ()
self.url = url
self.target = target
def on_start (self, event):
conn = event.container.connect (self.url)
event.container.create_receiver (conn, self.target)
def on_message (self, event):
print ("Got message: {0}".format (event.message.body))
if event.message.body == 'quit':
print ("Stopping listener")
event.receiver.close ()
event.connection.close ()
try:
Container (Handler ("localhost:5672", "topic://exam.ple.top.ic")).run ()
except KeyboardInterrupt:
pass
print(event._attrs)
if self.received == self.total:
event.connection.close()
event.container.stop()
def on_disconnected(self, event):
print(18)
self.sent = self.confirmed
parser = optparse.OptionParser(
usage="usage: %prog [options]",
description="Send messages to the supplied address.")
parser.add_option("-a",
"--address",
default="localhost:5672/examples",
help="address to which messages are sent (default %default)")
parser.add_option("-m",
"--messages",
type="int",
default=1,
help="number of messages to send (default %default)")
opts, args = parser.parse_args()
try:
container = Container(MyHandler(opts.address, opts.messages))
# container.container_id = 'myqueue'
container.run()
except KeyboardInterrupt:
pass
from proton import Url
class Recv(MessagingHandler):
def __init__(self, url):
super(Recv, self).__init__()
self.url = Url(url)
self.received = 0
def on_start(self, event):
conn = event.container.connect(self.url)
event.container.create_receiver(conn, self.url.path)
def on_message(self, event):
print("Message '%s' received" % event.message.body)
self.received += 1
parser = optparse.OptionParser(usage="usage: %prog [options]")
parser.add_option(
"-a",
"--address",
default="localhost:5672/examples",
help="address from which messages are received (default %default)")
opts, args = parser.parse_args()
try:
Container(Recv(opts.address)).run()
except KeyboardInterrupt:
pass
logger.error("%s: %s: %s" %
(event.transport.condition.name,
event.transport.condition.description,
event.transport.condition.info))
else:
logger.error("%s: %s" %
(event.transport.condition.name,
event.transport.condition.description))
else:
logging.error("Unspecified transport error")
# 当收到消息时被调用。
def on_message(self, event):
message = event.message
content = message.body.decode('utf-8')
topic = message.properties.get("topic")
message_id = message.properties.get("messageId")
print()
logger.info("receive message: message_id=%s, topic=%s, content=%s" %
(message_id, topic, content))
print()
self.update.receive_new_message(content)
event.receiver.flow(1)
try:
Container(AmqpClient()).run()
except Exception as e:
logging.error(e)
Container(AmqpClient()).run()
self.conn, self.address)
self.senders = {}
self.relay = None
def on_message(self, event):
sender = self.relay
if not sender:
sender = self.senders.get(event.message.reply_to)
if not sender:
sender = self.container.create_sender(self.conn,
event.message.reply_to)
self.senders[event.message.reply_to] = sender
response = Message(address=event.message.reply_to,
body=event.message.body.upper(),
correlation_id=event.message.correlation_id)
self.container.declare_transaction(self.conn,
handler=TxRequest(
response, sender,
event.delivery))
def on_connection_open(self, event):
if event.connection.remote_offered_capabilities and 'ANONYMOUS-RELAY' in event.connection.remote_offered_capabilities:
self.relay = self.container.create_sender(self.conn, None)
try:
Container(TxServer("localhost:5672", "examples")).run()
except KeyboardInterrupt:
pass
def run(self):
container = Container(self)
container.run()
def on_connection_closing(self, event):
self.remove_stale_consumers(event.connection)
def on_disconnected(self, event):
self.remove_stale_consumers(event.connection)
def remove_stale_consumers(self, connection):
l = connection.link_head(Endpoint.REMOTE_ACTIVE)
while l:
if l.is_sender:
self._unsubscribe(l)
l = l.next(Endpoint.REMOTE_ACTIVE)
def on_sendable(self, event):
self._queue(event.link.source.address).dispatch(event.link)
def on_message(self, event):
address = event.link.target.address
if address is None:
address = event.message.address
self._queue(address).publish(event.message)
parser = optparse.OptionParser(usage="usage: %prog [options]")
parser.add_option("-a", "--address", default="localhost:5672",
help="address router listens on (default %default)")
opts, args = parser.parse_args()
try:
Container(Broker(opts.address)).run()
except KeyboardInterrupt: pass
if self.conf.amqpd.archive_policy_name:
return self.conf.amqpd.archive_policy_name
# NOTE(sileht): We didn't catch NoArchivePolicyRuleMatch to log it
ap = self.indexer.get_archive_policy_for_metric(metric_name)
return ap.name
parser = optparse.OptionParser(usage="usage: %prog [options]")
parser.add_option(
"-a",
"--address",
default="localhost:5672/examples",
help="address from which messages are received (default %default)")
parser.add_option(
"-m",
"--messages",
type="int",
default=100,
help=
"number of messages to receive; 0 receives indefinitely (default %default)"
)
conf = service.prepare_service()
#if conf.statsd.resource_id is None:
#raise cfg.RequiredOptError("resource_id", cfg.OptGroup("amqpd"))
try:
Container(Amqp(opts.address, opts.messages, conf)).run()
except KeyboardInterrupt:
pass
def run(self):
container = Container(self)
container.container_id = "LRC"
container.run()
def run(self):
container = Container(self)
container.container_id = self.container_id
container.run()
# ignore duplicate message
return
if self.expected == 0 or self.received < self.expected:
print(event.message.body)
self.received += 1
if self.received == self.expected:
event.receiver.close()
event.connection.close()
parser = optparse.OptionParser(usage="usage: %prog [options]")
parser.add_option(
"-a",
"--address",
default="localhost:5672/examples",
help="address from which messages are received (default %default)")
parser.add_option(
"-m",
"--messages",
type="int",
default=100,
help=
"number of messages to receive; 0 receives indefinitely (default %default)"
)
opts, args = parser.parse_args()
try:
Container(Recv(opts.address, opts.messages)).run()
except KeyboardInterrupt:
pass
def on_start(self, event):
print("Listening on", self.url)
self.container = event.container
self.conn = event.container.connect(self.url)
self.receiver = event.container.create_receiver(
self.conn, self.address)
self.server = self.container.create_sender(self.conn, self.address)
def on_message(self, event):
print("Received", event.message)
self.server.send(
Message(address=event.message.reply_to,
body=event.message.body.upper(),
correlation_id=event.message.correlation_id))
parser = optparse.OptionParser(usage="usage: %prog [options]")
parser.add_option(
"-a",
"--address",
default=env.server_addr,
help="address from which messages are received (default %default)")
opts, args = parser.parse_args()
url = Url(opts.address)
try:
Container(Server(url, url.path)).run()
except KeyboardInterrupt:
pass
'JmsMessagesTestSender._create_jms_streammessage: Unknown or unsupported subtype "%s"'
% test_value_type)
return Message(id=(self.sent + 1),
body=body_list,
inferred=True,
annotations=create_annotation('JMS_STREAMMESSAGE_TYPE'))
def _create_jms_textmessage(self, test_value_text):
"""Create a JMS text message"""
return Message(id=(self.sent + 1),
body=unicode(test_value_text),
annotations=create_annotation('JMS_TEXTMESSAGE_TYPE'))
# --- main ---
# Args: 1: Broker address (ip-addr:port)
# 2: Queue name
# 3: JMS message type
# 4: JSON Test parameters containing 3 maps: [testValueMap, testHeadersMap, testPropertiesMap]
#print '#### sys.argv=%s' % sys.argv
#print '>>> test_values=%s' % loads(sys.argv[4])
try:
SENDER = JmsMessagesTestSender(sys.argv[1], sys.argv[2], sys.argv[3],
loads(sys.argv[4]))
Container(SENDER).run()
except KeyboardInterrupt:
pass
except Exception as exc:
print 'jms-sender-shim EXCEPTION:', exc
print format_exc()
def run(self):
Container(self).run()
if self.error is not None:
self.logger.dump()
if self.listener:
self.listener.close()
def on_connection_opening(self, event):
# Sends an empty failover list.
# This will test the case where we deliberately send an empty failover list so that the router
# receiving this open frame will clean out its failover list.
event.connection.properties = {symbol('failover-server-list'): []}
parser = optparse.OptionParser(usage="usage: %prog [options]",
description="Testing Router failover support")
parser.add_option("-a",
"--address",
default="localhost:55671",
help="address to listen on (default %default)")
opts, args = parser.parse_args()
handler = FailoverServer(opts.address)
def sigterm_handler(_signo, _stack_frame):
sys.exit(0)
signal.signal(signal.SIGTERM, sigterm_handler)
Container(handler).run()
self.senders = {}
def on_start(self, event):
print "Listening on:", self.url
self.container = event.container
self.acceptor = event.container.listen(self.url)
def on_message(self, event):
m = event.message
topic = m.subject
body = m.body
sequence = str(m.properties['x-opt-sequence-number'])
if topic == "hashablock":
print '- HASH BLOCK (' + sequence + ') -'
print binascii.hexlify(body)
elif topic == "hashtx":
print '- HASH TX (' + sequence + ') -'
print binascii.hexlify(body)
elif topic == "rawblock":
print '- RAW BLOCK HEADER (' + sequence + ') -'
print binascii.hexlify(body[:80])
elif topic == "rawtx":
print '- RAW TX (' + sequence + ') -'
print binascii.hexlify(body)
try:
Container(Server("127.0.0.1:%i" % port)).run()
except KeyboardInterrupt:
pass
def thread_process2(index):
logDS.info("begin %d"%index)
Container(HelloWorld("examples")).run()
logDS.info("exit %d"%index)
