ciena-mef-qos-flow

This YANG module defines the QoS Flow.

  • Version: 2017-10-23

    ciena-mef-qos-flow@2017-10-23


    
      module ciena-mef-qos-flow {
    
        yang-version 1;
    
        namespace
          "urn:ciena:params:xml:ns:yang:ciena-pn::ciena-mef-qos-flow";
    
        prefix flow;
    
        import ciena-mef-classifier {
          prefix classifier;
        }
        import ciena-mef-meter-profile {
          prefix meter;
        }
        import ciena-mef-frame-to-cos-map {
          prefix ftc;
        }
        import ciena-mef-cos-to-frame-map {
          prefix ctf;
        }
        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 the QoS Flow.";
    
        revision "2017-10-23" {
          description
            "Added missing reference and description.";
          reference
            "RFC 6020: YANG - A Data Modeling Language for
            the Network Configuration Protocol (NETCONF).
            No specific reference; standard not available.";
    
        }
    
        revision "2016-02-03" {
          description "Initial revision.";
          reference
            "RFC 6020: YANG - A Data Modeling Language for
            the Network Configuration Protocol (NETCONF).
            No specific reference; standard not available.";
    
        }
    
    
        typedef qos-flow-ref {
          type leafref {
            path "/flow:qos-flows/flow:qos-flow/flow:name";
          }
          description
            "This type is used by the data models that needs to reference
                 configured QoS flows.";
        }
    
        container qos-flows {
          description
            "Contains the list of QoS flows present currently in the system.";
          list qos-flow {
            key "name";
            description
              "This represents configurational data of corresponding QoS flow.";
            leaf name {
              type string;
              description
                "A unique string that is either system assigned or assigned
                         by the user but does not change over its life.";
            }
    
            leaf description {
              type string;
              description
                "A more detailed description that an operator can use
                         to describe the flow.";
            }
    
            leaf-list classifier-list {
              type classifier:classifier-ref;
              description
                "A reference to a list of classifier entries.";
            }
    
            leaf classifier-precedence {
              type uint32;
              description
                "A precedence value for the qos flow. Lower values take
                         precedence over higher values.";
            }
    
            leaf meter-profile {
              type meter:meter-ref;
              description
                "A reference to a Meter Profile.";
            }
    
            choice parent-interface {
              description
                "Parent interfaces can be either logical port(s) or FP(s).";
              leaf-list parent-port {
                type mef-logical-port:logical-port-ref;
                description
                  "A reference to list of logical ports, that this 
                                 traffic-profile is acting on.";
              }
              leaf-list parent-fp {
                type mef-fp:fp-ref;
                description
                  "A reference to FP, represents a list of FPs that
                                 acting on this QoS flow.";
              }
            }  // choice parent-interface
    
            leaf cos-to-frame-map {
              type ctf:cos-to-frame-ref;
              description
                "A reference to a CoS to Frame map.";
            }
    
            choice frame-to-cos-map {
              description
                "Frame to CoS mapping can be either mapped or fixed.";
              case map {
                leaf map-policy {
                  type enumeration {
                    enum "outer-vlan-tag" {
                      value 0;
                      description
                        "Use outer VLAN to map to CoS 
                                         and color.";
                    }
                    enum "inner-vlan-tag" {
                      value 1;
                      description
                        "Use inner VLAN to map to CoS
                                         and color.";
                    }
                    enum "dscp" {
                      value 2;
                      description
                        "Use DSCP to map to CoS and 
                                         color.";
                    }
                    enum "outer-mpls-tc" {
                      value 3;
                      description
                        "Use MPLS EXP bits to map to CoS
                                         and color.";
                    }
                  }
                  description
                    "This represents mapping policy value for CoS and color.";
                }
    
                leaf map-entry {
                  type ftc:frame-to-cos-ref;
                  description
                    "A reference to a Frame to CoS map.";
                }
              }  // case map
    
              case fixed {
                leaf fixed-cos {
                  type uint16 {
                    range "0..63";
                  }
                  description
                    "This represents fixed cos value assigned when the
                                 CoS policy is fixed.";
                }
    
                leaf fixed-color {
                  type enumeration {
                    enum "green" {
                      value 0;
                      description
                        "Fixed color value Green.";
                    }
                    enum "yellow" {
                      value 1;
                      description
                        "Fixed color value Yellow.";
                    }
                    enum "red" {
                      value 2;
                      description
                        "Fixed color value Red.";
                    }
                  }
                  description
                    "Fixed color value assigned when the CoS policy is set to fixed.";
                }
              }  // case fixed
            }  // choice frame-to-cos-map
    
            choice ingress-l2-transform {
              description
                "This represents ingress L2 transform.";
              case stamp {
                choice dei-policy {
                  description
                    "DEI policy can be either mapped or fixed.";
                  leaf dei-map {
                    type empty;
                    description
                      "Map from the incoming frame.";
                  }
                  leaf dei-value {
                    type boolean;
                    description
                      "Fixed DEI value.";
                  }
                }  // choice dei-policy
    
                choice pcp-policy {
                  description
                    "PCP policy can be either mapped or fixed.";
                  leaf pcp-map {
                    type empty;
                    description
                      "Map from the incoming frame.";
                  }
                  leaf pcp-value {
                    type uint8 {
                      range "0..7";
                    }
                    description
                      "Fixed PCP value.";
                  }
                }  // choice pcp-policy
              }  // case stamp
            }  // choice ingress-l2-transform
    
            choice ingress-l3-transform {
              description
                "This represents ingress L3 transform.";
              choice dscp-policy {
                description
                  "This choice describes DSCP policy can either mapped to frame-to-cos
                                 value or can be a fixed value in range 0 to 63.";
                leaf dscp-map {
                  type ftc:frame-to-cos-ref;
                  description
                    "Reference to a Frame to CoS Map.";
                }
                leaf dscp-value {
                  type uint8 {
                    range "0..63";
                  }
                  description
                    "Fixed DSCP value.";
                }
              }  // choice dscp-policy
            }  // choice ingress-l3-transform
    
            leaf stats-collection {
              type enumeration {
                enum "on" {
                  value 0;
                  description
                    "Stats collection on.";
                }
                enum "off" {
                  value 1;
                  description
                    "Stats collection off.";
                }
              }
              description
                "Determines whether stats collection will be turned on or not for a qos-flow.";
            }
          }  // list qos-flow
        }  // container qos-flows
    
        container qos-flow-state {
          config false;
          description
            "Global Qos Flow operational data.";
          list qos-flow {
            key "name";
            description
              "The operational data for this Qos Flow.";
            leaf name {
              type string;
              description
                "A string that identifies the Qos Flow.";
            }
          }  // list qos-flow
        }  // container qos-flow-state
      }  // module ciena-mef-qos-flow
    

© 2023 YumaWorks, Inc. All rights reserved.