def connect(self):
"""This method connects to RabbitMQ using a TornadoConnection object,
returning the connection handle.
When the connection is established, the on_connection_open method
will be invoked by pika.
:rtype: pika.adapters.TornadoConnection
"""
no_of_servers = len(self._rabbit_urls)
while True:
server_choice = (self._count % no_of_servers) - 1
self._url = self._rabbit_urls[server_choice]
try:
logger.info('Connecting', attempt=self._count)
return TornadoConnection(pika.URLParameters(self._url),
on_open_callback=self.on_connection_open,
on_open_error_callback=self.on_connection_open_error,
on_close_callback=self.on_connection_closed)
except pika.exceptions.AMQPConnectionError:
logger.exception("Connection error")
self._delay_before_reconnect()
continue
def test_tornado_connection_basic_consume_outside_transaction(producer):
def on_message(channel, method_frame, header_frame, body):
assert hasattr(method_frame, '_nr_start_time')
assert body == BODY
channel.basic_ack(method_frame.delivery_tag)
channel.close()
connection.close()
connection.ioloop.stop()
def on_open_channel(channel):
basic_consume(channel, QUEUE, on_message)
def on_open_connection(connection):
connection.channel(on_open_callback=on_open_channel)
connection = TornadoConnection(pika.ConnectionParameters(
DB_SETTINGS['host']),
on_open_callback=on_open_connection)
try:
connection.ioloop.start()
except:
connection.close()
connection.ioloop.stop()
raise
def connect(self):
if self.connecting:
self.logger.info(
'django-sockjs-server(SockjsServer): Already connecting to RabbitMQ'
)
return
self.logger.info(
'django-sockjs-server(SockjsServer): Connecting to RabbitMQ')
self.connecting = True
cred = pika.PlainCredentials(self.config.rabbitmq_user,
self.config.rabbitmq_password)
param = pika.ConnectionParameters(
host=self.config.rabbitmq_host,
port=self.config.rabbitmq_port,
virtual_host=self.config.rabbitmq_vhost,
credentials=cred)
try:
self.connection = TornadoConnection(
param, on_open_callback=self.on_connected)
self.connection.add_on_close_callback(self.on_closed)
except AMQPConnectionError:
self.logger.info(
'django-sockjs-server(SockjsServer): error connect, wait 5 sec'
)
time.sleep(5)
self.reconnect()
self.last_reconnect = now()
def connect(self):
self.connection = TornadoConnection(
self.parameters,
on_open_callback=self.on_connected,
stop_ioloop_on_close=False,
on_open_error_callback=self.on_open_error)
self.connection.add_on_close_callback(self.on_closed)
def connect(self) -> TornadoConnection:
"""This method connects to the broker, returning the connection handle."""
logger.info(f"Connecting to {self._host}:{self._port}{self._vhost}")
# set amqp credentials
if self._username:
credentials = pika.PlainCredentials(self._username, self._password)
# set amqp connection parameters
parameters = pika.ConnectionParameters(
host=self._host,
port=self._port,
virtual_host=self._vhost,
credentials=credentials,
)
else:
parameters = pika.ConnectionParameters(
host=self._host,
port=self._port,
virtual_host=self._vhost,
)
# connect
connection = TornadoConnection(
parameters=parameters,
on_open_callback=self.on_connection_open,
on_open_error_callback=self.on_connection_open_error,
on_close_callback=self.on_connection_closed,
)
return connection
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)
def connect(self, url=None, options=None, callback=None):
if url is not None:
self.url = url
purl = urlparse(self.url)
credentials = pika.PlainCredentials(purl.username, purl.password)
virtual_host = purl.path[1:]
host = purl.hostname
port = purl.port
options = options or {}
options = dict([(k.lstrip('DEFAULT_').lower(), v)
for k, v in options.items()])
options.update(host=host,
port=port,
virtual_host=virtual_host,
credentials=credentials)
params = pika.ConnectionParameters(**options)
try:
TornadoConnection(params,
stop_ioloop_on_close=False,
on_open_callback=partial(self.on_connect,
callback),
custom_ioloop=self.io_loop)
except AMQPConnectionError:
logging.info('Retrying to connect in 2 seconds')
self.io_loop.add_timeout(
timedelta(seconds=2),
partial(self.connect,
url=url,
options=options,
callback=callback))
def create_connection(self):
url_params = self._config.MQ_URI
future = Future()
TornadoConnection(URLParameters(url_params),
partial(self.on_connection_open, future),
partial(self.on_open_error, future))
return future
def _try_connect(self):
self.logger.debug("start creating connection")
future = Future()
self._io_loop.add_timeout(
datetime.timedelta(seconds=self._timeout),
functools.partial(self._on_timeout, future=future))
def open_callback(unused_connection):
self.logger.debug("created connection")
self._current_status = self.OPEN_STATUS
future.set_result(unused_connection)
def open_error_callback(connection, exception):
self.logger.error("open connection with error: %s", exception)
self._current_status = self.CLOSE_STATUS
future.set_exception(exception)
def close_callback(connection, reason):
self.logger.error("Connect closed, %s", reason)
self._current_status = self.CLOSE_STATUS
TornadoConnection(self._parameter,
on_open_callback=open_callback,
on_open_error_callback=open_error_callback,
on_close_callback=close_callback,
custom_ioloop=self._io_loop)
return future
def connect(self):
if not sickrage.app.api.token or not sickrage.app.config.general.server_id:
IOLoop.current().call_later(5, self.reconnect)
return
if sickrage.app.api.token_time_remaining < (int(sickrage.app.api.token['expires_in']) / 2):
if not sickrage.app.api.refresh_token():
IOLoop.current().call_later(5, self.reconnect)
return
try:
credentials = pika.credentials.PlainCredentials(username='******', password=sickrage.app.api.token["access_token"])
context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
parameters = pika.ConnectionParameters(
host=self._amqp_host,
port=self._amqp_port,
virtual_host=self._amqp_vhost,
credentials=credentials,
socket_timeout=300,
ssl_options=pika.SSLOptions(context)
)
TornadoConnection(
parameters,
on_open_callback=self.on_connection_open,
on_close_callback=self.on_connection_close,
on_open_error_callback=self.on_connection_open_error
)
except (AMQPConnectorException, AMQPConnectionError, SSLCertVerificationError):
sickrage.app.log.debug("AMQP connection error, attempting to reconnect")
IOLoop.current().call_later(5, self.reconnect)
def connect(self):
if self.connecting:
return
self.connecting = True
self.connection = TornadoConnection(on_open_callback=self.on_connected)
self.connection.add_on_close_callback(self.on_closed)
def connect(self):
if self.connecting:
return
self.connecting = True
self.connection = TornadoConnection(
pika.ConnectionParameters(host=self.host),
on_open_callback=self.on_connected)
self.connection.add_on_close_callback(self.on_closed)
def start(self):
credentials = pika.PlainCredentials('guest', 'guest')
param = pika.ConnectionParameters(host="localhost",
port=5672,
virtual_host="/",
credentials=credentials)
self.connection = TornadoConnection(param, on_open_callback=self.on_connected)
self.connection.set_backpressure_multiplier(100000)
def connect(self):
try:
logger = logging.getLogger('rmq_tornado')
credentials = pika.PlainCredentials(RMQ_USER, RMQ_PWD)
param = pika.ConnectionParameters(host=RMQ_HOST, port=RMQ_PORT, credentials=credentials)
self.connection = TornadoConnection(param, on_open_callback=self.on_connected)
except Exception as e:
logger.error('Something went wrong... %s', e)
def connect(self):
if self.connecting:
logging.error("PikaClient already connected")
return
logging.info("connecting to RabbitMQ")
self.connecting = True
param = pika.ConnectionParameters(host='10.212.66.144', port=5672)
self.connection = TornadoConnection(param,
on_open_callback=self.on_connected)
self.connection.add_on_close_callback(self.on_closed)
def connect(self):
try:
self.connection = TornadoConnection(
self.parameters,
on_open_callback=self.on_connected,
stop_ioloop_on_close=False,
on_open_error_callback=self.on_open_error)
self.connection.add_on_close_callback(self.on_closed)
except:
logging.info("connect faield")
def connect(self):
if self.connecting:
pika.log.info('PikaClient: Already connecting to RabbitMQ')
return
pika.log.info('PikaClient: Connecting to RabbitMQ on localhost:5672')
self.connecting = True
param = pika.ConnectionParameters(host='115.146.93.175')
self.connection = TornadoConnection(param,
on_open_callback=self.on_connected)
self.connection.add_on_close_callback(self.on_closed)
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
"""
self.logger.info('Connecting to %s', self._url)
return TornadoConnection(pika.URLParameters(self._url),
self.on_connection_open)
def connect(self):
if self.connecting:
log.info('Already connecting to RabbitMQ.')
return
#self.L.logger.info("Connecting to RabbitMQ")
self.connecting = True
creds = pika.PlainCredentials('guest', 'guest')
params = pika.ConnectionParameters(host='localhost', port=5672,
virtual_host='/', credentials=creds)
self.connection = TornadoConnection(params,
on_open_callback=self.on_connect)
self.connection.add_on_close_callback(self.on_closed)
def connect(self):
if self.connecting:
print('Already connecting to RabbitMQ.')
return
print("Connecting to RabbitMQ")
self.connecting = True
creds = pika.PlainCredentials('zyl', 'pwd_zyl')
params = pika.ConnectionParameters(host='112.74.75.38', port=5672,
virtual_host='/', credentials=creds)
self.connection = TornadoConnection(params,
on_open_callback=self.on_connect)
self.connection.add_on_close_callback(self.on_closed)
def connect(self):
"""
connect to rabbitmq server and declare exchange and queue.
"""
parameters = pika.ConnectionParameters(
virtual_host=self.virtual_host,
credentials=pika.PlainCredentials(self.username, self.password),
frame_max=self.frame_size,
host=self.mq_server,
heartbeat_interval=60)
self.connection = TornadoConnection(parameters=parameters,
on_open_callback=self.on_connected)
def _connect(self):
conn = pika.ConnectionParameters(
host=CREDS['host'], port=int(CREDS['port']),
virtual_host='/',
credentials=pika.PlainCredentials(
CREDS['user'], CREDS['pasw']))
self.tc = TornadoConnection(
conn, on_open_callback=self.on_connected,
on_open_error_callback=self.on_disconnect
)
self.tc.add_on_close_callback(self.on_disconnect)
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._url)
self._connection = TornadoConnection(
pika.URLParameters(self._url),
on_open_callback=self.on_connection_open,
on_open_error_callback=self.on_connection_open_error)
return self._connection
def connect(self):
if self.connecting:
pika.log.info('PikaClient: Already connecting to RabbitMQ')
return
pika.log.info('PikaClient: Connecting to RabbitMQ on localhost:5672')
self.connecting = True
credentials = pika.PlainCredentials('guest', 'guest')
param = pika.ConnectionParameters(host='localhost',
port=5672,
virtual_host="/",
credentials=credentials)
self.connection = TornadoConnection(param,
on_open_callback=self.on_connected)
self.connection.add_on_close_callback(self.on_closed)
def connect(self):
try:
logger = logging.getLogger('rmq_tornado')
username = '******' # 指定远程rabbitmq的用户名密码
pwd = '1220'
user_pwd = pika.PlainCredentials(username, pwd)
param = pika.ConnectionParameters(host='10.10.189.213',
virtual_host='TaskDistribute',
credentials=user_pwd)
self.connection = TornadoConnection(
param, on_open_callback=self.on_connected)
return self.connection
except Exception as e:
logger.error('Something went wrong... %s', e)
def try_connect(self):
self.logger.info("Creating connection to RabbitMQ")
self._io_loop.call_later(self._timeout, self._on_timeout)
if isinstance(self._io_loop, IOLoop):
TornadoConnection(self._parameters,
on_open_callback=self._open_callback,
on_open_error_callback=self._open_error_callback,
on_close_callback=self._close_callback,
custom_ioloop=self._io_loop)
else:
AsyncioConnection(self._parameters,
on_open_callback=self._open_callback,
on_open_error_callback=self._open_error_callback,
on_close_callback=self._close_callback,
custom_ioloop=self._io_loop)
def _connect(self):
future = Future()
TornadoConnection(self._connection_parameters,
on_open_callback=future.set_result,
on_open_error_callback=lambda *a: future.
set_exception(ConnectionError(a)),
on_close_callback=self._on_close,
custom_ioloop=self.io_loop)
log.info(
'PikaClient: Trying to connect to rabbitmq://%s:%s/%s, Object: %r',
self._connection_parameters.host, self._connection_parameters.port,
self._connection_parameters.virtual_host, self)
return future
def connect(self):
if self.connecting:
print('PikaClient: Already connecting to RabbitMQ')
return
print('PikaClient: Connecting to RabbitMQ on localhost:5672, Object: %s' % (self,))
self.connecting = True
credentials = pika.PlainCredentials('guest', 'guest')
param = pika.ConnectionParameters(host='localhost',
port=5672,
virtual_host="/",
credentials=credentials)
self.connection = TornadoConnection(param,
on_open_callback=self.on_connected)
def connect(self):
if self.connecting:
return
self.connecting = True
creds = pika.PlainCredentials(
self.config.get('user'),
self.config.get('pw')
)
params = pika.ConnectionParameters(
host=self.config.get('host'),
port=5671 if self.config.get('amqps') else 5672,
virtual_host=self.config.get('vhost'),
credentials=creds
)
self.connection = TornadoConnection(params)
self.connection.add_on_open_callback(self.on_connect)
self.connection.add_on_close_callback(self.on_closed)
return
def connect(self):
if self.connecting:
pika.log.info('PikaClient: Already connecting to RabbitMQ')
return
pika.log.info('PikaClient: Connecting to RabbitMQ')
self.connecting = True
#cred = pika.PlainCredentials('guest', 'guest')
param = pika.ConnectionParameters(
host='115.146.93.175',
#port=5672,
#virtual_host='/',
#credentials=cred
)
self.connection = TornadoConnection(param,
on_open_callback=self.on_connected)
self.connection.add_on_close_callback(self.on_closed)
