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()
