| module openconfig-module-catalog { |
| |
| yang-version "1"; |
| |
| // namespace |
| namespace "http://openconfig.net/yang/module-catalog"; |
| |
| prefix "oc-cat"; |
| |
| // import some basic types |
| import openconfig-inet-types { prefix oc-inet; } |
| import openconfig-catalog-types { prefix oc-cat-types; } |
| import openconfig-extensions { prefix oc-ext; } |
| |
| |
| // meta |
| organization "OpenConfig working group"; |
| |
| contact |
| "OpenConfig working group |
| www.openconfig.net"; |
| |
| description |
| "This module provides a schema for cataloging and descrbing |
| YANG models published across various organizations. The catalog |
| contains several categories of data: |
| |
| * organizations -- entities that publish and/or maintain |
| individual YANG modules or groups of modules |
| |
| * modules -- information regarding individual YANG modules, |
| including their versions, dependencies, submodules, and how |
| to access them |
| |
| * release bundles -- groups of modules that are compatible and |
| consistent with each other (as determined by the publisher of |
| of the bundle). The release bundle does not necessarily |
| correspond to a functional area, e.g., it could the entire |
| set of modules published by an organization |
| |
| * feature bundles -- sets of schema paths across a |
| release bundle that provide a specific set of functionality |
| |
| * implementations -- information about available module and/or |
| bundle implementations and their status"; |
| |
| oc-ext:openconfig-version "0.2.1"; |
| |
| revision "2017-05-01" { |
| description |
| "Fix to module dependency list"; |
| reference "0.2.1"; |
| } |
| |
| revision "2017-03-08" { |
| description |
| "OpenConfig public release"; |
| reference "0.2.0"; |
| } |
| |
| revision "2016-02-15" { |
| description |
| "Initial OpenConfig public release"; |
| reference "0.1.0"; |
| } |
| |
| |
| |
| // grouping statements |
| |
| grouping catalog-module-common-config { |
| description |
| "Data definitions common for both bundles and standalone |
| modules"; |
| |
| leaf name { |
| type string; |
| description |
| "The name of the module or bundle. For modules, this |
| should reflect the 'module' or 'submodule' |
| statement in the YANG module file. |
| |
| For bundles, this is the canonical name for the overall |
| bundle of modules which is to be released together. |
| This name should be consistent over multiple |
| releases"; |
| } |
| |
| leaf version { |
| type oc-cat-types:module-version-type; |
| description |
| "For individual modules, this is the version number, e.g., |
| a semantic version. The version may be the same as the date |
| indicated in the module revision statement. |
| |
| For bundles, this is a semantic version number for the |
| overall bundle. This version is to be defined as per the |
| approach specified in the OpenConfig semantic version |
| guidance - and is of the form x.y.z, where x is the major |
| version, y is the minor version, and z is the patch level"; |
| reference |
| "Semantic versioning for OpenConfig models"; |
| } |
| } |
| |
| grouping feature-bundle-included-reference { |
| description |
| "References to the included feature bundles"; |
| |
| leaf name { |
| type leafref { |
| path "../../../../../../../organizations/" + |
| "organization[name=current()/../publisher]/" + |
| "feature-bundles/feature-bundle/name"; |
| } |
| description |
| "Name of the referenced feature bundle"; |
| } |
| |
| leaf publisher { |
| type leafref { |
| path "../../../../../../../organizations/organization/" + |
| "name"; |
| } |
| description |
| "Publisher of the referenced feature bundle"; |
| } |
| |
| leaf version { |
| type oc-cat-types:module-version-type; |
| description |
| "Version of the referenced feature bundle"; |
| } |
| } |
| |
| grouping catalog-implementation-bundle-config { |
| description |
| "References to the feature bundles supported by an |
| implementation"; |
| |
| uses feature-bundle-included-reference; |
| } |
| |
| grouping catalog-implementation-bundle-top { |
| description |
| "Top-level grouping for the list of feature bundles |
| supported by an implementation"; |
| |
| container feature-bundles { |
| description |
| "Enclosing container for the list of feature bundles"; |
| |
| list feature-bundle { |
| key "name version"; |
| description |
| "List of feature bundles supported by the implementation"; |
| |
| uses catalog-implementation-bundle-config; |
| } |
| } |
| } |
| |
| grouping catalog-implementation-config { |
| description |
| "Data describing any available implementations"; |
| |
| leaf id { |
| type string; |
| description |
| "An identifier for the implementation, provided by the |
| implementor. This id should uniquely identify a specific |
| implementation of the module, e.g., based on the vendor, |
| platform, and platform version."; |
| } |
| |
| leaf description { |
| type string; |
| description |
| "A text summary of important information about the |
| implementation"; |
| } |
| |
| leaf reference { |
| type union { |
| type oc-inet:uri; |
| type string; |
| } |
| description |
| "A URI (preferred) or text reference to more detailed |
| information about the implementation."; |
| } |
| |
| |
| leaf platform { |
| type string; |
| description |
| "Name of the platform on which the implementation |
| is available -- this could be the model name of a network |
| device, a server OS, etc."; |
| } |
| |
| leaf platform-version { |
| type string; |
| description |
| "Implementor-defined version name or number of the |
| module implementation, corresponding to the platform. |
| This could be the firmware version of a network device |
| such as a router, OS version, or other server platform |
| version."; |
| } |
| |
| leaf status { |
| type identityref { |
| base oc-cat-types:IMPLEMENTATION_STATUS_TYPE; |
| } |
| description |
| "Indicates the status of the implementation, e.g., |
| complete, partial, in-progress, etc. Implementors |
| may define additional values for the base identity"; |
| } |
| } |
| |
| grouping catalog-implementation-top { |
| description |
| "Top level grouping for information on model implementations"; |
| |
| container implementations { |
| description |
| "Container for module implementation information"; |
| |
| list implementation { |
| key "id"; |
| description |
| "List of available implementations, keyed by an identifier |
| provided by either the implementor or the module |
| maintainer. Such a key avoids needing a complex composite |
| key to uniquely identify an implementation."; |
| |
| uses catalog-implementation-config; |
| uses catalog-implementation-bundle-top; |
| } |
| } |
| } |
| |
| grouping catalog-module-dependency-config { |
| description |
| "Information about module dependencies"; |
| |
| |
| leaf-list required-module { |
| type string; |
| description |
| "List of names of modules that are imported by the |
| current module. This list should reflect all of the 'import' |
| statements in the module. Release bundles should be used to |
| indicate which versions of the imported module are used |
| (or are compatible) with the current module"; |
| } |
| } |
| |
| grouping catalog-module-dependency-top { |
| description |
| "Top-level grouping for module dependency data"; |
| |
| container dependencies { |
| description |
| "Data about dependencies of the module"; |
| |
| uses catalog-module-dependency-config; |
| } |
| |
| } |
| |
| grouping catalog-module-classification-config { |
| description |
| "Data describing the module's classification(s)"; |
| |
| leaf category { |
| type identityref { |
| base oc-cat-types:MODULE_CATEGORY_BASE; |
| } |
| description |
| "Categorization of the module based on identities defined |
| or used by the publishing organizations."; |
| } |
| |
| leaf subcategory { |
| type identityref { |
| base oc-cat-types:MODULE_SUBCATEGORY_BASE; |
| } |
| description |
| "Sub-categorization of the module based on identities |
| defined or used by the publishing organizations."; |
| } |
| |
| leaf deployment-status { |
| type identityref { |
| base oc-cat-types:MODULE_STATUS_TYPE; |
| } |
| description |
| "Deployment status of the module -- experimental, |
| standards-track, production, etc."; |
| } |
| } |
| |
| grouping catalog-module-classification-top { |
| description |
| "Data definitions related to module classfications"; |
| |
| container classification { |
| description |
| "Container for data describing the module's classification"; |
| |
| uses catalog-module-classification-config; |
| } |
| } |
| |
| grouping catalog-module-access-config { |
| description |
| "Data pertaining to retrieval and usage of the module"; |
| |
| leaf uri { |
| type oc-inet:uri; |
| description |
| "URI where module can be downloaded. Modules may be |
| made available from the catalog maintainer, or directly |
| from the publisher"; |
| } |
| |
| leaf md5-hash { |
| type string; |
| description |
| "Optional MD5 hash of the module file. If specified, the |
| hash may be used by users to validate data integrity"; |
| } |
| } |
| |
| grouping catalog-module-access-top { |
| description |
| "Top level groupig for data related to accessing a module |
| or submodule"; |
| |
| container access { |
| description |
| "Container for data pertaining to retrieval and usage of the |
| module"; |
| |
| uses catalog-module-access-config; |
| } |
| } |
| |
| grouping catalog-module-submodule-config { |
| description |
| "Data definitions for submodules belonging to a |
| module"; |
| |
| leaf name { |
| type string; |
| description |
| "Name of the submodule as indicated by its top-level |
| 'submodule' statement"; |
| } |
| |
| } |
| |
| grouping catalog-module-submodule-top { |
| description |
| "Top-level grouping for submodule information"; |
| |
| container submodules { |
| description |
| "Data for the submodules belonging to a submodule. If the |
| module does not have any submodules, this container |
| should be empty."; |
| |
| list submodule { |
| key "name"; |
| description |
| "List of submodules included by a module. All submodules |
| specified by 'include' statements in the module should be |
| included in this list."; |
| |
| uses catalog-module-submodule-config; |
| uses catalog-module-access-top; |
| } |
| } |
| } |
| |
| grouping catalog-module-base-config { |
| description |
| "Basic information describing the module, e.g., the |
| YANG metadata in the module preface."; |
| |
| |
| leaf namespace { |
| type string; |
| description |
| "Published namespace of module, i.e., defined by the |
| 'namespace' "; |
| } |
| |
| leaf prefix { |
| type string; |
| description |
| "Published prefix of the module"; |
| } |
| |
| leaf revision { |
| type string; |
| description |
| "Date in the revision statement of the module"; |
| } |
| |
| leaf summary { |
| type string; |
| description |
| "Summary description of the module"; |
| } |
| } |
| |
| grouping release-bundle-member-config { |
| description |
| "Data for each member of a bundle"; |
| |
| leaf id { |
| type string; |
| description |
| "Identifier for the bundle member"; |
| } |
| |
| leaf type { |
| type identityref { |
| base oc-cat-types:CATALOG_MEMBER_TYPE; |
| } |
| description |
| "The type of member that is to be included within the |
| release bundle. Release bundles may include modules and |
| other release bundles. Both member modules and member |
| bundles should specify the list of compatible versions."; |
| } |
| |
| leaf module { |
| when "../type = 'oc-cat-types:MODULE'" { |
| description |
| "The module name is specified for bundle membrs that are |
| modules"; |
| } |
| type leafref { |
| path "../../../../../../../organizations/" + |
| "organization[name=current()/../publisher]/modules/" + |
| "module/name"; |
| } |
| description |
| "Name of the module set which is included in this bundle - |
| for example, 'openconfig-bgp'"; |
| } |
| |
| leaf release-bundle { |
| when "../type = 'oc-cat-types:RELEASE_BUNDLE'" { |
| description |
| "The release bundle is specified for bundle members that |
| are release bundles"; |
| } |
| type leafref { |
| path "../../../../../../../organizations/" + |
| "organization[name=current()/../publisher]/" + |
| "release-bundles/release-bundle/name"; |
| } |
| description |
| "Name of the module set which is included in this bundle - |
| for example, 'openconfig-bgp'"; |
| } |
| |
| leaf publisher { |
| type leafref { |
| path "../../../../../../../organizations/organization/" + |
| "name"; |
| } |
| description |
| "Reference to the name of the publishing organization"; |
| } |
| |
| leaf-list compatible-versions { |
| type oc-cat-types:module-version-type; |
| description |
| "A list of semantic version specification of the versions |
| of the specified module or release bundle which are |
| compatible when building this version of the bundle. |
| |
| Version specifications may be added when changes are made |
| to a module within a bundle, and this does not affect the |
| interaction between it and other modules. It is expected |
| that backwards compatible changes to an individual module or |
| member bundle do not affect the compatibility of that |
| with other members, and hence wildcard matches are allowed |
| within this list."; |
| } |
| } |
| |
| grouping release-bundle-member-top { |
| |
| description |
| "Parameters relating to models within release bundles"; |
| |
| container members { |
| description |
| "List of bundle members which make up this release bundle. A |
| member is defined as an individual YANG module specified |
| in the YANG catalogue, or another release |
| bundle which can be used to group multiple YANG |
| models together."; |
| |
| list member { |
| key "id"; |
| description |
| "A set of modules or bundles which are part of the bundle |
| of models. For example, if 'ietf-yang-types' were to be |
| specified within the bundle, then this would refer to the |
| individual entry within the module catalogue. If the type |
| of the entry is set to bundle, then for example, |
| openconfig-bgp could be referenced - which itself consists |
| of separate modules."; |
| |
| uses release-bundle-member-config; |
| |
| } |
| } |
| } |
| |
| grouping release-bundle-top { |
| description |
| "Top-level container for a release bundle"; |
| |
| container release-bundles { |
| description |
| "List of release bundles"; |
| |
| list release-bundle { |
| key "name version"; |
| |
| description |
| "List of release bundles - sets of modules and/or |
| bundles which are interoperable"; |
| |
| uses catalog-module-common-config; |
| uses release-bundle-member-top; |
| } |
| } |
| } |
| |
| grouping feature-bundle-release-config { |
| description |
| "Data definitions to identify the release bundle that the |
| feature bundle is based on."; |
| |
| leaf name { |
| type leafref { |
| path "../../../../release-bundles/release-bundle/name"; |
| } |
| description |
| "Reference to the name of the release bundle used for the |
| feature paths."; |
| } |
| |
| leaf version { |
| type leafref { |
| path "../../../../release-bundles/" + |
| "release-bundle[name=current()/../name]/version"; |
| } |
| description |
| "Reference to the release bundle version used for the |
| feature paths"; |
| } |
| |
| leaf publisher { |
| type leafref { |
| path "../../../../release-bundles/" + |
| "release-bundle[name=current()/../name]/publisher"; |
| } |
| description |
| "Reference to the publisher of the release bundle used for |
| the feature paths"; |
| } |
| } |
| |
| grouping feature-bundle-release-top { |
| description |
| "Top-level grouping for data about the release bundle used |
| to specify the feature bundle"; |
| |
| container release-bundle { |
| description |
| "Data to identify the release bundle from which the feature |
| paths should be specified. If the feature crosses |
| release bundles, a new release bundle should be |
| created to support the feature bundle."; |
| |
| leaf name { |
| type leafref { |
| path "../../../../../../organizations/" + |
| "organization[name=current()/../publisher]/" + |
| "release-bundles/release-bundle/name"; |
| } |
| description |
| "Name of the module set which is included in this bundle - |
| for example, 'openconfig-bgp'"; |
| } |
| |
| leaf publisher { |
| type leafref { |
| path "../../../../../../organizations/organization/" + |
| "name"; |
| } |
| description |
| "Reference to the name of the publishing organization"; |
| } |
| |
| leaf version { |
| type oc-cat-types:module-version-type; |
| description |
| "Version of the referenced release bundle"; |
| } |
| } |
| } |
| |
| |
| grouping feature-bundle-config { |
| description |
| "Data definitions for the feature bundle"; |
| |
| uses catalog-module-common-config; |
| |
| leaf-list path { |
| type string; |
| description |
| "The list of schema paths included in the feature. The |
| paths specify subtrees, i.e., all data underneath the |
| specified path are included in the feature."; |
| } |
| } |
| |
| grouping feature-bundle-feature-config { |
| description |
| "Data definitions for included feature bundles"; |
| |
| uses feature-bundle-included-reference; |
| } |
| |
| grouping feature-bundle-feature-top { |
| description |
| "Top level grouping for the list of included feature |
| bundles"; |
| |
| container feature-bundles { |
| description |
| "Enclosing container for the list of included feature |
| bundles. Feature bundles may be composed from other |
| smaller feature units"; |
| |
| list feature-bundle { |
| key "name"; |
| description |
| "The list of feature bundles included in the current |
| feature bundle."; |
| |
| uses feature-bundle-feature-config; |
| } |
| } |
| |
| } |
| |
| |
| grouping feature-bundle-top { |
| description |
| "Top-level grouping for OpenConfig feature bundles"; |
| |
| container feature-bundles { |
| description |
| "Enclosing container for the list of feature bundles"; |
| |
| list feature-bundle { |
| key "name version"; |
| description |
| "List of feature bundles"; |
| |
| uses feature-bundle-config; |
| uses feature-bundle-release-top; |
| uses feature-bundle-feature-top; |
| } |
| } |
| } |
| |
| grouping catalog-module-top { |
| description |
| "Top level structure of the module catalog"; |
| |
| container modules { |
| description |
| "Modules published by this organization"; |
| |
| list module { |
| key "name version"; |
| description |
| "List of published modules from the organization"; |
| |
| uses catalog-module-common-config; |
| uses catalog-module-base-config; |
| uses catalog-module-classification-top; |
| uses catalog-module-dependency-top; |
| uses catalog-module-access-top; |
| uses catalog-module-submodule-top; |
| } |
| } |
| } |
| |
| grouping catalog-organization-config { |
| description |
| "Top level grouping for data related to an organization that |
| publishes module, bundles, etc."; |
| |
| leaf name { |
| type string; |
| description |
| "Name of the maintaining organization -- the name should be |
| supplied in the official format used by the organization. |
| Standards Body examples: |
| IETF, IEEE, MEF, ONF, etc. |
| Commercial entity examples: |
| AT&T, Facebook, <Vendor> |
| Name of industry forum examples: |
| OpenConfig, OpenDaylight, ON.Lab"; |
| } |
| |
| leaf type { |
| type identityref { |
| base oc-cat-types:ORGANIZATION_TYPE; |
| } |
| description |
| "Type of the publishing organization"; |
| } |
| |
| leaf contact { |
| type string; |
| description |
| "Contact information for the publishing organization (web |
| site, email address, etc.)"; |
| } |
| } |
| |
| grouping catalog-organization-top { |
| description |
| "Top level grouping for list of maintaining organizations"; |
| |
| container organizations { |
| description |
| "List of organizations owning modules"; |
| |
| list organization { |
| key "name"; |
| |
| description |
| "List of organizations publishing YANG modules or |
| module bundles"; |
| |
| uses catalog-organization-config; |
| uses catalog-module-top; |
| uses release-bundle-top; |
| uses feature-bundle-top; |
| uses catalog-implementation-top; |
| } |
| } |
| } |
| |
| |
| grouping catalog-top { |
| description |
| "Top-level grouping for the YANG model catalog"; |
| |
| uses catalog-organization-top; |
| } |
| |
| // data definition statements |
| |
| uses catalog-top; |
| |
| } |