ietf-rsvp.yang

module ietf-rsvp {

  namespace "urn:ietf:params:xml:ns:yang:ietf-rsvp";

  /* Replace with IANA when assigned */
  prefix "rsvp";

  import ietf-interfaces {
    prefix "if";
  }

  import ietf-inet-types {
    prefix inet;
  }

  import ietf-yang-types {
    prefix "yang";
  }

  import ietf-routing {
    prefix "rt";
  }

  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:   Vishnu Pavan Beeram
               <mailto:vbeeram@juniper.net>

     Editor:   Tarek Saad
               <mailto:tsaad@cisco.com>

     Editor:   Rakesh Gandhi
               <mailto:rgandhi@cisco.com>

     Editor:   Himanshu Shah
               <mailto:hshah@ciena.com>

     Editor:   Xufeng Liu
               <mailto:xufeng.liu@ericsson.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
    "This module contains the RSVP YANG data model.";

  revision "2016-10-02" {
    description "Latest revision of RSVP yang module.";
    reference "RFC2205";
  }

  identity rsvp {
    base "rt:routing-protocol";
    description "RSVP protocol";
  }

  identity hash-algorithm {
    description
      "Base identity for message-digest algorithm";
  }

  identity MD5 {
    base hash-algorithm;
    description
      "MD5 hash algorithm";
    reference "RFC1321";
  }


  identity SHA-1 {
    base hash-algorithm;
    description
      "SHA-1 hash algorithm";
    reference "NIST, FIPS PUB 180-1: Secure Hash Standard";
  }

  grouping graceful-restart_config {
    description
      "Base configuration parameters relating to RSVP
       Graceful-Restart";
    leaf enabled {
      type boolean;
      description 
        "'true' if RSVP Graceful Restart is enabled.
         'false' if RSVP Graceful Restart is disabled.";
    }
  }

  grouping graceful-restart {
    description
      "Top level grouping for RSVP graceful-restart
      parameters";
    container graceful-restart {
      description
        "Top level container for RSVP graceful-restart";
      uses graceful-restart_config;
    }
  }

  grouping refresh-reduction_config {
    description
      "Configuration parameters relating to RSVP
       refresh reduction";

    leaf enabled {
      type boolean;
      description 
        "'true' if RSVP Refresh Reduction is enabled.
         'false' if RSVP Refresh Reduction is disabled.";
    }
  }

  grouping refresh-reduction {
    description
      "Top level grouping for RSVP refresh reduction
       parameters";
    container refresh-reduction {
      description
        "Top level container for RSVP refresh reduction
         parameters";
      uses refresh-reduction_config;
    }
  }

  grouping authentication_config {
    description
      "Configuration parameters relating to RSVP
       authentication";
    leaf enabled {
      type boolean;
      description 
        "'true' if RSVP Authenticaiton is enabled.
         'false' if RSVP Authenticaiton is disabled.";
    }
    leaf password {
      type string;
      description
        "An authentication key string";
    }
    leaf algorithm {
      type identityref {
        base hash-algorithm;
      }
      description
        "Cryptographic hash algorithm";
    }
  }

  grouping authentication {
    description
      "Top level grouping for RSVP authentication parameters";
    container authentication {
      description
        "Top level container for RSVP authentication
         parameters";
      uses authentication_config;
    }
  }

  grouping rsvp-hellos_config {
    description
      "Configuration parameters relating to RSVP
      hellos";
    leaf enabled {
      type boolean;
      description 
        "'true' if RSVP Hello is enabled.
         'false' if RSVP Hello is disabled.";
    }
  }

  grouping rsvp-hellos {
    description
      "Top level grouping for RSVP hellos parameters";
    container rsvp-hellos {
      description
        "Top level container for RSVP hello parameters";
      uses rsvp-hellos_config;
    }
  }

  grouping signaling-parameters_config {
    description
      "Configuration parameters relating to RSVP
      signaling";
  }

  grouping signaling-parameters {
    description
      "Top level grouping for RSVP signaling  parameters";
    uses signaling-parameters_config;
  }

  grouping session-attributes {
    description
      "Top level grouping for RSVP session properties";
    container config {
      description
        "Configuration for session properties";
    }
    container state {
      config false;
      description
        "State information associated with RSVP
         session properties";
    }
  }

  grouping neighbor-attributes {
    description
      "Top level grouping for RSVP neighbor properties";
    container neighbor-attributes {
      description
        "Top level container for RSVP neighbor properties";
      container config {
        description
          "Configuration for neighbor properties";
      }
      container state {
        config false;
        description
          "State information associated with RSVP
           neighbor properties";
        uses neighbor-derived_state;
      }
    }
  }

  grouping statistics-packets_state {
    description
      "Packet statistics grouping";
    container packets-stats {
      description
        "Packet statistics container";
      leaf sent {
        type yang:counter32;
        description
          "Packet sent count";
      }

      leaf rcvd {
        type yang:counter32;
        description
          "Packet received count";
      }
    }
  }

  grouping statistics-protocol_state {
    description 
      "RSVP protocol statistics grouping";
    container protocol-stats {
      description 
        "RSVP protocol statistics container";
      leaf ack-sent {
        type yang:counter32;
        description
          "Hello sent count";
      }

      leaf ack-rcvd {
        type yang:counter32;
        description
          "Hello received count";
      }

      leaf bundle-sent {
        type yang:counter32;
        description
          "Bundle sent count";
      }

      leaf bundle-rcvd {
        type yang:counter32;
        description
          "Bundle received count";
      }

      leaf hello-sent {
        type yang:counter32;
        description
          "Hello sent count";
      }

      leaf hello-rcvd {
        type yang:counter32;
        description
          "Hello received count";
      }

      leaf integrity-challenge-sent {
        type yang:counter32;
        description
          "Integrity Challenge sent count";
      }

      leaf integrity-challenge-rcvd {
        type yang:counter32;
        description
          "Integrity Challenge received count";
      }

      leaf integrity-response-sent {
        type yang:counter32;
        description
          "Integrity Response sent count";
      }

      leaf integrity-response-rcvd {
        type yang:counter32;
        description
          "Integrity Response received count";
      }

      leaf notify-sent {
        type yang:counter32;
        description
          "Notify sent count";
      }

      leaf notify-rcvd {
        type yang:counter32;
        description
          "Notify received count";
      }

      leaf path-sent {
        type yang:counter32;
        description
          "Path sent count";
      }

      leaf path-rcvd {
        type yang:counter32;
        description
          "Path received count";
      }

      leaf path-err-sent {
        type yang:counter32;
        description
          "Path error sent count";
      }

      leaf path-err-rcvd {
        type yang:counter32;
        description
          "Path error received count";
      }

      leaf path-tear-sent {
        type yang:counter32;
        description
          "Path tear sent count";
      }

      leaf path-tear-rcvd {
        type yang:counter32;
        description
          "Path tear received count";
      }

      leaf resv-sent {
        type yang:counter32;
        description
          "Resv sent count";
      }

      leaf resv-rcvd {
        type yang:counter32;
        description
          "Resv received count";
      }

      leaf resv-confirm-sent {
        type yang:counter32;
        description
          "Confirm sent count";
      }

      leaf resv-confirm-rcvd {
        type yang:counter32;
        description
          "Confirm received count";
      }

      leaf resv-err-sent {
        type yang:counter32;
        description
          "Resv error sent count";
      }

      leaf resv-err-rcvd {
        type yang:counter32;
        description
          "Resv error received count";
      }

      leaf resv-tear-sent {
        type yang:counter32;
        description
          "Resv tear sent count";
      }

      leaf resv-tear-rcvd {
        type yang:counter32;
        description
          "Resv tear received count";
      }

      leaf summary-refresh-sent {
        type yang:counter32;
        description
          "Summary refresh sent count";
      }

      leaf summary-refresh-rcvd {
        type yang:counter32;
        description
          "Summary refresh received count";
      }

      leaf unknown-recv {
        type yang:counter32;
        description
          "Unknown packet received count";
      }
    }
  }

  grouping statistics-errors_state {
    description
      "Error statistics state grouping";
    container errors-stats {
      description
        "Error statistics state container";
      leaf authenticate {
        type yang:counter64;
        description
          "The total number of packets received with an 
          authentication failure.";
      }

      leaf checksum {
        type yang:counter64;
        description
          "The total number of packets received with an invalid
          checksum value.";
      }

      leaf packet-len {
        type yang:counter64;
        description
          "The total number of packets received with an invalid
          packet length.";
      }
    }
  } // statistics_state

  grouping statistics_state {
    description "RSVP statistic attributes.";
    uses statistics-packets_state;
    uses statistics-protocol_state;
    uses statistics-errors_state;
  }

  grouping neighbor-derived_state {
    description
      "Derived state at neighbor level.";

    leaf epoch {
      type uint32;
      description
        "Neighbor epoch.";
    }

    leaf expiry-time {
      type uint32;
      units seconds;
      description
        "Neighbor expiry time after which the neighbor state
        is purged if no states associated with it";
    }

    container graceful-restart {
      description 
        "Graceful restart information.";
      
      leaf enabled {
        type boolean;
        description 
          "'true' if graceful restart is enabled for the 
          neighbor.";
      }

      leaf local-restart-time {
        type uint32;
        units seconds;
        description
          "Local node restart time";
      }

      leaf local-recovery-time {
        type uint32;
        units seconds;
        description
          "Local node recover time";
      }

      leaf nbr-restart-time {
        type uint32;
        units seconds;
        description
          "Neighbor restart time";
      }

      leaf nbr-recovery-time {
        type uint32;
        units seconds;
        description
          "Neighbor recover time";
      }

      container helper-mode {
        description 
          "Helper mode information ";

        leaf helper-mode {
          type boolean;
          description
            "'true' if helper mode is enabled.";
        }

        leaf max-helper-restart-time {
          type uint32;
          units seconds;
          description
            "The time the router or switch waits after it
             discovers that a neighboring router has gone down
             before it declares the neighbor down";
        }

        leaf max-helper-recovery-time {
          type uint32;
          units seconds;
          description
            "The amount of time the router retains the state of its
             RSVP neighbors while they undergo a graceful restart";
        }

        leaf nbr-restart-ttd {              
          type uint32;
          units seconds;
          description
            "Number of seconds remaining for neighbor to send
             Hello message after restart.";
        }

        leaf nbr-recovery-ttd {
          type uint32;
          units seconds;
          description
            "Number of seconds remaining for neighbor to 
            refresh.";
        }
      } // helper-mode
    } // graceful-restart

    leaf hello-status {
      type enumeration {
        enum "enabled" {
          description
            "Enabled";
        }
        enum "disabled" {
          description
            "Disabled";
        }
        enum "restarting" {
          description
            "Restarting";
        }           
      }
      description
        "Hello status";
    }

    leaf interface {
      type if:interface-ref;
      description
        "Interface to this neighbor.";
    }

    leaf neighbor-state {
      type enumeration {
        enum "up" {
          description
            "up";
        }
        enum "down" {
          description
            "down";
        }
        enum "hello-disable" {
          description
            "hello-disable";
        }
        enum "restarting" {
          description
            "restarting";
        }            
      }
      description
        "Neighbor state";
    }

    leaf psb-count {
      type uint32;
      description
        "Number of PSB state currently referencing the 
        neighbor.";
    }

    leaf rsb-count {
      type uint32;
      description
        "Number of RSB state currently referencing the 
        neighbor.";
    }

    leaf refresh-reduction-capable {
      type boolean;
      description
        "Whether neighbor is refresh reduction capable.";
    }

    leaf restart-count {
      type uint32;
      description
        "Number of times this neighbor restart";
    }

    leaf restart-time {
      type yang:date-and-time;
      description
        "Last restart time of the neighbor";
    }
  } // neighbor-derived_state

  grouping global-attributes {
    description
      "Top level grouping for RSVP global properties";
    container config {
      description
        "Configuration globals properties";
      uses graceful-restart;
    }
    container state {
      config false;
      description
        "State information associated with RSVP
         global properties";
      uses graceful-restart;
      uses statistics_state;
    }
  }

  grouping intf-attributes {
    description
      "Top level grouping for RSVP interface properties";
    container config {
      description
        "Configuration parameters relating to
        RSVP interface parameters";
      uses signaling-parameters;
      uses refresh-reduction;
      uses rsvp-hellos;
      uses authentication;
    }
    container state {
      config false;
      description
        "State information associated with RSVP
         interface parameters";
      uses signaling-parameters;
      uses refresh-reduction;
      uses rsvp-hellos;
      uses authentication;
      uses statistics_state;
    }
  }

  augment "/rt:routing/rt:control-plane-protocols/"
    + "rt:control-plane-protocol" {
    when "rt:type = 'rsvp:rsvp'" {
    description
     "This augment is only valid when routing protocol
      instance type is RSVP.";
    }
    description
      "RSVP protocol augmentation";
    container rsvp {
      presence "Enable RSVP feature";
      description "RSVP feature container";
      container globals {
        description "RSVP global properties.";
        uses global-attributes;
      }

      container interfaces {
        description
          "RSVP interfaces container";
        uses intf-attributes;

        list interface {
          key "interface";
          description
            "RSVP interfaces.";
          leaf interface {
            type if:interface-ref;
            description
              "RSVP interface.";
          }
          uses intf-attributes;
        }
      }

      container sessions {
        description
          "RSVP sessions container";
        list session {
          key "dst_port source destination";
          description
            "List of RSVP sessions";
          leaf dst_port {
            type uint16;
            description "RSVP destination port";
            reference "RFC2205";
          }
          leaf source {
            type inet:ip-address;
            description "RSVP source address";
            reference "RFC2205";
          }
          leaf destination {
            type inet:ip-address;
            description "RSVP destination address";
            reference "RFC2205";
          }
          uses session-attributes;
        }
      }

      container neighbors {
        description
          "RSVP neighbors container";
        list neighbor {
          key "address";
          description
            "List of RSVP neighbors";
          leaf address {
            type inet:ip-address;
            description
              "Neighbor address";
          }
          uses neighbor-attributes;
        }
      }
    }
  }
}