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
