netconfcentral logo

ietf-twamp-light@2017-06-13



  module ietf-twamp-light {

    yang-version 1;

    namespace
      "urn:ietf:params:xml:ns:yang:ietf-twamp-light";

    prefix ietf-twamp-light;

    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import ietf-key-chain {
      prefix kc;
    }

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

    contact
      "draft-mirsky-ippm-twamp-light-yang@tools.ietf.org";

    description "TWAMP Light Data Model";

    revision "2017-06-13" {
      description
        "08 version. Appendix I RFC 5357 is covered.";
      reference
        "RFC 5357";

    }


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

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

    feature twamp-light-authentication {
      description
        "TWAMP Light authentication supported";
    }

    typedef enable {
      type boolean;
      description "enable";
    }

    typedef session-reflector-mode {
      type enumeration {
        enum "stateful" {
          value 0;
          description
            "When the Session-Reflector is stateful,
                        i.e. is aware of TWAMP-Test session state.";
        }
        enum "stateless" {
          value 1;
          description
            "When the Session-Reflector is stateless,
                        i.e. is not aware of the state of
                        TWAMP-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
                        TWAMP 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 percentage {
      type decimal64 {
        fraction-digits 5;
      }
      description "Percentage";
    }

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

    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 twamp-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 twamp-session-percentile

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

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

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

      container delay-variation {
        description
          "Packets transmitted delay variation";
        leaf min {
          type uint32;
          units "microseconds";
          description
            "Min of Packets transmitted
                   delay variation";
        }

        leaf max {
          type uint32;
          units "microseconds";
          description
            "Max of Packets transmitted
                   delay variation";
        }

        leaf avg {
          type uint32;
          units "microseconds";
          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 percentile;
          description
            "Percentile of round-trip delay";
        }

        leaf near-end-delay {
          type percentile;
          description
            "Percentile of near-end delay";
        }

        leaf far-end-delay {
          type percentile;
          description
            "Percentile of far-end delay";
        }
      }  // container delay-percentile

      container jitter-percentile {
        description
          "Report round-trip, near- and far-end jitter";
        leaf rtt-jitter {
          type percentile;
          description
            "Percentile of round-trip jitter";
        }

        leaf near-end-jitter {
          type percentile;
          description
            "Percentile of near-end jitter";
        }

        leaf far-end-jitter {
          type percentile;
          description
            "Percentile of far-end jitter";
        }
      }  // container jitter-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 consequtively
                lost packets during the test interval.";
      }

      leaf loss-burst-min {
        type int32;
        description
          "Minimum number of consequtively
                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-light-parameters {
      description
        "Parameters common among
     Session-Sender and Session-Reflector";
      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 "49152..65535";
        }
        mandatory true;
        description
          "Reflector UDP port number";
      }
    }  // grouping session-light-parameters

    grouping session-light-auth-params {
      description
        "Grouping for TWAMP Light authentication parameters";
      container authentication-params {
        if-feature twamp-light-authentication;
        presence
          "Enables TWAMP Light authentication";
        description
          "Parameters for TWAMP Light authentication";
        leaf key-chain {
          type kc:key-chain-ref;
          description "Name of key-chain";
        }
      }  // container authentication-params
    }  // grouping session-light-auth-params

    container twamp-light {
      description
        "Top level container for TWAMP-Light configuration";
      container twamp-light-session-sender {
        if-feature session-sender-light;
        description
          "TWAMP-Light Session-Sender container";
        leaf sender-light-enable {
          type enable;
          default "true";
          description
            "Whether this network element is enabled to
         act as TWAMP-Light 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 enable;
            default "true";
            description
              "Whether this TWAMP 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 TWAMP-Test session is
              bound by number of test packets or not.";
          }

          leaf packet-padding-size {
            type uint32;
            default '27';
            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 TWAMP-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
                TWAMP-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 TWAMP-Reflector for the test session.";
          }

          uses session-light-parameters;

          uses session-light-auth-params;

          uses twamp-session-percentile;
        }  // list test-session
      }  // container twamp-light-session-sender

      container twamp-light-session-reflector {
        if-feature session-reflector-light;
        description
          "TWAMP-Light Session-Reflector container";
        leaf reflector-light-enable {
          type enable;
          default "true";
          description
            "Whether this network element is enabled to
           act as TWAMP-Light Reflector";
        }

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

        leaf reflector-light-mode-state {
          type session-reflector-mode;
          default 'stateless';
          description
            "The state of the mode of the TWAMP-Light
         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 TWAMP-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.";
          }

          uses session-light-parameters;

          uses session-light-auth-params;
        }  // list test-session
      }  // container twamp-light-session-reflector
    }  // container twamp-light

    container twamp-light-state {
      config false;
      description
        "Top level container for TWAMP-Light state data";
      container twamp-light-session-sender-state {
        if-feature session-sender-light;
        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 TWAMP-Light 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";
            }

            leaf packet-padding-size {
              type uint32;
              default '27';
              description
                "Size of the Packet Padding. Suggested to run
            Path MTU Discovery to avoid packet fragmentation
            in IPv4 and packet backholing 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";
            }

            uses session-light-parameters;

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

            uses maintenance-statistics;

            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
                "/twamp-light/twamp-light-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
                "/twamp-light/twamp-light-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
                "/twamp-light/twamp-light-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
                "/twamp-light/twamp-light-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
                "/twamp-light/twamp-light-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
          }  // container current-stats

          list history-stats {
            key "id";
            description
              "This container contains the results for the history
          Measurement Interval in a Measurement session ";
            leaf 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";
            }

            leaf number-of-packets {
              type uint32;
              description
                "The overall number of UDP test packets to be
            transmitted by the sender for this test session";
            }

            leaf packet-padding-size {
              type uint32;
              default '27';
              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 loss-packets {
              type uint32;
              description "Loss packets";
            }

            uses session-light-parameters;

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

            uses maintenance-statistics;

            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
          }  // list history-stats
        }  // list test-session-state
      }  // container twamp-light-session-sender-state

      container twamp-light-session-refl-state {
        if-feature session-reflector-light;
        description
          "TWAMP-Light Session-Reflector container for
      state data";
        leaf reflector-light-admin-status {
          type boolean;
          mandatory true;
          description
            "Whether this network element is enabled to
        act as TWAMP-Light 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";
          }

          uses maintenance-statistics;

          uses session-light-parameters;
        }  // list test-session-state
      }  // container twamp-light-session-refl-state
    }  // container twamp-light-state

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

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