def __init__(self, endpoint, symbol_db=None, descriptor_pool=None, lazy=False, ssl=False, compression=None, **kwargs): super().__init__(endpoint, symbol_db, descriptor_pool, ssl=ssl, compression=compression) self._service_names: list = None self._lazy = lazy self.reflection_stub = reflection_pb2_grpc.ServerReflectionStub( self.channel) self.registered_file_names = set() self.has_server_registered = False self._services_module_name = {} self._service_methods_meta: Dict[str, Dict[str, MethodMetaData]] = {} self._unary_unary_handler = {} self._unary_stream_handler = {} self._stream_unary_handler = {} self._stream_stream_handler = {} if not self._lazy: self.register_all_service()
async def setUp(self): self._server = aio.server() reflection.enable_server_reflection(_SERVICE_NAMES, self._server) port = self._server.add_insecure_port('[::]:0') await self._server.start() self._channel = aio.insecure_channel('localhost:%d' % port) self._stub = reflection_pb2_grpc.ServerReflectionStub(self._channel)
def reflection_request(channel, requests): stub = reflection_pb2_grpc.ServerReflectionStub(channel) responses = stub.ServerReflectionInfo(make_request(requests)) try: for resp in responses: yield resp except grpc._channel._Rendezvous as err: print(err)
def setUp(self): self._server = test_common.test_server() reflection.enable_server_reflection(_SERVICE_NAMES, self._server) port = self._server.add_insecure_port('[::]:0') self._server.start() channel = grpc.insecure_channel('localhost:%d' % port) self._stub = reflection_pb2_grpc.ServerReflectionStub(channel)
def setUp(self): server_pool = logging_pool.pool(test_constants.THREAD_CONCURRENCY) self._server = grpc.server(server_pool) reflection.enable_server_reflection(_SERVICE_NAMES, self._server) port = self._server.add_insecure_port('[::]:0') self._server.start() channel = grpc.insecure_channel('localhost:%d' % port) self._stub = reflection_pb2_grpc.ServerReflectionStub(channel)
def _get_server_reflection_info(self): reflection_stub = reflection_pb2_grpc.ServerReflectionStub(self._channel) # List Services message = reflection_pb2.ServerReflectionRequest(list_services='') responses = reflection_stub.ServerReflectionInfo(iter((message,))) for response in responses: for service in response.list_services_response.service: self._get_file_descriptor(reflection_stub, service)
def build_database_from_channel(channel): """Build descriptor pool and symbol database from reflection service. Args: channel: GRPC channel Returns: tuple (descriptor pool, symbol database) """ reflection_client = reflection_pb2_grpc.ServerReflectionStub(channel) return build_database_from_stub(reflection_client)
def list_services(channel): """Get list of fully qualified service names via reflection. Args: channel (grpc.Channel): The RPC channel to use. Raises: ServiceError: Reflection service responded with an error. grpc.RpcError: Lower level RPC error. """ stub = reflection_pb2_grpc.ServerReflectionStub(channel) return list(_list_services(stub))
def serve(): server = grpc.server(futures.ThreadPoolExecutor(max_workers=10)) greeter = Greeter() helloworld_pb2_grpc.add_GreeterServicer_to_server(greeter, server) server.add_insecure_port(listen_address) reflection.enable_server_reflection(["helloworld.Greeter"], server) server.start() channel = grpc.insecure_channel('localhost:%d' % 50051) reflection_pb2_grpc.ServerReflectionStub(channel) try: print("Server started, listening on: {}".format(listen_address)) while True: time.sleep(_ONE_DAY_IN_SECONDS) except KeyboardInterrupt: server.stop(0)
def __init__(self, endpoint, symbol_db=None, descriptor_pool=None, lazy=False, ssl=False, compression=None, **kwargs): super().__init__(endpoint, symbol_db, descriptor_pool, ssl=ssl, lazy=lazy, compression=compression, **kwargs) self.reflection_stub = reflection_pb2_grpc.ServerReflectionStub( self.channel) self.registered_file_names = set() if not self._lazy: self.register_all_service()
def load_protocols(self, channel, filenames=None, symbols=None): """Implementation of `GrpcReflectionClient.load_protocols`""" stub = reflection_pb2_grpc.ServerReflectionStub(channel) requests = [] if filenames: requests.extend( reflection_pb2.ServerReflectionRequest(file_by_filename=name) for name in filenames) if symbols: requests.extend( reflection_pb2.ServerReflectionRequest( file_containing_symbol=symbol) for symbol in symbols) if not requests: requests.extend( reflection_pb2.ServerReflectionRequest( file_containing_symbol=name) for name in _list_services(stub) if name != "grpc.reflection.v1alpha.ServerReflection") protos = {} traversed = set() while requests: responses = stub.ServerReflectionInfo(iter(requests), timeout=QUERY_TIMEOUT) deps = set() for response in responses: if response.HasField("error_response"): raise ServiceError(response.error_response.error_message) for desc_bytes in response.file_descriptor_response.file_descriptor_proto: proto = descriptor_pb2.FileDescriptorProto.FromString( # pylint: disable=no-member desc_bytes) traversed.add(proto.name) deps.update(proto.dependency) protos[proto.name] = proto self.methods_by_file[proto.name] = { service.name: service.method for service in proto.service } deps -= traversed requests = [ reflection_pb2.ServerReflectionRequest(file_by_filename=dep) for dep in deps ] # prevent unsatisfied deps from looping forever traversed.update(deps) names = deque(protos.keys()) traversed = set() while names: name = names[0] traversed.add(name) # raises KeyError if unsatisfied dep: proto = protos[name] deps = set(proto.dependency) - traversed if deps: names = deque(x for x in names if x not in deps) names.extendleft(deps) else: del names[0] self.pool.Add(proto) return protos.keys()