module ciena-mef-egress-qos {

    yang-version 1;

    namespace
      "urn:ciena:params:xml:ns:yang:ciena-pn::ciena-mef-egress-qos";

    prefix mef-egress-qos;

    import ciena-mef-logical-port {
      prefix mef-logical-port;
    }

    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 configuration of
queues and schedulers for Egress QoS.";

    revision "2017-10-23" {
      description
        "Added missed references and descriptions";
      reference
        "RFC 6020: YANG - A Data Modeling Language for
        the Network Configuration Protocol (NETCONF).
        No specific reference; standard not available.";

    }

    revision "2016-02-09" {
      description "Initial version";
      reference
        "RFC 6020: YANG - A Data Modeling Language for
        the Network Configuration Protocol (NETCONF).
        No specific reference; standard not available.";

    }


    typedef cos-queue-map-ref {
      type leafref {
        path "/mef-egress-qos:egress-qos/mef-egress-qos:cos-queue-map/mef-egress-qos:name";
      }
      description
        "This type is used by the data models that needs to reference
configured CoS queue maps.";
    }

    typedef congestion-avoidance-profile-ref {
      type leafref {
        path "/mef-egress-qos:egress-qos/mef-egress-qos:congestion-avoidance-profile/mef-egress-qos:name";
      }
      description
        "This type is used by the data models that needs to reference
configured congestion avoidance profiles.";
    }

    typedef queue-group-profile-ref {
      type leafref {
        path "/mef-egress-qos:egress-qos/mef-egress-qos:queue-group-profile/mef-egress-qos:name";
      }
      description
        "This type is used by the data models that needs to reference
configured queue group profiles.";
    }

    typedef queue-group-indirection-ref {
      type leafref {
        path "/mef-egress-qos:egress-qos/mef-egress-qos:queue-group-indirection/mef-egress-qos:name";
      }
      description
        "This type is used by the data models that needs to reference
queue-groups indirectly (e.g. where the root port changes dynamically).";
    }

    typedef scheduler-profile-ref {
      type leafref {
        path "/mef-egress-qos:egress-qos/mef-egress-qos:scheduler-profile/mef-egress-qos:name";
      }
      description
        "This type is used by the data models that needs to reference
configured scheduler-profiles.";
    }

    typedef scheduler-ref {
      type leafref {
        path "/mef-egress-qos:egress-qos/mef-egress-qos:scheduler/mef-egress-qos:name";
      }
      description
        "This type is used by the data models that needs to reference
configured scheduler.";
    }

    typedef queue-group-ref {
      type leafref {
        path "/mef-egress-qos:egress-qos/mef-egress-qos:queue-group/mef-egress-qos:name";
      }
      description
        "This type is used by the data models that needs to reference
queue-group-instances directly (e.g. where the root port changes dynamically).";
    }

    container egress-qos {
      description
        "List of egress qos configurations.";
      list cos-queue-map {
        key "name";
        description
          "List of cos queue maps.";
        leaf name {
          type string;
          description
            "Name for the CoS queue map.";
        }

        leaf cos-count {
          type uint32;
          description
            "Number of CoS values supported (e.g. 8 or 64)";
        }

        list map-entry {
          key "cos";
          description
            "List of cos map entries.";
          leaf cos {
            type uint32 {
              range "0..63";
            }
            description
              "Internal CoS to use for mapping to a Queue, green-wred-curve and yellow-wred curve.";
          }

          leaf queue {
            type uint32;
            description
              "Queue mapped to by internal CoS";
          }

          leaf green-wred-curve {
            type uint32;
            description
              "WRED curve relative to a Queue to use for traffic whose internal color is Green.";
          }

          leaf yellow-wred-curve {
            type uint32;
            description
              "WRED curve relative to a Queue to use for traffic whose internal color is Yellow.";
          }
        }  // list map-entry
      }  // list cos-queue-map

      list congestion-avoidance-profile {
        key "name";
        description
          "List of congestion avoidance profiles.";
        leaf name {
          type string;
          description
            "Name for the profile.";
        }

        leaf type {
          type enumeration {
            enum "wred" {
              value 0;
              description
                "Weighted random early detection.";
            }
            enum "red" {
              value 1;
              description
                "Random early detection.";
            }
          }
          description
            "congestion avoidance technique.";
        }
      }  // list congestion-avoidance-profile

      list queue-group-profile {
        key "name";
        description
          "Defines the characteristics of an instance of a group of queues.";
        leaf name {
          type string;
          description
            "Name for the profile.";
        }

        leaf queue-count {
          type uint32;
          description
            "Number of queues in the associated queue-group instances.";
        }

        leaf cos-queue-map {
          type cos-queue-map-ref;
          description
            "cos-queue map to use for mapping CoS to a queue.";
        }

        list queue {
          key "queue-number";
          description
            "List of queues in the associated queue-group.";
          leaf queue-number {
            type uint32;
            mandatory true;
            description
              "The queue-number for this queue. The priority and weight for this queue are determined via
the mapping of queue-number to tap-point number (typically 1:1) from the associated scheduler-profile
of the parent scheduler-instance.";
          }

          leaf congestion-avoidance-profile {
            type congestion-avoidance-profile-ref;
            description
              "Optional congestion avoidance algorithm for this queue.";
          }

          leaf cir {
            type uint32;
            description
              "Committed information rate for aggregate shaping in kilobits per second.";
          }

          leaf cir-percent {
            type uint32;
            description
              "Committed information rate for aggregate shaping on a percentage basis <0..100>.";
          }

          leaf cbs {
            type uint32;
            description
              "Committed burst size in kilobytes.";
          }

          leaf eir {
            type uint32;
            description
              "Maximum rate for aggregate shaping in kilobits per second.";
          }

          leaf eir-percent {
            type uint32;
            description
              "Maximum rate for aggregate shaping on a percentage basis <0..100>.";
          }

          leaf ebs {
            type uint32;
            description
              "Maximum burst size in kilobytes.";
          }
        }  // list queue
      }  // list queue-group-profile

      list scheduler-profile {
        key "name";
        description
          "Scheduler profile associated with queue-group.";
        leaf name {
          type string;
          description
            "Name for the profile.";
        }

        leaf tap-point-count {
          type uint32;
          description
            "The number of tap-points in corresponding scheduler-instances that queues
or child schedulers can uniquely use to attach to the scheduler.";
        }

        leaf scheduling-algorithm {
          type enumeration {
            enum "sp" {
              value 0;
              description "Strict priority.";
            }
            enum "rr" {
              value 1;
              description "Round-robin.";
            }
            enum "wrr" {
              value 2;
              description
                "Weighted round-robin.";
            }
            enum "wfq" {
              value 3;
              description
                "Weighted fair queueing.";
            }
            enum "wdrr" {
              value 4;
              description
                "Weighted deficit round-robin.";
            }
          }
          description
            "The scheduling algorithm used to service the tap-points of
the scheduler instances.";
        }

        leaf cir {
          type uint32;
          description
            "Committed information rate for aggregate shaping in kilobits per second.";
        }

        leaf cir-percent {
          type uint32;
          description
            "Committed information rate for aggregate shaping on a percentage basis <0..100>.";
        }

        leaf cbs {
          type uint32;
          description
            "Committed burst size in kilobytes.";
        }

        leaf eir {
          type uint32;
          description
            "Maximum rate for aggregate shaping in kilobits per second.";
        }

        leaf eir-percent {
          type uint32;
          description
            "Maximum rate for aggregate shaping on a percentage basis <0..100>.";
        }

        leaf ebs {
          type uint32;
          description
            "Maximum burst size in kilobytes.";
        }

        leaf cir-policy {
          type enumeration {
            enum "auto-adjust-disabled" {
              value 0;
              description
                "cir-policy of auto-adjust-disabled determines that cir (not cir-percent) is used for the scheduler instance associated
   with this scheduler-profile and also the child queues/scheduler-instances use cir.";
            }
            enum "cir-as-percent" {
              value 1;
              description
                "cir-policy of cir-as-percent determines that cir in percentage values are used for the scheduler instance associated
   with this scheduler-profile and also the child queues/scheduler-instances use cir-percent.";
            }
            enum "child-cir-as-percent" {
              value 2;
              description
                "cir-policy of child-cir-as-percent determines that cir (not cir-percent) is used for the scheduler instance associated
   with this scheduler-profile, but cir in percentage values are used for the child queues/scheduler-instances.";
            }
            enum "child-cir-sum" {
              value 3;
              description
                "cir-policy of child-cir-sum determines that cir for the scheduler instance associated
   with this scheduler-profile is calculated based on the sum of cir of the child queues/scheduler-instances.";
            }
          }
          description
            "cir-policy is used for the scheduler instance.";
        }

        leaf eir-policy {
          type enumeration {
            enum "auto-adjust-disabled" {
              value 0;
              description
                "eir-policy of auto-adjust-disabled determines that eir (not eir-percent) is used for the scheduler instance associated
   with this scheduler-profile and also the child queues/scheduler-instances use eir.";
            }
            enum "eir-as-percent" {
              value 1;
              description
                "eir-policy of eir-as-percent determines that eir in percentage values are used for the scheduler instance associated
   with this scheduler-profile and also the child queues/scheduler-instances use eir-percent.";
            }
            enum "child-eir-as-percent" {
              value 2;
              description
                "eir-policy of child-eir-as-percent determines that eir (not eir-percent) is used for the scheduler instance associated
   with this scheduler-profile, but eir in percentage values are used for the child queues/scheduler-instances.";
            }
          }
          description
            "eir-policy is used for the scheduler instance.";
        }

        list tap-point {
          key "number";
          description
            "Defines priority and weight for each tap-point of the associated scheduler instances.
Either Queues or Schedulers map to the tap points and their priority and weight is obtained
from this tap-point configuration.";
          leaf number {
            type uint32;
            description
              "tap-point identifier within a scheduler-instance";
          }

          leaf priority {
            type uint32;
            description
              "Priority of this tap-point relative to other tap-points in a scheduler-instance. Used when scheduling algorithm is strict-priority.";
          }

          leaf weight {
            type uint32;
            description
              "Weight of this tap-point relative to other tap-points in a scheduler-instance. Used when scheduling algorithm is
weighted-round-robin, weighted-fair-queuing, weighted-deficit-round-robin.";
          }
        }  // list tap-point
      }  // list scheduler-profile

      list queue-group {
        key "name";
        description
          "The queue-group is an instance of a group of queues as described by the associated queue-group-profile. The queue-group
instance has a parent scheduler instance which is part of a scheduling hierarchy rooted to a port.
Additionally, the queue-group instance may be mapped to both directly (e.g. from flow-points) and indirectly via the
queue-group-indirection (e.g. via MPLS PWs/MPLS Tunnels).";
        leaf name {
          type string;
          description
            "Name for the queue group instance.";
        }

        leaf queue-group-profile {
          type queue-group-profile-ref;
          mandatory true;
          description
            "The queue-group-profile describing the attributes of this queue-group instance.";
        }

        leaf instance-id {
          type uint32;
          description
            "Identifier for the scheduler-instance.";
        }

        leaf queue-group-indirection {
          type queue-group-indirection-ref;
          description
            "The queue-group-indirection that this queue-group instance is assigned to. Multiple different queue-groups
on different ports can be assigned to the same queue-group-indirection.";
        }

        leaf parent-scheduler {
          type scheduler-ref;
          mandatory true;
          description
            "The parent-scheduler instance for this queue group.";
        }
      }  // list queue-group

      list scheduler {
        key "name";
        description
          "The scheduler is an instance of a scheduler as described by the associated scheduler-profile. The scheduler
instance itself has either a parent scheduler instance which is part of a scheduling hierarchy rooted to a port or
the root port itself.";
        leaf name {
          type string;
          description
            "Name for the scheduler instance.";
        }

        leaf scheduler-profile {
          type scheduler-profile-ref;
          mandatory true;
          description
            "The scheduler-profile describing the attributes of this scheduler instance.";
        }

        leaf instance-id {
          type uint32;
          description
            "Identifier for the scheduler-instance.";
        }

        leaf parent-scheduler {
          type scheduler-ref;
          description
            "Optional reference to parent-scheduler instance if this scheduler instance is not the root scheduler instance
in the egress QoS hierarchy of a port.";
        }

        leaf parent-tap-point {
          type uint32;
          description
            "The tap point that this scheduler instance in a parent scheduler-instance. Determines the priority and weight
for this scheduler instance relative to its parent from the scheduler-profile.";
        }

        leaf parent-port {
          type mef-logical-port:logical-port-ref;
          description
            "Optional reference to a logical-port if this scheduler instance is the root scheduler instance
in the egress QoS hierarchy of a port.";
        }
      }  // list scheduler

      list queue-group-indirection {
        key "name";
        description
          "This is an indirected identification of a queue group that would be used by entities
which do not resolve directly to the root of the egress-qos hierarchy (a port).
An example of this is an MPLS PW which maps to a queue-group-indirection for service-based queuing and scheduling.
Dependent on the state of the underlying transport (e.g. MPLS Tunnels to next-hops to port), the actual queue-group instance
being used may change dynamically, however the queue-group-indirection allows.";
        leaf name {
          type string;
          description
            "Name for the queue group indirection.";
        }

        leaf indirection-id {
          type uint32;
          description
            "Identifier for the queue group indirection.";
        }
      }  // list queue-group-indirection
    }  // container egress-qos
  }  // module ciena-mef-egress-qos