def get_rpc_server():
endpoints = [ResultEndpoint()]
transport = messaging.get_transport(CONF)
s_target = target.Target('murano', 'results', server=str(uuid.uuid4()))
access_policy = dispatcher.DefaultRPCAccessPolicy
server = messaging.get_rpc_server(transport,
s_target,
endpoints,
'threading',
access_policy=access_policy)
return server
def listen_for_notifications(self, targets_and_priorities, pool,
on_incoming_callback, batch_size,
batch_timeout):
LOG.debug("Listen for notifications %s", targets_and_priorities)
if pool:
raise NotImplementedError('"pool" not implemented by '
'this transport driver')
listener = ProtonListener(self)
for target, priority in targets_and_priorities:
topic = '%s.%s' % (target.topic, priority)
t = messaging_target.Target(topic=topic)
self._ctrl.add_task(drivertasks.ListenTask(t, listener, True))
return base.PollStyleListenerAdapter(listener, on_incoming_callback,
batch_size, batch_timeout)
def __init__(self, endpoints, serializer, access_policy=None):
"""Construct a rpc server dispatcher.
:param endpoints: list of endpoint objects for dispatching to
:param serializer: optional message serializer
"""
cfg.CONF.register_opts(_dispatcher_opts)
oslo_rpc_server_ping = None
for ep in endpoints:
# Check if we have an attribute named 'target'
target = getattr(ep, 'target', None)
if target and not isinstance(target, msg_target.Target):
errmsg = "'target' is a reserved Endpoint attribute used" + \
" for namespace and version filtering. It must" + \
" be of type oslo_messaging.Target. Do not" + \
" define an Endpoint method named 'target'"
raise TypeError("%s: endpoint=%s" % (errmsg, ep))
# Check if we have an attribute named 'oslo_rpc_server_ping'
oslo_rpc_server_ping = getattr(ep, 'oslo_rpc_server_ping', None)
if oslo_rpc_server_ping:
errmsg = "'oslo_rpc_server_ping' is a reserved Endpoint" + \
" attribute which can be use to ping the" + \
" endpoint. Please avoid using any oslo_* " + \
" naming."
LOG.warning("%s (endpoint=%s)" % (errmsg, ep))
self.endpoints = endpoints
# Add ping endpoint if enabled in config
if cfg.CONF.rpc_ping_enabled:
if oslo_rpc_server_ping:
LOG.warning("rpc_ping_enabled=True in config but "
"oslo_rpc_server_ping is already declared "
"in an other Endpoint. Not enabling rpc_ping "
"Endpoint.")
else:
self.endpoints.append(PingEndpoint())
self.serializer = serializer or msg_serializer.NoOpSerializer()
self._default_target = msg_target.Target()
if access_policy is not None:
if issubclass(access_policy, RPCAccessPolicyBase):
self.access_policy = access_policy()
else:
raise TypeError('access_policy must be a subclass of '
'RPCAccessPolicyBase')
else:
self.access_policy = DefaultRPCAccessPolicy()
def start(self):
endpoints = [
TaskProcessingEndpoint(),
StaticActionEndpoint(),
SchemaEndpoint()
]
transport = messaging.get_rpc_transport(CONF)
s_target = target.Target('murano', 'tasks', server=str(uuid.uuid4()))
access_policy = dispatcher.DefaultRPCAccessPolicy
self.server = messaging.get_rpc_server(
transport, s_target, endpoints, 'eventlet',
access_policy=access_policy)
self.server.start()
super(EngineService, self).start()
def start_listener(conf, exchange, topic, endpoints):
"""Starts up a notification listener."""
trans = transport.get_transport(conf)
targets = [target.Target(exchange=exchange, topic=topic)]
pool_name = get_pool_name(exchange)
notification_listener = listener.get_notification_listener(
trans,
targets,
endpoints,
executor='threading',
allow_requeue=False,
pool=pool_name)
notification_listener.start()
return notification_listener
def __init__(self, endpoints, serializer, access_policy=None):
"""Construct a rpc server dispatcher.
:param endpoints: list of endpoint objects for dispatching to
:param serializer: optional message serializer
"""
self.endpoints = endpoints
self.serializer = serializer or msg_serializer.NoOpSerializer()
self._default_target = msg_target.Target()
if access_policy is not None:
if issubclass(access_policy, RPCAccessPolicyBase):
self.access_policy = access_policy()
else:
raise TypeError('access_policy must be a subclass of '
'RPCAccessPolicyBase')
else:
# TODO(pvinci): Change to DefaultRPCAccessPolicy when setting to
# DefaultRCPAccessPolicy no longer breaks in tempest tests.
self.access_policy = LegacyRPCAccessPolicy()
def __init__(self, transport):
client_target = target.Target('murano', 'tasks')
self._client = rpc.RPCClient(transport, client_target, timeout=15)
def _prepare_rpc_service(server_id):
endpoints = [TaskProcessingEndpoint()]
transport = messaging.get_transport(CONF)
s_target = target.Target('murano', 'tasks', server=server_id)
return messaging.get_rpc_server(transport, s_target, endpoints, 'eventlet')
