def test_get_transport_sad(self):
self.config(rpc_backend=self.rpc_backend, transport_url=self.transport_url)
if self.rpc_backend:
self.mox.StubOutWithMock(driver, "DriverManager")
invoke_args = [self.conf, messaging.TransportURL.parse(self.conf, self.url)]
invoke_kwds = dict(default_exchange="openstack", allowed_remote_exmods=[])
driver.DriverManager(
"oslo.messaging.drivers",
self.rpc_backend,
invoke_on_load=True,
invoke_args=invoke_args,
invoke_kwds=invoke_kwds,
).AndRaise(RuntimeError())
self.mox.ReplayAll()
try:
messaging.get_transport(self.conf, url=self.url)
self.assertFalse(True)
except Exception as ex:
ex_cls = self.ex.pop("cls")
ex_msg_contains = self.ex.pop("msg_contains")
self.assertIsInstance(ex, messaging.MessagingException)
self.assertIsInstance(ex, ex_cls)
self.assertIn(ex_msg_contains, six.text_type(ex))
for k, v in self.ex.items():
self.assertTrue(hasattr(ex, k))
self.assertEqual(v, str(getattr(ex, k)))
def test_get_transport_sad(self):
self.config(rpc_backend=self.rpc_backend,
transport_url=self.transport_url)
if self.rpc_backend:
self.mox.StubOutWithMock(driver, 'DriverManager')
invoke_args = [self.conf]
invoke_kwds = dict(default_exchange='openstack')
driver.DriverManager('oslo.messaging.drivers',
self.rpc_backend,
invoke_on_load=True,
invoke_args=invoke_args,
invoke_kwds=invoke_kwds).\
AndRaise(RuntimeError())
self.mox.ReplayAll()
try:
messaging.get_transport(self.conf, url=self.url)
self.assertFalse(True)
except Exception as ex:
ex_cls = self.ex.pop('cls')
ex_msg_contains = self.ex.pop('msg_contains')
self.assertTrue(isinstance(ex, messaging.MessagingException))
self.assertTrue(isinstance(ex, ex_cls))
self.assertTrue(hasattr(ex, 'msg'))
self.assertTrue(ex_msg_contains in ex.msg)
for k, v in self.ex.items():
self.assertTrue(hasattr(ex, k))
self.assertEqual(getattr(ex, k), v)
def test_multiple_servers(self):
url1 = "fake:///" + (self.exchange1 or "")
url2 = "fake:///" + (self.exchange2 or "")
transport1 = messaging.get_transport(self.conf, url=url1)
if url1 != url2:
transport2 = messaging.get_transport(self.conf, url=url1)
else:
transport2 = transport1
class TestEndpoint(object):
def __init__(self):
self.pings = []
def ping(self, ctxt, arg):
self.pings.append(arg)
def alive(self, ctxt):
return "alive"
if self.multi_endpoints:
endpoint1, endpoint2 = TestEndpoint(), TestEndpoint()
else:
endpoint1 = endpoint2 = TestEndpoint()
thread1 = self._setup_server(transport1, endpoint1, topic=self.topic1, server=self.server1)
thread2 = self._setup_server(transport2, endpoint2, topic=self.topic2, server=self.server2)
client1 = self._setup_client(transport1, topic=self.topic1)
client2 = self._setup_client(transport2, topic=self.topic2)
client1 = client1.prepare(server=self.server1)
client2 = client2.prepare(server=self.server2)
if self.fanout1:
client1.call({}, "alive")
client1 = client1.prepare(fanout=True)
if self.fanout2:
client2.call({}, "alive")
client2 = client2.prepare(fanout=True)
(client1.call if self.call1 else client1.cast)({}, "ping", arg="1")
(client2.call if self.call2 else client2.cast)({}, "ping", arg="2")
self.assertTrue(thread1.isAlive())
self._stop_server(client1.prepare(fanout=None), thread1, topic=self.topic1)
self.assertTrue(thread2.isAlive())
self._stop_server(client2.prepare(fanout=None), thread2, topic=self.topic2)
def check(pings, expect):
self.assertEqual(len(expect), len(pings))
for a in expect:
self.assertIn(a, pings)
if self.expect_either:
check(endpoint1.pings + endpoint2.pings, self.expect_either)
else:
check(endpoint1.pings, self.expect1)
check(endpoint2.pings, self.expect2)
def __init__(self, strategy=None):
_driver = None
_strategy = strategy
if CONF.notifier_strategy != 'default':
msg = _("notifier_strategy was deprecated in "
"favor of `notification_driver`")
LOG.warn(msg)
# NOTE(flaper87): Use this to keep backwards
# compatibility. We'll try to get an oslo.messaging
# driver from the specified strategy.
_strategy = strategy or CONF.notifier_strategy
_driver = _STRATEGY_ALIASES.get(_strategy)
publisher_id = CONF.default_publisher_id
try:
# NOTE(flaper87): Assume the user has configured
# the transport url.
self._transport = messaging.get_transport(CONF,
aliases=_ALIASES)
except messaging.DriverLoadFailure:
# NOTE(flaper87): Catch driver load failures and re-raise
# them *just* if the `transport_url` option was set. This
# step is intended to keep backwards compatibility and avoid
# weird behaviors (like exceptions on missing dependencies)
# when the old notifier options are used.
if CONF.transport_url is not None:
with excutils.save_and_reraise_exception():
LOG.exception(_('Error loading the notifier'))
# NOTE(flaper87): This needs to be checked
# here because the `get_transport` call
# registers `transport_url` into ConfigOpts.
if not CONF.transport_url:
# NOTE(flaper87): The next 3 lines help
# with the migration to oslo.messaging.
# Without them, gate tests won't know
# what driver should be loaded.
# Once this patch lands, devstack will be
# updated and then these lines will be removed.
url = None
if _strategy in ['rabbit', 'qpid']:
url = _strategy + '://'
self._transport = messaging.get_transport(CONF, url,
aliases=_ALIASES)
self._notifier = messaging.Notifier(self._transport,
driver=_driver,
publisher_id=publisher_id)
def test_set_default_control_exchange(self):
messaging.set_transport_defaults(control_exchange='foo')
self.mox.StubOutWithMock(driver, 'DriverManager')
invoke_kwds = mox.ContainsKeyValue('default_exchange', 'foo')
driver.DriverManager(mox.IgnoreArg(),
mox.IgnoreArg(),
invoke_on_load=mox.IgnoreArg(),
invoke_args=mox.IgnoreArg(),
invoke_kwds=invoke_kwds).\
AndReturn(_FakeManager(_FakeDriver(self.conf)))
self.mox.ReplayAll()
messaging.get_transport(self.conf)
def get_fake_transport():
# Get transport here to let oslo.messaging setup default config
# before changing the rpc_backend to the fake driver; otherwise,
# oslo.messaging will throw exception.
messaging.get_transport(cfg.CONF)
cfg.CONF.set_default('rpc_backend', 'fake')
url = transport.TransportURL.parse(cfg.CONF, None, None)
kwargs = dict(default_exchange=cfg.CONF.control_exchange,
allowed_remote_exmods=[])
mgr = driver.DriverManager('oslo.messaging.drivers',
url.transport,
invoke_on_load=True,
invoke_args=[cfg.CONF, url],
invoke_kwds=kwargs)
return transport.Transport(mgr.driver)
def __init__(self, target):
super(RPCServer, self).__init__()
self._server = messaging.get_rpc_server(
target=target,
transport=messaging.get_transport(cfg.CONF),
endpoints=[ContextEndpointHandler(self, target)],
)
def init(conf):
global TRANSPORT
exmods = get_allowed_exmods()
TRANSPORT = messaging.get_transport(conf,
url = CONF.hades_rabbit_url,
allowed_remote_exmods = exmods,
aliases = {})
def main(self):
# TODO: clean up and make more configurable!
logger = logging.getLogger('katello_notification')
logger.setLevel(self._get_loglevel())
handler = logging.FileHandler(LOG_LOCATION)
formatter = logging.Formatter('%(asctime)s - %(name)s - @%(filename)s %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
# quick config check
mgmt_server = self._katello_or_spacewalk()
if mgmt_server == 'katello':
payload_actions = KatelloPayloadActions()
elif mgmt_server == 'spacewalk':
payload_actions = SpacewalkPayloadActions()
else:
logger.error("mgmt server not set to 'katello' or 'spacewalk', aborting")
# set up transport and listener
transport = messaging.get_transport(cfg.CONF, url=self._get_amqp_url())
targets = [
messaging.Target(topic='subscription_notifications', exchange='nova'),
]
endpoints = [
NotificationEndpoint(payload_actions),
]
server = messaging.get_notification_listener(transport, targets, endpoints)
logger.info("listener initialized")
server.start()
server.wait()
def create_namespace_agent(self, context, port):
conf = self.conf
port_id = port["id"]
path = "rpc-proxy-%s" % port_id
unix_url = "punix:///%s" % path
unix_transport = messaging.get_transport(conf, unix_url)
unix_transport._driver.punix_listening.wait()
self._plug(port)
pm = external_process.ProcessManager(
conf, port_id, root_helper=self.root_helper, namespace=self._get_ns_name(port_id)
)
def cmd_callback(pid_file_name):
cmd = [
"tacker-servicevm-ns-rpc-proxy",
"--pid-file=%s" % pid_file_name,
"--svcvm-proxy-dir=%s" % conf.svcvm_proxy_dir,
"--src-transport-url",
"unix:///%s" % path,
]
cmd.extend(agent_config.get_log_args(conf, "tacker-servicevm-ns-rpc-proxy-%s.log" % port_id))
if _DEBUG:
cmd += ["--log-file=/tmp/tacker-servicevm-ns-rpc-proxy-" "%s.log" % port_id]
return cmd
pm.enable(cmd_callback)
ns_agent = NamespaceAgent(port_id, unix_transport, pm)
self._proxy_agents[port_id] = ns_agent
def test_get_transport(self):
self.config(rpc_backend=self.rpc_backend,
control_exchange=self.control_exchange,
transport_url=self.transport_url)
self.mox.StubOutWithMock(driver, 'DriverManager')
invoke_args = [self.conf]
invoke_kwds = dict(default_exchange=self.expect['exchange'])
if self.expect['url']:
invoke_kwds['url'] = self.expect['url']
drvr = _FakeDriver(self.conf)
driver.DriverManager('oslo.messaging.drivers',
self.expect['backend'],
invoke_on_load=True,
invoke_args=invoke_args,
invoke_kwds=invoke_kwds).\
AndReturn(_FakeManager(drvr))
self.mox.ReplayAll()
transport = messaging.get_transport(self.conf, url=self.url)
self.assertTrue(transport is not None)
self.assertTrue(transport.conf is self.conf)
self.assertTrue(transport._driver is drvr)
def test_reply_wire_format(self):
if hasattr(self, "skip_msg"):
self.skipTest(self.skip_msg)
transport = messaging.get_transport(self.conf, "kombu+memory:////")
self.addCleanup(transport.cleanup)
driver = transport._driver
target = messaging.Target(topic=self.topic, server=self.server, fanout=self.fanout)
listener = driver.listen(target)
connection, producer = _create_producer(target)
self.addCleanup(connection.release)
msg = {"oslo.version": "2.0", "oslo.message": {}}
msg["oslo.message"].update(self.msg)
msg["oslo.message"].update(self.ctxt)
msg["oslo.message"].update(
{"_msg_id": uuid.uuid4().hex, "_unique_id": uuid.uuid4().hex, "_reply_q": "reply_" + uuid.uuid4().hex}
)
msg["oslo.message"] = jsonutils.dumps(msg["oslo.message"])
producer.publish(msg)
received = listener.poll()
self.assertIsNotNone(received)
self.assertEqual(self.expected_ctxt, received.ctxt)
self.assertEqual(self.expected, received.message)
def test_two_endpoints(self):
transport = messaging.get_transport(self.conf, url='fake:')
endpoint1 = mock.Mock()
endpoint1.info.return_value = None
endpoint2 = mock.Mock()
endpoint2.info.return_value = messaging.NotificationResult.HANDLED
listener_thread = self._setup_listener(transport,
[endpoint1, endpoint2])
notifier = self._setup_notifier(transport)
notifier.info({}, 'an_event.start', 'test')
self.wait_for_messages(1)
self.assertFalse(listener_thread.stop())
endpoint1.info.assert_called_once_with({}, 'testpublisher',
'an_event.start', 'test', {
'timestamp': mock.ANY,
'message_id': mock.ANY
})
endpoint2.info.assert_called_once_with({}, 'testpublisher',
'an_event.start', 'test', {
'timestamp': mock.ANY,
'message_id': mock.ANY
})
def test_client_call_timeout(self):
transport = messaging.get_transport(self.conf, url='fake:')
finished = False
wait = threading.Condition()
class TestEndpoint(object):
def ping(self, ctxt, arg):
with wait:
if not finished:
wait.wait()
server_thread = self._setup_server(transport, TestEndpoint())
client = self._setup_client(transport)
try:
client.prepare(timeout=0).call({}, 'ping', arg='foo')
except Exception as ex:
self.assertIsInstance(ex, messaging.MessagingTimeout, ex)
else:
self.assertTrue(False)
with wait:
finished = True
wait.notify()
self._stop_server(client, server_thread)
def test_two_topics(self):
transport = messaging.get_transport(self.conf, url='fake:')
endpoint = mock.Mock()
endpoint.info.return_value = None
targets = [
messaging.Target(topic="topic1"),
messaging.Target(topic="topic2")
]
listener_thread = self._setup_listener(transport, [endpoint],
targets=targets)
notifier = self._setup_notifier(transport, topic='topic1')
notifier.info({'ctxt': '1'}, 'an_event.start1', 'test')
notifier = self._setup_notifier(transport, topic='topic2')
notifier.info({'ctxt': '2'}, 'an_event.start2', 'test')
self.wait_for_messages(2)
self.assertFalse(listener_thread.stop())
endpoint.info.assert_has_calls([
mock.call({'ctxt': '1'}, 'testpublisher', 'an_event.start1',
'test', {
'timestamp': mock.ANY,
'message_id': mock.ANY
}),
mock.call({'ctxt': '2'}, 'testpublisher', 'an_event.start2',
'test', {
'timestamp': mock.ANY,
'message_id': mock.ANY
})
],
any_order=True)
def __init__(self, strategy=None):
if CONF.notifier_strategy != 'default':
msg = _("notifier_strategy was deprecated in "
"favor of `notification_driver`")
warnings.warn(msg, DeprecationWarning)
# NOTE(flaper87): Use this to keep backwards
# compatibility. We'll try to get an oslo.messaging
# driver from the specified strategy.
_strategy = strategy or CONF.notifier_strategy
_driver = _STRATEGY_ALIASES.get(_strategy)
# NOTE(flaper87): The next 3 lines help
# with the migration to oslo.messaging.
# Without them, gate tests won't know
# what driver should be loaded.
# Once this patch lands, devstack will be
# updated and then these lines will be removed.
url = None
if _strategy in ['rabbit', 'qpid']:
url = _strategy + '://'
publisher_id = CONF.default_publisher_id
self._transport = messaging.get_transport(CONF, url)
self._notifier = messaging.Notifier(self._transport,
driver=_driver,
publisher_id=publisher_id)
def __init__(self, topic, endpoints):
self.hostname = socket.gethostname()
self.topic = topic
self.transport = messaging.get_transport(cfg.CONF)
self.target = messaging.Target(topic=self.topic, server=self.hostname, version=self.version)
self.endpoints = endpoints
self.server = messaging.get_rpc_server(self.transport, self.target, self.endpoints)
def test_get_transport(self):
self.config(rpc_backend=self.rpc_backend,
control_exchange=self.control_exchange,
transport_url=self.transport_url)
self.mox.StubOutWithMock(driver, 'DriverManager')
invoke_args = [self.conf,
messaging.TransportURL.parse(self.conf,
self.expect['url'])]
invoke_kwds = dict(default_exchange=self.expect['exchange'],
allowed_remote_exmods=self.expect['allowed'])
drvr = _FakeDriver(self.conf)
driver.DriverManager('oslo.messaging.drivers',
self.expect['backend'],
invoke_on_load=True,
invoke_args=invoke_args,
invoke_kwds=invoke_kwds).\
AndReturn(_FakeManager(drvr))
self.mox.ReplayAll()
kwargs = dict(url=self.url)
if self.allowed is not None:
kwargs['allowed_remote_exmods'] = self.allowed
if self.aliases is not None:
kwargs['aliases'] = self.aliases
transport_ = messaging.get_transport(self.conf, **kwargs)
self.assertIsNotNone(transport_)
self.assertIs(transport_.conf, self.conf)
self.assertIs(transport_._driver, drvr)
def get_transport():
global _TRANSPORT
if not _TRANSPORT:
_TRANSPORT = messaging.get_transport(cfg.CONF)
return _TRANSPORT
def __init__(self, parsed_url):
options = urlparse.parse_qs(parsed_url.query)
# the values of the option is a list of url params values
# only take care of the latest one if the option
# is provided more than once
self.per_meter_topic = bool(int(
options.get('per_meter_topic', [0])[-1]))
self.target = options.get('target', ['record_metering_data'])[0]
self.policy = options.get('policy', ['default'])[-1]
self.max_queue_length = int(options.get(
'max_queue_length', [1024])[-1])
self.local_queue = []
if self.policy in ['queue', 'drop']:
LOG.info(_('Publishing policy set to %s, '
'override backend retry config to 1') % self.policy)
override_backend_retry_config(1)
elif self.policy == 'default':
LOG.info(_('Publishing policy set to %s') % self.policy)
else:
LOG.warn(_('Publishing policy is unknown (%s) force to default')
% self.policy)
self.policy = 'default'
transport = messaging.get_transport()
self.rpc_client = messaging.get_rpc_client(transport, version='1.0')
def test_transport_url(self, fake_ensure_connection, fake_reset):
transport = messaging.get_transport(self.conf, self.url)
self.addCleanup(transport.cleanup)
driver = transport._driver
urls = driver._get_connection()._url.split(";")
self.assertEqual(sorted(self.expected), sorted(urls))
def main():
try:
config.parse_args()
logging.setup('Mistral')
# Map cli options to appropriate functions. The cli options are
# registered in mistral's config.py.
launch_options = {
'all': launch_all,
'api': launch_api,
'engine': launch_engine,
'executor': launch_executor
}
# Please refer to the oslo.messaging documentation for transport
# configuration. The default transport for oslo.messaging is rabbitMQ.
# The available transport drivers are listed under oslo.messaging at
# ./oslo/messaging/rpc/_drivers. The drivers are prefixed with "impl".
# The transport driver is specified using the rpc_backend option in the
# default section of the oslo configuration file. The expected value
# for rpc_backend is the last part of the driver name. For example,
# the driver for rabbit is impl_rabbit and for the fake driver is
# impl_fake. The rpc_backend value for these are "rabbit" and "fake"
# respectively. There are additional options such as ssl and credential
# that can be specified depending on the driver. Please refer to the
# driver implementation for those additional options.
transport = messaging.get_transport(cfg.CONF)
# Launch server(s).
launch_options[cfg.CONF.server](transport)
except RuntimeError, e:
sys.stderr.write("ERROR: %s\n" % e)
sys.exit(1)
def test_two_pools(self):
transport = messaging.get_transport(self.conf, url='fake:')
endpoint1 = mock.Mock()
endpoint1.info.return_value = None
endpoint2 = mock.Mock()
endpoint2.info.return_value = None
targets = [messaging.Target(topic="topic")]
listener1_thread = self._setup_listener(transport, [endpoint1], 2,
targets=targets, pool="pool1")
listener2_thread = self._setup_listener(transport, [endpoint2], 2,
targets=targets, pool="pool2")
notifier = self._setup_notifier(transport, topic="topic")
notifier.info({'ctxt': '0'}, 'an_event.start', 'test message0')
notifier.info({'ctxt': '1'}, 'an_event.start', 'test message1')
self.assertFalse(listener2_thread.wait_end())
self.assertFalse(listener1_thread.wait_end())
def mocked_endpoint_call(i):
return mock.call({'ctxt': '%d' % i}, 'testpublisher',
'an_event.start', 'test message%d' % i,
{'timestamp': mock.ANY, 'message_id': mock.ANY})
endpoint1.info.assert_has_calls([mocked_endpoint_call(0),
mocked_endpoint_call(1)])
endpoint2.info.assert_has_calls([mocked_endpoint_call(0),
mocked_endpoint_call(1)])
def init(conf):
global TRANSPORT, NOTIFIER
exmods = get_allowed_exmods()
TRANSPORT = messaging.get_transport(conf, allowed_remote_exmods=exmods, aliases=TRANSPORT_ALIASES)
serializer = RequestContextSerializer(JsonPayloadSerializer())
NOTIFIER = messaging.Notifier(TRANSPORT, serializer=serializer)
def main():
try:
config.parse_args()
logging.setup('Mistral')
# TODO(rakhmerov): This is a temporary hack.
# We have to initialize engine in executor process because
# executor now calls engine.convey_task_result() directly.
engine.load_engine()
# Please refer to the oslo.messaging documentation for transport
# configuration. The default transport for oslo.messaging is rabbitMQ.
# The available transport drivers are listed under oslo.messaging at
# ./oslo/messaging/rpc/_drivers. The drivers are prefixed with "impl".
# The transport driver is specified using the rpc_backend option in the
# default section of the oslo configuration file. The expected value
# for rpc_backend is the last part of the driver name. For example,
# the driver for rabbit is impl_rabbit and for the fake driver is
# impl_fake. The rpc_backend value for these are "rabbit" and "fake"
# respectively. There are additional options such as ssl and credential
# that can be specified depending on the driver. Please refer to the
# driver implementation for those additional options.
transport = messaging.get_transport(cfg.CONF)
target = messaging.Target(topic=cfg.CONF.executor.topic,
server=cfg.CONF.executor.host)
endpoints = [server.Executor()]
ex_server = messaging.get_rpc_server(transport, target, endpoints)
ex_server.start()
ex_server.wait()
except RuntimeError, e:
sys.stderr.write("ERROR: %s\n" % e)
sys.exit(1)
def create_rpc_namespace_proxy(self, context, src_target,
dst_transport_url, dst_target, direction):
LOG.debug('create_rpc_namespace_proxy %s %s %s %s %s',
context, src_target, dst_transport_url, dst_target,
direction)
dst_transport = self._proxies.get_transport(dst_transport_url)
if dst_transport is None:
dst_transport = messaging.get_transport(self.conf,
dst_transport_url)
self._proxies.add_transport(dst_transport_url, dst_transport)
if direction == 'send':
proxy_server = self._create_rpc_namespace_proxy(
self.src_transport, src_target, dst_transport, dst_target)
elif direction == 'receive':
proxy_server = self._create_rpc_namespace_proxy(
dst_transport, dst_target, self.src_transport, src_target)
else:
msg = _('unknown direction %s') % direction
LOG.error(msg)
raise RuntimeError(msg)
# proxy_server.start()
eventlet.spawn(proxy_server.start)
namespace_proxy_id = str(uuid.uuid4())
self._proxies.add_proxy(namespace_proxy_id,
dst_transport, proxy_server)
LOG.debug('namespace_proxy_id %s', namespace_proxy_id)
return namespace_proxy_id
def get_transport(self):
# get transport manually, oslo.messaging get_transport is broken
from stevedore import driver
from oslo.messaging import transport
messaging.get_transport(cfg.CONF)
cfg.CONF.set_default('verbose', True)
cfg.CONF.set_default('rpc_backend', 'fake')
url = transport.TransportURL.parse(cfg.CONF, None, None)
kwargs = dict(default_exchange=cfg.CONF.control_exchange,
allowed_remote_exmods=[])
mgr = driver.DriverManager('oslo.messaging.drivers',
url.transport,
invoke_on_load=True,
invoke_args=[cfg.CONF, url],
invoke_kwds=kwargs)
return transport.Transport(mgr.driver)
def __init__(self, target, url):
self._transport = messaging.get_transport(cfg.CONF, url)
self._target = messaging.Target(topic=target,
server='server1',
version='1.0')
self.timeout = 2
self.retry = True
def test_two_topics(self):
transport = messaging.get_transport(self.conf, url='fake:')
endpoint = mock.Mock()
endpoint.info.return_value = None
targets = [messaging.Target(topic="topic1"),
messaging.Target(topic="topic2")]
listener_thread = self._setup_listener(transport, [endpoint],
targets=targets)
notifier = self._setup_notifier(transport, topic='topic1')
notifier.info({'ctxt': '1'}, 'an_event.start1', 'test')
notifier = self._setup_notifier(transport, topic='topic2')
notifier.info({'ctxt': '2'}, 'an_event.start2', 'test')
self.wait_for_messages(2)
self.assertFalse(listener_thread.stop())
endpoint.info.assert_has_calls([
mock.call({'ctxt': '1'}, 'testpublisher',
'an_event.start1', 'test',
{'timestamp': mock.ANY, 'message_id': mock.ANY}),
mock.call({'ctxt': '2'}, 'testpublisher',
'an_event.start2', 'test',
{'timestamp': mock.ANY, 'message_id': mock.ANY})],
any_order=True)
def init(conf):
global TRANSPORT, NOTIFIER
exmods = get_allowed_exmods()
TRANSPORT = messaging.get_transport(conf,
allowed_remote_exmods=exmods,
aliases=TRANSPORT_ALIASES)
NOTIFIER = messaging.Notifier(TRANSPORT)
def start(self):
"""Bind the UDP socket and handle incoming data."""
# ensure dispatcher is configured before starting other services
self.dispatcher_manager = dispatcher.load_dispatcher_manager()
self.rpc_server = None
self.notification_server = None
super(CollectorService, self).start()
if cfg.CONF.collector.udp_address:
self.tg.add_thread(self.start_udp)
allow_requeue = cfg.CONF.collector.requeue_sample_on_dispatcher_error
transport = messaging.get_transport(optional=True)
if transport:
self.rpc_server = messaging.get_rpc_server(
transport, cfg.CONF.publisher_rpc.metering_topic, self)
target = oslo.messaging.Target(
topic=cfg.CONF.publisher_notifier.metering_topic)
self.notification_server = messaging.get_notification_listener(
transport, [target], [self],
allow_requeue=allow_requeue)
self.rpc_server.start()
self.notification_server.start()
if not cfg.CONF.collector.udp_address:
# Add a dummy thread to have wait() working
self.tg.add_timer(604800, lambda: None)
def test_client_call_timeout(self):
transport = messaging.get_transport(self.conf, url='fake:')
finished = False
wait = threading.Condition()
class TestEndpoint(object):
def ping(self, ctxt, arg):
with wait:
if not finished:
wait.wait()
server_thread = self._setup_server(transport, TestEndpoint())
client = self._setup_client(transport)
try:
client.prepare(timeout=0).call({}, 'ping', arg='foo')
except Exception as ex:
self.assertIsInstance(ex, messaging.MessagingTimeout, ex)
else:
self.assertTrue(False)
with wait:
finished = True
wait.notify()
self._stop_server(client, server_thread)
def __init__(self):
driver = None
transport_url = None
publisher_id = CONF.default_publisher_id
if CONF.notifier_strategy:
msg = _("notifier_strategy was deprecated in "
"favor of `notification_driver`")
LOG.warn(msg)
strategy = CONF.notifier_strategy
# NOTE(flaper87): Use this to keep backwards
# compatibility. We'll try to get an oslo.messaging
# driver from the specified strategy.
driver = _STRATEGY_ALIASES.get(strategy)
if driver == 'messaging':
transport_url = strategy + ':///'
self._transport = messaging.get_transport(CONF,
url=transport_url,
aliases=_ALIASES)
self._notifier = messaging.Notifier(self._transport,
driver=driver,
publisher_id=publisher_id)
def __init__(self, parsed_url):
super(RPCPublisher, self).__init__(parsed_url)
options = urlparse.parse_qs(parsed_url.query)
self.target = options.get('target', ['record_metering_data'])[0]
self.rpc_client = messaging.get_rpc_client(messaging.get_transport(),
version='1.0')
def _prepare_notification_service(server_id):
endpoints = [report_notification, track_instance, untrack_instance]
transport = messaging.get_transport(config.CONF)
s_target = target.Target(topic='murano', server=server_id)
dispatcher = oslo_dispatcher.NotificationDispatcher([s_target], endpoints,
None, True)
return messaging.MessageHandlingServer(transport, dispatcher, 'eventlet')
def __init__(self, parsed_url):
super(NotifierPublisher, self).__init__(parsed_url)
self.notifier = oslo.messaging.Notifier(
messaging.get_transport(),
driver=cfg.CONF.publisher_notifier.metering_driver,
publisher_id='metering.publisher.%s' % cfg.CONF.host,
topic=cfg.CONF.publisher_notifier.metering_topic
)
def start(self):
super(NotificationService, self).start()
self.pipeline_manager = pipeline.setup_pipeline()
if cfg.CONF.notification.store_events:
self.event_pipeline_manager = pipeline.setup_event_pipeline()
transport = messaging.get_transport()
self.partition_coordinator = coordination.PartitionCoordinator()
self.partition_coordinator.start()
event_transporter = None
if cfg.CONF.notification.workload_partitioning:
transporter = []
for pipe in self.pipeline_manager.pipelines:
transporter.append(self._get_notifier(transport, pipe))
if cfg.CONF.notification.store_events:
event_transporter = []
for pipe in self.event_pipeline_manager.pipelines:
event_transporter.append(
self._get_notifier(transport, pipe))
self.ctxt = context.get_admin_context()
self.group_id = self.NOTIFICATION_NAMESPACE
else:
# FIXME(sileht): endpoint use notification_topics option
# and it should not because this is oslo.messaging option
# not a ceilometer, until we have a something to get
# the notification_topics in an other way
# we must create a transport to ensure the option have
# beeen registered by oslo.messaging
messaging.get_notifier(transport, '')
transporter = self.pipeline_manager
if cfg.CONF.notification.store_events:
event_transporter = self.event_pipeline_manager
self.group_id = None
self.listeners, self.pipeline_listeners = [], []
self._configure_main_queue_listeners(transporter, event_transporter)
if cfg.CONF.notification.workload_partitioning:
self.partition_coordinator.join_group(self.group_id)
self._configure_pipeline_listeners()
self.partition_coordinator.watch_group(self.group_id,
self._refresh_agent)
self.tg.add_timer(cfg.CONF.coordination.heartbeat,
self.partition_coordinator.heartbeat)
self.tg.add_timer(cfg.CONF.coordination.check_watchers,
self.partition_coordinator.run_watchers)
if not cfg.CONF.notification.disable_non_metric_meters:
LOG.warning(
_LW('Non-metric meters may be collected. It is highly '
'advisable to disable these meters using '
'ceilometer.conf or the pipeline.yaml'))
# Add a dummy thread to have wait() working
self.tg.add_timer(604800, lambda: None)
def main(argv=None):
_usage = """Usage: %prog [options] <name>"""
parser = optparse.OptionParser(usage=_usage)
parser.add_option("--url", action="store", default=None)
parser.add_option("--id", action="store", default=None)
parser.add_option("--controller", action="store_true")
parser.add_option("--calls", action="store", type=int, default=0)
parser.add_option("--workers", action="store", type=int, default=None)
parser.add_option("--timeout", action="store", type=int, default=2)
parser.add_option("--config",
action="callback",
callback=handle_config_option,
nargs=2,
type="string")
opts, extra = parser.parse_args(args=argv)
logging.basicConfig(level=logging.INFO) #make this an option
if opts.url:
cfg.CONF.transport_url = opts.url
transport = messaging.get_transport(cfg.CONF)
server_name = opts.id or "%s_%s" % (socket.gethostname(), os.getpid())
server = Server(transport, server_name, opts.controller, opts.workers)
def signal_handler(s, f):
server.stop()
signal.signal(signal.SIGINT, signal_handler)
server.start()
if opts.controller:
time.sleep(0.5) # give server time to initialise
target = messaging.Target(exchange="test-exchange",
topic="test-topic",
fanout=True)
stub = messaging.RPCClient(transport, target, timeout=2)
stub.cast({},
'start',
controller=server_name,
count=opts.calls,
timeout=opts.timeout)
elif opts.calls:
target = messaging.Target(exchange="test-exchange", topic="test-topic")
stub = messaging.RPCClient(transport, target, timeout=2)
client = Client(stub)
stats = client.run("abcdefghijklmnopqrstuvwxyz",
count=opts.calls,
verbose=True)
print stats
server.stop()
server.wait()
if opts.controller:
server.collector.report()
return 0
def get_rpc_client(hosts=[], password='******'):
conf = cfg.CONF
conf.transport_url = 'rabbit://'
conf.rabbit_max_retries = 1
conf.rabbit_hosts = hosts
conf.rabbit_password = password
conf.control_exchange = 'numeter'
transport = messaging.get_transport(conf)
return BaseAPIClient(transport)
def __init__(self, parsed_url, topic):
super(NotifierPublisher, self).__init__(parsed_url)
self.notifier = oslo.messaging.Notifier(
messaging.get_transport(),
driver=cfg.CONF.publisher_notifier.telemetry_driver,
publisher_id='telemetry.publisher.%s' % cfg.CONF.host,
topic=topic,
retry=self.retry
)
def __init__(self, app, **conf):
self.notifier = notify.Notifier(
messaging.get_transport(cfg.CONF, conf.get('url')),
publisher_id=conf.get('publisher_id',
os.path.basename(sys.argv[0])))
self.service_name = conf.get('service_name')
self.ignore_req_list = [x.upper().strip() for x in
conf.get('ignore_req_list', '').split(',')]
super(RequestNotifier, self).__init__(app)
def test_transport_url(self, *args):
transport = messaging.get_transport(self.conf, self.url)
self.addCleanup(transport.cleanup)
driver = transport._driver
brokers_params = driver._get_connection().brokers_params
self.assertEqual(
sorted(self.expected, key=operator.itemgetter('host')),
sorted(brokers_params, key=operator.itemgetter('host')))
def _notify_task_executors(cls, tasks):
# TODO(m4dcoder): Use a pool for transport and client
if not cls.transport:
cls.transport = messaging.get_transport(cfg.CONF)
ex_client = client.ExecutorClient(cls.transport)
for task in tasks:
# TODO(m4dcoder): Fill request context argument with auth info
context = {}
ex_client.handle_task(context, task=task)
LOG.info("Submitted task for execution: '%s'" % task)
def __init__(self, topic, server, handlers):
serializer = RequestContextSerializer(JsonPayloadSerializer())
transport = messaging.get_transport(cfg.CONF,
aliases=TRANSPORT_ALIASES)
# TODO(asalkeld) add support for version='x.y'
target = messaging.Target(topic=topic, server=server)
self._server = messaging.get_rpc_server(transport,
target,
handlers,
serializer=serializer)
def test_driver_load(self):
self.config(heartbeat_timeout_threshold=0,
group='oslo_messaging_rabbit')
transport = messaging.get_transport(self.conf)
self.addCleanup(transport.cleanup)
driver = transport._driver
url = driver._get_connection()._url
self.assertIsInstance(driver, rabbit_driver.RabbitDriver)
self.assertEqual('memory:////', url)
def test_unknown_executor(self):
transport = messaging.get_transport(self.conf, url='fake:')
try:
messaging.get_rpc_server(transport, None, [], executor='foo')
except Exception as ex:
self.assertIsInstance(ex, messaging.ExecutorLoadFailure)
self.assertEqual('foo', ex.executor)
else:
self.assertTrue(False)
def init(conf):
global TRANSPORT, NOTIFIER
exmods = get_allowed_exmods()
TRANSPORT = messaging.get_transport(conf,
allowed_remote_exmods=exmods,
aliases=TRANSPORT_ALIASES)
#serializer = RequestContextSerializer(JsonPayloadSerializer())
# https://review.openstack.org/#/c/71532/1/nova/rpc.py
NOTIFIER = messaging.Notifier(TRANSPORT, serializer=None)
def __init__(self, strategy=None):
_driver = None
_strategy = strategy
if CONF.notifier_strategy != 'default':
msg = _("notifier_strategy was deprecated in "
"favor of `notification_driver`")
warnings.warn(msg, DeprecationWarning)
# NOTE(flaper87): Use this to keep backwards
# compatibility. We'll try to get an oslo.messaging
# driver from the specified strategy.
_strategy = strategy or CONF.notifier_strategy
_driver = _STRATEGY_ALIASES.get(_strategy)
publisher_id = CONF.default_publisher_id
# NOTE(flaper87): Assume the user has configured
# the transport url.
self._transport = messaging.get_transport(CONF,
aliases=_ALIASES)
# NOTE(flaper87): This needs to be checked
# here because the `get_transport` call
# registers `transport_url` into ConfigOpts.
if not CONF.transport_url:
# NOTE(flaper87): The next 3 lines help
# with the migration to oslo.messaging.
# Without them, gate tests won't know
# what driver should be loaded.
# Once this patch lands, devstack will be
# updated and then these lines will be removed.
url = None
if _strategy in ['rabbit', 'qpid']:
url = _strategy + '://'
self._transport = messaging.get_transport(CONF, url,
aliases=_ALIASES)
self._notifier = messaging.Notifier(self._transport,
driver=_driver,
publisher_id=publisher_id)
def test_no_server_topic(self):
transport = messaging.get_transport(self.conf, url='fake:')
target = messaging.Target(server='testserver')
server = messaging.get_rpc_server(transport, target, [])
try:
server.start()
except Exception as ex:
self.assertIsInstance(ex, messaging.InvalidTarget, ex)
self.assertEqual('testserver', ex.target.server)
else:
self.assertTrue(False)
def init(conf):
"""
初始化过程，实现三方面内容的初始化：
1.确定xdrs异常类的基类的处理文件xdrs.exception；
2.确定了使用rabbit这个AMQP的driver方式:
3.加载notifier各种驱动实现方式：
[oslo.messaging.notify.drivers]
log = oslo.messaging.notify._impl_log:LogDriver
messagingv2 = oslo.messaging.notify._impl_messaging:MessagingV2Driver
noop = oslo.messaging.notify._impl_noop:NoOpDriver
routing = oslo.messaging.notify._impl_routing:RoutingDriver
test = oslo.messaging.notify._impl_test:TestDriver
messaging = oslo.messaging.notify._impl_messaging:MessagingDriver
"""
global TRANSPORT, NOTIFIER
exmods = get_allowed_exmods()
"""
exmods = ['xdrs.exception']
这个方法实现了确定xdrs异常类的基类的处理文件；
"""
TRANSPORT = messaging.get_transport(conf,
allowed_remote_exmods=exmods,
aliases=TRANSPORT_ALIASES)
"""
======================================================================================
conf = <oslo.config.cfg.ConfigOpts object at 0x1ebf490>
allowed_remote_exmods = ['xdrs.exception']
aliases = {
'nova.openstack.common.rpc.impl_kombu': 'rabbit'
'nova.rpc.impl_kombu': 'rabbit',
}
TRANSPORT = <oslo.messaging.transport.Transport object at 0x30b5150>
======================================================================================
======================================================================================
返回值复制给TRANSPORT，实际上这里实现的就是确定了使用rabbit这个driver:
mgr = <stevedore.driver.DriverManager object at 0x2d5a090>
mgr.driver = <oslo.messaging._drivers.impl_rabbit.RabbitDriver object at 0x2dd90d0>
Transport(mgr.driver) = <oslo.messaging.transport.Transport object at 0x311f210>
TRANSPORT._driver = <oslo.messaging._drivers.impl_rabbit.RabbitDriver object at 0x3a000d0>
======================================================================================
"""
serializer = RequestContextSerializer(JsonPayloadSerializer())
"""
这里实现的是加载notifier各种驱动实现方式；
[oslo.messaging.notify.drivers]
log = oslo.messaging.notify._impl_log:LogDriver
messagingv2 = oslo.messaging.notify._impl_messaging:MessagingV2Driver
noop = oslo.messaging.notify._impl_noop:NoOpDriver
routing = oslo.messaging.notify._impl_routing:RoutingDriver
test = oslo.messaging.notify._impl_test:TestDriver
messaging = oslo.messaging.notify._impl_messaging:MessagingDriver
"""
NOTIFIER = messaging.Notifier(TRANSPORT, serializer=serializer)
def test_driver_load(self, fake_ensure, fake_reset):
self.config(heartbeat_timeout_threshold=0,
group='oslo_messaging_rabbit')
self.messaging_conf.transport_driver = self.transport_driver
transport = messaging.get_transport(self.conf)
self.addCleanup(transport.cleanup)
driver = transport._driver
url = driver._get_connection()._url
self.assertIsInstance(driver, rabbit_driver.RabbitDriver)
self.assertEqual(self.url, url)
