def str_to_schema(raw_schema):
file_descriptor_proto = descriptor_pb2.FileDescriptorProto.FromString(
raw_schema)
descriptor_pool = DescriptorPool()
descriptor_pool.Add(file_descriptor_proto)
name = file_descriptor_proto.name
descriptor_person = descriptor_pool.FindMessageTypeByName(
'tutorial.Person')
descriptor_addressbook = descriptor_pool.FindMessageTypeByName(
'tutorial.AddressBook')
descriptor_phonenumber = descriptor_pool.FindMessageTypeByName(
'tutorial.Person.PhoneNumber')
person_class = MessageFactory().GetPrototype(descriptor_person)
addressbook_class = MessageFactory().GetPrototype(descriptor_addressbook)
phonenumber_class = MessageFactory().GetPrototype(descriptor_phonenumber)
# A different way to extract types from the proto
# messages_type_dic = message_factory.GetMessages([file_descriptor_proto])
# # messages_type_dic only contain 'tutorial.Person' and 'tutorial.AddressBook'
# assert len(messages_type_dic) == 2
# assert 'tutorial.Person' in messages_type_dic
# assert 'tutorial.AddressBook' in messages_type_dic
# person_class = messages_type_dic['tutorial.Person']
# addressbook_class = messages_type_dic['tutorial.AddressBook']
# person_instance = person_class()
# addressbook_instance = addressbook_class()
# return person_class, addressbook_class
return person_class, addressbook_class, phonenumber_class
def create_expression_from_file_descriptor_set(tensor_of_protos,
proto_name,
file_descriptor_set,
message_format="binary"):
"""Create an expression from a 1D tensor of serialized protos.
Args:
tensor_of_protos: 1D tensor of serialized protos.
proto_name: fully qualified name (e.g. "some.package.SomeProto") of the
proto in `tensor_of_protos`.
file_descriptor_set: The FileDescriptorSet proto containing `proto_name`'s
and all its dependencies' FileDescriptorProto. Note that if file1 imports
file2, then file2's FileDescriptorProto must precede file1's in
file_descriptor_set.file.
message_format: Indicates the format of the protocol buffer: is one of
'text' or 'binary'.
Returns:
An expression.
"""
pool = DescriptorPool()
for f in file_descriptor_set.file:
# This method raises if f's dependencies have not been added.
pool.Add(f)
# This method raises if proto not found.
desc = pool.FindMessageTypeByName(proto_name)
return create_expression_from_proto(tensor_of_protos, desc, message_format)
def str_to_schema(raw_schema):
file_descriptor_proto = descriptor_pb2.FileDescriptorProto.FromString(
raw_schema)
descriptor_pool = DescriptorPool()
descriptor_pool.Add(file_descriptor_proto)
# message_descriptors = []
# for message_type in file_descriptor_proto.message_type:
# print(message_type)
# # The following line would raise error asking to import
# message_descriptors.append(descriptor.MakeDescriptor(message_type))
name = file_descriptor_proto.name
file_descriptor = descriptor_pool.FindFileByName(name)
descriptor1 = descriptor_pool.FindMessageTypeByName('tutorial.Person')
descriptor2 = descriptor_pool.FindMessageTypeByName('tutorial.AddressBook')
descriptor3 = descriptor_pool.FindMessageTypeByName(
'tutorial.Person.PhoneNumber')
return descriptor1, descriptor2, descriptor3
class ProtoFactory:
def __init__(self, platform_delegate: PlatformDelegate):
# Declare descriptor pool
self.descriptor_pool = DescriptorPool()
# Load trace processor descriptor and add to descriptor pool
tp_desc = platform_delegate.get_resource('trace_processor.descriptor')
tp_file_desc_set_pb2 = descriptor_pb2.FileDescriptorSet()
tp_file_desc_set_pb2.MergeFromString(tp_desc)
for f_desc_pb2 in tp_file_desc_set_pb2.file:
self.descriptor_pool.Add(f_desc_pb2)
# Load metrics descriptor and add to descriptor pool
metrics_desc = platform_delegate.get_resource('metrics.descriptor')
metrics_file_desc_set_pb2 = descriptor_pb2.FileDescriptorSet()
metrics_file_desc_set_pb2.MergeFromString(metrics_desc)
for f_desc_pb2 in metrics_file_desc_set_pb2.file:
self.descriptor_pool.Add(f_desc_pb2)
def create_message_factory(message_type):
message_desc = self.descriptor_pool.FindMessageTypeByName(
message_type)
return message_factory.MessageFactory().GetPrototype(message_desc)
# Create proto messages to correctly communicate with the RPC API by sending
# and receiving data as protos
self.AppendTraceDataResult = create_message_factory(
'perfetto.protos.AppendTraceDataResult')
self.StatusResult = create_message_factory(
'perfetto.protos.StatusResult')
self.ComputeMetricArgs = create_message_factory(
'perfetto.protos.ComputeMetricArgs')
self.ComputeMetricResult = create_message_factory(
'perfetto.protos.ComputeMetricResult')
self.RawQueryArgs = create_message_factory(
'perfetto.protos.RawQueryArgs')
self.QueryResult = create_message_factory(
'perfetto.protos.QueryResult')
self.TraceMetrics = create_message_factory(
'perfetto.protos.TraceMetrics')
self.DisableAndReadMetatraceResult = create_message_factory(
'perfetto.protos.DisableAndReadMetatraceResult')
self.CellsBatch = create_message_factory(
'perfetto.protos.QueryResult.CellsBatch')
class ReflectionClientTest(unittest.TestCase):
def setUp(self):
self._server = test_common.test_server()
self._SERVICE_NAMES = (
test_pb2.DESCRIPTOR.services_by_name["TestService"].full_name,
reflection.SERVICE_NAME,
)
reflection.enable_server_reflection(self._SERVICE_NAMES, self._server)
port = self._server.add_insecure_port("[::]:0")
self._server.start()
self._channel = grpc.insecure_channel("localhost:%d" % port)
self._reflection_db = ProtoReflectionDescriptorDatabase(self._channel)
self.desc_pool = DescriptorPool(self._reflection_db)
def tearDown(self):
self._server.stop(None)
self._channel.close()
def testListServices(self):
services = self._reflection_db.get_services()
self.assertCountEqual(self._SERVICE_NAMES, services)
def testReflectionServiceName(self):
self.assertEqual(reflection.SERVICE_NAME,
"grpc.reflection.v1alpha.ServerReflection")
def testFindFile(self):
file_name = _PROTO_FILE_NAME
file_desc = self.desc_pool.FindFileByName(file_name)
self.assertEqual(file_name, file_desc.name)
self.assertEqual(_PROTO_PACKAGE_NAME, file_desc.package)
self.assertEqual("proto3", file_desc.syntax)
self.assertIn("TestService", file_desc.services_by_name)
file_name = _EMPTY_PROTO_FILE_NAME
file_desc = self.desc_pool.FindFileByName(file_name)
self.assertEqual(file_name, file_desc.name)
self.assertEqual(_PROTO_PACKAGE_NAME, file_desc.package)
self.assertEqual("proto3", file_desc.syntax)
self.assertIn("Empty", file_desc.message_types_by_name)
def testFindFileError(self):
with self.assertRaises(KeyError):
self.desc_pool.FindFileByName(_INVALID_FILE_NAME)
def testFindMessage(self):
message_name = _EMPTY_PROTO_SYMBOL_NAME
message_desc = self.desc_pool.FindMessageTypeByName(message_name)
self.assertEqual(message_name, message_desc.full_name)
self.assertTrue(message_name.endswith(message_desc.name))
def testFindMessageError(self):
with self.assertRaises(KeyError):
self.desc_pool.FindMessageTypeByName(_INVALID_SYMBOL_NAME)
def testFindServiceFindMethod(self):
service_name = self._SERVICE_NAMES[0]
service_desc = self.desc_pool.FindServiceByName(service_name)
self.assertEqual(service_name, service_desc.full_name)
self.assertTrue(service_name.endswith(service_desc.name))
file_name = _PROTO_FILE_NAME
file_desc = self.desc_pool.FindFileByName(file_name)
self.assertIs(file_desc, service_desc.file)
method_name = "EmptyCall"
self.assertIn(method_name, service_desc.methods_by_name)
method_desc = service_desc.FindMethodByName(method_name)
self.assertIs(method_desc, service_desc.methods_by_name[method_name])
self.assertIs(service_desc, method_desc.containing_service)
self.assertEqual(method_name, method_desc.name)
self.assertTrue(method_desc.full_name.endswith(method_name))
empty_message_desc = self.desc_pool.FindMessageTypeByName(
_EMPTY_PROTO_SYMBOL_NAME)
self.assertEqual(empty_message_desc, method_desc.input_type)
self.assertEqual(empty_message_desc, method_desc.output_type)
def testFindServiceError(self):
with self.assertRaises(KeyError):
self.desc_pool.FindServiceByName(_INVALID_SYMBOL_NAME)
def testFindMethodError(self):
service_name = self._SERVICE_NAMES[0]
service_desc = self.desc_pool.FindServiceByName(service_name)
# FindMethodByName sometimes raises a KeyError, and sometimes returns None.
# See https://github.com/protocolbuffers/protobuf/issues/9592
with self.assertRaises(KeyError):
res = service_desc.FindMethodByName(_INVALID_SYMBOL_NAME)
if res is None:
raise KeyError()
def testFindExtensionNotImplemented(self):
"""
Extensions aren't implemented in Protobuf for Python.
For now, simply assert that indeed they don't work.
"""
message_name = _EMPTY_EXTENSIONS_SYMBOL_NAME
message_desc = self.desc_pool.FindMessageTypeByName(message_name)
self.assertEqual(message_name, message_desc.full_name)
self.assertTrue(message_name.endswith(message_desc.name))
extension_field_descs = self.desc_pool.FindAllExtensions(message_desc)
self.assertEqual(0, len(extension_field_descs))
with self.assertRaises(KeyError):
self.desc_pool.FindExtensionByName(message_name)
class LogReader(object):
"""
File-like interface for binary logs.
>>> with LogReader("path/to/log/file.gz") as log:
... for item in log.items():
... print(entry.type)
... print(entry.value.some.nested.object)
... print()
>>> with LogReader("path/to/log/file.gz") as log:
... for value in log.values():
... print(value.some.nested.object)
... print()
"""
def __init__(self, path):
self._log_reader = _LogReader(path)
# header
header_ = self._log_reader.header
fd_set = FileDescriptorSet()
fd_set.ParseFromString(header_.proto)
self._header = Header(proto=fd_set, types=header_.types)
# descriptors
self._pool = DescriptorPool()
for proto in self._header.proto.file:
self._pool.Add(proto)
self._factory = MessageFactory()
@property
def path(self):
"""Log path."""
return self._log_reader.path
@property
def header(self):
"""Log header."""
return self._header
def __repr__(self):
return repr(self._log_reader)
def items(self):
"""Return iterator to log items."""
this = self
class Iterator(object):
def __iter__(self):
return self
def next(self):
return this._next()
return Iterator()
def values(self):
"""Return iterator to log values."""
this = self
class Iterator(object):
def __iter__(self):
return self
def next(self):
return this._next().value
return Iterator()
def _next(self):
next_ = self._log_reader.next()
descriptor = self._pool.FindMessageTypeByName(next_.type)
value = self._factory.GetPrototype(descriptor)()
value.ParseFromString(next_.data)
return LogItem(next_.type, value)
def read(self):
"""Return None on EOF."""
try:
return self._next().value
except StopIteration:
return None
def close(self):
"""Closes LogReader. LogReader will take EOF state."""
self._log_reader.close()
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
self.close()
