draft-rgandhi-mpls-te.yang

module ietf-mpls-te {

    namespace "urn:cisco:params:xml:ns:yang:ietf-mpls-te";

    /* Replace with IANA when assigned */
    prefix "mpls-te";

    import ietf-inet-types { prefix inet; }
    import ietf-mpls-te-types { prefix mtt; }

    organization
      "IETF MPLS Working Group";

    contact
      "Rakesh Gandhi rgandhi@cisco.com
       Tarek Saad tsaad@cisco.com
       Robert Sawaya rsawaya@cisco.com";

    description
        "YANG data module for MPLS-TE and RSVP-TE configuration, 
         state, RPC and notifications.";

    revision 2014-11-06 {
        description
            "Initial revision.";
    }

    /* Groupings for MPLS-TE */
    grouping igp-protocol-def {
         leaf instance-id {
              description
                  "Constrains the computed path to a specific IGP
                   instance.";
              type string;
         }
         leaf igp {
             description
                 "Constrains the computed path to a specific IGP.";
             type enumeration {
                 enum ospf;
                 enum isis;
             }
         }
         choice igp-type {
              description
                  "Constrains the computed path to a specific IGP
                   area or level.";
              container isis {
                  leaf level {
                      type uint8 {
                           range "1..2";
                      }
                  }
              }
              container ospf {
                  leaf area {
                       type uint32 {
                            range "0..4294967295";
                       }
                  }
              }
         }
    }

    grouping igp-te-domains {
        container igp-te-domains {
            description "MPLS-TE enabled IGPs.";
            list igp-te-domain {
                key "instance-id";
                description "MPLS-TE enabled IGP instance.";
                uses igp-protocol-def;

                leaf te-router-id {
                    description "MPLS-TE Router ID.";
                    type inet:ip-address;
                }
                leaf-list routing-afs {
                    type inet:ip-version;
                }
            }
        }
    }

    /* Groupings for MPLS-TE Tunnels */
    grouping lsp-properties {
        choice lsp-type {
            /* Point-to-point LSP properties */
            case p2p {
                list p2p-properties {
                    when "/tunnels-cfg/tunnel/type = p2p";
                    key "po-index";
                    description "An index identifying a set of LSP
                                 properties, p2p path-option index.";
                    /* definition of the destination 
                       and associated path */
                    uses path-option-reference;
                    uses tunnel-template-leaf;
                }
            }
    
            /* Point-to-multipoint LSP properties */
            case p2mp {
                when "/tunnels-cfg/tunnel/type = p2mp";
                list p2mp-properties {
                    key "lsp-index";
                    leaf lsp-index {
                        description "An index identifying a set of LSP
                                     properties and their paths.";
                        type uint8 {
                             range "0..255";
                        }
                    }

                    /* definition of the destination 
                       and associated path */
                    list p2mp-path-group {
                        key "destination";
                        description "List of destinations 
                                     and their paths.";
                        uses path-option-reference;
                        uses tunnel-template-leaf;
                    }
                }
            }
        }
    }

    grouping path-option-reference {
        leaf destination {
            description "A reference to an MPLS-TE tunnel destination.";
            type leafref {
                path "/tunnels-cfg/tunnel/destination/address";
            }
        }
        leaf po-index {
            description "A reference to an MPLS-TE tunnel path-option.";
            type leafref {
                path "/tunnels-cfg/tunnel/destination
                  [address=current()/../destination]/paths/po-index";
            }
        }
    }

    grouping path-properties {
        choice type {
            case dynamic {
                leaf dynamic {
                    description
                        "A CSPF dynamically computed path";
                    type boolean;
                }
            }
            case explicit {
                description
                    "An operator specified explicit path.";
                list hops {
                    key "hop-index";
                    leaf hop-index {
                        type uint8 {
                             range "0..255";
                        }
                    }
                    leaf hop-address {
                        description
                            "An IP hop address.";
                        type mtt:hop-address-type;
                    }
                    leaf hop-action {
                        description
                            "An IP hop action.";
                        type mtt:hop-action-type;
                    }
                }
            }
        }

        container igp-constraint {
            uses igp-protocol-def;
        }

        leaf no-validation {
            description
                "Indicates no validation checks to be attempted on this
                 path.";
            type boolean;
        }
        leaf lockdown {
            description
                "Indicates no reoptimization to be attempted for this
                 path.";
            type boolean;
        }
    }

    grouping bfd-over-tunnel {
        container bfd-over-tunnel {
            presence "Enable BFD fast-detect on the tunnel.";
            leaf type {
                type mtt:bfd-type;
            }
            leaf encap-mode {
                type mtt:bfd-encap-mode-type;
            }
            leaf bringup-timeout {
                type uint32 {
                     range "60..3600";
                }
            }
            leaf dampening {
                type uint32 {
                     range "1..518400000";
                }
            }
            container lsp-ping {
                leaf disable {
                    type boolean;
                    default false;
                }
                leaf interval {
                     type uint32 {
                          range "60..3600";
                     }
                }
            }
            leaf minimum-interval {
                type uint32 {
                     range "3..30000";
                }
            }
            leaf multiplier {
                type uint32 {
                     range "3..10";
                }
            }
        }
    }

    grouping path-selection {
        container path-selection {
            leaf cost-limit {
                description
                    "The tunnel path cost limit.";
                type uint32 {
                     range "1..4294967295";
                }
                
            }
            leaf hop-limit {
                description
                    "The tunnel path hop limit.";
                type uint8 {
                     range "1..255";
                }
            }
            leaf metric-type {
                description
                    "The tunnel path metric type.";
                type mtt:path-metric-type;
            }
            leaf tiebreaker-type {
                description
                    "The tunnel path computation tie breakers.";
                type mtt:path-tiebreaker-type;
            }
            leaf ignore-overload {
                description
                    "The tunnel path can traverse overloaded node.";
                type boolean;
            }
        }
    }

    grouping signaling-properties {
        description "LSP signaling properties.";
        leaf source {
            description
                "LSP source address.";
            type inet:ip-address;
        }
        container fast-reroute {
            presence "Requests FRR local protection on LSRs.";
            leaf bandwidth-protection-desired {
                description
                    "Request FRR bandwidth protection on LSRs.";
                type boolean;
            }
            leaf node-protection-desired {
                description
                    "Request FRR node protection on LSRs.";
                type boolean;
            }
        }
        leaf record-route {
            description
                "Requests path RRO recording in RSVP PATH message.";
            type boolean;
        }
        leaf signaled-name {
            description
                "Sets the session name to use in the session attribute
                 object.";
            type string;
        }
        container priority {
            description
                "Sets the setup/hold priority to use in the session
                 attribute object.";
            leaf setup {
                type uint8 {
                     range "0..7";
                }
            }
            leaf hold {
                type uint8 {
                     range "0..7";
                }
            }
        }
        leaf soft-preemption {
            description
                "Requests soft-preemption in session 
                 attributes object at
                 at traversed LSR(s).";
            type boolean;
        }
        container signaled-bandwidth {
            description
                "Sets the requested bandwidth.";
            leaf type {
                 type mtt:bandwidth-type;
            }
            leaf value {
                type uint32 {
                     range "0..4294967295";
                }
            }
        }
    }

    grouping logging {
        container logging {
            choice event-type {
                case all {
                    leaf all {
                        type boolean;
                    }
                    description "Enables all MPLS-TE tunnel 
                                 event logging.";
                }
                case bfd-status {
                    leaf bfd-status {
                        type boolean;
                    }
                    description "Enable MPLS-TE tunnel BFD 
                                 specific event logging.";
                }
                case link-status {
                    leaf link-status {
                        type boolean;
                    }
                    description "Enable link status event logging.";
                }
                case lsp-status {
                    choice event {
                        case all {
                            leaf all-lsp-status-events {
                                type boolean;
                            }
                            description "Enables all LSP status 
                                         events logging.";
                        }
                        case subset {
                            leaf-list events {
                                type mtt:lsp-status-event-type;
                            }
                        }
                    }
                }
                case cspf-failure {
                    leaf cspf-failure-events {
                        type boolean;
                    }
                    description "Enable MPLS-TE tunnel CSPF 
                                 failure event logging.";
                }
            }
        }
    }

    grouping affinity {
        container affinity {
            choice style {
                case bitmap {
                    leaf value {
                         type uint32 {
                              range "0..4294967295";
                         }
                    }
                    leaf mask {
                         type uint32 {
                              range "0..4294967295";
                         }
                    }
                }
                case named {
                    list constraints {
                        key "action";
                        leaf action {
                             type mtt:affinity-action-type;
                        }
                        container constraint {
                            list affinity-list {
                                key "name";
                                leaf name {
                                     type string;
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    grouping routing-properties {
        choice routing-choice {
            description
                "Announces the tunnel to IGP as either 
                 autoroute or forwarding adjacency.";
            case autoroute {
                container autoroute-announce {
                    presence "Enable autoroute announce.";
                    description
                        "Announce the MPLS-TE tunnel as autoroute to 
                         IGP for use as IGP shortcut.";
                    leaf-list routing-afs {
                         type inet:ip-version;
                    }
                    choice metric-type {
                        leaf metric {
                            type uint32 {
                                 range "1..2147483647";
                            }
                        }
                        leaf relative-metric {
                            type int32 {
                                 range "-10..10";
                            }
                        }
                        leaf absolute-metric {
                            type uint32 {
                                 range "1..2147483647";
                            }
                        }
                    }
                }
            }
            case forwarding-adjacency {
                container forwarding-adjacency {
                    presence "Enable forwarding adjacency 
                              on the tunnel.";
                    description
                        "Announce the MPLS-TE tunnel 
                         as forwarding adjacency.";
                    leaf holdtime {
                        description
                            "Holdtime in seconds after 
                             tunnel becomes UP.";
                        type uint32 {
                             range "0..4294967295";
                        }
                    }
                    leaf-list routing-afs {
                         type inet:ip-version;
                    }
                }
            }
        }
    }

    grouping forwarding {
        description "Properties for using tunnel in forwarding.";
        container forwarding {
            leaf load-share {
                 description "ECMP tunnel forwarding 
                              load-share factor.";
                 type uint32 {
                      range "1..4294967295";
                 }
            }
            choice policy-type {
                container class {
                    leaf class {
                         type uint8 {
                              range "1..7";
                         }
                    }
                }
                container group {
                    leaf-list classes {
                         type uint8 {
                              range "1..7";
                         }
                    }
                }
            }
        }
    }

    grouping auto-bandwidth {
        container auto-bandwidth {
            presence "Enabled MPLS-TE tunnel 
                      auto-bandwidth feature.";
            description
                "MPLS-TE tunnel auto-bandwidth 
                 configuration parameters.";
            leaf adjustment-threshold {
                description
                    "Auto-bandwidth change percent 
                     to trigger adjustment.";
                type uint8 {
                     range "1..100";
                }
            }
            leaf adjustment-limit {
                description
                    "Auto-bandwidth consecutive collections to 
                     trigger adjustment.";
                type uint8 {
                     range "1..10";
                }
            }
            leaf adjustment-min-change {
                description
                    "Auto-bandwidth bandwidth change value to 
                     trigger an adjustment.";
                type uint32 {
                     range "1..4294967295";
                }
            }
            leaf overflow-threshold {
                description
                    "Auto-bandwidth change percent 
                     to trigger overflow.";
                type uint8 {
                     range "1..100";
                }
            }
            leaf overflow-limit {
                description
                    "Auto-bandwidth consecutive collections 
                     to trigger overflow.";
                type uint8 {
                     range "1..10";
                }
            }
            leaf overflow-min-change {
                description
                    "Auto-bandwidth bandwidth change value to 
                     trigger an overflow.";
                type uint32 {
                     range "1..4294967295";
                }
            }
            leaf underflow-threshold {
                description
                    "Auto-bandwidth change percent 
                     to trigger underflow.";
                type uint8 {
                     range "1..100";
                }
            }
            leaf underflow-limit {
                description
                    "Auto-bandwidth consecutive collections 
                     to trigger underflow.";
                type uint8 {
                     range "1..10";
                }
            }
            leaf underflow-min-change {
                description
                    "Auto-bandwidth bandwidth change value 
                     to trigger an underflow.";
                type uint32 {
                     range "1..4294967295";
                }
            }
            leaf collect-only {
                description
                    "Auto-bandwidth collection only mode.";
                type boolean;
            }
            leaf application-frequency {
                description
                    "Auto-bandwidth application 
                     interval in seconds.";
                type uint32 {
                     range "5..10080";
                }
            }
            container bandwidth-limit {
                description
                    "min/max bandwidth auto-bw can apply on a tunnel.";
                leaf min-limit {
                     type uint32 {
                          range "0..4294967295";
                     }
                }
                leaf max-limit {
                     type uint32 {
                          range "0..4294967295";
                     }
                }
            }
        }
    }

    grouping backup-bandwidth {
        container backup-bandwidth {
            when "/tunnels-cfg/tunnel/backup-tunnel = true";
            description
                "The backup bandwidth that can be protected by this
                 backup tunnel.";
            leaf value {
                type uint32 {
                     range "1..4294967295";
                }
            }
            leaf type {
                type mtt:backup-bandwidth-type;
            }
        }
    }

    grouping bidirectional-associated {
        container bidirectional {
            description
                "MPLS-TE associated bidirectional tunnel attributes.";
            container association {
                leaf id {
                     description
                         "The MPLS-TE tunnel association identifier.";
                     type uint16;
                }
                leaf source {
                     description
                            "The MPLS-TE tunnel association source.";
                     type inet:ip-address;
                }
                leaf global-source {
                     description
                            "The MPLS-TE tunnel association global
                             source.";
                     type inet:ip-address;
                }
                leaf type {
                     description "The MPLS-TE tunnel association type.";
                     type mtt:bidir-association-type;
                }
            }
        }
    }

    /* MPLS-TE Tunnel Template Configuration Data */
    grouping tunnel-template {
        leaf name {
            description "MPLS-TE tunnel-template name.";
            type string;
        }
        uses path-selection;
        uses signaling-properties;
        uses affinity;
        uses logging;
        uses auto-bandwidth;
        uses bfd-over-tunnel;
        uses routing-properties;
        uses forwarding;
    }

    grouping tunnel-template-leaf {
        leaf template {
            description
                "Name of the template to use for 
                 tunnel properties.";
            type leafref {
                path "/global-cfg/tunnel-templates/name";
            }
        }
    }

    /* groupings for rsvp */
    grouping rsvp-graceful-restart {
        description "Configure RSVP Graceful-Restart parameters.";
        container graceful-restart {
            presence "Enable RSVP graceful restart on the node.";

            leaf restart-time {
                description "Graceful restart time (seconds).";
                type uint32 {
                     range "60..3600";
                }
            }
            leaf hello-interval {
                description "Configure interval between successive 
                             Hello messages in milliseconds.";
                type uint32 {
                     range "3000..30000";
                }
            }
            leaf hello-misses {
                description "Configure max number of consecutive 
                             missed Hello messages.";
                type uint32 {
                     range "1..10";
                }
            }
            container pesr {
                description "Sending Path Error with 
                             Path State Removal flag.";
                leaf disable {
                     type boolean;
                }
            }
        }
    }

    grouping rsvp-authentication {
        container authentication {
            description "Configure RSVP authentication.";
            leaf key-chain {
                description "Key chain name to authenticate RSVP 
                             signaling messages.";
                type string {
                     length "1..32";
                }
            }
            leaf life-time {
                description "Life time for each security association";
                type uint32 {
                     range "30..86400";
                }
            }
            leaf window-size {
                description "Window-size to limit number of 
                             out-of-order messages.";
                type uint32 {
                     range "1..64";
                }
            }
            leaf challenge {
                 description "Enable challenge messages.";
                 type boolean;
            }
            leaf retransmits {
                 description "Number of retransmits when 
                             messages are dropped.";
                 type uint32 {
                      range "1..10000";
                 }
            }
        }
    }

    grouping rsvp-refresh-reduction {
        container refresh-reduction {
             description "Configure RSVP Refresh Reduction parameters.";
             leaf bundle-message-max-size {
                  description "Configure maximum size (bytes) of a 
                               single RSVP Bundle message.";
                      type uint32 {
                           range "512..65000";
                      }
                  }
                  leaf disable {
                       description "Disable refresh reduction.";
                       type boolean;
                  }
                  leaf reliable-ack-hold-time {
                       description "Configure hold time in milliseconds 
                                    for sending RSVP ACK message(s).";
                       type uint32 {
                            range "100..5000";
                       }
                  }
                  leaf reliable-ack-max-size {
                        description "Configure max size of a 
                                     single RSVP ACK message.";
                        type uint32 {
                             range "20..65000";
                       }
                  }
                  leaf reliable-retransmit-time {
                        description "Configure min delay in 
                                     milliseconds 
                                     to wait for an ACK 
                                     before a retransmit.";
                        type uint32 {
                             range "100..10000";
                        }
                  }
                  leaf reliable-srefresh {
                        description "Configure use of reliable 
                                     messaging for summary refresh.";
                        type boolean;
                  }
                  leaf summary-max-size {
                         description "Configure max size (bytes) 
                                      of a single RSVP 
                                      summary refresh message.";
                         type uint32 {
                              range "20..65000";
                         }
                  }
          }
    }

    grouping rsvp-signaling {
        container signaling {
            description "Configure RSVP signaling properties.";
            leaf dscp {
                description "DSCP for RSVP signaling messages.";
                type uint32 {
                     range "0..63";
                }
            }
            container hello-parameters {
                description "Configure Hello parameters.";
                leaf graceful-restart-interface-based {
                     description "Enable interface-based 
                                  Hello adjacency.";
                     type boolean;
                }
            }
            container rate-limiting-parameters {
                description "Configure rate limiting parameters.";
                leaf limit-messages-per-interval {
                     description "Number of messages to be 
                                  sent per interval.";
                     type uint32 {
                          range "1..500";
                     }
                }
                leaf limit-interval-size {
                    description "Size of an interval (milliseconds).";
                    type uint32 {
                         range "250..2000";
                    }
                }
            }
            container refresh-parameters {
                leaf refresh-interval {
                    description "Configure interval in seconds 
                                 between successive refreshes.";
                    type uint32 {
                         range "10..180";
                    }
                }
                leaf refresh-missed-messages {
                    description "Configure max number of consecutive 
                                 missed messages for state expiry.";
                    type uint32 {
                         range "1..8";
                    }
                }
                uses rsvp-refresh-reduction; 
            }
        }
    }

    grouping bandwidth-constraints {
        description "Bandwidth constraints.";
        container bandwidth-constraints {
            leaf maximum-reservable {
                type uint32 {
                     range "0..4294967295";
                }
            }
            leaf-list bc-value {
                type uint32 {
                    range "0..4294967295";
                }
                max-elements 8;
            }
        }
    }

    grouping bandwidth-constraint-values {
        choice value-type {
             case percentages {
                 container perc-values {
                     uses bandwidth-constraints;
                 }
             }
             case absolutes {
                 container abs-values {
                     uses bandwidth-constraints;
                 }
             }
        }
    }

    grouping rsvp-parameters {
        container rsvp {
            description "RSVP global configuration.";
            uses rsvp-graceful-restart;
            uses rsvp-authentication;
            uses rsvp-signaling;
    
            container reservable-bandwidth-percentages {
                description "Reservable bandwidth percentage 
                             capacity values.";
                container rdm-bc {
                    description "Russian Doll Model Bandwidth 
                                 Constraints.";
                    uses  bandwidth-constraints;
                }
                container mam-bc {
                    description "Maximum Allocation Model 
                                 Bandwidth Constraints.";
                    uses  bandwidth-constraints;
                }
                container mar-bc {
                    description "Maximum Allocation with Reservation 
                                 Model Bandwidth Constraints.";
                    uses  bandwidth-constraints;
                }
            }
        }
    }

    /* Grouping for MPLS-TE Link */
    grouping flooding-parameters {
        description "Link flooding properties.";
        container thresholds {
            description "Flooding threshold values.";
            choice type {
                case single-step {
                    leaf up-step {
                         type uint8 {
                              range "0..100";
                         }
                    }
                    leaf down-step {
                         type uint8 {
                              range "0..100";
                         }
                    }
                }
                case multiple-steps {
                    list up-steps {
                        key "value";
                        description "Percentage bandwidth exceeded 
                                     that causes flooding.";
                        leaf value {
                             type uint8 {
                                  range "0..100";
                             }
                        }
                    }
                    list down-steps {
                        key "value";
                        description "Percentage bandwidth crossed 
                                     that causes flooding.";
                        leaf value {
                             type uint8 {
                                  range "0..100";
                             }
                        }
                    }
                }
            }
        }
    }

    /* MPLS-TE Link Template Configuration Data */
    grouping link-template {
        leaf name {
            description "MPLS-TE link-template name.";
            type string;
        }
        uses rsvp-parameters;
    }

    grouping link-template-leaf {
        leaf template {
            description
                "Name of the template to use for 
                 TE link properties.";
            type leafref {
                path "/global-cfg/link-templates/name";
            }
        }
    }

    grouping auto-backup {
        description
            "Auto-tunnel backup properties.";
        container auto-backup {
            presence "Enable auto-tunnel backup on the node.";
            uses tunnel-template-leaf;
            leaf link-protection-only {
                 description
                     "Limit tunnel to link protection only.";
                 type boolean;
            }
            leaf backup-path-computation {
                 type mtt:path-computation-srlg-type;
            }
        }
    }

    /* MPLS-TE Global Configuration Data */
    container global-cfg {
        description
            "Configuration data model for Global System-wide 
             MPLS Traffic Engineering.";
        presence "Enable MPLS-TE Global mode.";

        grouping timers {
            container timers {
                description
                    "Global system-wide TE timer values.";
                leaf lsp-bw-hold-delay {
                     description
                         "Bandwidth hold interval for LSP 
                          admission in seconds.";
                     type uint32 {
                          range "0..300";
                     }
                }
                leaf lsp-preemption-delay {
                     description
                         "Delay in seconds to preempt LSPs 
                          after preemption event triggered.";
                     type uint32 {
                          range "0..300";
                     }
                }
                leaf link-holddown-sigerr {
                     description
                         "Link holddown in topology database for CSPF. 
                          Delay in seconds after signaling error.";
                     type uint32 {
                          range "0..300";
                     }
                }
            }
        }

        grouping reoptimization {
            description
                "Global periodic LSP reoptimization parameters.";
            container reoptimization {
                presence "Enable TE tunnel reoptimization globally 
                          on the node.";

                leaf interval {
                     description
                         "Periodic reoptimization interval in seconds.";
                     type uint32 {
                          range "0..604800";
                     }
                }
                leaf installation-delay {
                     description
                         "Delay in seconds before installing 
                          reoptimizing LSP in forwarding 
                          to carry traffic.";
                     type uint32 {
                          range "0..3600";
                     }
                }
                leaf cleanup-delay {
                     description
                         "Delay in seconds before removing 
                          reoptimized LSP in forwarding.";
                     type uint32 {
                          range "0..300";
                     }
                }
                leaf load-balance {
                     type  boolean;
                     description
                         "Enable CSPF ECMP load-balancing 
                          during reoptimization.";
                }
                container trigger-events {
                    description
                        "Event that triggers reoptimization.";
                    leaf link-up {
                        description
                            "Enable immediate reoptimization 
                             for the link up event.";
                        type  boolean;
                    }
                }
            }
        }

        grouping flooding {
            description
                "Global periodic TE topology flooding parameters.";
            container flooding {
                presence "Enable TE topology flooding 
                          globally on the node.";

                leaf interval {
                     description
                         "Periodic topology flooding 
                          interval in seconds.";
                     type uint32 {
                          range "0..3600";
                     }
                }

                uses flooding-parameters;
            }
        }

        grouping affinity-map {
            description
                "Mapping of affinity name and value.";
            leaf name {
                description
                    "Name of the affinity.";
                type string;
            }
            choice type  {
                case bitmap {
                    leaf value {
                         type uint32;
                    }
                }
                case bitmap-extended {
                    leaf-list bit-indexed {
                        type uint8;
                    }
                }
            }
        }

        grouping affinity-maps {
            description
                "Mapping of Affinity name and value.";

            container affinity-maps {
                list affinity-map {
                    description "MPLS-TE affinity-maps.";
                    key "name";
                    uses affinity-map;
                }
            }
        }

        grouping srlg-map {
            description
                "Mapping of SRLG name, value and admin-weight.";
            leaf name {
                 description "SRLG name.";
                 type string;
            }
            leaf value {
                 description "SRLG value.";
                 type uint32 {
                      range "0..4294967295";
                 }
            }
            leaf admin-weight {
                 description "SRLG administrative weight 
                              penalty in path computation.";
                 type uint32 {
                      range "0..4294967295";
                 }
            }
        }

        grouping srlg-maps {
            description
                "List of SRLG name, value and admin-weight.";
            container srlg-maps {
                list srlg-map {
                     description "MPLS-TE srlg-map.";
                     key "name";
                     uses srlg-map;
                }
            }
        }

        grouping global-soft-preemption {
            description
                "Soft-preemption properties.";
            container global-soft-preemption {
                presence "Enable soft-preemption on the node.";

                leaf timeout {
                     description
                         "Delay in seconds to teardown soft-preempted 
                          LSPs after soft-preemption event.";
                     type uint32 {
                          range "1..300";
                     }
                }
            }
        }

        grouping diff-serve-te {
            description
                "Diff-Serve TE properties.";
            container diff-serve-te {
                presence "Enable Diff-Serve TE on the node.";

                leaf bc-model {
                     description
                         "Diff-Serve TE bandwidth 
                          constraint model type.";
                     type mtt:bc-model-type;
                }
                list te-class {
                    description 
                        "Diff-Serve TE TE-class mapping.";
                    key "class-index";
                    leaf class-index {
                         description 
                            "TE-class index.";
                         type uint8 {
                              range "0..7";
                         }
                    }
                    leaf priority {
                         description 
                             "LSP setup or hold priority.";
                         type uint8 {
                              range "0..7";
                         }
                    }
                    leaf bc-value {
                         description 
                             "Bandwidth Constraint pool value.";
                         type uint8 {
                              range "0..7";
                         }
                    }
                }
            }
        }

        grouping global-auto-bandwidth {
            description
                "Auto-bandwidth adjustment properties.";
            container global-auto-bandwidth {
                presence "Enable auto-bandwidth on the node.";

                leaf stats-collection-interval {
                     description
                         "Auto-bandwidth statistics collection 
                          interval in seconds.";
                     type uint32 {
                          range "1..10080";
                     }
                }
            }
        }

        grouping auto-mesh-property {
            description
                "Auto-tunnel mesh-group properties.";
            leaf mesh-group {
                 description
                    "Value of the mesh-group.";
                 type uint32 {
                      range "0..4294967295";
                 }
            }
            uses tunnel-template-leaf;
            leaf access-list-name {
                 description
                    "Name of the access-list.";
                 type string;
            }
            leaf one-hop-only {
                 description
                    "Limit tunnel to one-hop away nodes only.";
                 type boolean;
            }
            leaf disable {
                 description
                    "Disable auto-tunnel creation for
                     given mesh-group.";
                 type boolean;
            }
        }

        grouping auto-mesh-groups {
            description  "Auto-tunnel mesh-groups."; 
            container auto-mesh-groups {
                presence  "Enable auto-tunnel mesh-groups 
                           on this node."; 
                list auto-mesh {
                     description "MPLS-TE auto-tunnel mesh-groups.";
                     key "mesh-group";
                     uses auto-mesh-property;
                }
            }
        }

        grouping pce {
            description  "Path Computation Element Properties."; 
            container pce {
                presence  "Enable Path Computation Element 
                           on this node."; 
                leaf address {
                     description  "Address of the PCE."; 
                     type inet:ip-address;
                }
                leaf node-id {
                     description  "PCE node identifier."; 
                     type string;
                }
                choice password-type {
                      leaf password-clear {
                           description "Clear password."; 
                           type string;
                      }
                      leaf password-encrypted {
                           description "Encrypted password."; 
                           type string;
                      }
                }
                leaf dead-timer {
                     description "Deadtimer interval in seconds."; 
                     type uint32 {
                          range "0..255";
                     }
                }
                leaf keep-alive-time {
                     description "Keepalive interval in seconds."; 
                     type uint32 {
                          range "0..255";
                     }
                }
                leaf keep-alive-tolerance-time {
                     description "Keepalive interval tolerance 
                                  in seconds."; 
                     type uint32 {
                          range "0..255";
                     }
                }
                container peer-table {
                         description "Configure PCE peers."; 
                         list peer {
                              key "peer-address"; 
                              description "PCE peer address.";
                              leaf peer-address{
                                   description "Address of PCE Peer."; 
                                   type inet:ip-address;
                              }
                         }
                         choice password-type {
                             leaf password-clear {
                                 description "Clear password."; 
                                 type string;
                             }
                             leaf password-encrypted {
                                  description "Encrypted password."; 
                                  type string;
                             }
                        }
                }
                leaf reoptimize-period {
                     description "PCE LSP reoptimization 
                                  period in seconds."; 
                     type uint32 {
                          range "0..604800";
                     }
                }
                leaf lsp-cleanup-time {
                     description "PCE LSP cleanup delay 
                                  without delegations."; 
                     type uint32 {
                          range "0..3600";
                     }
                }
                leaf request-timeout {
                     description "Request timeout value in seconds."; 
                     type uint32 {
                          range "5..100";
                     }
                }
                container stateful-client {
                    description
                        "Stateful Path Computation 
                         Element properties."; 
                    container capabilities {
                        leaf instantiation {
                             type boolean;
                        }
                    }
                }
                container logging {
                    choice event-type {
                        container all {
                            presence "Enable all PCE event logging.";
                        }
                        container peer-status {
                            presence "Enable peer status 
                                      event logging.";
                        }
                    }
                }

            }
        }

        grouping load-share {
            container load-share {
                description "ECMP tunnel forwarding 
                             load-share properties.";
                container unequal {
                    presence "ECMP tunnels to load-share forwarding of 
                              traffic unequally.";

                    leaf bandwidth-based {
                         type boolean;
                         description
                             "ECMP tunnels to load-share 
                              forwarding of traffic 
                              based on tunnel bandwidth.";
                    }
                }
            }
        }

        grouping tail-signaling {
            description
                "Signaling properties for LSP tail-end.";
            container tail-signaling {
                leaf advertise-explicit-null {
                     type boolean;
                }
            }
        }

        /* IGP-TE enabled domains 
         */
        uses igp-te-domains;

        /* Templates 
         */
        list tunnel-templates {
            description "MPLS-TE templates for tunnels.";
            key "name";
            uses tunnel-template;
        }

        list link-templates {
            description "MPLS-TE templates for links.";
            key "name";
            uses link-template;
        }

        /* Name/value maps */
        uses affinity-maps;
        uses srlg-maps;

        /* System-wide node properties */
        uses timers;
        uses flooding;
        uses reoptimization;
        uses load-share;
        uses tail-signaling;

        /* Specific feature properties */
        uses global-soft-preemption;
        uses diff-serve-te;
        uses global-auto-bandwidth;
        uses pce;
        uses auto-mesh-groups;
        uses auto-backup;
    }


    /* MPLS-TE Tunnel Configuration Data */
    container tunnels-cfg {
        description
            "Configuration, operational, notification and RPC data model
             for MPLS-TE tunnels.";
        presence "Enable MPLS-TE Global mode.";

        uses tunnel-template-leaf;

        list tunnel {
            key "name type";
            unique "identifier";
            description "MPLS-TE tunnel.";
            leaf name {
                type string;
                description "MPLS-TE tunnel name.";
            }
            leaf type {
                description "MPLS-TE tunnel type.";
                type mtt:tunnel-type;
            }
            leaf identifier {
                description
                    "MPLS-TE tunnel Identifier.";
                type uint16;
            }
            leaf description {
                description
                    "MPLS-TE tunnel description.";
                type string;
            }
            leaf admin-status {
                description "MPLS-TE tunnel administrative state.";
                type enumeration {
                     enum up;
                     enum down;
                }
                default up;
            }
            leaf path-protection {
                description "Enable MPLS-TE tunnel end-to-end 
                             path-protection.";
                type boolean;
            }
            container backup-tunnel {
                presence "Enable tunnel as being used for fast 
                          reroute backup.";

                uses backup-bandwidth;
            }

            uses path-selection;
            uses signaling-properties;
            uses affinity;
            uses logging;
            uses auto-bandwidth;
            uses bfd-over-tunnel;
            uses routing-properties;
            uses forwarding;

            uses bidirectional-associated;

            /* List of destinations and path(s) */
            list destination {
                key "address";
                description
                    "The MPLS-TE tunnel destination address.";
                leaf address {
                    type inet:ip-address;
                }
                list paths {
                    key "po-index";
                    leaf po-index {
                         type uint8 {
                              range "1..255";
                         }
                    }
                    uses path-properties;
                }
            }

            uses lsp-properties;
        }
    }

    /* MPLS-TE Link Configuration Data */
    container links-cfg {
        description
            "Configuration data model for MPLS-TE links.";

        uses link-template-leaf;

        list link {
            key "name";
            description "MPLS-TE links.";
            leaf name {
                 description "MPLS-TE link name.";
                 type string;
            }

            container flooding {
                uses flooding-parameters;
            }

            container fast-reroute-backups {
                choice type {
                    case static-tunnel {
                        list configured-backups {
                            key "name";
                            description "List of backup tunnels to 
                                         protect this link.";
                            leaf name {
                                 type string;
                            }
                        }
                    }
                    case auto-tunnel {
                        uses auto-backup;
                    }
                }
            }

            container igp {
                leaf admin-weight {
                    description "MPLS-TE admin-weight.";
                    type uint32 {
                         range "0..4294967295";
                    }
    
                }

                container affinities {
                    choice type {
                        case bitmap {
                            leaf bitmap { 
                                 type uint32; 
                            }
                        }
                        case bitmap-extended {
                            leaf-list bit-indexed {
                                type uint8;
                            }
                        }
                        case names {
                            list names {
                                key "name";
                                description "List of affinity names.";
                                leaf name { 
                                     type string; 
                                }
                            }
                        }
                    }
                }
    
                container srlgs {
                    choice type {
                        case srlg-name {
                            list names {
                                key "name";
                                description "List of SRLG names that 
                                    this link is part of.";
                                leaf name {
                                     type string;
                                }
                            }
                        }
                        case srlg-value {
                            list values {
                                key "value";
                                description "List of SRLG values that 
                                    this link is part of.";
                                leaf value {
                                     type uint32 {
                                          range "0..4294967295";
                                     }
                                }
                            }
                        }
                    }
                }
            }

            container rsvp {
                description "RSVP-TE configuration for the link.";

                uses rsvp-graceful-restart;
                uses rsvp-authentication;
                uses rsvp-signaling;
    
                container reservable-bandwidths {
                    description "Reservable bandwidth values.";
                    container link-rdm-bc {
                        uses  bandwidth-constraint-values;
                    }
                    container link-mam-bc {
                        uses  bandwidth-constraint-values;
                    }
                    container link-mar-bc {
                        uses  bandwidth-constraint-values;
                    }
                }
            }
        }
    }


    /* MPLS-TE Tunnel Operational Data */
    container tunnels-oper {
        config "false";
        /* mandatory "true"; */
        description "MPLS-TE tunnel operational state data.";
        list tunnel {
            key "name type";
            description "MPLS-TE tunnel.";
            leaf name {
                type string;
                description "MPLS-TE tunnel name.";
            }
            leaf type {
                description "MPLS-TE tunnel type.";
                type mtt:tunnel-type;
            }
        }
    }

    /* MPLS-TE Global Operational Data */
    container global-oper {
        config "false";
        description
            "Operational data model for Global MPLS-TE.";
    }

    /* MPLS-TE Links Operational Data */
    container links-oper {
        config "false";
        description
            "Operational data model for MPLS-TE links.";

        list link {
            key "name";
            description "MPLS-TE links.";
            leaf name {
                 type string;
                 description "MPLS-TE link name.";
            }
        }
    }
    
    /* MPLS-TE Tunnel RPCs/execution Data */
    rpc tunnels-rpc {
        description
            "Execution data for MPLS-TE tunnels.";
        input {
            leaf input-command {
                type string;
                default "";
                description "foo bar";
            }
        }
        output {
            leaf out-message {
                type string;
                default "";
                description "foo bar";
            }
        }
    }

    /* MPLS-TE Global RPCs/execution Data */
    rpc global-rpc {
        description
            "Execution data for MPLS-TE global.";
        input {
            leaf input-command {
                type string;
                default "";
                description "foo bar";
            }
        }
        output {
            leaf out-message {
                type string;
                default "";
                description "foo bar";
            }
        }
    }

    /* MPLS-TE links RPCs/execution Data */
    rpc links-rpc {
        description
            "Execution data for MPLS-TE links.";
        input {
            leaf input-command {
                type string;
                default "";
                description "foo bar";
            }
        }
        output {
            leaf out-message {
                type string;
                default "";
                description "foo bar";
            }
        }
    }


    /* MPLS-TE Tunnel Notification Data */
    notification tunnels-notif {
        description
            "Notification messages for MPLS-TE tunnels.";
        leaf name {
            type string;
            description "MPLS-TE tunnel name.";
            mandatory "true";
        }
        leaf type {
            type mtt:tunnel-type;
            mandatory "true";
        }
    }

    /* MPLS-TE Global Notification Data */
    notification global-notif {
        description
            "Notification messages for Global MPLS-TE.";
    }

    /* MPLS-TE Links Notification Data */
    notification links-notif {
        description
            "Notification messages for MPLS-TE links.";
        leaf name {
            type string;
            description "MPLS-TE link name.";
            mandatory "true";
        }
    }

}