def connect(self):
if self.connected:
return
cred = PlainCredentials(USERNAME, PASSWORD)
params = ConnectionParameters(host=HOST, port=PORT, virtual_host=VHOST, credentials=cred)
self.connection = TornadoConnection(params, on_open_callback=self.on_connected)
self.connection.add_on_close_callback(callback=self.on_closed)
class _BrokerTestCase(_BaseTestCase):
__contexts__ = (
('_flush_outbound',
patch('pika.adapters.base_connection.BaseConnection._flush_outbound')
),
('tornado_adapter_connect',
patch(mod + '.TornadoConnection._adapter_connect')),
('blocking_adapter_connect',
patch(mod + '.BlockingConnection._adapter_connect')),
)
nodes = {
'rabbit1': {
'host': 'rabbit1.example.com',
'port': 5673,
},
'rabbit2': {
'port': 5674,
},
'rabbit3': {
'host': 'rabbit3.example.com',
},
'localhost': {
'host': '127.0.0.1',
},
}
connect_options = {
'credentials':
PlainCredentials(username=sentinel.username,
password=sentinel.password),
'virtual_host':
'/pikachewie',
'heartbeat_interval':
60,
}
def launch_producer(args: ProducerConfig):
replays = read_lines(args.replay_file)
for replay_file in replays:
check_map_exists(args.replay_dir + "/" + replay_file)
connection = pika.BlockingConnection(
pika.ConnectionParameters(host=args.host,
port=args.port,
connection_attempts=5,
retry_delay=3,
credentials=PlainCredentials(
args.user, args.password)))
try:
channel = connection.channel()
logger.info(f"publishing {len(replays)} messages")
for replay in replays:
channel.basic_publish(
exchange='',
routing_key='parse',
body=replay,
properties=pika.BasicProperties(
delivery_mode=2, # make message persistent
))
finally:
connection.close()
def main():
def on_message_receive_callback(channel, method, properties, body):
log("Mensaje recibido.")
message = json.loads(body)
operation = message["operation"]
image_processor.run(operation)
log("Todas las tareas asociadas a la operación '{}' han finalizado.".
format(operation))
log("Inicializando conexión a RabbitMQ en '{}:{}'...".format(
RABBITMQ_HOST, RABBITMQ_PORT))
connection = BlockingConnection(
ConnectionParameters(host=RABBITMQ_HOST,
port=RABBITMQ_PORT,
credentials=PlainCredentials(
RABBITMQ_USER, RABBITMQ_PASS),
virtual_host="/"))
channel = connection.channel()
channel.exchange_declare(exchange="XPyxel-Nodes",
exchange_type="direct",
durable=True)
channel.queue_declare(queue=WORKER_ID, durable=True)
channel.basic_consume(queue=WORKER_ID,
on_message_callback=on_message_receive_callback,
auto_ack=True)
log("Pyxel [{}] ha iniciado correctamente y está esperando peticiones. Presione [Ctrl]+C para salir..."
.format(WORKER_ID))
channel.start_consuming()
def _check_connection(cls):
if not getattr(thread_data, 'rabbitmq_connected', False) \
and 'oioioi.notifications' in settings.INSTALLED_APPS \
and NotificationHandler.last_connection_check < \
time.time() - NotificationHandler.conn_try_interval:
try:
o = six.moves.urllib.parse.urlparse(
settings.NOTIFICATIONS_RABBITMQ_URL)
kwargs = {}
if o.hostname:
kwargs['host'] = o.hostname
if o.port:
kwargs['port'] = o.port
if o.path:
kwargs['virtual_host'] = o.path
if o.username and o.password:
kwargs['credentials'] = PlainCredentials(o.username, o.password)
parameters = ConnectionParameters(**kwargs)
thread_data.conn = BlockingConnection(parameters)
thread_data.rabbitmq_connected = True
# pylint: disable=broad-except
except Exception:
NotificationHandler.last_connection_check = time.time()
logger.info("Notifications: Can't connect to RabbitMQ",
exc_info=True)
def run(args):
crew_client = Client(
host=args.rmq_address, port=args.rmq_port, virtualhost=args.rmq_vhost,
credentials=PlainCredentials(username=args.rmq_user, password=args.rmq_password)
)
app = Application(
args=args,
handlers=HANDLERS,
xsrf_cookies=False,
cookie_secret=args.cookie_secret,
debug=args.debug,
reload=args.debug,
gzip=args.gzip,
crew=crew_client,
timeout=args.timeout
)
http_server = HTTPServer(app, xheaders=True)
http_server.listen(args.port, address=args.address)
log.info('Server started {host}:{port}'.format(host=args.address, port=args.port))
try:
tornado.ioloop.IOLoop.instance().start()
except Exception as e:
log.exception(e)
log.fatal("Server aborted by error: %r", e)
return 0
def __init__(self,
queue,
rabhost,
user,
passwd,
msg,
routing_key='py-fxp-publisher'):
self.queue = queue
self.host = rabhost
self.topic_type = 'direct'
self.user = user
self.passwd = passwd
self.result_exchange = 'py-fxp-publisher'
self.publish_connection = BlockingConnection(
ConnectionParameters(host=self.host,
port=5672,
virtual_host='/',
retry_delay=3,
connection_attempts=60,
credentials=PlainCredentials(
self.user, self.passwd)))
self.publish_channel = self.publish_connection.channel()
self.result_routing = routing_key
self.msg = msg
self.publish_channel.queue_declare(queue=self.queue,
passive=False,
durable=True,
exclusive=False,
auto_delete=False)
def publish_rmq(queue, properties, body, exchange=''):
global connection, channel
try:
channel.basic_publish(exchange=exchange,
routing_key=queue,
body=body,
properties=properties)
# try reconnecting if the connection has timedout
except pika.exceptions.StreamLostError:
# reconnect
logging.info(
f'Reconneting to RabbitMQ server: {args.host} (excl. creds)')
connection = pika.BlockingConnection(
pika.ConnectionParameters(args.host,
credentials=PlainCredentials(
args.username, args.password),
heartbeat=0))
channel = connection.channel()
channel.queue_declare(queue=queue)
# try publishing again
channel.basic_publish(exchange=exchange,
routing_key=queue,
body=body,
properties=properties)
def __init__( self, host = 'localhost', port = 5672, user = '', password = '', vhost = '/', routingKey = ''):
credentials = PlainCredentials( user, password )
self._connection = BlockingConnection( ConnectionParameters( host, port, vhost, credentials ) )
#self._connection = SelectConnection( ConnectionParameters( host, port, vhost, credentials ) )
self._channel = self._connection.channel()
self._channel.exchange_declare( exchange = exchange_name, type = 'topic' )
self.rkey = routingKey
def connection_parameters(self, **kwargs):
"""Get ``ConnectionParameters`` associated with this client
Will construct a ``ConnectionParameters`` object using parameters
passed at initialization as defaults. Any parameters passed in
kwargs will override initialization parameters.
Args:
**kwargs: Overrides for specific parameters
Returns:
:obj:`pika.ConnectionParameters`: ConnectionParameters object
"""
credentials = PlainCredentials(
username=kwargs.get("user", self._user),
password=kwargs.get("password", self._password),
)
return ConnectionParameters(
host=kwargs.get("host", self._host),
port=kwargs.get("port", self._port),
ssl=kwargs.get("ssl_enabled", self._ssl_enabled),
ssl_options=kwargs.get("ssl_options", self._ssl_options),
virtual_host=kwargs.get("virtual_host", self._virtual_host),
connection_attempts=kwargs.get("connection_attempts",
self._connection_attempts),
heartbeat=kwargs.get(
"heartbeat", kwargs.get("heartbeat_interval",
self._heartbeat)),
blocked_connection_timeout=kwargs.get(
"blocked_connection_timeout",
self._blocked_connection_timeout),
credentials=credentials,
)
def __init__(self,
queue: str,
conn_auth: tuple,
conn_params: dict = None or {},
exchange_params: dict = None or {},
**kwargs):
credentials = PlainCredentials(*conn_auth)
parameters = ConnectionParameters(credentials=credentials, **conn_params)
connection = BlockingConnection(parameters)
channel = connection.channel()
exchange = exchange_params.pop("exchange", "minitools")
auto_delete = kwargs.get("auto_delete", False)
routing_key = kwargs.get("routing_key", "")
requeue = kwargs.get("requeue", False)
exchange_params.setdefault("durable", True)
exchange_params.setdefault("auto_delete", auto_delete)
channel.exchange_declare(exchange, **exchange_params)
channel.queue_declare(queue=queue, auto_delete=auto_delete)
channel.queue_bind(queue=queue, exchange=exchange, routing_key=routing_key)
channel.basic_qos(prefetch_count=1)
self.queue = queue
self.requeue = requeue
self.channel = channel
self.exchange = exchange
self.connection = connection
self.routing_key = routing_key
def connect_to_mq(server,
vhost,
user,
passwd,
ioloop=False,
on_open_callback=None):
partes = urlparse.urlparse(server)
result = None
if partes.scheme == '' or partes.scheme == 'rabbitmq': #Legado, usando RabbitMQ
server = partes.netloc or partes.path
cred = PlainCredentials(user, passwd)
if not ioloop:
result = BlockingConnection(
ConnectionParameters(str(server),
virtual_host=vhost,
credentials=cred))
else:
result = SelectConnection(
ConnectionParameters(str(server),
virtual_host=vhost,
credentials=cred), on_open_callback)
elif partes.scheme == 'nsq':
result = NsqConnection(partes.netloc,
vhost[1:] if len(vhost) > 1 else '')
return result
def connect(self, consumer):
log.info("Connecting to RabbitMQ...")
user = self.settings["rabbit_user"]
password = self.settings["rabbit_password"]
queue = self.settings["backend_queue"]
parameters = dict(
host=self.settings["rabbit_host"],
port=self.settings["rabbit_port"],
socket_timeout=self.settings["rabbit_connecion_timeout"],
)
try:
credentials = PlainCredentials(user, password)
param = ConnectionParameters(**parameters)
self.connection = BlockingConnection(param)
self.channel = self.connection.channel()
self.channel.basic_consume(
queue=queue, auto_ack=True, on_message_callback=consumer
)
except Exception as e:
log.error("Something went wrong with connection to RabbitMQ... %s", e)
def connect(self):
"""This method connects to RabbitMQ, returning the connection handle.
When the connection is established, the on_connection_open method
will be invoked by pika.
:rtype: pika.SelectConnection
"""
LOGGER.info("Connecting to %s", self._server_details.host)
credentials = PlainCredentials(self._server_details.username,
self._server_details.password)
connection_params = ConnectionParameters(
host=self._server_details.host,
port=self._server_details.port,
virtual_host=self._server_details.vhost,
credentials=credentials,
)
if self._server_details.uses_ssl:
cafile = os.getenv("REQUESTS_CA_BUNDLE")
ssl_context = ssl.create_default_context(cafile=cafile)
connection_params.ssl_options = SSLOptions(ssl_context)
return SelectConnection(
parameters=connection_params,
on_open_callback=self.on_connection_open,
on_open_error_callback=self.on_connection_open_error,
on_close_callback=self.on_connection_closed,
)
def run(args):
log = logging.getLogger("main")
try:
SMTPSettings = namedtuple("SmtpSettings",
"host port user password tls sender")
Listener(
port=args.amqp_port,
host=args.amqp_address,
credentials=PlainCredentials(username=args.amqp_user,
password=args.amqp_password)
if args.amqp_user else None,
virtual_host=args.amqp_vhost,
handlers=context.handlers,
set_context=Context(options=args,
node_uuid=NODE_UUID,
uuid=UUID,
smtp=SMTPSettings(host=args.smtp_host,
port=args.smtp_port,
user=args.smtp_user,
password=args.smtp_password,
tls=args.smtp_tls,
sender=args.smtp_sender)),
).loop()
except Exception as e:
if logging.getLogger().level < logging.INFO:
log.exception(e)
else:
log.fatal("Exiting by fatal error: %s", e)
return 0
def connection_parameters(self, **kwargs):
"""Get ``ConnectionParameters`` associated with this client
Will construct a ``ConnectionParameters`` object using parameters
passed at initialization as defaults. Any parameters passed in
\*\*kwargs will override initialization parameters.
Args:
**kwargs: Overrides for specific parameters
Returns:
:obj:`pika.ConnectionParameters`: ConnectionParameters object
"""
credentials = PlainCredentials(
username=kwargs.get('user', self._user),
password=kwargs.get('password', self._password),
)
return ConnectionParameters(
host=kwargs.get('host', self._host),
port=kwargs.get('port', self._port),
ssl=kwargs.get('ssl_enabled', self._ssl_enabled),
ssl_options=kwargs.get('ssl_options', self._ssl_options),
virtual_host=kwargs.get('virtual_host', self._virtual_host),
connection_attempts=kwargs.get('connection_attempts',
self._connection_attempts),
heartbeat_interval=kwargs.get('heartbeat_interval',
self._heartbeat_interval),
credentials=credentials,
)
def send_message_queue(data):
credentials = PlainCredentials('user', 'pass')
connection = BlockingConnection(
ConnectionParameters('rabbit', 5672, 'vhost', credentials))
channel = connection.channel()
channel.queue_declare(queue='tasks')
channel.basic_publish(exchange='', routing_key='tasks', body=dumps(data))
connection.close()
def connection(self, **kwargs):
credentials = PlainCredentials(self.user, self.password)
connection_params = ConnectionParameters(
'localhost', self.connection_port(),
credentials=credentials, virtual_host=self.virtual_host,
**kwargs
)
return BlockingConnection(connection_params)
def connect(self):
"""
Connect with the exchange provider
"""
self._connection = BlockingConnection(
ConnectionParameters(host=self.__host,
port=self.__port,
credentials=PlainCredentials(
self.__user, self.__password)))
def __init__( self, groups, host = 'localhost', verbose = True, port = 5672, user = '', password = '' ):
credentials = PlainCredentials(user, password)
self._connection = BlockingConnection( ConnectionParameters( host, port, vhost, credentials ) )
self._channel = self._connection.channel()
self._channel.exchange_declare( exchange = exchange_name, type = 'topic' )
self._queueID = self._channel.queue_declare( exclusive = True ).method.queue
for topic in groups:
self._channel.queue_bind(exchange = exchange_name, queue = self._queueID, routing_key = topic)
def __init__(self):
self.url = flask.current_app.config['INFOSYSTEM_QUEUE_URL']
self.port = flask.current_app.config['INFOSYSTEM_QUEUE_PORT']
self.virtual_host = \
flask.current_app.config['INFOSYSTEM_QUEUE_VIRTUAL_HOST']
self.username = flask.current_app.config['INFOSYSTEM_QUEUE_USERNAME']
self.password = flask.current_app.config['INFOSYSTEM_QUEUE_PASSWORD']
credentials = PlainCredentials(self.username, self.password)
self.params = ConnectionParameters(
self.url, self.port, self.virtual_host, credentials)
def __init__(self, config, service_name):
self.config = config
credentials = PlainCredentials(username=config.username,
password=config.password)
connection_parameters = ConnectionParameters(host=config.host,
credentials=credentials)
self.connection = BlockingConnection(connection_parameters)
self.channel = self.connection.channel()
self.service_name = service_name
def __init__(self, nodes=None, connect_options=None):
if nodes is None:
nodes = self.DEFAULT_NODES
if connect_options is None:
connect_options = self.DEFAULT_CONNECT_OPTIONS
self._nodes = list(nodes.items())
self._connect_options = connect_options.copy()
if isinstance(self._connect_options.get('credentials'), dict):
self._connect_options['credentials'] = PlainCredentials(
**self._connect_options['credentials'])
def __init__(self, routing_key, is_in_production=False):
self.routing_key = routing_key
self.pika_connection = BlockingConnection(
ConnectionParameters(host=self.MQ_HOST,
virtual_host=self.MQ_VIRTUAL_HOST,
port=self.MQ_PORT,
credentials=PlainCredentials(
self.MQ_USERNAME, self.MQ_PASSWORD)))
self.connection_channel = self.pika_connection.channel()
self.connection_channel.exchange_declare(
exchange=self.MQ_EXCHANGE_NAME,
exchange_type=self.MQ_EXCHANGE_TYPE)
def _init_credentials(self) -> PlainCredentials: # pylint:disable = R0201
"""Initializes a PlainCredentials object.
To do so, it uses the NAVI_AMQP_USERNAME and NAVI_AMQP_PASSWORD environment variables.
Returns:
The created PlainCredentials instance.
"""
credentials = PlainCredentials(config.NAVI_AMQP_USERNAME,
config.NAVI_AMQP_PASSWORD)
return credentials
def connect(self) -> BlockingConnection:
"""Create blocking connection in RMQ.
Returns:
A BlockingConnection to the RMQ server specified
"""
return BlockingConnection(parameters=ConnectionParameters(
host=self.host,
port=self.port,
virtual_host=self.vhost,
credentials=PlainCredentials(username=self.user,
password=self.passwd),
))
def __init__(self):
self.g2m_name = 'game_to_model'
self.m2g_name = 'model_to_game'
connection = pika.BlockingConnection(
pika.ConnectionParameters(
host='retake.jlucs.club',
credentials=PlainCredentials(username='******',
password='******')))
self.channel = connection.channel()
self.channel.queue_declare(queue=self.g2m_name, durable=True)
self.channel.queue_declare(queue=self.m2g_name, durable=True)
global g2m_data
global m2g_data
def __init__(
self,
exchange_name: str,
queue_name: Optional[str] = "",
routing_key: Optional[str] = "",
exchange_type: Optional[str] = "direct",
**kwargs,
):
"""
:param exchange_name: Your exchange name.
:param queue_name: Your queue name.
:param routing_key: Your queue name.
:param exchange_type: Exchange type to declare. Default: ``"direct"``
:keyword host: Your RabbitMQ host. Checks env var ``RABBITMQ_HOST``. Default: ``"localhost"``
:keyword port: Your RabbitMQ port. Checks env var ``RABBITMQ_PORT``. Default: ``5672``
:keyword username: Your RabbitMQ username. Default: ``"guest"``
:keyword password: Your RabbitMQ password. Default: ``"guest"``
:keyword connection_attempts: How many times should PyRMQ try?. Default: ``3``
:keyword retry_delay: Seconds between retries. Default: ``5``
:keyword error_callback: Callback function to be called when connection_attempts is reached.
:keyword infinite_retry: Tells PyRMQ to keep on retrying to publish while firing error_callback, if any. Default: ``False``
:keyword exchange_args: Your exchange arguments. Default: ``None``
:keyword queue_args: Your queue arguments. Default: ``None``
"""
self.exchange_name = exchange_name
self.queue_name = queue_name
self.routing_key = routing_key
self.exchange_type = exchange_type
self.host = kwargs.get("host") or os.getenv("RABBITMQ_HOST") or "localhost"
self.port = kwargs.get("port") or os.getenv("RABBITMQ_PORT") or 5672
self.username = kwargs.get("username", "guest")
self.password = kwargs.get("password", "guest")
self.connection_attempts = kwargs.get("connection_attempts", 3)
self.retry_delay = kwargs.get("retry_delay", 5)
self.retry_backoff_base = kwargs.get("retry_backoff_base", 2)
self.retry_backoff_constant_secs = kwargs.get("retry_backoff_constant_secs", 5)
self.error_callback = kwargs.get("error_callback")
self.infinite_retry = kwargs.get("infinite_retry", False)
self.exchange_args = kwargs.get("exchange_args")
self.queue_args = kwargs.get("queue_args")
self.connection_parameters = ConnectionParameters(
host=self.host,
port=self.port,
credentials=PlainCredentials(self.username, self.password),
connection_attempts=self.connection_attempts,
retry_delay=self.retry_delay,
)
self.connections = {}
def connect(self):
"""
Create blocking connection in RMQ
:return: pika.BlockingConnection
"""
return BlockingConnection(
parameters=ConnectionParameters(host=self.host,
port=self.port,
virtual_host=self.vhost,
credentials=PlainCredentials(
username=self.user,
password=self.passwd,
)))
def __init__(self, server_details: RabbitServerDetails):
credentials = PlainCredentials(server_details.username,
server_details.password)
self._connection_params = ConnectionParameters(
host=server_details.host,
port=server_details.port,
virtual_host=server_details.vhost,
credentials=credentials,
)
if server_details.uses_ssl:
cafile = os.getenv("REQUESTS_CA_BUNDLE")
ssl_context = ssl.create_default_context(cafile=cafile)
self._connection_params.ssl_options = SSLOptions(ssl_context)