def _run(args: argparse.Namespace, methods: Sequence[str], per_method_metadata: PerMethodMetadataType) -> None: logger.info("Starting python xDS Interop Client.") global _global_server # pylint: disable=global-statement method_handles = [] channel_configs = {} for method in _SUPPORTED_METHODS: if method in methods: qps = args.qps else: qps = 0 channel_config = _ChannelConfiguration( method, per_method_metadata.get(method, []), qps, args.server, args.rpc_timeout_sec, args.print_response, args.secure_mode) channel_configs[method] = channel_config method_handles.append(_MethodHandle(args.num_channels, channel_config)) _global_server = grpc.server(futures.ThreadPoolExecutor()) _global_server.add_insecure_port(f"0.0.0.0:{args.stats_port}") test_pb2_grpc.add_LoadBalancerStatsServiceServicer_to_server( _LoadBalancerStatsServicer(), _global_server) test_pb2_grpc.add_XdsUpdateClientConfigureServiceServicer_to_server( _XdsUpdateClientConfigureServicer(channel_configs, args.qps), _global_server) channelz.add_channelz_servicer(_global_server) _global_server.start() _global_server.wait_for_termination() for method_handle in method_handles: method_handle.stop()
def create_server(addr, failure_rate): server = grpc.server(futures.ThreadPoolExecutor()) helloworld_pb2_grpc.add_GreeterServicer_to_server( FaultInjectGreeter(failure_rate), server) # Add Channelz Servicer to the gRPC server channelz.add_channelz_servicer(server) server.add_insecure_port(addr) return server
def create_server(addr: str, failure_rate: float) -> grpc.aio.Server: server = grpc.aio.server() helloworld_pb2_grpc.add_GreeterServicer_to_server( FaultInjectGreeter(failure_rate), server) # Add Channelz Servicer to the gRPC server channelz.add_channelz_servicer(server) server.add_insecure_port(addr) return server
async def setUp(self): # This server is for Channelz info fetching only # It self should not enable Channelz self._server = aio.server(options=_DISABLE_REUSE_PORT + _DISABLE_CHANNELZ) port = self._server.add_insecure_port('[::]:0') channelz.add_channelz_servicer(self._server) await self._server.start() # This channel is used to fetch Channelz info only # Channelz should not be enabled self._channel = aio.insecure_channel('localhost:%d' % port, options=_DISABLE_CHANNELZ) self._channelz_stub = channelz_pb2_grpc.ChannelzStub(self._channel)
def setUp(self): self._pairs = [] # This server is for Channelz info fetching only # It self should not enable Channelz self._server = grpc.server(futures.ThreadPoolExecutor(max_workers=3), options=_DISABLE_REUSE_PORT + _DISABLE_CHANNELZ) port = self._server.add_insecure_port('[::]:0') channelz.add_channelz_servicer(self._server) self._server.start() # This channel is used to fetch Channelz info only # Channelz should not be enabled self._channel = grpc.insecure_channel('localhost:%d' % port, _DISABLE_CHANNELZ) self._channelz_stub = channelz_pb2_grpc.ChannelzStub(self._channel)
def setUp(self): self._pairs = [] # This server is for Channelz info fetching only # It self should not enable Channelz self._server = grpc.server( futures.ThreadPoolExecutor(max_workers=3), options=_DISABLE_REUSE_PORT + _DISABLE_CHANNELZ) port = self._server.add_insecure_port('[::]:0') channelz.add_channelz_servicer(self._server) self._server.start() # This channel is used to fetch Channelz info only # Channelz should not be enabled self._channel = grpc.insecure_channel('localhost:%d' % port, _DISABLE_CHANNELZ) self._channelz_stub = channelz_pb2_grpc.ChannelzStub(self._channel)
def add_admin_servicers(server): """Register admin servicers to a server. gRPC provides some predefined admin services to make debugging easier by exposing gRPC's internal states. Each existing admin service is packaged as a separate library, and the documentation of the predefined admin services is usually scattered. It can be time consuming to get the dependency management, module initialization, and library import right for each one of them. This API provides a convenient way to create a gRPC server to expose admin services. With this, any new admin services that you may add in the future are automatically available via the admin interface just by upgrading your gRPC version. Args: server: A gRPC server to which all admin services will be added. """ channelz.add_channelz_servicer(server) grpc_csds.add_csds_servicer(server)
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)
# There should be always more than one socket connected to the server if len(sockets.socket_ref) == 1: number_of_failures += 1 else: number_of_failures = 0 # Sleep for 2 seconds before polling next time time.sleep(2) if __name__ == "__main__": signal_received = False FLAGS = parse_startup_arguments() server = grpc.server(futures.ThreadPoolExecutor(max_workers=1)) channelz.add_channelz_servicer(server) # Create an Event to keep the GRPC server running event = threading.Event() python_host = PythonHost(module_path=FLAGS.model_path) add_PythonInterpreterServicer_to_server(python_host, server) def interrupt_handler(signum, frame): pass def sigterm_handler(signum, frame): global signal_received if not signal_received: signal_received = True else: return