def establish_connection(hostname=None, userid=None, password=None, virtual_host=None, port=None, ssl=None, insist=None, connect_timeout=None, backend_cls=None, defaults=conf): """Establish a connection to the message broker.""" if insist is None: insist = defaults.BROKER_INSIST if ssl is None: ssl = defaults.BROKER_USE_SSL if connect_timeout is None: connect_timeout = defaults.BROKER_CONNECTION_TIMEOUT return BrokerConnection(hostname or defaults.BROKER_HOST, userid or defaults.BROKER_USER, password or defaults.BROKER_PASSWORD, virtual_host or defaults.BROKER_VHOST, port or defaults.BROKER_PORT, backend_cls=backend_cls or defaults.BROKER_BACKEND, insist=insist, ssl=ssl, connect_timeout=connect_timeout)
def __init__(self, hostname='localhost', port=5672, userid="collectoruser", password="******", **options): conn = BrokerConnection(hostname=hostname, port=port, userid=userid, password=password, virtual_host='collectorvhost') try: self.publisher = Publisher(connection=conn, exchange="collector.response", exchange_type='direct', routing_key="response", serializer="json") except Exception as ex: raise Worker.ConnectionException(ex) self.consumer = Consumer(connection=conn, queue="feed", exchange_type='topic', exchange="collector", routing_key="collector.*.*")
def __init__(self, hostname, port, vhost, userid, password): """connects to broker and provides convenience methods""" self.broker = BrokerConnection(hostname=hostname, port=port, userid=userid, password=password, virtual_host=vhost)
def connect(self): if not self.connection: self.connection = BrokerConnection(hostname=self.config.host, port=self.config.port, userid=self.config.user, password=self.config.password, virtual_host=self.config.vhost)
def main(): logging.basicConfig(level=logging.DEBUG) args = parser.parse_args() conn = BrokerConnection( hostname=args.hostname, virtual_host=args.vhost, userid=args.user, password=args.password, ) publisher = Publisher(auto_declare=False, connection=conn, exchange=args.exchange, routing_key=args.key) logging.info("Declaring exchange: %s" % args.exchange) publisher.backend.exchange_declare(exchange=args.exchange, type="topic", durable=False, auto_delete=False) while True: line = sys.stdin.readline() if not line: break logging.debug("Sending message '%s'" % line.strip()) publisher.send(line.strip()) publisher.close()
def cast(msg, event_type, topic, priority): yagi.config.setup(config_path='/etc/yagi.conf') conf = yagi.config.config_with('rabbit_broker') host = conf('host') port = conf('port') user = conf('user') exchange = conf('exchange') password = conf('password') vhost = conf('vhost') message_dict = { 'message_id': str(uuid.uuid4()), 'event_type': event_type, 'publisher_id': 'some_publisher', 'priority': priority, 'timestamp': str(datetime.datetime.utcnow()), 'payload': msg } conn = BrokerConnection(hostname=host, port=port, userid=user, password=password, virtual_host=vhost) publisher = Publisher(connection=conn, exchange=exchange, routing_key="%s.%s" % (topic, priority), durable=False, exchange_type='topic') publisher.send(message_dict) publisher.close()
def __init__(self, host_name, port, userid, password, virtual_host, encoder_class): self.q_connection = BrokerConnection(hostname=host_name, port=port, userid=userid, password=password, virtual_host=virtual_host) self.encoder = encoder_class()
def add(self): broker = BrokerConnection(hostname=self.hostname, port=self.port, userid=self.username, password=self.password, virtual_host=self.vhost) with self.lock: self._brokers.append(broker)
def add_many(self, limit): with self.lock: for _ in range(0, limit): broker = BrokerConnection(hostname=self.hostname, port=self.port, userid=self.username, password=self.password, virtual_host=self.vhost) self._brokers.append(broker)
def __init__(self, host_name, port, userid, password, virtual_host, encoder_class): self.q_connection = BrokerConnection(hostname=host_name, port=port, userid=userid, password=password, virtual_host=virtual_host) self.encoder = encoder_class() dispatcher.connect(self.spider_opened, signals.spider_opened) dispatcher.connect(self.spider_closed, signals.spider_closed)
def test_with_statement(self): with BrokerConnection(**test_connection_args()) as conn: self.assertFalse(conn._closed) with Publisher(connection=conn, exchange="F", routing_key="G") \ as publisher: self.assertFalse(publisher._closed) self.assertTrue(conn._closed) self.assertTrue(publisher._closed) with BrokerConnection(**test_connection_args()) as conn: self.assertFalse(conn._closed) with Consumer(connection=conn, queue="E", exchange="F", routing_key="G") as consumer: self.assertFalse(consumer._closed) self.assertTrue(conn._closed) self.assertTrue(consumer._closed)
def test_messaging(self): m = TMessaging(connection=BrokerConnection(backend_cls=PyQueueBackend)) self.assertTrue(m) self.assertEquals(m.fetch(), None) mdata = {"name": "Cosmo Kramer"} m.send(mdata) next_msg = m.fetch() next_msg_data = next_msg.decode() self.assertEquals(next_msg_data, mdata) self.assertEquals(m.fetch(), None)
def __init__(self, hostname, port, user_id, password, virtual_host, encoder_class): self.queue_connection = BrokerConnection( hostname=hostname, port=port, userid=user_id, password=password, virtual_host=virtual_host ) self.encoder = encoder_class() # Setup / Teardown Rabbit plumbing when spider opens / closes dispatcher.connect(self.spider_opened, signals.spider_opened) dispatcher.connect(self.spider_closed, signals.spider_closed)
def establish_consumer_connection(self, consumer): # for now all consumers use the same queue connection # That may not be the case forever config = conf.config_with("rabbit_broker") reconnect_delay = int(config("reconnect_delay")) max_wait = int(config("max_wait")) # This just sets the connection string. It doesn't actually # connect to the AMQP server yet. connection = BrokerConnection(hostname=config("host"), port=config("port"), userid=config("user"), password=config("password"), virtual_host=config("vhost"), ssl=confbool("ssl")) auto_delete = consumer.config("auto_delete") == "True" or False durable = consumer.config("durable") == "True" or False exdurable = confbool(consumer.config("exchange_durable")) exauto_delete = confbool(consumer.config("exchange_auto_delete")) # try a few times to connect, we might have lost the connection retries = 0 while True: try: carrot_consumer = NotQuiteSoStupidConsumer( connection=connection, warn_if_exists=True, exchange=consumer.config("exchange"), exchange_type=consumer.config("exchange_type"), routing_key=consumer.config("routing_key"), queue=consumer.queue_name, auto_delete=auto_delete, durable=durable, exchange_durable=exdurable, exchange_auto_delete=exauto_delete, ) consumer.connect(connection, carrot_consumer) LOG.info("Connection established for %s" % consumer.queue_name) break except amqplib.client_0_8.exceptions.AMQPConnectionException, e: LOG.error("AMQP protocol error connecting to for queue %s" % consumer.queue_name) LOG.exception(e) except socket.error, e: # lost connection? pass
def get_carrot_connection(config): backend = config.get('queue.library', 'pyamqplib') log.info("Carrot connnection using %s backend" % backend) try: port = int(config.get('queue.port', PORT)) except ValueError: port = PORT userid = config.get('queue.user_id', USERID) password = config.get('queue.password', PASSWORD) hostname = config.get('queue.host', HOSTNAME) virtual_host = config.get('queue.virtual_host', VIRTUAL_HOST) backend_cls = 'carrot.backends.%s.Backend' % backend return BrokerConnection(hostname=hostname, port=port, userid=userid, password=password, virtual_host=virtual_host, backend_cls=backend_cls)
def test_consumer_interface(self): to_send = ['No', 'soup', 'for', 'you!'] messages = [] def cb(message_data, message): messages.append(message_data) conn = BrokerConnection(backend_cls='memory') consumer = Consumer(connection=conn, queue="test", exchange="test", routing_key="test") consumer.register_callback(cb) publisher = Publisher(connection=conn, exchange="test", routing_key="test") for i in to_send: publisher.send(i) it = consumer.iterconsume() for i in range(len(to_send)): it.next() self.assertEqual(messages, to_send)
def main(): logging.basicConfig(level=logging.INFO) args = parser.parse_args() conn = BrokerConnection( hostname=args.hostname, virtual_host=args.vhost, userid=args.user, password=args.password, ) consumer = Consumer( auto_declare=False, connection=conn, exclusive=True, auto_delete=True, ) try: logging.info("Creating exchange: %s" % args.exchange) consumer.backend.exchange_declare(exchange=args.exchange, type="topic", durable=False, auto_delete=True) except Exception, e: logging.warning("Failed to create exchange: %s" % e)
from carrot.connection import BrokerConnection from config import BROKER_CONFIG, PRINTER_CONFIG from pointofsale import printer if __name__ == '__main__': conn = BrokerConnection(**BROKER_CONFIG) registry = printer.PrinterRegistry(PRINTER_CONFIG['registry'], PRINTER_CONFIG['auth_token']) p = printer.TestPrinter(PRINTER_CONFIG['name'], registry, conn) pm_handler = printer.PrinterMessageThread(p) pm_handler.start() while True: pm_handler.join(1) if not pm_handler.is_alive(): break
from carrot.connection import BrokerConnection from carrot.messaging import Consumer if __name__ == '__main__': connection = BrokerConnection(hostname='localhost', port=5672, userid='guest', password='******', virtual_host=None) consumer = Consumer(connection=connection, queue="transactions", exchange="transactions") def print_message(message_data, message): print(message_data) message.ack() consumer.register_callback(print_message) consumer.wait()
def create_backend(): return PyQueueBackend(connection=BrokerConnection())
def establish_test_connection(): return BrokerConnection(**test_connection_args())
"""Message-classes.""" import os, subprocess from os.path import join, split, splitext, exists from carrot.connection import BrokerConnection conn = BrokerConnection(hostname="localhost", port=5672, userid="test", password="******", virtual_host="test") arrot.messaging import Consumer consumer = Consumer(connection=conn, queue="feed", exchange="feed", routing_key="importer") def import_feed_callback(message_data, message): feed_url = message_data["import_feed"] print("Got feed import message for: %s" % feed_url) # something importing this feed url # import_feed(feed_url) message.ack() consumer.register_callback(import_feed_callback) consumer.wait() # Go into the consumer loop.
def create_connection(): return BrokerConnection(backend_cls=StompBackend, **test_stomp_connection_args())