def worker(*, uid: int, endpoint: str): ctx = zmq.Context() dispatcher = RPCDispatcher() client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(ctx, endpoint), ) proxy = client.get_proxy() @dispatcher.public def do_task(): from time import sleep for i in range(5): proxy.notify(f"{uid} y{i} ") sleep(0.1) return f"OK {uid}" @dispatcher.public def exit(): proxy.exit(uid) transport = ZmqServerTransport.create( ctx, endpoint.replace(".manager", f".{uid}")) rpc_server = RPCServer(transport, JSONRPCProtocol(), dispatcher) rpc_server.trace = partial(print, file=sys.stderr) rpc_server.serve_forever()
def client(*, endpoint: str, callback_endpoint: str): ctx = zmq.Context() dispatcher = RPCDispatcher() @dispatcher.public def notify(s: str): print("** {s} **") callback_server = RPCServer( ZmqServerTransport.create(ctx, callback_endpoint), JSONRPCProtocol(), dispatcher) callback_server.trace = print threading.Thread(target=callback_server.serve_forever, daemon=True).start() rpc_client = RPCClient(JSONRPCProtocol(), ZmqClientTransport.create(ctx, endpoint)) remote_server = rpc_client.get_proxy() for i in range(7): result = remote_server.act(i, "Hello, World!") print("Server answered:", result) result = remote_server.shutdown() print("Send shutdown:", result)
def __init__(self, ws): self.ws = ws self.queue = hub.Queue() super(WebSocketRPCClient, self).__init__( JSONRPCProtocol(), WebSocketClientTransport(ws, self.queue), )
def __init__(self, ip_hostname='pulsestreamer'): print("Connect to Pulse Streamer via JSON-RPC.") print("IP / Hostname:", ip_hostname) url = 'http://' + ip_hostname + ':8050/json-rpc' try: self.INFINITE = -1 self.CONSTANT_ZERO = (0, 0, 0, 0) if sys.version_info.major > 2: client = RPCClient(url) else: client = RPCClient(JSONRPCProtocol(), HttpPostClientTransport(url)) self.proxy = client.get_proxy() try: self.proxy.getSerial() except: try: self.proxy.isRunning() print( "Pulse Streamer class not compatible with current firmware. Please update your firmware." ) sys.exit(1) except: print("No Pulse Streamer found at IP/Host-address: " + ip_hostname) sys.exit(1) except: print("No Pulse Streamer found at IP/Host-address: " + ip_hostname) sys.exit(1)
def test_async_argument_error(async_dispatch, invoke_with, event_loop): method, args, kwargs, result = invoke_with protocol = JSONRPCProtocol() @async_dispatch.public async def fn_a(a, b): return a - b @async_dispatch.public async def fn_b(*a): return a[0] - a[1] @async_dispatch.public async def fn_c(**a): return a['a'] - a['b'] mock_request = Mock(RPCRequest) mock_request.args = args mock_request.kwargs = kwargs mock_request.method = method event_loop.run_until_complete(async_dispatch._dispatch(mock_request)) if inspect.isclass(result) and issubclass(result, Exception): assert type(mock_request.error_respond.call_args[0][0]) is result else: mock_request.respond.assert_called_with(result)
def test_argument_error(dispatch, invoke_with): method, args, kwargs, result = invoke_with protocol = JSONRPCProtocol() @dispatch.public def fn_a(a, b): return a - b @dispatch.public def fn_b(*a): return a[0] - a[1] @dispatch.public def fn_c(**a): return a['a'] - a['b'] mock_request = Mock(RPCRequest) mock_request.args = args mock_request.kwargs = kwargs mock_request.method = method dispatch._dispatch(mock_request) if inspect.isclass(result) and issubclass(result, Exception): assert type(mock_request.error_respond.call_args[0][0]) == result else: mock_request.respond.assert_called_with(result)
class RPCSocketHandler(WebSocketHandler): ''' This is **not** a singleton. There is an instance for every client. ''' protocol = JSONRPCProtocol() # one instance is enough. # this needs to be implemented by a subclass. Dict: method_string --> # Procedure(method_callback) procedures = None def on_message(self, message): json_request = self.protocol.parse_request(message) # procedures (dict: sting --> method) must be implemented in a # subclass! callback = self.procedures.get(json_request.method) if callback is None: response = json_request.error_respond('Method %r not implemented' % json_request.method) self.write_message(response.serialize()) return try: result = callback(json_request) except Exception as exc: logger.error(exc, exc_info=True) response = json_request.error_respond(repr(exc)) self.write_message(response.serialize()) return return self.return_result(result, json_request) def return_result(self, result, json_request): response = json_request.respond(result) self.write_message(response.serialize())
def authenticate(self): """ Performs authentication actions Patches `tinyrpc` to remove minor incompatibilities due to JSON-RPC protocol version differences. This is performed once. Initializes the RPCClient and RPCProxy instances that are used to make the requests to Lime. :return: None """ logger.info("Authenticating LimeAPI client") if not LimeAPI._rpc_protocol_patched: LimeAPI.patch_json_rpc_protocol() LimeAPI._rpc_protocol_patched = True self.rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport(endpoint=self.remote_api_url, headers=self.headers), ) self.rpc_proxy = self.rpc_client.get_proxy() self.session_key = self.rpc_proxy.get_session_key( username=self.username, password=self.password) if not self._validate_session_key(): raise Exception(f"Failed to validate session key: url={self.url} " f"session_key={self.session_key}") self._authenticated = True logger.info(f"Acquired session key: {self.session_key}")
def test_async_class_method_argument_error(async_dispatch, invoke_with, event_loop): method, args, kwargs, result = invoke_with protocol = JSONRPCProtocol() class Test: c = 0 @classmethod @public async def fn_a(cls, a, b): return a - b - cls.c @classmethod @public async def fn_b(cls, *a): return a[0] - a[1] - cls.c @classmethod @public async def fn_c(cls, **a): return a['a'] - a['b'] - cls.c test = Test() async_dispatch.register_instance(test) mock_request = Mock(RPCRequest) mock_request.args = args mock_request.kwargs = kwargs mock_request.method = method event_loop.run_until_complete(async_dispatch._dispatch(mock_request)) if inspect.isclass(result) and issubclass(result, Exception): assert type(mock_request.error_respond.call_args[0][0]) == result else: mock_request.respond.assert_called_with(result)
def nsZRPCBringupServer(ns, path, conn, maxconn): name = os.path.basename(path) dev_path = '/dev/zrpc/{}'.format(name) if nsRPCisServer(ns, path) is not True: nsError(ns, "ZRPC service {} misconfigured".format(name)) return False nsInfo(ns, "Configuring ZRPC 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, "ZRPC.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 = ZmqServerTransport.create(ctx, conn) nsSet(ns, "{}/transport".format(dev_path), transport) nsSet(ns, "{}/conn".format(dev_path), conn) rpc_server = RPCServerGreenlets(transport, JSONRPCProtocol(), dispatcher) nsSet(ns, "{}/rpc", rpc_server) nsDaemon(ns, "{}:ZRPC".format(name), rpc_server.serve_forever, _raw=True) nsInfo(ns, "ZRPC server {} is up".format(name)) return True
def __init__(self, host, port, privkey, nonce_update_interval=5.0, nonce_offset=0): endpoint = 'http://{}:{}'.format(host, port) session = requests.Session() adapter = requests.adapters.HTTPAdapter(pool_maxsize=50) session.mount(endpoint, adapter) self.transport = HttpPostClientTransport( endpoint, post_method=session.post, headers={'content-type': 'application/json'}, ) self.port = port self.privkey = privkey self.protocol = JSONRPCProtocol() self.sender = privatekey_to_address(privkey) self.nonce_last_update = 0 self.nonce_current_value = None self.nonce_lock = Semaphore() self.nonce_update_interval = nonce_update_interval self.nonce_offset = nonce_offset
def test_static_method_argument_error(dispatch, invoke_with): method, args, kwargs, result = invoke_with protocol = JSONRPCProtocol() class Test: c = 0 @staticmethod @public def fn_a(a, b): return a - b @staticmethod @public def fn_b(*a): return a[0] - a[1] @staticmethod @public def fn_c(**a): return a['a'] - a['b'] test = Test() dispatch.register_instance(test) mock_request = Mock(RPCRequest) mock_request.args = args mock_request.kwargs = kwargs mock_request.method = method dispatch._dispatch(mock_request, getattr(protocol, '_caller', None)) if inspect.isclass(result) and issubclass(result, Exception): assert type(mock_request.error_respond.call_args[0][0]) == result else: mock_request.respond.assert_called_with(result)
def __init__(self, host, port, privkey, nonce_update_interval=5.0, nonce_offset=0): endpoint = 'http://{}:{}'.format(host, port) session = requests.Session() adapter = requests.adapters.HTTPAdapter(pool_maxsize=50) session.mount(endpoint, adapter) self.transport = HttpPostClientTransport( endpoint, post_method=session.post, headers={'content-type': 'application/json'}, ) self.port = port self.privkey = privkey self.protocol = JSONRPCProtocol() self.sender = privatekey_to_address(privkey) # Needs to be initialized to None in the beginning since JSONRPCClient # gets constructed before the RaidenService Object. self.stop_event = None self.nonce_last_update = 0 self.nonce_current_value = None self.nonce_lock = Semaphore() self.nonce_update_interval = nonce_update_interval self.nonce_offset = nonce_offset
def login(self, username, password): self.rpc_client = RPCClient( JSONRPCProtocol(), HttpWebSocketClientTransport('ws://localhost:9001/api/ws')) self.loginManager = self.rpc_client.get_proxy("login.") hashed_password = hashlib.sha256(password).hexdigest() return self.loginManager.authenticate(username=username, password=hashed_password)
def __init__(self, node_url=None): rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport( node_url or os.getenv("RADIX_NODE_URL") or DEFAULT_NODE_URL ), ) self._rpc_proxy = rpc_client.get_proxy(prefix=RPC_METHOD_PREFIX)
def __init__(self, ws, rpc_callback): dispatcher = RPCDispatcher() dispatcher.register_instance(rpc_callback) super(WebSocketRPCServer, self).__init__( WebSocketServerTransport(ws), JSONRPCProtocol(), dispatcher, )
def __init__(self, obj, one_way=False): url = obj.env['device_manager.settings']._get_param( 'mqtt_rpc_bridge_url') logger.debug('HTTP bridge url {}'.format(url)) rpc_client = RPCClient( JSONRPCProtocol(), HttpPostClientTransport(url) ) self.proxy = rpc_client.get_proxy(one_way=one_way)
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 worker(): rpc_server = RPCServer( SubprocessServerTransport( input_port=sys.stdin.buffer, output_port=sys.stdout.buffer ), JSONRPCProtocol(), dispatcher, ) rpc_server.trace = partial(print, file=sys.stderr) rpc_server.serve_forever()
def __init__( self, transport: Callable[[bytes, Optional[float]], Awaitable[bytes]], app: BaseApplication, exception_mapping_callback: Optional[Callable[ [Optional[int], Optional[str], Optional[Any]], None]] = None, ): self._app = app self._proto = JSONRPCProtocol() self._transport = transport self._exception_mapping_callback = exception_mapping_callback
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 __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 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 connectHandler(cmd, handler): dispatcher = RPCDispatcher() print("cmd: {}".format(" ".join(cmd))) # line buffered p = subprocess.Popen(cmd, bufsize=1, universal_newlines=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) transport = PipeTransport(p.stdout, p.stdin) rpc_server = RPCServer(transport, JSONRPCProtocol(), dispatcher) dispatcher.register_instance(handler, '') return (rpc_server, p)
def worker(): ctx = zmq.Context() rpc_client = RPCClient( JSONRPCProtocol(), ZmqClientTransport.create(ctx, "tcp://127.0.0.1:5002")) proxy = rpc_client.get_proxy() for message in iter(partial(recv, port=sys.stdin), ""): proxy.post(f"hello {message}") import time time.sleep(0.4) sys.stdout.write("") sys.stdout.close()
def __init__(self, host: str, port: int, privkey: bytes, gasprice: int = None, nonce_update_interval: float = 5.0, nonce_offset: int = 0): if privkey is None or len(privkey) != 32: raise ValueError('Invalid private key') endpoint = 'http://{}:{}'.format(host, port) self.session = requests.Session() adapter = requests.adapters.HTTPAdapter(pool_maxsize=50) self.session.mount(endpoint, adapter) self.transport = HttpPostClientTransport( endpoint, post_method=self.session.post, headers={'content-type': 'application/json'}, ) self.port = port self.privkey = privkey self.protocol = JSONRPCProtocol() self.sender = privatekey_to_address(privkey) # Needs to be initialized to None in the beginning since JSONRPCClient # gets constructed before the RaidenService Object. self.stop_event = None self.nonce_last_update = 0 self.nonce_available_value = None self.nonce_lock = Semaphore() self.nonce_update_interval = nonce_update_interval self.nonce_offset = nonce_offset self.given_gas_price = gasprice cache = cachetools.TTLCache( maxsize=1, ttl=RPC_CACHE_TTL, ) cache_wrapper = cachetools.cached(cache=cache) self.gaslimit = cache_wrapper(self._gaslimit) cache = cachetools.TTLCache( maxsize=1, ttl=RPC_CACHE_TTL, ) cache_wrapper = cachetools.cached(cache=cache) self.gasprice = cache_wrapper(self._gasprice)
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")
def __init__(self, transport, publisher=None, ctx=None, protocol=None, dispatcher=None): self.ctx = ctx if ctx else zmq.Context().instance() self.protocol = protocol if protocol else JSONRPCProtocol() self.dispatcher = dispatcher if dispatcher else RPCDispatcher() self.publisher = publisher if publisher else NoOpPublisher() if isinstance(transport, dict): # dictionary: if 'receiver' in transport and 'replier' in transport: self.endpoints = transport else: msg = 'endpoint dictionary {} should contains receiver and replier' raise Exception(msg.format(transport)) self.endpoint = self.endpoints['receiver'] elif isinstance(transport, basestring): # only 1 endpoint is provided; create endpoint for replier by adding port by 10000 pattern = '(tcp://)?((?P<ip>[0-9.*]+):)?(?P<port>[0-9]+)' re_groups = re.match(pattern, transport.strip()) if not re_groups: raise Exception( 'Invalid transport format {}; ' 'expecting tcp://IP:PORT or IP:PORT'.format(transport)) replier_port = int(re_groups.group('port')) + 10000 ip = re_groups.group('ip') if re_groups.group('ip') else '*' receiver_endpoint = 'tcp://{}:{}'.format(ip, replier_port) replier_endpoint = 'tcp://{}:{}'.format(ip, replier_port) self.endpoints = { 'receiver': transport, 'replier': replier_endpoint } self.endpoint = self.endpoints['receiver'] else: # existing transport instance self.endpoint = transport logger_name = self.endpoint.replace('://', '') logger_name = logger_name.replace(':', '_') logger_name = logger_name.replace('tcp', '') self.logger = RPCLogger(logger_name) self.init_server(self.endpoints, self.logger) self.server_mode = 'normal'
def main(args): cmd = ["clef", "--stdio-ui"] if len(args) > 0 and args[0] == "test": cmd.extend(["--stdio-ui-test"]) print("cmd: {}".format(" ".join(cmd))) dispatcher = RPCDispatcher() dispatcher.register_instance(StdIOHandler(), '') # line buffered p = subprocess.Popen(cmd, bufsize=1, universal_newlines=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE) rpc_server = RPCServer( PipeTransport(p.stdout, p.stdin), JSONRPCProtocol(), dispatcher ) rpc_server.serve_forever()