ciena-sat

This YANG module defines Ciena's data definition for the management of benchmark Service Activation Testing. Copyright (c) 2016...

  • Version: 2017-12-07

    ciena-sat@2017-12-07


    
      module ciena-sat {
    
        yang-version 1;
    
        namespace
          "http://www.ciena.com/ns/yang/ciena-sat";
    
        prefix ciena-sat;
    
        import ietf-yang-types {
          prefix yang;
        }
        import ieee802-dot1q-types {
          prefix ieee;
        }
        import ciena-types {
          prefix ciena;
        }
        import ietf-inet-types {
          prefix inet;
        }
        import ciena-mef-logical-port {
          prefix mef-logical-port;
        }
        import ciena-mef-fp {
          prefix mef-fp;
        }
    
        organization "Ciena Corporation";
    
        contact
          "Web URL: http://www.ciena.com/
        E-mail:  yang@ciena.com
        Postal:  7035 Ridge Road
        Hanover, Maryland 21076
        U.S.A.
        Phone:   +1 800-921-1144
        Fax:     +1 410-694-5750";
    
        description
          "This YANG module defines Ciena's data definition for the
        management of benchmark Service Activation Testing.
    
        Copyright (c) 2016 Ciena Corporation.  All rights
        reserved.
    
        All information contained herein is, and remains
        the property of Ciena Corporation. Dissemination of this
        information or reproduction of this material is strictly
        forbidden unless prior written permission is obtained from
        Ciena Corporation.";
    
        revision "2017-12-07" {
          description
            "Added support for outage test.";
          reference
            "Carrier Ethernet Service Activation Testing (MEF 48), Oct 2014";
    
        }
    
        revision "2017-10-26" {
          description
            "Changed entity's role to a leaf instead of a choice.
           Changed entity's port to be a logical-port reference
           Replaced test instance's sub-port ID for flow point ID - refence to
            an MEF flow point
           Added active dst MAC, active s-vid and active c-vid leaf to the
            test instance operational data";
          reference
            "Carrier Ethernet Service Activation Testing (MEF 48), Oct 2014";
    
        }
    
        revision "2016-11-01" {
          description "Initial Version.";
          reference
            "Carrier Ethernet Service Activation Testing (MEF 48), Oct 2014";
    
        }
    
    
        typedef name-string {
          type string {
            length "1..45";
          }
          description
            "A text string of up to 45 characters.";
        }
    
        typedef latency-pdv-test-state-type {
          type enumeration {
            enum "idle" {
              value 0;
              description
                "Test is not configured or hasn't started yet.";
            }
            enum "sending-traffic" {
              value 1;
              description
                "Sending test packets.";
            }
            enum "waiting-for-timestamp-data" {
              value 2;
              description
                "Collecting latency data.";
            }
            enum "waiting-for-residual-packets" {
              value 3;
              description
                "Waiting for all test packets to return back to collector.";
            }
            enum "processing-results" {
              value 4;
              description
                "Processing latency data collected.";
            }
            enum "stopped-by-interval-timer" {
              value 5;
              description
                "Test stopped by the interval timer.";
            }
            enum "stopped-by-duration-timer" {
              value 6;
              description
                "Test stopped by the duration timer.";
            }
            enum "stopped-by-user" {
              value 7;
              description
                "Test stopped by the user.";
            }
            enum "done" {
              value 8;
              description "Testing complete.";
            }
          }
          description
            "Possible states for the latency and packet delay variation tests.";
        }
    
        typedef throughput-test-state-type {
          type enumeration {
            enum "idle" {
              value 0;
              description
                "Test is not configured or hasn't started yet.";
            }
            enum "running" {
              value 1;
              description
                "Test traffic is being sent.";
            }
            enum "waiting-for-residual-packets" {
              value 2;
              description
                "Waiting for all test packets to return back to collector.";
            }
            enum "processing-results" {
              value 3;
              description
                "Processing throughput results.";
            }
            enum "stopped-by-interval-timer" {
              value 4;
              description
                "Test stopped by the interval timer.";
            }
            enum "stopped-by-duration-timer" {
              value 5;
              description
                "Test stopped by the duration timer.";
            }
            enum "stopped-by-user" {
              value 6;
              description
                "Test stopped by the user.";
            }
            enum "done" {
              value 7;
              description "Test complete.";
            }
            enum
              "tx-max-throughput-for-yellow-test" {
              value 8;
              description
                "Transitting green test frames at maximum throughput found, while
               yellow test frames are sent in search of yellow maximum throughput.";
            }
          }
          description "Throughput test states";
        }
    
        typedef frameloss-test-state-type {
          type enumeration {
            enum "idle" {
              value 0;
              description
                "Test is not configured or hasn't started yet.";
            }
            enum "running-first-test" {
              value 1;
              description
                "Sending test packets for the first frame loss pass.";
            }
            enum
              "WaitingForResidualFirstPackets" {
              value 2;
              description
                "Waiting for all test packets from the first frame loss pass to 
               return back to collector.";
            }
            enum "processing-first-results" {
              value 3;
              description
                "Processing results for the first frame loss pass.";
            }
            enum "running-second-test" {
              value 4;
              description
                "Sending test packets for the first frame loss pass.";
            }
            enum
              "waiting-for-residual-second-packets" {
              value 5;
              description
                "Waiting for all test packets from the second frame loss pass 
               to return back to collector.";
            }
            enum "processing-second-results" {
              value 6;
              description
                "Processing results for the second frame loss pass.";
            }
            enum "stopped-by-interval-timer" {
              value 7;
              description
                "Test stopped by the interval timer.";
            }
            enum "stopped-by-duration-timer" {
              value 8;
              description
                "Test stopped by the duration timer.";
            }
            enum "stopped-by-user" {
              value 9;
              description
                "Test stopped by the user.";
            }
            enum "done" {
              value 10;
              description "Test complete.";
            }
          }
          description "Frame loss test states";
        }
    
        typedef rfc2544-test-state-type {
          type enumeration {
            enum "idle" {
              value 0;
              description
                "Test is not configured or hasn't started yet.";
            }
            enum "running" {
              value 1;
              description
                "The RFC 1544 test suite is currently running. 
               Refer to the throughput, frame loss and latency test state 
               to find out which test from the suite is currently executing.";
            }
            enum "stopped-by-interval-timer" {
              value 2;
              description
                "Test stopped by the interval timer.";
            }
            enum "stopped-by-duration-timer" {
              value 3;
              description
                "Test stopped by the duration timer.";
            }
            enum "stopped-by-user" {
              value 4;
              description
                "Test stopped by the user.";
            }
            enum "done" {
              value 5;
              description "Test complete.";
            }
          }
          description
            "RFC 2544 test suite state.";
        }
    
        typedef y1564-test-state-type {
          type enumeration {
            enum "idle" {
              value 0;
              description
                "Test is not configured or hasn't started yet.";
            }
            enum "running" {
              value 1;
              description
                "The Y.1564 test suite is currently running. 
               Refer to the throughput, frame loss, latency and PDV test state 
               to find out which test from the suite is currently executing.";
            }
            enum "stopped-by-interval-timer" {
              value 2;
              description
                "Test stopped by the interval timer.";
            }
            enum "stopped-by-duration-timer" {
              value 3;
              description
                "Test stopped by the duration timer.";
            }
            enum "stopped-by-user" {
              value 4;
              description
                "Test stopped by the user.";
            }
            enum "done" {
              value 5;
              description "Test complete.";
            }
          }
          description "Y1564 test suite state.";
        }
    
        typedef outage-test-state-type {
          type enumeration {
            enum "idle" {
              value 0;
              description
                "Test is not configured or hasn't started yet.";
            }
            enum "running" {
              value 1;
              description
                "The outage test is currently running.";
            }
            enum "stopped-by-duration-timer" {
              value 2;
              description
                "Test stopped by the duration timer.";
            }
            enum "stopped-by-user" {
              value 3;
              description
                "Test stopped by the user.";
            }
            enum "processing-outage-records" {
              value 4;
              description
                "Processing outage test records.";
            }
            enum "done" {
              value 5;
              description "Test complete.";
            }
          }
          description "outage test state.";
        }
    
        typedef priority {
          type uint8 {
            range "0..7";
          }
          description
            "Range of priorities from 0-7 inclusive.";
        }
    
        typedef basic-color {
          type enumeration {
            enum "green" {
              value 0;
              description "Green traffic.";
            }
            enum "yellow" {
              value 1;
              description "Yellow traffic.";
            }
          }
          description
            "Traffic color which is associated with the dot1q DEI 
          (drop eligible indictor) bit value.";
        }
    
        typedef color {
          type enumeration {
            enum "green" {
              value 0;
              description
                "The test is configured to run with green traffic only.";
            }
            enum "yellow" {
              value 1;
              description
                "The test is configured to run with yellow traffic only.";
            }
            enum "green-yellow" {
              value 2;
              description
                "The test is configured to run with green traffic starting at 
               the configured bandwidth and yellow traffic starting at 
               the configured excess bandwidth.";
            }
            enum "green-yellow-red" {
              value 3;
              description
                "The test is configured to run with green traffic starting at 
               the configured bandwidth and yellow traffic starting at 1.25 
               times the configured excess bandwidth.";
            }
          }
          description
            "Defines which traffic color needs to be tested. Green 
          test traffic is generated with DEI bit set to 0 and
          uses the profile bandwidth parameter as the starting
          bandwidth; yellow test traffic is generated with DEI bit
          set to 1 and uses the profile excess-bandwidth parameter
          as the starting bandwidth. When testing for red, the test
          stream has its DEI bit set to 1 and the starting bandwidth
          is (excess-bandwidth * 1.25)";
        }
    
        typedef kpi-result-type {
          type enumeration {
            enum "not-available" {
              value 0;
              description
                "No KPI (Key Performance Indicator) configured for the test.";
            }
            enum "pass" {
              value 1;
              description
                "The test results are within the configured KPI. 
               The test is therefore considered a pass";
            }
            enum "fail" {
              value 2;
              description
                "The test results are outside the configured KPI boundary. 
               The test is therefore considered a fail.";
            }
          }
          description
            "Provides a pass or fail for the test results compared to
          the selected KPI profile's pass crieteria for the test.";
        }
    
        typedef throughput-kpi-percent {
          type uint32;
          description
            "Percent of bandwidth that the maximum throughput result
          shouldn't go below for the test to be considered a pass.
          The value is given as an integer but represent a 4 decimal
          point percent. Ex: 0.2000 is reported as 2000.";
        }
    
        typedef frameloss-kpi-percent {
          type uint32;
          description
            "Percent of the frameloss test staring bandwidth, the frame
          loss shouldn't exceed for the test to be considered a pass.
          The value is given as an integer but represent a 4 decimal
          point percent. Ex: 0.2000 is reported as 2000.";
        }
    
        typedef throughput-result {
          type uint32;
          description
            "Throughput results in Mbps are sent as unsigned integer
          multiplied by 100 to provide a 2 decimal point accuracy.
          If result is 123.45 Mbps, it is sent as 12345 and should
          be divided by 100 by the application retrieving the
          data.";
        }
    
        typedef frameloss-result {
          type uint32;
          description
            "Frame loss results in Percent of frame loss start bandwidth
          are sent as unsigned integer multitplied by 100 to provide a
          2 decimal point accuracy.
          If result is 12.34 %, it is sent as 1234 and should
          be divided by 100 by the application retrieving the
          data.";
        }
    
        typedef pcp-bitmap {
          type bits {
            bit pcp0 {
              position 0;
              description "pcp 0.";
            }
            bit pcp1 {
              position 1;
              description "pcp 1.";
            }
            bit pcp2 {
              position 2;
              description "pcp 2.";
            }
            bit pcp3 {
              position 3;
              description "pcp 3.";
            }
            bit pcp4 {
              position 4;
              description "pcp 4.";
            }
            bit pcp5 {
              position 5;
              description "pcp 5.";
            }
            bit pcp6 {
              position 6;
              description "pcp 6.";
            }
            bit pcp7 {
              position 7;
              description "pcp 7.";
            }
          }
          description
            "Bitmap of the VLAN PCP (Priority Code) value to test
          with. When The RFC2544 test is selected in the profile,
          only 1 PCP bit can be set. For other tests, a test 
          session will be run simultaneously for each PCP set
          in the bitmap. In the latter case, the bandwidth will
          be distributed among the set of PCPs according to the
          selected PCP Bandwidth allocation profile. If no
          such profile is configured, the bandwidth will be
          evenly distributed among all set PCPs.";
        }
    
        grouping kpi-values {
          description
            "Common fields for pcp KPIs and untagged KPIs";
          leaf throughput {
            type throughput-kpi-percent;
            description
              "Throughput KPI for the given KPI profile, PCP and color
             expressed in percent of bandwidth * 10000 to provide a 4
             decimal point value.";
          }
    
          leaf frameloss {
            type frameloss-kpi-percent;
            description
              "Frameloss KPI for the given KPI profile, PCP and color
             expressed in percent of bandwidth * 10000 to provide a 4
             decimal point value.";
          }
    
          leaf latency {
            type uint32;
            units "microseconds";
            description
              "Maximum latency in micro-seconds that the latency result
             should not exceed in order for the test to be considered
             a pass.";
          }
    
          leaf pdv {
            type uint32;
            units "microseconds";
            description
              "Maximum PDV in micro-seconds that the PDV test result
             should not exceed in order for the test to be 
             considered a pass.";
          }
    
          leaf single-outage-max {
            type uint32 {
              range "0..10000";
            }
            units "milliseconds";
            description
              "Maximum time in milli-seconds that any single 
             outage should not exceed in order for the test 
             to be considered a pass.";
          }
    
          leaf sum-outages-max {
            type uint32 {
              range "0..30000";
            }
            units "milliseconds";
            description
              "Maximum time in milli-seconds that the sum of recorded
             outages should not exceed in order for the test 
             to be considered a pass.";
          }
    
          leaf max-num-outages {
            type uint32 {
              range "0..128";
            }
            description
              "Maximum number of outages that can occur during
             the outage test in order for the test to be 
             considered a pass.";
          }
        }  // grouping kpi-values
    
        grouping notification-base-fields {
          description
            "Common fields for all SAT notifications.";
          leaf severity {
            type ciena:event-severity;
            description "Severity.";
          }
    
          leaf mac-address {
            type yang:mac-address;
            description "Mac address.";
          }
    
          leaf test-instance-name {
            type name-string;
            mandatory true;
            description
              "Name of the test instance.";
          }
        }  // grouping notification-base-fields
    
        grouping notification-test-kpi-fields {
          description
            "Common fields for all SAT test KPI failure notifications";
          uses notification-base-fields;
    
          leaf kpi-profile {
            type name-string;
            description "KPI profile name.";
          }
    
          leaf kpi-pcp {
            type priority;
            description
              "PCP - when not untagged.";
          }
    
          leaf kpi-untagged {
            type boolean;
            description "Untagged.";
          }
    
          leaf kpi-color {
            type basic-color;
            description "Color.";
          }
    
          leaf current-pkt-size {
            type uint32;
            description "current packet size.";
          }
    
          leaf emix-sequence {
            type name-string;
            description "emix sequence name.";
          }
        }  // grouping notification-test-kpi-fields
    
        container sat {
          description "SAT configuration data.";
          container sat-global {
            description
              "SAT global configuration data.";
            leaf admin-state {
              type ciena:admin-state;
              default 'disabled';
              description
                "Overall administrative state of the benchmark feature.";
            }
    
            leaf default-emix-sequence {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:emix-sequence/ciena-sat:name";
              }
              description
                "Default EMIX sequence to be used on a test instance
              when no EMIX is specified in the test instance 
              targeted test profile. This applies to generator
              test instances only.";
            }
    
            leaf generator-default-kpi-profile {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:kpi-profile/ciena-sat:name";
              }
              description
                "Default KPI profile to be used to analyze the results
              of a test instance when no KPI profile is specifed in
              the targeted test profile. This applies to generator
              test instances only.";
            }
    
            leaf generator-default-bw-alloc-profile {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:bw-alloc-profile/ciena-sat:name";
              }
              description
                "Default bandwidth allocation profile to be used with
              a test instance when no bandwidth allocation profile is
              specified in the targeted test profile. This applies to
              generator test instances only.";
            }
          }  // container sat-global
    
          list entity {
            key "name";
            description
              "Service activation testing entity configuration.";
            leaf name {
              type name-string;
              description
                "Name of the service activation test entity.";
            }
    
            leaf port {
              type mef-logical-port:logical-port-ref;
              description
                "SAT entity's port under test";
            }
    
            leaf role {
              type enumeration {
                enum "reflector" {
                  value 0;
                  description
                    "SAT entity's mode of operation is reflector.";
                }
                enum "generator" {
                  value 1;
                  description
                    "SAT entity's mode of operation is generator.";
                }
              }
              description
                "SAT entity's mode of operation";
            }
    
            leaf generator-h-frame-size {
              when "../role='generator'";
              type uint32;
              description
                "Maximum frame size that should be generated by the generator
             device. This H frame size should be set to leave enough room for
             extra encapsulation bytes that will be pushed onto the 
             packet by the switch when pushing this test packet out on
             the network side port.
             A value of 0 indicates that the maximum frame size for the
             entity port should be used. 
             The generator device will ensure that any frame size list
             or EMIX used during the test is adjusted accordingly.
             This field is only valid for a generator SAT entity.";
            }
    
            leaf assoc-gen-vendor-type {
              when "../role='reflector'";
              type enumeration {
                enum "other" {
                  value 0;
                  description
                    "The remote generator is NOT a Ciena device.";
                }
                enum "ciena" {
                  value 1;
                  description
                    "The remote generator is a Ciena device.";
                }
              }
              default 'ciena';
              description
                "This is an indicator as to what is the vendor of the associated 
               generator entity connected to this reflector SAT entity.
               This field is only valid for a reflector SAT entity.";
            }
    
            leaf reflection-level {
              when "../role='reflector'";
              type enumeration {
                enum "none" {
                  value 0;
                  description "Not configured.";
                }
                enum "l2-only" {
                  value 1;
                  description
                    "Only the L2 layer fields need to be swapped on reflected packets.";
                }
                enum "l2-to-l3-ipv4-only" {
                  value 2;
                  description
                    "The L2 MAC addresses as well as the IPv4 addresses need to 
                    be swapped on reflected packets.";
                }
                enum "l2-to-l3-ipv6-only" {
                  value 3;
                  description
                    "The L2 MAC addresses as well as the IPv6 addresses need to 
                    be swapped on reflected packets.";
                }
                enum "l2-to-l4-ipv4-only" {
                  value 4;
                  description
                    "L2 MAC addresses, IPv4 addresses and UDP ports need to  
                    be swapped on the reflected packets.";
                }
                enum "l2-to-l4-ipv6-only" {
                  value 5;
                  description
                    "L2 MAC addresses, IPv6 addresses and UDP ports need to 
                    be swapped on the reflected packets.";
                }
                enum "l2-to-l4" {
                  value 6;
                  description
                    "L2 MAC addresses, IPv4 or IPv6 addresses and UDP ports need 
                    to be swapped on the reflected packets.";
                }
              }
              description
                "For reflector entities, this indicates the minimum reflection
               level required. If test traffic is going over an ethernet L2
               cloud, l2-only is fine. But if the test traffic is going over
               an IP network, the reflector needs to be able to swap L2 and
               L3 fields. Depending on the type of IP network, the user
               needs to configure IPv4 or IPv6. L2 to L4 will swap MAC 
               addresses, IP addresses and src and destination L4 port.
               Depending on the reflection level required, a different device
               is used to implement the reflector.
               This field is only valid for an 8.x reflector SAT entity.
               The default value is l2-to-l4.";
            }
    
            leaf reflector-mac-validation {
              when "../role='reflector'";
              type boolean;
              default 'true';
              description
                "Used to indicate whether the reflector should classify
               classify on the mac or not.";
            }
    
            leaf mode {
              type enumeration {
                enum "in-service" {
                  value 0;
                  description
                    "In service mode; customer traffic is not blocked on the port
                   under test while service activation testing is in progress.";
                }
                enum "out-of-service" {
                  value 1;
                  description
                    "Out of service mode; all customer traffic is dropped at the port
                   under test while service activation testing is in progress.";
                }
                enum "vid-out-of-service" {
                  value 2;
                  description
                    "Vlan ID Out Of Servcie mode; only customer traffic for the 
                   Vlan IDs currently being tested is being dropped at the port 
                   under test; all other customer traffic goes through.";
                }
                enum "evc-out-of-service" {
                  value 3;
                  description
                    "Virtual Circuit Out Of Service; all customer traffic 
                   associated with the virtual circuit(s) currently under test 
                   is being dropped at the port under test; 
                   all other customer traffic goes through.";
                }
              }
              default 'in-service';
              description
                "SAT entity's mode of operation";
            }
    
            leaf admin-state {
              type ciena:admin-state;
              default 'disabled';
              description
                "SAT entity's administrative state.";
            }
          }  // list entity
    
          list emix-sequence {
            key "name";
            description "EMIX sequence entry.";
            leaf name {
              type name-string;
              description
                "Name of this EMIX sequence";
            }
    
            leaf sequence {
              type string {
                length "1..16";
              }
              description
                "EMIX sequence which is a sequence of up to
              16 letters from the following set, that can
              be repeated, where each letter is associated with
              the frame size below it:
                   a    b    c    d    e    f    g    h    u     v   w   x 
                  64   128  256  512  1024 1280 1518 MTU custom 84  68  88 
              The u frame size is user configurable via the
              emix-sequence-UFrameSize attribute
              while the h frame size is the maximum frame size
              configured at the entity level. If the h frame size is
              not configured at the entity level, h takes the value of
              the maximum frame size of the port under test.
              Letter v is the minimum frame size for IPv6 untagged or dot1q
              test frames, w is the minimum for IPv4 qinq test frames, and
              x is the minimum for IPv6 qinq test frames.
              The EMIX character set is available via the
              emix-sequence-character-set list.";
            }
    
            leaf u-frame-size {
              type uint32 {
                range "64..9216";
              }
              default '594';
              description
                "The frame size associated with the u letter
              in the given sequence. The default value is
              594.";
            }
          }  // list emix-sequence
    
          list kpi-profile {
            key "name";
            description
              "Key performance indicator pass/fail criteria.";
            leaf name {
              type name-string;
              description
                "Name of the KPI profile";
            }
    
            list pcp {
              key "pcp-value";
              description
                "Each PCP within the KPI profile has its own configuration.";
              leaf pcp-value {
                type priority;
                description
                  "PCP value associated with this entry";
              }
    
              uses kpi-values;
            }  // list pcp
    
            container untagged {
              description
                "Untagged traffic does not have a PCP, so it is handled separately.";
              uses kpi-values;
            }  // container untagged
          }  // list kpi-profile
    
          list bw-alloc-profile {
            key "name";
            description
              "BW allocation profile entry";
            leaf name {
              type name-string;
              description
                "Name of the bandwidth allocation profile";
            }
    
            list pcp {
              key "pcp-value";
              description
                "Each PCP within the bw-alloc-profile has its own configuration.";
              leaf pcp-value {
                type priority;
                description
                  "PCP value associated with this entry.";
              }
    
              leaf ratio {
                type uint32 {
                  range "0..1000000";
                }
                description
                  "Ratio of test bandwidth to allocate to the
                test session with this PCP value.";
              }
            }  // list pcp
          }  // list bw-alloc-profile
    
          list test-profile {
            key "name";
            description
              "Service activation test profile configuation information.";
            leaf name {
              type name-string;
              description "Name of the profile.";
            }
    
            leaf bandwidth {
              type uint32 {
                range "1..10000";
              }
              description
                "Maximum bandwidth to use when generating green test
              traffic for the profile.";
            }
    
            leaf excess-bandwidth {
              type uint32 {
                range "0..10000";
              }
              default '0';
              description
                "Maximum bandwidth to use when generating yellow test
              traffic for the profile. When testing for red color,
              this bandwidth is multiplied by 1.25";
            }
    
            leaf interval {
              type enumeration {
                enum "t15min" {
                  value 0;
                  description "15 minutes.";
                }
                enum "t1hr" {
                  value 1;
                  description "1 hour.";
                }
                enum "t6hr" {
                  value 2;
                  description "6 hours.";
                }
                enum "tCompletion" {
                  value 3;
                  description
                    "Interval between the start of one test group and the start
                   of the nexxt test group configured on the profile (latency,
                   pdv, throughput, frameloss, rfc2544 and/or y1564).";
                }
                enum "t2hr" {
                  value 4;
                  description "2 hours.";
                }
              }
              default 'tCompletion';
              description
                "Interval between the start of one test group to the start
              of the next test group.";
            }
    
            leaf duration {
              type enumeration {
                enum "t15min" {
                  value 0;
                  description "15 minutes.";
                }
                enum "t1hr" {
                  value 1;
                  description "1 hour.";
                }
                enum "t6hr" {
                  value 2;
                  description "6 hours.";
                }
                enum "t24hr" {
                  value 3;
                  description "24 hours.";
                }
                enum "tIndefinite" {
                  value 4;
                  description "Indefinite.";
                }
                enum "tOnce" {
                  value 5;
                  description "Once.";
                }
              }
              default 'tOnce';
              description
                "Duration of the testing. The test group is repeated until
              the duration ends. When indefinite is set, test group is
              repeated until the user manually stops the test.";
            }
    
            leaf-list frame-size {
              type uint32 {
                range "64..9216";
              }
              max-elements 10;
              description
                "Used to replace the existing frame size table with the specified list.
              List of frame sizes the test will run with. The selected tests are 
              performed for one frames size, then the same test is repeated with
              the next frame size in the list.  Results are provided for each 
              separate frame size from the list.  When rfc2544 is selected, the
              default frame size is made up of the following 7 frame sizes:
              64,128,256,512,1024,1280,1518; The first frame size may differ
              from 64 depending on the VLAN encapsulation type configured and/or
              the IP version used for the test:
              Untagged, non IP or IPv4          64
              Untagged IPv6                     84
              dot1q non IP or IPv4              64
              dot1q IPv6                        84
              QinQ non IP or IPv4               68
              QinQ IPv6                         88.";
            }
    
            leaf max-searches {
              type uint8 {
                range "1..16";
              }
              default '7';
              description
                "The throughput test uses a binary search to find the maximum
              rate at which test traffic can be sent without any packet drops.
              This attributes dictates the maximum number of searches to perform
              in the binary search algorithm, before stopping the test.";
            }
    
            leaf max-samples {
              type uint8 {
                range "2..20";
              }
              default '10';
              description
                "For the latency and PDV tests, this is the number of
              samples to take in order to determine the min, avg
              and max latency and avg PDV.";
            }
    
            leaf sampling-interval {
              type uint16 {
                range "1..600";
              }
              default '1';
              description
                "This is the number of 100ms steps to use when running any of the
              configured tests. A value of 1 represents 100ms, a value of 600
              makes a sampling interval of 1 minutes (600 * 100ms). For the
              throughput and frame loss tests, this is the number of milliseconds
              to generate test traffic for before stopping and checking for 
              frame drops. For latency and PDV, it represents the number of 
              milliseconds between samples.";
            }
    
            leaf frameloss-start-bw {
              type enumeration {
                enum "profile-bandwidth" {
                  value 0;
                  description
                    "Bandwidth specified in profile.";
                }
                enum "maximum-throughput" {
                  value 1;
                  description
                    "Maximum throughput.";
                }
              }
              default 'maximum-throughput';
              description
                "For the frame loss test, this indicates which bandwidth
              value to use as the starting bandwidth; the maximum
              bandwidth determined via the throughput test or the
              bandwidth parameter configured in the profile. Note
              that when rfc2544 is enabled, this value is ignored and 
              the maximum bandwidth of the link is used (minimum of the 
              port under test speed and entity/FPGA link speed).";
            }
    
            leaf vid-validation {
              type boolean;
              default 'true';
              description
                "Indicates whether the VID of the reflected test frame should
              be checked for a match when it arrives back at the generator.
              If VID validation is set to false, PCP and Color validation
              are ignored and automatically become false.";
            }
    
            leaf pcp-validation {
              type boolean;
              default 'true';
              description
                "Used to indicate whether the PCP value of the
              test packet should be used to classifier the reflected
              packets or not. When color remarking is used, this should
              be set to false. Default is true.";
            }
    
            leaf color-validation {
              type boolean;
              default 'true';
              description
                "Used to indicate whether the color bit of the
              test packet should be used to classifier the reflected
              packets or not. In color unaware testing, this should
              be set to false. Default is true.";
            }
    
            leaf kpi-profile-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:kpi-profile/ciena-sat:name";
              }
              description
                "Name of a valid KPI profile, from the 
              kpi-profile list, to use when
              analysing the test results for this profile.";
            }
    
            leaf bw-alloc-profile {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:bw-alloc-profile/ciena-sat:name";
              }
              description
                "Name of a valid Bandwidth Allocation profile,
              from the bw-alloc-profile list,
              used for distributing the profile bandwidth amongst
              the configured PCP values for this profile when running
              tests.";
            }
    
            leaf emix-sequence {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:emix-sequence/ciena-sat:name";
              }
              description
                "Name of a valid EMIX sequence configured in the
              emix-sequence list, to use when y1564
              is selected. The EMIX sequence is used instead of the
              frame size list if and only if y1564 is selected.";
            }
    
            leaf encap-type {
              type enumeration {
                enum "untagged" {
                  value 0;
                  description "Untagged.";
                }
                enum "dot1Q" {
                  value 1;
                  description "Dot1q.";
                }
                enum "qinq" {
                  value 2;
                  description "QinQ.";
                }
              }
              default 'untagged';
              description
                "Encapsulation type to use for generated packets.";
            }
    
            leaf pdu-type {
              type enumeration {
                enum "ethernet" {
                  value 0;
                  description "Ethernet.";
                }
                enum "ip" {
                  value 1;
                  description "IP.";
                }
                enum "udp-echo" {
                  value 2;
                  description "UDP echo.";
                }
              }
              default 'ethernet';
              description "Test PDU type.";
            }
    
            leaf dst-mac {
              type yang:mac-address;
              description
                "MAC address to use as the destination MAC address on
              the generated packets.";
            }
    
            leaf s-vid {
              type ieee:vlanid;
              description
                "S-VLAN ID to used for generated packets when encapType is set to QinQ";
            }
    
            leaf s-pcp {
              type pcp-bitmap;
              description
                "Bitmap of the S-VLAN PCP (Priority Code Point) value to 
              test with. When RFC2544 test is enabled, only one 
              PCP can be set in the mask. Otherwise, a test session
              will be run for each PCP bit set. Used when the encapType
              set to QinQ";
            }
    
            leaf s-color {
              type color;
              description
                "Color of the S-VLAN tag for the test traffic. This is 
              directly related to the value of the DEI bit 
              configured in the VLAN tag of the test traffic. Green
              traffic will have its DEI bit set to 0 while Yellow
              traffic will have its DEI bit set to 1.
              Green test traffic is generated based on the bandwidth
              configured in the test profile. Yellow traffic is
              generated based on the excess-bandwidth parameter.
              Finally, if the user selects green-yellow-red, the
              yellow traffic is generated at 1.25 * excess-bandwidth.
              This is used only when encapType is set to QinQ";
            }
    
            leaf c-vid {
              type ieee:vlanid;
              description
                "C-VLAN ID to used for generated packets when encapType is set to
              QinQ or dot1q.";
            }
    
            leaf c-pcp {
              type pcp-bitmap;
              default 'pcp0';
              description
                "Bitmap of the C-VLAN PCP (Priority Code Point) value to 
              test with. When RFC2544 test is enabled, only one 
              PCP can be set in the mask. Otherwise, a test session
              will be run for each PCP bit set. Only used when the
              encapType is set to dot1q. In the QinQ type, the c-pcp 
              of the test packet takes the same value as the s-pcp to
              simplify software.";
            }
    
            leaf c-color {
              type color;
              default 'green';
              description
                "Color of the C-VLAN tag for the test traffic. This is 
              directly related to the value of the DEI bit 
              configured in the VLAN tag of the test traffic. Green
              traffic will have its DEI bit set to 0 while Yellow
              traffic will have its DEI bit set to 1.
              Green test traffic is generated based on the bandwidth
              configured in the test profile. Yellow traffic is
              generated based on the excess-bandwidth parameter.
              Finally, if the user selects green-yellow-red, the
              yellow traffic is generated at 1.25 * excess-bandwidth.
              This is used only when encapType is set to dot1q.
              In a QinQ configuration, the c-dei bit is set to the
              same value as the s-dei bit in order to simplify
              software.";
            }
    
            leaf tpid {
              type enumeration {
                enum "0x8100" {
                  value 0;
                  description
                    "VLAN tagged frame.";
                }
                enum "0x88a8" {
                  value 1;
                  description
                    "Provider bridging.";
                }
                enum "0x9100" {
                  value 2;
                  description "Proprietary.";
                }
              }
              default '0x8100';
              description
                "Vlan tag protocol identifier to use for the generated packets.";
            }
    
            leaf dscp {
              type inet:dscp;
              description
                "IP DSCP value to use for the generated packets.";
            }
    
            leaf src-addr {
              type inet:ip-address;
              description
                "Specifies the unicast source IP address to use in IP test packet.";
            }
    
            leaf dst-addr {
              type inet:ip-address;
              description
                "Specifies the unicast destination IP addr to use in IP test packet.";
            }
    
            leaf custom-payload {
              type binary {
                length "0..256";
              }
              description
                "Custom payload to be used in the generated packets.";
            }
    
            leaf throughput-test {
              type boolean;
              default 'false';
              description "Run throughput test";
            }
    
            leaf frameloss-test {
              type boolean;
              default 'false';
              description "Run frame loss test";
            }
    
            leaf latency-test {
              type boolean;
              default 'false';
              description "Run latency test";
            }
    
            leaf pdv-test {
              type boolean;
              default 'false';
              description
                "Run packet delay variation test";
            }
    
            leaf burst-test {
              type boolean;
              description
                "Run packet burst test";
            }
    
            leaf rfc2544-suite {
              type boolean;
              default 'false';
              description
                "Run RFC2544 test suite which includes throughput, frame
              loss and latency tests";
            }
    
            leaf y1564-suite {
              type boolean;
              default 'false';
              description
                "The Y1564 test includes the throughput, frameloss,
              latency and PDV tests and requires an EMIX sequence to be
              configured. If the profile's EMIX sequencei s not configured,
              the default generator EMIX sequence is used.
              Y1564 and RFC2544 are mutually exclusive.";
            }
    
            leaf outage-test {
              type boolean;
              default 'false';
              description "Run outage test";
            }
          }  // list test-profile
    
          list test-instance {
            key "name";
            description
              "Service activation test instance configuration data.";
            leaf name {
              type name-string;
              description
                "Unique name given to the test instance.";
            }
    
            leaf flow-point-id {
              type mef-fp:fp-ref;
              description
                "flow-point or sub-port to base this test instance on. The flow-point has
              to be a child of the logical port under test associated with an existing 
              entity.";
            }
    
            leaf profile {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-profile/ciena-sat:name";
              }
              description
                "Name of an existing test profile to be used with the test instance as
              the template for testing. A test profile ID has to be specified if
              this test instance is associated with a generator entity. If it's a
              reflector test instance, a profile ID CANNOT be specified, it has
              to remain unset.";
            }
    
            leaf s-vid {
              type uint16;
              description
                "S VLAN ID to use for testing.
              For generator test instances, this over-writes the value defined in 
              the referenced test profile if applicable (encap-type set to qinq).
              For reflector test instances, this has to be set to a valid s-vid
              accepted by the associated sub-port. A value of 0xFFFF indicates 
              ANY s-vid.";
            }
    
            leaf c-vid {
              type uint16;
              description
                "C VLAN ID to use for testing.
              For generator test instances, this over-writes the value defined 
              in the referenced test profile if applicable (encap-type set to 
              dot1q or qinq).
              For reflector test instances, this has to be set to a valid c-vid
              accepted by the associated port/sub-port. 
              A value of 0xFFFF indicates ANY c-vid.";
            }
    
            leaf untagged {
              type boolean;
              default 'false';
              description
                "When set to true, this indicates that the test instance
              is to be associated with untagged data traffic. When this
              is set, the cvid and svid parameters must be 0.";
            }
    
            leaf dst-mac {
              type yang:mac-address;
              description
                "Destination MAC address to use for generator test instances. When set,
              this over writes the value specified in the referenced test profile.
              This field is not applicable for reflector test instances.";
            }
    
            leaf admin-state {
              type ciena:admin-state;
              default 'disabled';
              description
                "Indicates the administrative state of the test instance. 
              Upon enabling a test instance, resources are allocated in hardware. 
              For reflector test instances, this triggers the start of reflection 
              of any test traffic received that matches the specified vid 
              combination on the specified port/sub-port.";
            }
          }  // list test-instance
        }  // container sat
    
        container sat-state {
          config false;
          description
            "Operational data for SAT.";
          container sat-global {
            description
              "SAT global operational data.";
            leaf platform-max-config-entities {
              type uint16;
              description
                "Maximum number of entities that can be created on
              this platform.";
            }
    
            leaf platform-max-config-test-intancess {
              type uint16;
              description
                "Maximum number of test instances that can be created on
              this platform.";
            }
    
            leaf platform-max-config-test-profiles {
              type uint16;
              description
                "Maximum number of test profiles that can be created on
              this platform.";
            }
    
            leaf platform-max-config-kpi-profiles {
              type uint16;
              description
                "Maximum number of KPI profiles that can be created on
              this platform.";
            }
    
            leaf platform-max-config-bw-alloc-profiles {
              type uint16;
              description
                "Maximum number of bandwidth distribution profiles
              that can be created on this platform.";
            }
    
            leaf platform-max-config-emix-sequences {
              type uint16;
              description
                "Maximum number of EMIX sequences that can be created on
              this platform, including the system created ones.";
            }
    
            leaf platform-max-simultaneous-running-tests {
              type uint16;
              description
                "Maximum number of test instances that can be running
              simultaneously on this platform.";
            }
    
            leaf configured-entities {
              type uint16;
              description
                "Number of entities currently configured.";
            }
    
            leaf configured-test-intances {
              type uint16;
              description
                "Number of test instances currently configured.";
            }
    
            leaf configured-profiles {
              type uint16;
              description
                "Number of test profiles currently configured.";
            }
    
            leaf configured-emix-sequences {
              type uint16;
              description
                "Number of EMIX sequences currently configured, including
              the system created ones.";
            }
    
            leaf configured-kpi-profiles {
              type uint16;
              description
                "Number of KPI profiles currently configured.";
            }
    
            leaf configured-bw-alloc-profiles {
              type uint16;
              description
                "Number of bandwidth distribution profiles currently
              configured.";
            }
    
            leaf enabled-test-intancess {
              type uint16;
              description
                "Number of test instances currently enabled across
              the platform.";
            }
    
            leaf generator-running-test-intancess {
              type uint16;
              description
                "Number of generator test instances currently running
              across the platform.";
            }
          }  // container sat-global
    
          list entity {
            key "name";
            description
              "Operational data for entity.";
            leaf name {
              type name-string;
              description
                "Name of the service activation test entity.";
            }
    
            leaf id {
              type uint32;
              description
                "Entity unique ID assigned on creation by the system.";
            }
    
            leaf oper-state {
              type ciena:oper-state;
              description
                "Entity operational enable/disable. An entity
              is operationally enabled when the feature is
              enabled, the entity is enabled and at least one
              test instance associated with that entity is 
              enabled (reflector) or running (generator)";
            }
    
            leaf slot-id {
              type uint32;
              description
                "The slot Id of the line module associated with this entity.
              For non-distributed platforms or single card nodes, this is
              always 1.";
            }
    
            leaf local-mac {
              type yang:mac-address;
              description
                "Mac address assigned to the SAT entity.";
            }
    
            leaf max-config-test-instances {
              type uint16;
              description
                "Maximum number of test instances that can
              be configured on this entity.";
            }
    
            leaf max-simultaneous-test-instances {
              type uint16;
              description
                "Maximum number of test instances that can
              be enabled (reflector) or running (generator)
              on this entity, given the availability of 
              hw sessions.";
            }
    
            leaf num-test-instances-configured {
              type uint16;
              description
                "Number of test instances currently configured
              on this SAT entity.";
            }
    
            leaf num-test-instances-enabled {
              type uint16;
              description
                "Number of test instances currently enabled on this SAT entity.";
            }
    
            leaf gen-num-test-instances-running {
              type uint16;
              description
                "Number of test instances currently running on this generator entity. 
              This information is only valid for generator entities.";
            }
    
            leaf bw-available {
              type uint32;
              description
                "Bandwidth in Mbps, available for test traffic if a reflector. 
              Bandwidth remaining for other test instances to be started 
              if this is a generator SAT entity.";
            }
    
            leaf gen-bw-used-by-running-tests {
              type uint32;
              description
                "Bandwidth used by test instances
              currently running on this generator entity, in Mbps.";
            }
    
            leaf available-hw-sessions {
              type uint32;
              description
                "Maximum number of simultaneous hardware sessions available 
              on this SAT entity.";
            }
    
            leaf allocated-hw-sessions {
              type uint32;
              description
                "Number of hw sessions currently allocated to enabled test instances.";
            }
    
            container statistics {
              description
                "A collection of entity-related statistics objects.";
              leaf tx-bytes {
                type yang:counter64;
                description
                  "Number of bytes transmitted by the benchmark port";
              }
    
              leaf tx-pkts {
                type yang:counter64;
                description
                  "Number of packets transmitted by the benchmark port";
              }
    
              leaf rx-bytes {
                type yang:counter64;
                description
                  "Number of bytes received on the benchmark port.";
              }
    
              leaf rx-pkts {
                type yang:counter64;
                description
                  "Number of packets received on the benchmark port.";
              }
    
              leaf miss-class-pkts {
                type yang:counter64;
                description
                  "Test packets received that didn't match any enabled
                test session.";
              }
    
              leaf crc-err-pkts {
                type yang:counter64;
                description
                  "Test packets received with CRC errors";
              }
    
              leaf udp-chksum-err-pkts {
                type yang:counter64;
                description
                  "Test packets received with UDP checksum errors";
              }
            }  // container statistics
          }  // list entity
    
          list emix-sequence {
            key "name";
            description "Emix sequence.";
            leaf name {
              type name-string;
              description
                "Name of this EMIX sequence";
            }
    
            leaf id {
              type uint8 {
                range "1..32";
              }
              description
                "Unique Id of the EMIX sequence entry";
            }
    
            leaf num-of-ref {
              type uint16;
              description
                "Number of generator test profiles currently
              using this EMIX sequence for testing.
              If this is the default EMIX sequence
              set in the generator, that also counts
              as one reference.";
            }
    
            leaf user-created {
              type boolean;
              description
                "Flag indicating whether this sequence was 
              created by the user or by the system at
              initialization. Only user created sequences
              are editable.";
            }
          }  // list emix-sequence
    
          list gen-test-session-allocation {
            key "entity-name test-instance-name untagged pcp color";
            description
              "Test session (aka hardware session) allocation entry.
            If untagged is True, pcp and color are irrelevant.";
            leaf entity-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:entity/ciena-sat:name";
              }
              description "Name of entity.";
            }
    
            leaf test-instance-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-instance/ciena-sat:name";
              }
              description
                "Name of test instance.";
            }
    
            leaf untagged {
              type boolean;
              description "Untagged.";
            }
    
            leaf pcp {
              type priority;
              description "PCP value.";
            }
    
            leaf color {
              type basic-color;
              description
                "Color - green or yellow only.";
            }
    
            leaf session-id {
              type uint32 {
                range "0..127";
              }
              description
                "Id of the hardware session allocated to the given
              test instance, pcp and color for this entity.";
            }
    
            leaf emix-sequence-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:emix-sequence/ciena-sat:name";
              }
              description
                "EMIX sequence used with this session. If not set, 
              this indicates that the the frame size list is being used
              for the test and current-frame-size
              indicates which packet size is currently being tested.";
            }
    
            leaf current-frame-size {
              type uint32;
              description
                "Packet size in bytes currently used by the running test.";
            }
    
            leaf throughput-test-state {
              type throughput-test-state-type;
              description
                "State of the throughput test for this hardware session
              defined by the test instance, pcp and color";
            }
    
            leaf frameloss-test-state {
              type frameloss-test-state-type;
              description
                "State of the frameloss test for this hardware session
              defined by the test instance, pcp and color";
            }
    
            leaf latency-test-state {
              type latency-pdv-test-state-type;
              description
                "State of the latency test for this hardware session
              defined by the test instance, pcp and color";
            }
    
            leaf pdv-test-state {
              type latency-pdv-test-state-type;
              description
                "State of the PDV test for this hardware session
              defined by the test instance, pcp and color";
            }
    
            leaf rfc2544-test-state {
              type rfc2544-test-state-type;
              description
                "State of the RFC2544 test for this hardware session
              defined by the test instance, pcp and color";
            }
    
            leaf y1564-test-state {
              type y1564-test-state-type;
              description
                "State of the Y1564 test for this hardware session
              defined by the test instance, pcp and color";
            }
    
            leaf outage-test-state {
              type outage-test-state-type;
              description
                "State of the outage test for this hardware session
              defined by the test instance, pcp and color";
            }
    
            leaf num-outages-so-far {
              type uint32;
              description
                "Outages detected so far";
            }
    
            leaf outage-progress {
              type uint8;
              description
                "Percentage of outage test completed";
            }
    
            leaf current-rate {
              type uint32;
              description
                "Traffic rate currently used to generate packets as percent
              of the line rate";
            }
    
            leaf samples-completed {
              type uint32;
              description
                "When latency and/or pdv is running, this indicates how 
              many samples have been gathered so far.";
            }
          }  // list gen-test-session-allocation
    
          list test-instance-statistics {
            key "entity-name test-instance-name";
            description
              "Benchmark test instance packet statistics";
            leaf entity-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:entity/ciena-sat:name";
              }
              description "Entity name.";
            }
    
            leaf test-instance-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-instance/ciena-sat:name";
              }
              description "Test instance name.";
            }
    
            leaf rx-pkts {
              type yang:counter64;
              description
                "Total number of received packets for 
              this test instance.";
            }
    
            leaf rx-ipv4-pkts {
              type yang:counter64;
              description
                "Total number of IPv4 packets received for
              this test instance.";
            }
    
            leaf rx-ipv4-udp-pkts {
              type yang:counter64;
              description
                "Total number of IPv4 UDP packets received for
              this test instance.";
            }
    
            leaf rx-ipv6-pkts {
              type yang:counter64;
              description
                "Total number of IPv6 packets received for
              this test instance.";
            }
    
            leaf rx-ipv6-udp-pkts {
              type yang:counter64;
              description
                "Total number of IPv6 UDP packets received for
              this test instance.";
            }
    
            leaf rx-non-ip-pkts {
              type yang:counter64;
              description
                "Total number of non-IP packets received for
              this test instance.";
            }
    
            leaf rx-unrecognized-pkts {
              type yang:counter64;
              description
                "Total number of unrecognized packets received for
              this test instance.";
            }
    
            leaf rx-duplicate-pkts {
              type yang:counter64;
              description
                "Total number of packets received with a duplicate
              this test instance.";
            }
    
            leaf rx-duplicate-pkts-overflow {
              type boolean;
              description
                "When set to true, this indicates that the duplicate
              pkt counter has rolled over in hardware and therefore,
              rxDuplicate-pkts might not be accurate.";
            }
    
            leaf rx-ooo-pkts {
              type yang:counter64;
              description
                "Total number of packets received with an out of 
              order sequence number. The sequence number was less
              than the expected sequence number for this test instance.";
            }
    
            leaf rx-ooo-pkts-overflow {
              type boolean;
              description
                "When set to true, this indicates that the out of order
              pkt counter has rolled over in hardware and therefore,
              rxOOO-pkts might not be accurate.";
            }
    
            leaf rx-disc-seq-num-pkts {
              type yang:counter64;
              description
                "Total number of packets received with a sequence number
              greater then the expected sequence number for this test instance.";
            }
    
            leaf rx-disc-seq-num-pkts-overflow {
              type boolean;
              description
                "When set to true, this indicates that the discontinuity
              in sequence number pkt counter has rolled over in hardware
              and therefore, rxDiscSeqNum-pkts might not be accurate.";
            }
    
            leaf tx-pkts {
              type yang:counter64;
              description
                "Total number of packets transmitted for this test instance.";
            }
          }  // list test-instance-statistics
    
          list gen-test-session-throughput-results {
            key "entity-name test-instance-name untagged pcp color profile-frame-size-index";
            description
              "generator test session throughput results.
            If untagged is True, pcp and color are irrelevant.";
            leaf entity-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:entity/ciena-sat:name";
              }
              description "Entity name.";
            }
    
            leaf test-instance-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-instance/ciena-sat:name";
              }
              description "Test instance name.";
            }
    
            leaf untagged {
              type boolean;
              description "Untagged.";
            }
    
            leaf pcp {
              type priority;
              description "PCP value";
            }
    
            leaf color {
              type basic-color;
              description
                "Color - green or yellow only.";
            }
    
            leaf profile-frame-size-index {
              type uint8 {
                range "0..9";
              }
              description
                "Frame size index for which those throughput results are
              for. When EMIX is used, in which case emix-sequence is 
              not NULL, there is only one frame size index for
              the given test instance, pcp and color. In such a case, the 
              frame size index will be 0 and frame size will also be 0.";
            }
    
            leaf frame-size {
              type uint32;
              description
                "Packet size in bytes. If 0, then the emix-sequence indicates 
              the name of the EMIX sequence used for the test";
            }
    
            leaf emix-sequence {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:emix-sequence/ciena-sat:name";
              }
              description
                "ID of the EMIX sequence that was used for running the
              test which produced these results. When 0,
              frame size indicates the size of the test frame
              associated with these results.";
            }
    
            leaf min {
              type throughput-result;
              description
                "Minimum throughput recorded for the given packet size 
              in Mbps * 100. The value is multiplied by 100 to be able
              to send the results as an integer but should be divided
              by 100 when displayed to provide a 2 decimal point accuracy.
              A result of 123.45 is sent as 12345.";
            }
    
            leaf max {
              type throughput-result;
              description
                "Maximum throughput recorded for the given packet size
              in Mbps * 100. The value is multiplied by 100 to be able
              to send the results as an integer but should be divided
              by 100 when displayed to provide a 2 decimal point accuracy.
              A result of 123.45 is sent as 12345.";
            }
    
            leaf avg {
              type throughput-result;
              description
                "Average throughput recorded for the given packet size
              in Mbps * 100. The value is multiplied by 100 to be able
              to send the results as an integer but should be divided
              by 100 when displayed to provide a 2 decimal point accuracy.
              A result of 123.45 is sent as 12345.";
            }
    
            leaf iterations {
              type uint32;
              description
                "Number of times the test has been run for this packet size.";
            }
    
            leaf kpi-result {
              type kpi-result-type;
              description
                "Pass or fail results for the test which is determined
              by comparing the max throughput against the selected 
              KPI test instance's throughput pass criteria. If no KPI test instance
              is selected for the given test instance Id, the result will
              be 'notApplicable'.";
            }
          }  // list gen-test-session-throughput-results
    
          list gen-test-session-frameloss-results {
            key "entity-name test-instance-name untagged pcp color profile-frame-size-index rate-index";
            description
              "generator test session frameloss results.
            If untagged is True, pcp and color are irrelevant.";
            leaf entity-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:entity/ciena-sat:name";
              }
              description "Entity name.";
            }
    
            leaf test-instance-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-instance/ciena-sat:name";
              }
              description "Test instance name.";
            }
    
            leaf untagged {
              type boolean;
              description "Untagged.";
            }
    
            leaf pcp {
              type priority;
              description "PCP value.";
            }
    
            leaf color {
              type basic-color;
              description
                "Color - green or yellow only.";
            }
    
            leaf profile-frame-size-index {
              type uint8 {
                range "0..9";
              }
              description "Frame size index.";
            }
    
            leaf rate-index {
              type uint8 {
                range "0..9";
              }
              description "Rate index.";
            }
    
            leaf frame-size {
              type uint32;
              description
                "Packet size in bytes. If 0, then the emix-sequence
              indicates the name of the EMIX sequence used for the test";
            }
    
            leaf emix-sequence {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:emix-sequence/ciena-sat:name";
              }
              description
                "EMIX sequence that was used for running the
              test which produced these results. When not set,
              frame size indicates the size of the test frame
              associated with these results.";
            }
    
            leaf rate {
              type uint32;
              description
                "Rate in percent of line rate.";
            }
    
            leaf first {
              type frameloss-result;
              description
                "Percentage of frames lost on first test sequence.";
            }
    
            leaf second {
              type frameloss-result;
              description
                "Percentage of frames lost on second test sequence.";
            }
    
            leaf kpi-result {
              type kpi-result-type;
              description
                "Pass or fail results for the test which is determined
              by comparing the frameloss result against the selected 
              KPI test instance's frameloss pass criteria. If no KPI test instance
              is selected for the given test instance Id, the result will
              be 'notApplicable'.";
            }
    
            leaf result {
              type frameloss-result;
              description
                "Percentage of frames lost on the largest test sequence results.";
            }
          }  // list gen-test-session-frameloss-results
    
          list gen-test-session-latency-results {
            key "entity-name test-instance-name untagged pcp color profile-frame-size-index";
            description
              "generator test session latency results.
            If untagged is True, pcp and color are irrelevant.";
            leaf entity-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:entity/ciena-sat:name";
              }
              description "Entity name.";
            }
    
            leaf test-instance-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-instance/ciena-sat:name";
              }
              description
                "Automagically generated leafref leaf.";
            }
    
            leaf untagged {
              type boolean;
              description "Untagged.";
            }
    
            leaf pcp {
              type priority;
              description "PCP value.";
            }
    
            leaf color {
              type basic-color;
              description
                "Color - green or yellow only.";
            }
    
            leaf profile-frame-size-index {
              type uint8 {
                range "0..9";
              }
              description "Frame size index.";
            }
    
            leaf frame-size {
              type uint32;
              description
                "Packet size in bytes.";
            }
    
            leaf emix-sequence {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:emix-sequence/ciena-sat:name";
              }
              description
                "Name of the EMIX sequence that was used for running the
              test which produced these results. When not set,
              frame size indicates the size of the test frame
              associated with these results.";
            }
    
            leaf min {
              type uint32;
              description
                "Minimum latency recorded for the given packet size.";
            }
    
            leaf max {
              type uint32;
              description
                "Maximum latency recorded for the given packet size.";
            }
    
            leaf avg {
              type uint32;
              description
                "Average latency recorded for the given packet size.";
            }
    
            leaf samples {
              type uint32;
              description
                "Number of samples taken during the test.";
            }
    
            leaf kpi-result {
              type kpi-result-type;
              description
                "Pass or fail results for the test which is determined
              by comparing the frameloss result against the selected 
              KPI test instance's latency pass criteria. If no KPI test instance
              is selected for the given test instance Id, the result will
              be 'notApplicable'.";
            }
          }  // list gen-test-session-latency-results
    
          list gen-test-session-pdv-results {
            key "entity-name test-instance-name untagged pcp color frame-size-index";
            description
              "generator test session packet delay variation results.
            If untagged is True, pcp and color are irrelevant.";
            leaf entity-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:entity/ciena-sat:name";
              }
              description "Entity name.";
            }
    
            leaf test-instance-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-instance/ciena-sat:name";
              }
              description "Test instance name.";
            }
    
            leaf untagged {
              type boolean;
              description "Untagged.";
            }
    
            leaf pcp {
              type priority;
              description "PCP value.";
            }
    
            leaf color {
              type basic-color;
              description
                "Color - green or yellow only.";
            }
    
            leaf frame-size-index {
              type uint8 {
                range "0..9";
              }
              description
                "Frame size index associated with these PDV stats.";
            }
    
            leaf frame-size {
              type uint32;
              description
                "Packet size in bytes.";
            }
    
            leaf emix-sequence {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:emix-sequence/ciena-sat:name";
              }
              description
                "Name of the EMIX sequence that was used for running the
              test which produced these results. When not set,
              frame size indicates the size of the test frame
              associated with these results.";
            }
    
            leaf avg {
              type uint32;
              description
                "Average PDV recorded for the given packet size.";
            }
    
            leaf samples {
              type uint32;
              description
                "Number of samples used for the test.";
            }
    
            leaf kpi-result {
              type kpi-result-type;
              description
                "Pass or fail results for the test which is determined
              by comparing the frameloss result against the selected 
              KPI test instance's throughput PDV criteria. If no KPI test instance
              is selected for the given test instance Id, the result will
              be 'notApplicable'.";
            }
          }  // list gen-test-session-pdv-results
    
          list gen-test-session-outage-results {
            key "entity-name test-instance-name untagged pcp color frame-size-index";
            description
              "generator test session frameloss results.
            If untagged is True, pcp and color are irrelevant.";
            leaf entity-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:entity/ciena-sat:name";
              }
              description "Entity name.";
            }
    
            leaf test-instance-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-instance/ciena-sat:name";
              }
              description "Test instance name.";
            }
    
            leaf untagged {
              type boolean;
              description "Untagged.";
            }
    
            leaf pcp {
              type priority;
              description "PCP value.";
            }
    
            leaf color {
              type basic-color;
              description
                "Color - green or yellow only.";
            }
    
            leaf frame-size-index {
              type uint8 {
                range "0..9";
              }
              description
                "Frame size index associated with these PDV stats.";
            }
    
            leaf frame-size {
              type uint32;
              description
                "Packet size in bytes.";
            }
    
            leaf emix-sequence {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:emix-sequence/ciena-sat:name";
              }
              description
                "Name of the EMIX sequence that was used for running the
              test which produced these results. When not set,
              frame size indicates the size of the test frame
              associated with these results.";
            }
    
            leaf outage-test-start-time {
              type yang:date-and-time;
              description
                "Date and time this outage test was started.";
            }
    
            leaf outage-test-end-time {
              type yang:date-and-time;
              description
                "Date and time this outage test ended.";
            }
    
            leaf total-outages {
              type uint32;
              description
                "Total number of outages, both recorded and unrecorded.";
            }
    
            leaf recorded-outages {
              type uint32;
              description
                "Number of recorded outages with detailed statistics.";
            }
    
            leaf sum-total-outages {
              type uint64;
              units "microseconds";
              description
                "Sum of total outages, both recorded and unrecorded.";
            }
    
            leaf sum-recorded-outages {
              type uint64;
              units "microseconds";
              description
                "Sum of recorded outages.";
            }
    
            leaf average-throughput {
              type throughput-result;
              description
                "Average throughput recorded in Mbps * 100. 
              The value is multiplied by 100 to be able
              to send the results as an integer but should be divided
              by 100 when displayed to provide a 2 decimal point accuracy.
              A result of 123.45 is sent as 12345.";
            }
    
            leaf overall-kpi-result {
              type kpi-result-type;
              description
                "Overall Pass or fail result for the test. 
              FAIL if either sum-outages-kpi-result or 
              max-outages-kpi-result or ANY of the single outage
              kpi-result leaves are FAIL.
              If no KPI instance is selected for the given 
              test instance Id, the result will be 'notApplicable'.";
            }
    
            leaf sum-outages-kpi-result {
              type kpi-result-type;
              description
                "Fail if the sum of recorded outages exceeds
              the maximum KPI specified.
              If no KPI test instance is selected for the given 
              test instance Id, the result will be 'notApplicable'.";
            }
    
            leaf max-outages-kpi-result {
              type kpi-result-type;
              description
                "Fail if the total number of outages exceeds
              the maximum KPI specified.
              If no KPI test instance is selected for the given 
              test instance Id, the result will be 'notApplicable'.";
            }
    
            list per-outage {
              key "outage-index";
              description
                "Each of the first 128 outages has its own details.";
              leaf outage-index {
                type uint8 {
                  range "1..128";
                }
                description
                  "Index of this individual outage entry";
              }
    
              leaf start-time {
                type yang:date-and-time;
                description
                  "Date and time this individual outage began.";
              }
    
              leaf end-time {
                type yang:date-and-time;
                description
                  "Date and time this individual outage ended.";
              }
    
              leaf length {
                type uint64;
                units "microseconds";
                description
                  "Length of this individual outage in usecs.";
              }
    
              leaf frames-dropped {
                type uint64;
                description
                  "Number of frames dropped during this outage.";
              }
    
              leaf kpi-result {
                type kpi-result-type;
                description
                  "Pass or fail results for the test which is determined
                by comparing the duration against the selected KPI
                test instance's single outage duration pass criteria. 
                If no KPI test instance is selected for the given test 
                instance Id, the result will be 'notApplicable'.";
              }
            }  // list per-outage
          }  // list gen-test-session-outage-results
    
          list emix-character-set {
            key "index";
            description
              "EMIX character and its associated frame size.";
            leaf index {
              type uint8 {
                range "1..26";
              }
              description "Character index.";
            }
    
            leaf character {
              type string {
                length "1";
              }
              description
                "EMIX character that can be used for creating an EMIX sequence.
              The character set currently includes: a b c d e f g h u v w x  ";
            }
    
            leaf frame-size {
              type string {
                length "1..6";
              }
              description
                "Frame size associated with the character. For h, the frame size
              is the port under test's MTU and the u character is a custom
              frame size configurable for each EMIX. The u frame size can take 
              a value of 64 to 10000 and defaults to 594. If u is bigger than
              the MTU of the port under test, it will be reduced to the same
              size as h.";
            }
          }  // list emix-character-set
    
          list emix-frame-size-for-sat-entity {
            key "entity-name emix-sequence";
            description
              "Frame size associated with given EMIX 
            sequence and frame size index on a given Entity";
            leaf entity-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:entity/ciena-sat:name";
              }
              description "Entity name.";
            }
    
            leaf emix-sequence {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:emix-sequence/ciena-sat:name";
              }
              description "Emix sequence name.";
            }
    
            leaf-list emix-frame-size {
              type uint32 {
                range "64..9216";
              }
              description
                "List of Frame sizes associated with the letters 
              in the EMIX sequence.";
            }
    
            leaf avg-frame-size {
              type uint32 {
                range "64..9216";
              }
              description
                "Average frame size for the EMIX sequence on this entity.";
            }
          }  // list emix-frame-size-for-sat-entity
    
          list kpi-profile {
            key "name";
            description
              "Key performance indicator pass/fail criteria.";
            leaf name {
              type name-string;
              description
                "Name of the KPI profile";
            }
    
            leaf id {
              type uint32 {
                range "1..32";
              }
              description
                "Unique Id of the KPI profile entry";
            }
    
            leaf num-of-ref {
              type uint32;
              description
                "Number of generator test profiles currently
              using this KPI profile for results analysis.
              If this is the default KPI profile set in
              the generator, that also counts as one reference.";
            }
          }  // list kpi-profile
    
          list bw-alloc-profile {
            key "name";
            description
              "BW allocation profile operational data.";
            leaf name {
              type name-string;
              description
                "Name of the bandwidth allocation profile";
            }
    
            leaf id {
              type uint32 {
                range "1..32";
              }
              description
                "Unique Id of the bandwidth allocation
              profile entry";
            }
    
            leaf num-of-ref {
              type uint32;
              description
                "Number of generator test profiles currently
              using this bandwidth allocation profile
              for testing.
              If this is the default BW allocation
              profile set in the generator, that also counts
              as one reference.";
            }
          }  // list bw-alloc-profile
    
          list test-profile {
            key "name";
            description
              "Operational data for each test profile.";
            leaf name {
              type name-string;
              description
                "Name of the test profile";
            }
    
            leaf id {
              type uint32 {
                range "1..256";
              }
              description
                "index for test profile records.";
            }
    
            leaf hw-sessions-required {
              type uint32;
              description
                "This represents the number of hardware sessions 
              required to enable/run a test instance using 
              this profile according to the profile's current
              configuration.
              One hardware session is required for each outer tag
              PCP and color configured.
              Ex 1) Encap type set to dot1q, c-pcp is 0,3 and 
                    c-color is set to green, 2 PCPs * 1 color =
                    2 hw sessions.
              Ex 2) Encap type set to qinq, s-pcp is 0,4,5 and
                    s-color is set to green-yellow, then you
                    need 3 PCPs * 2 colors = 6 hw sessions.
              Ex 3) Encap type set to untagged, only 1 hw session
                    is required.";
            }
    
            leaf num-of-ref {
              type uint32;
              description
                "Number of generator test instances currently
              using this test profile for testing.";
            }
          }  // list test-profile
    
          list test-instance {
            key "name";
            description
              "Operational data for a test instance.";
            leaf name {
              type name-string;
              description
                "Name of the test instance";
            }
    
            leaf id {
              type uint32 {
                range "1..1280";
              }
              config false;
              description
                "Unique identifier for the test instance.";
            }
    
            leaf current-interval {
              type uint32;
              description
                "Applicable to generator test instances, this indicates the 
              number of intervals of the selected tests have been run, 
              including the current one, in relation to the total number of
              intervals to complete. This is based on the profile's
              interval and duration configured.";
            }
    
            leaf total-intervals {
              type uint32;
              description
                "Applicable to generator test instances, this indicates the 
              total number of intervals of the selected tests to be run
              by a single start command on the test instance. This is 
              based on the profile's interval and duration configured.
              A value of 0 should be interpreted as unknown and -1 as
              indefinite.";
            }
    
            leaf last-iteration-start-timestamp {
              type yang:date-and-time;
              description
                "Date and time of the last iteration that started since the 
              last time the system was rebooted or the statistics were
              cleared on the test instance.";
            }
    
            leaf assoc-entity {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:entity/ciena-sat:name";
              }
              description
                "Name of the entity this test instance is associated with.";
            }
    
            leaf oper-state {
              type ciena:oper-state;
              description
                "Test instance operational enable/disable.";
            }
    
            leaf active-s-vid {
              type uint32;
              description
                "Active s-vid that is used by the Test-Instance. 
             For Generator: it is user supplied vtag-stack when the 
             test instance is created OR if not supplied, the value
             configured in the test profile.
             For Reflector: The active s-vid is provided on create 
             Test-Instance, if not * or untagged 0 means not configured,
             and FFFF means any s-vid.";
            }
    
            leaf active-c-vid {
              type uint32;
              description
                "Active c-vid that is used by the Test-Instance. 
             For Generator: it is user supplied vtag-stack when the 
             test instance is created OR if not supplied, the value
             configured in the test profile.
             For Reflector: The active c-vid is provided on create 
             Test-Instance, if not * or untagged 0 means not configured,
             and FFFF means any c-vid.";
            }
    
            leaf active-untagged-data {
              type boolean;
              description
                "When set to true, this indicates that the test instance
              is associated with untagged data traffic. When this is 
              set, the active-s-vid and active-c-vid parameters are 0.";
            }
    
            leaf active-dst-mac {
              type yang:mac-address;
              description
                " Destination MAC address used for generator test 
              instances. When set, this over writes the value 
              specified in the referenced test profile.This 
              field is not applicable for reflector TI.";
            }
    
            leaf active-start-bw {
              type uint32;
              description
                "Port Under Test's max bandwidth, if RFC-2544 is 
              set in bandwidth profile, else bandwidth specified 
              in bandwidth profile. This field is not applicable
              for reflector TI.";
            }
          }  // list test-instance
        }  // container sat-state
    
        rpc entity-clear-statistics {
          description
            "Clear the statistics/counters of the targeted SAT entity.";
          input {
            leaf entity-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:entity/ciena-sat:name";
              }
              mandatory true;
              description
                "Name of a SAT entity to clear counters for. A reflector SAT entity
               has to be disabled in order to be able to clear its counters. A
               generator SAT entity cannot have any running test instances for 
               a request to clear its counters to be successful.";
            }
          }
    
          output {
            leaf status {
              type string;
              description
                "Status of the clear statistics operation.";
            }
          }
        }  // rpc entity-clear-statistics
    
        rpc test-instance-start {
          description
            "Start testing for the targeted generator test instance.";
          input {
            leaf test-instance-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-instance/ciena-sat:name";
              }
              mandatory true;
              description
                "Name of the generator test instance for which to initiate testing.";
            }
          }
    
          output {
            leaf status {
              type string;
              description
                "Status of the start test operation.";
            }
          }
        }  // rpc test-instance-start
    
        rpc test-instance-stop {
          description
            "Stop testing for the targeted generator test instance.";
          input {
            leaf test-instance-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-instance/ciena-sat:name";
              }
              mandatory true;
              description
                "Name of the generator test instance for which to abort testing.";
            }
          }
    
          output {
            leaf status {
              type string;
              description
                "Status of the stop test operation.";
            }
          }
        }  // rpc test-instance-stop
    
        rpc test-instance-connectivity-test {
          description
            "Perform a connectivity test for the targeted generator test instance.";
          input {
            leaf test-instance-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-instance/ciena-sat:name";
              }
              mandatory true;
              description
                "Name of the generator test instance targeted by this action.";
            }
          }
    
          output {
            leaf status {
              type string;
              description
                "Status of the trigger test operation.";
            }
          }
        }  // rpc test-instance-connectivity-test
    
        rpc test-instance-clear-statistics {
          description
            "Clear the results and counters for the targeted test instance.";
          input {
            leaf test-instance-name {
              type leafref {
                path "/ciena-sat:sat/ciena-sat:test-instance/ciena-sat:name";
              }
              mandatory true;
              description
                "Name of the test instance targeted by this action. Reflector test
               instances have to be disabled prior to clearing their counters,
               and geneartor test instances cannot be running tests.";
            }
          }
    
          output {
            leaf status {
              type string;
              description
                "Status of the clear statistics operation.";
            }
          }
        }  // rpc test-instance-clear-statistics
    
        notification test-started {
          description
            "Testing for this generator test instance has been initiated.";
          uses notification-base-fields;
    
          leaf port {
            type mef-logical-port:logical-port-ref;
            description "port under test.";
          }
    
          leaf svid {
            type ieee:vlanid;
            description "S-VID.";
          }
    
          leaf cvid {
            type ieee:vlanid;
            description "C-VID.";
          }
    
          leaf dst-mac {
            type yang:mac-address;
            description "Mac address.";
          }
        }  // notification test-started
    
        notification test-stopped {
          description
            "Testing for this generator test instance has been stopped.";
          uses notification-base-fields;
        }  // notification test-stopped
    
        notification test-completed {
          description
            "Testing for this generator test instance has completed.";
          uses notification-base-fields;
        }  // notification test-completed
    
        notification test-iteration-completed {
          description
            "Testing for this generator test instance has completed.";
          uses notification-base-fields;
    
          leaf iteration {
            type uint32;
            description "iteration.";
          }
        }  // notification test-iteration-completed
    
        notification test-throughput-kpi-failure {
          description
            "This generator test instance's iteration throughput results are 
           below the set KPI value.";
          uses notification-test-kpi-fields;
    
          leaf throughput-result {
            type uint32;
            description
              "Maximum throughput recorded for the given packet size
             in Mbps * 100. The value is multiplied by 100 to be able
             to send the results as an integer but should be divided
             by 100 when displayed to provide a 2 decimal point accuracy.
             A result of 123.45 is sent as 12345.";
          }
        }  // notification test-throughput-kpi-failure
    
        notification test-frameloss-kpi-failure {
          description
            "This generator test instance's iteration frameloss results are 
           above the set KPI value.";
          uses notification-test-kpi-fields;
    
          leaf frameloss-result {
            type uint32;
            description
              "Frame loss results in Percent of frame loss start bandwidth
             are sent as unsigned integer multitplied by 100 to provide a
             2 decimal point accuracy.
             If result is 12.34 %, it is sent as 1234 and should
             be divided by 100 by the application retrieving the
             data.";
          }
        }  // notification test-frameloss-kpi-failure
    
        notification test-latency-kpi-failure {
          description
            "This generator test instance's iteration latency results are 
           above the set KPI value.";
          uses notification-test-kpi-fields;
    
          leaf latency-result {
            type uint32;
            description
              "Maximum latency recorded for the given packet size.";
          }
        }  // notification test-latency-kpi-failure
    
        notification test-pdv-kpi-failure {
          description
            "This generator test instance's iteration packet delay variation 
           results are above the set KPI value.";
          uses notification-test-kpi-fields;
    
          leaf pdv-result {
            type uint32;
            description
              "Average PDV recorded for the given packet size.";
          }
        }  // notification test-pdv-kpi-failure
    
        notification test-outage-max-number-kpi-failure {
          description
            "This generator test instance's outage results do not
           meet the set KPI values for max number of outages.";
          uses notification-test-kpi-fields;
    
          leaf num-outages {
            type uint32;
            description
              "Number of outages that occurred during the outage test.";
          }
        }  // notification test-outage-max-number-kpi-failure
    
        notification test-outage-single-outage-kpi-failure {
          description
            "This generator test instance's iteration outage
           results do not meet the set KPI values.";
          uses notification-test-kpi-fields;
    
          leaf single-outage-max-duration {
            type uint64;
            units "microseconds";
            description
              "Length of maximum individual outage in usecs.";
          }
        }  // notification test-outage-single-outage-kpi-failure
    
        notification test-outage-sum-outages-kpi-failure {
          description
            "This generator test instance's outage results do not
           meet the set KPI values for max time of total recorded outages.";
          uses notification-test-kpi-fields;
    
          leaf sum-recorded-outages {
            type uint64;
            units "microseconds";
            description
              "Time in micro-seconds of the sum of recorded outages.";
          }
        }  // notification test-outage-sum-outages-kpi-failure
      }  // module ciena-sat
    

© 2023 YumaWorks, Inc. All rights reserved.