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)