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