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 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, 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 __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")
def tearDown(self):
self.running = False
connect("127.0.0.1", PORT).close()
self.server.join(3)
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)
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)
#!/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()
def connect(self, **kwargs):
return Connection(connect("127.0.0.1", PORT), **kwargs)
# 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)
def setup_connection(self):
socket = connect(self._broker.host(), self._broker.port())
return Connection(sock=socket)
