path: root/src/plugins/yang/openconfig/openconfig-qos-elements.yang

submodule openconfig-qos-elements {

  belongs-to openconfig-qos {
    prefix "oc-qos";
  }

  import openconfig-extensions { prefix oc-ext; }
  import openconfig-qos-types { prefix oc-qos-types; }
  import openconfig-packet-match { prefix oc-pkt-match; }
  import openconfig-platform { prefix oc-platform; }
  import openconfig-types { prefix oc-types; }


  organization
    "OpenConfig working group";

  contact
    "OpenConfig working group
    netopenconfig@googlegroups.com";

  description
    "This submodule defines configuration and operational state
    data associated with QoS elements.  The primary elements of
    the model include:

      classifiers: match packets with a specific characteristic

      forwarding groups: logical class of packets that receive
      common forwarding treatment

      queues:  collection of packets to be scheduled, including
      a queue management scheme

      schedulers: sequence of one more elements that schedule
      packets for transmission, including policer and shaper
      functions";

  oc-ext:openconfig-version "0.2.0";

  revision "2016-12-16" {
    description
      "Fix incorrect interface-ref placement";
    reference "0.2.0";
  }

  revision "2016-06-03" {
    description
      "Initial revision";
    reference "0.1.0";
  }

  grouping qos-classifier-term-config {
    description
      "Configuration data for list of match criteria in a QoS
      classifier";

    leaf id {
      type string;
      description
        "Identifier for the match term";
    }
  }

  grouping qos-classifier-term-state {
    description
      "Operational state data for list of match criteria in a QoS
      classifier";
  }

  grouping qos-classifier-term-action-config {
    description
      "Configuration parameters for actions for a classifier term.";

    leaf target-group {
      type leafref {
        // Current location:
        // /qos/classifiers/classifier/terms/term/actions/config/target-group
        path "../../../../../../../forwarding-groups/forwarding-group/" +
          "config/name";
      }
      description
        "References the forwarding group or class to which the
        matched packets should be assigned";
    }
  }

  grouping qos-classifier-terms-top {
    description
      "Top-level grouping for list of match criteria in a QoS
      classifier";

    container terms {
      description
        "Enclosing container for ths list of terms";

      list term {
        key "id";
        description
          "List of match terms used in the classifier";

        leaf id {
          type leafref {
            path "../config/id";
          }
          description
            "Reference to id list key.";
        }

        container config {
          description
            "Configuration data for list of match criteria in a QoS
            classifier";

          uses qos-classifier-term-config;
        }

        container state {
          config false;
          description
            "Operational state data for list of match criteria in a
            QoS classifier";

          uses qos-classifier-term-config;
          uses qos-classifier-term-state;
        }

        container conditions {
          description
            "Conditions for the classifier term. Packets must match all of
            the criteria specified within the match condition to be considered
            matching the term.";

            // TODO(robjs): Consider whether we should have classifiers
            // that can match >1 different value of a field, or whether
            // this should require different match terms within the
            // classifier.
            uses oc-pkt-match:ethernet-header-top;
            uses oc-pkt-match:ipv4-protocol-fields-top;
            uses oc-pkt-match:ipv6-protocol-fields-top;
            uses oc-pkt-match:transport-fields-top;
            uses oc-pkt-match:mpls-header-top;
        }

        container actions {
          description
            "Actions to be applied for packets matching the specified
            classification rules.";

          container config {
            description
              "Actions to be applied to packets that match the classifier
              term.";

            uses qos-classifier-term-action-config;
          }

          container state {
            config false;
            description
              "Operational state parameters associated with classifier term
              actions";

            uses qos-classifier-term-action-config;
          }

          container remark {
            description
              "Remark actions to be associated with packets that match the
              classifier term. Where a packet matches these criteria, the
              specified rewrite actions should be performed.";

            uses qos-common-remark-actions;
          }
        }
      }
    }
  }

  grouping qos-classifier-config {
    description
      "Configuration data for classifiers";

    leaf name {
      type string;
      description
        "User-assigned name of the classifier";
    }

    leaf type {
      type enumeration {
        enum IPV4 {
          description
            "Classifier matches and operates
            on packets with IPv4 headers.";
        }
        enum IPV6 {
          description
            "Classifier matches and operates
            on packets with IPv6 headers.";
        }
        enum MPLS {
          description
            "Classifier matches and operates
            on packets with MPLS headers.";
        }
        enum ETHERNET {
          description
            "Classifier matches and operates
            on fields within the L2 ETHERNET
            headers.";
        }
      }
      description
        "Type of classifier.";
    }
  }

  grouping qos-classifier-state {
    description
      "Operational state data for classifiers";

  }

  grouping qos-classifier-top {
    description
      "Top-level grouping for classifier data";

    container classifiers {
      description
        "Enclosing container for QoS classifiers";

      list classifier {
        key "name";
        description
          "List of classifier elements";

        leaf name {
          type leafref {
            path "../config/name";
          }
          description
            "Reference to list key name";
        }

        container config {
          description
            "Configuration data for classifers";

          uses qos-classifier-config;
        }

        container state {
          config false;
          description
            "Operational state data for classifiers";

          uses qos-classifier-config;
          uses qos-classifier-state;
        }

        uses qos-classifier-terms-top;
      }
    }
  }

  grouping qos-fabric-trace-config {
    description
      "Configuration data for fabric trace data";

    leaf source {
      type leafref {
        path "/oc-platform:components/oc-platform:component" +
          "/oc-platform:config/oc-platform:name";
      }
      description
        "Source component for fabric trace data";
    }

    leaf dest {
      type leafref {
        path "/oc-platform:components/oc-platform:component" +
          "/oc-platform:config/oc-platform:name";
      }
      description
        "Destination component for fabric trace data";
    }
  }

  grouping qos-forwarding-group-config {
    description
      "Configuration data for forwarding groups";

    leaf name {
      type string;
      description
        "Name of the forwarding group";
    }

    // TODO(robjs, Simon G): Discuss optionally moving
    // this to a high/low priority indicator, if this
    // is common across implementations.
    leaf fabric-priority {
      type uint8;
      description
        "Set the priority for the forwarding group for
        local transmission through the device, e.g.,
        across a switching fabric. Higher priorities
        are considered to be better, such that traffic
        with fabric priority 128 is considered to be
        higher priority than that with fabric priority
        0.";
    }

    leaf output-queue {
      type leafref {
        path "../../../../queues/queue/config/name";
      }
      description
        "Queue for packets in this forwarding group.";
    }
  }

  grouping qos-forwarding-group-state {
    description
      "Operational state data for forwarding groups";
  }

  grouping qos-forwarding-group-top {
    description
      "Top-level grouping for forwarding group data";

    container forwarding-groups {
      description
        "Enclosing container for list of forwarding groups";

      list forwarding-group {
        key "name";
        description
          "List of forwarding groups.  Forwarding groups are
          logical groups of traffic that will receive common
          forwarding treatment.";

        leaf name {
          type leafref {
            path "../config/name";
          }
          description
            "Reference to name list key";
        }

        container config {
          description
            "Configuration data for forwarding groups";

          uses qos-forwarding-group-config;
        }

        container state {
          config false;
          description
            "Operational state data for forwarding groups";

          uses qos-forwarding-group-config;
          uses qos-forwarding-group-state;
        }
      }
    }
  }

  grouping qos-queue-red-common-config {
    description
      "Common configuration parameters applicable to RED and
      its variants";

    leaf enable-ecn {
      type boolean;
      default false;
      description
        "When set to true, the device should mark packets that are
        ECN-capable rather than dropping them.  The receiver is
        expected to echo the congestion signal back to the sender
        so that it may adjust its transmission rate accordingly.
        When this leaf is false, the device drops packets according
        to the RED/WRED probability, or all packets if the
        average queue length is above the max threshold.";
    }
  }

  grouping qos-queue-red-common-state {
    description
      "Common operational state data applicable to RED and
      its variants";

  }

  grouping qos-queue-wred-config {
    description
      "Configuration data for WRED-managed queues";

    // TODO(robjs, aashaikh): Add configuration for weighted RED
    // within this grouping.
  }

  grouping qos-queue-wred-state {
    description
      "Operational state data for WRED-managed queues";
  }

  grouping qos-queue-wred-top {
    description
      "Top-level grouping for WRED-managed queues";

    container wred {
      description
        "Top-level container for WRED data";

      container config {
        description
          "Configuration data for WRED";

        uses qos-queue-wred-config;
      }

      container state {
        config false;
        description
          "Operational state data for WRED";

        uses qos-queue-wred-config;
        uses qos-queue-wred-state;
      }
    }
  }

  grouping qos-queue-red-config {
    description
      "Configuration data for queues managed with RED";

    leaf minth {
      type uint64;
      units bytes;
      description
        "The mininum threshold parameter for a RED-managed queue.
        When the average queue length is less than minth, all
        packets are admitted to the queue.";
    }

    leaf maxth {
      type uint64;
      units bytes;
      description
        "The maximum threshold parameter for a RED-managed queue.
        When the average queue length exceeds the maxth value, all
        packets are dropped (or marked if ECN is enabled).";
    }
  }

  grouping qos-queue-red-state {
    description
      "Operational state data for queues managed with RED";
  }

  grouping qos-queue-red-top {
    description
      "Top-level grouping for RED queues";

    container red {
      description
        "Top-level container for data related to RED-managed
        queues";

      container config {
        description
          "Configuration data for RED queues";

        uses qos-queue-red-config;
      }

      container state {
        config false;
        description
          "Operational state data for RED queues";

        uses qos-queue-red-config;
        uses qos-queue-red-state;
      }
    }
  }


  grouping qos-queue-config {
    description
      "Configuration data for QoS egress queues";

    leaf name {
      type string;
      description
        "User-defined name of the queue";
    }

    leaf queue-type {
      type identityref {
        base oc-qos-types:QOS_QUEUE_TYPE;
      }
      description
        "Sets the type of the queue";
    }
  }

  grouping qos-queue-state {
    description
      "Operational state data for egress queues";
  }

  grouping qos-queue-top {
    description
      "Top-level grouping for queue elements";

    container queues {
      description
        "Enclosing container for the list of queues";

      list queue {
        key "name";
        description
          "List of defined queues";

        leaf name {
          type leafref {
            path "../config/name";
          }
          description
            "Reference to the queue name list key.";
        }

        container config {
          description
            "Configuration data for queues";

          uses qos-queue-config;
        }

        container state {
          config false;
          description
            "Operational state data for queues";

          uses qos-queue-config;
          uses qos-queue-state;
        }

        uses qos-queue-red-top {
          when "../config/queue-type = 'oc-qos-types:RED'" {
            description
              "RED configuration is valid when the queue-type
              is set accordingly.";
          }
        }
        uses qos-queue-wred-top {
          when "../config/queue-type = 'oc-qos-types:WRED'" {
            description
              "WRED configuration is valid when the queue-type
              is set accordingly.";
          }
        }
      }
    }
  }

  grouping qos-scheduler-output-config {
    description
      "Configuration data for scheduler output operations";

    leaf output-type {
      type enumeration {
        enum SCHEDULER {
          description
            "Scheduler output is a child scheduler, e.g. to
            implement hierarchical schedulers.";
        }
        enum FWD_GROUP {
          description
            "Scheduler output is a forwarding group, e.g., when
            performing ingress scheduling before packets traverse
            a fabric to be processed by an egress forwarding
            complex.";
        }
        enum INTERFACE {
          description
            "Scheduler output is an interface for forwarding.";
        }
      }
      description
        "Describes the type of output sink for the scheduler.";
    }

    leaf child-scheduler {
      // TODO: consider whether both child (output) and parent
      // (input) references are needed; consider whether child
      // reference should separate in-profile and out-of-profile
      type leafref {
        // current loc:
        // /qos/scheduler-policies/scheduler-policy/schedulers/scheduler/
        // output/config/child-scheduler
        path "../../../../../../../scheduler-policies/scheduler-policy/" +
             "config/name";
      }
      when "../output-type = 'SCHEDULER'" {
        description
          "The child-scheduler leaf is valid only when
          the output type of the scheduler is a child scheduler";
      }
      description
        "When the scheduler output type is a child scheduler,
        this leaf provides a reference to the downstream
        scheduler.";
    }

    leaf output-fwd-group {
      type leafref {
        path "../../../../../../../forwarding-groups/forwarding-group" +
          "/config/name";
      }
      when "../output-type = 'FWD_GROUP'" {
        description
          "The output-fwd-group leaf is valid only when
          the output type of the scheduler is a forwarding group";
      }
      description
        "When the scheduler output type is a forwarding group,
        this leaf provides a reference to the forwarding group.";
    }
  }

  grouping qos-scheduler-output-state {
    description
      "Operational state data for scheduler output";
  }

  grouping qos-scheduler-output-top {
    description
      "Top-level grouping for data related to scheduler output";

    container output {
      description
        "Top-level container for scheduler output data";

      container config {
        description
          "Configuration data for scheduler output";

        uses qos-scheduler-output-config;
      }

      container state {
        config false;
        description
          "Operational state data for scheduler output";

        uses qos-scheduler-output-config;
        uses qos-scheduler-output-state;
      }
    }
  }

  grouping qos-scheduler-inputs-config {
    description
      "Configuration data for scheduler input sources";

    leaf id {
      type string;
      description
        "User-defined identifier for the scheduler input";
    }

    leaf input-type {
      type enumeration {
        enum QUEUE {
          description
            "Input is a defined queue.";
        }
        enum IN_PROFILE {
          description
            "Input is in-profile traffic from a parent scheduler/
            shaper";
        }
        enum OUT_PROFILE {
          description
            "Input is out-of-profile traffic from a parent
            scheduler/shaper";
        }
      }
      description
        "Describes the type of input source for the scheduler";
    }

    leaf queue {
      type leafref {
        // current loc: /qos/scheduler-policies/scheduler-policy/schedulers/
        // scheduler/inputs/input/config/queue
        path "../../../../../../../../queues/queue/name";
      }
      when "../input-type = 'QUEUE'" {
        description
          "The queue leaf is valid only when
          the input type of the scheduler is a queue";
      }
      description
        "Reference to a queue that is an input source for the
        scheduler";
    }

    leaf weight {
      type uint64;
      description
        "For priority schedulers, this indicates the priority of
        the corresponding input.  Higher values indicate higher
        priority.  For weighted round-robin schedulers, this leaf
        indicates the weight of the corresponding input.";
    }
  }

  grouping qos-scheduler-inputs-state {
    description
      "Operational state data for scheduler input sources";
  }

  grouping qos-scheduler-inputs-top {
    description
      "Top-level grouping for defining inputs to a scheduler.";

    container inputs {
      description
        "Enclosing container ";

      list input {
        key "id";
        description
          "List of input sources for the scheduler.";

        leaf id {
          type leafref {
            path "../config/id";
          }
          description
            "Reference to list key";
        }

        container config {
          description
            "Configuration data for scheduler input sources";

          uses qos-scheduler-inputs-config;
        }

        container state {
          config false;
          description
            "Operational state data for scheduler input sources";

          uses qos-scheduler-inputs-config;
          uses qos-scheduler-inputs-state;
        }
      }
    }
  }

  grouping qos-scheduler-1r2c-config {
    description
      "Configuration data for 1 rate, 2 color scheduler.";

    leaf cir {
      type uint64;
      units bps;
      description
        "Committed information rate for the single-rate token
        bucket scheduler.  This value represents the rate at which
        tokens are added to the bucket.";
    }

    leaf cir-pct {
      type oc-types:percentage;
      description
        "Committed information rate for the single-rate token
        bucket scheduler. This value represents the rate at which
        tokens are added to the bucket. It is expressed as a
        percentage of the total bandwidth allocated to the
        context in which the scheduler is referenced.";
    }

    leaf cir-pct-remaining {
      type oc-types:percentage;
      description
        "Committed information rate for the single-rate token
        bucket scheduler. This value represents the rate at which
        tokens are added to the bucket. It is expressed as a
        percentage of the unallocated bandwidth available in the
        context in which the scheduled is referenced.";
    }

    leaf bc {
      type uint32;
      units bytes;
      description
        "Committed burst size for the single-rate token bucket
        scheduler.  This value represents the depth of the token
        bucket.";
    }

    leaf queuing-behavior {
      type oc-qos-types:queue-behavior;
      description
        "The type of scheduler that is being configured.";
    }

    // TODO(robjs): Add when statements to these parameters when the
    // types of scheduler are agreed through review.
    leaf max-queue-depth-bytes {
      type uint32;
      units bytes;
      description
        "When the scheduler is specified to be a shaper - the
        maximum depth of the queue in bytes is the value
        specified by this leaf.";
    }

    leaf max-queue-depth-packets {
      type uint32;
      units packets;
      description
        "When the scheduler is specified to be a shaper - the
        maximum depth of the queue in packets is the value
        specified by this leaf.";
    }

    leaf max-queue-depth-percent {
      type oc-types:percentage;
      description
        "The queue depth specified as a percentage of the total
        available buffer that is avaialble.";
    }
  }

  grouping qos-scheduler-1r2c-top {
    description
      "Top-level grouping for 1 rate, 2 color shapers";

    container one-rate-two-color {
      description
        "Top-level container for data related to a 1 rate, 2 color
        shaper.";

      container config {
        description
          "Configuration data for 1 rate, 2 color shapers";

        uses qos-scheduler-1r2c-config;
      }

      container state {
        config false;
        description
          "Operational state data for 1 rate, 2 color shapers";

        uses qos-scheduler-1r2c-config;
      }

      container conform-action {
        description
          "Action to be applied to packets that are scheduled within the
          CIR of the one-rate, two-colour scheduler. Packets that receive
          a token from the in-CIR bucket are said to be conforming and
          have all of the specified actions applied.";

        container config {
          description
            "Configuration parameters relating to conforming packets for the
            1r2c scheduler.";

          uses qos-common-remark-actions-config;
        }

        container state {
          config false;
          description
            "Operational state parameters relating to conforming packets
            for the 1r2c scheduler.";

          uses qos-common-remark-actions-config;
        }
      }

      container exceed-action {
        description
          "Action to be applied to packets that are scheduled above the CIR
          of the one-rate, two-colour shaper. Packets that do not receive a
          token from the in-CIR bucket are said to be exceeding, and have
          all of the specified actions applied.";

          container config {
            description
              "Configuration parameters relating to exceeding packets for
              the 1r2c scheduler.";

            uses qos-common-remark-actions-config;
            uses qos-common-scheduler-actions-config;
          }

          container state {
            config false;
            description
              "Operational state parameters relating to exceeding
              packets for the 1r2c scheduler.";

            uses qos-common-remark-actions-config;
            uses qos-common-scheduler-actions-config;
          }
      }
    }
  }

  grouping qos-scheduler-2r3c-config {
    description
      "Configuration data for 2 rate, 3 color policer";

    leaf cir {
      type uint64;
      units bps;
      description
        "Committed information rate for the dual-rate token
        bucket policer.  This value represents the rate at which
        tokens are added to the primary bucket.";
    }

    leaf cir-pct {
      type oc-types:percentage;
      description
        "Committed information rate for the dual-rate token bucket
        policer. This value represents the rate at which tokens
        are added to the primary bucket. It is expressed as a
        percentage of the total bandwidth available within the
        context the scheduler is instantiated.";
    }

    leaf cir-pct-remaining {
      type oc-types:percentage;
      description
        "Committed information rate for the dual-rate token
        bucket policer. This value represents the rate at which
        tokens are added to the primary bucket. It is expressed
        as a percentage of the remaining bandwidth within the
        context the scheduler is instantiated.";
    }

    leaf pir {
      type uint64;
      units bps;
      description
        "Peak information rate for the dual-rate token bucket
        policer.  This value represents the rate at which tokens
        are added to the secondary bucket.";
    }

    leaf pir-pct {
      type oc-types:percentage;
      description
        "Peak information rate for the dual-rate token bucket
        policer. This value represents the rate at which tokens
        are added to the secondary bucket. The value is expressed
        as a percentage of the total bandwidth available in the
        context in which the scheduler is instantiated.";
    }

    leaf pir-pct-remaining {
      type oc-types:percentage;
      description
        "Peak information rate for the dual-rate token
        bucket policer. This value represents the rate at which
        tokens are added to the secondary bucket. It is expressed
        as a percentage of the remaining bandwidth within the
        context the scheduler is instantiated.";
    }

    leaf bc {
      type uint32;
      units bytes;
      description
        "Committed burst size for the dual-rate token bucket
        policer.  This value represents the depth of the token
        bucket.";
    }

    leaf be {
      type uint32;
      units bytes;
      description
        "Excess burst size for the dual-rate token bucket policer.
        This value represents the depth of the secondary bucket.";
    }
  }

  grouping qos-scheduler-2r3c-top {
    description
      "Top-level grouping for 2 rate, 3 color policers..";

    container two-rate-three-color {
      description
        "Top-level container for data for a 2 rate, 3 color policer.";

      container config {
        description
          "Configuration data for 2 rate, 3 color policers.";

        uses qos-scheduler-2r3c-config;
      }

      container state {
        config false;
        description
          "Operational state data for 2 rate, 3 color policers.";

        uses qos-scheduler-2r3c-config;
      }

      container conform-action {
        description
          "Action to be applied to the packets that are scheduled
          within the CIR of the policer. All packets that receive
          a token from this bucket have all actions specified
          applied to them";

          container config {
            description
              "Configuration parameters for the conform action of a
              2r3c policer.";
            uses qos-common-remark-actions-config;
          }

          container state {
            config false;
            description
              "Operational state parameters relating to the conform
              action of a 2r3c policer.";
            uses qos-common-remark-actions-config;
          }
      }

      container exceed-action {
        description
          "Action to be applied to the packets that are scheduled
          within the PIR of the policer. Packets that receive a
          token from within the PIR allocation have all the
          specified actions applied to them";

        container config {
          description
            "Configuration parameters relating to the action
            applied to exceeding packets.";

          uses qos-common-remark-actions-config;
          uses qos-common-scheduler-actions-config;
        }

        container state {
          config false;
          description
            "Operational state parameters relating to the action
            applied to exceeding packets.";

          uses qos-common-remark-actions-config;
          uses qos-common-scheduler-actions-config;
        }
      }

      container violate-action {
        description
          "Action to be applied to the packets that are scheduled
          above the PIR of the policer. Packets that do not receive
          a token from either bucket have all specified actions
          applied to them.";

        container config {
          description
            "Configuration parameters relating to the action
            applied to violating packets.";

          uses qos-common-remark-actions-config;
          uses qos-common-scheduler-actions-config;
        }

        container state {
          config false;
          description
            "Operational state parameters relating to the action
            applied to violating packets.";

          uses qos-common-remark-actions-config;
          uses qos-common-scheduler-actions-config;
        }
      }
    }
  }

  grouping qos-scheduler-config {
    description
      "Configuration data for QoS schedulers";

    leaf sequence {
      type uint32;
      description
        "Sequence number for the scheduler within the scheduler
        policy. Schedulers are processed from lowest sequence
        to highest.";
    }

    leaf type {
      type identityref {
        base oc-qos-types:QOS_SCHEDULER_TYPE;
      }
      description
        "Sets the type of scheduler, i.e. the scheduling algorithm
        used to serve inputs.";
    }

    leaf priority {
      type enumeration {
        enum STRICT {
          description
            "This scheduler term is considered as a strict priority
            term - such that packets that arrive in the queue are
            immediately serviced.";
        }
      }
      description
        "Priority of the scheduler within the scheduler policy.";
    }
  }

  grouping qos-scheduler-state {
    description
      "Operational state data for QoS schedulers";
  }

  grouping qos-scheduler-policy-config {
    description
      "Configuration parameters relating to a scheduler policy";

    leaf name {
      type string;
      description
        "Name for the scheduler policy.";
    }
  }

  grouping qos-scheduler-top {
    description
      "Top-level grouping for the set of defined QoS schedulers";

    container scheduler-policies {
      description
        "Enclosing container for the list of configured scheduler policies.";

      list scheduler-policy {
        key "name";

        description
          "List of scheduler policies. A scheduler policy is a set of schedulers
          that are to be applied together. Each scheduler within a scheduler
          policy takes an input, and outputs it according to a scheduling
          discipline that is specified within it. The schedulers consume
          resources according to the specification that is provided - which
          may be absolute resource limits, or relative.";

        leaf name {
          type leafref {
            path "../config/name";
          }
          description
            "Reference to the name of the scheduler policy";
        }

        container config {
          description
            "Configuration parameters relating to a scheduler policy.";
          uses qos-scheduler-policy-config;
        }

        container state {
          config false;
          description
            "Operational state parameters relating to a scheduler policy.";
          uses qos-scheduler-policy-config;
        }

        container schedulers {
          description
            "Schedulers within the scheduler policy.";

          list scheduler {
            key "sequence";
            description
              "List of defined QoS traffic schedulers.";

            leaf sequence {
              type leafref {
                path "../config/sequence";
              }
              description
                "Reference to the list key";
            }

            container config {
              description
                "Configuration data for QoS schedulers";

              uses qos-scheduler-config;
            }

            container state {
              config false;

              description
                "Operational state data for QoS schedulers";

              uses qos-scheduler-config;
              uses qos-scheduler-state;
            }

            uses qos-scheduler-inputs-top;
            uses qos-scheduler-output-top;
            uses qos-scheduler-1r2c-top;
            uses qos-scheduler-2r3c-top;
          }
        }
      }
    }
  }

  grouping qos-common-remark-actions {
    description
      "Common grouping specifying actions related to re-marking
      packets";

    container config {
      description
        "Configuration parameters relating to remarking packets.";
      uses qos-common-remark-actions-config;
    }

    container state {
      config false;
      description
        "Operational state parameters relating to remarking packets.";
      uses qos-common-remark-actions-config;
    }
  }

  grouping qos-common-scheduler-actions-config {
    description
      "Configuration data for common actions of a QoS scheduler.";

    leaf drop {
      type boolean;
      description
        "If set to true, packets within this context are dropped.";
    }
  }

  grouping qos-common-remark-actions-config {
    description
      "Configuration data for QoS re-marking actions";

    leaf set-dscp {
      type uint8;
      description
        "Sets the 6-bit DSCP (differentiated services code point)
        value in the IP packet header.";
      reference
        "RFC 2474 - Definition of the Differentiated Services Field
        (DS Field) in the IPv4 and IPv6 Headers";
    }

    leaf set-dot1p {
      type uint8;
      description
        "Sets the 3-bit class-of-service value in the
        Ethernet packet header for 802.1Q VLAN-tagged packets,
        also known as PCP (priority code point).";
      reference
        "IEEE 802.1Q-2014 - IEEE Standard for Local and metropolitan
        area networks--Bridges and Bridged Networks";
    }

    leaf set-mpls-tc {
      type uint8;
      description
        "Sets the 3-bit traffic class value (also referred to as EXP
        or CoS) in MPLS packets.";
      reference
        "RFC 3270 - Multi-Protocol Label Switching (MPLS) Support of
        Differentiated Services";
    }
  }
}