def connect(options):
# port 5671 is for SSL, port 5672 is for TCP
if options.keyfile is not None or options.certfile is not None:
if options.keyfile is None:
print("you must specify a key file for user with your cert file")
sys.exit(1)
if options.certfile is None:
print("you must specify a cert file for user with your key file")
sys.exit(1)
if options.ca_certfile is None:
print("you must specify a ca_certs file")
sys.exit(1)
print("connecting to %s:5671 with certificate and key" % options.server)
return amqp.Connection(host="%s:%d" % (options.server,5671),
login_method="EXTERNAL",
virtual_host=options.vhost,
ssl={"keyfile":options.keyfile,
"certfile":options.certfile,
"cert_reqs":ssl.CERT_REQUIRED,
"ca_certs":options.ca_certfile},
heartbeat=60)
if options.password is not None and options.ask_pass:
print("don't specify -p and -P")
sys.exit(1)
if options.password is not None or options.ask_pass:
if options.user is None:
print("you must specify a user if you provide a password")
sys.exit(1)
if options.user is not None:
if options.password is None:
if options.ask_pass:
options.password = getpass.getpass("password for %s:" % options.user)
else:
print("you must specify a password along with a user")
sys.exit(1)
if options.ca_certfile is not None:
print("connecting over SSL to %s:5671 with username and password" % options.server)
return amqp.Connection(host="%s:%d" % (options.server,5671),
userid=options.user,
password=options.password,
virtual_host=options.vhost,
ssl={"cert_reqs":ssl.CERT_REQUIRED,
"ca_certs":options.ca_certfile},
heartbeat=60)
else:
print("connecting over TCP to %s:5672 with username and password" % options.server)
return amqp.Connection(host="%s:%d" % (options.server,5672),
userid=options.user,
password=options.password,
virtual_host=options.vhost,
heartbeat=60)
else:
print("connecting to %s:5672 anonymously" % options.server)
return amqp.Connection(host="%s:%d" % (options.server,5672),
virtual_host=options.vhost,
heartbeat=60)
def get_connection(
hostname, port, vhost, use_tls=False, keyfile=None, certfile=None):
host = '%s:%s' % (hostname, port)
if use_tls:
return amqp.Connection(host=host, vhost=vhost, ssl={
'keyfile': keyfile,
'certfile': certfile
}
)
else:
return amqp.Connection(host=host, vhost=vhost)
def __init__(self, uri="amqp://*****:*****@localhost:5672", exchange="is"):
url = urllib.parse.urlparse(uri)
self.connection = amqp.Connection(
host="{}:{}".format(url.hostname or "localhost", url.port or 5672),
userid=url.username or "guest",
password=url.password or "guest",
virtual_host='/'
if not url.path or url.path == '/' else url.path[1:],
connect_timeout=5.0,
)
self.connection.connect()
self._channel = self.connection.channel()
self._channel.auto_decode = False
self._exchange = exchange
self._channel.exchange_declare(
exchange=self._exchange,
type="topic",
durable=False,
auto_delete=False,
)
self.subscriptions = []
self.amqp_message = None
def Connect_AMQP_UserPass(self):
ssl_opts = {
'ca_certs': os.environ.get('X509_USER_CERT'),
'ssl_version': ssl.PROTOCOL_TLSv1_2
}
for host in [
self.config['AMQP_PRIMARY'], self.config['AMQP_FALLBACK']
]:
try:
eprint('AMQP connecting to host={} as userid={}'.format(
host, self.config['AMQP_USERID']))
self.AMQP_connection = amqp.Connection(
login_method='AMQPLAIN',
host=host,
virtual_host='xsede',
userid=self.config['AMQP_USERID'],
password=self.config['AMQP_PASSWORD'],
heartbeat=120,
ssl=ssl_opts)
self.AMQP_connection.connect()
self.AMQP_channel = self.AMQP_connection.channel()
return self.AMQP_channel
except Exception as ex:
eprint('AMQP connect error: ' + format(ex))
eprint('Failed to connect to all AMQP services')
sys.exit(1)
def stopSCMB(host):
logging.info("ovincidents: stopSCMB: Start")
EXCHANGE_NAME = 'scmb'
dest = host + ':5671'
# Setup our ssl options
ssl_options = ({
'ca_certs': 'certs/' + host + '-caroot.pem',
'certfile': 'certs/' + host + '-client.pem',
'keyfile': 'certs/' + host + '-key.pem',
'cert_reqs': ssl.CERT_REQUIRED,
'ssl_version': ssl.PROTOCOL_TLSv1_1,
'server_side': False
})
logging.info("ovincidents : recv: ssl_options %s", ssl_options)
# Connect to RabbitMQ
conn = amqp.Connection(dest, login_method='EXTERNAL', ssl=ssl_options)
ch = conn.channel()
qname, _, _ = ch.queue_declare()
ch.queue_bind(qname, EXCHANGE_NAME, 'scmb.#')
# Send a message to end this queue
# This code written based on info provided by https://www.rabbitmq.com/consumer-cancel.html
# basic_cancel(msg.consumer_tag)
print(ch)
ch.basic_cancel(None, None)
ch.close()
logging.info("ovincidents: stopSCMB: End")
def recv(host, route):
# Create and bind to queue
EXCHANGE_NAME = 'scmb'
dest = host + ':5671'
# Setup our ssl options
ssl_options = ({
'ca_certs': 'caroot.pem',
'certfile': 'client.pem',
'keyfile': 'key.pem',
'cert_reqs': ssl.CERT_REQUIRED,
'server_side': False
})
# Connect to RabbitMQ
conn = amqp.Connection(dest, login_method='EXTERNAL', ssl=ssl_options)
conn.connect()
ch = conn.channel()
qname, _, _ = ch.queue_declare()
ch.queue_bind(qname, EXCHANGE_NAME, route)
ch.basic_consume(qname, callback=partial(callback, ch))
# Start listening for messages
while ch.callbacks:
ch.wait(amqp.spec.Queue.BindOk)
ch.close()
conn.close()
def __connect(self):
self.conn = amqp.Connection(**self.params)
self.chan = self.conn.channel()
self.chan.exchange_declare(exchange=self.exchange_name,
type=self.exchange_type,
auto_delete=False,
durable=True)
def connect(self):
"""
Connects to the given AMQP instance, defined in `self._config`.
:returns Bool: True if connection and channel is established successfully.
"""
params = self._build_connection_params()
self._connection = amqp.Connection(**params)
# handle older and newer versions of amqp
try:
self._connection.connect()
except: # NOQA
pass
self._channel = self._connection.channel()
is_valid_connection = self._connection and self._channel
if is_valid_connection:
__log__.info("Connection successfully created.")
else:
__log__.error("FAILED to create connection or channel!")
return is_valid_connection
def connection(request):
host = '%s:%s' % (
os.environ.get('RABBITMQ_HOST', 'localhost'),
os.environ.get('RABBITMQ_5672_TCP', '5672')
)
vhost = getattr(request.config, "slaveinput", {}).get("slaveid", None)
return amqp.Connection(host=host, vhost=vhost)
def submit_job(app_id, app_key, task_id, mimetype, text_col, dedupe):
"""Submit a job to the queue for the Celery worker. Create the required JSON message and post it to RabbitMQ."""
# These are the args that the Python function in the adjunct processor will use.
kwargs = {
"app_id": app_id,
"app_key": app_key,
"task_id": task_id,
"format": mimetype,
"text_col": text_col,
"dedupe": dedupe,
"s3_endpoint": S3ENDPOINT,
"bucket": BUCKET,
"redis_port": REDISPORT,
"redis_host": REDISHOST
}
# Recreate a celery message manually so that we don't need to import celery_tasks.py which has heavy dependencies.
job = {
"id": task_id,
# "task": "synapsify_adjunct.celery_tasks.synapsify_master",
"task": "dc2_master",
"kwargs": kwargs
}
# Connect to RabbitMQ and post.
conn = amqp.Connection(host=RMQHOST,
port=RMQPORT,
userid=RMQUSERNAME,
password=RMQPASSWORD,
virtual_host=RMQVHOST,
insist=False)
cha = conn.channel()
msg = amqp.Message(json.dumps(job))
msg.properties["content_type"] = "application/json"
cha.basic_publish(routing_key=RMQEXCHANGE, msg=msg)
cha.close()
conn.close()
def _connect(self, service):
if self.connection is not None:
self._close()
toks = service.split(":")
host = toks[0]
try:
port = int(toks[1])
except:
if self.ssl_options is None:
port = 5672
else:
port = 5671
if self.ssl_options is None:
ssl = False
login_method = "AMQPLAIN"
else:
ssl = self.ssl_options
if "certfile" in ssl:
login_method = "EXTERNAL"
else:
login_method = "AMQPLAIN"
self.connection = amqp.Connection(host="%s:%d" % (host, port),
login_method=login_method,
userid=self.username,
password=self.password,
virtual_host=self.vhost,
ssl=ssl,
heartbeat=60,
confirm_publish=True)
self.channel = self.connection.channel()
def connect(self):
"""
连接rabbitmq服务器
"""
k = self.symbol()
if k not in connection_pool:
self.connection = amqp.Connection(
host="%s:%s" % (self.host, self.port),
userid=self.username or 'guest',
password=self.password or 'guest',
virtual_host=unquote(self.path.lstrip('/') or '%2F'))
self.connection.connect()
self.channel = self.connection.channel()
connection_pool[k] = self.connection
channel_pool[k] = self.channel
else:
self.connection = connection_pool[k]
if not self.connection.connected:
del connection_pool[k]
channel_pool[k].close()
del channel_pool[k]
self.connect()
else:
self.channel = channel_pool[k]
try:
self.channel.queue_declare(self.queuename, durable=True)
except amqp.exceptions.PreconditionFailed:
pass
def conn(self):
"""Find or create current greenlet's AMQP connection"""
gid = self.greenlet_id
if gid not in self.conns:
log.debug("%s: Opening new AMQP connection.", self.lbl)
self.conns[gid] = amqp.Connection(config.AMQP_URI)
return self.conns[gid]
def connect(self):
try:
self._connection = amqp.Connection(**self.connkwargs)
self._connection.connect()
self._channel = self._connection.channel()
except Exception:
raise ConnectionError('Connect failed')
def main():
"""Creates connection to amqp on HOST to channel DRIVE, """
parser = ArgumentParser()
parser.add_argument('--config', '-c', required=True, type=FileType('r'))
parser.add_argument('--host', '-h', default=HOST)
parser.add_argument('--queue', '-q', default=DRIVE_QUEUE)
parser.add_argument('--device', '-d', default=None)
args = parser.parse_args()
connection = amqp.Connection(args.host)
channel = connection.channel()
channel.queue_declare(queue=args.queue)
# maybe add controller callibration??
if args.device is None:
args.device = DEVICE
device = evdev.device.InputDevice(args.device) # get evdev device
config = json.load(args.config)
args.config.close()
events = ((config[str(event.code)], event.value)
for event in device.read_loop())
events = (event for event in events if event[0] in EVENT_TO_ACTION)
for msg in messages(events):
print(msg)
channel.basic_publish(msg, routing_key=args.queue)
def publish_messages():
with amqp.Connection('localhost',
userid="iotile",
password="******",
confirm_publish=True) as c:
ch = c.channel()
with open("/opt/src/messages.txt", "r") as input_messages:
line = input_messages.readline()
while len(line) > 0:
signal, site, machine, value = line.split(",")
body = {"value": float(value)}
jbody = json.dumps(body)
message = amqp.Message(body=jbody,
application_headers={
"timestamp_in_ms":
int(time.time() * 1000)
})
ch.basic_publish(
message,
exchange="amq.topic",
routing_key=f'raw.arch.{site}.{machine}.{signal}')
time.sleep(0.1)
line = input_messages.readline()
def main():
parser = optparse.OptionParser()
parser.add_option('-c',
'--config-file',
help='Galaxy configuration file',
dest='config_file',
action='store')
parser.add_option(
'-s',
'--http-server-section',
help='Name of the HTTP server section in the Galaxy configuration file',
dest='http_server_section',
action='store')
(opts, args) = parser.parse_args()
log.debug("GALAXY LISTENER PID: " + str(os.getpid()) + " - " + str(opts))
# read the Galaxy config file
global config_file_name
config_file_name = opts.config_file
global config
config = ConfigParser.ConfigParser()
config.read(opts.config_file)
global http_server_section
http_server_section = opts.http_server_section
amqp_config = {}
for option in config.options("galaxy_amqp"):
amqp_config[option] = config.get("galaxy_amqp", option)
log.debug(str(amqp_config))
# connect
conn = amqp.Connection(host=amqp_config['host'] + ":" +
amqp_config['port'],
userid=amqp_config['userid'],
password=amqp_config['password'],
virtual_host=amqp_config['virtual_host'])
chan = conn.channel()
chan.queue_declare(queue=amqp_config['queue'],
durable=True,
exclusive=True,
auto_delete=False)
chan.exchange_declare(
exchange=amqp_config['exchange'],
type="direct",
durable=True,
auto_delete=False,
)
chan.queue_bind(queue=amqp_config['queue'],
exchange=amqp_config['exchange'],
routing_key=amqp_config['routing_key'])
chan.basic_consume(queue=amqp_config['queue'],
no_ack=True,
callback=recv_callback,
consumer_tag="testtag")
log.debug('Connected to rabbitmq server - ' + amqp_config['host'] + ":" +
amqp_config['port'])
while True:
chan.wait()
chan.basic_cancel("testtag")
chan.close()
conn.close()
def run(self, config_path: str, broker: str, device: str) -> "IO ()":
connection = amqp.Connection(broker)
channel = connection.channel()
for queue in self.queues:
channel.queue_declare(queue=queue, arguments=QUEUE_ARGS)
device = evdev.device.InputDevice(device)
super().run(config_path, device.read_loop(), partial(sink, channel))
def setUp(self):
self.exchange = 'test_exchange'
self.type = 'direct'
self.msg_body = 'test_message'
self.routing_key = 'test_routing_key'
self.connection = amqp.Connection()
self.channel = self.connection.channel()
self.channel.exchange_declare(exchange=self.exchange, type=self.type)
def main():
parser = OptionParser(
usage='usage: %prog [options] message\nexample: %prog hello world', )
parser.add_option(
'--host',
dest='host',
help='AMQP server to connect to (default: %default)',
default='localhost',
)
parser.add_option(
'-u',
'--userid',
dest='userid',
help='userid to authenticate as (default: %default)',
default='guest',
)
parser.add_option(
'-p',
'--password',
dest='password',
help='password to authenticate with (default: %default)',
default='guest',
)
parser.add_option(
'--ssl',
dest='ssl',
action='store_true',
help='Enable SSL (default: not enabled)',
default=False,
)
options, args = parser.parse_args()
if not args:
parser.print_help()
sys.exit(1)
msg_body = ' '.join(args)
conn = amqp.Connection(options.host,
userid=options.userid,
password=options.password,
ssl=options.ssl)
ch = conn.channel()
ch.exchange_declare('myfan', 'fanout')
msg = amqp.Message(msg_body,
content_type='text/plain',
application_headers={
'foo': 7,
'bar': 'baz'
})
ch.basic_publish(msg, 'myfan')
ch.close()
conn.close()
def drive(self) -> "IO ()":
"""Opens connect, channel and consumes until channel closed"""
connection = amqp.Connection(self.host)
channel = connection.channel()
channel.queue_declare(queue=self.queue)
channel.basic_consume(queue=self.queue, callback=self.callback)
while channel.callbacks:
channel.wait()
def get_connection(hostname,
port,
vhost,
use_tls=False,
keyfile=None,
certfile=None,
ca_certs=None):
host = f'{hostname}:{port}'
if use_tls:
return amqp.Connection(host=host,
vhost=vhost,
ssl={
'keyfile': keyfile,
'certfile': certfile,
'ca_certs': ca_certs,
})
else:
return amqp.Connection(host=host, vhost=vhost)
def _connect(self):
try:
self.close()
except Exception:
pass
self.connection = amqp.Connection(**self.connection_parameters)
self.channel = self.connection.channel()
if self.subscription:
self._subscribe()
def reconnect(self):
parsed = urlparse.urlparse(self.amqp_url)
port = parsed.port or 5672
self.connection = amqp.Connection(
host="%s:%s" % (parsed.hostname, port),
userid=parsed.username,
password=parsed.password,
virtual_host=unquote(parsed.path.lstrip('/')))
self.channel = self.connection.channel()
self.channel.queue_declare(self.name)
def ensure_chan(self):
'''获取channel'''
if not isinstance(self.con, amqp.connection.Connection):
self.con = amqp.Connection(host=config.MQ_HOST, userid=config.MQ_UID, \
password=config.MQ_PWD, virtual_host=config.MQ_VHOST, insit=False)
else:
for k in self.con.channels:
if isinstance(self.con.channels[k], amqp.channel.Channel):
return self.con.channels[k]
return self.con.channel()
def connect(self):
if self._connection:
return
try:
self._connection = amqp.Connection(**self.connkwargs)
self._connection.connect()
self._channel = self._connection.channel()
self._register_handlers()
except Exception:
raise ConnectionError('Connect failed')
def main():
roomba = Create(BluetoothController('00:0A:3A:2E:C9:BB'))
roomba.control()
connection = amqp.Connection(HOST)
channel = connection.channel()
channel.queue_declare(queue=DRIVE_QUEUE)
channel.basic_consume(queue=DRIVE_QUEUE, callback=partial(drive, roomba))
while channel.callbacks:
channel.wait()
def connection(self):
"""Returns a new connection as a context manager."""
conn = amqp.Connection(
host="%s:%s" % (self.config.RABBIT_HOST, self.config.RABBIT_PORT),
userid=self.config.RABBIT_USER,
password=self.config.RABBIT_PASSWORD,
virtual_host=self.config.RABBIT_VIRTUAL_HOST)
logger.info('Connected to RabbitMQ')
with closing(conn):
yield conn
def conn(self):
"""Find or create current greenlet's AMQP connection"""
gid = self.greenlet_id
if gid not in self.conns:
log.debug("%s: Opening new AMQP connection.", self.lbl)
conn = amqp.Connection(config.AMQP_URI)
# TODO: The following line is needed for later versions of amqp lib
# conn.connect()
self.conns[gid] = conn
return self.conns[gid]
def server(dir, rate, broker, loglevel):
"""
The server CLI. See README.
"""
logging.basicConfig(level=loglevel.upper())
monitorer = DirMonitorer(dir, rate) # no such word...
print(f" Monitoring { dir } ...")
server_id = str(uuid.uuid4())
print(f" Server ID for client connection: { server_id }")
exchange_in = f"{ server_id }-in"
exchange_out = f"{ server_id }-out"
if broker:
c = amqp.Connection(host=broker)
else:
c = amqp.Connection()
with c:
ch = c.channel()
# Setup full-state exchange and queue
ch.exchange_declare(exchange=exchange_in, type="fanout")
queue_in, *_ = ch.queue_declare(exclusive=True)
ch.queue_bind(queue_in, exchange=exchange_in)
ch.basic_consume(queue=queue_in, callback=lambda msg: monitorer.full_state(ch, msg))
# Setup updates exchange
ch.exchange_declare(exchange=exchange_out, type="fanout")
print(" (Ctrl+C to stop)\n")
while True:
# Reply to full-state requests (why does it raise?... i don't get it...)
try:
c.drain_events(timeout=monitorer.delay_seconds)
except socket.timeout:
pass
# Publish updates
monitorer.publish_updates(ch, exchange_out)
