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'))
