ietf-pcep-stats@2018-06-22.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;
    }

    import ietf-yang-types {
        prefix "yang";
        reference "RFC 6991";
    }

    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) 2018 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 2018-06-22 {
        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.";
            }
        }
        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.";
                }
            }
        }
        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.";
            }
        }
    }//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
                 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