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)