async def rpc_handler(self, request: web.Request) -> web.Response:
try:
result = await self._rpc.call(
await request.read(), request.charset
)
if result.method is not None:
span.tag(SPAN_TAG_RPC_METHOD, result.method)
if result.error is not None:
span.error(result.error)
if isinstance(result.error, InternalError):
self.app.log_err(result.error)
resp = self._err_resp(result.error)
if result.result is not None:
resp['result'] = result.result
else:
resp = {"code": 0, "message": 'OK', 'result': result.result}
span.tag(SPAN_TAG_RPC_CODE, resp['code'])
span.name = 'rpc::in (%s)' % result.method
span.set_name4adapter(self.app.logger.ADAPTER_PROMETHEUS, 'rpc_in')
body = self._json_encode(resp).encode()
return web.Response(body=body, content_type='application/json')
except Exception as err:
span.error(err)
self.app.log_err(err)
return web.Response(
body=self._json_encode(
self._err_resp(InternalError(parent=err))
).encode(),
content_type='application/json',
)
def _parse_request(self, request: bytes,
method_name: str) -> 'RestRpcRequest':
if span:
span.set_name4adapter(self._app.logger.ADAPTER_PROMETHEUS,
'rpc_in')
try:
return self._protocol.parse_request(request, method_name)
except (RestRpcInvalidRequestError, RestRpcParseError) as err:
self._set_span_method(None)
self._set_span_err(err)
raise
async def _exec_batch(
self, req: rpc.JSONRPCBatchRequest
) -> Optional[rpc.RPCBatchResponse]:
if span:
span.name = 'rpc::in::batch'
span.tag(SPAN_TAG_JSONRPC_IS_BATCH, 'true')
span.set_name4adapter(
self._app.logger.ADAPTER_PROMETHEUS, 'rpc_in_batch'
)
resp = req.create_batch_response()
batch = []
for req_item in req:
if isinstance(req_item, rpc.InvalidRequestError):
batch.append(self._exec_err(req_item))
else:
batch.append(
self._exec(
req_item.method,
req_item.args,
req_item.kwargs,
req_item.one_way,
)
)
results = await asyncio.gather(*batch, return_exceptions=True)
if resp is None:
return None
for i in range(len(req)):
if isinstance(req[i], rpc.InvalidRequestError):
err_resp = req[i].error_respond()
if hasattr(err_resp, 'data'):
err_resp.data = self.cast2dump(err_resp.data)
resp.append(err_resp)
elif req[i].one_way:
pass
elif isinstance(results[i], BaseException):
err_resp = req[i].error_respond(results[i])
if hasattr(err_resp, 'data'):
err_resp.data = self.cast2dump(err_resp.data)
resp.append(err_resp)
else:
resp.append(req[i].respond(self.cast2dump(results[i])))
return resp
async def _exec(
self,
method: str,
args: Tuple[Any, ...],
kwargs: Dict[str, Any],
is_one_way: bool,
) -> Any:
if span and span.tags.get(SPAN_TAG_JSONRPC_IS_BATCH):
with span.new_child(kind=Span.KIND_SERVER):
span.set_name4adapter(
self._app.logger.ADAPTER_PROMETHEUS, 'rpc_in'
)
return await self._exec_method(
method, args, kwargs, is_one_way
)
else:
return await self._exec_method(method, args, kwargs, is_one_way)
def _parse_request(
self, request: bytes
) -> Union['rpc.JSONRPCRequest', 'rpc.JSONRPCBatchRequest']:
if span:
span.set_name4adapter(self._app.logger.ADAPTER_PROMETHEUS,
'rpc_in')
try:
return self._protocol.parse_request(request)
except (JSONRPCInvalidRequestError, JSONRPCParseError) as err:
if isinstance(err, JSONRPCInvalidRequestError):
old = self._old_parse_request(request)
if old is not None:
return old
self._set_span_method(None)
self._set_span_err(err)
raise