def __init__(self, rest_url=None): self.dispatcher = RESTDispatcher(rest_url) # TinyRPC WSGI App self.transport = WsgiServerTransport(queue_class=gevent.queue.Queue) self.wsgi_app = self.transport.handle # TinyRPC RPC Server self.rpc_server = RPCServerGreenlets(self.transport, JSONRPCProtocol(), self.dispatcher) gevent.spawn(self.rpc_server.serve_forever)
def __init__(self, app): log.debug('initializing JSONRPCServer') BaseService.__init__(self, app) self.app = app self.dispatcher = RPCDispatcher() transport = WsgiServerTransport(queue_class=gevent.queue.Queue) # start wsgi server as a background-greenlet self.wsgi_server = gevent.wsgi.WSGIServer(('127.0.0.1', 5000), transport.handle) self.rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), self.dispatcher)
def wsgi_server(request): app = WsgiServerTransport(queue_class=gevent.queue.Queue) server = WSGIServer(TEST_SERVER_ADDR, app.handle) def fin(): server.stop() server_greenlet.join() request.addfinalizer(fin) server_greenlet = gevent.spawn(server.serve_forever) gevent.sleep(0) # wait for server to come up return (app, 'http://%s:%d' % TEST_SERVER_ADDR)
def nsRPCBringupServer(ns, path, host, port, maxconn): name = os.path.basename(path) dev_path = '/dev/rpc/{}'.format(name) if nsRPCisServer(ns, path) is not True: nsError(ns, "RPC service {} misconfigured".format(name)) return False nsInfo(ns, "Configuring RPC server from {}".format(path)) nsMkdir(ns, dev_path) nsMkdir(ns, "{}/root".format(dev_path)) _to_root = nsGet(ns, "{}/jail".format(path), []) for j in _to_root: _n = os.path.basename(j) _dst = "{}/root/{}".format(dev_path, _n) nsInfo(ns, "RPC.JAIL({}): {}".format(name, j)) nsLn(ns, j, _dst) dispatcher = RPCDispatcher() nsSet(ns, "{}/dispatcher".format(dev_path), dispatcher) for h in nsLs(ns, "{}/handlers".format(path)): nsInfo(ns, "Registering {}->{} ".format(name, h)) _fun = nsGet(ns, "{}/handlers/{}".format(path, h)) dispatcher.add_method(partial(_fun, dev_path), h) transport = WsgiServerTransport(queue_class=gevent.queue.Queue) nsSet(ns, "{}/transport".format(dev_path), transport) nsSet(ns, "{}/listen".format(dev_path), host) nsSet(ns, "{}/port".format(dev_path), host) nsConsole( ns, "RPC server {} will be listening on tcp://{}:{}".format( name, host, port)) pool = gevent.pool.Pool(maxconn) nsSet(ns, "{}/pool".format(dev_path), pool) wsgi_server = gevent.pywsgi.WSGIServer((host, port), transport.handle, spawn=pool, log=None) nsSet(ns, "{}/wsgi".format(dev_path), wsgi_server) nsDaemon(ns, "{}:WSGI".format(name), wsgi_server.serve_forever, _raw=True) rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), dispatcher) if nsGet(ns, "/config/RPCCatchCalls") is True or nsGet( ns, "/etc/flags/rpctrace", False) is True: _q = gevent.queue.Queue() nsSet(ns, "{}/trace".format(dev_path), _q) rpc_server.trace = partial(nsRPCCatcher, ns, dev_path, _q) nsSet(ns, "{}/rpc", rpc_server) nsDaemon(ns, "{}:RPC".format(name), rpc_server.serve_forever, _raw=True) nsInfo(ns, "RPC server {} is up".format(name)) return True
def __init__(self, interface): """ Args: interface: Interface to provide. """ self.__dispatcher = RPCLoggingDispatcher() transport = WsgiServerTransport(queue_class=gevent.queue.Queue) self._wsgi_server = gevent.wsgi.WSGIServer( ('', configuration.get_rpc_server_port()), transport.handle, log=None) gevent.spawn(self._wsgi_server.serve_forever) self.__server = RPCServerGreenlets(transport, JSONRPCProtocol(), self.__dispatcher) # register interface's public functions self.__dispatcher.register_instance(interface, "")
def __init__(self, app): log.debug('initializing JSONRPCServer') BaseService.__init__(self, app) self.app = app self.dispatcher = LoggingDispatcher() # register sub dispatchers for subdispatcher in self.subdispatcher_classes(): subdispatcher.register(self) transport = WsgiServerTransport(queue_class=gevent.queue.Queue) # start wsgi server as a background-greenlet self.listen_port = app.config['jsonrpc']['listen_port'] self.listen_host = app.config['jsonrpc']['listen_host'] self.wsgi_server = gevent.wsgi.WSGIServer( (self.listen_host, self.listen_port), transport.handle, log=WSGIServerLogger) self.rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), self.dispatcher) self.default_block = 'latest'
def gevent_main(wotabag, dispatcher, sdp_transport): """Secondary thread for gevent event loop. Needed so that it does not conflict with dbus/glib event loop. """ logger = logging.getLogger('wotabag') ble_rpc_server = WotabagRPCServerGreenlets( sdp_transport, JSONRPCProtocol(), dispatcher ) # Configure WSGI (HTTP) RPC server wsgi_transport = WsgiServerTransport(queue_class=gevent.queue.Queue) wsgi_server = WSGIServer((wotabag.rpc_host, wotabag.rpc_port), wsgi_transport.handle) gevent.spawn(wsgi_server.serve_forever) wsgi_rpc_server = WotabagRPCServerGreenlets( wsgi_transport, JSONRPCProtocol(), dispatcher ) try: greenlets = [] logger.info("Running RPC server at {}:{}".format(wotabag.rpc_host, wotabag.rpc_port)) greenlets.append(wsgi_rpc_server.start()) greenlets.append(ble_rpc_server.start()) gevent.sleep(0) server_done.wait() except Exception as e: logger.exception(e) raise e finally: gevent.joinall(greenlets) logger.info("RPC server finished")
import gevent import gevent.pywsgi import gevent.queue from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.wsgi import WsgiServerTransport from tinyrpc.server.gevent import RPCServerGreenlets from tinyrpc.dispatch import RPCDispatcher import subprocess import json import radio_data_rate import time import re dispatcher = RPCDispatcher() transport = WsgiServerTransport(queue_class=gevent.queue.Queue) # start wsgi server as a background-greenlet wsgi_server = gevent.pywsgi.WSGIServer(('192.168.1.100', 8080), transport.handle) gevent.spawn(wsgi_server.serve_forever) rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), dispatcher) current_radio_rate_r1 = {'vhf': 9600, 'uhf': 240, 'sat_comm': 512} def set_vhf_data_rate(interface=None, rate=None, parent=None, classid=None): if None not in (interface, rate, parent, classid): if rate == 9600: rate_in_kbps = '9.6kbps' elif rate == 4800:
from UE_ROS_Bridge_ListenerBase import SetupListeners, SetupServiceListeners from UE_ROS_Bridge_PublisherBase import SetupPublishers from timeit import default_timer as timer import gevent import gevent.wsgi import gevent.queue from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from tinyrpc.transports.wsgi import WsgiServerTransport from tinyrpc.server.gevent import RPCServerGreenlets from tinyrpc.dispatch import RPCDispatcher from threading import Lock dispatcher = RPCDispatcher() transport = WsgiServerTransport(max_content_length=4096 * 1024, queue_class=gevent.queue.Queue) # start wsgi server as a background-greenlet wsgi_server = gevent.wsgi.WSGIServer(('0.0.0.0', 10090), transport.handle) gevent.spawn(wsgi_server.serve_forever) rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), dispatcher) TFPublisher = rospy.Publisher('tf', tfMessage, queue_size=1) rospy.init_node('UE_ROS_Bridge') tfBroadcaster = tf.TransformBroadcaster() serviceHandlers = {} messagePages = [{}, {}] messageSendingPage = [0] pageMutex = Lock()