def __init__(self, host='localhost', port=5672, ssl=None): ''' Connect to QPID and make bindings to route message to external.dropbox queue @param host: string hostname of computer running EDEX and QPID (default localhost) @param port: integer port used to connect to QPID (default 5672) @param ssl: boolean to determine whether ssl is used, default value of None will use ssl only if a client certificate is found. ''' try: # socket = connect(host, port) if "QPID_SSL_CERT_DB" in os.environ: certdb = os.environ["QPID_SSL_CERT_DB"] else: certdb = os.path.expanduser("~/.qpid/") if "QPID_SSL_CERT_NAME" in os.environ: certname = os.environ["QPID_SSL_CERT_NAME"] else: certname = QPID_USERNAME certfile = os.path.join(certdb, certname + ".crt") if ssl or (ssl is None and os.path.exists(certfile)): keyfile = os.path.join(certdb, certname + ".key") trustfile = os.path.join(certdb, "root.crt") socket = qpid.util.ssl(socket, keyfile=keyfile, certfile=certfile, ca_certs=trustfile) self.connection = Connection (sock=socket, username=QPID_USERNAME, password=QPID_PASSWORD) self.connection.start() self.session = self.connection.session(str(uuid4())) self.session.exchange_bind(exchange='amq.direct', queue='external.dropbox', binding_key='external.dropbox') print 'Connected to Qpid' except: print 'Unable to connect to Qpid'
def get_qpid_connection(broker_addr): try: socket = connect(broker_addr, 5672) connection = Connection (sock=socket) connection.start() return connection except: sys.stderr.write("mhsAckNotify: connect to %s: %s\n" % (broker_addr, sys.exc_info()[1],)) return None
def connect(self, host=None, port=None): url = self.broker if url.scheme == URL.AMQPS: default_port = 5671 else: default_port = 5672 try: sock = connect(host or url.host, port or url.port or default_port) except socket.error, e: raise Skipped(e)
def run(self): # Create connection and session socket = connect( self.host, self.port) connection = Connection(sock=socket, username=self.username, password=self.password) print("consumer "+self.queueName+": starting connection...") connection.start() print("consumer "+self.queueName+": ...connection started") print("consumer "+self.queueName+": getting session...") session = connection.session(str(uuid4())) print("consumer "+self.queueName+": ...session got") # Define local queue local_queue_name = 'my_local_queue_' +self.queueName # Create local queue print("consumer "+self.queueName+": getting queue...") queue = session.incoming(local_queue_name) print("consumer "+self.queueName+": ...queue got") # Route messages from message_queue to my_local_queue print("consumer "+self.queueName+": subscribing...") session.message_subscribe(queue = self.queueName, destination=local_queue_name) print("consumer "+self.queueName+": ...subscribed") print("consumer "+self.queueName+": starting queue...") queue.start() print("consumer "+self.queueName+": ...queue started") content = '' index = 0 while (self.running): try: # Get message from the local queue, timeout 5 seconds message = queue.get(timeout=5) except: break # exit this thread, consumer # Get body of the message content = message.body #message_properties = message.get("message_properties") # Accept message (removes it from the queue) session.message_accept(RangedSet(message.id)) if (content != ""): try: self.readGPB(content) except Exception, e: print( "Unexpected error: %s\n" % str(e) )
def __init__(self, broker, **kw): self.set_broker(broker) self.socket = connect(self.host, self.port) if self.url.scheme == URL.AMQPS: self.socket = ssl(self.socket) self.connection = Connection(sock=self.socket, username=self.user, password=self.password) self.connection.start() log.info("Connected to AMQP Broker %s" % self.host) self.session = self.connection.session(str(uuid4()))
def __init__(self, hub, config): self.config = config self.set_broker(self.config.get('amqp_broker')) self.socket = connect(self.host, self.port) if self.url.scheme == URL.AMQPS: self.socket = ssl(self.socket) self.connection = Connection(sock=self.socket, username=self.user, password=self.password) self.connection.start() log.info("Connected to AMQP Broker %s" % self.host) self.session = self.connection.session(str(uuid4())) self.local_queues = [] super(QpidAMQPHubExtension, self).__init__()
def get_qpid_connection(broker_host): try: socket = connect(broker_host, 5672) connection = Connection(sock=socket, username=QPID_USERNAME, password=QPID_PASSWORD) connection.start() return connection except: sys.stderr.write("mhsAckNotify: connect to %s: %s\n" % ( broker_host, sys.exc_info()[1], )) return None
def __init__(self, model, host, port): self.model = model self.host = host self.port = port self.broker_id = "%s:%i" % (self.host, self.port) self.conn = Connection(connect(host, port), self.model.spec) self.mclient = managementClient( self.model.spec, None, self.model.on_props, self.model.on_stats, self.model.on_callback ) self.mclient.schemaListener(self.model.on_schema) self.chan = None self.model.connections[self.broker_id] = self
def __init__(self, host='localhost', port=5672): ''' Connect to QPID and make bindings to route message to external.dropbox queue @param host: string hostname of computer running EDEX and QPID (default localhost) @param port: integer port used to connect to QPID (default 5672) ''' try: # self.socket = connect(host, port) self.connection = Connection (sock=self.socket, username=QPID_USERNAME, password=QPID_PASSWORD) self.connection.start() self.session = self.connection.session(str(uuid4())) self.session.exchange_bind(exchange='amq.direct', queue='external.dropbox', binding_key='external.dropbox') print('Connected to Qpid') except: print('Unable to connect to Qpid')
def start(self): """ Enable AMQP queueing. This method puts up the event processor and sets it to "active". """ self.log.debug("enabling AMQP queueing") # Evaluate username user = self.config.get("amqp.id", default=None) if not user: user = self.env.uuid password = self.config.get("amqp.key") # Create initial broker connection url = "%s:%s" % (self.url['host'], self.url['port']) self._conn = Connection.establish(url, reconnect=self.reconnect, username=user, password=password, transport=self.url['transport'], reconnect_interval=self.reconnect_interval, reconnect_limit=self.reconnect_limit) # Do automatic broker failover if requested if self.config.get('amqp.failover', False): auto_fetch_reconnect_urls(self._conn) # Create event exchange socket = connect(self.url['host'], self.url['port']) if self.url['scheme'][-1] == 's': socket = ssl(socket) user = self.config.get("amqp.id", default=None) if not user: user = self.env.uuid connection = DirectConnection(sock=socket, username=user, password=self.config.get("amqp.key")) connection.start() session = connection.session(str(uuid4())) # pylint: disable=E1103 session.exchange_declare(exchange=self.env.domain, type="xml") connection.close() # Create event provider self._eventProvider = EventProvider(self.env, self.getConnection())
def __init__(self, disp, host, username="******", password="******"): self.lock = Lock() self.tables = {} self.schema = {} self.bootSequence = 0 self.operational = False self.disp = disp self.cli = None self.lastUnit = None self.methodSeq = 1 self.methodsPending = {} self.sessionId = "%s.%d" % (platform.uname()[1], os.getpid()) self.broker = Broker(host) sock = connect(self.broker.host, self.broker.port) oldTimeout = sock.gettimeout() sock.settimeout(10) self.conn = Connection(sock, username=self.broker.username, password=self.broker.password) def aborted(): raise Timeout( "Waiting for connection to be established with broker") oldAborted = self.conn.aborted self.conn.aborted = aborted self.conn.start() sock.settimeout(oldTimeout) self.conn.aborted = oldAborted self.mclient = managementClient("unused", self.ctrlHandler, self.configHandler, self.instHandler, self.methodReply, self.closeHandler) self.mclient.schemaListener(self.schemaHandler) self.mch = self.mclient.addChannel(self.conn.session(self.sessionId)) self.operational = True self.idMap = {} self.idBackMap = {} self.nextId = 101
def __init__(self, host='localhost', port=5672): ''' Connect to QPID and make bindings to route message to external.dropbox queue @param host: string hostname of computer running EDEX and QPID (default localhost) @param port: integer port used to connect to QPID (default 5672) ''' try: # self.socket = connect(host, port) self.connection = Connection(sock=self.socket, username=QPID_USERNAME, password=QPID_PASSWORD) self.connection.start() self.session = self.connection.session(str(uuid4())) self.session.exchange_bind(exchange='amq.direct', queue='external.dropbox', binding_key='external.dropbox') print('Connected to Qpid') except: print('Unable to connect to Qpid')
def __init__ (self, disp, host, username="******", password="******"): self.lock = Lock () self.tables = {} self.schema = {} self.bootSequence = 0 self.operational = False self.disp = disp self.cli = None self.lastUnit = None self.methodSeq = 1 self.methodsPending = {} self.sessionId = "%s.%d" % (platform.uname()[1], os.getpid()) self.broker = Broker (host) sock = connect (self.broker.host, self.broker.port) oldTimeout = sock.gettimeout() sock.settimeout(10) self.conn = Connection (sock, username=self.broker.username, password=self.broker.password) def aborted(): raise Timeout("Waiting for connection to be established with broker") oldAborted = self.conn.aborted self.conn.aborted = aborted self.conn.start () sock.settimeout(oldTimeout) self.conn.aborted = oldAborted self.mclient = managementClient ("unused", self.ctrlHandler, self.configHandler, self.instHandler, self.methodReply, self.closeHandler) self.mclient.schemaListener (self.schemaHandler) self.mch = self.mclient.addChannel (self.conn.session(self.sessionId)) self.operational = True self.idMap = {} self.idBackMap = {} self.nextId = 101
def get_session(self, user, passwd): socket = connect(self.broker.host, self.broker.port) connection = Connection (sock=socket, username=user, password=passwd, mechanism="PLAIN") connection.start() return connection.session(str(uuid4()))
def dump_queue(binfo, queue_name, to): # Create a client and log in to it. child_connection = Connection(sock=connect(str(binfo['ip']), int(binfo['port']))) child_connection.start() child_session = child_connection.session(str(uuid4())) child_session.queue_declare(queue=queue_name, exclusive=True) child_session.exchange_bind(exchange='amq.direct', queue=queue_name, binding_key=queue_name) print 'Messages queue: ' + queue_name # Create the local queue. Use the queue name as destination name dest = queue_name queue = child_session.incoming(dest) # Subscribe the local queue to the queue on the server child_session.message_subscribe(queue=queue_name, destination=dest, accept_mode=child_session.accept_mode.explicit) child_session.message_flow(dest, child_session.credit_unit.message, 0xFFFFFFFFL) child_session.message_flow(dest, child_session.credit_unit.byte, 0xFFFFFFFFL) # Read responses as they come in and print to the screen. message = 0 count = 0 while True: try: message = queue.get(timeout=to) count = count + 1 if count == 1: print 'Received first reponse: %s ' % str(time.time()) except Empty: print 'Received %s messages: %s' % (str(count), str(time.time() - to)) break # except qpid.session.Closed: # print "Re-establishing" # try: # child_connection.close() # except: # pass # # # Give broker time to stablize and accept connections # time.sleep(2) # child_connection = Connection(sock=connect(str(binfo['ip']), int(binfo['port']))) # child_connection.start() # child_session = child_connection.session(str(uuid4())) # child_session.queue_declare(queue=queue_name, exclusive=True) # child_session.exchange_bind(exchange='amq.direct', queue=queue_name, binding_key=queue_name) # # # Create the local queue. Use the queue name as destination name # queue = child_session.incoming(dest) # # # Subscribe the local queue to the queue on the server # child_session.message_subscribe(queue=queue_name, destination=dest, accept_mode=child_session.accept_mode.explicit) # child_session.message_flow(dest, child_session.credit_unit.message, 0xFFFFFFFFL) # child_session.message_flow(dest, child_session.credit_unit.byte, 0xFFFFFFFFL) except: print 'Unexpected exception!' break if message != 0: child_session.message_accept(RangedSet(message.id)) child_session.close(timeout=10) child_connection.close() return (0)
def tearDown(self): self.running = False connect("127.0.0.1", PORT).close() self.server.join(3)
def connect(self, **kwargs): return Connection(connect("127.0.0.1", PORT), **kwargs)
# Any functions and classes needed for a given example # go here. #----- Initialization ----------------------------------- # Set parameters for login host = "127.0.0.1" port = 5672 user = "******" password = "******" # Create a connection and a session. The constructor for a session # requires a UUID to uniquely identify the session. socket = connect(host, port) connection = Connection(sock=socket) connection.start() session = connection.session(str(uuid4())) print connection #----- Main Body of Program -------------------------------- # Main body of each example goes here #----- Cleanup --------------------------------------------- # Close the session before exiting so there are no open threads. session.close(timeout=10)
def __init__(self, conn, host, port): self.socket = connect(host, port) if conn.tcp_nodelay: self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
from qpid.harness import Skipped from qpid.exceptions import VersionError from qpid.spec08 import load from qpid.connection import Connection from qpid.util import connect from qpid.session import Session import qpid.delegate import time from qpid.datatypes import Message, RangedSet, serial from qpid.ops import * logging.basicConfig(level=logging.DEBUG) address = "amq.topic" sock = connect("127.0.0.1", "5672") conn = Connection(sock, username="******", password="******", vhost="/ssw", client_properties={"client_process": "aa"}) conn.start(timeout=10000) session = conn.session("PYTHON_SESSION") time.sleep(5) session.queue_declare(queue="test-queue", exclusive=True, auto_delete=True) session.exchange_declare("test", "direct") session.exchange_bind(queue="test-queue", exchange="test", binding_key="key")
import optparse parser = optparse.OptionParser() parser.add_option("-t", "--targets", dest="targets", default="localhost", help="comma-separated list of target hostnames running qpid") parser.add_option("-d", "--debug", dest="debug", action="store_true", help="debug what messages are being sent") options, args = parser.parse_args() options.targets = [t.strip() for t in options.targets.split(',')] # Create connection and session session_dicts = [] for target in options.targets: print "Attempting to setup connection with", target try: socket = connect(target, 5672) connection = Connection( socket, username='******', password='******', ) connection.start(timeout=10000) session = connection.session(str(uuid4())) # Setup routing properties properties = session.delivery_properties(routing_key='httpdlight_http_rawlogs') session_dicts.append({ 'target' : target, 'socket' : socket, 'connection' : connection, 'session' : session, 'properties' : properties, })
broker_info['port'] = broker_info['broker_port'] broker_info['queue'] = broker_info['broker_queue'] except ConfigError, error: print '%s' % error.msg print 'Attempting to retrieve config from %s' % conf_file try: broker_info = read_config_file(conf_file, 'Broker') except ConfigError, error: print '%s' % error.msg print 'Exiting' return(FAILURE) replyTo = str(uuid4()) # Create a client and log in to it. connection = Connection(sock=connect(str(broker_info['ip']), int(broker_info['port']))) connection.start() session = connection.session(str(uuid4())) session.queue_declare(queue=replyTo, exclusive=True, auto_delete=True) session.queue_declare(queue=broker_info['queue'], exclusive=False, durable="true") session.exchange_bind(exchange='amq.direct', queue=broker_info['queue'], binding_key='grid') session.exchange_bind(exchange='amq.direct', queue=replyTo, binding_key=replyTo) # Create the local queue. Use the queue name as destination name dest = replyTo recv_queue = session.incoming(dest) print 'Messages queue: ' + dest # Subscribe the local queue to the queue on the server
def setup_connection(self): socket = connect(self._broker.host(), self._broker.port()) return Connection(sock=socket)
#!/usr/bin/env python from qpid.connection import Connection from qpid.datatypes import Message, uuid4 from qpid.util import connect import sys import optparse parser = optparse.OptionParser() parser.add_option("-t", "--target", dest="target", default="localhost", help="target hostname running qpid") parser.add_option("-d", "--debug", dest="debug", action="store_true", help="debug what messages are being sent") options, args = parser.parse_args() # Create connection and session socket = connect(options.target, 5672) connection = Connection(sock=socket, username='******', password='******') connection.start() session = connection.session(str(uuid4())) # Setup queue session.queue_declare(queue='message_queuefoobar') session.exchange_bind(exchange='amq.topic', queue='message_queuefoobar', binding_key='httpdlight_http_rawlogs') # Setup routing properties properties = session.delivery_properties(routing_key='httpdlight_http_rawlogs') while True: msg = sys.stdin.readline()
# Set parameters for login host="127.0.0.1" port=5672 user="******" password="******" # If an alternate host or port has been specified, use that instead # (this is used in our unit tests) if len(sys.argv) > 1 : host=sys.argv[1] if len(sys.argv) > 2 : port=int(sys.argv[2]) # Create a connection. socket = connect(host, port) connection = Connection (sock=socket, username=user, password=password) connection.start() session = connection.session(str(uuid4())) #----- Read from queue -------------------------------------------- # Now let's create a local client queue and tell it to read # incoming messages. # The local_queue_name identifies the client-side queue. local_queue_name = "local_queue" queue = session.incoming(local_queue_name) # Call message_subscribe() to tell the broker to deliver messages
help="amqp topic to talk on.") parser.add_option("-d", "--debug", dest="debug", action="store_true", help="debug what messages are being sent") options, args = parser.parse_args() options.targets = [t.strip() for t in options.targets.split(',')] # Create connection and session session_dicts = [] for target in options.targets: print "Attempting to setup connection with", target try: socket = connect(target, 5672) connection = Connection( socket, username='******', password='******', ) connection.start(timeout=10000) session = connection.session(str(uuid4())) # Setup routing properties print "Talking to %s on topic %s" % (target, options.topic) properties = session.delivery_properties(routing_key=options.topic) session_dicts.append({ 'target': target, 'socket': socket, 'connection': connection,
def dump_queue(queue, ses, con, num_msgs, to, dest, broker): # Read responses as they come in and print to the screen. message = 0 count = 0 expected = 2*int(num_msgs) while True: try: message = queue.get(timeout=to) content = message.body count = count + 1 job_data = message.get('message_properties').application_headers print 'Reply Message ID: ' + str(message.get('message_properties').message_id) print 'Correlation ID: ' + str(message.get('message_properties').correlation_id) print 'Headers:' for header in job_data.keys(): print header + ': ' + str(job_data[header]) # print '' # print 'Body: ' # print content print '' except Empty: if count < expected: print 'Only received %d messages but expected %d. TEST FAILED!' % (count, expected) else: print 'Received %d messages. TEST PASSED.' % count break except qpid.session.Closed: try: con.close() except: pass # Give broker time to stablize and accept connections time.sleep(2) con = Connection(sock=connect(str(broker['ip']), int(broker['port']))) con.start() ses = con.session(str(uuid4())) ses.queue_declare(queue=dest, exclusive=True) ses.queue_declare(queue=broker['queue'], exclusive=False, durable=True) ses.exchange_bind(exchange='amq.direct', queue=broker['queue'], binding_key='grid') ses.exchange_bind(exchange='amq.direct', queue=dest, binding_key=dest) # Create the local queue. Use the queue name as destination name queue = ses.incoming(dest) # Subscribe the local queue to the queue on the server ses.message_subscribe(queue=dest, destination=dest, accept_mode=ses.accept_mode.explicit) ses.message_flow(dest, ses.credit_unit.message, 0xFFFFFFFFL) ses.message_flow(dest, ses.credit_unit.byte, 0xFFFFFFFFL) except: print 'Unexpected exception!' break if message != 0: ses.message_accept(RangedSet(message.id)) return (0)