From c6d536fa340cf1882b0fc219d22ebb442f6dfc2b Mon Sep 17 00:00:00 2001 From: Gaurav Agrawal Date: Fri, 17 Mar 2017 11:56:31 +0530 Subject: [PATCH] [ONOS-5989] YANG based L3VPN: Provide the skeleton structure with L3SM model Change-Id: Ib72b92cef6b3f62f35eef6e10a811308f7b43b3f --- apps/l3vpn/BUCK | 19 + apps/l3vpn/netl3vpn/BUCK | 16 + apps/l3vpn/netl3vpn/pom.xml | 60 + .../l3vpn/netl3vpn/NetL3vpnManager.java | 106 + .../l3vpn/netl3vpn/package-info.java | 20 + apps/l3vpn/pom.xml | 47 + apps/l3vpn/yangmodel/BUCK | 13 + apps/l3vpn/yangmodel/pom.xml | 51 + .../src/main/yang/ietf-inet-types.yang | 454 +++ .../main/yang/ietf-l3vpn-svc@2016-07-30.yang | 2599 +++++++++++++++++ .../src/main/yang/ietf-yang-types.yang | 473 +++ .../main/yang/l3vpn-svc-ext@2016-07-30.yang | 362 +++ modules.defs | 3 +- 13 files changed, 4222 insertions(+), 1 deletion(-) create mode 100644 apps/l3vpn/BUCK create mode 100644 apps/l3vpn/netl3vpn/BUCK create mode 100644 apps/l3vpn/netl3vpn/pom.xml create mode 100644 apps/l3vpn/netl3vpn/src/main/java/org/onosproject/l3vpn/netl3vpn/NetL3vpnManager.java create mode 100644 apps/l3vpn/netl3vpn/src/main/java/org/onosproject/l3vpn/netl3vpn/package-info.java create mode 100644 apps/l3vpn/pom.xml create mode 100644 apps/l3vpn/yangmodel/BUCK create mode 100644 apps/l3vpn/yangmodel/pom.xml create mode 100755 apps/l3vpn/yangmodel/src/main/yang/ietf-inet-types.yang create mode 100755 apps/l3vpn/yangmodel/src/main/yang/ietf-l3vpn-svc@2016-07-30.yang create mode 100755 apps/l3vpn/yangmodel/src/main/yang/ietf-yang-types.yang create mode 100644 apps/l3vpn/yangmodel/src/main/yang/l3vpn-svc-ext@2016-07-30.yang diff --git a/apps/l3vpn/BUCK b/apps/l3vpn/BUCK new file mode 100644 index 0000000000..1c6d6ef7ca --- /dev/null +++ b/apps/l3vpn/BUCK @@ -0,0 +1,19 @@ +APPS = [ + 'org.onosproject.yang', +] + +BUNDLES = [ + '//apps/l3vpn/netl3vpn:onos-apps-l3vpn-netl3vpn', + '//apps/l3vpn/yangmodel:onos-apps-l3vpn-yangmodel', +] + +onos_app( + app_name = 'org.onosproject.l3vpn', + title = 'YANG L3VPN App', + category = 'L3VPN APP', + url = 'http://onosproject.org', + included_bundles = BUNDLES, + description = 'L3VPN YANG Application', + required_apps = APPS, +) + diff --git a/apps/l3vpn/netl3vpn/BUCK b/apps/l3vpn/netl3vpn/BUCK new file mode 100644 index 0000000000..47b8c9aa55 --- /dev/null +++ b/apps/l3vpn/netl3vpn/BUCK @@ -0,0 +1,16 @@ +COMPILE_DEPS = [ + '//lib:CORE_DEPS', + '//apps/l3vpn/yangmodel:onos-apps-l3vpn-yangmodel', + '//lib:onos-yang-model', + '//lib:onos-yang-runtime', +] + +TEST_DEPS = [ + '//lib:TEST_ADAPTERS', + '//utils/osgi:onlab-osgi-tests', +] + +osgi_jar_with_tests( + deps = COMPILE_DEPS, + test_deps = TEST_DEPS, +) diff --git a/apps/l3vpn/netl3vpn/pom.xml b/apps/l3vpn/netl3vpn/pom.xml new file mode 100644 index 0000000000..2ce1d098aa --- /dev/null +++ b/apps/l3vpn/netl3vpn/pom.xml @@ -0,0 +1,60 @@ + + + + 4.0.0 + + + org.onosproject + onos-app-l3vpn + 1.10.0-SNAPSHOT + ../pom.xml + + + onos-app-l3vpn-netl3vpn + bundle + + IETF L3VPN Service Model + + + 1.12.0-b5 + + + + + org.onosproject + onlab-junit + test + + + org.onosproject + onos-yang-model + ${yang-tool-version} + + + org.onosproject + onos-yang-runtime + ${yang-tool-version} + + + org.onosproject + onos-app-l3vpn-yangmodel + ${project.version} + + + diff --git a/apps/l3vpn/netl3vpn/src/main/java/org/onosproject/l3vpn/netl3vpn/NetL3vpnManager.java b/apps/l3vpn/netl3vpn/src/main/java/org/onosproject/l3vpn/netl3vpn/NetL3vpnManager.java new file mode 100644 index 0000000000..2535173e5f --- /dev/null +++ b/apps/l3vpn/netl3vpn/src/main/java/org/onosproject/l3vpn/netl3vpn/NetL3vpnManager.java @@ -0,0 +1,106 @@ +/* + * Copyright 2017-present Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onosproject.l3vpn.netl3vpn; + +import org.apache.felix.scr.annotations.Activate; +import org.apache.felix.scr.annotations.Component; +import org.apache.felix.scr.annotations.Deactivate; +import org.apache.felix.scr.annotations.Reference; +import org.apache.felix.scr.annotations.ReferenceCardinality; +import org.onosproject.core.CoreService; +import org.onosproject.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev20130715.IetfInetTypes; +import org.onosproject.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.l3vpn.svc.rev20160730.IetfL3VpnSvc; +import org.onosproject.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev20130715.IetfYangTypes; +import org.onosproject.yang.gen.v1.urn.ietf.params.xml.ns.yang.l3vpn.svc.ext.rev20160730.L3VpnSvcExt; +import org.onosproject.yang.model.YangModel; +import org.onosproject.yang.model.YangModuleId; +import org.onosproject.yang.runtime.DefaultAppModuleInfo; +import org.onosproject.yang.runtime.DefaultModelRegistrationParam; +import org.onosproject.yang.runtime.ModelRegistrationParam; +import org.onosproject.yang.runtime.YangModelRegistry; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Iterator; + +import static org.onosproject.yang.runtime.helperutils.YangApacheUtils.getYangModel; + +/** + * The IETF net l3vpn manager implementation. + */ +@Component(immediate = true) +public class NetL3vpnManager { + + private static final String APP_ID = "org.onosproject.app.l3vpn"; + private final Logger log = LoggerFactory.getLogger(getClass()); + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected CoreService coreService; + + @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY) + protected YangModelRegistry modelRegistry; + + private ModelRegistrationParam regParam = null; + + @Activate + protected void activate() { + coreService.registerApplication(APP_ID); + log.info("Started"); + //TODO implementation + } + + @Deactivate + protected void deactivate() { + modelRegistry.unregisterModel(regParam); + log.info("Stopped"); + } + + private void registerModel() { + YangModel model = getYangModel(getClass()); + Iterator it = model.getYangModulesId().iterator(); + + //Create model registration param. + ModelRegistrationParam.Builder b = + DefaultModelRegistrationParam.builder().setYangModel(model); + + YangModuleId id; + while (it.hasNext()) { + id = it.next(); + switch (id.moduleName()) { + case "ietf-inet-types": + b.addAppModuleInfo(id, new DefaultAppModuleInfo( + IetfInetTypes.class, null)); + break; + case "ietf-l3vpn-svc": + b.addAppModuleInfo(id, new DefaultAppModuleInfo( + IetfL3VpnSvc.class, null)); + break; + case "ietf-yang-types": + b.addAppModuleInfo(id, new DefaultAppModuleInfo( + IetfYangTypes.class, null)); + break; + case "l3vpn-svc-ext": + b.addAppModuleInfo(id, new DefaultAppModuleInfo( + L3VpnSvcExt.class, null)); + break; + default: + break; + } + } + regParam = b.build(); + modelRegistry.registerModel(regParam); + } +} diff --git a/apps/l3vpn/netl3vpn/src/main/java/org/onosproject/l3vpn/netl3vpn/package-info.java b/apps/l3vpn/netl3vpn/src/main/java/org/onosproject/l3vpn/netl3vpn/package-info.java new file mode 100644 index 0000000000..de5783a952 --- /dev/null +++ b/apps/l3vpn/netl3vpn/src/main/java/org/onosproject/l3vpn/netl3vpn/package-info.java @@ -0,0 +1,20 @@ +/* + * Copyright 2017-present Open Networking Laboratory + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * The implementations of IETF l3vpn net YANG. + */ +package org.onosproject.l3vpn.netl3vpn; diff --git a/apps/l3vpn/pom.xml b/apps/l3vpn/pom.xml new file mode 100644 index 0000000000..faa3170601 --- /dev/null +++ b/apps/l3vpn/pom.xml @@ -0,0 +1,47 @@ + + + + 4.0.0 + + + org.onosproject + onos-apps + 1.10.0-SNAPSHOT + ../pom.xml + + + onos-app-l3vpn + pom + + + + org.onosproject + onos-yang-model + 1.12.0-b5 + + + + + netl3vpn + yangmodel + + + L3VPN YANG Application + + diff --git a/apps/l3vpn/yangmodel/BUCK b/apps/l3vpn/yangmodel/BUCK new file mode 100644 index 0000000000..386be7b60f --- /dev/null +++ b/apps/l3vpn/yangmodel/BUCK @@ -0,0 +1,13 @@ +COMPILE_DEPS = [ + '//lib:CORE_DEPS', + '//lib:onos-yang-model', +] + +yang_osgi_jar( + deps = COMPILE_DEPS, + name = 'onos-apps-l3vpn-yangmodel', + srcs = glob(['src/main/**/*.yang']), + visibility = [ + 'PUBLIC' + ], +) \ No newline at end of file diff --git a/apps/l3vpn/yangmodel/pom.xml b/apps/l3vpn/yangmodel/pom.xml new file mode 100644 index 0000000000..a2bfbd22b0 --- /dev/null +++ b/apps/l3vpn/yangmodel/pom.xml @@ -0,0 +1,51 @@ + + + + 4.0.0 + + + org.onosproject + onos-app-l3vpn + 1.10.0-SNAPSHOT + ../pom.xml + + + onos-app-l3vpn-yangmodel + bundle + + IETF L3VPN YANG models + + + + + org.onosproject + onos-yang-maven-plugin + 1.11 + + + + yang2java + + + + + + + + diff --git a/apps/l3vpn/yangmodel/src/main/yang/ietf-inet-types.yang b/apps/l3vpn/yangmodel/src/main/yang/ietf-inet-types.yang new file mode 100755 index 0000000000..51a44a3081 --- /dev/null +++ b/apps/l3vpn/yangmodel/src/main/yang/ietf-inet-types.yang @@ -0,0 +1,454 @@ + module ietf-inet-types { + + yang-version 1; + + namespace + "urn:ietf:params:xml:ns:yang:ietf-inet-types"; + + prefix inet; + + organization + "IETF NETMOD (NETCONF Data Modeling Language) Working Group"; + + contact + "WG Web: + WG List: + + WG Chair: David Kessens + + + WG Chair: Juergen Schoenwaelder + + + Editor: Juergen Schoenwaelder + "; + + description + "This module contains a collection of generally useful derived + YANG data types for Internet addresses and related things. + + Copyright (c) 2013 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject + to the license terms contained in, the Simplified BSD License + set forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (http://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 6991; see + the RFC itself for full legal notices."; + + revision "2013-07-15" { + description + "This revision adds the following new data types: + - ip-address-no-zone + - ipv4-address-no-zone + - ipv6-address-no-zone"; + reference + "RFC 6991: Common YANG Data Types"; + + } + + revision "2010-09-24" { + description "Initial revision."; + reference + "RFC 6021: Common YANG Data Types"; + + } + + + typedef ip-version { + type enumeration { + enum "unknown" { + value 0; + description + "An unknown or unspecified version of the Internet + protocol."; + } + enum "ipv4" { + value 1; + description + "The IPv4 protocol as defined in RFC 791."; + } + enum "ipv6" { + value 2; + description + "The IPv6 protocol as defined in RFC 2460."; + } + } + description + "This value represents the version of the IP protocol. + + In the value set and its semantics, this type is equivalent + to the InetVersion textual convention of the SMIv2."; + reference + "RFC 791: Internet Protocol + RFC 2460: Internet Protocol, Version 6 (IPv6) Specification + RFC 4001: Textual Conventions for Internet Network Addresses"; + + } + + typedef dscp { + type uint8 { + range "0..63"; + } + description + "The dscp type represents a Differentiated Services Code Point + that may be used for marking packets in a traffic stream. + In the value set and its semantics, this type is equivalent + to the Dscp textual convention of the SMIv2."; + reference + "RFC 3289: Management Information Base for the Differentiated + Services Architecture + RFC 2474: Definition of the Differentiated Services Field + (DS Field) in the IPv4 and IPv6 Headers + RFC 2780: IANA Allocation Guidelines For Values In + the Internet Protocol and Related Headers"; + + } + + typedef ipv6-flow-label { + type uint32 { + range "0..1048575"; + } + description + "The ipv6-flow-label type represents the flow identifier or Flow + Label in an IPv6 packet header that may be used to + discriminate traffic flows. + + In the value set and its semantics, this type is equivalent + to the IPv6FlowLabel textual convention of the SMIv2."; + reference + "RFC 3595: Textual Conventions for IPv6 Flow Label + RFC 2460: Internet Protocol, Version 6 (IPv6) Specification"; + + } + + typedef port-number { + type uint16 { + range "0..65535"; + } + description + "The port-number type represents a 16-bit port number of an + Internet transport-layer protocol such as UDP, TCP, DCCP, or + SCTP. Port numbers are assigned by IANA. A current list of + all assignments is available from . + + Note that the port number value zero is reserved by IANA. In + situations where the value zero does not make sense, it can + be excluded by subtyping the port-number type. + In the value set and its semantics, this type is equivalent + to the InetPortNumber textual convention of the SMIv2."; + reference + "RFC 768: User Datagram Protocol + RFC 793: Transmission Control Protocol + RFC 4960: Stream Control Transmission Protocol + RFC 4340: Datagram Congestion Control Protocol (DCCP) + RFC 4001: Textual Conventions for Internet Network Addresses"; + + } + + typedef as-number { + type uint32; + description + "The as-number type represents autonomous system numbers + which identify an Autonomous System (AS). An AS is a set + of routers under a single technical administration, using + an interior gateway protocol and common metrics to route + packets within the AS, and using an exterior gateway + protocol to route packets to other ASes. IANA maintains + the AS number space and has delegated large parts to the + regional registries. + + Autonomous system numbers were originally limited to 16 + bits. BGP extensions have enlarged the autonomous system + number space to 32 bits. This type therefore uses an uint32 + base type without a range restriction in order to support + a larger autonomous system number space. + + In the value set and its semantics, this type is equivalent + to the InetAutonomousSystemNumber textual convention of + the SMIv2."; + reference + "RFC 1930: Guidelines for creation, selection, and registration + of an Autonomous System (AS) + RFC 4271: A Border Gateway Protocol 4 (BGP-4) + RFC 4001: Textual Conventions for Internet Network Addresses + RFC 6793: BGP Support for Four-Octet Autonomous System (AS) + Number Space"; + + } + + typedef ip-address { + type union { + type ipv4-address; + type ipv6-address; + } + description + "The ip-address type represents an IP address and is IP + version neutral. The format of the textual representation + implies the IP version. This type supports scoped addresses + by allowing zone identifiers in the address format."; + reference + "RFC 4007: IPv6 Scoped Address Architecture"; + + } + + typedef ipv4-address { + type string { + pattern + '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])(%[\p{N}\p{L}]+)?'; + } + description + "The ipv4-address type represents an IPv4 address in + dotted-quad notation. The IPv4 address may include a zone + index, separated by a % sign. + + The zone index is used to disambiguate identical address + values. For link-local addresses, the zone index will + typically be the interface index number or the name of an + interface. If the zone index is not present, the default + zone of the device will be used. + + The canonical format for the zone index is the numerical + format"; + } + + typedef ipv6-address { + type string { + pattern + '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(%[\p{N}\p{L}]+)?'; + pattern + '(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)(%.+)?'; + } + description + "The ipv6-address type represents an IPv6 address in full, + mixed, shortened, and shortened-mixed notation. The IPv6 + address may include a zone index, separated by a % sign. + + The zone index is used to disambiguate identical address + values. For link-local addresses, the zone index will + typically be the interface index number or the name of an + interface. If the zone index is not present, the default + zone of the device will be used. + + + + The canonical format of IPv6 addresses uses the textual + representation defined in Section 4 of RFC 5952. The + canonical format for the zone index is the numerical + format as described in Section 11.2 of RFC 4007."; + reference + "RFC 4291: IP Version 6 Addressing Architecture + RFC 4007: IPv6 Scoped Address Architecture + RFC 5952: A Recommendation for IPv6 Address Text + Representation"; + + } + + typedef ip-address-no-zone { + type union { + type ipv4-address-no-zone; + type ipv6-address-no-zone; + } + description + "The ip-address-no-zone type represents an IP address and is + IP version neutral. The format of the textual representation + implies the IP version. This type does not support scoped + addresses since it does not allow zone identifiers in the + address format."; + reference + "RFC 4007: IPv6 Scoped Address Architecture"; + + } + + typedef ipv4-address-no-zone { + type ipv4-address { + pattern '[0-9\.]*'; + } + description + "An IPv4 address without a zone index. This type, derived from + ipv4-address, may be used in situations where the zone is + known from the context and hence no zone index is needed."; + } + + typedef ipv6-address-no-zone { + type ipv6-address { + pattern '[0-9a-fA-F:\.]*'; + } + description + "An IPv6 address without a zone index. This type, derived from + ipv6-address, may be used in situations where the zone is + known from the context and hence no zone index is needed."; + reference + "RFC 4291: IP Version 6 Addressing Architecture + RFC 4007: IPv6 Scoped Address Architecture + RFC 5952: A Recommendation for IPv6 Address Text + Representation"; + + } + + typedef ip-prefix { + type union { + type ipv4-prefix; + type ipv6-prefix; + } + description + "The ip-prefix type represents an IP prefix and is IP + version neutral. The format of the textual representations + implies the IP version."; + } + + typedef ipv4-prefix { + type string { + pattern + '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])/(([0-9])|([1-2][0-9])|(3[0-2]))'; + } + description + "The ipv4-prefix type represents an IPv4 address prefix. + The prefix length is given by the number following the + slash character and must be less than or equal to 32. + + A prefix length value of n corresponds to an IP address + mask that has n contiguous 1-bits from the most + significant bit (MSB) and all other bits set to 0. + + The canonical format of an IPv4 prefix has all bits of + the IPv4 address set to zero that are not part of the + IPv4 prefix."; + } + + typedef ipv6-prefix { + type string { + pattern + '((:|[0-9a-fA-F]{0,4}):)([0-9a-fA-F]{0,4}:){0,5}((([0-9a-fA-F]{0,4}:)?(:|[0-9a-fA-F]{0,4}))|(((25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9]?[0-9])))(/(([0-9])|([0-9]{2})|(1[0-1][0-9])|(12[0-8])))'; + pattern + '(([^:]+:){6}(([^:]+:[^:]+)|(.*\..*)))|((([^:]+:)*[^:]+)?::(([^:]+:)*[^:]+)?)(/.+)'; + } + description + "The ipv6-prefix type represents an IPv6 address prefix. + The prefix length is given by the number following the + slash character and must be less than or equal to 128. + + A prefix length value of n corresponds to an IP address + mask that has n contiguous 1-bits from the most + significant bit (MSB) and all other bits set to 0. + + The IPv6 address should have all bits that do not belong + to the prefix set to zero. + + The canonical format of an IPv6 prefix has all bits of + the IPv6 address set to zero that are not part of the + IPv6 prefix. Furthermore, the IPv6 address is represented + as defined in Section 4 of RFC 5952."; + reference + "RFC 5952: A Recommendation for IPv6 Address Text + Representation"; + + } + + typedef domain-name { + type string { + length "1..253"; + pattern + '((([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.)*([a-zA-Z0-9_]([a-zA-Z0-9\-_]){0,61})?[a-zA-Z0-9]\.?)|\.'; + } + description + "The domain-name type represents a DNS domain name. The + name SHOULD be fully qualified whenever possible. + + Internet domain names are only loosely specified. Section + 3.5 of RFC 1034 recommends a syntax (modified in Section + 2.1 of RFC 1123). The pattern above is intended to allow + for current practice in domain name use, and some possible + future expansion. It is designed to hold various types of + domain names, including names used for A or AAAA records + (host names) and other records, such as SRV records. Note + that Internet host names have a stricter syntax (described + in RFC 952) than the DNS recommendations in RFCs 1034 and + 1123, and that systems that want to store host names in + schema nodes using the domain-name type are recommended to + adhere to this stricter standard to ensure interoperability. + + The encoding of DNS names in the DNS protocol is limited + to 255 characters. Since the encoding consists of labels + prefixed by a length bytes and there is a trailing NULL + byte, only 253 characters can appear in the textual dotted + notation. + + The description clause of schema nodes using the domain-name + type MUST describe when and how these names are resolved to + IP addresses. Note that the resolution of a domain-name value + may require to query multiple DNS records (e.g., A for IPv4 + and AAAA for IPv6). The order of the resolution process and + which DNS record takes precedence can either be defined + explicitly or may depend on the configuration of the + resolver. + + Domain-name values use the US-ASCII encoding. Their canonical + format uses lowercase US-ASCII characters. Internationalized + domain names MUST be A-labels as per RFC 5890."; + reference + "RFC 952: DoD Internet Host Table Specification + RFC 1034: Domain Names - Concepts and Facilities + RFC 1123: Requirements for Internet Hosts -- Application + and Support + RFC 2782: A DNS RR for specifying the location of services + (DNS SRV) + RFC 5890: Internationalized Domain Names in Applications + (IDNA): Definitions and Document Framework"; + + } + + typedef host { + type union { + type ip-address; + type domain-name; + } + description + "The host type represents either an IP address or a DNS + domain name."; + } + + typedef uri { + type string; + description + "The uri type represents a Uniform Resource Identifier + (URI) as defined by STD 66. + + Objects using the uri type MUST be in US-ASCII encoding, + and MUST be normalized as described by RFC 3986 Sections + 6.2.1, 6.2.2.1, and 6.2.2.2. All unnecessary + percent-encoding is removed, and all case-insensitive + characters are set to lowercase except for hexadecimal + digits, which are normalized to uppercase as described in + Section 6.2.2.1. + + The purpose of this normalization is to help provide + unique URIs. Note that this normalization is not + sufficient to provide uniqueness. Two URIs that are + textually distinct after this normalization may still be + equivalent. + + Objects using the uri type may restrict the schemes that + they permit. For example, 'data:' and 'urn:' schemes + might not be appropriate. + + A zero-length URI is not a valid URI. This can be used to + express 'URI absent' where required. + + In the value set and its semantics, this type is equivalent + to the Uri SMIv2 textual convention defined in RFC 5017."; + reference + "RFC 3986: Uniform Resource Identifier (URI): Generic Syntax + RFC 3305: Report from the Joint W3C/IETF URI Planning Interest + Group: Uniform Resource Identifiers (URIs), URLs, + and Uniform Resource Names (URNs): Clarifications + and Recommendations + RFC 5017: MIB Textual Conventions for Uniform Resource + Identifiers (URIs)"; + + } + } \ No newline at end of file diff --git a/apps/l3vpn/yangmodel/src/main/yang/ietf-l3vpn-svc@2016-07-30.yang b/apps/l3vpn/yangmodel/src/main/yang/ietf-l3vpn-svc@2016-07-30.yang new file mode 100755 index 0000000000..dbd60dc36b --- /dev/null +++ b/apps/l3vpn/yangmodel/src/main/yang/ietf-l3vpn-svc@2016-07-30.yang @@ -0,0 +1,2599 @@ +module ietf-l3vpn-svc { + + namespace "urn:ietf:params:xml:ns:yang:ietf-l3vpn-svc"; + + prefix l3vpn-svc; + + import ietf-inet-types { + prefix inet; + } + + import ietf-yang-types { + prefix yang; + } + + organization + "IETF L3SM Working Group"; + + contact + "WG List: <mailto:l3sm@ietf.org> + + Editor: + + "; + + description + "The YANG module defines a generic service configuration + model for Layer 3 VPN common across all of the vendor + implementations."; + + revision 2016-07-30 { + description + "Eliminated warnings"; + reference + "draft-ietf-l3sm-l3vpn-service-yang-11"; + } + + revision 2016-07-05 { + description + "Draft text update"; + reference + "draft-ietf-l3sm-l3vpn-service-yang-11"; + } + revision 2016-06-27 { + description + " + * Removed templates + * Add site-network-access-type + * Add a leaf number-of-dynamic-address in case + of pe-dhcp addressing; + + "; + reference "draft-ietf-l3sm-l3vpn-service-yang-10"; + } + revision 2016-06-10 { + description + "Add site-vpn-flavor NNI"; + reference "draft-ietf-l3sm-l3vpn-service-yang-09"; + } + revision 2016-06-09 { + description + "Traffic protection moved to site level. + Decouple operational-requirements in two containers. + "; + reference "draft-ietf-l3sm-l3vpn-service-yang-08"; + } + revision 2016-06-06 { + description + "Set config false to actual-site-start and stop + Add a container before cloud-access list + Add a container before authorized-sites list + Add a container before denied-sites list + Modified access-diversity modeling + Replacing type placement diversity by an identity"; + reference "draft-ietf-l3sm-l3vpn-service-yang-07"; + } + revision 2016-04-19 { + description + "* remove reference to core routing model : + created new address family identities + * added features + * Modified bearer parameters + * Modified union for ipv4/ipv6 addresses to ip-address + type + * Add BSR parameters for multicast + * Add applications matching for QoS classification + "; + reference "draft-ietf-l3sm-l3vpn-service-yang-06"; + } + revision 2016-04-05 { + description + " + * Added linecard diverse for site diversity + * Added a new diversity enum in placement-diversity : none + * Added state to site location + + "; + reference ""; + } + revision 2016-03-11 { + description + " + * Modify VPN policy and creating a vpn-policy-list + * Add VPN policy reference and VPN ID reference + under site-network-access + "; + reference "draft-ietf-l3sm-l3vpn-service-yang-05"; + } + revision 2016-01-04 { + description + " + * Add extranet-vpn container in vpn-svc + * Creating top level containers + * Refine groupings + * Added site-vpn-flavor + "; + reference "draft-ietf-l3sm-l3vpn-service-yang-03"; + } + revision 2016-01-04 { + description + " + * qos-profile moved to choice + * vpn leaf moved to vpn-id in vpn-policy + * added ordered-by user to qos classification list + * moved traffic protection to access availability + * creating a choice in matching filter for VPN policy + * added dot1p matching field in flow-definition + "; + reference ""; + } + revision 2015-12-07 { + description + " + * A site is now a collection of site-accesses. + This was introduced to support M to N availability. + * Site-availability has been removed, replaced by + availability parameters under site-accesses + * Added transport-constraints within vpn-svc + "; + reference "draft-ietf-l3sm-l3vpn-service-yang-02"; + } + revision 2015-11-03 { + description " + * Add ToS support in match-flow + * nexthop in cascaded lan as mandatory + * customer-specific-info deleted and moved to routing + protocols + * customer-lan-connection modified : need prefix and CE address + * add choice in managing PE-CE addressing + * Simplifying traffic protection + "; + reference ""; + } + revision 2015-09-10 { + description " + * Refine groupings for vpn-svc + * Removed name in vpn-svc + * id in vpn-svc moved to string + * Rename id in vpn-svc to vpn-id + * Changed key of vpn-svc list to vpn-id + * Add DSCP support in flow definition + "; + reference ""; + } + revision 2015-08-07 { + description + " + Multicast : + * Removed ACL from security + * Add FW for site and cloud access + "; + reference ""; + } + revision 2015-08-05 { + description + " + Multicast : + * Removed anycast-rp identity as discovery mechanism + * Added rp-group mappings for multicast + * Added flag for provider managed RP. + "; + reference ""; + } + revision 2015-08-03 { + description + " * Creating multiple reusable groupings + * Added mpls leaf in vpn-svc for carrier's carrier case + * Modify identity single to single-site + * Modify site-type to site-role and also child identities. + * Creating OAM container under site and moved BFD in. + * Creating flow-definition grouping to be reused + in ACL, QoS ... + * Simplified VPN policy. + * Adding multicast static group to RP mappings. + * Removed native-vpn and site-role from global site + cfg, now managed within the VPN policy. + * Creating a separate list for site templates. + "; + reference "draft-ietf-l3sm-l3vpn-service-yang-01"; + } + revision 2015-07-02 { + reference "draft-ietf-l3sm-l3vpn-service-yang-00"; + } + revision 2015-04-24 { + description " + * Add encryption parameters + * Adding holdtime for BFD. + * Add postal address in location + "; + reference "draft-lstd-l3sm-l3vpn-service-yang-00"; + } + revision 2015-02-05 { + description "Initial revision."; + reference "draft-l3vpn-service-yang-00"; + } + + /* Features */ + + feature cloud-access { + description + "Allow VPN to connect to a Cloud Service + provider."; + } + feature multicast { + description + "Enables multicast capabilities in a VPN"; + } + feature ipv4 { + description + "Enables IPv4 support in a VPN"; + } + feature ipv6 { + description + "Enables IPv6 support in a VPN"; + } + feature carrierscarrier { + description + "Enables support of carrier's carrier"; + } + feature traffic-engineering { + description + "Enables support of transport constraint."; + } + feature traffic-engineering-multicast { + description + "Enables support of transport constraint + for multicast."; + } + feature extranet-vpn { + description + "Enables support of extranet VPNs"; + } + feature site-diversity { + description + "Enables support of site diversity constraints"; + } + feature encryption { + description + "Enables support of encryption"; + } + feature qos { + description + "Enables support of Class of Services"; + } + feature qos-custom { + description + "Enables support of custom qos profile"; + } + feature rtg-bgp { + description + "Enables support of BGP routing protocol."; + } + feature rtg-rip { + description + "Enables support of RIP routing protocol."; + } + feature rtg-ospf { + description + "Enables support of OSPF routing protocol."; + } + feature rtg-ospf-sham-link { + description + "Enables support of OSPF sham-links."; + } + feature rtg-vrrp { + description + "Enables support of VRRP routing protocol."; + } + feature fast-reroute { + description + "Enables support of Fast Reroute."; + } + feature bfd { + description + "Enables support of BFD."; + } + feature always-on { + description + "Enables support for always-on access + constraint."; + } + feature requested-type { + description + "Enables support for requested-type access + constraint."; + } + feature bearer-reference { + description + "Enables support for bearer-reference access + constraint."; + } + + /* Typedefs */ + + typedef svc-id { + type string; + description + "Defining a type of service component + identificators."; + } + + typedef template-id { + type string; + description + "Defining a type of service template + identificators."; + } + + /* Identities */ + + identity site-network-access-type { + description + "Base identity for site-network-access type"; + } + identity point-to-point { + base site-network-access-type; + description + "Identity for point-to-point connection"; + } + identity multipoint { + base site-network-access-type; + description + "Identity for multipoint connection + Example : ethernet broadcast segment"; + } + identity placement-diversity { + description + "Base identity for site placement + constraints"; + } + identity pe-diverse { + base placement-diversity; + description + "Identity for PE diversity"; + } + identity pop-diverse { + base placement-diversity; + description + "Identity for POP diversity"; + } + identity linecard-diverse { + base placement-diversity; + description + "Identity for linecard diversity"; + } + identity same-pe { + base placement-diversity; + description + "Identity for having sites connected + on the same PE"; + } + identity same-bearer { + base placement-diversity; + description + "Identity for having sites connected + using the same bearer"; + } + identity customer-application { + description + "Base identity for customer application"; + } + identity web { + base customer-application; + description + "Identity for web application (e.g. HTTP,HTTPS)"; + } + identity mail { + base customer-application; + description + "Identity for mail applications"; + } + identity file-transfer { + base customer-application; + description + "Identity for file transfer applications ( + e.g. FTP, SFTP, ...)"; + } + identity database { + base customer-application; + description + "Identity for database applications"; + } + identity social { + base customer-application; + description + "Identity for social network applications"; + } + identity games { + base customer-application; + description + "Identity for gaming applications"; + } + identity p2p { + base customer-application; + description + "Identity for peer to peer applications"; + } + identity network-management { + base customer-application; + description + "Identity for management applications (e.g. telnet + syslog, snmp ...)"; + } + identity voice { + base customer-application; + description + "Identity for voice applications"; + } + identity video { + base customer-application; + description + "Identity for video conference applications"; + } + identity address-family { + description + "Base identity for an address family."; + } + identity ipv4 { + base address-family; + description + "Identity for IPv4 address family."; + } + identity ipv6 { + base address-family; + description + "Identity for IPv6 address family."; + } + identity site-vpn-flavor { + description + "Base identity for the site VPN service flavor."; + } + identity site-vpn-flavor-single { + base site-vpn-flavor; + description + "Base identity for the site VPN service flavor. + Used when the site belongs to only one VPN."; + } + identity site-vpn-flavor-multi { + base site-vpn-flavor; + description + "Base identity for the site VPN service flavor. + Used when a logical connection of a site + belongs to multiple VPNs."; + } + identity site-vpn-flavor-sub { + base site-vpn-flavor; + description + "Base identity for the site VPN service flavor. + Used when a site has multiple logical connections. + Each of the connection may belong to different + multiple VPNs."; + } + identity site-vpn-flavor-nni { + base site-vpn-flavor; + description + "Base identity for the site VPN service flavor. + Used to describe a NNI option A connection."; + } + identity transport-constraint { + description + "Base identity for transport constraint."; + } + identity tc-latency { + base transport-constraint; + description + "Base identity for transport constraint + based on latency."; + } + identity tc-jitter { + base transport-constraint; + description + "Base identity for transport constraint + based on jitter."; + } + identity tc-bandwidth { + base transport-constraint; + description + "Base identity for transport constraint + based on bandwidth."; + } + identity tc-path-diversity { + base transport-constraint; + description + "Base identity for transport constraint + based on path diversity."; + } + identity tc-site-diversity { + base transport-constraint; + description + "Base identity for transport constraint + based on site diversity."; + } + identity management { + description + "Base identity for site management scheme."; + } + identity co-managed { + base management; + description + "Base identity for comanaged site."; + } + identity customer-managed { + base management; + description + "Base identity for customer managed site."; + } + identity provider-managed { + base management; + description + "Base identity for provider managed site."; + } + identity address-allocation-type { + description + "Base identity for address-allocation-type + for PE-CE link."; + } + identity pe-dhcp { + base address-allocation-type; + description + "PE router provides DHCP service to CE."; + } + identity static-address { + base address-allocation-type; + description + "PE-CE addressing is static."; + } + identity slaac { + base address-allocation-type; + description + "Use IPv6 SLAAC."; + } + identity site-role { + description + "Base identity for site type."; + } + identity any-to-any-role { + base site-role; + description + "Site in a any to any IPVPN."; + } + identity spoke-role { + base site-role; + description + "Spoke Site in a Hub & Spoke IPVPN."; + } + identity hub-role { + base site-role; + description + "Hub Site in a Hub & Spoke IPVPN."; + } + identity vpn-topology { + description + "Base identity for VPN topology."; + } + identity any-to-any { + base vpn-topology; + description + "Identity for any to any VPN topology."; + } + identity hub-spoke { + base vpn-topology; + description + "Identity for Hub'n'Spoke VPN topology."; + } + identity hub-spoke-disjoint { + base vpn-topology; + description + "Identity for Hub'n'Spoke VPN topology + where Hubs cannot talk between each other."; + } + identity multicast-tree-type { + description + "Base identity for multicast tree type."; + } + identity ssm-tree-type { + base multicast-tree-type; + description + "Identity for SSM tree type."; + } + identity asm-tree-type { + base multicast-tree-type; + description + "Identity for ASM tree type."; + } + identity bidir-tree-type { + base multicast-tree-type; + description + "Identity for BiDir tree type."; + } + identity multicast-rp-discovery-type { + description + "Base identity for rp discovery type."; + } + identity auto-rp { + base multicast-rp-discovery-type; + description + "Base identity for auto-rp discovery type."; + } + identity static-rp { + base multicast-rp-discovery-type; + description + "Base identity for static type."; + } + identity bsr-rp { + base multicast-rp-discovery-type; + description + "Base identity for BDR discovery type."; + } + identity routing-protocol-type { + description + "Base identity for routing-protocol type."; + } + identity ospf { + base routing-protocol-type; + description + "Identity for OSPF protocol type."; + } + identity bgp { + base routing-protocol-type; + description + "Identity for BGP protocol type."; + } + identity static { + base routing-protocol-type; + description + "Identity for static routing protocol type."; + } + identity rip { + base routing-protocol-type; + description + "Identity for RIP protocol type."; + } + identity rip-ng { + base routing-protocol-type; + description + "Identity for RIPng protocol type."; + } + identity vrrp { + base routing-protocol-type; + description + "Identity for VRRP protocol type. + This is to be used when LAn are directly connected + to provider Edge routers."; + } + identity direct { + base routing-protocol-type; + description + "Identity for direct protocol type. + ."; + } + identity protocol-type { + description + "Base identity for protocol field type."; + } + identity tcp { + base protocol-type; + description + "TCP protocol type."; + } + identity udp { + base protocol-type; + description + "UDP protocol type."; + } + identity icmp { + base protocol-type; + description + "icmp protocol type."; + } + identity icmp6 { + base protocol-type; + description + "icmp v6 protocol type."; + } + identity gre { + base protocol-type; + description + "GRE protocol type."; + } + identity ipip { + base protocol-type; + description + "IPinIP protocol type."; + } + identity hop-by-hop { + base protocol-type; + description + "Hop by Hop IPv6 header type."; + } + identity routing { + base protocol-type; + description + "Routing IPv6 header type."; + } + identity esp { + base protocol-type; + description + "ESP header type."; + } + identity ah { + base protocol-type; + description + "AH header type."; + } + + /* Groupings */ + + grouping vpn-service-cloud-access { + container cloud-accesses { + list cloud-access { + if-feature cloud-access; + key cloud-identifier; + + leaf cloud-identifier { + type string; + description + "Identification of cloud service. Local + admin meaning."; + } + container authorized-sites { + list authorized-site { + key site-id; + + leaf site-id { + type leafref { + path "/l3vpn-svc/sites/site/site-id"; + } + description + "Site ID."; + } + description + "List of authorized sites."; + } + description + "Configuration of authorized sites"; + } + container denied-sites { + list denied-site { + key site-id; + + leaf site-id { + type leafref { + path "/l3vpn-svc/sites/site/site-id"; + } + description + "Site ID."; + } + description + "List of denied sites."; + } + description + "Configuration of denied sites"; + } + leaf nat-enabled { + type boolean; + description + "Control if NAT is required or not."; + } + leaf customer-nat-address { + type inet:ipv4-address; + description + "NAT address to be used in case of public + or shared cloud. + This is to be used in case customer is providing + the public address."; + } + description + "Cloud access configuration."; + } + description + "Container for cloud access configurations"; + } + description + "grouping for vpn cloud definition"; + } + + grouping multicast-rp-group-cfg { + choice group-format { + case startend { + leaf group-start { + type inet:ip-address; + description + "First group address."; + } + leaf group-end { + type inet:ip-address; + description + "Last group address."; + } + } + case singleaddress { + leaf group-address { + type inet:ip-address; + description + "Group address"; + } + } + description + "Choice for group format."; + } + description + "Definition of groups for + RP to group mapping."; + } + + grouping vpn-service-multicast { + container multicast { + if-feature multicast; + leaf enabled { + type boolean; + default false; + description + "Enable multicast."; + } + container customer-tree-flavors { + list tree-flavor { + key type; + + leaf type { + type identityref { + base multicast-tree-type; + } + description + "Type of tree to be used."; + } + description + "List of tree flavors."; + } + description + "Type of trees used by customer."; + } + container rp { + container rp-group-mappings { + list rp-group-mapping { + key "id"; + + leaf id { + type uint16; + description + "Unique identifier for the mapping."; + } + container provider-managed { + leaf enabled { + type boolean; + default false; + description + "Set to true, if the RP must be a + provider + managed node. + Set to false, if it is a customer + managed node."; + } + + leaf rp-redundancy { + when "../enabled = 'true'" { + description + "Relevant when RP + is provider managed."; + } + type boolean; + default false; + description + "If true, redundancy + mechanism for RP is required."; + } + leaf optimal-traffic-delivery { + when "../enabled = 'true'" { + description + "Relevant when RP + is provider managed."; + } + type boolean; + default false; + description + "If true, SP must ensure + that traffic uses an optimal path."; + } + description + "Parameters for provider managed RP."; + } + + leaf rp-address { + when "../provider-managed/enabled='false'" { + description + "Relevant when RP + is provider managed."; + } + type inet:ip-address; + description + "Defines the address of the + RendezvousPoint. + Used if RP is customer managed."; + } + + container groups { + list group { + key id; + + leaf id { + type uint16; + description + "Identifier for the group."; + } + uses multicast-rp-group-cfg; + description + "List of groups."; + } + description + "Multicast groups associated with RP."; + } + + description + "List of RP to group mappings."; + } + description + "RP to group mappings."; + } + container rp-discovery { + leaf rp-discovery-type { + type identityref { + base multicast-rp-discovery-type; + } + default static-rp; + description + "Type of RP discovery used."; + } + container bsr-candidates { + when "../rp-discovery-type='bsr-rp'" { + description + "Only applicable if discovery type + is BSR-RP"; + } + list bsr-candidate { + key address; + + leaf address { + type inet:ip-address; + description + "Address of BSR candidate"; + } + + description + "List of customer BSR candidates"; + } + description + "Customer BSR candidates address"; + } + description + "RP discovery parameters"; + } + + description + "RendezvousPoint parameters."; + } + description + "Multicast global parameters for the VPN service."; + } + description + "grouping for multicast vpn definition"; + } + + grouping vpn-service-mpls { + leaf carrierscarrier { + if-feature carrierscarrier; + type boolean; + default false; + description + "The VPN is using Carrier's Carrier, + and so MPLS is required."; + } + description + "grouping for mpls CsC definition"; + } + + grouping customer-location-info { + container location { + leaf address { + type string; + description + "Address (number and street) + of the site."; + + } + leaf zip-code { + type string; + description + "ZIP code of the site."; + } + leaf state { + type string; + description + "State of the site. + This leaf can also be used + to describe a region + for country who does not have + states. + "; + } + leaf city { + type string; + description + "City of the site."; + } + leaf country-code { + type string; + description + "Country of the site."; + } + description + "Location of the site."; + } + description + "This grouping defines customer location + parameters"; + } + + grouping site-diversity { + container site-diversity { + if-feature site-diversity; + + container groups { + list group { + key group-id; + + leaf group-id { + type string; + description + "Group-id the site + is belonging to"; + } + description + "List of group-id"; + } + description + "Groups the site + is belonging to. + All site network accesses will + inherit those group values."; + } + description + "Diversity constraint type."; + } + description + "This grouping defines site diversity + parameters"; + } + + grouping access-diversity { + container access-diversity { + if-feature site-diversity; + container groups { + list group { + key group-id; + + leaf group-id { + type string; + description + "Group-id the site network access + is belonging to"; + } + description + "List of group-id"; + } + description + "Groups the site network access + is belonging to"; + } + container constraints { + list constraint { + key constraint-type; + + leaf constraint-type { + type identityref { + base placement-diversity; + } + description + "Diversity constraint type."; + } + container target { + choice target-flavor { + case id { + list group { + key group-id; + + leaf group-id { + type string; + description + "The constraint will apply + against this particular + group-id"; + } + description + "List of groups"; + } + } + case all-accesses { + leaf all-other-accesses { + type empty; + description + "The constraint will apply + against all other site network + access + of this site"; + } + } + case all-groups { + leaf all-other-groups { + type empty; + description + "The constraint will apply + against all other groups the + customer + is managing"; + } + } + description + "Choice for the group definition"; + } + description + "The constraint will apply against + this list of groups"; + } + description + "List of constraints"; + } + description + "Constraints for placing this site + network access"; + } + + description + "Diversity parameters."; + } + description + "This grouping defines access diversity + parameters"; + } + + grouping operational-requirements { + leaf requested-site-start { + type yang:date-and-time; + description + "Optional leaf indicating requested date + and time + when the service at a particular site is + expected + to start"; + } + + leaf requested-site-stop { + type yang:date-and-time; + description + "Optional leaf indicating requested date + and time + when the service at a particular site is + expected + to stop"; + } + description + "This grouping defines some operational parameters + parameters"; + } + + grouping operational-requirements-ops { + leaf actual-site-start { + type yang:date-and-time; + config false; + description + "Optional leaf indicating actual date + and time + when the service at a particular site + actually + started"; + } + leaf actual-site-stop { + type yang:date-and-time; + config false; + description + "Optional leaf indicating actual date + and time + when the service at a particular site + actually + stopped"; + } + description + "This grouping defines some operational parameters + parameters"; + } + + grouping flow-definition { + container match-flow { + leaf dscp { + type uint8 { + range "0 .. 63"; + } + description + "DSCP value."; + } + leaf tos { + type uint8 { + range "0 .. 254"; + } + description + "TOS value."; + } + leaf dot1p { + type uint8 { + range "0 .. 7"; + } + description + "802.1p matching."; + } + leaf ipv4-src-prefix { + type inet:ipv4-prefix; + description + "Match on IPv4 src address."; + } + leaf ipv6-src-prefix { + type inet:ipv6-prefix; + description + "Match on IPv6 src address."; + } + leaf ipv4-dst-prefix { + type inet:ipv4-prefix; + description + "Match on IPv4 dst address."; + } + leaf ipv6-dst-prefix { + type inet:ipv6-prefix; + description + "Match on IPv6 dst address."; + } + leaf l4-src-port { + type uint16; + description + "Match on layer 4 src port."; + } + leaf l4-dst-port { + type uint16; + description + "Match on layer 4 dst port."; + } + leaf protocol-field { + type union { + type uint8; + type identityref { + base protocol-type; + } + } + description + "Match on IPv4 protocol or + Ipv6 Next Header + field."; + } + + description + "Describe flow matching + criterions."; + } + description + "Flow definition based on criteria."; + } + + grouping site-service-basic { + leaf svc-input-bandwidth { + type uint32; + units bps; + description + "From the PE perspective, the service input + bandwidth of the connection."; + } + leaf svc-output-bandwidth { + type uint32; + units bps; + description + "From the PE perspective, the service output + bandwidth of the connection."; + } + leaf svc-mtu { + type uint16; + units bytes; + description + "MTU at service level. + If the service is IP, + it refers to the IP MTU."; + } + description + "Defines basic service parameters for a site."; + } + + grouping site-protection { + container traffic-protection { + if-feature fast-reroute; + leaf enabled { + type boolean; + description + "Enables + traffic protection of access link."; + } + + description + "Fast reroute service parameters + for the site."; + } + description + "Defines protection service parameters for a site."; + } + + grouping site-service-mpls { + container carrierscarrier { + if-feature carrierscarrier; + leaf signalling-type { + type enumeration { + enum "ldp" { + description + "Use LDP as signalling + protocol between PE and CE."; + } + enum "bgp" { + description + "Use BGP 3107 as signalling + protocol between PE and CE. + In this case, bgp must be also + configured + as routing-protocol. + "; + } + } + description + "MPLS signalling type."; + } + description + "This container is used when customer provides + MPLS based services. + This is used in case of Carrier's + Carrier."; + } + description + "Defines MPLS service parameters for a site."; + } + + grouping site-service-qos-profile { + container qos { + if-feature qos; + container qos-classification-policy { + list rule { + key id; + ordered-by user; + + leaf id { + type uint16; + description + "ID of the rule."; + } + + choice match-type { + case match-flow { + uses flow-definition; + } + case match-application { + leaf match-application { + type identityref { + base customer-application; + } + description + "Defines the application + to match."; + } + } + description + "Choice for classification"; + } + + leaf target-class-id { + type string; + description + "Identification of the + class of service. + This identifier is internal to + the administration."; + } + + description + "List of marking rules."; + } + description + "Need to express marking rules ..."; + } + container qos-profile { + + choice qos-profile { + description + "Choice for QoS profile. + Can be standard profile or custom."; + case standard { + leaf profile { + type string; + description + "QoS profile to be used"; + } + } + case custom { + container classes { + if-feature qos-custom; + list class { + key class-id; + + leaf class-id { + type string; + description + "Identification of the + class of service. + This identifier is internal to + the administration."; + } + leaf rate-limit { + type uint8; + units percent; + description + "To be used if class must + be rate + limited. Expressed as + percentage of the svc-bw."; + } + leaf priority-level { + type uint8; + description + "Defines the level of the + class in + term of priority queueing. + The higher the level is the + higher + is the priority."; + } + leaf guaranteed-bw-percent { + type uint8; + units percent; + description + "To be used to define the + guaranteed + BW in percent of the svc-bw + available at the priority-level."; + } + description + "List of class of services."; + } + description + "Container for + list of class of services."; + } + + } + + } + description + "Qos profile configuration."; + } + description + "QoS configuration."; + } + description + "This grouping defines QoS parameters + for a site"; + + } + + grouping site-security-authentication { + container authentication { + description + "Authentication parameters"; + } + description + "This grouping defines authentication + parameters + for a site"; + } + + grouping site-security-encryption { + container encryption { + if-feature encryption; + leaf enabled { + type boolean; + description + "If true, access encryption is required."; + } + leaf layer { + type enumeration { + enum layer2 { + description + "Encryption will occur at layer2."; + } + enum layer3 { + description + "IPSec is requested."; + } + } + description + "Layer on which encryption is applied."; + } + container encryption-profile { + choice profile { + case provider-profile { + leaf profile-name { + type string; + description + "Name of the SP profile + to be applied."; + } + } + case customer-profile { + leaf algorithm { + type string; + description + "Encryption algorithm to + be used."; + } + choice key-type { + case psk { + leaf preshared-key { + type string; + description + "Key coming from + customer."; + } + } + case pki { + + } + description + "Type of keys to be used."; + } + } + description + "Choice of profile."; + } + description + "Profile of encryption to be applied."; + } + description + "Encryption parameters."; + } + description + "This grouping defines encryption parameters + for a site"; + } + + grouping site-attachment-bearer { + container bearer { + container requested-type { + if-feature requested-type; + leaf requested-type { + type string; + description + "Type of requested bearer Ethernet, DSL, + Wireless ... + Operator specific."; + } + leaf strict { + type boolean; + default false; + description + "define if the requested-type is a preference + or a strict requirement."; + } + description + "Container for requested type."; + } + leaf always-on { + if-feature always-on; + type boolean; + default true; + description + "Request for an always on access type. + This means no Dial access type for + example."; + } + leaf bearer-reference { + if-feature bearer-reference; + type string; + description + "This is an internal reference for the + service provider. + Used "; + } + description + "Bearer specific parameters. + To be augmented."; + } + description + "Defines physical properties of + a site attachment."; + } + + grouping site-routing { + container routing-protocols { + list routing-protocol { + key type; + + leaf type { + type identityref { + base routing-protocol-type; + } + description + "Type of routing protocol."; + } + + + container ospf { + when "../type = 'ospf'" { + description + "Only applies + when protocol is OSPF."; + } + if-feature rtg-ospf; + leaf-list address-family { + type identityref { + base address-family; + } + description + "Address family to be activated."; + } + leaf area-address { + type yang:dotted-quad; + description + "Area address."; + } + leaf metric { + type uint16; + description + "Metric of PE-CE link."; + } + container sham-links { + if-feature rtg-ospf-sham-link; + list sham-link { + key target-site; + + leaf target-site { + type svc-id; + description + "Target site for the sham link + connection. + The site is referred through it's ID."; + } + leaf metric { + type uint16; + description + "Metric of the sham link."; + } + description + "Creates a shamlink with another + site"; + } + description + "List of Sham links"; + } + description + "OSPF specific configuration."; + } + + container bgp { + + when "../type = 'bgp'" { + description + "Only applies when + protocol is BGP."; + } + if-feature rtg-bgp; + leaf autonomous-system { + type uint32; + description + "AS number."; + } + leaf-list address-family { + type identityref { + base address-family; + } + description + "Address family to be activated."; + } + description + "BGP specific configuration."; + } + container static { + when "../type = 'static'" { + description + "Only applies when protocol + is static."; + } + + container cascaded-lan-prefixes { + list ipv4-lan-prefixes { + if-feature ipv4; + key "lan next-hop"; + + leaf lan { + type inet:ipv4-prefix; + description + "Lan prefixes."; + } + leaf lan-tag { + type string; + description + "Internal tag to be used in vpn + policies."; + } + leaf next-hop { + type inet:ipv4-address; + description + "Nexthop address to use at customer + side."; + } + description " + List of LAN prefixes for + the site. + "; + } + list ipv6-lan-prefixes { + if-feature ipv6; + key "lan next-hop"; + + leaf lan { + type inet:ipv6-prefix; + description + "Lan prefixes."; + } + leaf lan-tag { + type string; + description + "Internal tag to be used + in vpn policies."; + } + leaf next-hop { + type inet:ipv6-address; + description + "Nexthop address to use at + customer side."; + } + description " + List of LAN prefixes for the site. + "; + } + description + "LAN prefixes from the customer."; + } + description + "Static routing + specific configuration."; + } + container rip { + + when "../type = 'rip'" { + description + "Only applies when + protocol is RIP."; + } + if-feature rtg-rip; + leaf-list address-family { + type identityref { + base address-family; + } + description + "Address family to be + activated."; + } + + description + "RIP routing specific + configuration."; + } + + + container vrrp { + + when "../type = 'vrrp'" { + description + "Only applies when + protocol is VRRP."; + } + if-feature rtg-vrrp; + leaf-list address-family { + type identityref { + base address-family; + } + description + "Address family to be activated."; + } + description + "VRRP routing specific configuration."; + } + + + description + "List of routing protocols used + on the site. + Need to be augmented."; + } + description + "Defines routing protocols."; + } + description + "Grouping for routing protocols."; + } + + grouping site-attachment-ip-connection { + container ip-connection { + container ipv4 { + if-feature ipv4; + leaf address-allocation-type { + type identityref { + base address-allocation-type; + } + + default "static-address"; + description + "Defines how addresses are allocated. + "; + } + + leaf number-of-dynamic-address { + when + "../address-allocation-type = 'pe-dhcp'" + { + description + "Only applies when + protocol allocation type is static"; + } + type uint8; + default 1; + description + "Describes the number of IP addresses the + customer requires"; + } + container addresses { + when + "../address-allocation-type = 'static-address'" { + description + "Only applies when + protocol allocation type is static"; + } + leaf provider-address { + type inet:ipv4-address; + description + "Provider side address."; + } + leaf customer-address { + type inet:ipv4-address; + description + "Customer side address."; + } + leaf mask { + type uint8 { + range "0..32"; + } + description + "Subnet mask expressed + in bits"; + } + description + "Describes IP addresses used"; + } + description + "IPv4 specific parameters"; + + } + container ipv6 { + if-feature ipv6; + leaf address-allocation-type { + type identityref { + base address-allocation-type; + } + default "static-address"; + description + "Defines how addresses are allocated. + "; + } + leaf number-of-dynamic-address { + when + "../address-allocation-type = 'pe-dhcp'" { + description + "Only applies when + protocol allocation type is static"; + } + type uint8; + default 1; + description + "Describes the number of IP addresses the + customer requires"; + } + container addresses { + when + "../address-allocation-type = 'static-address'" { + description + "Only applies when + protocol allocation type is static"; + } + leaf provider-address { + type inet:ipv6-address; + description + "Provider side address."; + } + leaf customer-address { + type inet:ipv6-address; + description + "Customer side address."; + } + leaf mask { + type uint8 { + range "0..128"; + + } + description + "Subnet mask expressed + in bits"; + } + description + "Describes IP addresses used"; + } + + description + "IPv6 specific parameters"; + + } + container oam { + container bfd { + if-feature bfd; + leaf bfd-enabled { + type boolean; + description + "BFD activation"; + } + + choice holdtime { + case profile { + leaf profile-name { + type string; + description + "Service provider well + known profile."; + } + description + "Service provider well + known profile."; + } + case fixed { + leaf fixed-value { + type uint32; + units msec; + description + "Expected holdtime + expressed + in msec."; + } + } + description + "Choice for holdtime flavor."; + } + description + "Container for BFD."; + } + description + "Define the OAM used on the connection."; + } + description + "Defines connection parameters."; + } + description + "This grouping defines IP connection parameters."; + } + + grouping site-service-multicast { + container multicast { + if-feature multicast; + leaf multicast-site-type { + type enumeration { + enum receiver-only { + description + "The site has only receivers."; + } + enum source-only { + description + "The site has only sources."; + } + enum source-receiver { + description + "The site has both + sources & receivers."; + } + } + default "source-receiver"; + description + "Type of multicast site."; + } + container multicast-transport-protocol { + leaf ipv4 { + if-feature ipv4; + type boolean; + default true; + description + "Enables ipv4 multicast transport"; + } + leaf ipv6 { + if-feature ipv6; + type boolean; + default false; + description + "Enables ipv6 multicast transport"; + } + description + "Defines protocol to transport multicast."; + } + leaf protocol-type { + type enumeration { + enum host { + description + " + Hosts are directly connected + to the provider network. + Host protocols like IGMP, MLD + are required. + "; + } + enum router { + description + " + Hosts are behind a customer router. + PIM will be implemented. + "; + } + enum both { + description + "Some Hosts are behind a customer + router and some others are directly + connected to the provider network. + Both host and routing protocols must be + used. Typically IGMP and PIM will be + implemented. + "; + } + } + default "both"; + description + "Multicast protocol type to be used + with the customer site."; + } + + description + "Multicast parameters for the site."; + } + description + "Multicast parameters for the site."; + } + + grouping site-management { + container management { + leaf type { + type identityref { + base management; + } + description + "Management type of the connection."; + } + leaf management-transport { + type identityref { + base address-family; + } + description + "Transport protocol used for management."; + } + leaf address { + type inet:ip-address; + description + "Management address"; + } + + description + "Management configuration"; + } + description + "Management parameters for the site."; + } + + grouping site-vpn-flavor-profile { + leaf site-vpn-flavor { + type identityref { + base site-vpn-flavor; + } + default site-vpn-flavor-single; + description + "Defines if the site + is a single VPN site, or multiVPN or ..."; + } + description + "Grouping for site-vpn-flavor."; + } + + grouping site-vpn-policy { + container vpn-policy-list { + list vpn-policy { + key vpn-policy-id; + + leaf vpn-policy-id { + type svc-id; + description + "Unique identifier for + the VPN policy."; + } + + list entries { + key id; + + leaf id { + type svc-id; + description + "Unique identifier for + the policy entry."; + } + container filter { + choice lan { + case lan-prefix { + container lan-prefixes { + list ipv4-lan-prefixes { + if-feature ipv4; + key lan; + + leaf lan { + type inet:ipv4-prefix; + description + "Lan prefixes."; + } + description " + List of LAN prefixes + for the site. + "; + } + list ipv6-lan-prefixes { + if-feature ipv6; + key lan; + + leaf lan { + type inet:ipv6-prefix; + description + "Lan prefixes."; + } + description " + List of LAN prefixes + for the site. + "; + } + description + "LAN prefixes from the customer."; + } + } + case lan-tag { + leaf-list lan-tag { + type string; + description + "List of lan-tags to be matched."; + } + } + description + "Choice for LAN matching type"; + } + description + "If used, it permit to split site LANs + among multiple VPNs. + If no filter used, all the LANs will be + part of the same VPNs with the same + role."; + } + container vpn { + leaf vpn-id { + type leafref { + path "/l3vpn-svc/vpn-services/vpn-svc/vpn-id"; + } + mandatory true; + description + "Reference to an IPVPN."; + } + leaf site-role { + type identityref { + base site-role; + } + mandatory true; + description + "Role of the site in the IPVPN."; + } + description + "List of VPNs the LAN is associated to."; + } + description + "List of entries for export policy."; + } + description + "List of VPN policies."; + } + description + "VPN policy."; + } + description + "VPN policy parameters for the site."; + } + + grouping site-maximum-routes { + container maximum-routes { + list address-family { + key af; + + leaf af { + type identityref { + base address-family; + } + description + "Address-family."; + } + leaf maximum-routes { + type uint32; + description + "Maximum prefixes the VRF can + accept for this + address-family."; + } + description + "List of address families."; + } + + description + "Define maximum-routes for the VRF."; + } + description + "Define maximum-routes for the site."; + } + + grouping site-security { + container security { + uses site-security-authentication; + uses site-security-encryption; + + description + "Site specific security parameters."; + } + description + "Grouping for security parameters."; + } + + grouping site-service { + container service { + uses site-service-basic; + uses site-service-qos-profile; + uses site-service-mpls; + uses site-service-multicast; + + description + "Service parameters on the attachement."; + } + description + "Grouping for service parameters."; + } + + grouping transport-constraint-profile { + list constraint-list { + key constraint-type; + + leaf constraint-type { + type identityref { + base transport-constraint; + } + description + "Constraint type to be applied."; + } + leaf constraint-opaque-value { + type string; + description + "Opaque value that can be used to + specify constraint parameters."; + } + description + "List of constraints"; + } + description + "Grouping for transport constraint."; + } + + grouping transport-constraints { + container transport-constraints { + if-feature traffic-engineering; + container unicast-transport-constraints { + list constraint { + key constraint-id; + + leaf constraint-id { + type svc-id; + description + "Defines an ID for the constraint + rule."; + } + + leaf site1 { + type svc-id; + description + "The ID refers to one site end."; + } + leaf site2 { + type svc-id; + description + "The ID refers to the other + site end."; + } + uses transport-constraint-profile; + description + "List of constraints. + Constraints are bidirectional."; + } + description + "Unicast transport constraints."; + } + container multicast-transport-constraints { + if-feature traffic-engineering-multicast; + list constraint { + key constraint-id; + + leaf constraint-id { + type svc-id; + description + "Defines an ID for the constraint + rule."; + } + + leaf src-site { + type svc-id; + description + "The ID refers to source site."; + } + leaf dst-site { + type svc-id; + description + "The ID refers to the receiver + site."; + } + uses transport-constraint-profile; + description + "List of constraints. + Constraints are unidirectional."; + } + description + "Multicast transport constraints."; + } + description + "transport constraints."; + } + description + "Grouping for transport constraints + description."; + } + + grouping vpn-extranet { + container extranet-vpns { + if-feature extranet-vpn; + list extranet-vpn { + key vpn-id; + + leaf vpn-id { + type svc-id; + description + "Identifies the target VPN"; + } + leaf local-sites-role { + type identityref { + base site-role; + } + description + "This describes the role of the + local sites in the target VPN topology."; + } + description + "List of extranet VPNs the local + VPN is attached to."; + } + description + "Container for extranet vpn cfg."; + } + description + "grouping for extranet VPN configuration. + Extranet provides a way to interconnect all sites + from two VPNs in a easy way."; + } + + grouping site-attachment-availability { + container availability { + leaf access-priority { + type uint32; + default 1; + description + "Defines the priority for the access. + The highest the priority value is, + the highest the + preference of the access is."; + } + description + "Availability parameters + (used for multihoming)"; + } + description + "Defines site availability parameters."; + } + + grouping access-vpn-policy { + container vpn-attachment { + choice attachment-flavor { + case vpn-policy-id { + leaf vpn-policy-id { + type leafref { + path "/l3vpn-svc/sites/site/"+ + "vpn-policy-list/vpn-policy/"+ + "vpn-policy-id"; + } + description + "Reference to a VPN policy."; + } + } + case vpn-id { + leaf vpn-id { + type leafref { + path "/l3vpn-svc/vpn-services"+ + "/vpn-svc/vpn-id"; + } + description + "Reference to a VPN."; + } + leaf site-role { + type identityref { + base site-role; + } + mandatory true; + description + "Role of the site in the IPVPN."; + } + } + mandatory true; + description + "Choice for VPN attachment flavor."; + } + description + "Defines VPN attachment of a site."; + } + description + "Defines the VPN attachment rules + for a site logical access."; + } + + grouping vpn-svc-cfg { + leaf vpn-id { + type svc-id; + description + "VPN identifier. Local administration meaning."; + } + leaf customer-name { + type string; + description + "Name of the customer."; + } + leaf topology { + type identityref { + base vpn-topology; + } + default "any-to-any"; + description + "VPN topology."; + } + + uses vpn-service-cloud-access; + uses vpn-service-multicast; + uses vpn-service-mpls; + uses transport-constraints; + uses vpn-extranet; + + description + "grouping for vpn-svc configuration."; + } + + grouping site-top-level-cfg { + uses operational-requirements; + uses customer-location-info; + uses site-diversity; + uses site-management; + uses site-vpn-policy; + uses site-vpn-flavor-profile; + uses site-maximum-routes; + uses site-security; + uses site-service; + uses site-protection; + uses site-routing; + + description + "Grouping for site top level cfg."; + } + + grouping site-network-access-top-level-cfg { + leaf site-network-access-type { + type identityref { + base site-network-access-type; + } + default "point-to-point"; + description + "Describes the type of connection, e.g. : + point-to-point or multipoint"; + } + uses access-diversity; + uses site-attachment-bearer; + uses site-attachment-ip-connection; + uses site-security; + uses site-service; + uses site-routing; + uses site-attachment-availability; + uses access-vpn-policy; + + description + "Grouping for site network access + top level cfg."; + } + + /* Main blocks */ + + container l3vpn-svc { + container vpn-services { + list vpn-svc { + key vpn-id; + + uses vpn-svc-cfg; + + description " + List of VPN services. + + "; + } + description + "top level container + for the VPN services."; + } + + container sites { + list site { + key site-id; + + leaf site-id { + type svc-id; + description + "Identifier of the site."; + } + + uses site-top-level-cfg; + uses operational-requirements-ops; + + container site-network-accesses { + list site-network-access { + key site-network-access-id; + + leaf site-network-access-id { + type svc-id; + description + "Identifier for the access"; + } + uses site-network-access-top-level-cfg; + + description + "List of accesses for a site."; + } + description + "List of accesses for a site."; + } + + description "List of sites."; + } + description + "Container for sites"; + } + + description + "Main container for L3VPN service configuration."; + } +} \ No newline at end of file diff --git a/apps/l3vpn/yangmodel/src/main/yang/ietf-yang-types.yang b/apps/l3vpn/yangmodel/src/main/yang/ietf-yang-types.yang new file mode 100755 index 0000000000..3f87464366 --- /dev/null +++ b/apps/l3vpn/yangmodel/src/main/yang/ietf-yang-types.yang @@ -0,0 +1,473 @@ +module ietf-yang-types { + + namespace "urn:ietf:params:xml:ns:yang:ietf-yang-types"; + prefix "yang"; + + organization + "IETF NETMOD (NETCONF Data Modeling Language) Working Group"; + + contact + "WG Web: + WG List: + + WG Chair: David Kessens + + + WG Chair: Juergen Schoenwaelder + + + Editor: Juergen Schoenwaelder + "; + + description + "This module contains a collection of generally useful derived + YANG data types. + + Copyright (c) 2013 IETF Trust and the persons identified as + authors of the code. All rights reserved. + + Redistribution and use in source and binary forms, with or + without modification, is permitted pursuant to, and subject + to the license terms contained in, the Simplified BSD License + set forth in Section 4.c of the IETF Trust's Legal Provisions + Relating to IETF Documents + (http://trustee.ietf.org/license-info). + + This version of this YANG module is part of RFC 6991; see + the RFC itself for full legal notices."; + + revision 2013-07-15 { + description + "This revision adds the following new data types: + - yang-identifier + - hex-string + - uuid + - dotted-quad"; + reference + "RFC 6991: Common YANG Data Types"; + } + + revision 2010-09-24 { + description + "Initial revision."; + reference + "RFC 6021: Common YANG Data Types"; + } + + /*** collection of counter and gauge types ***/ + + typedef counter32 { + type uint32; + description + "The counter32 type represents a non-negative integer + that monotonically increases until it reaches a + maximum value of 2^32-1 (4294967295 decimal), when it + wraps around and starts increasing again from zero. + + Counters have no defined 'initial' value, and thus, a + single value of a counter has (in general) no information + content. Discontinuities in the monotonically increasing + value normally occur at re-initialization of the + management system, and at other times as specified in the + description of a schema node using this type. If such + other times can occur, for example, the creation of + a schema node of type counter32 at times other than + re-initialization, then a corresponding schema node + should be defined, with an appropriate type, to indicate + the last discontinuity. + + The counter32 type should not be used for configuration + schema nodes. A default statement SHOULD NOT be used in + combination with the type counter32. + + In the value set and its semantics, this type is equivalent + to the Counter32 type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 + (SMIv2)"; + } + + typedef zero-based-counter32 { + type yang:counter32; + default "0"; + description + "The zero-based-counter32 type represents a counter32 + that has the defined 'initial' value zero. + + A schema node of this type will be set to zero (0) on creation + and will thereafter increase monotonically until it reaches + a maximum value of 2^32-1 (4294967295 decimal), when it + wraps around and starts increasing again from zero. + + Provided that an application discovers a new schema node + of this type within the minimum time to wrap, it can use the + 'initial' value as a delta. It is important for a management + station to be aware of this minimum time and the actual time + between polls, and to discard data if the actual time is too + long or there is no defined minimum time. + In the value set and its semantics, this type is equivalent + to the ZeroBasedCounter32 textual convention of the SMIv2."; + reference + "RFC 4502: Remote Network Monitoring Management Information + Base Version 2"; + } + + typedef counter64 { + type uint64; + description + "The counter64 type represents a non-negative integer + that monotonically increases until it reaches a + maximum value of 2^64-1 (18446744073709551615 decimal), + when it wraps around and starts increasing again from zero. + + Counters have no defined 'initial' value, and thus, a + single value of a counter has (in general) no information + content. Discontinuities in the monotonically increasing + value normally occur at re-initialization of the + management system, and at other times as specified in the + description of a schema node using this type. If such + other times can occur, for example, the creation of + a schema node of type counter64 at times other than + re-initialization, then a corresponding schema node + should be defined, with an appropriate type, to indicate + the last discontinuity. + + The counter64 type should not be used for configuration + schema nodes. A default statement SHOULD NOT be used in + combination with the type counter64. + + In the value set and its semantics, this type is equivalent + to the Counter64 type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 + (SMIv2)"; + } + + typedef zero-based-counter64 { + type yang:counter64; + default "0"; + description + "The zero-based-counter64 type represents a counter64 that + has the defined 'initial' value zero. + A schema node of this type will be set to zero (0) on creation + and will thereafter increase monotonically until it reaches + a maximum value of 2^64-1 (18446744073709551615 decimal), + when it wraps around and starts increasing again from zero. + + Provided that an application discovers a new schema node + of this type within the minimum time to wrap, it can use the + 'initial' value as a delta. It is important for a management + station to be aware of this minimum time and the actual time + between polls, and to discard data if the actual time is too + long or there is no defined minimum time. + + In the value set and its semantics, this type is equivalent + to the ZeroBasedCounter64 textual convention of the SMIv2."; + reference + "RFC 2856: Textual Conventions for Additional High Capacity + Data Types"; + } + + typedef gauge32 { + type uint32; + description + "The gauge32 type represents a non-negative integer, which + may increase or decrease, but shall never exceed a maximum + value, nor fall below a minimum value. The maximum value + cannot be greater than 2^32-1 (4294967295 decimal), and + the minimum value cannot be smaller than 0. The value of + a gauge32 has its maximum value whenever the information + being modeled is greater than or equal to its maximum + value, and has its minimum value whenever the information + being modeled is smaller than or equal to its minimum value. + If the information being modeled subsequently decreases + below (increases above) the maximum (minimum) value, the + gauge32 also decreases (increases). + + In the value set and its semantics, this type is equivalent + to the Gauge32 type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 + (SMIv2)"; + } + + typedef gauge64 { + type uint64; + description + "The gauge64 type represents a non-negative integer, which + may increase or decrease, but shall never exceed a maximum + value, nor fall below a minimum value. The maximum value + cannot be greater than 2^64-1 (18446744073709551615), and + the minimum value cannot be smaller than 0. The value of + a gauge64 has its maximum value whenever the information + being modeled is greater than or equal to its maximum + value, and has its minimum value whenever the information + being modeled is smaller than or equal to its minimum value. + If the information being modeled subsequently decreases + below (increases above) the maximum (minimum) value, the + gauge64 also decreases (increases). + + In the value set and its semantics, this type is equivalent + to the CounterBasedGauge64 SMIv2 textual convention defined + in RFC 2856"; + reference + "RFC 2856: Textual Conventions for Additional High Capacity + Data Types"; + } + + /*** collection of identifier-related types ***/ + + typedef object-identifier { + type string { + pattern '(([0-1](\.[1-3]?[0-9]))|(2\.(0|([1-9]\d*))))' + + '(\.(0|([1-9]\d*)))*'; + } + description + "The object-identifier type represents administratively + assigned names in a registration-hierarchical-name tree. + + Values of this type are denoted as a sequence of numerical + non-negative sub-identifier values. Each sub-identifier + value MUST NOT exceed 2^32-1 (4294967295). Sub-identifiers + are separated by single dots and without any intermediate + whitespace. + + The ASN.1 standard restricts the value space of the first + sub-identifier to 0, 1, or 2. Furthermore, the value space + of the second sub-identifier is restricted to the range + 0 to 39 if the first sub-identifier is 0 or 1. Finally, + the ASN.1 standard requires that an object identifier + has always at least two sub-identifiers. The pattern + captures these restrictions. + + Although the number of sub-identifiers is not limited, + module designers should realize that there may be + implementations that stick with the SMIv2 limit of 128 + sub-identifiers. + + This type is a superset of the SMIv2 OBJECT IDENTIFIER type + since it is not restricted to 128 sub-identifiers. Hence, + this type SHOULD NOT be used to represent the SMIv2 OBJECT + IDENTIFIER type; the object-identifier-128 type SHOULD be + used instead."; + reference + "ISO9834-1: Information technology -- Open Systems + Interconnection -- Procedures for the operation of OSI + Registration Authorities: General procedures and top + arcs of the ASN.1 Object Identifier tree"; + } + + typedef object-identifier-128 { + type object-identifier { + pattern '\d*(\.\d*){1,127}'; + } + description + "This type represents object-identifiers restricted to 128 + sub-identifiers. + + In the value set and its semantics, this type is equivalent + to the OBJECT IDENTIFIER type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 + (SMIv2)"; + } + + typedef yang-identifier { + type string { + length "1..max"; + pattern '[a-zA-Z_][a-zA-Z0-9\-_.]*'; + pattern '.|..|[^xX].*|.[^mM].*|..[^lL].*'; + } + description + "A YANG identifier string as defined by the 'identifier' + rule in Section 12 of RFC 6020. An identifier must + start with an alphabetic character or an underscore + followed by an arbitrary sequence of alphabetic or + numeric characters, underscores, hyphens, or dots. + + A YANG identifier MUST NOT start with any possible + combination of the lowercase or uppercase character + sequence 'xml'."; + reference + "RFC 6020: YANG - A Data Modeling Language for the Network + Configuration Protocol (NETCONF)"; + } + + /*** collection of types related to date and time***/ + + typedef date-and-time { + type string { + pattern '\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?' + + '(Z|[\+\-]\d{2}:\d{2})'; + } + description + "The date-and-time type is a profile of the ISO 8601 + standard for representation of dates and times using the + Gregorian calendar. The profile is defined by the + date-time production in Section 5.6 of RFC 3339. + + The date-and-time type is compatible with the dateTime XML + schema type with the following notable exceptions: + + (a) The date-and-time type does not allow negative years. + + (b) The date-and-time time-offset -00:00 indicates an unknown + time zone (see RFC 3339) while -00:00 and +00:00 and Z + all represent the same time zone in dateTime. + + (c) The canonical format (see below) of data-and-time values + differs from the canonical format used by the dateTime XML + schema type, which requires all times to be in UTC using + the time-offset 'Z'. + + This type is not equivalent to the DateAndTime textual + convention of the SMIv2 since RFC 3339 uses a different + separator between full-date and full-time and provides + higher resolution of time-secfrac. + + The canonical format for date-and-time values with a known time + zone uses a numeric time zone offset that is calculated using + the device's configured known offset to UTC time. A change of + the device's offset to UTC time will cause date-and-time values + to change accordingly. Such changes might happen periodically + in case a server follows automatically daylight saving time + (DST) time zone offset changes. The canonical format for + date-and-time values with an unknown time zone (usually + referring to the notion of local time) uses the time-offset + -00:00."; + reference + "RFC 3339: Date and Time on the Internet: Timestamps + RFC 2579: Textual Conventions for SMIv2 + XSD-TYPES: XML Schema Part 2: Datatypes Second Edition"; + } + + typedef timeticks { + type uint32; + description + "The timeticks type represents a non-negative integer that + represents the time, modulo 2^32 (4294967296 decimal), in + hundredths of a second between two epochs. When a schema + node is defined that uses this type, the description of + the schema node identifies both of the reference epochs. + + In the value set and its semantics, this type is equivalent + to the TimeTicks type of the SMIv2."; + reference + "RFC 2578: Structure of Management Information Version 2 + (SMIv2)"; + } + + typedef timestamp { + type yang:timeticks; + description + "The timestamp type represents the value of an associated + timeticks schema node at which a specific occurrence + happened. The specific occurrence must be defined in the + description of any schema node defined using this type. When + the specific occurrence occurred prior to the last time the + associated timeticks attribute was zero, then the timestamp + value is zero. Note that this requires all timestamp values + to be reset to zero when the value of the associated timeticks + attribute reaches 497+ days and wraps around to zero. + + The associated timeticks schema node must be specified + in the description of any schema node using this type. + + In the value set and its semantics, this type is equivalent + to the TimeStamp textual convention of the SMIv2."; + reference + "RFC 2579: Textual Conventions for SMIv2"; + } + + /*** collection of generic address types ***/ + + typedef phys-address { + type string { + pattern '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'; + } + + description + "Represents media- or physical-level addresses represented + as a sequence octets, each octet represented by two hexadecimal + numbers. Octets are separated by colons. The canonical + representation uses lowercase characters. + + In the value set and its semantics, this type is equivalent + to the PhysAddress textual convention of the SMIv2."; + reference + "RFC 2579: Textual Conventions for SMIv2"; + } + + typedef mac-address { + type string { + pattern '[0-9a-fA-F]{2}(:[0-9a-fA-F]{2}){5}'; + } + description + "The mac-address type represents an IEEE 802 MAC address. + The canonical representation uses lowercase characters. + + In the value set and its semantics, this type is equivalent + to the MacAddress textual convention of the SMIv2."; + reference + "IEEE 802: IEEE Standard for Local and Metropolitan Area + Networks: Overview and Architecture + RFC 2579: Textual Conventions for SMIv2"; + } + + /*** collection of XML-specific types ***/ + + typedef xpath1.0 { + type string; + description + "This type represents an XPATH 1.0 expression. + + When a schema node is defined that uses this type, the + description of the schema node MUST specify the XPath + context in which the XPath expression is evaluated."; + reference + "XPATH: XML Path Language (XPath) Version 1.0"; + } + + /*** collection of string types ***/ + + typedef hex-string { + type string { + pattern '([0-9a-fA-F]{2}(:[0-9a-fA-F]{2})*)?'; + } + + description + "A hexadecimal string with octets represented as hex digits + separated by colons. The canonical representation uses + lowercase characters."; + } + + typedef uuid { + type string { + pattern '[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-' + + '[0-9a-fA-F]{4}-[0-9a-fA-F]{12}'; + } + description + "A Universally Unique IDentifier in the string representation + defined in RFC 4122. The canonical representation uses + lowercase characters. + + The following is an example of a UUID in string representation: + f81d4fae-7dec-11d0-a765-00a0c91e6bf6 + "; + reference + "RFC 4122: A Universally Unique IDentifier (UUID) URN + Namespace"; + } + + typedef dotted-quad { + type string { + pattern + '(([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}' + + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])'; + } + description + "An unsigned 32-bit number expressed in the dotted-quad + notation, i.e., four octets written as decimal numbers + and separated with the '.' (full stop) character."; + } + } \ No newline at end of file diff --git a/apps/l3vpn/yangmodel/src/main/yang/l3vpn-svc-ext@2016-07-30.yang b/apps/l3vpn/yangmodel/src/main/yang/l3vpn-svc-ext@2016-07-30.yang new file mode 100644 index 0000000000..e3fecb63d6 --- /dev/null +++ b/apps/l3vpn/yangmodel/src/main/yang/l3vpn-svc-ext@2016-07-30.yang @@ -0,0 +1,362 @@ +module l3vpn-svc-ext { + yang-version 1; + namespace "urn:ietf:params:xml:ns:yang:l3vpn:svc:ext"; + prefix "l3vpn-svc-ext"; + + import ietf-inet-types { prefix inet; } + import ietf-l3vpn-svc { prefix l3vpn; } + + revision 2016-07-30 { + description + "Eliminated warnings"; + } + + revision "2016-07-20" { + description "Initial revision of extended l3vpn yang model"; + } + + typedef short-as-number { + type inet:as-number { + range 0..65535; + } + } + + typedef route-distinguisher { + reference "https://tools.ietf.org/html/rfc4364#section-4.2"; + type union { + type rd-ipv4; + type rd-as; + type rd-as2; + } + } + + typedef rd-ipv4 { + type string { + /* IPv4 : 2B number */ + pattern '((([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\.){3}' + + '([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]))' + + ':' + + '([0-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|' + + '[1-5][0-9][0-9][0-9][0-9]|6[0-4][0-9][0-9][0-9]|' + + '65[0-4][0-9][0-9]|655[0-2][0-9]|6553[0-5])'; + } + } + + typedef rd-as { + type string { + /* 2B AS : 4B number */ + pattern '([0-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|' + + '[1-5][0-9][0-9][0-9][0-9]|6[0-4][0-9][0-9][0-9]|' + + '65[0-4][0-9][0-9]|655[0-2][0-9]|6553[0-5])' + + ':' + + '([0-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|' + + '[1-9][0-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9][0-9]|' + + '[1-9][0-9][0-9][0-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|' + + '[1-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|[1-3][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|' + + '4[0-1][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|42[0-8][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|' + + '429[0-3][0-9][0-9][0-9][0-9][0-9][0-9]|4294[0-8][0-9][0-9][0-9][0-9][0-9]|' + + '42949[0-5][0-9][0-9][0-9][0-9]|429496[0-6][0-9][0-9][0-9]|4294967[0-1][0-9][0-9]|' + + '42949672[0-8][0-9]|429496729[0-5])'; + } + } + + typedef rd-as2 { + type string { + /* 4B AS : 2B number */ + pattern '([0-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|' + + '[1-9][0-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9][0-9]|' + + '[1-9][0-9][0-9][0-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|' + + '[1-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|[1-3][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|' + + '4[0-1][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|42[0-8][0-9][0-9][0-9][0-9][0-9][0-9][0-9]|' + + '429[0-3][0-9][0-9][0-9][0-9][0-9][0-9]|4294[0-8][0-9][0-9][0-9][0-9][0-9]|' + + '42949[0-5][0-9][0-9][0-9][0-9]|429496[0-6][0-9][0-9][0-9]|4294967[0-1][0-9][0-9]|' + + '42949672[0-8][0-9]|429496729[0-5])' + + ':' + + '([0-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|' + + '[1-5][0-9][0-9][0-9][0-9]|6[0-4][0-9][0-9][0-9]|' + + '65[0-4][0-9][0-9]|655[0-2][0-9]|6553[0-5])'; + } + } + + identity tc-demanded-tunnel { + base l3vpn:transport-constraint; + description "on-demand tunnel."; + } + + grouping class-profile { + list qos-class { + key class-id; + leaf class-id { + type string; + description + "Identification of the + class of service. + This identifier is internal to + the administration."; + } + leaf rate-limit { + type uint8; + units percent; + description + "To be used if class must + be rate + limited. Expressed as + percentage of the svc-bw."; + } + leaf priority-level { + type uint8; + description + "Defines the level of the + class in + term of priority queueing. + The higher the level is the + higher + is the priority."; + } + leaf guaranteed-bw-percent { + type uint8; + units percent; + description + "To be used to define the + guaranteed + BW in percent of the svc-bw + available at the priority-level."; + } + description + "List of class of services."; + } + } + + augment "/l3vpn:l3vpn-svc/l3vpn:sites/l3vpn:site/l3vpn:site-network-accesses/l3vpn:site-network-access/l3vpn:service/l3vpn:qos/l3vpn:qos-profile/l3vpn:qos-profile" { + case custom-unicom { + container inbound-classes { + uses class-profile; + } + container outbound-classes { + uses class-profile; + } + } + } + + grouping bearer-attachment-grouping { + container bearer-attachment { + leaf pe-name { + type string; + } + leaf pe-mgmt-ip { + type inet:ipv4-address; + } + description "attached PE"; + } + } + + augment "/l3vpn:l3vpn-svc/l3vpn:sites/l3vpn:site/l3vpn:site-network-accesses/l3vpn:site-network-access/l3vpn:bearer" { + uses bearer-attachment-grouping; + } + + grouping requested-type-grouping { + container requested-type-profile { + choice requested-type-choice { + case dot1q-case { + container dot1q { + leaf physical-if { + description "physical interface name."; + type string; + } + leaf vlan-id { + type uint16 { + range "1..4096"; + } + } + } + } + case physical-case { + container physical { + leaf physical-if { + description "physical interface name."; + type string; + } + } + } + } + leaf circuit-id { + description "circuit description for PE-CE port."; + type string; + } + } + } + + augment "/l3vpn:l3vpn-svc/l3vpn:sites/l3vpn:site/l3vpn:site-network-accesses/l3vpn:site-network-access/l3vpn:bearer/l3vpn:requested-type" { + uses requested-type-grouping; + } + + grouping bfd-grouping { + leaf bfd-enabled { + type boolean; + description + "BFD activation"; + } + choice holdtime { + case profile { + leaf profile-name { + type string; + description + "Service provider well + known profile."; + } + description + "Service provider well + known profile."; + } + case fixed { + leaf fixed-value { + type uint32; + units msec; + description + "Expected holdtime + expressed + in msec."; + } + } + case dynamic { + container dynamic-value { + leaf interval { + type uint16; + units msec; + default 500; + } + leaf multiplier { + type uint16; + default 3; + } + description + "interval * multiplier is + timeout value."; + } + } + } + } + + grouping bgp-profile { + leaf as-override { + type boolean; + default false; + } + container soo { + leaf soo-enabled { + type boolean; + } + leaf soo-value { + type string; + } + } + container password { + leaf password-enabled { + type boolean; + } + leaf password-value { + type string; + } + } + container bgp-timer { + leaf keep-alive { + type uint16; + default 60; + units "seconds"; + } + leaf hold-time { + type uint16; + default 180; + units "seconds"; + } + } + container bfd { + uses bfd-grouping; + } + } + + augment "/l3vpn:l3vpn-svc/l3vpn:sites/l3vpn:site/l3vpn:site-network-accesses/l3vpn:site-network-access/l3vpn:routing-protocols/l3vpn:routing-protocol/l3vpn:bgp" { + uses bgp-profile; + } + + augment "/l3vpn:l3vpn-svc/l3vpn:vpn-services/l3vpn:vpn-svc/l3vpn:transport-constraints/l3vpn:unicast-transport-constraints/l3vpn:constraint/l3vpn:constraint-list" { + leaf constraint-opaque-value2 { + type string; + description + "Opaque value that can be used to + specify constraint parameters."; + } + } + + grouping route-ipv4-extended-community { + reference "http://tools.ietf.org/html/rfc4360"; + leaf global-administrator { + type inet:ipv4-address; + } + leaf local-administrator { + type uint16; + } + } + + grouping extended-community { + choice extended-community { + reference "http://tools.ietf.org/html/rfc4360#section-4"; + default route-target-extended-community-case; + case route-target-extended-community-case { + container route-target-extended-community { + leaf global-administrator { + type short-as-number; + } + leaf local-administrator { + type uint32; + } + } + } + case route-target-ipv4-case { + container route-target-ipv4 { + uses route-ipv4-extended-community; + } + } + case route-target-extended-community-case2 { + container route-target-extended-community2 { + leaf global-administrator { + type uint32; + } + leaf local-administrator { + type uint16; + } + } + } + } + } + + grouping rdrt-profile { + choice site-role { + case custom-case { + container custom { + list import-rt { + key imrt-id; + leaf imrt-id { + type string; + } + uses extended-community; + } + list export-rt { + key exrt-id; + leaf exrt-id { + type string; + } + uses extended-community; + } + leaf rd { + type route-distinguisher; + } + } + } + } + } + + augment "/l3vpn:l3vpn-svc/l3vpn:sites/l3vpn:site/l3vpn:site-network-accesses/l3vpn:site-network-access/l3vpn:vpn-attachment" { + uses rdrt-profile; + } +} \ No newline at end of file diff --git a/modules.defs b/modules.defs index b748938a50..452f04ab7f 100644 --- a/modules.defs +++ b/modules.defs @@ -191,7 +191,8 @@ ONOS_APPS = [ '//apps/yang:onos-apps-yang-oar', '//apps/yang-gui:onos-apps-yang-gui-oar', '//apps/cord-support:onos-apps-cord-support-oar', - '//apps/network-troubleshoot:onos-apps-network-troubleshoot-oar' + '//apps/network-troubleshoot:onos-apps-network-troubleshoot-oar', + '//apps/l3vpn:onos-apps-l3vpn-oar', ] APP_JARS = [