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 PikaClient(object):
#all the following functions precede in order starting with connect
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 on_connected(self, connection):
"""When we are completely connected to rabbitmq this is called"""
logger.info('Succesfully connected to rabbitmq')
#open a channel
self.connection.channel(self.on_channel_open)
def on_channel_open(self, new_channel):
"""When the channel is open this is called"""
logging.info('Opening channel to rabbitmq')
global channel
channel = new_channel
class PikaClient(object):
# All the following functions precede in order starting with connect
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 on_connected(self, connection):
"""When we are completely connected to rabbitmq this is called"""
logger.info('Succesfully connected to rabbitmq')
# Open a channel
self.connection.channel(self.on_channel_open)
def on_channel_open(self, new_channel):
"""When the channel is open this is called"""
logging.info('Opening channel to rabbitmq')
global channel
channel = new_channel
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()
class Sender(object):
def __init__(self, settings, io_loop):
self.io_loop = io_loop
self.channel = None
self.exchange = "poly"
credentials = None
if settings.get("username", None):
credentials = pika.PlainCredentials(
settings["username"],
settings["password"]
)
self.connection_parameters = None
if credentials or settings.get("host", None) or settings.get("vhost"):
self.connection_parameters = pika.ConnectionParameters(
credentials=credentials,
host=settings.get("host", None),
port=settings.get("port", None),
virtual_host=settings.get("vhost", None)
)
else:
raise Exception("NO self.connection_parameters")
self.settings = settings
def connect(self):
logging.info("MQ connect...")
try:
self.connection = TornadoConnection(
self.connection_parameters,
self.on_connected
)
self.connection.add_on_close_callback(self.on_close)
except socket.error, e:
logging.warn("connection failed, trying again in 5 seconds")
self.io_loop.add_timeout(time.time() + 5, self.connect)
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 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:
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 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 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)
class PikaClient(object):
def __init__(self, io_loop):
self.io_loop = io_loop
self.connected = False
self.connecting = False
self.connection = None
self.channel = None
self.event_listeners = set([])
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 on_connected(self, connection):
self.connected = True
self.connection = connection
self.connection.channel(self.on_channel_open)
def on_channel_open(self, channel):
self.channel = channel
channel.queue_declare(queue="plase",
durable=True,
callback=self.on_queue_declared)
def on_queue_declared(self, frame):
self.channel.basic_consume(self.on_message, queue='plase')
def on_closed(self, connection):
self.io_loop.stop()
def on_message(self, channel, method, header, body):
self.notify_listeners(body)
def notify_listeners(self, event_obj):
event_json = json.dumps(event_obj)
for listener in self.event_listeners:
listener.write_message(event_json)
def add_event_listener(self, listener):
self.event_listeners.add(listener)
def remove_event_listener(self, listener):
try:
self.event_listeners.remove(listener)
except KeyError:
pass
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):
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)
class PikaClient(object):
def __init__(self, io_loop):
self.io_loop = io_loop
self.connected = False
self.connecting = False
self.connection = None
self.channel = None
self.event_listeners = set([])
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 on_connected(self, connection):
self.connected = True
self.connection = connection
self.connection.channel(self.on_channel_open)
def on_channel_open(self, channel):
self.channel = channel
channel.queue_declare(queue="plase", durable=True, callback=self.on_queue_declared)
def on_queue_declared(self, frame):
self.channel.basic_consume(self.on_message, queue="plase")
def on_closed(self, connection):
self.io_loop.stop()
def on_message(self, channel, method, header, body):
self.notify_listeners(body)
def notify_listeners(self, event_obj):
event_json = json.dumps(event_obj)
for listener in self.event_listeners:
listener.write_message(event_json)
def add_event_listener(self, listener):
self.event_listeners.add(listener)
def remove_event_listener(self, listener):
try:
self.event_listeners.remove(listener)
except KeyError:
pass
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
class AMQPClient(object):
channels = {}
def __init__(self, uri, logger, on_connected_callback=None):
self._uri = uri or 'amqp://*****:*****@localhost:5672/%2f'
self._logger = logger or logging.getLogger(self.__class__.__name__)
self._on_connected_callback = on_connected_callback
self._amqp_connect()
@property
def uri(self):
return self._uri
@property
def connection(self):
return self._connection
def __getattr__(self, name):
if name in self.channels.keys():
return self.channels[name]
self.channels[name] = AMQPChannelClient(self, name)
return self.channels[name]
def __getitem__(self, name):
return self.__getattr__(name)
def _amqp_connect(self):
self._connection = TornadoConnection(pika.URLParameters(self.uri),
on_open_callback=self._on_amqp_opened, stop_ioloop_on_close=True)
def _on_amqp_opened(self, connection):
self._logger.debug('AMQP connection opened')
self.connection.add_on_close_callback(self._on_connection_closed)
if self._on_connected_callback:
self._on_connected_callback()
def _on_connection_closed(self, connection):
#TODO: Log disconnection details...
#self.log.warning('Server closed connection, reopening: (%s) %s',
#method_frame.method.reply_code,
#method_frame.method.reply_text)
#self.log.debug(connection._is_method_frame())
self._connection = self._amqp_connect()
def close(self):
for channel in self.channels.values():
channel.cancel_consume()
self._logger.debug('Closing AMQP connection')
self._connection.close()
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)
class PikaClient:
def __init__(self, io_loop):
print(f'{self.__str__()}: __init__()')
self.io_loop = io_loop
self.connection = None
self.connected = False
self.channel = None
# 打开链接
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)
# 连接成功 callback
def on_connected(self, connection):
self.connected = True
self.connection = connection
print(f'{self.__str__()}: connected() succeed')
self.connection.channel(on_open_callback=self.on_channel_open)
# 关闭连接 callback
def on_closed(self, connection):
print(f'{self.__str__()}: on_closed()')
connection.close()
self.connection = None
self.connected = False
self.io_loop.stop()
# 打开通道 callback
def on_channel_open(self, channel):
self.channel = channel
self.channel.exchange_declare(exchange=EXCHANGE, exchange_type="direct", durable=True)
# queue如果通过其他方式已经创建的话可能出错, 如果出错先删除再重新创建
try:
self.channel.queue_declare(queue=QUEUE, durable=True)
except Exception as e:
print(f'{self.__str__()} channel.queue_declare Error: ', e)
channel.queue_delete(queue=QUEUE)
channel.queue_declare(queue=QUEUE, durable=True)
self.channel.queue_bind(queue=QUEUE, exchange=EXCHANGE, routing_key=ROUTING_KEY)
# 如果是消费者, 绑定消息处理 callback
if isinstance(self, Consumer):
self.channel.basic_consume(queue=QUEUE, on_message_callback=self.handle_message, auto_ack=True)
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 connect(self):
'Establish RabbitMQ connection.'
self.connection = TornadoConnection(
pika.ConnectionParameters(host=self._host, port=self._port),
on_open_callback=self.on_connected)
logger.info('connecting to RabbitMQ...')
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:
self.logger.info('django-sockjs-server(PikaClient): Already connecting to RabbitMQ')
return
self.logger.info('django-sockjs-server(PikaClient): 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(PikaClient): error connect, wait 5 sec')
time.sleep(5)
self.reconnect()
self.last_reconnect = now()
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 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 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 _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
class PikaClient(object):
"""A modified class as described in pika's demo_tornado.py.
It handles the connection for the Tornado instance. Messaging/RPC
callbacks are handled by the Tornado RequestHandler above."""
def __init__(self):
self.connecting = False
self.connection = None
self.channel = None
#self.L = log_class.Logger()
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 on_connect(self, connection):
self.connection = connection
connection.channel(self.on_channel_open)
def on_channel_open(self, channel):
#self.L.logger.info('Channel Open')
self.channel = channel
# I'm having trouble using named exchanges.
## channel.exchange_declare(exchange='rpc_ex', type='direct',
## auto_delete=True, durable=False,
## callback=self.on_exchange_declare)
def on_exchange_declare(self, frame):
log.info("Exchange declared.")
def on_basic_cancel(self, frame):
log.info('Basic Cancel Ok.')
# If we don't have any more consumer processes running close
self.connection.close()
def on_closed(self, connection):
# We've closed our pika connection so stop the demo
tornado.ioloop.IOLoop.instance().stop()
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):
LOGGER.info('Connecting to RabbitMQ')
# exc_type, exc_value, exc_traceback = sys.exc_info()
# traceback.print_tb(exc_traceback, limit=None, file=sys.stdout)
# self.connecting = True
self._connection = TornadoConnection(rc.connParam,
on_open_callback=self.on_connection_open)
class AMQPClient(object):
"Connect to RabbitMQ and create a channel"
def __init__(self, on_msg_callback=None, oid=None, io_loop=None,
on_channel_created=None):
self.oid = oid or options.oid
self.io_loop = io_loop or IOLoop.instance()
self.on_msg_callback = on_msg_callback
self.connection = None
self.channel = None
self._on_channel_created = on_channel_created
self.checker = PeriodicCallback(self._check_connection, 1000)
def connect(self):
"Connect to RabbitMQ"
log.debug("Connecting to RabbitMQ")
if self.connection:
return
self.connection = TornadoConnection(
get_conn_params(),
self.on_connected,
custom_ioloop=self.io_loop)
def on_connected(self, connection):
"Create a channel just after connected"
log.debug("%s is established" % connection)
self.connection.channel(self.on_channel_created)
self.checker.start()
def on_channel_created(self, channel):
"Implement in subclasses"
log.debug("%s is established" % channel)
self.channel = channel
if self._on_channel_created:
self._on_channel_created(channel)
def _check_connection(self):
"Restablish connection to server if we lost it"
if self.connection:
try:
self.connection.socket.fileno()
except socket.error, exc:
log.debug("lost connection to RabbitMQ, %s" % str(exc))
self.checker.stop()
self.connection = None
self.connect()
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)
class PikaClient(object):
"""A modified class as described in pika's demo_tornado.py.
It handles the connection for the Tornado instance. Messaging/RPC
callbacks are handled by the Tornado RequestHandler above."""
def __init__(self):
self.connecting = False
self.connection = None
self.channel = None
# self.L = log_class.Logger()
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 on_connect(self, connection):
self.connection = connection
connection.channel(self.on_channel_open)
def on_channel_open(self, channel):
# self.L.logger.info('Channel Open')
self.channel = channel
# I'm having trouble using named exchanges.
## channel.exchange_declare(exchange='rpc_ex', type='direct',
## auto_delete=True, durable=False,
## callback=self.on_exchange_declare)
def on_exchange_declare(self, frame):
log.info("Exchange declared.")
def on_basic_cancel(self, frame):
log.info("Basic Cancel Ok.")
# If we don't have any more consumer processes running close
self.connection.close()
def on_closed(self, connection):
# We've closed our pika connection so stop the demo
tornado.ioloop.IOLoop.instance().stop()
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)
class PikaClient(object):
def __init__(self):
self.connected = False
self.connection = None
self.channel = None
self.messages = list()
def connect(self):
self.connection = TornadoConnection(on_open_callback=self.on_connected)
def on_connected(self, connection):
self.connected = True
self.connection = connection
self.connection.channel(self.on_channel_open)
def on_channel_open(self, channel):
pika.log.info("channel open")
self.channel = channel
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):
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):
"Connect to RabbitMQ"
log.debug("Connecting to RabbitMQ")
if self.connection:
return
self.connection = TornadoConnection(
get_conn_params(),
self.on_connected,
custom_ioloop=self.io_loop)
class PikaClient(object):
"""A modified class as described in pika's demo_tornado.py.
It handles the connection for the Tornado instance. Messaging/RPC
callbacks are handled by the Tornado RequestHandler above."""
def __init__(self):
self.connecting = False
self.connection = None
self.channel = None
def connect(self):
# print 22222222
if self.connecting:
logger.info('Already connecting to RabbitMQ.')
return
logger.info("Connecting to RabbitMQ")
self.connecting = True
creds = pika.PlainCredentials('zyl', 'pwd_zyl')
params = pika.ConnectionParameters(host='112.74.75.38', port=5672,
credentials=creds)
self.connection = TornadoConnection(params,
on_open_callback=self.on_connect)
self.connection.add_on_close_callback(self.on_closed)
# print 4444444444
def on_connect(self, connection):
self.connection = connection
connection.channel(self.on_channel_open)
def on_channel_open(self, channel):
logger.info('Channel Open')
self.channel = channel
def on_exchange_declare(self, frame):
logger.info("Exchange declared.")
def on_basic_cancel(self, frame):
logger.info('Basic Cancel Ok.')
# If we don't have any more consumer processes running close
self.connection.close()
def on_closed(self, connection):
# We've closed our pika connection so stop the demo
print 'close'
class Pika(object):
""" rabbitMQ manager. """
def __init__(self):
""" rabbitMQ manager init. """
self.connection = None
self.connecting = False
self.channel = None
def connect(self):
""" rabbitMQ manager connect. """
if self.connecting:
logging.info('Already connecting to RabbitMQ')
return
logging.info('Connectiong to RabbitMQ')
self.connecting = True
credentials = pika.PlainCredentials('guest', 'guest')
params = pika.ConnectionParameters(
host='localhost',
port=5672,
virtual_host='/smsgo',
credentials=credentials)
self.connection = TornadoConnection(
params, on_open_callback=self.on_connect)
self.connection.add_on_close_callback(on_closed)
def on_connect(self, connection):
""" rabbitMQ manager on connect callback. """
self.connection = connection
connection.channel(self.on_channel_open)
def on_channel_open(self, channel):
""" rabbitMQ manager on channel open callback. """
logging.info('Channel Open')
self.channel = channel
#def on_exchange_declare(self, frame):
#logging.info('Exchange Declare')
def on_basic_cancel(self, frame):
""" rabbitMQ manager on basic cancel callback. """
logging.info('Basic Cancel Ok')
self.connection.close()
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:
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)
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):
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):
logging.info("MQ connect...")
try:
self.connection = TornadoConnection(
self.connection_parameters,
self.on_connected
)
self.connection.add_on_close_callback(self.on_close)
except socket.error, e:
logging.warn("connection failed, trying again in 5 seconds")
self.io_loop.add_timeout(time.time() + 5, self.connect)
def connect(self):
pika.log.info('PikaClient: Connecting to RabbitMQ on localhost:5672')
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)
class PikaClient(object):
def __init__(self, username='******', exchange_name='ws', password='******', host='localhost', port=5672, virtual_host='/'):
self.exchange_name = exchange_name
# Options
self.username = username
self.password = password
self.host = host
self.port = port
self.virtual_host = virtual_host
# Default values
self.connected = False
self.connecting = False
self.connection = None
self.channel = None
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(self.username, self.password)
param = pika.ConnectionParameters(host=self.host,
port=self.port,
virtual_host=self.virtual_host,
credentials=credentials)
self.connection = TornadoConnection(param,
on_open_callback=self.on_connected)
self.connection.add_on_close_callback(self.on_closed)
def on_connected(self, connection):
pika.log.info('PikaClient: Connected to RabbitMQ on localhost:5672')
self.connected = True
self.connection = connection
self.connection.channel(self.on_channel_open)
def on_channel_open(self, channel):
pika.log.info('PikaClient: Channel Open, Declaring Exchange')
self.channel = channel
self.channel.exchange_declare(exchange=self.exchange_name,
type="direct",
callback=self.on_exchange_declared)
def on_exchange_declared(self, frame):
pika.log.info('PikaClient: Exchange Declared, Ready for declaring Queues')
def on_basic_cancel(self, frame):
pika.log.info('PikaClient: Basic Cancel Ok')
# If we don't have any more consumer processes running close
self.connection.close()
def on_closed(self, connection):
# We've closed our pika connection so stop the demo
tornado.ioloop.IOLoop.instance().stop()
class RabbitClient(object):
"""Managing incoming messages from Rabbit Service"""
def __init__(self, app=None):
self.app = app
self._connect()
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 on_disconnect(self, *args):
logger.warning("Connection lost, reconnect in 5 seconds...")
IOLoop.instance().add_timeout(
time.time() + 5, self._connect)
def on_connected(self, con):
con.channel(self.on_channel_open)
def on_channel_open(self, channel):
channel.basic_consume(consumer_callback=self.on_message,
queue=CREDS['queue'],
no_ack=True)
def on_message(self, channel, method, header, body):
self.app.manager.send(body)
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(self.username, self.password)
param = pika.ConnectionParameters(host=self.host,
port=self.port,
virtual_host=self.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):
""" rabbitMQ manager connect. """
if self.connecting:
logging.info('Already connecting to RabbitMQ')
return
logging.info('Connectiong to RabbitMQ')
self.connecting = True
credentials = pika.PlainCredentials('guest', 'guest')
params = pika.ConnectionParameters(
host='localhost',
port=5672,
virtual_host='/smsgo',
credentials=credentials)
self.connection = TornadoConnection(
params, on_open_callback=self.on_connect)
self.connection.add_on_close_callback(on_closed)
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:
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.94.68",
# 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)
def connect(self):
if self.connecting:
self.logger.warning('Already connecting to RabbitMQ')
return
param = self._connect_pull[self._connect_index]
self.logger.debug('Connecting to RabbitMQ on '
'{host}:{port}'.format(host=param.host,
port=param.port))
self.connecting = True
# TODO: add on_connection_error
try:
self.connection = TornadoConnection(
param,
on_open_callback=self.on_connected
)
self.connection.add_on_close_callback(self.on_closed)
except AMQPConnectionError:
self.reconnect()
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='localhost',
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)
