def __init__(self,
conf,
url,
default_exchange=None,
allowed_remote_exmods=None):
deprecate(
"The pika driver is no longer maintained. It has been"
" deprecated",
message="It is recommended that all users of the pika driver"
" transition to using the rabbit driver.",
version="pike",
removal_version="rocky")
opt_group = cfg.OptGroup(name='oslo_messaging_pika',
title='Pika driver options')
conf.register_group(opt_group)
conf.register_opts(pika_drv_conn_factory.pika_opts, group=opt_group)
conf.register_opts(pika_pool_opts, group=opt_group)
conf.register_opts(message_opts, group=opt_group)
conf.register_opts(rpc_opts, group=opt_group)
conf.register_opts(notification_opts, group=opt_group)
conf = common.ConfigOptsProxy(conf, url, opt_group.name)
self._pika_engine = pika_drv_engine.PikaEngine(conf, url,
default_exchange,
allowed_remote_exmods)
self._reply_listener = pika_drv_lstnr.RpcReplyPikaListener(
self._pika_engine)
super(PikaDriver, self).__init__(conf, url, default_exchange,
allowed_remote_exmods)
def register_opts(conf, url):
opt_group = cfg.OptGroup(name='oslo_messaging_zmq',
title='ZeroMQ driver options')
conf.register_opts(zmq_opts, group=opt_group)
conf.register_opts(server._pool_opts)
conf.register_opts(base.base_opts)
return common.ConfigOptsProxy(conf, url, opt_group.name)
def test_rabbit(self):
group = 'oslo_messaging_rabbit'
self.config(rabbit_retry_interval=1,
rabbit_qos_prefetch_count=0,
rabbit_max_retries=3,
kombu_reconnect_delay=5.0,
group=group)
dummy_opts = [cfg.ListOpt('list_str', item_type=types.String(),
default=[]),
cfg.ListOpt('list_int', item_type=types.Integer(),
default=[]),
cfg.DictOpt('dict', default={}),
cfg.BoolOpt('bool', default=False),
cfg.StrOpt('str', default='default')]
self.conf.register_opts(dummy_opts, group=group)
url = transport.TransportURL.parse(
self.conf, "rabbit:///"
"?rabbit_qos_prefetch_count=2"
"&unknown_opt=4"
"&kombu_reconnect_delay=invalid_value"
"&list_str=1&list_str=2&list_str=3"
"&list_int=1&list_int=2&list_int=3"
"&dict=x:1&dict=y:2&dict=z:3"
"&bool=True"
)
conf = drv_cmn.ConfigOptsProxy(self.conf, url)
self.assertRaises(cfg.NoSuchOptError,
conf.__getattr__,
'unknown_group')
self.assertIsInstance(getattr(conf, group),
conf.GroupAttrProxy)
self.assertEqual(1, conf.oslo_messaging_rabbit.rabbit_retry_interval)
self.assertEqual(2,
conf.oslo_messaging_rabbit.rabbit_qos_prefetch_count)
self.assertEqual(3, conf.oslo_messaging_rabbit.rabbit_max_retries)
self.assertRaises(cfg.NoSuchOptError,
conf.oslo_messaging_rabbit.__getattr__,
'unknown_opt')
self.assertRaises(ValueError,
conf.oslo_messaging_rabbit.__getattr__,
'kombu_reconnect_delay')
self.assertEqual(['1', '2', '3'], conf.oslo_messaging_rabbit.list_str)
self.assertEqual([1, 2, 3], conf.oslo_messaging_rabbit.list_int)
self.assertEqual({'x': '1', 'y': '2', 'z': '3'},
conf.oslo_messaging_rabbit.dict)
self.assertEqual(True, conf.oslo_messaging_rabbit.bool)
self.assertEqual('default', conf.oslo_messaging_rabbit.str)
def __init__(self,
conf,
url,
default_exchange=None,
allowed_remote_exmods=[]):
if proton is None or controller is None:
raise NotImplementedError("Proton AMQP C libraries not installed")
super(ProtonDriver, self).__init__(conf, url, default_exchange,
allowed_remote_exmods)
opt_group = cfg.OptGroup(name='oslo_messaging_amqp',
title='AMQP 1.0 driver options')
conf.register_group(opt_group)
conf.register_opts(opts.amqp1_opts, group=opt_group)
conf = common.ConfigOptsProxy(conf, url, opt_group.name)
self._hosts = url.hosts
self._conf = conf
self._default_exchange = default_exchange
# lazy connection setup - don't create the controller until
# after the first messaging request:
self._ctrl = None
self._pid = None
self._lock = threading.Lock()
# timeout for message acknowledgement
opt_name = conf.oslo_messaging_amqp
self._default_reply_timeout = opt_name.default_reply_timeout
self._default_send_timeout = opt_name.default_send_timeout
self._default_notify_timeout = opt_name.default_notify_timeout
self._default_reply_retry = opt_name.default_reply_retry
# which message types should be sent pre-settled?
ps = [s.lower() for s in opt_name.pre_settled]
self._pre_settle_call = 'rpc-call' in ps
self._pre_settle_reply = 'rpc-reply' in ps
self._pre_settle_cast = 'rpc-cast' in ps
self._pre_settle_notify = 'notify' in ps
bad_opts = set(ps).difference(
['rpc-call', 'rpc-reply', 'rpc-cast', 'notify'])
if bad_opts:
LOG.warning(_LW("Ignoring unrecognized pre_settle value(s): %s"),
" ".join(bad_opts))
def __init__(self,
conf,
url,
default_exchange=None,
allowed_remote_exmods=None):
opt_group = cfg.OptGroup(name='oslo_messaging_pika',
title='Pika driver options')
conf.register_group(opt_group)
conf.register_opts(pika_drv_conn_factory.pika_opts, group=opt_group)
conf.register_opts(pika_pool_opts, group=opt_group)
conf.register_opts(message_opts, group=opt_group)
conf.register_opts(rpc_opts, group=opt_group)
conf.register_opts(notification_opts, group=opt_group)
conf = common.ConfigOptsProxy(conf, url, opt_group.name)
self._pika_engine = pika_drv_engine.PikaEngine(conf, url,
default_exchange,
allowed_remote_exmods)
self._reply_listener = pika_drv_lstnr.RpcReplyPikaListener(
self._pika_engine)
super(PikaDriver, self).__init__(conf, url, default_exchange,
allowed_remote_exmods)
def register_opts(conf, url):
opt_group = cfg.OptGroup(name='oslo_messaging_kafka',
title='Kafka driver options')
conf.register_group(opt_group)
conf.register_opts(KAFKA_OPTS, group=opt_group)
return common.ConfigOptsProxy(conf, url, opt_group.name)
def __init__(self, conf, url, default_exchange=None,
allowed_remote_exmods=None):
conf = drv_cmn.ConfigOptsProxy(conf, url)
self.conf = conf
self.url = url
self._connection_factory_type = (
self.conf.oslo_messaging_pika.connection_factory
)
self._connection_factory = None
self._connection_without_confirmation_pool = None
self._connection_with_confirmation_pool = None
self._pid = None
self._init_lock = threading.Lock()
self.host_connection_reconnect_delay = (
conf.oslo_messaging_pika.host_connection_reconnect_delay
)
# 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.default_content_type = (
'application/' + conf.oslo_messaging_pika.default_serializer_type
)