netconfcentral logo

ietf-stamp@2019-10-20



  module ietf-stamp {

    yang-version 1.1;

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

    prefix ietf-stamp;

    import ietf-inet-types {
      prefix inet;
      reference
        "RFC 6991: Common YANG Types.";


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


    }
    import ietf-key-chain {
      prefix kc;
      reference
        "RFC 8177: YANG Data Model for Key Chains.";


    }

    organization
      "IETF IPPM (IP Performance Metrics) Working Group";

    contact
      "WG Web: http://tools.ietf.org/wg/ippm/
     WG List: ippm@ietf.org

     Editor: Greg Mirsky
          gregimirsky@gmail.com
     Editor: Xiao Min
          xiao.min2@zte.com.cn
     Editor: Wei S Luo
          wei.s.luo@ericsson.com";

    description
      "This YANG module specifies a vendor-independent model
     for the Simple Two-way Active Measurement Protocol (STAMP).

     The data model covers two STAMP logical entities -
     Session-Sender and Session-Reflector; characteristics
     of the STAMP test session, as well as measured and
     calculated performance metrics.

        Copyright (c) 2019 IETF Trust and the persons identified as
        the document authors.  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-10-20" {
      description
        "Initial Revision. Base STAMP specification is covered";
      reference
        "RFC XXXX: STAMP YANG Data Model.";

    }


    typedef session-reflector-mode {
      type enumeration {
        enum "stateful" {
          value 0;
          description
            "When the Session-Reflector is stateful,
        i.e. is aware of STAMP-Test session state.";
        }
        enum "stateless" {
          value 1;
          description
            "When the Session-Reflector is stateless,
          i.e. is not aware of the state of
          STAMP-Test session.";
        }
      }
      description
        "State of the Session-Reflector";
    }

    typedef session-dscp-mode {
      type enumeration {
        enum "copy-received-value" {
          value 0;
          description
            "Use DSCP value copied from received
        STAMP test packet of the test session.";
        }
        enum "use-configured-value" {
          value 1;
          description
            "Use DSCP value configured for this
        test session on the Session-Reflector.";
        }
      }
      description
        "DSCP handling mode by Session-Reflector.";
    }

    typedef timestamp-format {
      type enumeration {
        enum "ntp-format" {
          value 0;
          description
            "NTP 64 bit format of a timestamp";
        }
        enum "ptp-format" {
          value 1;
          description
            "PTPv2 truncated format of a timestamp";
        }
      }
      description
        "Timestamp format used by Session-Sender
    or Session-Reflector.";
    }

    typedef percentage {
      type decimal64 {
        fraction-digits 5;
      }
      description "Percentage";
    }

    typedef percentile {
      type decimal64 {
        fraction-digits 5;
      }
      description
        "Percentile is a measure used in statistics
    indicating the value below which a given
    percentage of observations in a group of
    observations fall.";
    }

    feature session-sender {
      description
        "This feature relates to the device functions as the
    STAMP Session-Sender";
    }

    feature session-reflector {
      description
        "This feature relates to the device functions as the
    STAMP Session-Reflector";
    }

    feature stamp-security {
      description "Secure STAMP supported";
    }

    grouping maintenance-statistics {
      description
        "Maintenance statistics grouping";
      leaf sent-packets {
        type uint32;
        description "Packets sent";
      }

      leaf rcv-packets {
        type uint32;
        description "Packets received";
      }

      leaf sent-packets-error {
        type uint32;
        description "Packets sent error";
      }

      leaf rcv-packets-error {
        type uint32;
        description "Packets received error";
      }

      leaf last-sent-seq {
        type uint32;
        description
          "Last sent sequence number";
      }

      leaf last-rcv-seq {
        type uint32;
        description
          "Last received sequence number";
      }
    }  // grouping maintenance-statistics

    grouping test-session-statistics {
      description
        "Performance metrics calculated for
    a STAMP test session.";
      leaf packet-padding-size {
        type uint32;
        description
          "Size of the Packet Padding. Suggested to run
      Path MTU Discovery to avoid packet fragmentation
      in IPv4 and packet blackholing in IPv6";
      }

      leaf interval {
        type uint32;
        units "microseconds";
        description
          "Time interval between transmission of two
      consecutive packets in the test session";
      }

      leaf duplicate-packets {
        type uint32;
        description "Duplicate packets";
      }

      leaf reordered-packets {
        type uint32;
        description "Reordered packets";
      }

      leaf sender-timestamp-format {
        type timestamp-format;
        description
          "Sender Timestamp format";
      }

      leaf reflector-timestamp-format {
        type timestamp-format;
        description
          "Reflector Timestamp format";
      }

      leaf dscp {
        type inet:dscp;
        description
          "The DSCP value that was placed in the header of
        STAMP UDP test packets by the Session-Sender.";
      }

      container two-way-delay {
        description
          "two way delay result of the test session";
        uses delay-statistics;
      }  // container two-way-delay

      container one-way-delay-far-end {
        description
          "one way delay far-end of the test session";
        uses delay-statistics;
      }  // container one-way-delay-far-end

      container one-way-delay-near-end {
        description
          "one way delay near-end of the test session";
        uses delay-statistics;
      }  // container one-way-delay-near-end

      container low-percentile {
        when
          "/stamp/stamp-session-sender/"
            + "test-session[session-id]/"
            + "first-percentile != '0.00'" {
          description
            "Only valid if the
              the first-percentile is not NULL";
        }
        description "Low percentile report";
        uses time-percentile-report;
      }  // container low-percentile

      container mid-percentile {
        when
          "/stamp/stamp-session-sender/"
            + "test-session[session-id]/"
            + "second-percentile != '0.00'" {
          description
            "Only valid if the
              the first-percentile is not NULL";
        }
        description "Mid percentile report";
        uses time-percentile-report;
      }  // container mid-percentile

      container high-percentile {
        when
          "/stamp/stamp-session-sender/"
            + "test-session[session-id]/"
            + "third-percentile != '0.00'" {
          description
            "Only valid if the
              the first-percentile is not NULL";
        }
        description "High percentile report";
        uses time-percentile-report;
      }  // container high-percentile

      container two-way-loss {
        description
          "two way loss count and ratio result of
            the test session";
        uses packet-loss-statistics;
      }  // container two-way-loss

      container one-way-loss-far-end {
        when
          "/stamp/stamp-session-sender/"
            + "test-session[session-id]/"
            + "test-session-reflector-mode = 'stateful'" {
          description
            "One-way statistic is only valid if the
              session-reflector is in stateful mode.";
        }
        description
          "one way loss count and ratio far-end of
            the test session";
        uses packet-loss-statistics;
      }  // container one-way-loss-far-end

      container one-way-loss-near-end {
        when
          "/stamp/stamp-session-sender/"
            + "test-session[session-id]/"
            + "test-session-reflector-mode = 'stateful'" {
          description
            "One-way statistic is only valid if the
              session-reflector is in stateful mode.";
        }
        description
          "one way loss count and ratio near-end of
            the test session";
        uses packet-loss-statistics;
      }  // container one-way-loss-near-end

      uses session-parameters;

      uses maintenance-statistics;
    }  // grouping test-session-statistics

    grouping stamp-session-percentile {
      description "Percentile grouping";
      leaf first-percentile {
        type percentile;
        default '95.00';
        description
          "First percentile to report";
      }

      leaf second-percentile {
        type percentile;
        default '99.00';
        description
          "Second percentile to report";
      }

      leaf third-percentile {
        type percentile;
        default '99.90';
        description
          "Third percentile to report";
      }
    }  // grouping stamp-session-percentile

    grouping delay-statistics {
      description
        "Delay statistics grouping";
      container delay {
        description
          "Packets transmitted delay";
        leaf min {
          type yang:gauge64;
          units "nanoseconds";
          description
            "Min of Packets transmitted delay";
        }

        leaf max {
          type yang:gauge64;
          units "nanoseconds";
          description
            "Max of Packets transmitted delay";
        }

        leaf avg {
          type yang:gauge64;
          units "nanoseconds";
          description
            "Avg of Packets transmitted delay";
        }
      }  // container delay

      container delay-variation {
        description
          "Packets transmitted delay variation";
        leaf min {
          type yang:gauge32;
          units "nanoseconds";
          description
            "Min of Packets transmitted
        delay variation";
        }

        leaf max {
          type yang:gauge32;
          units "nanoseconds";
          description
            "Max of Packets transmitted
        delay variation";
        }

        leaf avg {
          type yang:gauge32;
          units "nanoseconds";
          description
            "Avg of Packets transmitted
        delay variation";
        }
      }  // container delay-variation
    }  // grouping delay-statistics

    grouping time-percentile-report {
      description
        "Delay percentile report grouping";
      container delay-percentile {
        description
          "Report round-trip, near- and far-end delay";
        leaf rtt-delay {
          type yang:gauge64;
          units "nanoseconds";
          description
            "Percentile of round-trip delay";
        }

        leaf near-end-delay {
          type yang:gauge64;
          units "nanoseconds";
          description
            "Percentile of near-end delay";
        }

        leaf far-end-delay {
          type yang:gauge64;
          units "nanoseconds";
          description
            "Percentile of far-end delay";
        }
      }  // container delay-percentile

      container delay-variation-percentile {
        description
          "Report round-trip, near- and far-end delay variation";
        leaf rtt-delay-variation {
          type yang:gauge32;
          units "nanoseconds";
          description
            "Percentile of round-trip delay-variation";
        }

        leaf near-end-delay-variation {
          type yang:gauge32;
          units "nanoseconds";
          description
            "Percentile of near-end delay variation";
        }

        leaf far-end-delay-variation {
          type yang:gauge32;
          units "nanoseconds";
          description
            "Percentile of far-end delay-variation";
        }
      }  // container delay-variation-percentile
    }  // grouping time-percentile-report

    grouping packet-loss-statistics {
      description
        "Grouping for Packet Loss statistics";
      leaf loss-count {
        type int32;
        description
          "Number of lost packets
      during the test interval.";
      }

      leaf loss-ratio {
        type percentage;
        description
          "Ratio of packets lost to packets
      sent during the test interval.";
      }

      leaf loss-burst-max {
        type int32;
        description
          "Maximum number of consecutively
      lost packets during the test interval.";
      }

      leaf loss-burst-min {
        type int32;
        description
          "Minimum number of consecutively
              lost packets during the test interval.";
      }

      leaf loss-burst-count {
        type int32;
        description
          "Number of occasions with packet
    loss during the test interval.";
      }
    }  // grouping packet-loss-statistics

    grouping session-parameters {
      description
        "Parameters Session-Sender";
      leaf sender-ip {
        type inet:ip-address;
        mandatory true;
        description "Sender IP address";
      }

      leaf sender-udp-port {
        type inet:port-number {
          range "49152..65535";
        }
        mandatory true;
        description "Sender UDP port number";
      }

      leaf reflector-ip {
        type inet:ip-address;
        mandatory true;
        description "Reflector IP address";
      }

      leaf reflector-udp-port {
        type inet:port-number {
          range
            "862 | 1024..49151 | 49152..65535";
        }
        default '862';
        description
          "Reflector UDP port number";
      }
    }  // grouping session-parameters

    grouping session-security {
      description
        "Grouping for STAMP security and related parameters";
      container security {
        if-feature stamp-security;
        presence "Enables secure STAMP";
        description
          "Parameters for STAMP authentication";
        leaf key-chain {
          type kc:key-chain-ref;
          description "Name of key-chain";
        }
      }  // container security
    }  // grouping session-security

    container stamp {
      description
        "Top level container for STAMP configuration";
      container stamp-session-sender {
        if-feature session-sender;
        description
          "STAMP Session-Sender container";
        leaf sender-enable {
          type boolean;
          default "true";
          description
            "Whether this network element is enabled to
        act as STAMP Session-Sender";
        }

        list test-session {
          key "session-id";
          unique "sender-ip sender-udp-port reflector-ip reflector-udp-port dscp-value";
          description
            "This structure is a container of test session
        managed objects";
          leaf session-id {
            type uint32;
            description "Session ID";
          }

          leaf test-session-enable {
            type boolean;
            default "true";
            description
              "Whether this STAMP Test session is enabled";
          }

          leaf number-of-packets {
            type union {
              type uint32 {
                range "1..4294967294";
              }
              type enumeration {
                enum "forever" {
                  value 0;
                  description
                    "Indicates that the test session SHALL
                be run *forever*.";
                }
              }
            }
            default '10';
            description
              "This value determines if the STAMP-Test session is
          bound by number of test packets or not.";
          }

          leaf packet-padding-size {
            type uint32;
            default '30';
            description
              "Size of the Packet Padding. Suggested to run
          Path MTU Discovery to avoid packet fragmentation in
          IPv4 and packet blackholing in IPv6";
          }

          leaf interval {
            type uint32;
            units "microseconds";
            description
              "Time interval between transmission of two
          consecutive packets in the test session in
          microseconds";
          }

          leaf session-timeout {
            when
              "../number-of-packets != 'forever'" {
              description
                "Test session timeout only valid if the
            test mode is periodic.";
            }
            type uint32;
            units "seconds";
            default '900';
            description
              "The timeout value for the Session-Sender to
          collect outstanding reflected packets.";
          }

          leaf measurement-interval {
            when
              "../number-of-packets = 'forever'" {
              description
                "Valid only when the test to run forever,
            i.e. continuously.";
            }
            type uint32;
            units "seconds";
            default '60';
            description
              "Interval to calculate performance metric when
          the test mode is 'continuous'.";
          }

          leaf repeat {
            type union {
              type uint32 {
                range "0..4294967294";
              }
              type enumeration {
                enum "forever" {
                  value 0;
                  description
                    "Indicates that the test session SHALL
                be repeated *forever* using the
                information in repeat-interval
                parameter, and SHALL NOT decrement
                the value.";
                }
              }
            }
            default '0';
            description
              "This value determines if the STAMP-Test session must
          be repeated. When a test session has completed, the
          repeat parameter is checked. The default value
          of 0 indicates that the session MUST NOT be repeated.
          If the repeat value is 1 through 4,294,967,294
          then the test session SHALL be repeated using the
          information in repeat-interval parameter.
          The implementation MUST decrement the value of repeat
          after determining a repeated session is expected.";
          }

          leaf repeat-interval {
            when "../repeat != '0'";
            type uint32;
            units "seconds";
            default '0';
            description
              "This parameter determines the timing of repeated
          STAMP-Test sessions when repeat is more than 0.";
          }

          leaf dscp-value {
            type inet:dscp;
            default '0';
            description
              "DSCP value to be set in the test packet.";
          }

          leaf test-session-reflector-mode {
            type session-reflector-mode;
            default "stateless";
            description
              "The mode of STAMP-Reflector for the test session.";
          }

          uses session-parameters;

          leaf sender-timestamp-format {
            type timestamp-format;
            default 'ntp-format';
            description
              "Sender Timestamp format";
          }

          uses session-security;

          uses stamp-session-percentile;
        }  // list test-session
      }  // container stamp-session-sender

      container stamp-session-reflector {
        if-feature session-reflector;
        description
          "STAMP Session-Reflector container";
        leaf reflector-enable {
          type boolean;
          default "true";
          description
            "Whether this network element is enabled to
        act as STAMP Session-Reflector";
        }

        leaf ref-wait {
          type uint32 {
            range "1..604800";
          }
          units "seconds";
          default '900';
          description
            "REFWAIT(STAMP test session timeout in seconds),
        the default value is 900";
        }

        leaf reflector-mode-state {
          type session-reflector-mode;
          default 'stateless';
          description
            "The state of the mode of the STAMP
        Session-Reflector";
        }

        list test-session {
          key "session-id";
          unique "sender-ip sender-udp-port reflector-ip reflector-udp-port";
          description
            "This structure is a container of test session
        managed objects";
          leaf session-id {
            type uint32;
            description "Session ID";
          }

          leaf dscp-handling-mode {
            type session-dscp-mode;
            default 'copy-received-value';
            description
              "Session-Reflector handling of DSCP:
          - use value copied from received STAMP-Test packet;
          - use value explicitly configured";
          }

          leaf dscp-value {
            when
              "../dscp-handling-mode = 'use-configured-value'";
            type inet:dscp;
            default '0';
            description
              "DSCP value to be set in the reflected packet
        if dscp-handling-mode is set to use-configured-value.";
          }

          leaf sender-ip {
            type union {
              type inet:ip-address;
              type enumeration {
                enum "any" {
                  value 0;
                  description
                    "Indicates that the Session-Reflector
                accepts STAMP test packets from
                any Session-Sender";
                }
              }
            }
            default 'any';
            description
              "This value determines whether specific
          IPv4/IPv6 address of the Session-Sender
          or the wildcard, i.e. any address";
          }

          leaf sender-udp-port {
            type union {
              type inet:port-number {
                range "49152..65535";
              }
              type enumeration {
                enum "any" {
                  value 0;
                  description
                    "Indicates that the Session-Reflector
                accepts STAMP test packets from
                any Session-Sender";
                }
              }
            }
            default 'any';
            description
              "This value determines whether specific
          port number of the Session-Sender
          or the wildcard, i.e. any";
          }

          leaf reflector-ip {
            type union {
              type inet:ip-address;
              type enumeration {
                enum "any" {
                  value 0;
                  description
                    "Indicates that the Session-Reflector
                accepts STAMP test packets on
                any of its interfaces";
                }
              }
            }
            default 'any';
            description
              "This value determines whether specific
          IPv4/IPv6 address of the Session-Reflector
          or the wildcard, i.e. any address";
          }

          leaf reflector-udp-port {
            type inet:port-number {
              range
                "862 | 1024..49151 | 49152..65535";
            }
            default '862';
            description
              "Reflector UDP port number";
          }

          leaf reflector-timestamp-format {
            type timestamp-format;
            default 'ntp-format';
            description
              "Reflector Timestamp format";
          }

          uses session-security;
        }  // list test-session
      }  // container stamp-session-reflector
    }  // container stamp

    container stamp-state {
      config false;
      description
        "Top level container for STAMP state data";
      container stamp-session-sender-state {
        if-feature session-sender;
        description
          "Session-Sender container for state data";
        list test-session-state {
          key "session-id";
          description
            "This structure is a container of test session
        managed objects";
          leaf session-id {
            type uint32;
            description "Session ID";
          }

          leaf sender-session-state {
            type enumeration {
              enum "active" {
                value 0;
                description
                  "Test session is active";
              }
              enum "ready" {
                value 1;
                description
                  "Test session is idle";
              }
            }
            description
              "State of the particular STAMP test
          session at the sender";
          }

          container current-stats {
            description
              "This container contains the results for the current
          Measurement Interval in a Measurement session ";
            leaf start-time {
              type yang:date-and-time;
              mandatory true;
              description
                "The time that the current Measurement Interval started";
            }

            uses test-session-statistics;
          }  // container current-stats

          list history-stats {
            key "session-id";
            description
              "This container contains the results for the history
          Measurement Interval in a Measurement session ";
            leaf session-id {
              type uint32;
              description
                "The identifier for the Measurement Interval
            within this session";
            }

            leaf end-time {
              type yang:date-and-time;
              mandatory true;
              description
                "The time that the Measurement Interval ended";
            }

            uses test-session-statistics;
          }  // list history-stats
        }  // list test-session-state
      }  // container stamp-session-sender-state

      container stamp-session-refl-state {
        if-feature session-reflector;
        description
          "STAMP Session-Reflector container for
      state data";
        leaf reflector-light-admin-status {
          type boolean;
          description
            "Whether this network element is enabled to
        act as STAMP Session-Reflector";
        }

        list test-session-state {
          key "session-id";
          description
            "This structure is a container of test session
        managed objects";
          leaf session-id {
            type uint32;
            description "Session ID";
          }

          leaf reflector-timestamp-format {
            type timestamp-format;
            description
              "Reflector Timestamp format";
          }

          uses session-parameters;

          uses maintenance-statistics;
        }  // list test-session-state
      }  // container stamp-session-refl-state
    }  // container stamp-state

    rpc stamp-sender-start {
      description
        "start the configured sender session";
      input {
        leaf session-id {
          type uint32;
          mandatory true;
          description
            "The STAMP session to be started";
        }
      }
    }  // rpc stamp-sender-start

    rpc stamp-sender-stop {
      description
        "stop the configured sender session";
      input {
        leaf session-id {
          type uint32;
          mandatory true;
          description
            "The session to be stopped";
        }
      }
    }  // rpc stamp-sender-stop
  }  // module ietf-stamp