def test_eq(self):
self.assertEqual(credentials.PlainCredentials('u', 'p'),
credentials.PlainCredentials('u', 'p'))
self.assertEqual(credentials.PlainCredentials('u', 'p', True),
credentials.PlainCredentials('u', 'p', True))
self.assertEqual(credentials.PlainCredentials('u', 'p', False),
credentials.PlainCredentials('u', 'p', False))
self.assertEqual(credentials.PlainCredentials('u', 'p', False),
ChildPlainCredentials('u', 'p', False))
self.assertEqual(ChildPlainCredentials('u', 'p', False),
credentials.PlainCredentials('u', 'p', False))
class Foreign(object):
def __eq__(self, other):
return 'foobar'
self.assertEqual(
credentials.PlainCredentials('u', 'p', False) == Foreign(),
'foobar')
self.assertEqual(
Foreign() == credentials.PlainCredentials('u', 'p', False),
'foobar')
def credentials(username, password):
"""返回一个plain credentials对象
:param username:用户名
:param password:密码
:return:pika_credentials.PlainCredentials
"""
return credentials.PlainCredentials(username, password)
def _init_messaging(self):
LOG.info('Initializing connection to rabbitmq node..')
# construct credentials
credentials = pika_credentials.PlainCredentials(
username=self.rabbitUID, password=self.rabbitPass)
parameters = pika.ConnectionParameters(
host=self.rabbitHost,
port=self.rabbitPort,
virtual_host=self.rabbitVHost,
credentials=credentials,
channel_max=self.channel_max,
frame_max=self.frame_max,
heartbeat_interval=self.heartbeat_rate,
connection_attempts=self.connection_attemps,
retry_delay=self.retry_delay,
socket_timeout=self.socket_timeout,
locale=self.pika_locale)
self.connection = pika.BlockingConnection(parameters=parameters)
self.channel = self.connection.channel()
self.channel.confirm_delivery()
# self.channel.basic_qos(prefetch_size=0,
# prefetch_count=0,
# all_channels=False
# )
self.channel.exchange_declare(exchange=self.exchange_name,
exchange_type=self.exchange_type,
passive=self.is_passive,
durable=self.is_durable,
auto_delete=self.is_auto_delete,
internal=self.is_internal,
arguments=self.arguments)
def create_or_get_instance(rabbitmq_conf):
global __conn
if __conn is None:
connection_conf = []
creds = credentials.PlainCredentials(rabbitmq_conf['user'],
rabbitmq_conf['pass'])
hosts = rabbitmq_conf['hosts']
for host_idx in range(len(hosts)):
params = connection.ConnectionParameters(host=hosts[host_idx],
credentials=creds)
if host_idx == len(hosts) - 1:
params.connection_attempts = rabbitmq_conf[
'connection_attempts']
params.retry_delay = rabbitmq_conf['retry_delay']
connection_conf.append(params)
try:
__conn = adapters.select_connection.SelectConnection(
connection_conf, custom_ioloop=IOLoop.current())
__conn.add_on_close_callback(
RabbitMq._on_connection_close(rabbitmq_conf))
except AMQPConnectionError as e:
print(
f'Failed to connect to any of the RabbitMq hosts {hosts} because {e}'
)
raise e
return __conn
def new_mock_parameters(self, host, port, vhost, user, password):
mock_credentials = credentials.PlainCredentials(user, password)
mock_credentials.username = user
mock_credentials.password = password
mock_parameters = connection.ConnectionParameters(
host, port, vhost, mock_credentials)
return mock_parameters
def test_good_connection_parameters(self):
"""make sure connection kwargs get set correctly"""
kwargs = {
'host': 'https://www.test.com',
'port': 5678,
'virtual_host': u'vvhost',
'channel_max': 3,
'frame_max': 40000,
'credentials': credentials.PlainCredentials('very', 'secure'),
'heartbeat_interval': 7,
'backpressure_detection': False,
'retry_delay': 3,
'ssl': True,
'connection_attempts': 2,
'locale': 'en',
'ssl_options': {'ssl': 'options'}
}
conn = connection.ConnectionParameters(**kwargs)
#check values
for t_param in ('host', 'port', 'virtual_host', 'channel_max',
'frame_max', 'backpressure_detection', 'ssl',
'credentials', 'retry_delay', 'connection_attempts',
'locale'):
self.assertEqual(kwargs[t_param], getattr(conn, t_param), t_param)
self.assertEqual(kwargs['heartbeat_interval'], conn.heartbeat)
def test_good_connection_parameters(self):
"""make sure connection kwargs get set correctly"""
kwargs = {
'backpressure_detection': False,
'blocked_connection_timeout': 10.5,
'channel_max': 3,
'client_properties': {'good': 'day'},
'connection_attempts': 2,
'credentials': credentials.PlainCredentials('very', 'secure'),
'frame_max': 40000,
'heartbeat': 7,
'host': 'https://www.test.com',
'locale': 'en',
'port': 5678,
'retry_delay': 3,
'socket_timeout': 100.5,
'ssl': True,
'ssl_options': {'ssl': 'options'},
'virtual_host': u'vvhost',
}
params = connection.ConnectionParameters(**kwargs)
# Verify
expected_values = copy.copy(kwargs)
# Make sure we're testing all public properties
self.assertSequenceEqual(sorted(expected_values),
sorted(_ALL_PUBLIC_PARAMETERS_PROPERTIES))
# Check property values
for t_param in expected_values:
value = getattr(params, t_param)
self.assertEqual(expected_values[t_param], value,
msg='Expected %s=%r, but got %r' %
(t_param, expected_values[t_param], value))
def get_default_properties(self):
"""
:returns: a dict of expected public property names and default values
for `pika.connection.Parameters`
"""
kls = connection.Parameters
defaults = {
'backpressure_detection': kls.DEFAULT_BACKPRESSURE_DETECTION,
'blocked_connection_timeout':
kls.DEFAULT_BLOCKED_CONNECTION_TIMEOUT,
'channel_max': kls.DEFAULT_CHANNEL_MAX,
'client_properties': kls.DEFAULT_CLIENT_PROPERTIES,
'connection_attempts': kls.DEFAULT_CONNECTION_ATTEMPTS,
'credentials': credentials.PlainCredentials(kls.DEFAULT_USERNAME,
kls.DEFAULT_PASSWORD),
'frame_max': kls.DEFAULT_FRAME_MAX,
'heartbeat': kls.DEFAULT_HEARTBEAT_TIMEOUT,
'host': kls.DEFAULT_HOST,
'locale': kls.DEFAULT_LOCALE,
'port': kls.DEFAULT_PORT,
'retry_delay': kls.DEFAULT_RETRY_DELAY,
'socket_timeout': kls.DEFAULT_SOCKET_TIMEOUT,
'ssl': kls.DEFAULT_SSL,
'ssl_options': kls.DEFAULT_SSL_OPTIONS,
'virtual_host': kls.DEFAULT_VIRTUAL_HOST
}
# Make sure we didn't miss anything
self.assertSequenceEqual(sorted(defaults),
sorted(_ALL_PUBLIC_PARAMETERS_PROPERTIES))
return defaults
def _credentials(self, username, password):
'''返回一个plain credentials对象
:param username:用户名
:param password:密码
:return:pika_credentials.PlainCredentials
'''
return credentials.PlainCredentials(username, password)
def _credentials(self, username, password):
"""Return a plain credentials object for the specified username and
password.
:param str username: The username to use
:param str password: The password to use
:rtype: pika_credentials.PlainCredentials
"""
return pika_credentials.PlainCredentials(username, password)
def __init__(self, level=logging.NOTSET, formatter=JSONFormatter(),
host='localhost', port=5672, connection_params=None,
username=None, password=None,
exchange='log', declare_exchange=False,
routing_key_format="{name}.{level}", close_after_emit=False,
fields=None, fields_under_root=True):
"""
Initialize the handler.
:param level: Logs level.
:param formatter: Use custom formatter for the logs.
:param host: RabbitMQ host. Default localhost
:param port: RabbitMQ Port. Default 5672
:param connection_params: Allow extra params to connect with RabbitMQ.
:param username: Username in case of authentication.
:param password: Password for the username.
:param exchange: Send logs using this exchange.
:param declare_exchange: Whether or not to declare the exchange.
:param routing_key_format: Customize how messages will be routed to the queues.
:param close_after_emit: Close connection after emit the record?
:param fields: Send these fields as part of all logs.
:param fields_under_root: Merge the fields in the root object.
"""
super(RabbitMQHandler, self).__init__(level=level)
# Important instances/properties.
self.exchange = exchange
self.connection = None
self.channel = None
self.exchange_declared = not declare_exchange
self.routing_key_format = routing_key_format
self.close_after_emit = close_after_emit
# Connection parameters.
# Allow extra params when connect to RabbitMQ.
# @see: http://pika.readthedocs.io/en/0.10.0/modules/parameters.html#pika.connection.ConnectionParameters
conn_params = connection_params if isinstance(connection_params, dict) else {}
self.connection_params = conn_params.copy()
self.connection_params.update(dict(host=host, port=port, heartbeat_interval=0))
if username and password:
self.connection_params['credentials'] = credentials.PlainCredentials(username, password)
# Logging.
self.formatter = formatter
self.fields = fields if isinstance(fields, dict) else {}
self.fields_under_root = fields_under_root
if len(self.fields) > 0:
self.addFilter(FieldFilter(self.fields, self.fields_under_root))
# Connect.
self.createLock()
def __init__(self, config, type, callback=None):
'''
初始化需要连接的rabbitmq server
:param config: 要连接的rabbitmq server 配置信息，config.py模块导入
:param type: 需要接收的日志等级
:param callback: 对接收到的日志信息进行的处理
'''
self.connection_para = dict(host=config.MQHOST)
if config.MQPORT:
self.connection_para['port'] = config.MQPORT
if config.VIRTUAL_HOST:
self.connection_para['virtual_host'] = config.VIRTUAL_HOST
if config.USERNAME and config.PASSWORD:
self.connection_para['credentials'] = credentials.PlainCredentials(
config.USERNAME, config.PASSWORD)
self.exchange = config.EXCHANGE
self.exchange_type = config.EXCHANGE_TYPE
self.connection, self.channel = None, None
#连接到指定的rabbitmq server
try:
self.connection = pika.BlockingConnection(
pika.ConnectionParameters(**self.connection_para))
except Exception as e:
print "connect to rabbitmq is error"
else:
self.channel = self.connection.channel()
#创建rabbitmq server 的exchange，并使该机制持久化存储在rabbitmq中
self.channel.exchange_declare(exchange=self.exchange,
exchange_type=self.exchange_type,
durable=True,
auto_delete=False)
sys.stdout.write('%s - stdout - [mq] Declare exchange success.\n' %
datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
#创建需要监听的消息队列
result = self.channel.queue_declare(queue=config.QUEUE_NAMES[type])
queue_name = result.method.queue
#exchange和需要监听的queue进行绑定
self.channel.queue_bind(exchange=MQLogConfig.EXCHANGE,
queue=config.QUEUE_NAMES[type],
routing_key="#." + config.BRIND_KEYS[type])
#对rabbitmq server 队列中的消息进行处理，默认把消息打印到console，可自己指定xxxcallback
if callback == None:
self.channel.basic_consume(printcallback,
queue=queue_name,
no_ack=True)
else:
self.channel.basic_consume(callback, queue=queue_name, no_ack=True)
def test_eq(self):
self.assertEqual(credentials.PlainCredentials('u', 'p'),
credentials.PlainCredentials('u', 'p'))
self.assertEqual(credentials.PlainCredentials('u', 'p', True),
credentials.PlainCredentials('u', 'p', True))
self.assertEqual(credentials.PlainCredentials('u', 'p', False),
credentials.PlainCredentials('u', 'p', False))
def test_eq(self):
params_1 = connection.Parameters()
params_2 = connection.Parameters()
params_3 = ChildParameters()
self.assertEqual(params_1, params_2)
self.assertEqual(params_2, params_1)
params_1.host = 'localhost'
params_1.port = 5672
params_1.virtual_host = '/'
params_1.credentials = credentials.PlainCredentials('u', 'p')
params_2.host = 'localhost'
params_2.port = 5672
params_2.virtual_host = '//'
params_2.credentials = credentials.PlainCredentials('uu', 'pp')
self.assertEqual(params_1, params_2)
self.assertEqual(params_2, params_1)
params_1.host = 'localhost'
params_1.port = 5672
params_1.virtual_host = '/'
params_1.credentials = credentials.PlainCredentials('u', 'p')
params_3.host = 'localhost'
params_3.port = 5672
params_3.virtual_host = '//'
params_3.credentials = credentials.PlainCredentials('uu', 'pp')
self.assertEqual(params_1, params_3)
self.assertEqual(params_3, params_1)
class Foreign(object):
def __eq__(self, other):
return 'foobar'
self.assertEqual(params_1 == Foreign(), 'foobar')
self.assertEqual(Foreign() == params_1, 'foobar')
def _get_common_settings(cls):
if 'url' in settings.CQRS:
host, port, user, password = cls._parse_url(settings.CQRS.get('url'))
else:
host = settings.CQRS.get('host', ConnectionParameters.DEFAULT_HOST)
port = settings.CQRS.get('port', ConnectionParameters.DEFAULT_PORT)
user = settings.CQRS.get('user', ConnectionParameters.DEFAULT_USERNAME)
password = settings.CQRS.get('password', ConnectionParameters.DEFAULT_PASSWORD)
exchange = settings.CQRS.get('exchange', 'cqrs')
return (
host,
port,
credentials.PlainCredentials(user, password, erase_on_connect=True),
exchange,
)
def test_credentials(self):
params = connection.Parameters()
plain_cred = credentials.PlainCredentials('very', 'reliable')
params.credentials = plain_cred
self.assertEqual(params.credentials, plain_cred)
ext_cred = credentials.ExternalCredentials()
params.credentials = ext_cred
self.assertEqual(params.credentials, ext_cred)
with self.assertRaises(TypeError):
params.credentials = connection.Parameters()
with self.assertRaises(TypeError):
params.credentials = repr(plain_cred)
def receive_messages(
host: str, port: int, user: str, password: str, queue: str
) -> None:
"""
Start consuming messages from RabbitMQ broker.
:param host: Host of XQueue broker.
:param port: Port of XQueue broker.
:param user: Username for basic auth.
:param password: Password for basic auth.
:param queue: Queue name.
"""
#logger: Logger = get_logger("rabbitmq")
connection: BlockingConnection = BlockingConnection(
ConnectionParameters(
host=host,
port=port,
credentials=credentials.PlainCredentials(user, password),
)
)
ch: channel = connection.channel()
# Set durable=True to save messages between RabbitMQ restarts
ch.queue_declare(queue=queue, durable=True)
# Make RabbitMQ avoid giving more than 1 message at a time to a worker
ch.basic_qos(prefetch_count=1)
# Start receiving messages
ch.basic_consume(queue=queue, on_message_callback=callback_function)
try:
#logger.info("Started consuming messages from RabbitMQ.")
print("Started consuming messages from RabbitMQ.")
ch.start_consuming()
except KeyboardInterrupt as exception:
#logger.info("Stopped consuming messages from RabbitMQ.")
print("Stopped consuming messages from RabbitMQ.")
ch.stop_consuming()
connection.close()
raise exception
def __init__(self,
auth_user: str,
auth_pass: str,
host: str,
vhost: str,
queue: str,
port: int = 5672):
self.queue_name = queue
self.params = pika.ConnectionParameters(
host=host,
port=port,
virtual_host=vhost,
blocked_connection_timeout=2,
socket_timeout=2,
credentials=credentials.PlainCredentials(username=auth_user,
password=auth_pass,
erase_on_connect=True))
self.connection = None
self.channel = None
def __init__(self, host, port, virtual_host, user, password):
"""Construct our RabbitMQ object for use on the Tornado IOLoop
:param host: RabbitMQ server host
:type host: str
:param port: RabbitMQ server port
:type port: int
:param virtual_host: RabbitMQ virtual host to use
:type virtual_host: str
:param user: RabbitMQ user to connect as
:type user: str
:param password: RabbitMQ user's password
:type paassword: str
"""
# Create a logger instance
self._logger = logging.getLogger(__name__)
# We don't have a valid connection until the initial connect is done
self._connection = None
# We don't have a channel until we're connected
self._channel = None
# Set our app_id for publishing messages
self.app_id = "%s/%s" % (RabbitMQ.DEFAULT_APP_ID, __version__)
# Set our delivery mode for publishing messages
self.delivery_mode = RabbitMQ.DEFAULT_DELIVERY_MODE
# Set our encoding for publishing messages
self.encoding = RabbitMQ.DEFAULT_ENCODING
# Create our credentials
creds = credentials.PlainCredentials(username=user, password=password)
# Create the connection parameters
self.params = connection.ConnectionParameters(
host=host, port=port, virtual_host=virtual_host, credentials=creds)
# Create a new connection
tornado_connection.TornadoConnection(self.params, self._on_connected)
def add_tasks(self, task):
"""
Add load testing tasks to the queue
"""
message = QueueTaskSerializer().to_representation(task)
message["host"] = settings.EXTERNAL_ADDRESS
connection = pika.BlockingConnection(
pika.ConnectionParameters(
host=str(settings.AMQP_HOST),
credentials=pika_credentials.PlainCredentials(
settings.AMQP_USER, settings.AMQP_PASS)))
channel = connection.channel()
serialized_message = json.dumps(message)
for _ in xrange(task.run_count):
channel.basic_publish(exchange='',
routing_key=settings.AMQP_QUEUE,
body=serialized_message)
connection.close()
def __init__(self):
logging.Handler.__init__(self)
self.zafira_connected = self.__connect_to_zafira()
self.exchange = 'logs'
self.connection = None
self.channel = None
self.virtual_host = '/'
self.type = 'x-recent-history'
self.history = 1000
self.routing_key = ''
# make sure exchange only declared once.
self.is_exchange_declared = False
# lock for serializing log sending, because pika is not thread safe.
self.emit_lock = threading.Lock()
# init connection.
self.connection_params = dict(host=self.host,
port=self.port,
virtual_host=self.virtual_host,
credentials=credentials.PlainCredentials(
self.username, self.password))
self.activate_options()
def __init__(self, config):
'''
初始化需要连接的rabbitmq server
:param config: 要连接的rabbitmq server 配置信息，config.py模块导入
'''
logging.Handler.__init__(self)
self.connection_para = dict(host=config["mqhsot"])
if config["mqhsot"]:
self.connection_para['port'] = config["mqport"]
if config["virtual_host"]:
self.connection_para['virtual_host'] = config["virtual_host"]
if config["username"] and config["password"]:
self.connection_para['credentials'] = credentials.PlainCredentials(
config["username"], config["password"])
self.exchange = config["exchange"]
self.exchange_type = config["exchange_type"]
self.connection, self.channel = None, None
# make sure exchange only declared once.
self.is_exchange_declared = False
# init connection.
self.connect()
def startService(self):
params = {}
if self.settings.get("username", None, section='amqp') \
and self.settings.get("pass", None, section='amqp'):
params['credentials'] = pika_credentials.PlainCredentials(
self.settings.get("username", None, section='amqp'),
self.settings.get("pass", None, section='amqp'))
if self.settings.getdict("params", dict(), section='amqp'):
params.update(
self.settings.getdict("params", dict(), section='amqp'))
if self.settings.get("amqp_vhost", '/'):
params.update({
'virtual_host':
self.settings.get("vhost", '/', section='amqp')
})
parameters = ConnectionParameters(**params)
self._client = protocol.ClientCreator(
reactor, twisted_connection.TwistedProtocolConnection, parameters)
self.do_connect()
def _do_create_host_connection(self, host, for_listening):
connection_params = pika.ConnectionParameters(
host=host.hostname,
port=host.port,
credentials=pika_credentials.PlainCredentials(
host.username, host.password
),
heartbeat_interval=(
self._heartbeat_interval if for_listening else None
),
**self._common_pika_params
)
if for_listening:
connection = pika_connection.ThreadSafePikaConnection(
parameters=connection_params
)
else:
connection = pika.BlockingConnection(
parameters=connection_params
)
connection.params = connection_params
self._set_tcp_user_timeout(connection._impl.socket)
return connection
def __init__(self, level=logging.NOTSET, formatter=None,
host='localhost', port=5672, connection_params=None,
username=None, password=None,
exchange='log', declare_exchange=False,
routing_key_format="{name}.{level}",
routing_key_formatter=None,
close_after_emit=False,
fields=None, fields_under_root=True, message_headers=None,
record_fields=None, exclude_record_fields=None):
# Initialize the handler.
#
# :param level: Logs level.
# :param formatter: Use custom formatter for the logs.
# :param host: RabbitMQ host. Default localhost
# :param port: RabbitMQ Port. Default 5672
# :param connection_params: Allow extra params to connect with RabbitMQ.
# :param message_headers: A dictionary of headers to be published with the message. Optional.
# :param username: Username in case of authentication.
# :param password: Password for the username.
# :param exchange: Send logs using this exchange.
# :param declare_exchange: Whether or not to declare the exchange.
# :param routing_key_format: Customize how messages will be routed to the queues.
# :param routing_key_formatter: Override how messages will be routed to the queues.
# Formatter is passed record object.
# :param close_after_emit: Close connection after emit the record?
# :param fields: Send these fields as part of all logs.
# :param fields_under_root: Merge the fields in the root object.
# :record_fields A set of attributes that should be preserved from the record object.
# :exclude_record_fields A set of attributes that should be ignored from the record object.
super(RabbitMQHandler, self).__init__(level=level)
# Important instances/properties.
self.exchange = exchange
self.connection = None
self.channel = None
self.exchange_declared = not declare_exchange
self.routing_key_format = routing_key_format
self.close_after_emit = close_after_emit
# Connection parameters.
# Allow extra params when connect to RabbitMQ.
# @see: http://pika.readthedocs.io/en/0.10.0/modules/parameters.html#pika.connection.ConnectionParameters
conn_params = connection_params if isinstance(connection_params, dict) else {}
self.connection_params = conn_params.copy()
self.connection_params.update(dict(host=host, port=port, heartbeat_interval=0))
if username and password:
self.connection_params['credentials'] = credentials.PlainCredentials(username, password)
# Extra params for message publication
self.message_headers = message_headers
# Save routing-key formatter.
self.routing_key_formatter = routing_key_formatter
# Logging.
self.formatter = formatter or JSONFormatter(
include=record_fields,
exclude=exclude_record_fields
)
self.fields = fields if isinstance(fields, dict) else {}
self.fields_under_root = fields_under_root
if len(self.fields) > 0:
self.addFilter(FieldFilter(self.fields, self.fields_under_root))
# Connect.
self.createLock()
def __init__(self,
conf,
url,
default_exchange=None,
allowed_remote_exmods=None):
self.conf = conf
self._force_select_poller_use = (
pika_drv_cmns.is_eventlet_monkey_patched('select'))
# processing rpc options
self.default_rpc_exchange = (
conf.oslo_messaging_pika.default_rpc_exchange)
self.rpc_reply_exchange = (conf.oslo_messaging_pika.rpc_reply_exchange)
self.allowed_remote_exmods = [pika_drv_cmns.EXCEPTIONS_MODULE]
if allowed_remote_exmods:
self.allowed_remote_exmods.extend(allowed_remote_exmods)
self.rpc_listener_prefetch_count = (
conf.oslo_messaging_pika.rpc_listener_prefetch_count)
self.default_rpc_retry_attempts = (
conf.oslo_messaging_pika.default_rpc_retry_attempts)
self.rpc_retry_delay = (conf.oslo_messaging_pika.rpc_retry_delay)
if self.rpc_retry_delay < 0:
raise ValueError("rpc_retry_delay should be non-negative integer")
self.rpc_reply_listener_prefetch_count = (
conf.oslo_messaging_pika.rpc_listener_prefetch_count)
self.rpc_reply_retry_attempts = (
conf.oslo_messaging_pika.rpc_reply_retry_attempts)
self.rpc_reply_retry_delay = (
conf.oslo_messaging_pika.rpc_reply_retry_delay)
if self.rpc_reply_retry_delay < 0:
raise ValueError("rpc_reply_retry_delay should be non-negative "
"integer")
self.rpc_queue_expiration = (
self.conf.oslo_messaging_pika.rpc_queue_expiration)
# processing notification options
self.default_notification_exchange = (
conf.oslo_messaging_pika.default_notification_exchange)
self.notification_persistence = (
conf.oslo_messaging_pika.notification_persistence)
self.notification_listener_prefetch_count = (
conf.oslo_messaging_pika.notification_listener_prefetch_count)
self.default_notification_retry_attempts = (
conf.oslo_messaging_pika.default_notification_retry_attempts)
if self.default_notification_retry_attempts is None:
raise ValueError("default_notification_retry_attempts should be "
"an integer")
self.notification_retry_delay = (
conf.oslo_messaging_pika.notification_retry_delay)
if (self.notification_retry_delay is None
or self.notification_retry_delay < 0):
raise ValueError("notification_retry_delay should be non-negative "
"integer")
self._tcp_user_timeout = self.conf.oslo_messaging_pika.tcp_user_timeout
self.host_connection_reconnect_delay = (
self.conf.oslo_messaging_pika.host_connection_reconnect_delay)
self._heartbeat_interval = (
self.conf.oslo_messaging_pika.heartbeat_interval)
# initializing connection parameters for configured RabbitMQ hosts
common_pika_params = {
'virtual_host': url.virtual_host,
'channel_max': self.conf.oslo_messaging_pika.channel_max,
'frame_max': self.conf.oslo_messaging_pika.frame_max,
'ssl': self.conf.oslo_messaging_pika.ssl,
'ssl_options': self.conf.oslo_messaging_pika.ssl_options,
'socket_timeout': self.conf.oslo_messaging_pika.socket_timeout,
}
self._connection_lock = threading.Lock()
self._connection_host_param_list = []
self._connection_host_status_list = []
if not url.hosts:
raise ValueError("You should provide at least one RabbitMQ host")
for transport_host in url.hosts:
pika_params = common_pika_params.copy()
pika_params.update(
host=transport_host.hostname,
port=transport_host.port,
credentials=pika_credentials.PlainCredentials(
transport_host.username, transport_host.password),
)
self._connection_host_param_list.append(pika_params)
self._connection_host_status_list.append({
self.HOST_CONNECTION_LAST_TRY_TIME:
0,
self.HOST_CONNECTION_LAST_SUCCESS_TRY_TIME:
0
})
self._next_connection_host_num = random.randint(
0,
len(self._connection_host_param_list) - 1)
# initializing 2 connection pools: 1st for connections without
# confirmations, 2nd - with confirmations
self.connection_without_confirmation_pool = pika_pool.QueuedPool(
create=self.create_connection,
max_size=self.conf.oslo_messaging_pika.pool_max_size,
max_overflow=self.conf.oslo_messaging_pika.pool_max_overflow,
timeout=self.conf.oslo_messaging_pika.pool_timeout,
recycle=self.conf.oslo_messaging_pika.pool_recycle,
stale=self.conf.oslo_messaging_pika.pool_stale,
)
self.connection_with_confirmation_pool = pika_pool.QueuedPool(
create=self.create_connection,
max_size=self.conf.oslo_messaging_pika.pool_max_size,
max_overflow=self.conf.oslo_messaging_pika.pool_max_overflow,
timeout=self.conf.oslo_messaging_pika.pool_timeout,
recycle=self.conf.oslo_messaging_pika.pool_recycle,
stale=self.conf.oslo_messaging_pika.pool_stale,
)
self.connection_with_confirmation_pool.Connection = (
_PooledConnectionWithConfirmations)
def test_erase_response_for_no_mechanism_match(self):
cred = credentials.PlainCredentials(*self.CREDENTIALS)
start = spec.Connection.Start()
start.mechanisms = 'FOO BAR BAZ'
self.assertEqual(cred.response_for(start), (None, None))
def test_erase_credentials_false(self):
cred = credentials.PlainCredentials(*self.CREDENTIALS)
cred.erase_credentials()
self.assertEqual((cred.username, cred.password), self.CREDENTIALS)
def test_erase_credentials_true(self):
cred = credentials.PlainCredentials(self.CREDENTIALS[0],
self.CREDENTIALS[1], True)
cred.erase_credentials()
self.assertEqual((cred.username, cred.password), (None, None))
def test_ne(self):
self.assertNotEqual(credentials.PlainCredentials('uu', 'p', False),
credentials.PlainCredentials('u', 'p', False))
self.assertNotEqual(credentials.PlainCredentials('u', 'p', False),
credentials.PlainCredentials('uu', 'p', False))
self.assertNotEqual(credentials.PlainCredentials('u', 'pp', False),
credentials.PlainCredentials('u', 'p', False))
self.assertNotEqual(credentials.PlainCredentials('u', 'p', False),
credentials.PlainCredentials('u', 'pp', False))
self.assertNotEqual(credentials.PlainCredentials('u', 'p', True),
credentials.PlainCredentials('u', 'p', False))
self.assertNotEqual(credentials.PlainCredentials('u', 'p', False),
credentials.PlainCredentials('u', 'p', True))
self.assertNotEqual(credentials.PlainCredentials('uu', 'p', False),
ChildPlainCredentials('u', 'p', False))
self.assertNotEqual(ChildPlainCredentials('u', 'pp', False),
credentials.PlainCredentials('u', 'p', False))
self.assertNotEqual(
credentials.PlainCredentials('u', 'p', False),
dict(username='******', password='******', erase_on_connect=False))
self.assertNotEqual(
dict(username='******', password='******', erase_on_connect=False),
credentials.PlainCredentials('u', 'p', False))
class Foreign(object):
def __ne__(self, other):
return 'foobar'
self.assertEqual(
credentials.PlainCredentials('u', 'p', False) != Foreign(),
'foobar')
self.assertEqual(
Foreign() != credentials.PlainCredentials('u', 'p', False),
'foobar')