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)
