def grpc_serve(): # the +5 you see below re: max_workers is a hack to avoid thread starvation # working on a proper workaround server = grpc.server( futures.ThreadPoolExecutor(max_workers=multiprocessing.cpu_count() + 5)) # Add the application servicer to the server. whereami_pb2_grpc.add_WhereamiServicer_to_server(WhereamigRPC(), server) # Create a health check servicer. We use the non-blocking implementation # to avoid thread starvation. health_servicer = health.HealthServicer( experimental_non_blocking=True, experimental_thread_pool=futures.ThreadPoolExecutor(max_workers=1)) health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server) # Create a tuple of all of the services we want to export via reflection. services = tuple( service.full_name for service in whereami_pb2.DESCRIPTOR.services_by_name.values()) + ( reflection.SERVICE_NAME, health.SERVICE_NAME) # Add the reflection service to the server. reflection.enable_server_reflection(services, server) server.add_insecure_port('[::]:9090') server.start() # Mark all services as healthy. overall_server_health = "" for service in services + (overall_server_health, ): health_servicer.set(service, health_pb2.HealthCheckResponse.SERVING) # Park the main application thread. server.wait_for_termination()
def serve(port: int, hostname: str): server = grpc.server( futures.ThreadPoolExecutor(max_workers=multiprocessing.cpu_count())) # Add the application servicer to the server. helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(hostname), server) # Create a health check servicer. We use the non-blocking implementation # to avoid thread starvation. health_servicer = health.HealthServicer( experimental_non_blocking=True, experimental_thread_pool=futures.ThreadPoolExecutor(max_workers=1)) health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server) # Create a tuple of all of the services we want to export via reflection. services = tuple( service.full_name for service in helloworld_pb2.DESCRIPTOR.services_by_name.values()) + ( reflection.SERVICE_NAME, health.SERVICE_NAME) # Add the reflection service to the server. reflection.enable_server_reflection(services, server) server.add_insecure_port(f"[::]:{port}") server.start() # Mark all services as healthy. overall_server_health = "" for service in services + (overall_server_health, ): health_servicer.set(service, health_pb2.HealthCheckResponse.SERVING) # Park the main application thread. server.wait_for_termination()
def __init__(self, host: str, *, port: int = 0, register: bool = False, workers: int = 10, write_address: bool = False, config: 'Optional[mtap.Config]' = None): if host is None: host = '127.0.0.1' if port is None: port = 0 self.write_address = write_address thread_pool = ThreadPoolExecutor(max_workers=workers) if config is None: config = _config.Config() server = grpc.server(thread_pool, options=[ ('grpc.max_send_message_length', config['grpc.max_send_message_length']), ('grpc.max_receive_message_length', config['grpc.max_receive_message_length']) ]) servicer = EventsServicer() events_pb2_grpc.add_EventsServicer_to_server(servicer, server) health_servicer = health.HealthServicer() health_servicer.set('', 'SERVING') health_servicer.set(constants.EVENTS_SERVICE_NAME, 'SERVING') health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server) self._port = server.add_insecure_port(host + ':' + str(port)) self._server = server self._address = host self._config = _config.Config() self._register = register self._address_file = None
def serve(host='[::]', port=5000, max_workers=4, max_receive_message_length=MAX_RECEIVE_MESSAGE_LENGTH, max_send_message_length=MAX_SEND_MESSAGE_LENGTH): servicer = health.HealthServicer() servicer.set('', health_pb2.HealthCheckResponse.SERVING) # Asset servicer.set('get_asset', health_pb2.HealthCheckResponse.SERVING) servicer.set('add_asset', health_pb2.HealthCheckResponse.SERVING) servicer.set('update_asset', health_pb2.HealthCheckResponse.SERVING) servicer.set('remove_asset', health_pb2.HealthCheckResponse.SERVING) servicer.set('exists_asset', health_pb2.HealthCheckResponse.SERVING) servicer.set('get_asset_info', health_pb2.HealthCheckResponse.SERVING) servicer.set('get_task_state', health_pb2.HealthCheckResponse.SERVING) servicer.set('get_bucket', health_pb2.HealthCheckResponse.SERVING) servicer.set('query', health_pb2.HealthCheckResponse.SERVING) # Bucket servicer.set('add_bucket', health_pb2.HealthCheckResponse.SERVING) servicer.set('update_bucket', health_pb2.HealthCheckResponse.SERVING) servicer.set('remove_bucket', health_pb2.HealthCheckResponse.SERVING) servicer.set('exists_bucket', health_pb2.HealthCheckResponse.SERVING) servicer.set('get_assets', health_pb2.HealthCheckResponse.SERVING) options = [('grpc.max_receive_message_length', max_receive_message_length), ('grpc.max_send_message_length', max_send_message_length)] server = grpc.server(futures.ThreadPoolExecutor(max_workers=max_workers), options=options) opac_pb2.add_AssetServiceServicer_to_server(Asset(), server) opac_pb2.add_BucketServiceServicer_to_server(AssetBucket(), server) # Health service health_pb2.add_HealthServicer_to_server(servicer, server) # Set port and Start Server server.add_insecure_port('{0}:{1}'.format(host, port)) server.start() logging.info( 'Started GRPC server on localhost, port: {0}, accept connections!'. format(port)) try: while True: time.sleep(1) except KeyboardInterrupt: logging.info('User stopping server...') server.stop(0) logging.info('Server stopped; exiting.') except Exception as e: logging.info('Caught exception "%s"; stopping server...', e) server.stop(0) logging.info('Server stopped; exiting.')
def _add_servicers(self): logger.info("Adding servicers") logger.debug("Adding HealthServicer") health_servicer = health.HealthServicer() health_pb2_grpc.add_HealthServicer_to_server(health_servicer, self.server) logger.debug("Adding StatisticsServicer") add_StatisticsProcesserServicer_to_server(Calculator(), self.server)
def __init__(self, name: str, max_workers: int = 10): self.name = name self.port = GRPC_PORT self.server = grpc.server( futures.ThreadPoolExecutor(max_workers=max_workers)) self.healthServer = health.HealthServicer() health_pb2_grpc.add_HealthServicer_to_server(self.healthServer, self.server) self.status = Status.UNKNOWN
def __init__( self, args: argparse.Namespace, **kwargs, ): """Initialize grpc and data request handling. :param args: args from CLI :param kwargs: keyword args """ self._health_servicer = health.HealthServicer(experimental_non_blocking=True) super().__init__(args, **kwargs)
def _run( cls, config: DefaultConfig, target: str, server_credentials: Optional[grpc.ServerCredentials] = None, block: Optional[bool] = None, ): self = cls(config) for bp_cls in self.get_blueprints(): self.register_blueprint(bp_cls) services: Tuple[str, ...] = (reflection.SERVICE_NAME, health.SERVICE_NAME) for name, bp in self.blueprints.items(): services += add_blueprint_to_server(self.config, bp, self) if self.config.GRPC_HEALTH_CHECKING_ENABLE: health_service = health.HealthServicer( experimental_non_blocking=True, experimental_thread_pool=futures.ThreadPoolExecutor( max_workers=self.config. GRPC_HEALTH_CHECKING_THREAD_POOL_NUM), ) health_pb2_grpc.add_HealthServicer_to_server(health_service, self) if self.config.GRPC_SEVER_REFLECTION_ENABLE: reflection.enable_server_reflection(services, self) if block is None: block = self.config.GRPC_SERVER_RUN_WITH_BLOCK self.before_server_start() if server_credentials: self.add_secure_port(target.encode("utf-8"), server_credentials=server_credentials) else: self.add_insecure_port(target.encode("utf-8")) self.start() self.logger.info(f"gRPC server is running on {target}") if block: # pragma: no cover try: while True: time.sleep(_ONE_DAY_IN_SECONDS) except: pass finally: self.stop(0) return self
def add_to_server(self, server): if self.config['enable']: health_servicer = health.HealthServicer( experimental_non_blocking=True) health_servicer.set('', HealthCheckResponse.SERVING) for svc in self.app.service_names: if svc in self.config['not_serving']: status = HealthCheckResponse.NOT_SERVING else: status = HealthCheckResponse.SERVING health_servicer.set(svc, status) health_pb2_grpc.add_HealthServicer_to_server( health_servicer, server)
def create_server(server_address): interceptors = [ExceptionToStatusInterceptor()] server = grpc.server(futures.ThreadPoolExecutor(max_workers=10), interceptors=interceptors) project_pb2_grpc.add_ProjectServicesServicer_to_server( ProjectServicer(), server) # Create a health check servicer. We use the non-blocking implementation # to avoid thread starvation. health_servicer = health.HealthServicer( experimental_non_blocking=True, experimental_thread_pool=futures.ThreadPoolExecutor(max_workers=1)) health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server) port = server.add_insecure_port(server_address) return server, port
def setUp(self): servicer = health.HealthServicer() servicer.set('', health_pb2.HealthCheckResponse.SERVING) servicer.set('grpc.test.TestServiceServing', health_pb2.HealthCheckResponse.SERVING) servicer.set('grpc.test.TestServiceUnknown', health_pb2.HealthCheckResponse.UNKNOWN) servicer.set('grpc.test.TestServiceNotServing', health_pb2.HealthCheckResponse.NOT_SERVING) self._server = test_common.test_server() port = self._server.add_insecure_port('[::]:0') health_pb2_grpc.add_HealthServicer_to_server(servicer, self._server) self._server.start() channel = grpc.insecure_channel('localhost:%d' % port) self._stub = health_pb2_grpc.HealthStub(channel)
def setUp(self): servicer = health.HealthServicer() servicer.set('', health_pb2.HealthCheckResponse.SERVING) servicer.set('grpc.test.TestServiceServing', health_pb2.HealthCheckResponse.SERVING) servicer.set('grpc.test.TestServiceUnknown', health_pb2.HealthCheckResponse.UNKNOWN) servicer.set('grpc.test.TestServiceNotServing', health_pb2.HealthCheckResponse.NOT_SERVING) server_pool = logging_pool.pool(test_constants.THREAD_CONCURRENCY) self._server = grpc.server(server_pool) port = self._server.add_insecure_port('[::]:0') health_pb2.add_HealthServicer_to_server(servicer, self._server) self._server.start() channel = grpc.insecure_channel('localhost:%d' % port) self._stub = health_pb2.HealthStub(channel)
def __init__(self, address: str, *, port: int, register: bool = False, workers: int = 10): thread_pool = ThreadPoolExecutor(max_workers=workers) server = grpc.server(thread_pool) servicer = EventsServicer() events_pb2_grpc.add_EventsServicer_to_server(servicer, server) health_servicer = health.HealthServicer() health_servicer.set('', 'SERVING') health_servicer.set(constants.EVENTS_SERVICE_NAME, 'SERVING') health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server) self._port = server.add_insecure_port(address + ':' + str(port)) self._server = server self._address = address self._config = Config() self._register = register
def start_server(self, non_blocking=False, thread_pool=None): self._thread_pool = thread_pool self._servicer = health.HealthServicer( experimental_non_blocking=non_blocking, experimental_thread_pool=thread_pool) self._servicer.set(_SERVING_SERVICE, health_pb2.HealthCheckResponse.SERVING) self._servicer.set(_UNKNOWN_SERVICE, health_pb2.HealthCheckResponse.UNKNOWN) self._servicer.set(_NOT_SERVING_SERVICE, health_pb2.HealthCheckResponse.NOT_SERVING) self._server = test_common.test_server() port = self._server.add_insecure_port('[::]:0') health_pb2_grpc.add_HealthServicer_to_server( self._servicer, self._server) self._server.start() self._channel = grpc.insecure_channel('localhost:%d' % port) self._stub = health_pb2_grpc.HealthStub(self._channel)
def main(dim, save_path, keys_path, log, debug, updateable, max_workers, nprobe): if log: handler = logging.FileHandler(filename=log) else: handler = logging.StreamHandler(sys.stdout) formatter = logging.Formatter('%(asctime)s:%(levelname)s:%(name)s - %(message)s') handler.setFormatter(formatter) root = logging.getLogger() level = debug and logging.DEBUG or logging.INFO root.setLevel(level) root.addHandler(handler) logging.info('server loading...') logging.info('max workers: %d', max_workers) server = grpc.server(futures.ThreadPoolExecutor(max_workers=max_workers)) health_servicer = health.HealthServicer() health_servicer.set('', health_pb2.HealthCheckResponse.SERVING) health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server) servicer = FaissServer(dim, save_path, keys_path, nprobe) pb2_grpc.add_ServerServicer_to_server(servicer, server) server.add_insecure_port('[::]:50051') server.start() logging.info('server started') def stop_serve(signum, frame): raise KeyboardInterrupt signal.signal(signal.SIGINT, stop_serve) signal.signal(signal.SIGTERM, stop_serve) try: while True: time.sleep(_ONE_DAY_IN_SECONDS) except KeyboardInterrupt: health_servicer.enter_graceful_shutdown() server.stop(0) if updateable: servicer.save() logging.info('server stopped')
def serve(args): server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) health_servicer = health.HealthServicer() health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server) namer_pb2_grpc.add_NamerServicer_to_server(Namer(), server) ca_cert = None client_auth = False if args.ca_cert: ca_cert = open(args.ca_cert, 'rb').read() client_auth = True if args.server_cert and args.server_key: private_key = open(args.server_key, 'rb').read() certificate_chain = open(args.server_cert, 'rb').read() credentials = grpc.ssl_server_credentials( [(private_key, certificate_chain)], root_certificates=ca_cert, require_client_auth=client_auth ) server.add_secure_port('[::]:' + str(args.port), credentials) else: server.add_insecure_port('[::]:' + str(args.port)) if args.metrics_port: print('Starting metrics server. Listening on port {}...'.format( args.metrics_port)) start_http_server(args.metrics_port) print('Starting server. Listening on port {}...'.format(args.port)) server.start() health_servicer.set('', health_pb2.HealthCheckResponse.SERVING) try: while True: time.sleep(86400) except KeyboardInterrupt: health_servicer.set('', health_pb2.HealthCheckResponse.NOT_SERVING) time.sleep(10) server.stop(1)
def _configure_maintenance_server(server: grpc.Server, maintenance_port: int) -> None: channelz.add_channelz_servicer(server) listen_address = f"{_LISTEN_HOST}:{maintenance_port}" server.add_insecure_port(listen_address) health_servicer = grpc_health.HealthServicer( experimental_non_blocking=True, experimental_thread_pool=futures.ThreadPoolExecutor( max_workers=_THREAD_POOL_SIZE)) health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server) SERVICE_NAMES = ( test_pb2.DESCRIPTOR.services_by_name["TestService"].full_name, health_pb2.DESCRIPTOR.services_by_name["Health"].full_name, channelz_pb2.DESCRIPTOR.services_by_name["Channelz"].full_name, reflection.SERVICE_NAME, ) for service in SERVICE_NAMES: health_servicer.set(service, health_pb2.HealthCheckResponse.SERVING) reflection.enable_server_reflection(SERVICE_NAMES, server)
def __init__(self, runner: 'mtap.processing.ProcessingComponent', host: str, port: int = 0, *, register: bool = False, workers: Optional[int] = None, write_address: bool = False, config: 'Optional[mtap.Config]' = None): self.host = host self._port = port self.processor_id = runner.processor_id self.write_address = write_address if config is None: config = _config.Config() self._health_servicer = health.HealthServicer() self._health_servicer.set('', 'SERVING') self._servicer = _ProcessorServicer( config=config, address=host, runner=runner, health_servicer=self._health_servicer, register=register) workers = workers or 10 thread_pool = thread.ThreadPoolExecutor(max_workers=workers) self._server = grpc.server( thread_pool, options=[('grpc.max_send_message_length', config.get('grpc.max_send_message_length')), ('grpc.max_receive_message_length', config.get('grpc.max_receive_message_length'))]) health_pb2_grpc.add_HealthServicer_to_server(self._health_servicer, self._server) processing_pb2_grpc.add_ProcessorServicer_to_server( self._servicer, self._server) self._port = self._server.add_insecure_port("{}:{}".format( self.host, self.port)) self._stopped_event = threading.Event() self._address_file = None
async def launch_server(bind_address, port, server_id): """Start async grpcio server sub process""" server = grpc.aio.server(futures.ThreadPoolExecutor(max_workers=5, )) takeorders_pb2_grpc.add_OrderServicer_to_server( StoreService.Store(server_id, port, API_URL, API_KEY), server) health_servicer = health.HealthServicer( experimental_non_blocking=True, experimental_thread_pool=futures.ThreadPoolExecutor(max_workers=1)) health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server) services = tuple(service.full_name for service in takeorders_pb2.DESCRIPTOR.services_by_name.values()) \ + (reflection.SERVICE_NAME, health.SERVICE_NAME) reflection.enable_server_reflection(services, server) server.add_insecure_port(bind_address) await server.start() # Mark all services as healthy. overall_server_health = "" for service in services + (overall_server_health, ): health_servicer.set(service, health_pb2.HealthCheckResponse.SERVING) await server.wait_for_termination()
def __init__(self, proc: EventProcessor, address: str, port: int = 0, *, register: bool = False, events_address: Optional[str] = None, processor_id: Optional[str] = None, workers: Optional[int] = None, params: Optional[Mapping[str, Any]] = None): self.pr = proc self.address = address self._port = port self.processor_id = processor_id or proc.metadata['name'] self.params = params or {} self.events_address = events_address self._health_servicer = health.HealthServicer() self._health_servicer.set('', 'SERVING') self._servicer = _ProcessorServicer( config=Config(), pr=proc, address=address, health_servicer=self._health_servicer, register=register, processor_id=processor_id, params=params, events_address=events_address) workers = workers or 10 thread_pool = ThreadPoolExecutor(max_workers=workers) self._server = grpc.server(thread_pool) health_pb2_grpc.add_HealthServicer_to_server(self._health_servicer, self._server) processing_pb2_grpc.add_ProcessorServicer_to_server( self._servicer, self._server) self._port = self._server.add_insecure_port("{}:{}".format( self.address, self.port)) self._stopped_event = threading.Event()
def _configure_maintenance_server(server: grpc.Server, maintenance_port: int) -> None: listen_address = f"{_LISTEN_HOST}:{maintenance_port}" server.add_insecure_port(listen_address) # Create a health check servicer. We use the non-blocking implementation # to avoid thread starvation. health_servicer = health.HealthServicer( experimental_non_blocking=True, experimental_thread_pool=futures.ThreadPoolExecutor( max_workers=_THREAD_POOL_SIZE)) # Create a tuple of all of the services we want to export via reflection. services = tuple( service.full_name for service in helloworld_pb2.DESCRIPTOR.services_by_name.values()) + ( reflection.SERVICE_NAME, health.SERVICE_NAME) # Mark all services as healthy. health_pb2_grpc.add_HealthServicer_to_server(health_servicer, server) for service in services: health_servicer.set(service, health_pb2.HealthCheckResponse.SERVING) reflection.enable_server_reflection(services, server)
def __init__(self): self._impls = {} self._health_servicer = health.HealthServicer()
def __init__( self, host="localhost", port=None, socket=None, max_workers=1, loadable_target_origin=None, heartbeat=False, heartbeat_timeout=30, lazy_load_user_code=False, ipc_output_file=None, fixed_server_id=None, ): check.opt_str_param(host, "host") check.opt_int_param(port, "port") check.opt_str_param(socket, "socket") check.int_param(max_workers, "max_workers") check.opt_inst_param(loadable_target_origin, "loadable_target_origin", LoadableTargetOrigin) check.invariant( port is not None if seven.IS_WINDOWS else True, "You must pass a valid `port` on Windows: `socket` not supported.", ) check.invariant( (port or socket) and not (port and socket), "You must pass one and only one of `port` or `socket`.", ) check.invariant( host is not None if port else True, "Must provide a host when serving on a port", ) check.bool_param(heartbeat, "heartbeat") check.int_param(heartbeat_timeout, "heartbeat_timeout") self._ipc_output_file = check.opt_str_param(ipc_output_file, "ipc_output_file") check.opt_str_param(fixed_server_id, "fixed_server_id") check.invariant(heartbeat_timeout > 0, "heartbeat_timeout must be greater than 0") check.invariant( max_workers > 1 if heartbeat else True, "max_workers must be greater than 1 if heartbeat is True", ) self.server = grpc.server(ThreadPoolExecutor(max_workers=max_workers)) self._server_termination_event = threading.Event() self._api_servicer = DagsterApiServer( server_termination_event=self._server_termination_event, loadable_target_origin=loadable_target_origin, heartbeat=heartbeat, heartbeat_timeout=heartbeat_timeout, lazy_load_user_code=lazy_load_user_code, fixed_server_id=fixed_server_id, ) # Create a health check servicer self._health_servicer = health.HealthServicer() health_pb2_grpc.add_HealthServicer_to_server(self._health_servicer, self.server) add_DagsterApiServicer_to_server(self._api_servicer, self.server) if port: server_address = host + ":" + str(port) else: server_address = "unix:" + os.path.abspath(socket) # grpc.Server.add_insecure_port returns: # - 0 on failure # - port number when a port is successfully bound # - 1 when a UDS is successfully bound res = self.server.add_insecure_port(server_address) if socket and res != 1: if self._ipc_output_file: with ipc_write_stream(self._ipc_output_file) as ipc_stream: ipc_stream.send(GrpcServerFailedToBindEvent()) raise CouldNotBindGrpcServerToAddress(socket) if port and res != port: if self._ipc_output_file: with ipc_write_stream(self._ipc_output_file) as ipc_stream: ipc_stream.send(GrpcServerFailedToBindEvent()) raise CouldNotBindGrpcServerToAddress(port)
def __init__( self, host="localhost", port=None, socket=None, max_workers=None, loadable_target_origin=None, heartbeat=False, heartbeat_timeout=30, lazy_load_user_code=False, ipc_output_file=None, fixed_server_id=None, entry_point=None, container_context=None, ): check.opt_str_param(host, "host") check.opt_int_param(port, "port") check.opt_str_param(socket, "socket") check.opt_int_param(max_workers, "max_workers") check.opt_inst_param(loadable_target_origin, "loadable_target_origin", LoadableTargetOrigin) check.invariant( port is not None if seven.IS_WINDOWS else True, "You must pass a valid `port` on Windows: `socket` not supported.", ) check.invariant( (port or socket) and not (port and socket), "You must pass one and only one of `port` or `socket`.", ) check.invariant( host is not None if port else True, "Must provide a host when serving on a port", ) check.bool_param(heartbeat, "heartbeat") check.int_param(heartbeat_timeout, "heartbeat_timeout") self._ipc_output_file = check.opt_str_param(ipc_output_file, "ipc_output_file") check.opt_str_param(fixed_server_id, "fixed_server_id") check.invariant(heartbeat_timeout > 0, "heartbeat_timeout must be greater than 0") check.invariant( max_workers is None or max_workers > 1 if heartbeat else True, "max_workers must be greater than 1 or set to None if heartbeat is True. " "If set to None, the server will use the gRPC default.", ) self.server = grpc.server( ThreadPoolExecutor(max_workers=max_workers), compression=grpc.Compression.Gzip, options=[ ("grpc.max_send_message_length", max_send_bytes()), ("grpc.max_receive_message_length", max_rx_bytes()), ], ) self._server_termination_event = threading.Event() try: self._api_servicer = DagsterApiServer( server_termination_event=self._server_termination_event, loadable_target_origin=loadable_target_origin, heartbeat=heartbeat, heartbeat_timeout=heartbeat_timeout, lazy_load_user_code=lazy_load_user_code, fixed_server_id=fixed_server_id, entry_point=entry_point, container_context=container_context, ) except Exception: if self._ipc_output_file: with ipc_write_stream(self._ipc_output_file) as ipc_stream: ipc_stream.send( GrpcServerLoadErrorEvent( error_info=serializable_error_info_from_exc_info( sys.exc_info()))) raise # Create a health check servicer self._health_servicer = health.HealthServicer() health_pb2_grpc.add_HealthServicer_to_server(self._health_servicer, self.server) add_DagsterApiServicer_to_server(self._api_servicer, self.server) if port: server_address = host + ":" + str(port) else: server_address = "unix:" + os.path.abspath(socket) # grpc.Server.add_insecure_port returns: # - 0 on failure # - port number when a port is successfully bound # - 1 when a UDS is successfully bound res = self.server.add_insecure_port(server_address) if socket and res != 1: if self._ipc_output_file: with ipc_write_stream(self._ipc_output_file) as ipc_stream: ipc_stream.send(GrpcServerFailedToBindEvent()) raise CouldNotBindGrpcServerToAddress(socket) if port and res != port: if self._ipc_output_file: with ipc_write_stream(self._ipc_output_file) as ipc_stream: ipc_stream.send(GrpcServerFailedToBindEvent()) raise CouldNotBindGrpcServerToAddress(port)
def __init__(self, tmp_dir="/tmp"): self._impls = {} self._health_servicer = health.HealthServicer() self.tmp_dir = tmp_dir
def __init__( self, args: argparse.Namespace, **kwargs, ): """Initialize grpc server for the head runtime. :param args: args from CLI :param kwargs: keyword args """ self._health_servicer = health.HealthServicer( experimental_non_blocking=True) super().__init__(args, **kwargs) if args.name is None: args.name = '' self.name = args.name self._deployment_name = os.getenv('JINA_DEPLOYMENT_NAME', 'worker') self.connection_pool = GrpcConnectionPool( logger=self.logger, compression=args.compression, metrics_registry=self.metrics_registry, ) self._retries = self.args.retries if self.metrics_registry: with ImportExtensions( required=True, help_text= 'You need to install the `prometheus_client` to use the montitoring functionality of jina', ): from prometheus_client import Summary self._summary = (Summary( 'receiving_request_seconds', 'Time spent processing request', registry=self.metrics_registry, namespace='jina', labelnames=('runtime_name', ), ).labels(self.args.name).time()) else: self._summary = contextlib.nullcontext() polling = getattr(args, 'polling', self.DEFAULT_POLLING.name) try: # try loading the polling args as json endpoint_polling = json.loads(polling) # '*' is used a wildcard and will match all endpoints, except /index, /search and explicitly defined endpoins default_polling = (PollingType.from_string(endpoint_polling['*']) if '*' in endpoint_polling else self.DEFAULT_POLLING) self._polling = self._default_polling_dict(default_polling) for endpoint in endpoint_polling: self._polling[endpoint] = PollingType( endpoint_polling[endpoint] if type( endpoint_polling[endpoint]) == int else PollingType. from_string(endpoint_polling[endpoint])) except (ValueError, TypeError): # polling args is not a valid json, try interpreting as a polling enum type default_polling = (polling if type(polling) == PollingType else PollingType.from_string(polling)) self._polling = self._default_polling_dict(default_polling) if hasattr(args, 'connection_list') and args.connection_list: connection_list = json.loads(args.connection_list) for shard_id in connection_list: shard_connections = connection_list[shard_id] if isinstance(shard_connections, str): self.connection_pool.add_connection( deployment=self._deployment_name, address=shard_connections, shard_id=int(shard_id), ) else: for connection in shard_connections: self.connection_pool.add_connection( deployment=self._deployment_name, address=connection, shard_id=int(shard_id), ) self.uses_before_address = args.uses_before_address self.timeout_send = args.timeout_send if self.timeout_send: self.timeout_send /= 1e3 # convert ms to seconds if self.uses_before_address: self.connection_pool.add_connection( deployment='uses_before', address=self.uses_before_address) self.uses_after_address = args.uses_after_address if self.uses_after_address: self.connection_pool.add_connection( deployment='uses_after', address=self.uses_after_address) self._reduce = not args.disable_reduce