This commit consists of:
1) Dockerizing the netconf server
2) Update proto2yang to support module imports
3) Provide a set of yang modules derived from the proto files in voltha.
These files as well as the slight mmodifications to the proto files are
provided in the experiments/netconf/proto2yang directory
4) Code to automatically pull proto files from voltha into the netconf server,
compiles them and produce the yang equivalent files.
5) Add a getvoltha netconf API to provide voltha state information (basic at
this time). There is potential to make this generic once we experiment
with additional APIs
Change-Id: I94f3a1f871b8025ad675d5f9b9b626d1be8b8d36
diff --git a/experiments/netconf/proto2yang/ietf-descriptor.yang b/experiments/netconf/proto2yang/ietf-descriptor.yang
new file mode 100644
index 0000000..487f100
--- /dev/null
+++ b/experiments/netconf/proto2yang/ietf-descriptor.yang
@@ -0,0 +1,1331 @@
+
+module ietf-descriptor {
+
+
+ namespace "urn:opencord:params:xml:ns:voltha:ietf-descriptor";
+ prefix descriptor;
+
+
+ organization "CORD";
+ contact
+ " Any name";
+
+ description
+ "";
+
+ revision "2016-11-15" {
+ description "Initial revision.";
+ reference "reference";
+ }
+
+
+ container FileDescriptorSet {
+ description
+ "The protocol compiler can output a FileDescriptorSet containing the .proto
+ files it parses.";
+ list file {
+ key "name";
+ uses FileDescriptorProto;
+
+ description
+ "";
+ }
+
+ }
+
+ grouping FileDescriptorProto {
+ description
+ "Describes a complete .proto file.";
+ leaf name {
+ type string;
+ description
+ "file name, relative to root of source tree";
+ }
+
+ leaf package {
+ type string;
+ description
+ "e.g. foo , foo.bar , etc.";
+ }
+
+ list dependency {
+ key "dependency";
+ leaf dependency {
+ type string;
+ description
+ "Names of files imported by this file.";
+ }
+ description
+ "Names of files imported by this file.";
+ }
+
+ list public_dependency {
+ key "public_dependency";
+ leaf public_dependency {
+ type int32;
+ description
+ "Indexes of the public imported files in the dependency list above.";
+ }
+ description
+ "Indexes of the public imported files in the dependency list above.";
+ }
+
+ list weak_dependency {
+ key "weak_dependency";
+ leaf weak_dependency {
+ type int32;
+ description
+ "Indexes of the weak imported files in the dependency list.
+ For Google-internal migration only. Do not use.";
+ }
+ description
+ "Indexes of the weak imported files in the dependency list.
+ For Google-internal migration only. Do not use.";
+ }
+
+ list message_type {
+ key "name";
+ uses DescriptorProto;
+
+ description
+ "All top-level definitions in this file.";
+ }
+
+ list enum_type {
+ key "name";
+ uses EnumDescriptorProto;
+
+ description
+ "";
+ }
+
+ list service {
+ key "name";
+ uses ServiceDescriptorProto;
+
+ description
+ "";
+ }
+
+ list extension {
+ key "name";
+ uses FieldDescriptorProto;
+
+ description
+ "";
+ }
+
+ container options {
+ uses FileOptions;
+
+ description
+ "";
+ }
+
+ container source_code_info {
+ uses SourceCodeInfo;
+
+ description
+ "This field contains optional information about the original source code.
+ You may safely remove this entire field without harming runtime
+ functionality of the descriptors -- the information is needed only by
+ development tools.";
+ }
+
+ leaf syntax {
+ type string;
+ description
+ "The syntax of the proto file.
+ The supported values are proto2 and proto3 .";
+ }
+
+ }
+
+ grouping DescriptorProto {
+ description
+ "Describes a message type.";
+ leaf name {
+ type string;
+ description
+ "";
+ }
+
+ list field {
+ key "name";
+ uses FieldDescriptorProto;
+
+ description
+ "";
+ }
+
+ list extension {
+ key "name";
+ uses FieldDescriptorProto;
+
+ description
+ "";
+ }
+
+ list nested_type {
+ key "name";
+ uses DescriptorProto;
+
+ description
+ "";
+ }
+
+ list enum_type {
+ key "name";
+ uses EnumDescriptorProto;
+
+ description
+ "";
+ }
+
+
+ list oneof_decl {
+ key "name";
+ uses OneofDescriptorProto;
+
+ description
+ "";
+ }
+
+ container options {
+ uses MessageOptions;
+
+ description
+ "";
+ }
+
+
+ list reserved_name {
+ key "reserved_name";
+ leaf reserved_name {
+ type string;
+ description
+ "Reserved field names, which may not be used by fields in the same message.
+ A given name may only be reserved once.";
+ }
+ description
+ "Reserved field names, which may not be used by fields in the same message.
+ A given name may only be reserved once.";
+ }
+
+ grouping ExtensionRange {
+ description
+ "";
+ leaf start {
+ type int32;
+ description
+ "";
+ }
+
+ leaf end {
+ type int32;
+ description
+ "";
+ }
+
+ }
+
+ grouping ReservedRange {
+ description
+ "Range of reserved tag numbers. Reserved tag numbers may not be used by
+ fields or extension ranges in the same message. Reserved ranges may
+ not overlap.";
+ leaf start {
+ type int32;
+ description
+ "Inclusive.";
+ }
+
+ leaf end {
+ type int32;
+ description
+ "Exclusive.";
+ }
+
+ }
+
+ }
+
+ grouping FieldDescriptorProto {
+ description
+ "Describes a field within a message.";
+ leaf name {
+ type string;
+ description
+ "";
+ }
+
+ leaf number {
+ type int32;
+ description
+ "";
+ }
+
+ leaf label {
+ type Label;
+ description
+ "";
+ }
+
+ leaf type {
+ type Type;
+ description
+ "If type_name is set, this need not be set. If both this and type_name
+ are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.";
+ }
+
+ leaf type_name {
+ type string;
+ description
+ "For message and enum types, this is the name of the type. If the name
+ starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
+ rules are used to find the type (i.e. first the nested types within this
+ message are searched, then within the parent, on up to the root
+ namespace).";
+ }
+
+ leaf extendee {
+ type string;
+ description
+ "For extensions, this is the name of the type being extended. It is
+ resolved in the same manner as type_name.";
+ }
+
+ leaf default_value {
+ type string;
+ description
+ "For numeric types, contains the original text representation of the value.
+ For booleans, true or false .
+ For strings, contains the default text contents (not escaped in any way).
+ For bytes, contains the C escaped value. All bytes >= 128 are escaped.
+ TODO(kenton): Base-64 encode?";
+ }
+
+ leaf oneof_index {
+ type int32;
+ description
+ "If set, gives the index of a oneof in the containing type's oneof_decl
+ list. This field is a member of that oneof.";
+ }
+
+ leaf json_name {
+ type string;
+ description
+ "JSON name of this field. The value is set by protocol compiler. If the
+ user has set a json_name option on this field, that option's value
+ will be used. Otherwise, it's deduced from the field's name by converting
+ it to camelCase.";
+ }
+
+ container options {
+ uses FieldOptions;
+
+ description
+ "";
+ }
+
+ typedef Type {
+ type enumeration {
+ enum TYPE_DOUBLE {
+ description "";
+ }
+ enum TYPE_FLOAT {
+ description "";
+ }
+ enum TYPE_INT64 {
+ description "";
+ }
+ enum TYPE_UINT64 {
+ description "";
+ }
+ enum TYPE_INT32 {
+ description "";
+ }
+ enum TYPE_FIXED64 {
+ description "";
+ }
+ enum TYPE_FIXED32 {
+ description "";
+ }
+ enum TYPE_BOOL {
+ description "";
+ }
+ enum TYPE_STRING {
+ description "";
+ }
+ enum TYPE_GROUP {
+ description "";
+ }
+ enum TYPE_MESSAGE {
+ description "";
+ }
+ enum TYPE_BYTES {
+ description "";
+ }
+ enum TYPE_UINT32 {
+ description "";
+ }
+ enum TYPE_ENUM {
+ description "";
+ }
+ enum TYPE_SFIXED32 {
+ description "";
+ }
+ enum TYPE_SFIXED64 {
+ description "";
+ }
+ enum TYPE_SINT32 {
+ description "";
+ }
+ enum TYPE_SINT64 {
+ description "";
+ }
+ }
+ description
+ "";
+ }
+
+ typedef Label {
+ type enumeration {
+ enum LABEL_OPTIONAL {
+ description "";
+ }
+ enum LABEL_REQUIRED {
+ description "";
+ }
+ enum LABEL_REPEATED {
+ description "";
+ }
+ }
+ description
+ "";
+ }
+
+ }
+
+ grouping OneofDescriptorProto {
+ description
+ "Describes a oneof.";
+ leaf name {
+ type string;
+ description
+ "";
+ }
+
+ container options {
+ uses OneofOptions;
+
+ description
+ "";
+ }
+
+ }
+
+ grouping EnumDescriptorProto {
+ description
+ "Describes an enum type.";
+ leaf name {
+ type string;
+ description
+ "";
+ }
+
+ list value {
+ key "name";
+ uses EnumValueDescriptorProto;
+
+ description
+ "";
+ }
+
+ container options {
+ uses EnumOptions;
+
+ description
+ "";
+ }
+
+ }
+
+ grouping EnumValueDescriptorProto {
+ description
+ "Describes a value within an enum.";
+ leaf name {
+ type string;
+ description
+ "";
+ }
+
+ leaf number {
+ type int32;
+ description
+ "";
+ }
+
+ container options {
+ uses EnumValueOptions;
+
+ description
+ "";
+ }
+
+ }
+
+ grouping ServiceDescriptorProto {
+ description
+ "Describes a service.";
+ leaf name {
+ type string;
+ description
+ "";
+ }
+
+ list method {
+ key "name";
+ uses MethodDescriptorProto;
+
+ description
+ "";
+ }
+
+ container options {
+ uses ServiceOptions;
+
+ description
+ "";
+ }
+
+ }
+
+ grouping MethodDescriptorProto {
+ description
+ "Describes a method of a service.";
+ leaf name {
+ type string;
+ description
+ "";
+ }
+
+ leaf input_type {
+ type string;
+ description
+ "Input and output type names. These are resolved in the same way as
+ FieldDescriptorProto.type_name, but must refer to a message type.";
+ }
+
+ leaf output_type {
+ type string;
+ description
+ "";
+ }
+
+ container options {
+ uses MethodOptions;
+
+ description
+ "";
+ }
+
+ leaf client_streaming {
+ type boolean;
+ description
+ "Identifies if client streams multiple client messages";
+ }
+
+ leaf server_streaming {
+ type boolean;
+ description
+ "Identifies if server streams multiple server messages";
+ }
+
+ }
+
+ grouping FileOptions {
+ description
+ "===================================================================
+ Options
+Each of the definitions above may have options attached. These are
+ just annotations which may cause code to be generated slightly differently
+ or may contain hints for code that manipulates protocol messages.
+
+ Clients may define custom options as extensions of the Options messages.
+ These extensions may not yet be known at parsing time, so the parser cannot
+ store the values in them. Instead it stores them in a field in the Options
+ message called uninterpreted_option. This field must have the same name
+ across all Options messages. We then use this field to populate the
+ extensions when we build a descriptor, at which point all protos have been
+ parsed and so all extensions are known.
+
+ Extension numbers for custom options may be chosen as follows:
+ For options which will only be used within a single application or
+ organization, or for experimental options, use field numbers 50000
+ through 99999. It is up to you to ensure that you do not use the
+ same number for multiple options.
+ For options which will be published and used publicly by multiple
+ independent entities, e-mail protobuf-global-extension-registry@google.com
+ to reserve extension numbers. Simply provide your project name (e.g.
+ Objective-C plugin) and your project website (if available) -- there's no
+ need to explain how you intend to use them. Usually you only need one
+ extension number. You can declare multiple options with only one extension
+ number by putting them in a sub-message. See the Custom Options section of
+ the docs for examples:
+ https: developers.google.com protocol-buffers docs proto#options
+ If this turns out to be popular, a web service will be set up
+ to automatically assign option numbers.";
+ leaf java_package {
+ type string;
+ description
+ "Sets the Java package where classes generated from this .proto will be
+ placed. By default, the proto package is used, but this is often
+ inappropriate because proto packages do not normally start with backwards
+ domain names.";
+ }
+
+ leaf java_outer_classname {
+ type string;
+ description
+ "If set, all the classes from the .proto file are wrapped in a single
+ outer class with the given name. This applies to both Proto1
+ (equivalent to the old --one_java_file option) and Proto2 (where
+ a .proto always translates to a single class, but you may want to
+ explicitly choose the class name).";
+ }
+
+ leaf java_multiple_files {
+ type boolean;
+ description
+ "If set true, then the Java code generator will generate a separate .java
+ file for each top-level message, enum, and service defined in the .proto
+ file. Thus, these types will not be nested inside the outer class
+ named by java_outer_classname. However, the outer class will still be
+ generated to contain the file's getDescriptor() method as well as any
+ top-level extensions defined in the file.";
+ }
+
+ leaf java_generate_equals_and_hash {
+ type boolean;
+ description
+ "If set true, then the Java code generator will generate equals() and
+ hashCode() methods for all messages defined in the .proto file.
+ This increases generated code size, potentially substantially for large
+ protos, which may harm a memory-constrained application.
+ - In the full runtime this is a speed optimization, as the
+ AbstractMessage base class includes reflection-based implementations of
+ these methods.
+ - In the lite runtime, setting this option changes the semantics of
+ equals() and hashCode() to more closely match those of the full runtime;
+ the generated methods compute their results based on field values rather
+ than object identity. (Implementations should not assume that hashcodes
+ will be consistent across runtimes or versions of the protocol compiler.)";
+ }
+
+ leaf java_string_check_utf8 {
+ type boolean;
+ description
+ "If set true, then the Java2 code generator will generate code that
+ throws an exception whenever an attempt is made to assign a non-UTF-8
+ byte sequence to a string field.
+ Message reflection will do the same.
+ However, an extension field still accepts non-UTF-8 byte sequences.
+ This option has no effect on when used with the lite runtime.";
+ }
+
+ leaf optimize_for {
+ type OptimizeMode;
+ description
+ "";
+ }
+
+ leaf go_package {
+ type string;
+ description
+ "Sets the Go package where structs generated from this .proto will be
+ placed. If omitted, the Go package will be derived from the following:
+ - The basename of the package import path, if provided.
+ - Otherwise, the package statement in the .proto file, if present.
+ - Otherwise, the basename of the .proto file, without extension.";
+ }
+
+ leaf cc_generic_services {
+ type boolean;
+ description
+ "Should generic services be generated in each language? Generic services
+ are not specific to any particular RPC system. They are generated by the
+ main code generators in each language (without additional plugins).
+ Generic services were the only kind of service generation supported by
+ early versions of google.protobuf.
+
+ Generic services are now considered deprecated in favor of using plugins
+ that generate code specific to your particular RPC system. Therefore,
+ these default to false. Old code which depends on generic services should
+ explicitly set them to true.";
+ }
+
+ leaf java_generic_services {
+ type boolean;
+ description
+ "";
+ }
+
+ leaf py_generic_services {
+ type boolean;
+ description
+ "";
+ }
+
+ leaf deprecated {
+ type boolean;
+ description
+ "Is this file deprecated?
+ Depending on the target platform, this can emit Deprecated annotations
+ for everything in the file, or it will be completely ignored; in the very
+ least, this is a formalization for deprecating files.";
+ }
+
+ leaf cc_enable_arenas {
+ type boolean;
+ description
+ "Enables the use of arenas for the proto messages in this file. This applies
+ only to generated classes for C++.";
+ }
+
+ leaf objc_class_prefix {
+ type string;
+ description
+ "Sets the objective c class prefix which is prepended to all objective c
+ generated classes from this .proto. There is no default.";
+ }
+
+ leaf csharp_namespace {
+ type string;
+ description
+ "Namespace for generated classes; defaults to the package.";
+ }
+
+ list uninterpreted_option {
+ key "identifier_value";
+ uses UninterpretedOption;
+
+ description
+ "The parser stores options it doesn't recognize here. See above.";
+ }
+
+ typedef OptimizeMode {
+ type enumeration {
+ enum SPEED {
+ description "";
+ }
+ enum CODE_SIZE {
+ description "";
+ }
+ enum LITE_RUNTIME {
+ description "";
+ }
+ }
+ description
+ "Generated classes can be optimized for speed or code size.";
+ }
+
+ }
+
+ grouping MessageOptions {
+ description
+ "";
+ leaf message_set_wire_format {
+ type boolean;
+ description
+ "Set true to use the old proto1 MessageSet wire format for extensions.
+ This is provided for backwards-compatibility with the MessageSet wire
+ format. You should not use this for any other reason: It's less
+ efficient, has fewer features, and is more complicated.
+
+ The message must be defined exactly as follows:
+ message Foo
+ option message_set_wire_format = true;
+ extensions 4 to max;
+
+ Note that the message cannot have any defined fields; MessageSets only
+ have extensions.
+
+ All extensions of your type must be singular messages; e.g. they cannot
+ be int32s, enums, or repeated messages.
+
+ Because this is an option, the above two restrictions are not enforced by
+ the protocol compiler.";
+ }
+
+ leaf no_standard_descriptor_accessor {
+ type boolean;
+ description
+ "Disables the generation of the standard descriptor() accessor, which can
+ conflict with a field of the same name. This is meant to make migration
+ from proto1 easier; new code should avoid fields named descriptor .";
+ }
+
+ leaf deprecated {
+ type boolean;
+ description
+ "Is this message deprecated?
+ Depending on the target platform, this can emit Deprecated annotations
+ for the message, or it will be completely ignored; in the very least,
+ this is a formalization for deprecating messages.";
+ }
+
+ leaf map_entry {
+ type boolean;
+ description
+ "Whether the message is an automatically generated map entry type for the
+ maps field.
+
+ For maps fields:
+ map<KeyType, ValueType> map_field = 1;
+ The parsed descriptor looks like:
+ message MapFieldEntry
+ option map_entry = true;
+ optional KeyType key = 1;
+ optional ValueType value = 2;
+
+ repeated MapFieldEntry map_field = 1;
+
+ Implementations may choose not to generate the map_entry=true message, but
+ use a native map in the target language to hold the keys and values.
+ The reflection APIs in such implementions still need to work as
+ if the field is a repeated message field.
+
+ NOTE: Do not set the option in .proto files. Always use the maps syntax
+ instead. The option should only be implicitly set by the proto compiler
+ parser.";
+ }
+
+ list uninterpreted_option {
+ key "identifier_value";
+ uses UninterpretedOption;
+
+ description
+ "The parser stores options it doesn't recognize here. See above.";
+ }
+
+ }
+
+ grouping FieldOptions {
+ description
+ "";
+ leaf ctype {
+ type CType;
+ description
+ "The ctype option instructs the C++ code generator to use a different
+ representation of the field than it normally would. See the specific
+ options below. This option is not yet implemented in the open source
+ release -- sorry, we'll try to include it in a future version!";
+ }
+
+ leaf packed {
+ type boolean;
+ description
+ "The packed option can be enabled for repeated primitive fields to enable
+ a more efficient representation on the wire. Rather than repeatedly
+ writing the tag and type for each element, the entire array is encoded as
+ a single length-delimited blob. In proto3, only explicit setting it to
+ false will avoid using packed encoding.";
+ }
+
+ leaf jstype {
+ type JSType;
+ description
+ "The jstype option determines the JavaScript type used for values of the
+ field. The option is permitted only for 64 bit integral and fixed types
+ (int64, uint64, sint64, fixed64, sfixed64). By default these types are
+ represented as JavaScript strings. This avoids loss of precision that can
+ happen when a large value is converted to a floating point JavaScript
+ numbers. Specifying JS_NUMBER for the jstype causes the generated
+ JavaScript code to use the JavaScript number type instead of strings.
+ This option is an enum to permit additional types to be added,
+ e.g. goog.math.Integer.";
+ }
+
+ leaf lazy {
+ type boolean;
+ description
+ "Should this field be parsed lazily? Lazy applies only to message-type
+ fields. It means that when the outer message is initially parsed, the
+ inner message's contents will not be parsed but instead stored in encoded
+ form. The inner message will actually be parsed when it is first accessed.
+
+ This is only a hint. Implementations are free to choose whether to use
+ eager or lazy parsing regardless of the value of this option. However,
+ setting this option true suggests that the protocol author believes that
+ using lazy parsing on this field is worth the additional bookkeeping
+ overhead typically needed to implement it.
+
+ This option does not affect the public interface of any generated code;
+ all method signatures remain the same. Furthermore, thread-safety of the
+ interface is not affected by this option; const methods remain safe to
+ call from multiple threads concurrently, while non-const methods continue
+ to require exclusive access.
+
+
+ Note that implementations may choose not to check required fields within
+ a lazy sub-message. That is, calling IsInitialized() on the outher message
+ may return true even if the inner message has missing required fields.
+ This is necessary because otherwise the inner message would have to be
+ parsed in order to perform the check, defeating the purpose of lazy
+ parsing. An implementation which chooses not to check required fields
+ must be consistent about it. That is, for any particular sub-message, the
+ implementation must either always check its required fields, or never
+ check its required fields, regardless of whether or not the message has
+ been parsed.";
+ }
+
+ leaf deprecated {
+ type boolean;
+ description
+ "Is this field deprecated?
+ Depending on the target platform, this can emit Deprecated annotations
+ for accessors, or it will be completely ignored; in the very least, this
+ is a formalization for deprecating fields.";
+ }
+
+ leaf weak {
+ type boolean;
+ description
+ "For Google-internal migration only. Do not use.";
+ }
+
+ list uninterpreted_option {
+ key "identifier_value";
+ uses UninterpretedOption;
+
+ description
+ "The parser stores options it doesn't recognize here. See above.";
+ }
+
+ typedef CType {
+ type enumeration {
+ enum STRING {
+ description "";
+ }
+ enum CORD {
+ description "";
+ }
+ enum STRING_PIECE {
+ description "";
+ }
+ }
+ description
+ "";
+ }
+
+ typedef JSType {
+ type enumeration {
+ enum JS_NORMAL {
+ description "";
+ }
+ enum JS_STRING {
+ description "";
+ }
+ enum JS_NUMBER {
+ description "";
+ }
+ }
+ description
+ "";
+ }
+
+ }
+
+ grouping OneofOptions {
+ description
+ "";
+ list uninterpreted_option {
+ key "identifier_value";
+ uses UninterpretedOption;
+
+ description
+ "The parser stores options it doesn't recognize here. See above.";
+ }
+
+ }
+
+ grouping EnumOptions {
+ description
+ "";
+ leaf allow_alias {
+ type boolean;
+ description
+ "Set this option to true to allow mapping different tag names to the same
+ value.";
+ }
+
+ leaf deprecated {
+ type boolean;
+ description
+ "Is this enum deprecated?
+ Depending on the target platform, this can emit Deprecated annotations
+ for the enum, or it will be completely ignored; in the very least, this
+ is a formalization for deprecating enums.";
+ }
+
+ list uninterpreted_option {
+ key "identifier_value";
+ uses UninterpretedOption;
+
+ description
+ "The parser stores options it doesn't recognize here. See above.";
+ }
+
+ }
+
+ grouping EnumValueOptions {
+ description
+ "";
+ leaf deprecated {
+ type boolean;
+ description
+ "Is this enum value deprecated?
+ Depending on the target platform, this can emit Deprecated annotations
+ for the enum value, or it will be completely ignored; in the very least,
+ this is a formalization for deprecating enum values.";
+ }
+
+ list uninterpreted_option {
+ key "identifier_value";
+ uses UninterpretedOption;
+
+ description
+ "The parser stores options it doesn't recognize here. See above.";
+ }
+
+ }
+
+ grouping ServiceOptions {
+ description
+ "";
+ leaf deprecated {
+ type boolean;
+ description
+ "Is this service deprecated?
+ Depending on the target platform, this can emit Deprecated annotations
+ for the service, or it will be completely ignored; in the very least,
+ this is a formalization for deprecating services.
+Note: Field numbers 1 through 32 are reserved for Google's internal RPC
+ framework. We apologize for hoarding these numbers to ourselves, but
+ we were already using them long before we decided to release Protocol
+ Buffers.";
+ }
+
+ list uninterpreted_option {
+ key "identifier_value";
+ uses UninterpretedOption;
+
+ description
+ "The parser stores options it doesn't recognize here. See above.";
+ }
+
+ }
+
+ grouping MethodOptions {
+ description
+ "";
+ leaf deprecated {
+ type boolean;
+ description
+ "Is this method deprecated?
+ Depending on the target platform, this can emit Deprecated annotations
+ for the method, or it will be completely ignored; in the very least,
+ this is a formalization for deprecating methods.
+Note: Field numbers 1 through 32 are reserved for Google's internal RPC
+ framework. We apologize for hoarding these numbers to ourselves, but
+ we were already using them long before we decided to release Protocol
+ Buffers.";
+ }
+
+ list uninterpreted_option {
+ key "identifier_value";
+ uses UninterpretedOption;
+
+ description
+ "The parser stores options it doesn't recognize here. See above.";
+ }
+
+ }
+
+ grouping UninterpretedOption {
+ description
+ "A message representing a option the parser does not recognize. This only
+ appears in options protos created by the compiler::Parser class.
+ DescriptorPool resolves these when building Descriptor objects. Therefore,
+ options protos in descriptor objects (e.g. returned by Descriptor::options(),
+ or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+ in them.";
+
+ leaf identifier_value {
+ type string;
+ description
+ "The value of the uninterpreted option, in whatever type the tokenizer
+ identified it as during parsing. Exactly one of these should be set.";
+ }
+
+ leaf positive_int_value {
+ type uint64;
+ description
+ "";
+ }
+
+ leaf negative_int_value {
+ type int64;
+ description
+ "";
+ }
+
+ leaf double_value {
+ type decimal64 {
+ fraction-digits 5;
+ }
+ description
+ "";
+ }
+
+ leaf string_value {
+ type binary;
+ description
+ "";
+ }
+
+ leaf aggregate_value {
+ type string;
+ description
+ "";
+ }
+
+ grouping NamePart {
+ description
+ "The name of the uninterpreted option. Each string represents a segment in
+ a dot-separated name. is_extension is true iff a segment represents an
+ extension (denoted with parentheses in options specs in .proto files).
+ E.g., foo , false , bar.baz , true , qux , false represents
+ foo.(bar.baz).qux .";
+ leaf name_part {
+ type string;
+ description
+ "";
+ }
+
+ leaf is_extension {
+ type boolean;
+ description
+ "";
+ }
+
+ }
+
+ }
+
+ grouping SourceCodeInfo {
+ description
+ "Encapsulates information about the original source file from which a
+ FileDescriptorProto was generated.
+===================================================================
+ Optional source code info";
+
+ grouping Location {
+ description
+ "";
+ list path {
+ key "path";
+ leaf path {
+ type int32;
+ description
+ "Identifies which part of the FileDescriptorProto was defined at this
+ location.
+
+ Each element is a field number or an index. They form a path from
+ the root FileDescriptorProto to the place where the definition. For
+ example, this path:
+ 4, 3, 2, 7, 1
+ refers to:
+ file.message_type(3) 4, 3
+ .field(7) 2, 7
+ .name() 1
+ This is because FileDescriptorProto.message_type has field number 4:
+ repeated DescriptorProto message_type = 4;
+ and DescriptorProto.field has field number 2:
+ repeated FieldDescriptorProto field = 2;
+ and FieldDescriptorProto.name has field number 1:
+ optional string name = 1;
+
+ Thus, the above path gives the location of a field name. If we removed
+ the last element:
+ 4, 3, 2, 7
+ this path refers to the whole field declaration (from the beginning
+ of the label to the terminating semicolon).";
+ }
+ description
+ "Identifies which part of the FileDescriptorProto was defined at this
+ location.
+
+ Each element is a field number or an index. They form a path from
+ the root FileDescriptorProto to the place where the definition. For
+ example, this path:
+ 4, 3, 2, 7, 1
+ refers to:
+ file.message_type(3) 4, 3
+ .field(7) 2, 7
+ .name() 1
+ This is because FileDescriptorProto.message_type has field number 4:
+ repeated DescriptorProto message_type = 4;
+ and DescriptorProto.field has field number 2:
+ repeated FieldDescriptorProto field = 2;
+ and FieldDescriptorProto.name has field number 1:
+ optional string name = 1;
+
+ Thus, the above path gives the location of a field name. If we removed
+ the last element:
+ 4, 3, 2, 7
+ this path refers to the whole field declaration (from the beginning
+ of the label to the terminating semicolon).";
+ }
+
+ list span {
+ key "span";
+ leaf span {
+ type int32;
+ description
+ "Always has exactly three or four elements: start line, start column,
+ end line (optional, otherwise assumed same as start line), end column.
+ These are packed into a single field for efficiency. Note that line
+ and column numbers are zero-based -- typically you will want to add
+ 1 to each before displaying to a user.";
+ }
+ description
+ "Always has exactly three or four elements: start line, start column,
+ end line (optional, otherwise assumed same as start line), end column.
+ These are packed into a single field for efficiency. Note that line
+ and column numbers are zero-based -- typically you will want to add
+ 1 to each before displaying to a user.";
+ }
+
+ leaf leading_comments {
+ type string;
+ description
+ "If this SourceCodeInfo represents a complete declaration, these are any
+ comments appearing before and after the declaration which appear to be
+ attached to the declaration.
+
+ A series of line comments appearing on consecutive lines, with no other
+ tokens appearing on those lines, will be treated as a single comment.
+
+ leading_detached_comments will keep paragraphs of comments that appear
+ before (but not connected to) the current element. Each paragraph,
+ separated by empty lines, will be one comment element in the repeated
+ field.
+
+ Only the comment content is provided; comment markers (e.g. ) are
+ stripped out. For block comments, leading whitespace and an asterisk
+ will be stripped from the beginning of each line other than the first.
+ Newlines are included in the output.
+
+ Examples:
+
+ optional int32 foo = 1; Comment attached to foo.
+ Comment attached to bar.
+ optional int32 bar = 2;
+
+ optional string baz = 3;
+ Comment attached to baz.
+ Another line attached to baz.
+
+ Comment attached to qux.
+
+ Another line attached to qux.
+ optional double qux = 4;
+
+ Detached comment for corge. This is not leading or trailing comments
+ to qux or corge because there are blank lines separating it from
+ both.
+
+ Detached comment for corge paragraph 2.
+
+ optional string corge = 5;
+ Block comment attached
+ to corge. Leading asterisks
+ will be removed.
+ Block comment attached to
+ grault.
+ optional int32 grault = 6;
+
+ ignored detached comments.";
+ }
+
+ leaf trailing_comments {
+ type string;
+ description
+ "";
+ }
+
+ list leading_detached_comments {
+ key "leading_detached_comments";
+ leaf leading_detached_comments {
+ type string;
+ description
+ "";
+ }
+ description
+ "";
+ }
+
+ }
+
+ }
+
+ container GeneratedCodeInfo {
+ description
+ "Describes the relationship between generated code and its original source
+ file. A GeneratedCodeInfo message is associated with only one generated
+ source file, but may contain references to different source .proto files.";
+
+ grouping Annotation {
+ description
+ "";
+ list path {
+ key "path";
+ leaf path {
+ type int32;
+ description
+ "Identifies the element in the original source .proto file. This field
+ is formatted the same as SourceCodeInfo.Location.path.";
+ }
+ description
+ "Identifies the element in the original source .proto file. This field
+ is formatted the same as SourceCodeInfo.Location.path.";
+ }
+
+ leaf source_file {
+ type string;
+ description
+ "Identifies the filesystem path to the original source .proto.";
+ }
+
+ leaf begin {
+ type int32;
+ description
+ "Identifies the starting offset in bytes in the generated code
+ that relates to the identified object.";
+ }
+
+ leaf end {
+ type int32;
+ description
+ "Identifies the ending offset in bytes in the generated code that
+ relates to the identified offset. The end offset should be one past
+ the last relevant byte (so the length of the text = end - begin).";
+ }
+
+ }
+
+ }
+
+}
\ No newline at end of file