class JSONRPCServer(BaseService): name = 'jsonrpc' 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 _run(self): log.info('starting JSONRPCServer') # in the main greenlet, run our rpc_server self.wsgi_thread = gevent.spawn(self.wsgi_server.serve_forever) self.rpc_server.serve_forever() def add_method(self, func, name=None): self.dispatcher.add_method(func, name) def stop(self): log.info('stopping JSONRPCServer') self.wsgi_thread.kill()
class JSONRPCServer(BaseService): name = 'jsonrpc' 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 _run(self): log.info('starting JSONRPCServer') # in the main greenlet, run our rpc_server self.wsgi_thread = gevent.spawn(self.wsgi_server.serve_forever) self.rpc_server.serve_forever() def add_method(self, func, name=None): self.dispatcher.add_method(func, name) def stop(self): log.info('stopping JSONRPCServer') self.wsgi_thread.kill()
def WebSocketRPCHandler(trustlines: TrustlinesRelay): dispatcher = RPCDispatcher() dispatcher.add_method(partial(subscribe, trustlines), "subscribe") protocol = JSONRPCProtocol() def handle(ws): app = RPCWebSocketApplication(protocol, dispatcher, ws) app.handle() return handle
def MessagingWebSocketRPCHandler(trustlines: TrustlinesRelay): dispatcher = RPCDispatcher() dispatcher.add_method(partial(messaging_subscribe, trustlines), "listen") dispatcher.add_method(partial(get_missed_messages, trustlines), "getMissedMessages") protocol = JSONRPCProtocol() def handle(ws): app = RPCWebSocketApplication(protocol, dispatcher, ws) app.handle() return handle
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
class RPCService(object): def __init__(self, function_lists, is_id_valid): self._rpc_dispatcher = RPCDispatcher() self._rpc_protocol = JSONRPCProtocol() self._is_id_valid = is_id_valid for f in function_lists: self._rpc_dispatcher.add_method(f) logger.info("RPC service initialized") def handle_rpccmd_message(self, context, dest_id, src_id, msg_type, payload): # logger.debug("got RPCCMD message from src_id %s:\n%s" % (MPTN.ID_TO_STRING(src_id), MPTN.formatted_print([payload]))) if not self._is_id_valid(dest_id): logger.error("invalid RPCCMD dest ID %X: not found in network" % dest_id) return None if src_id != MPTN.MASTER_ID: logger.error("invalid RPCCMD src ID %X: should be master" % src_id) return None if payload is None: logger.error("packet RPCCMD should have the payload") return None try: request = self._rpc_protocol.parse_request(payload) except RPCError as e: response = e.error_respond() else: response = self._rpc_dispatcher.dispatch(request) if response is None: response = str(None) else: response = response.serialize() message = MPTN.create_packet_to_str(src_id, dest_id, MPTN.MPTN_MSGTYPE_RPCREP, response) MPTN.socket_send(context, src_id, message) return
from tinyrpc.dispatch import RPCDispatcher from tinyrpc.protocols.jsonrpc import JSONRPCProtocol from werkzeug.wrappers import Response, Request try: import config except ImportError: import default_config as config dispatcher = RPCDispatcher() protocol = JSONRPCProtocol() import api from api import api_methods, create_instruments create_instruments() for method in api_methods: dispatcher.add_method(getattr(api, method), method) def application(environ, start_response): request = Request(environ) access_control_headers = { 'Access-Control-Allow-Methods': 'POST', 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Headers': 'Content-Type, X-Requested-With, Accept, Origin' } if request.method == 'OPTIONS': response = Response(headers=access_control_headers) elif request.method == 'POST': # message is encoded in POST, read it... message = request.stream.read() request = protocol.parse_request(message) result = dispatcher.dispatch(request)