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()