path: root/actn-interface-tools/actn-model/src/main/yang/ietf-service-pm@2020-07-13.yang

module ietf-service-pm {
  yang-version 1.1;

  namespace "urn:ietf:params:xml:ns:yang:ietf-service-pm";
  prefix "svc-pm";

  import ietf-eth-tran-service {
    prefix "ethtsvc";
  }

  import ietf-yang-types {
    prefix "yang";
  }

  import ietf-trans-client-service {
    prefix "clntsvc";
  }

  organization
    "Internet Engineering Task Force (IETF) CCAMP WG";
  contact
    "
      WG List: <mailto:ccamp@ietf.org>
      ID-draft editor:
        Haomian Zheng (zhenghaomian@huawei.com);
        Italo Busi (italo.busi@huawei.com);
        Yanlei Zheng (zhengyanlei@chinaunicom.cn);
    ";

  description
    "This module defines the performance monitoring for Ethernet
     services. The model fully conforms to the Network Management
     Datastore Architecture (NMDA).

     Copyright (c) 2020 IETF Trust and the persons
     identified as authors of the code.  All rights reserved.
     Redistribution and use in source and binary forms, with or
     without modification, is permitted pursuant to, and subject
     to the license terms contained in, the Simplified BSD License
     set forth in Section 4.c of the IETF Trust's Legal Provisions
     Relating to IETF Documents
     (https://trustee.ietf.org/license-info).
     This version of this YANG module is part of RFC XXXX; see
     the RFC itself for full legal notices.";

  revision 2020-07-13 {
    description
      "Initial version";
    reference
      "ADD REFERENCE HERE";
  }

  typedef performance-parameter-value {
    type union {
      type uint32;
      type uint64;
      type decimal64 {
        fraction-digits 6;
      }
      type string;
    }
    description
      "A performance parameter value.";
  }

  grouping service-performance-monitor-set{
    description "the set of parameter name, value and description.";
    leaf parameter-name{
      type identityref {
        base performance-parameter-type;
      }
      description
        "The name of parameters to be monitored.
         For example, latency, Bit Error Rate, Bandwidth and so on.";
    }
    list parameter-value {
      key index;
      description
        "The table of values of the performance and
        their descriptions.";
      leaf index {
        type uint64;
        description
          "Used for list index";
      }
      leaf value {
        type performance-parameter-value;
        mandatory true;
        description
          "The value of the parameter. ";
      }
      leaf value-unit {
        type string;
        mandatory true;
        description
          "The value unit of the parameter.
           For example, second, minute and so on.";
      }
      leaf etht-svc-end-point {
        when "../../../service-name = "
        + "/ethtsvc:etht-svc/ethtsvc:etht-svc-instances/ethtsvc:etht-svc-name";
          type leafref {
            path "/ethtsvc:etht-svc/ethtsvc:etht-svc-instances"
               + "/ethtsvc:etht-svc-end-points/ethtsvc:etht-svc-end-point-name";
          } 
        description
          "Reference to the Ethernet service end point
           at which this performance parameter is monitored.";
      }
      leaf value-description{
        type string;
        description
          "The description of previous value. ";
      }
      leaf start-time {
        type yang:date-and-time;
        description
          "The time stamp when the parameter is started.";
      }
      leaf end-time {
        type yang:date-and-time;
        description
          "The time stamp when the parameter is ended.";
      }
    }
  }

  identity performance-parameter-type {
    description
      "Base type of the performance parameter being monitored.";
  }

  identity near-frame-loss {
    base performance-parameter-type;
    description
      "Near frame loss, using one-way eth loss measure,
       the sampling point is the MEP.";
  }

  identity far-frame-loss {
    base performance-parameter-type;
    description
      "Far frame loss, using one-way eth loss measure,
       the sampling point is the MEP.";
  }

  identity one-way-delay {
    base performance-parameter-type;
    description
      "One way delay.";
  }

  identity two-way-delay {
    base performance-parameter-type;
    description
      "Two way delay.";
  }

  identity receive-packets {
    base performance-parameter-type;
    description
      "Total number of received packets.";
  }

  identity transmit-packets {
    base performance-parameter-type;
    description
      "Total number of transmitted packets.";
  }

  identity ingress-bandwidth {
    base performance-parameter-type;
    description
      "Current bandwidth usage of the ingress traffic.";
  }

  identity egress-bandwidth {
    base performance-parameter-type;
    description
      "Current bandwidth usage of the egress traffic.";
  }

  identity alarm-status {
    description "indicates whether there is alarm or not";
  }
  identity alarm {
    base alarm-status;
    description "There is one or multiple alarms from the monitor. ";
  }

  identity no-alarm {
    base alarm-status;
    description "There is no alarms from the monitor. ";
  }

  identity monitoring-state {
    description
      "The state of performance monitoring. ";
  }

  identity monitoring {
    base monitoring-state;
    description "The Ethernet client signal is under monitoring. ";
  }

  identity monitor-finished {
    base monitoring-state;
    description
      "The monitoring of Ethernet client signal is finished. ";
  }

  identity monitor-failed {
    base monitoring-state;
    description
      "The monitoring of Ethernet client signal is failed. ";
  }

  identity granularity-type {
    description
      "Monitoring granularity";
  }

  identity granularity-1min {
    base granularity-type;
    description
      "1 minute";
  }

  identity granularity-15min {
    base granularity-type;
    description
      "15 minutes";
  }
  identity granularity-24h {
    base granularity-type;
    description
      "24 hours";
  }

  identity measure-method {
    description "Measure method.";
  }

  identity measure-by-loopback {
    base measure-method;
    description "Loopback measure method.";
  }

  identity measure-at-ingress {
    base measure-method;
    description "Ingress measure method.";
  }

  container performance-monitoring {
    description
      "This part is for performance monitoring. ";
    list service-pm {
      key "service-name";
      description
        "The list of service to be monitored.";
      leaf service-name {
        mandatory true;
        type leafref {
           path "/ethtsvc:etht-svc/ethtsvc:etht-svc-instances"
              + "/ethtsvc:etht-svc-name";
        }
        /** FIXME: DECHENG leafref under union not supported
        type union {
          type leafref {
            path "/ethtsvc:etht-svc/ethtsvc:etht-svc-instances"
               + "/ethtsvc:etht-svc-name";
          }
          type leafref {
            path "/clntsvc:client-svc/clntsvc:client-svc-instances"
               + "/clntsvc:client-svc-name";
          }
        }
        **/
        description "The name of service.";
      }

      leaf task-pm-enable {
        type boolean;
        description
          "Indicate whether the performance monitoring
          is enable or not.";
      }

      leaf granularity {
        type identityref {
          base granularity-type;
        }
        description
          "Monitoring granularity";
      }

      list performance-data-config {
        key parameter-name;
        description
          "Specify the performance parameters to be queried";

        leaf parameter-name {
          type identityref {
            base performance-parameter-type;
          }
          description
            "The name of parameters to be monitored.
             For example, latency, BER, Bandwidth and so on.";
        }
        leaf measure-method {
          type identityref {
            base measure-method;
          }
        }
      }

      container service-pm-state {
        config false;
        description
          "The state of service performance monitoring.";

        container oam-state {
          leaf cc-state {
            mandatory true;
            type enumeration {
              enum up;
              enum down;
            }
          }
          leaf lm-state {
            type enumeration {
              enum up;
              enum down;
            }
          }
          leaf dm-state {
            type enumeration {
              enum up;
              enum down;
            }
          }
        }

        list performance-data{
          key parameter-name;
          description "The list of performance under monitor.";
          uses service-performance-monitor-set;
        }

        leaf monitor-state {
          mandatory true;
          type identityref {
            base monitoring-state;
          }
          description "The status of performance monitoring. ";
        }

        container error-info {
          description
            "Describe the error message.";
          leaf error-code {
            type uint32;
            description
              "The code of error.";
          }
          leaf error-message {
            type string;
            description
              "The message of error.";
          }
        }

        container alarm {
          description
            "To retrieve the Alarm during performance Monitoring.";
          leaf status {
            type identityref {
              base alarm-status;
            }
            description "The status of the alarm. ";
          }
        }
      }
    }
  }

}