module ietf-diffserv-policy {

    yang-version 1;

    namespace
      "urn:ietf:params:xml:ns:yang:ietf-diffserv-policy";

    prefix policy;

    import ietf-diffserv-classifier {
      prefix classifier;
    }

    organization
      "IETF NETMOD (Netmod Working Group) Working Group";

    contact
      "WG Web:   <http://tools.ietf.org/wg/netmod/>
WG List:  <mailto:netmod@ietf.org>

WG Chair: Juergen Schoenwaelder
	  <mailto:j.schoenwaelder@jacobs-university.de>

WG Chair: Tom Nadeau
	  <mailto:tnadeau@lucidvision.com>

Editor:   Aseem Choudhary
	  <mailto:asechoud@cisco.com>

Editor:   Shitanshu Shah
	  <mailto:svshah@cisco.com>";

    description
      "This module contains a collection of YANG definitions for
configuring diffserv specification implementations.

Copyright (c) 2014 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
(http://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 "2015-04-07" {
      description
        "Latest revision of diffserv policy";
      reference
        "RFC XXXX";

    }


    feature policy-template-support {
      description
        " This feature allows policy template to be configured";
    }

    feature hierarchial-policy-support {
      description
        " This feature allows hierarchial policy to be configured";
    }

    identity action-type {
      description
        "This base identity type defines action-types";
    }

    container policies {
      if-feature policy-template-support;
      description "list of policy templates";
      list policy-entry {
        key "policy-name";
        description "policy template";
        leaf policy-name {
          type string;
          description "Diffserv policy name";
        }

        leaf policy-descr {
          type string;
          description
            "Diffserv policy description";
        }

        list classifier-entry {
          key "classifier-entry-name";
          ordered-by user;
          description
            "Classifier entry configuration in a policy";
          leaf classifier-entry-name {
            type string;
            description
              "Diffserv classifier entry name";
          }

          leaf classifier-entry-inline {
            type boolean;
            default "false";
            description
              "Indication of inline classifier entry";
          }

          leaf classifier-entry-filter-oper {
            type identityref {
              base classifier-entry-filter-operation-type;
            }
            default "match-any-filter";
            description
              "Filters are applicable as any or all filters";
          }

          list filter-entry {
            if-feature policy-inline-classifier-config;
            must
              "../classifier-entry-inline = 'true'" {
              description
                "For inline filter configuration, inline attribute
must be true";
            }
            key "filter-type filter-logical-not";
            description
              "Filters configured inline in a policy";
            leaf filter-type {
              type identityref {
                base filter-type;
              }
              description
                "This leaf defines type of the filter";
            }

            leaf filter-logical-not {
              type boolean;
              description
                "
This is logical-not operator for a filter. When true, it
indicates filter looks for absence of a pattern defined
by the filter
";
            }

            choice filter-param {
              description
                "Choice of filter types";
              case dscp {
                description
                  "Filter containing list of dscp ranges";
                list dscp-cfg {
                  key "dscp-min dscp-max";
                  description
                    "list of dscp ranges";
                  leaf dscp-min {
                    type inet:dscp;
                    description
                      "Minimum value of dscp range";
                  }

                  leaf dscp-max {
                    type inet:dscp;
                    description
                      "maximum value of dscp range";
                  }
                }  // list dscp-cfg
              }  // case dscp

              case source-ip-address {
                description
                  "Filter containing list of source ip addresses";
                list source-ip-address-cfg {
                  key "source-ip-addr";
                  description
                    "list of source ip address";
                  leaf source-ip-addr {
                    type inet:ip-prefix;
                    description
                      "source ip prefix";
                  }
                }  // list source-ip-address-cfg
              }  // case source-ip-address

              case destination-ip-address {
                description
                  "Filter containing list of destination ip address";
                list destination-ip-address-cfg {
                  key "destination-ip-addr";
                  description
                    "list of destination ip address";
                  leaf destination-ip-addr {
                    type inet:ip-prefix;
                    description
                      "destination ip prefix";
                  }
                }  // list destination-ip-address-cfg
              }  // case destination-ip-address

              case source-port {
                description
                  "Filter containing list of source-port ranges";
                list source-port-cfg {
                  key "source-port-min source-port-max";
                  description
                    "list of ranges of source port";
                  leaf source-port-min {
                    type inet:port-number;
                    description
                      "minimum value of source port range";
                  }

                  leaf source-port-max {
                    type inet:port-number;
                    description
                      "maximum value of source port range";
                  }
                }  // list source-port-cfg
              }  // case source-port

              case destination-port {
                description
                  "Filter containing list of destination-port ranges";
                list destination-port-cfg {
                  key "destination-port-min destination-port-max";
                  description
                    "list of ranges of destination port";
                  leaf destination-port-min {
                    type inet:port-number;
                    description
                      "minimum value of destination port range";
                  }

                  leaf destination-port-max {
                    type inet:port-number;
                    description
                      "maximum value of destination port range";
                  }
                }  // list destination-port-cfg
              }  // case destination-port

              case protocol {
                description
                  "Filter Type Protocol";
                list protocol-cfg {
                  key "protocol-min protocol-max";
                  description
                    "list of ranges of protocol values";
                  leaf protocol-min {
                    type uint8 {
                      range "0..255";
                    }
                    description
                      "minimum value of protocol range";
                  }

                  leaf protocol-max {
                    type uint8 {
                      range "0..255";
                    }
                    description
                      "maximum value of protocol range";
                  }
                }  // list protocol-cfg
              }  // case protocol
            }  // choice filter-param
          }  // list filter-entry

          list classifier-action-entry-cfg {
            key "action-type";
            ordered-by user;
            description
              "Configuration of classifier & associated actions";
            leaf action-type {
              type identityref {
                base action-type;
              }
              description
                "This defines action type ";
            }

            choice action-cfg-params {
              description
                "Choice of action types";
              container marking-cfg {
                description
                  "Marking configuration container";
                leaf dscp {
                  type inet:dscp;
                  description "dscp marking";
                }
              }  // container marking-cfg
              container priority-cfg {
                description
                  "priority attributes container";
                leaf priority-level {
                  type uint8;
                  description
                    "priority level";
                }

                container rate-burst {
                  if-feature priority-rate-burst-support;
                  description
                    "absolute priority rate with/without burst rateand absolute percent";
                  leaf rate {
                    type uint64;
                    units "bits-per-second";
                    description "Rate value";
                  }

                  leaf absolute-rate-metric {
                    type policy-types:metric;
                    default "none";
                    description "Metric";
                  }

                  leaf absolute-rate-units {
                    type policy-types:rate-unit;
                    description
                      "Rate basic units";
                  }

                  leaf rate-percent {
                    type percent-value-1to100;
                    description "percent";
                  }

                  leaf rate-ratio {
                    type uint32 {
                      range "1..65532";
                    }
                  }

                  choice burst-type {
                    description
                      "Choice of burst type";
                    leaf burst-size {
                      type uint64;
                      units "bytes";
                      description
                        "burst size";
                    }
                    leaf burst-interval {
                      type uint64;
                      units "microsecond";
                      description
                        "burst interval";
                    }
                  }  // choice burst-type
                }  // container rate-burst
              }  // container priority-cfg
              container meter-cfg {
                description
                  "Meter list configuration container";
                list meter-list {
                  key "meter-id";
                  description
                    "Meter configuration";
                  leaf meter-id {
                    type uint16;
                    description
                      "meter identifier";
                  }

                  leaf meter-rate {
                    type uint64;
                    units "bits-per-second";
                    description "meter rate";
                  }

                  choice burst-type {
                    description
                      "Choice of burst type";
                    leaf burst-size {
                      type uint64;
                      units "bytes";
                      description
                        "burst size";
                    }
                    leaf burst-interval {
                      type uint64;
                      units "microsecond";
                      description
                        "burst interval";
                    }
                  }  // choice burst-type

                  container color {
                    description
                      "color aware & color blind attributes container";
                    leaf classifier-entry-name {
                      type string;
                      description
                        "Diffserv classifier name";
                    }

                    leaf classifier-entry-descr {
                      type string;
                      description
                        "Description of the class template";
                    }

                    leaf classifier-entry-filter-operation {
                      type identityref {
                        base classifier-entry-filter-operation-type;
                      }
                      default
                        "match-any-filter";
                      description
                        "Filters are applicable as any or all filters";
                    }
                  }  // container color

                  container succeed-action {
                    description
                      "confirm action";
                    leaf meter-action-type {
                      type identityref {
                        base meter-action-type;
                      }
                      description
                        "meter action type";
                    }

                    leaf next-meter-id {
                      type uint16;
                      description
                        "next meter identifier";
                    }

                    choice val {
                      description
                        " meter action based on choice of meter action type";
                      case meter-action-mark {
                        description
                          "meter action: mark";
                        leaf dscp {
                          type inet:dscp;
                          description
                            "dscp marking";
                        }
                      }  // case meter-action-mark

                      case meter-action-drop {
                        description
                          "meter action: drop";
                        leaf drop-action {
                          type empty;
                          description
                            "always drop algorithm";
                        }
                      }  // case meter-action-drop
                    }  // choice val
                  }  // container succeed-action

                  container fail-action {
                    description
                      "exceed action";
                    leaf meter-action-type {
                      type identityref {
                        base meter-action-type;
                      }
                      description
                        "meter action type";
                    }

                    leaf next-meter-id {
                      type uint16;
                      description
                        "next meter identifier";
                    }

                    choice val {
                      description
                        " meter action based on choice of meter action type";
                      case meter-action-mark {
                        description
                          "meter action: mark";
                        leaf dscp {
                          type inet:dscp;
                          description
                            "dscp marking";
                        }
                      }  // case meter-action-mark

                      case meter-action-drop {
                        description
                          "meter action: drop";
                        leaf drop-action {
                          type empty;
                          description
                            "always drop algorithm";
                        }
                      }  // case meter-action-drop
                    }  // choice val
                  }  // container fail-action
                }  // list meter-list
              }  // container meter-cfg
              container min-rate-cfg {
                description
                  "min guaranteed bandwidth";
                leaf min-rate {
                  type uint64;
                  units "bits-per-second";
                  description "minimum rate";
                }

                leaf absolute-rate-metric {
                  type policy-types:metric;
                  default "none";
                  description "Metric";
                }

                leaf absolute-rate-units {
                  type policy-types:rate-unit;
                  description
                    "Rate basic units";
                }

                leaf rate-percent {
                  type percent-value-1to100;
                  description "percent";
                }

                leaf rate-ratio {
                  type uint32 {
                    range "1..65532";
                  }
                }

                container bw-excess-share-cfg {
                  description
                    "share the bandwidth remaming";
                  leaf value {
                    type uint32;
                    description
                      "percentage or ratio value";
                  }

                  leaf absolute-rate-metric {
                    type policy-types:metric;
                    default "none";
                    description "Metric";
                  }

                  leaf absolute-rate-units {
                    type policy-types:rate-unit;
                    description
                      "Rate basic units";
                  }

                  leaf rate-percent {
                    type percent-value-1to100;
                    description "percent";
                  }

                  leaf rate-ratio {
                    type uint32 {
                      range "1..65532";
                    }
                  }
                }  // container bw-excess-share-cfg
              }  // container min-rate-cfg
              container max-rate-cfg {
                description
                  "maximum rate attributes";
                leaf absolute-rate {
                  type uint64;
                  units "bits-per-second";
                  description
                    "rate in bits per second";
                }

                choice burst-type {
                  description
                    "Choice of burst type";
                  leaf burst-size {
                    type uint64;
                    units "bytes";
                    description "burst size";
                  }
                  leaf burst-interval {
                    type uint64;
                    units "microsecond";
                    description
                      "burst interval";
                  }
                }  // choice burst-type

                leaf absolute-rate-metric {
                  type policy-types:metric;
                  default "none";
                  description "Metric";
                }

                leaf absolute-rate-units {
                  type policy-types:rate-unit;
                  description
                    "Rate basic units";
                }

                leaf rate-percent {
                  type percent-value-1to100;
                  description "percent";
                }

                leaf rate-ratio {
                  type uint32 {
                    range "1..65532";
                  }
                }
              }  // container max-rate-cfg
              choice drop-algorithm {
                description
                  "Choice of Drop Algorithm";
                container drop-cfg {
                  description
                    "Always Drop configuration container";
                  leaf drop-action {
                    type empty;
                    description
                      "always drop algorithm";
                  }
                }  // container drop-cfg
                container tail-drop-cfg {
                  description
                    "Tail Drop configuration container";
                  list qlimit-dscp-thresh {
                    key "dscp-min dscp-max";
                    description
                      "the queue limit per dscp range";
                    leaf dscp-min {
                      type inet:dscp;
                      description
                        "Minimum of dscp range";
                    }

                    leaf dscp-max {
                      type inet:dscp;
                      description
                        "Maximum of dscp range";
                    }

                    container threshold {
                      description
                        "threshold";
                      choice threshold-type {
                        description
                          "Choice of threshold type";
                        leaf threshold-size {
                          type uint64;
                          units "bytes";
                          description
                            "Threshold size";
                        }
                        leaf threshold-interval {
                          type uint64;
                          units
                            "microsecond";
                          description
                            "Threshold interval";
                        }
                      }  // choice threshold-type
                    }  // container threshold
                  }  // list qlimit-dscp-thresh
                }  // container tail-drop-cfg
                container random-detect-cfg {
                  if-feature aqm-red-support;
                  description
                    "Random Detect configuration container";
                  leaf exp-weighting-const {
                    type uint32;
                    description
                      "Exponential weighting constant factor for red profile ";
                  }

                  container red-min-thresh {
                    description
                      "Minimum threshold";
                    container threshold {
                      description
                        "threshold";
                      choice threshold-type {
                        description
                          "Choice of threshold type";
                        leaf threshold-size {
                          type uint64;
                          units "bytes";
                          description
                            "Threshold size";
                        }
                        leaf threshold-interval {
                          type uint64;
                          units
                            "microsecond";
                          description
                            "Threshold interval";
                        }
                      }  // choice threshold-type
                    }  // container threshold
                  }  // container red-min-thresh

                  container red-max-thresh {
                    description
                      "Maximum threshold";
                    container threshold {
                      description
                        "threshold";
                      choice threshold-type {
                        description
                          "Choice of threshold type";
                        leaf threshold-size {
                          type uint64;
                          units "bytes";
                          description
                            "Threshold size";
                        }
                        leaf threshold-interval {
                          type uint64;
                          units
                            "microsecond";
                          description
                            "Threshold interval";
                        }
                      }  // choice threshold-type
                    }  // container threshold
                  }  // container red-max-thresh

                  leaf mark-probability {
                    type uint32 {
                      range "1..1000";
                    }
                    description
                      "Mark probability";
                  }
                }  // container random-detect-cfg
              }  // choice drop-algorithm
            }  // choice action-cfg-params
          }  // list classifier-action-entry-cfg
        }  // list classifier-entry
      }  // list policy-entry
    }  // container policies
  }  // module ietf-diffserv-policy