| module actn-ietf-te { |
| yang-version 1.1; |
| |
| namespace "urn:ietf:params:xml:ns:yang:actn-ietf-te"; |
| |
| /* Replace with IANA when assigned */ |
| prefix "te"; |
| |
| /* Import TE generic types */ |
| import actn-ietf-te-types { |
| prefix te-types; |
| } |
| |
| import yrt-ietf-te-mpls-types { |
| prefix "te-mpls-types"; |
| } |
| |
| import yrt-ietf-inet-types { |
| prefix inet; |
| } |
| |
| organization |
| "IETF Traffic Engineering Architecture and Signaling (TEAS) |
| Working Group"; |
| |
| contact |
| "WG Web: <http://tools.ietf.org/wg/teas/> |
| WG List: <mailto:teas@ietf.org> |
| |
| WG Chair: Lou Berger |
| <mailto:lberger@labn.net> |
| |
| WG Chair: Vishnu Pavan Beeram |
| <mailto:vbeeram@juniper.net> |
| |
| Editor: Tarek Saad |
| <mailto:tsaad@cisco.com> |
| |
| Editor: Rakesh Gandhi |
| <mailto:rgandhi@cisco.com> |
| |
| Editor: Vishnu Pavan Beeram |
| <mailto:vbeeram@juniper.net> |
| |
| Editor: Himanshu Shah |
| <mailto:hshah@ciena.com> |
| |
| Editor: Xufeng Liu |
| <mailto:Xufeng_Liu@jabil.com> |
| |
| Editor: Xia Chen |
| <mailto:jescia.chenxia@huawei.com> |
| |
| Editor: Raqib Jones |
| <mailto:raqib@Brocade.com> |
| |
| Editor: Bin Wen |
| <mailto:Bin_Wen@cable.comcast.com>"; |
| |
| description |
| "YANG data module for TE configuration, |
| state, RPC and notifications."; |
| |
| revision "2017-03-10" { |
| description "Latest update to TE generic YANG module."; |
| reference "TBD"; |
| } |
| |
| typedef tunnel-ref { |
| type leafref { |
| path "/te:te/te:tunnels/te:tunnel/te:name"; |
| } |
| description |
| "This type is used by data models that need to reference |
| configured TE tunnel."; |
| } |
| |
| typedef tunnel-p2mp-ref { |
| type leafref { |
| path "/te:te/te:tunnels/te:tunnel-p2mp/te:name"; |
| } |
| description |
| "This type is used by data models that need to reference |
| configured P2MP TE tunnel."; |
| } |
| |
| /** |
| * TE tunnel generic groupings |
| */ |
| grouping path-route-objects { |
| description |
| "List of EROs to be included or excluded when performing |
| the path computation."; |
| container explicit-route-objects { |
| description |
| "Container for the include or exclude route object list"; |
| list explicit-route-object { |
| key index; |
| description |
| "List of explicit route objects to include or |
| exclude in path computation"; |
| leaf index { |
| type leafref { |
| path "../config/index"; |
| } |
| description |
| "Index of this explicit route object"; |
| } |
| leaf explicit-route-usage { |
| type identityref { |
| base te-types:route-usage-type; |
| } |
| description "An explicit-route hop action."; |
| } |
| uses te-types:explicit-route-hop; |
| } |
| } |
| } |
| |
| grouping path-affinities { |
| description |
| "Path affinities grouping"; |
| container path-affinities { |
| description |
| "Path affinities container"; |
| choice style { |
| description |
| "Path affinities representation style"; |
| case values { |
| leaf value { |
| type uint32 { |
| range "0..4294967295"; |
| } |
| description |
| "Affinity value"; |
| } |
| leaf mask { |
| type uint32 { |
| range "0..4294967295"; |
| } |
| description |
| "Affinity mask"; |
| } |
| } |
| case named { |
| list constraints { |
| key "usage"; |
| leaf usage { |
| type identityref { |
| base te-types:resource-affinities-type; |
| } |
| description "Affinities usage"; |
| } |
| container constraint { |
| description |
| "Container for named affinities"; |
| list affinity-names { |
| key "name"; |
| leaf name { |
| type string; |
| description |
| "Affinity name"; |
| } |
| description |
| "List of named affinities"; |
| } |
| } |
| description |
| "List of named affinity constraints"; |
| } |
| } |
| } |
| } |
| } |
| |
| grouping path-srlgs { |
| description |
| "Path SRLG properties grouping"; |
| container path-srlgs { |
| description |
| "Path SRLG properties container"; |
| choice style { |
| description |
| "Type of SRLG representation"; |
| case values { |
| leaf usage { |
| type identityref { |
| base te-types:route-exclude-srlg; |
| } |
| description "SRLG usage"; |
| } |
| leaf-list values { |
| type te-types:srlg; |
| description "SRLG value"; |
| } |
| } |
| case named { |
| list constraints { |
| key "usage"; |
| leaf usage { |
| type identityref { |
| base te-types:route-exclude-srlg; |
| } |
| description "SRLG usage"; |
| } |
| container constraint { |
| description |
| "Container for named SRLG list"; |
| list srlg-names { |
| key "name"; |
| leaf name { |
| type string; |
| description |
| "The SRLG name"; |
| } |
| description |
| "List named SRLGs"; |
| } |
| } |
| description |
| "List of named SRLG constraints"; |
| } |
| } |
| } |
| } |
| } |
| |
| grouping bidir-assoc-properties { |
| description |
| "TE tunnel associated bidirectional properties |
| grouping"; |
| container bidirectional { |
| description |
| "TE tunnel associated bidirectional attributes."; |
| container association { |
| description |
| "Tunnel bidirectional association properties"; |
| leaf id { |
| type uint16; |
| description |
| "The TE tunnel association identifier."; |
| } |
| leaf source { |
| type inet:ip-address; |
| description |
| "The TE tunnel association source."; |
| } |
| leaf global-source { |
| type inet:ip-address; |
| description |
| "The TE tunnel association global |
| source."; |
| } |
| leaf type { |
| type identityref { |
| base te-types:bidir-association-type; |
| } |
| default te-types:bidir-assoc-non-corouted; |
| description |
| "The TE tunnel association type."; |
| } |
| leaf provisioing { |
| type identityref { |
| base te-types:bidir-provisioning-mode; |
| } |
| description |
| "Describes the provisioning model of the |
| associated bidirectional LSP"; |
| reference |
| "draft-ietf-teas-mpls-tp-rsvpte-ext- |
| associated-lsp, section-3.2"; |
| } |
| } |
| } |
| } |
| |
| grouping p2p-secondary-path-properties { |
| description |
| "tunnel path properties."; |
| container config { |
| description |
| "Configuration parameters relating to |
| tunnel properties"; |
| uses p2p-path-properties_config; |
| } |
| container state { |
| config false; |
| description |
| "State information associated with tunnel |
| properties"; |
| uses p2p-path-properties_config; |
| uses p2p-secondary-path-properties_state; |
| } |
| } |
| |
| grouping p2p-primary-path-properties { |
| description |
| "TE tunnel primary path properties grouping"; |
| container config { |
| description |
| "Configuration parameters relating to |
| tunnel properties"; |
| uses p2p-path-properties_config; |
| } |
| container state { |
| config false; |
| description |
| "State information associated with tunnel |
| properties"; |
| uses p2p-path-properties_config; |
| uses p2p-primary-path-properties_state; |
| } |
| } |
| |
| grouping p2p-primary-path-properties_state { |
| description "TE path state parameters"; |
| container lsps { |
| description "TE LSPs container"; |
| list lsp { |
| key |
| "source destination tunnel-id lsp-id "+ |
| "extended-tunnel-id type"; |
| description "List of LSPs associated with the tunnel."; |
| |
| leaf source { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp/source"; |
| } |
| description |
| "Tunnel sender address extracted from |
| SENDER_TEMPLATE object"; |
| reference "RFC3209"; |
| } |
| leaf destination { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp/destination"; |
| } |
| description |
| "Tunnel endpoint address extracted from |
| SESSION object"; |
| reference "RFC3209"; |
| } |
| leaf tunnel-id { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp/tunnel-id"; |
| } |
| description |
| "Tunnel identifier used in the SESSION |
| that remains constant over the life |
| of the tunnel."; |
| reference "RFC3209"; |
| } |
| leaf lsp-id { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp/lsp-id"; |
| } |
| description |
| "Identifier used in the SENDER_TEMPLATE |
| and the FILTER_SPEC that can be changed |
| to allow a sender to share resources with |
| itself."; |
| reference "RFC3209"; |
| } |
| leaf extended-tunnel-id { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp/" + |
| "extended-tunnel-id"; |
| } |
| description |
| "Extended Tunnel ID of the LSP."; |
| reference "RFC3209"; |
| } |
| leaf type { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp/type"; |
| } |
| description "LSP type P2P or P2MP"; |
| } |
| leaf signaling-type { |
| type identityref { |
| base te-types:path-signaling-type; |
| } |
| description "TE tunnel path signaling type"; |
| } |
| } |
| } |
| } |
| |
| grouping p2p-secondary-path-properties_state { |
| description "TE secondary path state parameters"; |
| list lsp { |
| key "source"; |
| description "List of LSPs associated with the tunnel."; |
| |
| leaf source { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp/source"; |
| } |
| description |
| "Tunnel sender address extracted from |
| SENDER_TEMPLATE object"; |
| reference "RFC3209"; |
| } |
| leaf destination { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp/destination"; |
| } |
| description |
| "Tunnel endpoint address extracted from |
| SESSION object"; |
| reference "RFC3209"; |
| } |
| leaf tunnel-id { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp/tunnel-id"; |
| } |
| description |
| "Tunnel identifier used in the SESSION |
| that remains constant over the life |
| of the tunnel."; |
| reference "RFC3209"; |
| } |
| leaf lsp-id { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp/lsp-id"; |
| } |
| description |
| "Identifier used in the SENDER_TEMPLATE |
| and the FILTER_SPEC that can be changed |
| to allow a sender to share resources with |
| itself."; |
| reference "RFC3209"; |
| } |
| leaf extended-tunnel-id { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp" + |
| "/extended-tunnel-id"; |
| } |
| description |
| "Extended Tunnel ID of the LSP."; |
| reference "RFC3209"; |
| } |
| leaf type { |
| type leafref { |
| path "../../../../../../../../lsps-state/lsp/type"; |
| } |
| description "LSP type P2P or P2MP"; |
| } |
| leaf active { |
| type boolean; |
| description |
| "Indicates the current active path option that has |
| been selected of the candidate secondary paths"; |
| } |
| } |
| } |
| |
| grouping p2p-path-properties_config { |
| description |
| "TE tunnel path properties configuration grouping"; |
| leaf name { |
| type string; |
| description "TE path name"; |
| } |
| leaf preference { |
| type uint8 { |
| range "1..255"; |
| } |
| description |
| "Specifies a preference for this path. The lower the |
| number higher the preference"; |
| } |
| leaf path-setup-protocol { |
| type identityref { |
| base te-types:te-path-setup-protocol; |
| } |
| description |
| "Signaling protocol used to set up this tunnel"; |
| } |
| leaf path-computation-method { |
| type identityref { |
| base te-types:path-computation-method; |
| } |
| default te-types:path-locally-computed; |
| description |
| "The method used for computing the path, either |
| locally computed, queried from a server or not |
| computed at all (explicitly configured)."; |
| } |
| leaf path-computation-server { |
| when "../path-computation-method = 'path-externally-queried'" { |
| description |
| "The path-computation server when the path is |
| externally queried"; |
| } |
| type inet:ip-address; |
| description |
| "Address of the external path computation |
| server"; |
| } |
| leaf compute-only { |
| type empty; |
| description |
| "When set, the path is computed and updated whenever |
| the topology is updated. No resources are committed |
| or reserved in the network."; |
| } |
| leaf use-cspf { |
| when "../path-computation-method = 'path-locally-computed'"; |
| type boolean; |
| description "A CSPF dynamically computed path"; |
| } |
| leaf verbatim { |
| type empty; |
| description |
| "Indicates no topology or CSPF is attempted on the |
| specified path."; |
| } |
| leaf lockdown { |
| type empty; |
| description |
| "Indicates no reoptimization to be attempted for |
| this path."; |
| } |
| //TODO: added te-default-metric, te-delay-metric, te-srlgs, te-nsrlgs |
| leaf te-default-metric { |
| type uint32; |
| description |
| "Traffic engineering metric."; |
| } |
| leaf te-delay-metric { |
| type uint32; |
| description |
| "Traffic engineering delay metric."; |
| } |
| leaf te-hop-metric { |
| type uint32; |
| description |
| "Traffic engineering hop metric."; |
| } |
| container te-srlgs { |
| description |
| "Containing a list of SLRGs."; |
| leaf-list value { |
| type te-types:srlg; |
| description "SRLG value."; |
| reference |
| "RFC4202: Routing Extensions in Support of |
| Generalized Multi-Protocol Label Switching (GMPLS)."; |
| } |
| } |
| container te-nsrlgs { |
| if-feature nsrlg; |
| description |
| "Containing a list of NSRLGs (Not Sharing Risk Link |
| Groups). |
| When an abstract TE link is configured, this list specifies |
| the request that underlay TE paths need to be mutually |
| disjoint with other TE links in the same groups."; |
| leaf-list id { |
| type uint32; |
| description |
| "NSRLG ID, uniquely configured within a topology."; |
| reference |
| "RFC4872: RSVP-TE Extensions in Support of End-to-End |
| Generalized Multi-Protocol Label Switching (GMPLS) |
| Recovery"; |
| } |
| } |
| leaf named-explicit-path { |
| when "../path-computation-method = 'path-explicitly-defined'"; |
| type leafref { |
| path "../../../../../../globals/named-explicit-paths/" |
| + "named-explicit-path/config/name"; |
| } |
| description "The explicit-path name"; |
| } |
| leaf named-path-constraint { |
| if-feature te-types:named-path-constraints; |
| type leafref { |
| path "../../../../../../globals/" |
| + "named-path-constraints/named-path-constraint/" |
| + "config/name"; |
| } |
| description |
| "Reference to a globally defined named path |
| constraint set"; |
| } |
| } |
| |
| /* TE tunnel configuration data */ |
| grouping tunnel-p2mp-params_config { |
| description |
| "Configuration parameters relating to TE tunnel"; |
| leaf name { |
| type string; |
| description "TE tunnel name."; |
| } |
| leaf type { |
| type identityref { |
| base te-types:tunnel-type; |
| } |
| description "TE tunnel type."; |
| } |
| leaf identifier { |
| type uint16; |
| description |
| "TE tunnel Identifier."; |
| } |
| leaf description { |
| type string; |
| description |
| "Textual description for this TE tunnel"; |
| } |
| leaf setup-priority { |
| type uint8 { |
| range "0..7"; |
| } |
| description |
| "TE LSP setup priority"; |
| } |
| leaf hold-priority { |
| type uint8 { |
| range "0..7"; |
| } |
| description |
| "TE LSP hold priority"; |
| } |
| leaf lsp-protection-type { |
| type identityref { |
| base te-types:lsp-prot-type; |
| } |
| description "LSP protection type."; |
| } |
| leaf admin-status { |
| type identityref { |
| base te-types:state-type; |
| } |
| default te-types:state-up; |
| description "TE tunnel administrative state."; |
| } |
| leaf reoptimize-timer { |
| type uint16; |
| units seconds; |
| description |
| "frequency of reoptimization of |
| a traffic engineered LSP"; |
| } |
| } |
| |
| grouping te-tunnel-bandwidth_config { |
| description |
| "Configuration parameters related to bandwidth for a tunnel"; |
| |
| leaf specification-type { |
| type te-mpls-types:te-bandwidth-type; |
| default SPECIFIED; |
| description |
| "The method used for settign the bandwidth, either explicitly |
| specified or configured"; |
| } |
| |
| leaf set-bandwidth { |
| when "../specification-type = 'te-mpls-types:SPECIFIED'" { |
| description |
| "The bandwidth value when bandwidth is explicitly |
| specified"; |
| } |
| type te-mpls-types:bandwidth-kbps; |
| description |
| "set bandwidth explicitly, e.g., using |
| offline calculation"; |
| } |
| leaf class-type { |
| type te-types:te-ds-class; |
| description |
| "The Class-Type of traffic transported by the LSP."; |
| reference "RFC4124: section-4.3.1"; |
| } |
| } |
| |
| grouping te-tunnel-bandwidth_state { |
| description |
| "Operational state parameters relating to bandwidth for a tunnel"; |
| |
| leaf signaled-bandwidth { |
| type te-mpls-types:bandwidth-kbps; |
| description |
| "The currently signaled bandwidth of the LSP. In the case where |
| the bandwidth is specified explicitly, then this will match the |
| value of the set-bandwidth leaf; in cases where the bandwidth is |
| dynamically computed by the system, the current value of the |
| bandwidth should be reflected."; |
| } |
| } |
| |
| grouping te-lsp-auto-bandwidth_config { |
| description |
| "Configuration parameters related to autobandwidth"; |
| |
| leaf enabled { |
| type boolean; |
| default false; |
| description |
| "enables mpls auto-bandwidth on the |
| lsp"; |
| } |
| |
| leaf min-bw { |
| type te-mpls-types:bandwidth-kbps; |
| description |
| "set the minimum bandwidth in Kbps for an |
| auto-bandwidth LSP"; |
| } |
| |
| leaf max-bw { |
| type te-mpls-types:bandwidth-kbps; |
| description |
| "set the maximum bandwidth in Kbps for an |
| auto-bandwidth LSP"; |
| } |
| |
| leaf adjust-interval { |
| type uint32; |
| description |
| "time in seconds between adjustments to |
| LSP bandwidth"; |
| } |
| |
| leaf adjust-threshold { |
| type te-types:percentage; |
| description |
| "percentage difference between the LSP's |
| specified bandwidth and its current bandwidth |
| allocation -- if the difference is greater than the |
| specified percentage, auto-bandwidth adjustment is |
| triggered"; |
| } |
| } |
| |
| grouping te-lsp-overflow_config { |
| description |
| "configuration for mpls lsp bandwidth |
| overflow adjustment"; |
| |
| leaf enabled { |
| type boolean; |
| default false; |
| description |
| "enables mpls lsp bandwidth overflow |
| adjustment on the lsp"; |
| } |
| |
| leaf overflow-threshold { |
| type te-types:percentage; |
| description |
| "bandwidth percentage change to trigger |
| an overflow event"; |
| |
| } |
| |
| leaf trigger-event-count { |
| type uint16; |
| description |
| "number of consecutive overflow sample |
| events needed to trigger an overflow adjustment"; |
| } |
| } |
| |
| grouping te-lsp-underflow_config { |
| description |
| "configuration for mpls lsp bandwidth |
| underflow adjustment"; |
| |
| leaf enabled { |
| type boolean; |
| default false; |
| description |
| "enables bandwidth underflow |
| adjustment on the lsp"; |
| } |
| |
| leaf underflow-threshold { |
| type te-types:percentage; |
| description |
| "bandwidth percentage change to trigger |
| and underflow event"; |
| } |
| |
| leaf trigger-event-count { |
| type uint16; |
| description |
| "number of consecutive underflow sample |
| events needed to trigger an underflow adjustment"; |
| } |
| } |
| |
| grouping te-path-bandwidth_top { |
| description |
| "Top level grouping for specifying bandwidth for a TE path"; |
| |
| container bandwidth { |
| description |
| "Bandwidth configuration for TE LSPs"; |
| |
| container config { |
| description |
| "Configuration parameters related to bandwidth on TE |
| tunnels:"; |
| uses te-tunnel-bandwidth_config; |
| } |
| |
| container state { |
| config false; |
| description |
| "State parameters related to bandwidth |
| configuration of TE tunnels"; |
| uses te-tunnel-bandwidth_config; |
| uses te-tunnel-bandwidth_state; |
| } |
| } |
| } |
| |
| grouping te-tunnel-bandwidth_top { |
| description |
| "Top level grouping for specifying bandwidth for a tunnel"; |
| |
| container bandwidth { |
| description |
| "Bandwidth configuration for TE LSPs"; |
| |
| container config { |
| description |
| "Configuration parameters related to bandwidth on TE |
| tunnels:"; |
| uses te-tunnel-bandwidth_config; |
| } |
| |
| container state { |
| config false; |
| description |
| "State parameters related to bandwidth |
| configuration of TE tunnels"; |
| uses te-tunnel-bandwidth_config; |
| uses te-tunnel-bandwidth_state; |
| } |
| |
| container auto-bandwidth { |
| when "../config/specification-type = 'AUTO'" { |
| description |
| "Include this container for auto bandwidth |
| specific configuration"; |
| } |
| description |
| "Parameters related to auto-bandwidth"; |
| |
| container config { |
| description |
| "Configuration parameters relating to MPLS |
| auto-bandwidth on the tunnel."; |
| uses te-lsp-auto-bandwidth_config; |
| } |
| container state { |
| config false; |
| description |
| "State parameters relating to MPLS |
| auto-bandwidth on the tunnel."; |
| uses te-lsp-auto-bandwidth_config; |
| } |
| |
| container overflow { |
| description |
| "configuration of MPLS overflow bandwidth |
| adjustement for the LSP"; |
| |
| container config { |
| description |
| "Config information for MPLS overflow bandwidth |
| adjustment"; |
| uses te-lsp-overflow_config; |
| } |
| |
| container state { |
| config false; |
| description |
| "Config information for MPLS overflow bandwidth |
| adjustment"; |
| uses te-lsp-overflow_config; |
| } |
| } |
| |
| container underflow { |
| description |
| "configuration of MPLS underflow bandwidth |
| adjustement for the LSP"; |
| |
| container config { |
| description |
| "Config information for MPLS underflow bandwidth |
| adjustment"; |
| uses te-lsp-underflow_config; |
| } |
| |
| container state { |
| config false; |
| description |
| "State information for MPLS underflo |
| adjustment"; |
| uses te-lsp-underflow_config; |
| } |
| } |
| } |
| } |
| } |
| |
| grouping tunnel-p2p-params_config { |
| description |
| "Configuration parameters relating to TE tunnel"; |
| leaf name { |
| type string; |
| description "TE tunnel name."; |
| } |
| leaf type { |
| type identityref { |
| base te-types:tunnel-type; |
| } |
| description "TE tunnel type."; |
| } |
| leaf identifier { |
| type uint16; |
| description |
| "TE tunnel Identifier."; |
| } |
| leaf description { |
| type string; |
| description |
| "Textual description for this TE tunnel"; |
| } |
| leaf switching-layer { |
| type identityref { |
| base te-types:switching-capabilities; |
| } |
| description |
| "Switching layer of this TE tunnel"; |
| } |
| leaf encoding { |
| type identityref { |
| base te-types:lsp-encoding-types; |
| } |
| description "LSP encoding type"; |
| } |
| leaf protection-type { |
| type identityref { |
| base te-types:lsp-prot-type; |
| } |
| description "LSP protection type."; |
| } |
| leaf admin-status { |
| type identityref { |
| base te-types:state-type; |
| } |
| default te-types:state-up; |
| description "TE tunnel administrative state."; |
| } |
| leaf preference { |
| type uint8 { |
| range "1..255"; |
| } |
| description |
| "Specifies a preference for this tunnel. |
| A lower number signifies a better preference"; |
| } |
| leaf reoptimize-timer { |
| type uint16; |
| units seconds; |
| description |
| "frequency of reoptimization of |
| a traffic engineered LSP"; |
| } |
| /*****************************************************/ |
| //TODO: HENRY added begin |
| leaf provider-id { |
| type te-types:te-global-id; |
| description |
| "An identifier to uniquely identify a provider."; |
| } |
| leaf client-id { |
| type te-types:te-global-id; |
| description |
| "An identifier to uniquely identify a client."; |
| } |
| leaf te-topology-id { |
| type te-types:te-topology-id; |
| description |
| "It is presumed that a datastore will contain many |
| topologies. To distinguish between topologies it is |
| vital to have UNIQUE topology identifiers."; |
| } |
| |
| //TODO: HENRY added end |
| /*****************************************************/ |
| |
| leaf source { |
| type inet:ip-address; |
| description |
| "TE tunnel source address."; |
| } |
| leaf destination { |
| /* Add when check */ |
| type inet:ip-address; |
| description |
| "P2P tunnel destination address"; |
| } |
| leaf src-tp-id { |
| type binary; |
| description |
| "TE tunnel source termination point identifier."; |
| } |
| leaf dst-tp-id { |
| /* Add when check */ |
| type binary; |
| description |
| "TE tunnel destination termination point identifier."; |
| } |
| leaf setup-priority { |
| type uint8 { |
| range "0..7"; |
| } |
| description |
| "TE LSP setup priority"; |
| } |
| leaf hold-priority { |
| type uint8 { |
| range "0..7"; |
| } |
| description |
| "TE LSP hold priority"; |
| } |
| leaf signaling-type { |
| type identityref { |
| //TODO: FIXME |
| //base te-types:path-signaling-type; |
| base te-types:tunnel-type; |
| |
| } |
| description "TE tunnel path signaling type"; |
| } |
| container hierarchical-link-id { |
| description |
| "Identifies a hierarchical link (in server layer) |
| that this tunnel is associated with."; |
| leaf local-te-node-id { |
| type te-types:te-node-id; |
| description |
| "Local TE node identifier"; |
| } |
| leaf local-te-link-tp-id { |
| type te-types:te-tp-id; |
| description |
| "Local TE link termination point identifier"; |
| } |
| leaf remote-te-node-id { |
| type te-types:te-node-id; |
| description |
| "Remote TE node identifier"; |
| } |
| leaf te-topology-id { |
| type te-types:te-topology-id; |
| description |
| "It is presumed that a datastore will contain many |
| topologies. To distinguish between topologies it is |
| vital to have UNIQUE topology identifiers."; |
| } |
| } |
| uses bidir-assoc-properties; |
| } |
| |
| grouping tunnel-p2p-params_state { |
| description |
| "State parameters relating to TE tunnel"; |
| leaf oper-status { |
| type identityref { |
| base te-types:state-type; |
| } |
| description "TE tunnel operational state."; |
| } |
| leaf prov-state { |
| type identityref { |
| base te-types:prov-state-type; |
| } |
| description "TE tunnel provisioning state."; |
| } |
| } |
| |
| /* TE tunnel configuration/state grouping */ |
| grouping tunnel-p2mp-properties { |
| description |
| "Top level grouping for P2MP tunnel properties."; |
| container config { |
| description |
| "Configuration parameters relating to |
| tunnel P2MP properties"; |
| uses tunnel-p2mp-params_config; |
| } |
| |
| container state { |
| config false; |
| description |
| "State information associated with tunnel |
| properties"; |
| uses tunnel-p2mp-params_config; |
| } |
| } |
| |
| grouping p2p-path-candidate-secondary-path-config { |
| description |
| "Configuration parameters relating to a secondary path which |
| is a candidate for a particular primary path"; |
| |
| leaf secondary-path { |
| type leafref { |
| path "../../../../../../p2p-secondary-paths/" + |
| "p2p-secondary-path/config/name"; |
| } |
| description |
| "A reference to the secondary path that should be utilised |
| when the containing primary path option is in use"; |
| } |
| |
| leaf priority { |
| type uint16; |
| description |
| "The priority of the specified secondary path option. Higher |
| priority options are less preferable - such that a secondary |
| path reference with a priority of 0 is the most preferred"; |
| } |
| leaf path-setup-protocol { |
| type identityref { |
| base te-types:te-path-setup-protocol; |
| } |
| description |
| "Signaling protocol used to set up this tunnel"; |
| } |
| } |
| |
| grouping p2p-path-candidate-secondary-path-state { |
| description |
| "Operational state parameters relating to a secondary path |
| which is a candidate for a particular primary path"; |
| |
| leaf active { |
| type boolean; |
| description |
| "Indicates the current active path option that has |
| been selected of the candidate secondary paths"; |
| } |
| } |
| |
| grouping tunnel-p2p-properties { |
| description |
| "Top level grouping for tunnel properties."; |
| container config { |
| description |
| "Configuration parameters relating to |
| tunnel properties"; |
| uses tunnel-p2p-params_config; |
| } |
| container state { |
| config false; |
| description |
| "State information associated with tunnel |
| properties"; |
| uses tunnel-p2p-params_config; |
| uses tunnel-p2p-params_state; |
| } |
| uses te-tunnel-bandwidth_top; |
| |
| container p2p-primary-paths { |
| description "Set of P2P primary aths container"; |
| list p2p-primary-path { |
| key "name"; |
| description |
| "List of primary paths for this tunnel."; |
| leaf name { |
| type leafref { |
| path "../config/name"; |
| } |
| description "TE path name"; |
| } |
| uses p2p-primary-path-properties; |
| container candidate-p2p-secondary-paths { |
| description |
| "The set of candidate secondary paths which may be used |
| for this primary path. When secondary paths are specified |
| in the list the path of the secondary LSP in use must be |
| restricted to those path options referenced. The |
| priority of the secondary paths is specified within the |
| list. Higher priority values are less preferred - that is |
| to say that a path with priority 0 is the most preferred |
| path. In the case that the list is empty, any secondary |
| path option may be utilised when the current primary path |
| is in use."; |
| list candidate-p2p-secondary-path { |
| key "secondary-path"; |
| description |
| "List of secondary paths for this tunnel."; |
| leaf secondary-path { |
| type leafref { |
| path "../config/secondary-path"; |
| } |
| description "TE path name"; |
| } |
| container config { |
| description |
| "Configuration parameters relating to the candidate |
| secondary path"; |
| |
| uses p2p-path-candidate-secondary-path-config; |
| } |
| |
| container state { |
| config false; |
| description |
| "Operational state parameters relating to the candidate |
| secondary path"; |
| |
| uses p2p-path-candidate-secondary-path-config; |
| uses p2p-path-candidate-secondary-path-state; |
| } |
| } |
| } |
| } |
| } |
| container p2p-secondary-paths { |
| description "Set of P2P secondary paths container"; |
| list p2p-secondary-path { |
| key "name"; |
| description |
| "List of secondary paths for this tunnel."; |
| leaf name { |
| type leafref { |
| path "../config/name"; |
| } |
| description "TE path name"; |
| } |
| uses p2p-primary-path-properties; |
| } |
| } |
| } |
| |
| grouping tunnel-actions { |
| description "Tunnel actions"; |
| /***TODO: FIXME: actions are not supported by yangtools yet |
| action tunnel-action { |
| description "Tunnel action"; |
| input { |
| leaf action-type { |
| type identityref { |
| base te-types:tunnel-action-type; |
| } |
| description "Tunnel action type"; |
| } |
| } |
| output { |
| leaf action-result { |
| type identityref { |
| base te-types:te-action-result; |
| } |
| description "The result of the RPC operation"; |
| } |
| } |
| } |
| ****TODO: FIXME****/ |
| } |
| /*** End of TE tunnel groupings ***/ |
| |
| /** |
| * LSP related generic groupings |
| */ |
| grouping lsp-record-route-information_state { |
| description "recorded route information grouping"; |
| container lsp-record-route-subobjects { |
| description "RSVP recorded route object information"; |
| list record-route-subobject { |
| when "../../origin-type = 'ingress'" { |
| description "Applicable on non-ingress LSPs only"; |
| } |
| key "index"; |
| description "Record route sub-object list"; |
| leaf index { |
| type uint32; |
| description "RRO subobject index"; |
| } |
| uses te-types:record-route-subobject; |
| } |
| } |
| } |
| |
| grouping lsp-properties_state { |
| description |
| "State parameters relating to LSP"; |
| leaf oper-status { |
| type identityref { |
| base te-types:state-type; |
| } |
| description "LSP operational state."; |
| } |
| leaf path-setup-protocol { |
| type identityref { |
| base te-types:te-path-setup-protocol; |
| } |
| description |
| "Signaling protocol used to set up this tunnel"; |
| } |
| leaf origin-type { |
| type enumeration { |
| enum ingress { |
| description |
| "Origin ingress"; |
| } |
| enum egress { |
| description |
| "Origin egress"; |
| } |
| enum transit { |
| description |
| "transit"; |
| } |
| } |
| description |
| "Origin type of LSP relative to the location |
| of the local switch in the path."; |
| } |
| |
| leaf lsp-resource-status { |
| type enumeration { |
| enum primary { |
| description |
| "A primary LSP is a fully established LSP for |
| which the resource allocation has been committed |
| at the data plane"; |
| } |
| enum secondary { |
| description |
| "A secondary LSP is an LSP that has been provisioned |
| in the control plane only; e.g. resource allocation |
| has not been committed at the data plane"; |
| } |
| } |
| description "LSP resource allocation type"; |
| reference "rfc4872, section 4.2.1"; |
| } |
| |
| leaf lsp-protection-role { |
| type enumeration { |
| enum working { |
| description |
| "A working LSP must be a primary LSP whilst a protecting |
| LSP can be either a primary or a secondary LSP. Also, |
| known as protected LSPs when working LSPs are associated |
| with protecting LSPs."; |
| } |
| enum protecting { |
| description |
| "A secondary LSP is an LSP that has been provisioned |
| in the control plane only; e.g. resource allocation |
| has not been committed at the data plane"; |
| } |
| } |
| description "LSP role type"; |
| reference "rfc4872, section 4.2.1"; |
| } |
| |
| leaf lsp-carry-normal-traffic { |
| type empty; |
| description |
| "This bit is set when a protecting LSP is carrying the normal |
| traffic after protection switching"; |
| } |
| } |
| /*** End of TE LSP groupings ***/ |
| |
| /** |
| * TE global generic groupings |
| */ |
| |
| /* Global named admin-groups configuration data */ |
| grouping named-admin-groups_config { |
| description |
| "Global named administrative groups configuration |
| grouping"; |
| leaf name { |
| type string; |
| description |
| "A string name that uniquely identifies a TE |
| interface named admin-group"; |
| } |
| leaf bit-position { |
| type uint32; |
| description |
| "Bit position representing the administrative group"; |
| } |
| } |
| grouping named-admin-groups { |
| description |
| "Global named administrative groups configuration |
| grouping"; |
| container named-admin-groups { |
| description "TE named admin groups container"; |
| list named-admin-group { |
| if-feature te-types:extended-admin-groups; |
| if-feature te-types:named-extended-admin-groups; |
| key "name"; |
| description |
| "List of named TE admin-groups"; |
| leaf name { |
| type leafref { |
| path "../config/name"; |
| } |
| description "Admin-group name"; |
| } |
| container config { |
| description |
| "Configuration parameters related to admin-groups"; |
| uses named-admin-groups_config; |
| } |
| container state { |
| config false; |
| description |
| "State parameters related to admin-groups"; |
| uses named-admin-groups_config; |
| } |
| } |
| } |
| } |
| |
| /* Global named admin-srlgs configuration data */ |
| grouping named-srlgs_config { |
| description |
| "Global named SRLGs configuration grouping"; |
| leaf name { |
| type string; |
| description |
| "A string name that uniquely identifies a TE |
| interface named srlg"; |
| } |
| leaf group { |
| type te-types:srlg; |
| description "An SRLG value"; |
| } |
| leaf cost { |
| type uint32; |
| description |
| "SRLG associated cost. Used during path to append |
| the path cost when traversing a link with this SRLG"; |
| } |
| } |
| |
| grouping named-srlgs { |
| description |
| "Global named SRLGs configuration grouping"; |
| container named-srlgs { |
| description "TE named SRLGs container"; |
| list named-srlg { |
| if-feature te-types:named-srlg-groups; |
| key "name"; |
| description |
| "A list of named SRLG groups"; |
| leaf name { |
| type leafref { |
| path "../config/name"; |
| } |
| description "SRLG name"; |
| } |
| container config { |
| description |
| "Configuration parameters related to named SRLGs"; |
| uses named-srlgs_config; |
| } |
| container state { |
| config false; |
| description |
| "State parameters related to named SRLGs"; |
| uses named-srlgs_config; |
| } |
| } |
| } |
| } |
| |
| /* Global named explicit-paths configuration data */ |
| grouping named-explicit-paths_config { |
| description |
| "Global explicit path configuration |
| grouping"; |
| leaf name { |
| type string; |
| description |
| "A string name that uniquely identifies an |
| explicit path"; |
| } |
| container explicit-route-objects { |
| description "Explicit route objects container"; |
| list explicit-route-object { |
| key "index"; |
| description |
| "List of explicit route objects"; |
| leaf index { |
| type leafref { |
| path "../config/index"; |
| } |
| description |
| "Index of this explicit route object"; |
| } |
| leaf explicit-route-usage { |
| type identityref { |
| base te-types:route-usage-type; |
| } |
| description "An explicit-route hop action."; |
| } |
| uses te-types:explicit-route-hop; |
| } |
| } |
| } |
| |
| grouping named-explicit-paths { |
| description |
| "Global explicit path configuration |
| grouping"; |
| container named-explicit-paths { |
| description "TE named explicit path container"; |
| list named-explicit-path { |
| key "name"; |
| description |
| "A list of explicit paths"; |
| leaf name { |
| type leafref { |
| path "../config/name"; |
| } |
| description "Explicit-path name"; |
| } |
| |
| container config { |
| description |
| "Configuration parameters related to named paths"; |
| uses named-explicit-paths_config; |
| } |
| container state { |
| config false; |
| description |
| "State parameters related to named paths"; |
| uses named-explicit-paths_config; |
| } |
| } |
| } |
| } |
| |
| /* Global named paths constraints configuration data */ |
| grouping named-path-constraints_config { |
| description |
| "Global named path constraints configuration |
| grouping"; |
| leaf name { |
| type string; |
| description |
| "A string name that uniquely identifies a |
| path constraint set"; |
| } |
| leaf topology-id { |
| type te-types:te-topology-id; |
| description |
| "The tunnel path is computed using the specific |
| topology identified by this identifier"; |
| } |
| leaf cost-limit { |
| type uint32 { |
| range "1..4294967295"; |
| } |
| description |
| "The tunnel path cost limit."; |
| } |
| leaf hop-limit { |
| type uint8 { |
| range "1..255"; |
| } |
| description |
| "The tunnel path hop limit."; |
| } |
| leaf metric-type { |
| type identityref { |
| base te-types:path-metric-type; |
| } |
| default te-types:path-metric-te; |
| description |
| "The tunnel path metric type."; |
| } |
| leaf tiebreaker-type { |
| type identityref { |
| base te-types:path-tiebreaker-type; |
| } |
| default te-types:path-tiebreaker-maxfill; |
| description |
| "The tunnel path computation tie breakers."; |
| } |
| leaf ignore-overload { |
| type boolean; |
| description |
| "The tunnel path can traverse overloaded node."; |
| } |
| leaf setup-priority { |
| type uint8 { |
| range "0..7"; |
| } |
| description |
| "TE LSP setup priority"; |
| } |
| leaf hold-priority { |
| type uint8 { |
| range "0..7"; |
| } |
| description |
| "TE LSP hold priority"; |
| } |
| uses path-affinities; |
| uses path-srlgs; |
| uses path-route-objects; |
| uses te-path-bandwidth_top; |
| } |
| |
| grouping named-path-constraints { |
| description |
| "Global named path constraints configuration |
| grouping"; |
| container named-path-constraints { |
| description "TE named path constraints container"; |
| list named-path-constraint { |
| if-feature te-types:named-path-constraints; |
| key "name"; |
| description |
| "A list of named path constraints"; |
| leaf name { |
| type leafref { |
| path "../config/name"; |
| } |
| description "Path constraint name"; |
| } |
| container config { |
| description |
| "Configuration parameters related to admin-groups"; |
| uses named-path-constraints_config; |
| } |
| container state { |
| config false; |
| description |
| "State parameters related to admin-groups"; |
| uses named-path-constraints_config; |
| } |
| } |
| } |
| } |
| |
| /* TE globals container data */ |
| grouping globals-grouping { |
| description |
| "Globals TE system-wide configuration data grouping"; |
| container globals { |
| description |
| "Globals TE system-wide configuration data container"; |
| uses named-admin-groups; |
| uses named-srlgs; |
| uses named-explicit-paths; |
| uses named-path-constraints; |
| } |
| } |
| |
| /* TE tunnels container data */ |
| grouping tunnels-grouping { |
| description |
| "Tunnels TE configuration data grouping"; |
| container tunnels { |
| description |
| "Tunnels TE configuration data container"; |
| |
| list tunnel { |
| key "name"; |
| unique "identifier"; |
| description "P2P TE tunnels list."; |
| leaf name { |
| type leafref { |
| path "../config/name"; |
| } |
| description "TE tunnel name."; |
| } |
| leaf identifier { |
| type leafref { |
| path "../config/identifier"; |
| } |
| description |
| "TE tunnel Identifier."; |
| } |
| |
| |
| uses tunnel-p2p-properties; |
| uses tunnel-actions; |
| } |
| list tunnel-p2mp { |
| key "name"; |
| unique "identifier"; |
| description "P2MP TE tunnels list."; |
| leaf name { |
| type leafref { |
| path "../config/name"; |
| } |
| description "TE tunnel name."; |
| } |
| leaf identifier { |
| type leafref { |
| path "../config/identifier"; |
| } |
| description |
| "TE tunnel Identifier."; |
| } |
| uses tunnel-p2mp-properties; |
| } |
| } |
| } |
| |
| /* TE LSPs ephemeral state container data */ |
| grouping lsps-state-grouping { |
| description |
| "LSPs state operational data grouping"; |
| container lsps-state { |
| config "false"; |
| description "LSPs operational state data."; |
| |
| list lsp { |
| key |
| "source destination tunnel-id lsp-id "+ |
| "extended-tunnel-id type"; |
| description |
| "List of LSPs associated with the tunnel."; |
| leaf source { |
| type inet:ip-address; |
| description |
| "Tunnel sender address extracted from |
| SENDER_TEMPLATE object"; |
| reference "RFC3209"; |
| } |
| leaf destination { |
| type inet:ip-address; |
| description |
| "Tunnel endpoint address extracted from |
| SESSION object"; |
| reference "RFC3209"; |
| } |
| leaf tunnel-id { |
| type uint16; |
| description |
| "Tunnel identifier used in the SESSION |
| that remains constant over the life |
| of the tunnel."; |
| reference "RFC3209"; |
| } |
| leaf lsp-id { |
| type uint16; |
| description |
| "Identifier used in the SENDER_TEMPLATE |
| and the FILTER_SPEC that can be changed |
| to allow a sender to share resources with |
| itself."; |
| reference "RFC3209"; |
| } |
| leaf extended-tunnel-id { |
| type inet:ip-address; |
| description |
| "Extended Tunnel ID of the LSP."; |
| reference "RFC3209"; |
| } |
| leaf type { |
| type identityref { |
| base te-types:tunnel-type; |
| } |
| description "The LSP type P2P or P2MP"; |
| } |
| |
| uses lsp-properties_state; |
| uses lsp-record-route-information_state; |
| } |
| } |
| } |
| /*** End of TE global groupings ***/ |
| |
| /** |
| * TE configurations container |
| */ |
| container te { |
| presence "Enable TE feature."; |
| description |
| "TE global container."; |
| |
| /* TE Global Configuration Data */ |
| uses globals-grouping; |
| |
| /* TE Tunnel Configuration Data */ |
| uses tunnels-grouping; |
| |
| /* TE LSPs State Data */ |
| uses lsps-state-grouping; |
| } |
| |
| /* TE Global RPCs/execution Data */ |
| rpc globals-rpc { |
| description |
| "Execution data for TE global."; |
| } |
| |
| /* TE interfaces RPCs/execution Data */ |
| rpc interfaces-rpc { |
| description |
| "Execution data for TE interfaces."; |
| } |
| |
| /* TE Tunnel RPCs/execution Data */ |
| rpc tunnels-rpc { |
| description "TE tunnels RPC nodes"; |
| input { |
| container tunnel-info { |
| description "Tunnel Identification"; |
| choice type { |
| description "Tunnel information type"; |
| case tunnel-p2p { |
| leaf p2p-id { |
| type te:tunnel-ref; |
| description "P2P TE tunnel"; |
| } |
| } |
| case tunnel-p2mp { |
| leaf p2mp-id { |
| type te:tunnel-p2mp-ref; |
| description "P2MP TE tunnel"; |
| } |
| } |
| } |
| } |
| } |
| output { |
| container result { |
| description |
| "The container result of the RPC operation"; |
| leaf result { |
| type enumeration { |
| enum success { |
| description "Origin ingress"; |
| } |
| enum in-progress { |
| description "Origin egress"; |
| } |
| enum fail { |
| description "transit"; |
| } |
| } |
| description "The result of the RPC operation"; |
| } |
| } |
| } |
| } |
| |
| /**************************************************************/ |
| //TODO: FIXME: HENRY added begins |
| |
| grouping te-optimization-criterion { |
| description |
| ""; |
| container optimization-criterion { |
| description "Optimization criterion."; |
| list metric { |
| key "name"; |
| description |
| "Name of the numerical property"; |
| |
| leaf name { |
| type identityref { |
| base te-types:te-path-numerical-property; |
| } |
| description ""; |
| } |
| leaf goal { |
| type enumeration { |
| enum minimize { |
| description "Minimize"; |
| } |
| enum maxmize { |
| description "Maxmize"; |
| } |
| } |
| description ""; |
| } |
| leaf weight { |
| type uint8; |
| description ""; |
| } |
| } |
| list tiebreaker { |
| key "metric"; |
| description |
| "A list of numerical properties used as tiebreakers. |
| The order of a property in the list is the precedence |
| of tiebreaking."; |
| |
| leaf metric { |
| type identityref { |
| base te-types:te-path-numerical-property; |
| } |
| description ""; |
| } |
| leaf tiebreaker-type { |
| type identityref { |
| base te-types:path-tiebreaker-type; |
| } |
| default te-types:path-tiebreaker-minfill; |
| description |
| "The tunnel path computation tie breakers."; |
| } |
| } |
| } |
| } |
| |
| grouping te-path-constraints { |
| description |
| "TE path constraints configuration grouping"; |
| |
| container path-constraints { |
| description "Path constraints."; |
| list metric { |
| key "name"; |
| description ""; |
| |
| leaf name { |
| type identityref { |
| base te-types:te-path-numerical-property; |
| } |
| description |
| "Name of the numerical property"; |
| } |
| leaf low-limit { |
| type uint64; |
| description |
| ""; |
| } |
| leaf high-limit { |
| type uint64; |
| description |
| ""; |
| } |
| } |
| leaf bandwidth-generic { |
| type te-types:te-bandwidth; |
| description |
| "A technology agnostic requested bandwidth to use |
| for path computation"; |
| } |
| leaf setup-priority { |
| type uint8 { |
| range "0..7"; |
| } |
| description |
| "TE LSP requested setup priority"; |
| } |
| leaf hold-priority { |
| type uint8 { |
| range "0..7"; |
| } |
| description |
| "TE LSP requested hold priority"; |
| } |
| leaf ignore-overload { |
| type boolean; |
| description |
| "The tunnel path can traverse overloaded node."; |
| } |
| uses path-affinities; |
| uses path-srlgs; |
| } |
| } |
| |
| grouping te-path-properties { |
| description |
| ""; |
| |
| container path-properties { |
| description ""; |
| list metric { |
| key "name"; |
| description ""; |
| |
| leaf name { |
| type identityref { |
| base te-types:te-path-numerical-property; |
| } |
| description ""; |
| } |
| leaf value { |
| type uint64; |
| description ""; |
| } |
| } |
| leaf bandwidth-generic { |
| type te-types:te-bandwidth; |
| description |
| "A technology agnostic requested bandwidth to use |
| for path computation"; |
| } |
| leaf setup-priority { |
| type uint8 { |
| range "0..7"; |
| } |
| description |
| "TE LSP requested setup priority"; |
| } |
| leaf hold-priority { |
| type uint8 { |
| range "0..7"; |
| } |
| description |
| "TE LSP requested hold priority"; |
| } |
| leaf ignore-overload { |
| type boolean; |
| description |
| "The tunnel path can traverse overloaded node."; |
| } |
| uses path-affinities; |
| uses path-srlgs; |
| } |
| } |
| |
| rpc te-tunnel-path-compute { |
| description "TE tunnel path computation "; |
| input { |
| leaf inter-request-diversity { |
| type te-types:te-path-disjointness; |
| description |
| "Diversity requirement between requests. |
| If not specified, requests are computed independently."; |
| } |
| uses te-optimization-criterion; |
| |
| list request { |
| key "id"; |
| description "A list of request items."; |
| |
| leaf id { |
| type uint8; |
| description |
| "Request ID."; |
| } |
| |
| leaf source { |
| type te-types:te-node-id; |
| description |
| "TE tunnel source address."; |
| } |
| leaf destination { |
| type te-types:te-node-id; |
| description |
| "P2P tunnel destination address"; |
| } |
| leaf src-tp-id { |
| type binary; |
| description |
| "TE tunnel source termination point identifier."; |
| } |
| leaf dst-tp-id { |
| type binary; |
| description |
| "TE tunnel destination termination point identifier."; |
| } |
| leaf switching-layer { |
| type identityref { |
| base te-types:switching-capabilities; |
| } |
| description |
| "Switching layer where the requests are computed."; |
| } |
| leaf encoding { |
| type identityref { |
| base te-types:lsp-encoding-types; |
| } |
| description "LSP encoding type"; |
| } |
| |
| uses te-path-constraints; |
| |
| container explicit-route-objects { |
| description ""; |
| } |
| } |
| } |
| output { |
| leaf return-code { |
| type enumeration { |
| enum success { |
| description "success"; |
| } |
| enum aborted { |
| description ""; |
| } |
| enum destination-not-found { |
| description ""; |
| } |
| enum invalid-argument { |
| description ""; |
| } |
| enum no-memory { |
| description ""; |
| } |
| enum no-path-found{ |
| description ""; |
| } |
| enum other-error { |
| description ""; |
| } |
| enum some-path-not-found{ |
| description ""; |
| } |
| enum source-not-found { |
| description ""; |
| } |
| enum topology-error { |
| description ""; |
| } |
| } |
| description |
| "Return code."; |
| } |
| list result { |
| key "id"; |
| description |
| "A list of results for all requests."; |
| |
| leaf id { |
| type uint8; |
| description |
| "Request ID."; |
| } |
| |
| uses te-path-properties; |
| |
| container explicit-route-objects { |
| description ""; |
| } |
| } |
| } |
| } |
| |
| //TODO: FIXME: HENRY added finish |
| /**************************************************************/ |
| |
| /* TE Global Notification Data */ |
| notification globals-notif { |
| description |
| "Notification messages for Global TE."; |
| } |
| |
| /* TE Tunnel Notification Data */ |
| notification tunnels-notif { |
| description |
| "Notification messages for TE tunnels."; |
| } |
| } |