def test_uri_set_heartbeat(self): connection = \ UriConnection('amqps://*****:*****@localhost:5672/%2F?' 'heartbeat=360', True) self.assertIsInstance(connection.parameters['heartbeat'], int) self.assertEqual(connection.parameters['heartbeat'], 360)
def test_uri_simple(self): connection = \ UriConnection('amqps://localhost:5672/%2F', True) self.assertEqual(connection.parameters['hostname'], 'localhost') self.assertEqual(connection.parameters['username'], 'guest') self.assertEqual(connection.parameters['password'], 'guest')
def test_uri_set_password(self): connection = \ UriConnection('amqps://*****:*****@localhost:5672/%2F?' 'heartbeat=1337', True) self.assertIsInstance(connection.parameters['password'], str) self.assertEqual(connection.parameters['password'], 'password')
def test_uri_set_hostname(self): connection = \ UriConnection('amqps://*****:*****@my-server:5672/%2F?' 'heartbeat=1337', True) self.assertIsInstance(connection.parameters['hostname'], str) self.assertEqual(connection.parameters['hostname'], 'my-server')
def test_uri_set_username(self): connection = \ UriConnection('amqps://*****:*****@localhost:5672/%2F?' 'heartbeat=1337', True) self.assertIsInstance(connection.parameters['username'], str) self.assertEqual(connection.parameters['username'], 'username')
def test_uri_set_timeout(self): connection = \ UriConnection('amqps://*****:*****@localhost:5672/%2F?' 'timeout=1337', True) self.assertIsInstance(connection.parameters['timeout'], int) self.assertEqual(connection.parameters['timeout'], 1337)
def connection(self): """The :class:amqpstorm.Connection` for the current proccess. This property may change without notice. """ with self.lock: if self._connection is None or self._connection.is_closed: self._connection = UriConnection(self.url) return self._connection
def test_uri_set_client_properties(self): cp = {'platform': 'Atari', 'license': 'MIT'} connection = UriConnection('amqp://*****:*****@localhost:5672/%2F', lazy=True, client_properties=cp) self.assertIsInstance(connection.parameters['client_properties'], dict) self.assertEqual(connection.parameters['client_properties'], cp)
def test_functional_ssl_uri_connection_with_context(self): ssl_options = { 'context': ssl.create_default_context(cafile=CAFILE), 'server_hostname': SSL_HOST } self.connection = UriConnection(SSL_URI, ssl_options=ssl_options) self.channel = self.connection.channel() self.assertTrue(self.connection.is_open)
def test_uri_get_invalid_ssl_validation(self): connection = \ UriConnection('amqps://*****:*****@localhost:5672/%2F', True) self.assertEqual(ssl.CERT_NONE, connection._get_ssl_validation('cert_test')) self.assertIn( "ssl_options: cert_reqs 'cert_test' not found " "falling back to CERT_NONE.", self.get_last_log())
def test_uri_get_invalid_ssl_version(self): connection = \ UriConnection('amqps://*****:*****@localhost:5672/%2F', True) self.assertEqual(connection._get_ssl_version('protocol_test'), ssl.PROTOCOL_TLSv1) self.assertIn( "ssl_options: ssl_version 'protocol_test' not found " "falling back to PROTOCOL_TLSv1.", self.get_last_log())
def test_uri_invalid_ssl_options(self): connection = \ UriConnection('amqps://*****:*****@localhost:5672/%2F', True) ssl_kwargs = { 'unit_test': ['not_required'], } ssl_options = connection._parse_ssl_options(ssl_kwargs) self.assertFalse(ssl_options) self.assertIn("invalid option: unit_test", self.get_last_log())
def test_uri_invalid_ssl_options(self): connection = \ UriConnection('amqps://*****:*****@localhost:5672/%2F', True) ssl_kwargs = { 'unit_test': ['not_required'], } ssl_options = connection._parse_ssl_options(ssl_kwargs) self.assertFalse(ssl_options) self.assertIn("invalid option: unit_test", self.logging_handler.messages['warning'][0])
def test_uri_default(self): connection = \ UriConnection('amqp://*****:*****@localhost:5672/%2F', True) self.assertEqual(connection.parameters['hostname'], 'localhost') self.assertEqual(connection.parameters['username'], 'guest') self.assertEqual(connection.parameters['password'], 'guest') self.assertEqual(connection.parameters['virtual_host'], '/') self.assertEqual(connection.parameters['port'], 5672) self.assertEqual(connection.parameters['heartbeat'], 60) self.assertEqual(connection.parameters['timeout'], 30) self.assertFalse(connection.parameters['ssl'])
def test_uri_get_ssl_options(self): connection = \ UriConnection('amqp://*****:*****@localhost:5672/%2F', True) ssl_kwargs = { 'cert_reqs': ['cert_required'], 'ssl_version': ['protocol_tlsv1'], 'keyfile': ['file.key'], 'certfile': ['file.crt'] } ssl_options = connection._parse_ssl_options(ssl_kwargs) self.assertEqual(ssl_options['cert_reqs'], ssl.CERT_REQUIRED) self.assertEqual(ssl_options['ssl_version'], ssl.PROTOCOL_TLSv1) self.assertEqual(ssl_options['keyfile'], 'file.key') self.assertEqual(ssl_options['certfile'], 'file.crt')
def test_uri_default(self): connection = UriConnection('amqp://*****:*****@localhost:5672/%2F', lazy=True) self.assertEqual(connection.parameters['hostname'], 'localhost') self.assertEqual(connection.parameters['username'], 'guest') self.assertEqual(connection.parameters['password'], 'guest') self.assertEqual(connection.parameters['virtual_host'], DEFAULT_VIRTUAL_HOST) self.assertEqual(connection.parameters['port'], 5672) self.assertEqual(connection.parameters['heartbeat'], DEFAULT_HEARTBEAT_INTERVAL) self.assertEqual(connection.parameters['timeout'], DEFAULT_SOCKET_TIMEOUT) self.assertFalse(connection.parameters['ssl'])
def connect(self): """Create a connection. :return: """ attempts = 0 while True: attempts += 1 try: if self._router._connection_type == "app": request_res = requests.post( "https://api.kervi.io/sessions", headers={ "api-user": self._user, "api-password": self._password, "app_id": self._app_id, "app_name": self._app_name, }) print("cres", request_res.json()) connection_string = 'amqps://' + self._user + ':' + self._password + '@' + self._address + ':' + str( self._port) + '/' + self._vhost #print("cns", connection_string) self._connection = UriConnection(connection_string) #self._connection = Connection(self._address, self._user, self._password, port=self._port, vhost=self._vhost) break except amqpstorm.AMQPError as why: LOGGER.exception(why) print("why connect", why.error_code) if why.error_code == 403 or why.error_code == 530: print( "Kervi.io authentication error, check configuration for the plugin kervi.plugin.routing.kervi_io" ) break if self._max_retries and attempts > self._max_retries: break time.sleep(min(attempts * 2, 30)) except KeyboardInterrupt: break if self._connection: self._consumer = _MQConsumer(self) self._consumer.start() self._publisher = _MQPublisher(self) self._router.on_connected()
def test_uri_set_ssl(self): connection = UriConnection( 'amqps://*****:*****@localhost:5671/%2F?' 'ssl_version=protocol_tlsv1&cert_reqs=cert_required&' 'keyfile=file.key&certfile=file.crt&' 'ca_certs=travis-ci', True) self.assertTrue(connection.parameters['ssl']) self.assertEqual(connection.parameters['ssl_options']['ssl_version'], ssl.PROTOCOL_TLSv1) self.assertEqual(connection.parameters['ssl_options']['cert_reqs'], ssl.CERT_REQUIRED) self.assertEqual(connection.parameters['ssl_options']['keyfile'], 'file.key') self.assertEqual(connection.parameters['ssl_options']['certfile'], 'file.crt') self.assertEqual(connection.parameters['ssl_options']['ca_certs'], 'travis-ci')
def connect(self, force=False): """Connect to the Message Broker supporting AMQP(S).""" if force: LOG.debug("Force close the connection") self.close() if self.conn: # LOG.debug("We already have a connection") if not self.conn.is_closed: # LOG.debug("connection not closed, returning it") return self.close() if not self.connection_params: self.fetch_args() self.conn = UriConnection(self.connection_params, ssl_options=self.ssl_options, client_properties=self.client_properties, lazy=True) # don't start it # Retry loop backoff = self.interval for count in range(1, self.attempts + 1): try: self.conn.open() LOG.debug("Connection successful") return except AMQPConnectionError as e: self.conn.close( ) # when we can't open, we must close the unused socket LOG.error("Opening MQ Connection retry attempt %d", count) LOG.error('Reason %r', e) sleep(backoff) backoff = (2**(count // 10)) * self.interval # from 0 to 9, sleep 1 * interval secs # from 10 to 19, sleep 2 * interval secs # from 20 to 29, sleep 4 * interval secs ... etc # fail if callable(self.on_failure): LOG.error("Failed to open the connection") self.on_failure()
def test_uri_get_ssl_options_new_method(self): ssl_kwargs = { 'cert_reqs': ssl.CERT_REQUIRED, 'ssl_version': ssl.PROTOCOL_TLSv1, 'keyfile': 'file.key', 'certfile': 'file.crt' } connection = UriConnection( 'amqps://*****:*****@localhost:5671/%2F?' 'server_hostname=rmq.eandersson.net&certfile=file.crt', ssl_options=ssl_kwargs, lazy=True) ssl_options = connection.parameters.get('ssl_options') self.assertEqual(ssl_options['server_hostname'], 'rmq.eandersson.net') self.assertEqual(ssl_options['cert_reqs'], ssl.CERT_REQUIRED) self.assertEqual(ssl_options['ssl_version'], ssl.PROTOCOL_TLSv1) self.assertEqual(ssl_options['keyfile'], 'file.key') self.assertEqual(ssl_options['certfile'], 'file.crt')
def connect(self, amqp_uri, events_bindings: Dict[str, Callable], exchange_name): if exchange_name not in self._exchanges: if amqp_uri not in self._connections: self._connections[amqp_uri] = { '_conn': UriConnection(amqp_uri) } self._connections[amqp_uri]['_ch'] = self._connections[ amqp_uri]['_conn'].channel() channel = self._connections[amqp_uri]['_ch'] # Declare direct exchange channel.exchange.declare(exchange=exchange_name, durable=True) for event_name, callback in events_bindings.items(): declared_queue = channel.queue.declare(queue=event_name) queue_name = declared_queue.get('queue') channel.queue.bind(queue_name, exchange_name, event_name) # Define queue callback function channel.basic.consume(queue=queue_name, callback=callback) self._exchanges[exchange_name] = channel else: raise ValueError( 'Already connected to server / exchange combination')
def setup_connection(self): """ Connect to rabbit mq using self.rabbitmq_url. """ self._connection = UriConnection(self.rabbitmq_url) return self._connection
r.publish(token + "face", rid) #print(token,rid) return while True: result = childChannel.basic.get("tf-task", no_ack=False) if not result: childChannel.basic.consume(processTask, "tf-task", no_ack=False) childChannel.start_consuming() continue processTask(result) while True: try: mainConnection = UriConnection(config.RABBITMQ_CONFIG['uri']) break except: print("Couldn't connect to rabbitMQ server. Retrying") time.sleep(3) continue global mainchannel_out mainChannel_out = mainConnection.channel() mainChannel_in = mainConnection.channel() def processMessage(message): message.ack() #print(message.body) tensorThread(message.body) ##
def test_uri_set_virtual_host(self): connection = \ UriConnection('amqps://*****:*****@localhost:5672/travis', True) self.assertIsInstance(connection.parameters['virtual_host'], str) self.assertEqual(connection.parameters['virtual_host'], 'travis')
def test_uri_set_port(self): connection = \ UriConnection('amqps://*****:*****@localhost:1337/%2F', True) self.assertIsInstance(connection.parameters['port'], int) self.assertEqual(connection.parameters['port'], 1337)
def test_uri_set_port(self): connection = UriConnection('amqps://*****:*****@localhost:5672/%2F', lazy=True) self.assertIsInstance(connection.parameters['port'], int) self.assertEqual(connection.parameters['port'], 5672)
def test_functional_uri_connection(self): self.connection = UriConnection(URI) self.channel = self.connection.channel() self.assertTrue(self.connection.is_open)
def test_uri_get_ssl_version(self): connection = \ UriConnection('amqp://*****:*****@localhost:5672/%2F', True) self.assertEqual(ssl.PROTOCOL_TLSv1, connection._get_ssl_version('protocol_tlsv1'))
def test_uri_ssl(self): connection = \ UriConnection('amqps://*****:*****@localhost:5672/%2F', True) self.assertTrue(connection.parameters['ssl'])
def test_uri_get_ssl_validation(self): connection = \ UriConnection('amqps://*****:*****@localhost:5672/%2F', True) self.assertEqual(ssl.CERT_REQUIRED, connection._get_ssl_validation('cert_required'))