def test_unknown_executor(self):
transport = oslo_messaging.get_transport(self.conf, url='fake:')
try:
oslo_messaging.get_rpc_server(transport, None, [], executor='foo')
except Exception as ex:
self.assertIsInstance(ex, oslo_messaging.ExecutorLoadFailure)
self.assertEqual('foo', ex.executor)
else:
self.assertTrue(False)
def test_warning_when_notifier_transport(self, log):
transport = oslo_messaging.get_notification_transport(self.conf)
target = oslo_messaging.Target(topic='foo', server='bar')
endpoints = [object()]
serializer = object()
oslo_messaging.get_rpc_server(transport, target,
endpoints, serializer=serializer)
log.warning.assert_called_once_with(
"Using notification transport for RPC. Please use "
"get_rpc_transport to obtain an RPC transport "
"instance.")
def __init__(self, messaging_config, node_id, node_rpc_endpoints,
partition_id=None):
self.messaging_config = messaging_config
self.node_id = node_id
self.node_rpc_endpoints = node_rpc_endpoints
# unique identifier shared by all nodes that can communicate
self.partition_id = partition_id
self.node_rpc_endpoints.append(DseNodeEndpoints(self))
self._running = False
self._services = []
self.instance = uuid.uuid4()
self.context = self._message_context()
self.transport = messaging.get_transport(
self.messaging_config,
allowed_remote_exmods=[exception.__name__, ])
self._rpctarget = self.node_rpc_target(self.node_id, self.node_id)
self._rpcserver = messaging.get_rpc_server(
self.transport, self._rpctarget, self.node_rpc_endpoints,
executor='eventlet')
self._service_rpc_servers = {} # {service_id => (rpcserver, target)}
# # keep track of what publisher/tables local services subscribe to
# subscribers indexed by publisher and table:
# {publisher_id ->
# {table_name -> set_of_subscriber_ids}}
self.subscriptions = {}
# Note(ekcs): A little strange that _control_bus starts before self?
self._control_bus = DseNodeControlBus(self)
self.register_service(self._control_bus)
# load configured drivers
self.loaded_drivers = self.load_drivers()
self.start()
def __init__(self, messaging_config, node_id, node_rpc_endpoints,
partition_id=None):
self.messaging_config = messaging_config
self.node_id = node_id
self.node_rpc_endpoints = node_rpc_endpoints
# unique identifier shared by all nodes that can communicate
self.partition_id = partition_id
self.node_rpc_endpoints.append(DseNodeEndpoints(self))
self._running = False
self._services = []
self.instance = uuid.uuid4()
self.context = self._message_context()
self.transport = messaging.get_transport(
self.messaging_config,
allowed_remote_exmods=[exception.__name__, ])
self._rpctarget = self.node_rpc_target(self.node_id, self.node_id)
self._rpcserver = messaging.get_rpc_server(
self.transport, self._rpctarget, self.node_rpc_endpoints,
executor='eventlet')
self._service_rpc_servers = {} # {service_id => (rpcserver, target)}
self._control_bus = DseNodeControlBus(self)
self.register_service(self._control_bus)
# keep track of which local services subscribed to which other services
self.subscribers = {}
# load configured drivers
self.loaded_drivers = self.load_drivers()
self.start()
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 start(self):
LOG.info("Start VitrageApiHandlerService")
super(VitrageApiHandlerService, self).start()
transport = oslo_messaging.get_transport(cfg.CONF)
# TODO(Dany) add real server
target = oslo_messaging.Target(topic='rpcapiv1', server='localhost')
# TODO(Dany) add rabbit configuratipn
# target = om.Target(topic='testme', server='192.168.56.102')
# target = oslo_messaging.Target(
# topic='testme', server='135.248.18.223')
# cfg.CONF.set_override('rabbit_host', '135.248.18.223')
# cfg.CONF.set_override('rabbit_port', 5672)
# cfg.CONF.set_override('rabbit_userid', 'guest')
# cfg.CONF.set_override('rabbit_password', 'cloud')
# cfg.CONF.set_override('rabbit_login_method', 'AMQPLAIN')
# cfg.CONF.set_override('rabbit_virtual_host', '/')
cfg.CONF.set_override('rpc_backend', 'rabbit')
endpoints = [EntityGraphApis(self.entity_graph), ]
# TODO(Dany) use eventlet instead of threading
server = oslo_messaging.get_rpc_server(transport, target,
endpoints, executor='threading')
server.start()
LOG.info("Finish start VitrageApiHandlerService")
def get_rpc_server(transport, topic, endpoint):
"""Return a configured oslo_messaging rpc server."""
cfg.CONF.import_opt('host', 'ceilometer.service')
target = oslo_messaging.Target(server=cfg.CONF.host, topic=topic)
return oslo_messaging.get_rpc_server(transport, target,
[endpoint], executor='threading',
serializer=_SERIALIZER)
def launch_engine(transport):
target = messaging.Target(
topic=cfg.CONF.engine.topic,
server=cfg.CONF.engine.host
)
engine_v2 = def_eng.DefaultEngine(rpc.get_engine_client())
endpoints = [rpc.EngineServer(engine_v2)]
# Setup scheduler in engine.
db_api.setup_db()
scheduler.setup()
# Setup expiration policy
expiration_policy.setup()
server = messaging.get_rpc_server(
transport,
target,
endpoints,
executor='eventlet',
serializer=ctx.RpcContextSerializer(ctx.JsonPayloadSerializer())
)
engine_v2.register_membership()
server.start()
server.wait()
def get_server(target, endpoints, transport, serializer=None):
assert transport is not None
return messaging.get_rpc_server(transport,
target,
endpoints,
executor='eventlet',
serializer=serializer)
def main(argv=None):
opts = setup_options(argv)
core.setup_logging(level=logging.WARN if opts.quiet else logging.DEBUG)
transport_url = core.rabbit_connection_url(driver='rabbit')
transport = oslo_messaging.get_transport(cfg.CONF, transport_url)
target = oslo_messaging.Target(topic=opts.topic, server=opts.server_name)
control = ServerControlEndpoint(None)
control.response_delay = opts.response_delay
control.num_messages = opts.num_messages
endpoints = [
control,
]
server = oslo_messaging.get_rpc_server(transport, target, endpoints,
executor='eventlet')
control.server = server
control.num_messages = opts.num_messages
t_start = time.time()
try:
server.start()
server.wait()
t_end = time.time()
except KeyboardInterrupt:
t_end = time.time()
server.stop()
print('*** Stats ***')
msgs_per_sec = float(control._counter) / float(t_end - t_start)
print('msgs/sec:\t%.2f' % (msgs_per_sec, ))
print('msgs:\t%d' % control._counter)
print('secs:\t%d' % (t_end - t_start, ))
LOG.info("Exciting...")
def launch_collector(transport):
target = messaging.Target(
topic=cfg.CONF.collector.topic,
server=cfg.CONF.collector.host
)
launch_collector = collector.Collector()
endpoints = [rpc.GlobalManagerServer(launch_collector)]
tg = threadgroup.ThreadGroup()
tg.add_dynamic_timer(
launch_collector.run_periodic_tasks,
initial_delay=None,
periodic_interval_max=None,
context=None
)
server = messaging.get_rpc_server(
transport,
target,
endpoints,
executor='eventlet'
)
server.start()
server.wait()
def launch_executor(transport):
target = messaging.Target(
topic=cfg.CONF.executor.topic,
server=cfg.CONF.executor.host
)
executor_v2 = def_executor.DefaultExecutor(rpc.get_engine_client())
endpoints = [rpc.ExecutorServer(executor_v2)]
server = messaging.get_rpc_server(
transport,
target,
endpoints,
executor='eventlet',
serializer=ctx.RpcContextSerializer(ctx.JsonPayloadSerializer())
)
executor_v2.register_membership()
try:
server.start()
while True:
time.sleep(604800)
except (KeyboardInterrupt, SystemExit):
pass
finally:
print("Stopping executor service...")
server.stop()
server.wait()
def __init__(self, topic, host, handler):
serializer = messaging.RequestContextSerializer(
messaging.JsonPayloadSerializer())
transport = messaging.get_transport(cfg.CONF)
target = messaging.Target(topic=topic, server=host)
self.rpc_server = messaging.get_rpc_server(transport, target, handler,
serializer=serializer)
def test_constructor_without_explicit_RPCAccessPolicy(self, warn):
transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:')
target = oslo_messaging.Target(topic='foo', server='bar')
endpoints = [object()]
serializer = object()
warnings.simplefilter("always", FutureWarning)
oslo_messaging.get_rpc_server(transport, target,
endpoints, serializer=serializer)
self.assertEqual([
mock.call("blocking executor is deprecated. Executor default will "
"be removed. Use explicitly threading or eventlet "
"instead in version 'pike' and will be removed in "
"version 'rocky'",
category=FutureWarning, stacklevel=3)
], warn.mock_calls)
def start(self):
super(OctaviaConsumer, self).start()
LOG.info(_LI("Starting octavia consumer..."))
self.server = messaging.get_rpc_server(self.transport, self.target,
self.endpoints,
executor='eventlet')
self.server.start()
def test_constructor(self, warn):
transport = oslo_messaging.get_rpc_transport(self.conf, url='fake:')
target = oslo_messaging.Target(topic='foo', server='bar')
endpoints = [object()]
serializer = object()
access_policy = dispatcher.DefaultRPCAccessPolicy
warnings.simplefilter("always", FutureWarning)
server = oslo_messaging.get_rpc_server(transport,
target,
endpoints,
serializer=serializer,
access_policy=access_policy)
self.assertIs(server.conf, self.conf)
self.assertIs(server.transport, transport)
self.assertIsInstance(server.dispatcher, oslo_messaging.RPCDispatcher)
self.assertIs(server.dispatcher.endpoints, endpoints)
self.assertIs(server.dispatcher.serializer, serializer)
self.assertEqual('blocking', server.executor_type)
self.assertEqual([
mock.call("blocking executor is deprecated. Executor default will "
"be removed. Use explicitly threading or eventlet "
"instead in version 'pike' and will be removed in "
"version 'rocky'",
category=FutureWarning, stacklevel=3)
], warn.mock_calls)
def test_server_wait_method(self):
transport = oslo_messaging.get_transport(self.conf, url='fake:')
target = oslo_messaging.Target(topic='foo', server='bar')
endpoints = [object()]
serializer = object()
class MagicMockIgnoreArgs(mock.MagicMock):
"""MagicMock ignores arguments.
A MagicMock which can never misinterpret the arguments passed to
it during construction.
"""
def __init__(self, *args, **kwargs):
super(MagicMockIgnoreArgs, self).__init__()
server = oslo_messaging.get_rpc_server(transport, target, endpoints,
serializer=serializer)
# Mocking executor
server._executor_cls = MagicMockIgnoreArgs
server._create_listener = MagicMockIgnoreArgs()
server.dispatcher = MagicMockIgnoreArgs()
# Here assigning executor's listener object to listener variable
# before calling wait method, because in wait method we are
# setting executor to None.
server.start()
listener = server.listener
server.stop()
# call server wait method
server.wait()
self.assertEqual(1, listener.cleanup.call_count)
def get_server(target, endpoints, serializer=None):
assert TRANSPORT is not None
serializer = RequestContextSerializer(serializer)
access_policy = dispatcher.DefaultRPCAccessPolicy
return oslo_messaging.get_rpc_server(TRANSPORT, target, endpoints,
'eventlet', serializer,
access_policy=access_policy)
def get_rpc_server(conf, transport, topic, endpoint):
"""Return a configured oslo_messaging rpc server."""
target = oslo_messaging.Target(server=conf.host, topic=topic)
serializer = oslo_serializer.RequestContextSerializer(
oslo_serializer.JsonPayloadSerializer())
return oslo_messaging.get_rpc_server(transport, target,
[endpoint], executor='eventlet',
serializer=serializer)
def get_server(target, endpoints, serializer=None):
assert TRANSPORT is not None
serializer = PluginRpcSerializer(serializer)
return oslo_messaging.get_rpc_server(TRANSPORT,
target,
endpoints,
executor='eventlet',
serializer=serializer)
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 setUp(self):
super(RpcServerFixture, self).setUp()
endpoints = [self.endpoint, self]
self.server = oslo_messaging.get_rpc_server(self.transport,
self.target,
endpoints)
self._ctrl = oslo_messaging.RPCClient(self.transport, self.ctrl_target)
self._start()
def _wrap_get_server(self, target, endpoints, serializer=None):
"""Mirror rpc.get_server() but with our special sauce."""
serializer = CheatingSerializer(serializer)
return messaging.get_rpc_server(rpc.TRANSPORT,
target,
endpoints,
executor='eventlet',
serializer=serializer)
def getRPCServer(self, target, endpoints, serializer=None):
assert self.TRANSPORT is not None
return oslo_msg.get_rpc_server(self.TRANSPORT,
target,
endpoints,
executor="eventlet",
serializer=serializer)
def get_rpc_server(target, endpoint):
"""Return a configured oslo_messaging rpc server."""
serializer = RequestContextSerializer(JsonPayloadSerializer())
access_policy = dispatcher.DefaultRPCAccessPolicy
return oslo_messaging.get_rpc_server(TRANSPORT, target, [endpoint],
executor='eventlet',
serializer=serializer,
access_policy=access_policy)
def get_server(target, endpoints, serializer=None):
assert TRANSPORT is not None
serializer = RequestContextSerializer(serializer)
return messaging.get_rpc_server(TRANSPORT,
target,
endpoints,
executor='eventlet',
serializer=serializer)
def __init__(self, target):
global TRANSPORT
self.__server = messaging.get_rpc_server(
target=target,
transport=TRANSPORT,
endpoints=[self],
executor='eventlet')
def get_rpc_server(transport, topic, endpoint):
"""Return a configured oslo_messaging rpc server."""
cfg.CONF.import_opt('host', 'ceilometer.service')
target = oslo_messaging.Target(server=cfg.CONF.host, topic=topic)
serializer = RequestContextSerializer(JsonPayloadSerializer())
return oslo_messaging.get_rpc_server(transport, target,
[endpoint], executor='eventlet',
serializer=serializer)
def get_server(target, endpoints, serializer=None):
access_policy = dispatcher.DefaultRPCAccessPolicy
return messaging.get_rpc_server(TRANSPORT,
target,
endpoints,
executor='eventlet',
serializer=serializer,
access_policy=access_policy)
def __init__(self, transport, topic, server, endpoint, serializer):
self.controller = ServerSetupMixin.ServerController()
target = oslo_messaging.Target(topic=topic, server=server)
self.server = oslo_messaging.get_rpc_server(transport,
target,
[endpoint,
self.controller],
serializer=serializer)
def register_service(self, service):
assert service.node is None
if self.service_object(service.service_id):
msg = ('Service %s already exsists on the node %s' %
(service.service_id, self.node_id))
raise exception.DataServiceError(msg)
access_policy = dispatcher.DefaultRPCAccessPolicy
service.node = self
self._services.append(service)
service._target = self.service_rpc_target(service.service_id,
server=self.node_id)
service._rpc_server = messaging.get_rpc_server(
self.transport,
service._target,
service.rpc_endpoints(),
executor='eventlet',
access_policy=access_policy)
if self._running:
service.start()
LOG.debug('<%s> Service %s RPC Server listening on %s', self.node_id,
service.service_id, service._target)
def launch_executor_server(transport, executor):
target = messaging.Target(
topic=cfg.CONF.executor.topic,
server=cfg.CONF.executor.host
)
server = messaging.get_rpc_server(
transport,
target,
[rpc.ExecutorServer(executor)],
executor='blocking',
serializer=ctx.RpcContextSerializer(ctx.JsonPayloadSerializer())
)
try:
server.start()
while True:
eventlet.sleep(604800)
except (KeyboardInterrupt, SystemExit):
LOG.info("Stopping executor service...")
finally:
server.stop()
server.wait()
def start(self):
"""Start a service."""
LOG.debug("Creating RPC server for service %s", self.topic)
#ctxt = context.get_admin_context()
endpoints = [self.manager]
#endpoints.extend(self.manager.additional_endpoints)
#obj_version_cap = objects.Service.get_minimum_obj_version(ctxt)
#LOG.debug("Pinning object versions for RPC server serializer to %s",
# obj_version_cap)
#serializer = objects_base.CinderObjectSerializer(obj_version_cap)
#url="rabbit://*****:*****@127.0.0.1:5672"
url = "rabbit://*****:*****@192.168.100.13:5672/"
transport = messaging.get_transport(conf, url)
target = messaging.Target(topic=self.topic, server=self.host)
serializer = RequestSerializer()
pdb.set_trace()
self.rpcserver = messaging.get_rpc_server(transport,
target,
endpoints,
executor='eventlet')
self.rpcserver.start()
LOG.debug("OSP RPC server running")
def test_server_invalid_stop_from_other_thread(self, mock_wait):
transport = oslo_messaging.get_transport(self.conf, url='fake:')
target = oslo_messaging.Target(topic='foo', server='bar')
endpoints = [object()]
serializer = object()
server = oslo_messaging.get_rpc_server(transport,
target,
endpoints,
serializer=serializer,
executor='eventlet')
t = test_utils.ServerThreadHelper(server)
t.start()
self.addCleanup(t.join)
self.addCleanup(t.stop)
with mock.patch('logging.Logger.warn') as warn:
server.stop()
warn.assert_called_with('start/stop/wait must be called '
'in the same thread')
with mock.patch('logging.Logger.warn') as warn:
server.wait()
warn.assert_called_with('start/stop/wait must be called '
'in the same thread')
def run(self):
qinling_endpoint = keystone_utils.get_qinling_endpoint()
orchestrator = orchestra_base.load_orchestrator(CONF, qinling_endpoint)
db_api.setup_db()
topic = CONF.engine.topic
server = CONF.engine.host
transport = messaging.get_rpc_transport(CONF)
target = messaging.Target(topic=topic, server=server, fanout=False)
endpoint = engine.DefaultEngine(orchestrator, qinling_endpoint)
access_policy = dispatcher.DefaultRPCAccessPolicy
self.server = messaging.get_rpc_server(
transport,
target, [endpoint],
executor='threading',
access_policy=access_policy,
serializer=rpc.ContextSerializer(
messaging.serializer.JsonPayloadSerializer()))
LOG.info('Starting function mapping periodic task...')
periodics.start_function_mapping_handler(endpoint)
LOG.info('Starting engine...')
self.server.start()
def __init__(self):
super(HyperSwitchAgent, self).__init__()
self.device_id = cfg.CONF.host
# the queue client for plug/unplug calls from nova driver
transport = oslo_messaging.get_transport(cfg.CONF)
endpoints = [self]
target = oslo_messaging.Target(topic=hs_constants.HYPERSWITCH_UPDATE,
version='1.0',
exchange=hs_constants.HYPERSWITCH,
server=cfg.CONF.host)
self.server = oslo_messaging.get_rpc_server(transport, target,
endpoints)
# the call back to nova driver init
self.call_back = HyperSwitchAgentCallback()
# instance according to configuration
self.vif_driver = vif_hyperswitch_driver.HyperSwitchVIFDriver(
device_id=self.device_id, call_back=self.call_back)
self.vif_driver.startup_init()
self.server.start()
from oslo_config import cfg
import oslo_messaging as msg
class TestEndpoint(object):
target = msg.Target(namespace='control', version='2.0')
def test(self, ctx, arg):
print('I am testing endpoint of server')
print(arg)
# Authentication
cfg.CONF(['--config-file', 'msg.conf'])
transport = msg.get_transport(cfg.CONF)
target = msg.Target(topic='kiennn', server='127.0.0.1')
endpoints = [
TestEndpoint(),
]
server = msg.get_rpc_server(transport, target, endpoints)
server.start()
server.wait()
def get_server(target, endpoints, serializer=None):
return messaging.get_rpc_server(TRANSPORT,
target,
endpoints,
executor='eventlet',
serializer=serializer)
def build_server(self, target):
return om.get_rpc_server(self.__transport,
target,
self.__endpoints,
executor='eventlet',
serializer=self.__serializer)
def stop(self, ctx):
if self.server:
self.server.stop()
class TestEndpoint(object):
def test(self, ctx, arg):
print "test"
print arg
return arg
transport = oslo_messaging.get_transport(cfg.CONF)
target = oslo_messaging.Target(topic='test123', server='server1')
endpoints = [
ServerControlEndpoint(None),
TestEndpoint(),
]
server = oslo_messaging.get_rpc_server(transport,
target,
endpoints,
executor='blocking')
try:
server.start()
while True:
time.sleep(1)
except KeyboardInterrupt:
print("Stopping server")
server.stop()
server.wait()
sleep(20)
print("I am testing endpoint 1 of server")
print(arg)
class TestEndpoint2(object):
def test2(self, cxtx, arg):
sleep(20)
print("I am testing endpoint 2 of server")
print(arg)
# Create Messaging Transport
transport = messaging.get_transport(cfg.CONF)
# Create Target
target = messaging.Target(topic='test', server='server1')
# Create Endpoint
endpoints = [
ServerCotrolEndpoint(None),
TestEndpoint(),
TestEndpoint2()
]
# Create RPC Server
server = messaging.get_rpc_server(transport, target, endpoints)
# Start RPX Server
server.start()
server.wait()
##Create EndPoint
class TestEndpoint(object):
def test_method1(self, ctx, arg):
res = "Result from test_method1 " + str(arg)
print res
return res
def test_method2(self, ctx, arg):
res = "Result from test_method2 " + str(arg)
print res
return res
##Create EndPoint List
endpoints = [
TestEndpoint(),
]
##Create RPC Server
access_policy = om.rpc.dispatcher.DefaultRPCAccessPolicy
server = om.get_rpc_server(transport,
target,
endpoints,
executor='eventlet',
access_policy=access_policy)
#server = om.get_rpc_server(transport, target, endpoints, executor='blocking', access_policy=access_policy)
##Start RPC Server
server.start()
server.wait()
def get_rpc_server(target, endpoint):
"""Return a configured oslo_messaging rpc server."""
serializer = RequestContextSerializer(JsonPayloadSerializer())
return oslo_messaging.get_rpc_server(TRANSPORT, target, [endpoint],
executor='eventlet',
serializer=serializer)
def __init__(self, target):
self.__server = messaging.get_rpc_server(
target=target,
transport=messaging.get_transport(cfg.CONF),
endpoints=[self],
executor='eventlet')
def get_server(target, endpoints):
assert TRANSPORT is not None
return messaging.get_rpc_server(TRANSPORT,
target,
endpoints,
executor='eventlet')
from oslo_log import helpers as log_helpers
from oslo_config import cfg
import oslo_messaging
import eventlet
eventlet.monkey_patch()
LOG = logging.getLogger(__name__)
symlog.basicConfig(level=symlog.INFO)
class RpcCallHandler(object):
def func1(self, ctxt, **kwargs):
LOG.info("called RpcCallHandler.func1 - %s", kwargs)
return True
transport_url = 'rabbit://*****:*****@sidewinder.rmq.cloudamqp.com:5672/gjxdknsw'
transport = oslo_messaging.get_transport(cfg.CONF, transport_url)
target = oslo_messaging.Target(exchange="basic", topic='basic_agent',
server=socket.gethostname())
endpoints = [RpcCallHandler()]
server = oslo_messaging.get_rpc_server(
transport, target, endpoints, executor='eventlet')
LOG.info('server starts')
server.start()
LOG.info('server consuming...')
server.wait()
def get_server(target, endpoints, serializer=None):
serializer = RequestContextSerializer(serializer)
return messaging.get_rpc_server(_get_transport(), target, endpoints,
executor='eventlet',
serializer=serializer)
from oslo_config import cfg
import oslo_messaging as om
CONF = cfg.CONF
CONF(default_config_files=['test.conf'])
transport = om.get_transport(cfg.CONF)
target = om.Target(topic='testme', server='10.145.72.51')
class TestEndpoint(object):
def test_method1(self, ctx, arg):
res = "Result from test_method1 " + str(arg)
print res
return res
def test_method2(self, ctx, arg):
res = "Result from test_method2 " + str(arg)
print res
return res
endpoints = [TestEndpoint()]
server = om.get_rpc_server(transport, target, endpoints, executor='blocking')
server.start()
def main(argv=None):
_usage = """Usage: %prog [options] <server name>"""
parser = optparse.OptionParser(usage=_usage)
parser.add_option("--topic",
action="store",
default="my-topic",
help="target topic, default 'my-topic'")
parser.add_option("--exchange",
action="store",
default="my-exchange",
help="target exchange, default 'my-exchange'")
parser.add_option("--namespace",
action="store",
default="my-namespace",
help="target namespace, default 'my-namespace'")
parser.add_option("--version",
action="store",
default="1.1",
help="target version, default '1.1'")
parser.add_option("--url",
action="store",
default="rabbit://localhost",
help="transport address, default 'rabbit://localhost'")
parser.add_option("--executor",
action="store",
default="blocking",
help="defaults to 'blocking'")
parser.add_option("--oslo-config",
type="string",
help="the oslo.messaging configuration file.")
opts, extra = parser.parse_args(args=argv)
if not extra:
print("<server-name> not supplied!")
return False
server_name = extra[0]
rpc_log_init()
LOG.info("Running server, name=%s exchange=%s topic=%s namespace=%s" %
(server_name, opts.exchange, opts.topic, opts.namespace))
if opts.oslo_config:
LOG.info("Loading config file %s" % opts.oslo_config)
cfg.CONF(["--config-file", opts.oslo_config])
transport = messaging.get_transport(cfg.CONF, url=opts.url)
target = messaging.Target(exchange=opts.exchange,
topic=opts.topic,
namespace=opts.namespace,
server=server_name,
version=opts.version)
server = messaging.get_rpc_server(transport,
target,
[TestEndpoint(server_name, target)],
executor=opts.executor)
try:
server.start()
while True:
time.sleep(1)
except KeyboardInterrupt:
LOG.info("Stopping..")
server.stop()
return True
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')
def main(argv=None):
logging.warning("my-server.py has been superseded by rpc-server")
global quiet
_usage = """Usage: %prog [options] <name>"""
parser = optparse.OptionParser(usage=_usage)
parser.add_option("--exchange", action="store", default="my-exchange")
parser.add_option("--topic", action="store", default="my-topic")
#parser.add_option("--server", action="store", default="my-server-name")
parser.add_option("--namespace", action="store", default="my-namespace")
parser.add_option("--version", action="store", default="1.1")
parser.add_option("--eventlet", action="store_true")
parser.add_option("--url", action="store", default="qpid://localhost")
parser.add_option("--topology",
action="store",
type="int",
default=2,
help="QPID Topology version to use.")
parser.add_option("--auto-delete",
action="store_true",
help="Set amqp_auto_delete to True")
parser.add_option("--durable",
action="store_true",
help="Set amqp_durable_queues to True")
parser.add_option("--config",
action="callback",
callback=handle_config_option,
nargs=2,
type="string",
help="set a config variable (--config name value)")
parser.add_option("--oslo-config",
type="string",
help="the oslo.messaging configuration file.")
parser.add_option("--quiet",
action="store_true",
help="Supress console output")
parser.add_option("--debug",
action="store_true",
help="Enable debug logging.")
opts, extra = parser.parse_args(args=argv)
if not extra:
print("<name> not supplied!")
return -1
quiet = opts.quiet
server_name = extra[0]
if not quiet:
print("Running server, name=%s exchange=%s topic=%s namespace=%s" %
(server_name, opts.exchange, opts.topic, opts.namespace))
if opts.debug:
logging.basicConfig(level=logging.DEBUG)
else:
logging.basicConfig(level=logging.INFO)
if opts.oslo_config:
if not opts.quiet: print("Loading config file %s" % opts.oslo_config)
cfg.CONF(["--config-file", opts.oslo_config])
transport = messaging.get_transport(cfg.CONF, url=opts.url)
if opts.topology:
if not quiet: print("Using QPID topology version %d" % opts.topology)
cfg.CONF.qpid_topology_version = opts.topology
if opts.auto_delete:
if not quiet: print("Enable auto-delete")
cfg.CONF.amqp_auto_delete = True
if opts.durable:
if not quiet: print("Enable durable queues")
cfg.CONF.amqp_durable_queues = True
target = messaging.Target(exchange=opts.exchange,
topic=opts.topic,
namespace=opts.namespace,
server=server_name,
version=opts.version)
endpoints = [
TestEndpoint01(server_name, target),
TestEndpoint02(server_name, target),
]
server = messaging.get_rpc_server(
transport,
target,
endpoints,
executor='eventlet' if opts.eventlet else 'blocking')
try:
server.start()
while True:
time.sleep(1)
if not quiet:
sys.stdout.write('.')
sys.stdout.flush()
except KeyboardInterrupt:
if not quiet: print("Stopping..")
server.stop()
server.wait()
return 0
self.speaker.evpn_prefix_del(route_type=EVPN_MAC_IP_ADV_ROUTE,
route_dist=network.route_dist,
esi=0,
ethernet_tag_id=0,
mac_addr=mac,
ip_addr=client.ip)
client = network.clients.pop(mac)
return {vni: client.to_jsondict()}
##Create EndPoint List
endpoints = [
RestVtep(),
]
##Create RPC Server
server = om.get_rpc_server(transport, target, endpoints, executor='eventlet')
##Start RPC Server
try:
server.start()
while True:
time.sleep(1)
except KeyboardInterrupt:
print("Stopping server")
server.stop()
server.wait()
def get_rpc_server(conf, transport, topic, endpoint):
"""Return a configured oslo_messaging rpc server."""
target = oslo_messaging.Target(server=conf.host, topic=topic)
return oslo_messaging.get_rpc_server(transport, target,
[endpoint], executor='threading',
serializer=_SERIALIZER)
def get_server(target, endpoints, serializer=None):
assert TRANSPORT is not None
serializer = RequestContextSerializer(serializer)
return oslo_messaging.get_rpc_server(TRANSPORT, target, endpoints,
'eventlet', serializer)
def get_rpc_server(target, endpoint):
access_policy = dispatcher.DefaultRPCAccessPolicy
return oslo_messaging.get_rpc_server(TRANSPORT,
target, [endpoint],
executor='eventlet',
access_policy=access_policy)
def get_server(target, endpoints):
return oslo_messaging.get_rpc_server(
transport=get_transport(),
target=target,
endpoints=endpoints,
)
def create_consumer(self, topic, endpoints):
target = oslo_messaging.Target(
topic=topic, server=aim_cfg.CONF.aim.aim_service_identifier)
server = oslo_messaging.get_rpc_server(self.transport, target,
endpoints)
self.servers.append(server)
def __init__(self, transport, topic, server, endpoint, serializer):
target = oslo_messaging.Target(topic=topic, server=server)
self._server = oslo_messaging.get_rpc_server(transport,
target,
[endpoint, self],
serializer=serializer)
def get_server(target, endpoints, serializer=None):
assert TRANSPORT is not None
serializer = RequestContextSerializer(serializer)
LOG.info("%s,%s,%s,%s,%s", TRANSPORT, "111", target, "222", endpoints)
return oslo_messaging.get_rpc_server(TRANSPORT, target, endpoints,
'eventlet', serializer)
