ietf-rsvp.yang

module ietf-rsvp {
  yang-version 1.1;
  namespace "urn:ietf:params:xml:ns:yang:ietf-rsvp";

  /* Replace with IANA when assigned */

  prefix rsvp;

  import ietf-interfaces {
    prefix if;
    reference
      "RFC8343: A YANG Data Model for Interface Management";
  }
  import ietf-inet-types {
    prefix inet;
    reference
      "RFC6991: Common YANG Data Types";
  }
  import ietf-yang-types {
    prefix yang;
    reference
      "RFC6991: Common YANG Data Types";
  }
  import ietf-routing {
    prefix rt;
    reference
      "RFC8349: A YANG Data Model for Routing Management
       (NMDA Version)";
  }
  import ietf-key-chain {
    prefix key-chain;
    reference
      "RFC8177: YANG Data Model for Key Chains";
  }
  import ietf-netconf-acm {
    prefix nacm;
    reference
      "RFC8341: Network Configuration Access Control Model";
  }
  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>

     Editor:   Vishnu Pavan Beeram
               <mailto:vbeeram@juniper.net>

     Editor:   Tarek Saad
               <mailto:tsaad@juniper.net>

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

     Editor:   Xufeng Liu
               <mailto: xufeng.liu.ietf@gmail.com>

     Editor:   Igor Bryskin
               <mailto:i_bryskin@yahoo.com>";
  description
    "This module contains the RSVP YANG data model.
     The model fully conforms to the Network Management Datastore
     Architecture (NMDA).

     Copyright (c) 2019 IETF Trust and the persons
     identified as authors of the code.  All rights reserved.

     Redistribution and use in source and binary forms, with or
     without modification, is permitted pursuant to, and subject
     to the license terms contained in, the Simplified BSD License
     set forth in Section 4.c of the IETF Trust's Legal Provisions
     Relating to IETF Documents
     (https://trustee.ietf.org/license-info).
     This version of this YANG module is part of RFC XXXX; see
     the RFC itself for full legal notices.";

  // RFC Ed.: replace XXXX with actual RFC number and remove this
  // note.
  // RFC Ed.: update the date below with the date of RFC publication
  // and remove this note.

  revision 2023-10-06 {
    description
      "Initial version.";
    reference
      "RFCXXXX: A YANG Data Model for Resource Reservation Protocol
       (RSVP)";
  }

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

  identity rsvp-session-type {
    description
      "Base RSVP session type";
  }

  identity rsvp-session-ip {
    base rsvp-session-type;
    description
      "RSVP IP session type";
  }

  identity reservation-style {
    description
      "Base identity for reservation style.";
  }

  identity reservation-wildcard-filter {
    base reservation-style;
    description
      "Wildcard-Filter (WF) Style.";
    reference
      "RFC2205";
  }

  identity reservation-fixed-filter {
    base reservation-style;
    description
      "Fixed-Filter (FF) Style.";
    reference
      "RFC2205";
  }

  identity reservation-shared-explicit {
    base reservation-style;
    description
      "Shared Explicit (SE) Style.";
    reference
      "RFC2205";
  }

  grouping intf-attributes {
    description
      "Top level grouping for RSVP interface properties.";
    container refresh-reduction {
      description
        "Top level container for RSVP refresh reduction parameters.";
      leaf enabled {
        type boolean;
        default "true";
        description
          "'true' if RSVP Refresh Reduction is enabled.
           'false' if RSVP Refresh Reduction is disabled.";
      }
      reference
        "RFC2961 RSVP Refresh Overhead Reduction Extensions";
    }
    container hellos {
      description
        "Top level container for RSVP hello parameters.";
      leaf enabled {
        type boolean;
        default "true";
        description
          "'true' if RSVP Hello is enabled.
           'false' if RSVP Hello is disabled.";
      reference
        "RFC3209: RSVP-TE: Extensions to RSVP for LSP Tunnels.
         RFC5495: Description of the Resource Reservation Protocol -
         Traffic-Engineered (RSVP-TE) Graceful Restart Procedures.";
      }
    }
    container authentication {
      description
        "Top level container for RSVP authentication parameters.";
      leaf enabled {
        type boolean;
        default "false";
        description
          "'true' if RSVP Authentication is enabled.
           'false' if RSVP Authentication is disabled.";
      }
      leaf authentication-key {
        type string;
        description
          "An authentication key string.";
        reference
          "RFC2747: RSVP Cryptographic Authentication";
      }
      leaf crypto-algorithm {
        type identityref {
          base key-chain:crypto-algorithm;
        }
        description
          "Cryptographic algorithm associated with key.";
      }
    }
    container statistics {
      config false;
      description
        "RSVP statistics container.";
      container messages {
        description
          "RSVP protocol statistics container.";
        leaf ack-sent {
          type yang:counter64;
          description
            "RSVP Hello sent count.";
        }
        leaf ack-received {
          type yang:counter64;
          description
            "RSVP Hello received count.";
        }
        leaf bundle-sent {
          type yang:counter64;
          description
            "RSVP Bundle message sent count.";
        }
        leaf bundle-received {
          type yang:counter64;
          description
            "RSVP Bundle message received count.";
        }
        leaf hello-sent {
          type yang:counter64;
          description
            "RSVP Hello message sent count.";
        }
        leaf hello-received {
          type yang:counter64;
          description
            "RSVP Hello message received count.";
        }
        leaf integrity-challenge-sent {
          type yang:counter64;
          description
            "RSVP Integrity Challenge message sent count.";
        }
        leaf integrity-challenge-received {
          type yang:counter64;
          description
            "RSVP Integrity Challenge message received count.";
        }
        leaf integrity-response-sent {
          type yang:counter64;
          description
            "RSVP Integrity Response message sent count.";
        }
        leaf integrity-response-received {
          type yang:counter64;
          description
            "RSVP Integrity Response message received count.";
        }
        leaf notify-sent {
          type yang:counter64;
          description
            "RSVP Notify message sent count.";
        }
        leaf notify-received {
          type yang:counter64;
          description
            "RSVP Notify message received count.";
        }
        leaf path-sent {
          type yang:counter64;
          description
            "RSVP Path message sent count.";
        }
        leaf path-received {
          type yang:counter64;
          description
            "RSVP Path message received count.";
        }
        leaf path-err-sent {
          type yang:counter64;
          description
            "RSVP Path error message sent count.";
        }
        leaf path-err-received {
          type yang:counter64;
          description
            "RSVP Path error message received count.";
        }
        leaf path-tear-sent {
          type yang:counter64;
          description
            "RSVP Path tear message sent count.";
        }
        leaf path-tear-received {
          type yang:counter64;
          description
            "RSVP Path tear message received count.";
        }
        leaf resv-sent {
          type yang:counter64;
          description
            "RSVP Resv message sent count.";
        }
        leaf resv-received {
          type yang:counter64;
          description
            "RSVP Resv message received count.";
        }
        leaf resv-confirm-sent {
          type yang:counter64;
          description
            "RSVP Confirm message sent count.";
        }
        leaf resv-confirm-received {
          type yang:counter64;
          description
            "RSVP Confirm message received count.";
        }
        leaf resv-err-sent {
          type yang:counter64;
          description
            "RSVP Resv error message sent count.";
        }
        leaf resv-err-received {
          type yang:counter64;
          description
            "RSVP Resv error message received count.";
        }
        leaf resv-tear-sent {
          type yang:counter64;
          description
            "RSVP Resv tear message sent count.";
        }
        leaf resv-tear-received {
          type yang:counter64;
          description
            "RSVP Resv tear message received count.";
        }
        leaf srefresh-sent {
          type yang:counter64;
          description
            "RSVP Srefresh message sent count.";
        }
        leaf srefresh-received {
          type yang:counter64;
          description
            "RSVP Srefresh message received count.";
        }
        leaf unknown-messages-received {
          type yang:counter64;
          description
            "Unknown messages received count.";
        }
      }
      container packets {
        description
          "Packet statistics container.";
        leaf sent {
          type yang:counter64;
          description
            "RSVP packet sent count.";
        }
        leaf received {
          type yang:counter64;
          description
            "RSVP packet received count.";
        }
      }
      container errors {
        description
          "Error statistics container.";
        leaf authenticate {
          type yang:counter64;
          description
            "The total number of RSVP packets received with an
             authentication failure.";
        }
        leaf checksum {
          type yang:counter64;
          description
            "The total number of RSVP packets received with an invalid
             checksum value.";
        }
        leaf packet-length {
          type yang:counter64;
          description
            "The total number of packets received with an invalid
             packet length.";
        }
      }
    }
  }

  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 interfaces {
        description
          "RSVP interfaces container.";
        uses intf-attributes;
        list interface {
          key "name";
          description
            "RSVP interfaces.";
          leaf name {
            type if:interface-ref;
            description
              "RSVP interface.";
          }
          uses intf-attributes;
        }
      }
      container sessions {
        description
          "RSVP sessions container.";
        list session-ip {
          key "destination protocol-id destination-port";
          config false;
          description
            "List of RSVP sessions.";
          leaf destination-port {
            type uint16;
            description
              "RSVP destination port.";
            reference
              "RFC2205";
          }
          leaf protocol-id {
            type uint8;
            description
              "The IP protocol ID.";
            reference
              "RFC2205, section 3.2";
          }
          leaf source {
            type inet:ip-address;
            description
              "RSVP source address.";
            reference
              "RFC2205";
          }
          leaf destination {
            type inet:ip-address;
            description
              "RSVP destination address.";
            reference
              "RFC2205";
          }
          leaf session-name {
            type string;
            description
              "The signaled name of this RSVP session.";
          }
          leaf session-status {
            type enumeration {
              enum up {
                description
                  "RSVP session is up.";
              }
              enum down {
                description
                  "RSVP session is down.";
              }
            }
            description
              "Enumeration of RSVP session states.";
          }
          leaf session-type {
            type identityref {
              base rsvp-session-type;
            }
            mandatory "true";
            description
              "RSVP session type.";
          }
          container psbs {
            description
              "Path State Block (PSB) container.";
            list psb {
              description
                "List of Path State Blocks.";
              leaf source-port {
                type inet:port-number;
                description
                  "RSVP source port.";
                reference
                  "RFC2205";
              }
              leaf expires-in {
                type uint32;
                units "seconds";
                description
                  "Time to expiry (in seconds).";
              }
            }
          }
          container rsbs {
            description
              "Reservation State Block (RSB) container.";
            list rsb {
              description
                "List of Reservation State Blocks.";
              leaf source-port {
                type inet:port-number;
                description
                  "RSVP source port.";
                reference
                  "RFC2205";
              }
              leaf reservation-style {
                type identityref {
                  base reservation-style;
                }
                description
                  "RSVP reservation style.";
              }
              leaf expires-in {
                type uint32;
                units "seconds";
                description
                  "Time to expiry (in seconds).";
              }
            }
          }
        }
      }
      container neighbors {
        description
          "RSVP neighbors container";
        list neighbor {
          key "address";
          description
            "List of RSVP neighbors";
          leaf address {
            type inet:ip-address;
            description
              "Address of the RSVP neighbor.";
          }
          leaf epoch {
            type uint32;
            description
              "Neighbor epoch.";
            reference "RFC2961 and RFC5063";
          }
          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 neighbor-restart-time {
              type uint32;
              units "seconds";
              config false;
              description
                "Time it takes the neighbor node to restart its RSVP-TE
                 component (to the point where it can exchange RSVP
                 Hello with its neighbors). A value of 0xffffffff
                 indicates that the restart of the neighbor's control plane
                 may occur over an indeterminate interval and that the
                 operation of its data plane is unaffected by control plane
                 failures.";
              reference "RFC3473";
            }
            leaf neighbor-recovery-time {
              type uint32;
              units "seconds";
              config false;
              description
                "The period of time, in milliseconds, that the neighbor
                 node requires to re-synchronize RSVP and MPLS
                 forwarding state with its neighbor. A value of zero (0)
                 indicates that MPLS forwarding state was not preserved
                 across a particular reboot.";
              reference "RFC3473";
            }
            container helper-mode {
              config false;
              description
                "Helper mode information.";
              leaf neighbor-restart-time-remaining {
                type uint32;
                units "seconds";
                description
                  "Number of seconds remaining for neighbor to send Hello
                   message after restart.";
                reference "RFC5063";
              }
              leaf neighbor-recovery-time-remaining {
                type uint32;
                units "seconds";
                description
                  "Number of seconds remaining for neighbor to refresh.";
                reference "RFC5063";
              }
            }
            // helper-mode
          }
          leaf hello-status {
            type enumeration {
              enum enabled {
                description
                  "RSVP Hellos enabled.";
              }
              enum disabled {
                description
                  "RSVP Hellos disabled.";
              }
              enum restarting {
                description
                  "RSVP restarting.";
              }
            }
            config false;
            description
              "RSVP Hello status.";
          }
          leaf interface {
            type if:interface-ref;
            description
              "Interface where RSVP neighbor was detected.";
          }
          leaf neighbor-status {
            type enumeration {
              enum up {
                description
                  "Neighbor state up.";
              }
              enum down {
                description
                  "Neighbor state down.";
              }
              enum hello-disable {
                description
                  "RSVP Hellos disabled.";
              }
              enum restarting {
                description
                  "RSVP neighbor restarting.";
              }
            }
            config false;
            description
              "RSVP neighbor state.";
          }
          leaf refresh-reduction-capable {
            type boolean;
            default "true";
            description
              "Enables all RSVP refresh reduction message bundling, RSVP
               message ID, reliable message delivery and Srefresh
               messages.";
            reference
              "RFC2961 RSVP Refresh Overhead Reduction Extensions";
          }
          leaf restart-count {
            type yang:counter32;
            config false;
            description
              "Number of times this RSVP neighbor has restarted.";
          }
          leaf restart-time {
            type yang:date-and-time;
            config false;
            description
              "Last restart time of the RSVP neighbor.";
            reference "RFC3473";
          }
        }
      }
      container graceful-restart {
        description
          "Graceful restart local information.";
        leaf enabled {
          type boolean;
          description
            "'true' if RSVP Graceful Restart is enabled.
             'false' if RSVP Graceful Restart is disabled.";
          reference "RFC5495";
        }
        leaf local-restart-time {
          type uint32;
          units "seconds";
          description
            "Time it takes the local node to restart its RSVP-TE
             component (to the point where it can exchange RSVP
             Hello with its neighbors). A value of 0xffffffff
             indicates that the restart of the neighbor's control plane
             may occur over an indeterminate interval and that the
             operation of its data plane is unaffected by control plane
             failures.";
          reference "RFC3473";
        }
        leaf local-recovery-time {
          type uint32;
          units "seconds";
          description
            "The period of time, in seconds, that the local
             node requires to re-synchronize RSVP and MPLS
             forwarding state with its neighbor. A value of zero (0)
             indicates that MPLS forwarding state was not preserved
             across a particular reboot.";
          reference "RFC3473";
        }
        container helper-mode {
          description
            "Helper mode information. In this mode, the node
             resynchronizes its stored states with a neighbor whose
             control plane has restarted. The helper mode term is
             borrowed from RFC3623 and adopted by several vendors
             vendors in their implementation of RSVP graceful restart.";
          leaf enabled {
            type boolean;
            description
              "'true' if helper mode is enabled.";
          }
          leaf max-helper-restart-time {
            type uint32;
            units "seconds";
            default "20";
            description
              "The maximum time the router or switch waits after it
               discovers that the neighboring router has gone down
               before it declares the neighbor down.";
            reference "RFC5063";
          }
          leaf max-helper-recovery-time {
            type uint32;
            units "seconds";
            default "180";
            description
              "The maximum amount of time the router retains the state
               of its RSVP neighbors while they undergo a graceful
               restart.";
            reference "RFC5063";
          }
        }
      }
    }
  }

  grouping session-ref {
    description
      "Session reference information";
    leaf destination {
      type leafref {
        path "/rt:routing/rt:control-plane-protocols"
           + "/rt:control-plane-protocol/rsvp:rsvp"
           + "/rsvp:sessions/rsvp:session-ip/destination";
      }
      mandatory true;
      description
        "The RSVP session destination.";
    }
    leaf protocol-id {
      type uint8;
      mandatory true;
      description
        "The RSVP session protocol ID.";
    }
    leaf destination-port {
      type inet:ip-address;
      mandatory true;
      description
        "The RSVP session destination port.";
    }
  }

  rpc clear-session {
    nacm:default-deny-all;
    description
      "Clears RSVP sessions RPC";
    input {
      leaf routing-protocol-instance-name {
        type leafref {
          path "/rt:routing/rt:control-plane-protocols/"
             + "rt:control-plane-protocol/rt:name";
        }
        mandatory true;
        description
          "Name of the RSVP protocol instance whose session
           is being cleared.

           If the corresponding RSVP instance doesn't exist,
           then the operation will fail with an error-tag of
           'data-missing' and an error-app-tag of
           'routing-protocol-instance-not-found'.";
      }
      choice filter-type {
        mandatory true;
        description
          "Filter choice";
        case match-all {
          leaf all {
            type empty;
            mandatory true;
            description
              "Match all RSVP sessions.";
          }
        }
        case match-one {
          container session-info {
            description
              "Specifies the specific session to invoke the operation
               on.";
            choice session-type {
              mandatory true;
              description
                "The RSVP session type.";
              case rsvp-session-ip {
                uses session-ref;
              }
            }
          }
        }
      }
    }
  }

  rpc clear-neighbor {
    nacm:default-deny-all;
    description
      "RPC to clear the RSVP Hello session to a neighbor.";
    input {
      leaf routing-protocol-instance-name {
        type leafref {
          path "/rt:routing/rt:control-plane-protocols/"
             + "rt:control-plane-protocol/rt:name";
        }
        mandatory true;
        description
          "Name of the RSVP protocol instance whose session
           is being cleared.

           If the corresponding RSVP instance doesn't exist,
           then the operation will fail with an error-tag of
           'data-missing' and an error-app-tag of
           'routing-protocol-instance-not-found'.";
      }
      choice filter-type {
        mandatory true;
        description
          "The Filter choice.";
        case match-all {
          leaf all {
            type empty;
            mandatory true;
            description
              "Match all RSVP neighbor sessions.";
          }
        }
        case match-one {
          leaf neighbor-address {
            type leafref {
              path "/rt:routing/rt:control-plane-protocols"
                 + "/rt:control-plane-protocol/rsvp:rsvp"
                 + "/rsvp:neighbors/rsvp:neighbor/address";
            }
            mandatory true;
            description
              "Match the specific RSVP neighbor session.";
          }
        }
      }
    }
  }

  rpc clear-authentication {
    nacm:default-deny-all;
    description
      "Clears the RSVP Security Association (SA) before the
       lifetime expires.";
    input {
      leaf routing-protocol-instance-name {
        type leafref {
          path "/rt:routing/rt:control-plane-protocols/"
             + "rt:control-plane-protocol/rt:name";
        }
        mandatory true;
        description
          "Name of the RSVP protocol instance whose session
           is being cleared.

           If the corresponding RSVP instance doesn't exist,
           then the operation will fail with an error-tag of
           'data-missing' and an error-app-tag of
           'routing-protocol-instance-not-found'.";
      }
      choice filter-type {
        mandatory true;
        description
          "Filter choice";
        case match-all {
          leaf all {
            type empty;
            mandatory true;
            description
              "Match all RSVP security associations.";
          }
        }
        case match-one-interface {
          leaf interface {
            type if:interface-ref;
            description
              "Interface where RSVP security association(s) to be
               detected.";
          }
        }
      }
    }
  }
}