ietf-pcep-stats@2019-03-24.yang

module ietf-pcep-stats {

  yang-version 1.1;

  namespace "urn:ietf:params:xml:ns:yang:ietf-pcep-stats";

  prefix ps;

  import ietf-pcep {
    prefix p;
    reference 
      "RFC XXXX: A YANG Data Model for Path Computation
      Element Communications Protocol (PCEP)";
  }

  import ietf-yang-types {
    prefix "yang";
    reference 
      "RFC 6991: Common YANG Data Types";
  }

  organization
    "IETF PCE (Path Computation Element) Working Group";

  contact
    "WG Web:  <http://tools.ietf.org/wg/pce/>
    WG List:  <mailto:pce@ietf.org>
    Editor:   Dhruv Dhody
              <mailto:dhruv.ietf@gmail.com>";

  description
    "The YANG module augments the PCEP yang operational
    model with statistics, counters and telemetry data.

    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
    (http://trustee.ietf.org/license-info).

    This version of this YANG module is part of RFC XXXX; see the
    RFC itself for full legal notices.";

  revision 2019-03-24 {
    description "Initial revision.";
    reference
      "RFC XXXX:  A YANG Data Model for Path Computation
      Element Communications Protocol (PCEP)";
  }

  /*
   * Groupings
   */

  grouping pcep-stats{
    description
      "This grouping defines statistics for PCEP. It is used
      for both peer and current session.";
    leaf avg-rsp-time{
      when "../../p:role = 'pce'" +
           "or " +
           "../../p:role = 'pcc-and-pce'"
      {
        description
          "Valid for PCEP Peer as PCE";
      }
      type uint32;
      units "milliseconds";

      description
        "The average response time. If an average response time 
        has not been calculated then this leaf has the value 
        zero.";
    }

    leaf lwm-rsp-time{
      when "../../p:role = 'pce'" +
           "or " +
           "../../p:role = 'pcc-and-pce'"
      {
        description
          "Valid for PCEP Peer as PCE";
      }
      type uint32;
      units "milliseconds";

      description
        "The smallest (low-water mark) response time seen.
        If no responses have been received then this leaf has 
        the value zero.";
    }

    leaf hwm-rsp-time{
      when "../../p:role = 'pce'" +
           "or " +
           "../../p:role = 'pcc-and-pce'"
      {
        description
          "Valid for PCEP Peer as PCE";
      }
      type uint32;
      units "milliseconds";

      description
        "The greatest (high-water mark) response time seen.
        If no responses have been received then this object
        has the value zero.";
    }

    leaf num-pcreq-sent{
        when "../../p:role = 'pce'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
           "Valid for PCEP Peer as PCE";
        }
        type yang:counter32;
        description
         "The number of PCReq messages sent.";
    }

    leaf num-pcreq-rcvd{
      when "../../p:role = 'pcc'" +
           "or " +
           "../../p:role = 'pcc-and-pce'"
      {
        description
          "Valid for PCEP Peer as PCC";
      }
      type yang:counter32;
      description
        "The number of PCReq messages received.";
    }

    leaf num-pcrep-sent{
      when "../../p:role = 'pcc'" +
           "or " +
           "../../p:role = 'pcc-and-pce'"
      {
        description
          "Valid for PCEP Peer as PCC";
      }

      type yang:counter32;
      description
        "The number of PCRep messages sent.";
      }

      leaf num-pcrep-rcvd{
        when "../../p:role = 'pce'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCE";
        }

        type yang:counter32;
        description
          "The number of PCRep messages received.";
      }

      leaf num-pcerr-sent{
        type yang:counter32;
        description
          "The number of PCErr messages sent.";
      }

      leaf num-pcerr-rcvd{
        type yang:counter32;
        description
          "The number of PCErr messages received.";
      }

      leaf num-pcntf-sent{
        type yang:counter32;
        description
          "The number of PCNtf messages sent.";
      }

      leaf num-pcntf-rcvd{
        type yang:counter32;
        description
          "The number of PCNtf messages received.";
      }

      leaf num-keepalive-sent{
        type yang:counter32;
        description
          "The number of Keepalive messages sent.";
      }

      leaf num-keepalive-rcvd{
        type yang:counter32;
        description
          "The number of Keepalive messages received.";
      }

      leaf num-unknown-rcvd{
        type yang:counter32;
        description
        "The number of unknown messages received.";
      }

      leaf num-corrupt-rcvd{
        type yang:counter32;
        description
          "The number of corrupted PCEP message received.";
      }

      leaf num-req-sent{
        when "../../p:role = 'pce'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCE";
        }
        type yang:counter32;
        description
          "The number of requests sent.  A request corresponds
          1:1 with an RP object in a PCReq message. This might
          be greater than num-pcreq-sent because multiple
          requests can be batched into a single PCReq
          message.";
      }

      leaf num-req-sent-pend-rep{
        when "../../p:role = 'pce'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCE";
        }
        type yang:counter32;
        description
          "The number of requests that have been sent for
          which a response is still pending.";
      }

      leaf num-req-sent-ero-rcvd{
        when "../../p:role = 'pce'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCE";
        }
        type yang:counter32;
        description
          "The number of requests that have been sent for
          which a response with an ERO object was received.
          Such responses indicate that a path was
          successfully computed by the peer.";
      }

      leaf num-req-sent-nopath-rcvd{
        when "../../p:role = 'pce'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCE";
        }
        type yang:counter32;
        description
          "The number of requests that have been sent for
          which a response with a NO-PATH object was
          received. Such responses indicate that the peer
          could not find a path to satisfy the
          request.";
      }

      leaf num-req-sent-cancel-rcvd{
        when "../../p:role = 'pce'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCE";
        }
        type yang:counter32;
        description
          "The number of requests that were cancelled with
          a PCNtf message. This might be different than 
          num-pcntf-rcvd because not all PCNtf messages are 
          used to cancel requests, and a single PCNtf message 
          can cancel multiple requests.";
      }

      leaf num-req-sent-error-rcvd{
        when "../../p:role = 'pce'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCE";
        }
        type yang:counter32;
        description
          "The number of requests that were rejected with a
          PCErr message. This might be different than 
          num-pcerr-rcvd because not all PCErr messages are 
          used to reject requests, and a single PCErr message 
          can reject multiple requests.";
      }

      leaf num-req-sent-timeout{
        when "../../p:role = 'pce'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCE";
        }
        type yang:counter32;
        description
          "The number of requests that have been sent to a peer
          and have been abandoned because the peer has taken too
          long to respond to them.";
      }

      leaf num-req-sent-cancel-sent{
        when "../../p:role = 'pce'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCE";
        }
        type yang:counter32;
        description
          "The number of requests that were sent to the peer and
          explicitly cancelled by the local PCEP entity sending
          a PCNtf.";
      }

      leaf num-req-rcvd{
        when "../../p:role = 'pcc'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCC";
        }
        type yang:counter32;
        description
          "The number of requests received.  A request
          corresponds 1:1 with an RP object in a PCReq
          message.
          This might be greater than num-pcreq-rcvd because
          multiple requests can be batched into a single
          PCReq message.";
      }

      leaf num-req-rcvd-pend-rep{
        when "../../p:role = 'pcc'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCC";
        }
        type yang:counter32;
        description
          "The number of requests that have been received for
          which a response is still pending.";
      }

      leaf num-req-rcvd-ero-sent{
        when "../../p:role = 'pcc'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCC";
        }
        type yang:counter32;
        description
          "The number of requests that have been received for
          which a response with an ERO object was sent.  Such
          responses indicate that a path was successfully
          computed by the local PCEP entity.";
      }

      leaf num-req-rcvd-nopath-sent{
        when "../../p:role = 'pcc'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCC";
        }
        type yang:counter32;
        description
          "The number of requests that have been received for
          which a response with a NO-PATH object was sent. Such
          responses indicate that the local PCEP entity could
          not find a path to satisfy the request.";
      }

      leaf num-req-rcvd-cancel-sent{
        when "../../p:role = 'pcc'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCC";
        }
        type yang:counter32;
        description
          "The number of requests received that were cancelled
          by the local PCEP entity sending a PCNtf message.
          This might be different than num-pcntf-sent because
          not all PCNtf messages are used to cancel requests,
          and a single PCNtf message can cancel multiple
          requests.";
      }

      leaf num-req-rcvd-error-sent{
        when "../../p:role = 'pcc'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCC";
        }
        type yang:counter32;
        description
          "The number of requests received that were cancelled
          by the local PCEP entity sending a PCErr message.
          This might be different than num-pcerr-sent because
          not all PCErr messages are used to cancel requests,
          and a single PCErr message can cancel multiple
          requests.";
      }

      leaf num-req-rcvd-cancel-rcvd{
        when "../../p:role = 'pcc'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCC";
        }
        type yang:counter32;
        description
          "The number of requests that were received from the
          peer and explicitly cancelled by the peer sending
          a PCNtf.";
      }
      leaf num-rep-rcvd-unknown{
        when "../../p:role = 'pce'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCE";
        }
        type yang:counter32;
        description
          "The number of responses to unknown requests
          received. A response to an unknown request is a
          response whose RP object does not contain the
          request ID of any request that is currently
          outstanding on the session.";
      }

      leaf num-req-rcvd-unknown{
        when "../../p:role = 'pcc'" +
             "or " +
             "../../p:role = 'pcc-and-pce'"
        {
          description
            "Valid for PCEP Peer as PCC";
        }
        type yang:counter32;
        description
          "The number of unknown requests that have been
          received. An unknown request is a request
          whose RP object contains a request ID of zero.";
      }

      container svec{
        if-feature p:svec;
        description
          "If synchronized path computation is supported";
        leaf num-svec-sent{
          when "../../../p:role = 'pce'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of SVEC objects sent in PCReq messages.
            An SVEC object represents a set of synchronized
            requests.";
        }
        leaf num-svec-req-sent{
          when "../../../p:role = 'pce'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of requests sent that appeared in one
            or more SVEC objects.";
        }

        leaf num-svec-rcvd{
          when "../../../p:role = 'pcc'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCC";
          }
          type yang:counter32;
          description
            "The number of SVEC objects received in PCReq
            messages. An SVEC object represents a set of
            synchronized requests.";
        }

        leaf num-svec-req-rcvd{
          when "../../../p:role = 'pcc'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCC";
          }
          type yang:counter32;
          description
            "The number of requests received that appeared
            in one or more SVEC objects.";
        }
      }//svec
      container stateful{
        if-feature p:stateful;
        description
          "Stateful PCE related statistics";
        leaf num-pcrpt-sent{
          when "../../../p:role = 'pce'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of PCRpt messages sent.";
        }

        leaf num-pcrpt-rcvd{
          when "../../../p:role = 'pcc'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCC";
          }
          type yang:counter32;
          description
            "The number of PCRpt messages received.";
        }

        leaf num-pcupd-sent{
          when "../../../p:role = 'pcc'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCC";
          }
          type yang:counter32;
          description
            "The number of PCUpd messages sent.";
        }

        leaf num-pcupd-rcvd{
          when "../../../p:role = 'pce'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of PCUpd messages received.";
        }

        leaf num-rpt-sent{
          when "../../../p:role = 'pce'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of LSP Reports sent.  A LSP report
            corresponds 1:1 with an LSP object in a PCRpt
            message. This might be greater than
            num-pcrpt-sent because multiple reports can
            be batched into a single PCRpt message.";
        }

        leaf num-rpt-rcvd{
          when "../../../p:role = 'pcc'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCC";
          }
          type yang:counter32;
          description
            "The number of LSP Reports received.  A LSP report
            corresponds 1:1 with an LSP object in a PCRpt
            message.
            This might be greater than num-pcrpt-rcvd because
            multiple reports can be batched into a single
            PCRpt message.";
        }

        leaf num-rpt-rcvd-error-sent{
          when "../../../p:role = 'pcc'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCC";
          }
          type yang:counter32;
          description
            "The number of reports of LSPs received that were
            responded by the local PCEP entity by sending a
            PCErr message.";
        }

        leaf num-upd-sent{
          when "../../../p:role = 'pcc'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCC";
          }
          type yang:counter32;
          description
            "The number of LSP updates sent.  A LSP update
            corresponds 1:1 with an LSP object in a PCUpd
            message. This might be greater than
            num-pcupd-sent because multiple updates can
            be batched into a single PCUpd message.";
        }

        leaf num-upd-rcvd{
          when "../../../p:role = 'pce'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of LSP Updates received.  A LSP update
            corresponds 1:1 with an LSP object in a PCUpd
            message.
            This might be greater than num-pcupd-rcvd because
            multiple updates can be batched into a single
            PCUpd message.";
        }

        leaf num-upd-rcvd-unknown{
          when "../../../p:role = 'pce'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of updates to unknown LSPs
            received. An update to an unknown LSP is a
            update whose LSP object does not contain the
            PLSP-ID of any LSP that is currently
            present.";
        }

        leaf num-upd-rcvd-undelegated{
          when "../../../p:role = 'pce'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of updates to not delegated LSPs
            received. An update to an undelegated LSP is a
            update whose LSP object does not contain the
            PLSP-ID of any LSP that is currently
            delegated to current PCEP session.";
        }

        leaf num-upd-rcvd-error-sent{
          when "../../../p:role = 'pce'" +
               "or " +
               "../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of updates to LSPs received that were
            responded by the local PCEP entity by sending a
            PCErr message.";
       }

      container initiation {
        if-feature p:pce-initiated;
        description
          "PCE-Initiated related statistics";
        leaf num-pcinitiate-sent{
          when "../../../../p:role = 'pcc'" +
               "or " +
               "../../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCC";
          }
          type yang:counter32;
          description
            "The number of PCInitiate messages sent.";
        }

        leaf num-pcinitiate-rcvd{
          when "../../../../p:role = 'pce'" +
               "or " +
               "../../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of PCInitiate messages received.";
        }

        leaf num-initiate-sent{
          when "../../../../p:role = 'pcc'" +
               "or " +
               "../../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCC";
          }
          type yang:counter32;
          description
            "The number of LSP Initiation sent via PCE.
            A LSP initiation corresponds 1:1 with an LSP
            object in a PCInitiate message. This might be
            greater than num-pcinitiate-sent because
            multiple initiations can be batched into a
            single PCInitiate message.";
        }

        leaf num-initiate-rcvd{
          when "../../../../p:role = 'pce'" +
               "or " +
               "../../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of LSP Initiation received from
            PCE.  A LSP initiation corresponds 1:1 with
            an LSP object in a PCInitiate message. This
            might be greater than num-pcinitiate-rcvd
            because multiple initiations can be batched
            into a single PCInitiate message.";
        }

        leaf num-initiate-rcvd-error-sent{
          when "../../../../p:role = 'pce'" +
               "or " +
               "../../../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of initiations of LSPs received
            that were responded by the local PCEP entity
            by sending a PCErr message.";
        }
      }//initiation
    }//stateful
    
    container path-key {
      when "../../p:role = 'pcc'" +
           "or " +
           "../../p:role = 'pcc-and-pce'"
      {
        description
          "Valid for PCEP Peer as PCC";
      }
      if-feature p:path-key;
      description
        "If Path-Key is supported";
      leaf num-unknown-path-key{
        type yang:counter32;
        description
          "The number of attempts to expand an unknown
          path-key.";
      }
      leaf num-exp-path-key{
        type yang:counter32;
        description
          "The number of attempts to expand an expired
          path-key.";
      }
      leaf num-dup-path-key{
        type yang:counter32;
        description
          "The number of duplicate attempts to expand same
          path-key.";
      }
      leaf num-path-key-no-attempt{
        type yang:counter32;
        description
          "The number of expired path-keys with no attempt to
          expand it.";
      }
    }//path-key 
  }//pcep-stats

  /*
   * Augment modules to add statistics
   */

  augment "/p:pcep/p:entity/p:peers/p:peer" {
    description
      "Augmenting the statistics";
    
      leaf num-sess-setup-ok{
        type yang:counter32;
        config false;
        description
          "The number of PCEP sessions successfully established with 
          the peer, including any current session.  This counter is 
          incremented each time a session with this peer is 
          successfully established.";
      }

      leaf num-sess-setup-fail{
          type yang:counter32;
          config false;
          description
             "The number of PCEP sessions with the peer
              that have been attempted but failed
              before being fully established. This
              counter is incremented each time a
              session retry to this peer fails.";
      }
        
      container pcep-stats {
        config false;
        description
          "The container for all statistics at peer level.";
        uses pcep-stats{
          description
          "Since PCEP sessions can be ephemeral, the peer statistics 
          tracks a peer even when no PCEP session currently exists 
          to that peer. The statistics contained are an aggregate of 
          the statistics for all successive sessions to that peer.";
        }

        leaf num-req-sent-closed{
          when "../../p:role = 'pce'" +
               "or " +
               "../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCE";
          }
          type yang:counter32;
          description
            "The number of requests that were sent to the peer and 
            implicitly cancelled when the session they were sent 
            over was closed.";
        }

        leaf num-req-rcvd-closed{
          when "../../p:role = 'pcc'" +
               "or " +
               "../../p:role = 'pcc-and-pce'"
          {
            description
              "Valid for PCEP Peer as PCC";
          }
          type yang:counter32;
          description
            "The number of requests that were received from the peer 
            and implicitly cancelled when the session they were 
            received over was closed.";
        }
      }//pcep-stats
  }//augment

  augment "/p:pcep/p:entity/p:peers/p:peer/" +
          "p:sessions/p:session" {
    description
      "Augmenting the statistics";
    
    container pcep-stats {
      description
        "The container for all statistics at session level.";
      uses pcep-stats{
      description
        "The statistics contained are for the current sessions to
        that peer. These are lost when the session goes down.";
      }
    }//pcep-stats
  }//augment
}//module