async def _dry_run(self, **kwargs) -> bool:
"""Sends a dry run to the Flow to validate if the Flow is ready to receive requests
:param kwargs: potential kwargs received passed from the public interface
:return: boolean indicating the health/readiness of the Flow
"""
try:
async with GrpcConnectionPool.get_grpc_channel(
f'{self.args.host}:{self.args.port}',
asyncio=True,
tls=self.args.tls,
) as channel:
stub = jina_pb2_grpc.JinaGatewayDryRunRPCStub(channel)
self.logger.debug(f'connected to {self.args.host}:{self.args.port}')
call_result = stub.dry_run(
jina_pb2.google_dot_protobuf_dot_empty__pb2.Empty(), **kwargs
)
metadata, response = (
await call_result.trailing_metadata(),
await call_result,
)
if response.code == jina_pb2.StatusProto.SUCCESS:
return True
except Exception as e:
self.logger.error(f'Error while getting response from grpc server {e!r}')
return False
async def _get_results(
self,
inputs: 'InputType',
on_done: 'CallbackFnType',
on_error: Optional['CallbackFnType'] = None,
on_always: Optional['CallbackFnType'] = None,
compression: Optional[str] = None,
**kwargs,
):
try:
self.compression = (
getattr(grpc.Compression, compression)
if compression
else grpc.Compression.NoCompression
)
self.inputs = inputs
req_iter = self._get_requests(**kwargs)
async with GrpcConnectionPool.get_grpc_channel(
f'{self.args.host}:{self.args.port}',
asyncio=True,
tls=self.args.tls,
) as channel:
stub = jina_pb2_grpc.JinaRPCStub(channel)
self.logger.debug(f'connected to {self.args.host}:{self.args.port}')
with ProgressBar(
total_length=self._inputs_length, disable=not (self.show_progress)
) as p_bar:
async for resp in stub.Call(
req_iter,
compression=self.compression,
):
callback_exec(
response=resp,
on_error=on_error,
on_done=on_done,
on_always=on_always,
continue_on_error=self.continue_on_error,
logger=self.logger,
)
if self.show_progress:
p_bar.update()
yield resp
except KeyboardInterrupt:
self.logger.warning('user cancel the process')
except asyncio.CancelledError as ex:
self.logger.warning(f'process error: {ex!r}')
except (grpc.aio._call.AioRpcError, InternalNetworkError) as err:
my_code = err.code()
my_details = err.details()
msg = f'gRPC error: {my_code} {my_details}'
try:
if my_code == grpc.StatusCode.UNAVAILABLE:
self.logger.error(
f'{msg}\nThe ongoing request is terminated as the server is not available or closed already.'
)
raise ConnectionError(my_details) from None
elif my_code == grpc.StatusCode.DEADLINE_EXCEEDED:
self.logger.error(
f'{msg}\nThe ongoing request is terminated due to a server-side timeout.'
)
raise ConnectionError(my_details) from None
elif my_code == grpc.StatusCode.INTERNAL:
self.logger.error(f'{msg}\ninternal error on the server side')
raise err
elif (
my_code == grpc.StatusCode.UNKNOWN
and 'asyncio.exceptions.TimeoutError' in my_details
):
raise BadClientInput(
f'{msg}\n'
'often the case is that you define/send a bad input iterator to jina, '
'please double check your input iterator'
) from err
else:
raise BadClient(msg) from err
except (
grpc.aio._call.AioRpcError,
BaseJinaException,
ConnectionError,
) as e: # depending on if there are callbacks we catch or not the exception
if on_error or on_always:
if on_error:
callback_exec_on_error(on_error, e, self.logger)
if on_always:
callback_exec(
response=None,
on_error=None,
on_done=None,
on_always=on_always,
continue_on_error=self.continue_on_error,
logger=self.logger,
)
else:
raise e
async def _get_results(
self,
inputs: 'InputType',
on_done: 'CallbackFnType',
on_error: Optional['CallbackFnType'] = None,
on_always: Optional['CallbackFnType'] = None,
**kwargs,
):
try:
self.inputs = inputs
req_iter = self._get_requests(**kwargs)
async with GrpcConnectionPool.get_grpc_channel(
f'{self.args.host}:{self.args.port}',
asyncio=True,
https=self.args.https,
) as channel:
stub = jina_pb2_grpc.JinaRPCStub(channel)
self.logger.debug(
f'connected to {self.args.host}:{self.args.port}')
cm1 = (ProgressBar(total_length=self._inputs_length)
if self.show_progress else nullcontext())
with cm1 as p_bar:
async for resp in stub.Call(req_iter):
callback_exec(
response=resp,
on_error=on_error,
on_done=on_done,
on_always=on_always,
continue_on_error=self.continue_on_error,
logger=self.logger,
)
if self.show_progress:
p_bar.update()
yield resp
except KeyboardInterrupt:
self.logger.warning('user cancel the process')
except asyncio.CancelledError as ex:
self.logger.warning(f'process error: {ex!r}')
except grpc.aio._call.AioRpcError as rpc_ex:
# Since this object is guaranteed to be a grpc.Call, might as well include that in its name.
my_code = rpc_ex.code()
my_details = rpc_ex.details()
msg = f'gRPC error: {my_code} {my_details}'
if my_code == grpc.StatusCode.UNAVAILABLE:
self.logger.error(
f'{msg}\nthe ongoing request is terminated as the server is not available or closed already'
)
raise rpc_ex
elif my_code == grpc.StatusCode.INTERNAL:
self.logger.error(f'{msg}\ninternal error on the server side')
raise rpc_ex
elif (my_code == grpc.StatusCode.UNKNOWN
and 'asyncio.exceptions.TimeoutError' in my_details):
raise BadClientInput(
f'{msg}\n'
'often the case is that you define/send a bad input iterator to jina, '
'please double check your input iterator') from rpc_ex
else:
raise BadClient(msg) from rpc_ex
async def _get_results(
self,
inputs: 'InputType',
on_done: 'CallbackFnType',
on_error: Optional['CallbackFnType'] = None,
on_always: Optional['CallbackFnType'] = None,
compression: str = 'NoCompression',
**kwargs,
):
try:
if compression.lower() not in GRPC_COMPRESSION_MAP:
import warnings
warnings.warn(
message=
f'Your compression "{compression}" is not supported. Supported '
f'algorithms are `Gzip`, `Deflate` and `NoCompression`. NoCompression will be used as '
f'default')
compression = 'NoCompression'
self.inputs = inputs
req_iter = self._get_requests(**kwargs)
async with GrpcConnectionPool.get_grpc_channel(
f'{self.args.host}:{self.args.port}',
asyncio=True,
tls=self.args.tls,
) as channel:
stub = jina_pb2_grpc.JinaRPCStub(channel)
self.logger.debug(
f'connected to {self.args.host}:{self.args.port}')
with ProgressBar(total_length=self._inputs_length,
disable=not (self.show_progress)) as p_bar:
async for resp in stub.Call(
req_iter,
compression=GRPC_COMPRESSION_MAP.get(
compression.lower(),
grpc.Compression.NoCompression),
):
callback_exec(
response=resp,
on_error=on_error,
on_done=on_done,
on_always=on_always,
continue_on_error=self.continue_on_error,
logger=self.logger,
)
if self.show_progress:
p_bar.update()
yield resp
except KeyboardInterrupt:
self.logger.warning('user cancel the process')
except asyncio.CancelledError as ex:
self.logger.warning(f'process error: {ex!r}')
except grpc.aio._call.AioRpcError as rpc_ex:
# Since this object is guaranteed to be a grpc.Call, might as well include that in its name.
my_code = rpc_ex.code()
my_details = rpc_ex.details()
msg = f'gRPC error: {my_code} {my_details}'
try:
if my_code == grpc.StatusCode.UNAVAILABLE:
self.logger.error(
f'{msg}\nthe ongoing request is terminated as the server is not available or closed already'
)
raise rpc_ex
elif my_code == grpc.StatusCode.INTERNAL:
self.logger.error(
f'{msg}\ninternal error on the server side')
raise rpc_ex
elif (my_code == grpc.StatusCode.UNKNOWN
and 'asyncio.exceptions.TimeoutError' in my_details):
raise BadClientInput(
f'{msg}\n'
'often the case is that you define/send a bad input iterator to jina, '
'please double check your input iterator') from rpc_ex
else:
raise BadClient(msg) from rpc_ex
except (
grpc.aio._call.AioRpcError,
BaseJinaException,
) as e: # depending on if there are callbacks we catch or not the exception
if on_error or on_always:
if on_error:
callback_exec_on_error(on_error, e, self.logger)
if on_always:
callback_exec(
response=None,
on_error=None,
on_done=None,
on_always=on_always,
continue_on_error=self.continue_on_error,
logger=self.logger,
)
else:
raise e