async def send_request_async(
request: Request,
target: str,
timeout: float = 1.0,
https: bool = False,
root_certificates: Optional[str] = None,
) -> Request:
"""
Sends a request asynchronously to the target via grpc
:param request: the request to send
:param target: where to send the request to, like 127.0.0.1:8080
:param timeout: timeout for the send
:param https: if True, use https for the grpc channel
:param root_certificates: the path to the root certificates for https, only u
:returns: the response request
"""
async with GrpcConnectionPool.get_grpc_channel(
target,
asyncio=True,
https=https,
root_certificates=root_certificates,
) as channel:
if type(request) == DataRequest:
stub = jina_pb2_grpc.JinaSingleDataRequestRPCStub(channel)
return await stub.process_single_data(request, timeout=timeout)
elif type(request) == ControlRequest:
stub = jina_pb2_grpc.JinaControlRequestRPCStub(channel)
return await stub.process_control(request, timeout=timeout)
def create_async_channel_stub(
address,
https=False,
root_certificates: Optional[str] = None,
) -> Tuple[jina_pb2_grpc.JinaSingleDataRequestRPCStub,
jina_pb2_grpc.JinaDataRequestRPCStub,
jina_pb2_grpc.JinaControlRequestRPCStub, grpc.aio.Channel, ]:
"""
Creates an async GRPC Channel. This channel has to be closed eventually!
:param address: the address to create the connection to, like 127.0.0.0.1:8080
:param https: if True, use https for the grpc channel
:param root_certificates: the path to the root certificates for https, only u
:returns: DataRequest/ControlRequest stubs and an async grpc channel
"""
channel = GrpcConnectionPool.get_grpc_channel(
address,
asyncio=True,
https=https,
root_certificates=root_certificates,
)
return (
jina_pb2_grpc.JinaSingleDataRequestRPCStub(channel),
jina_pb2_grpc.JinaDataRequestRPCStub(channel),
jina_pb2_grpc.JinaControlRequestRPCStub(channel),
channel,
)
def send_request_sync(
request: Request,
target: str,
timeout=100.0,
tls=False,
root_certificates: Optional[str] = None,
endpoint: Optional[str] = None,
) -> Request:
"""
Sends a request synchronously to the target via grpc
:param request: the request to send
:param target: where to send the request to, like 127.0.0.1:8080
:param timeout: timeout for the send
:param tls: if True, use tls encryption for the grpc channel
:param root_certificates: the path to the root certificates for tls, only used if tls is True
:param endpoint: endpoint to target with the request
:returns: the response request
"""
for i in range(3):
try:
with GrpcConnectionPool.get_grpc_channel(
target,
tls=tls,
root_certificates=root_certificates,
) as channel:
if type(request) == DataRequest:
metadata = (('endpoint',
endpoint), ) if endpoint else None
stub = jina_pb2_grpc.JinaSingleDataRequestRPCStub(
channel)
response, call = stub.process_single_data.with_call(
request,
timeout=timeout,
metadata=metadata,
)
elif type(request) == ControlRequest:
stub = jina_pb2_grpc.JinaControlRequestRPCStub(channel)
response = stub.process_control(request,
timeout=timeout)
return response
except grpc.RpcError as e:
if e.code() != grpc.StatusCode.UNAVAILABLE or i == 2:
raise