Network Working Group                                            X. Geng
Internet-Draft                                                   M. Chen
Intended status: Standards Track                     Huawei Technologies
Expires: May 7, September 10, 2020                                      Y. Ryoo
                                                                    ETRI
                                                                   Z. Li
                                                            China Mobile
                                                               R. Rahman
                                                           Cisco Systems
                                                       November 04, 2019
                                                                D. Fedyk
                                                 LabN Consulting, L.L.C.
                                                          March 09, 2020

       Deterministic Networking (DetNet) Configuration YANG Model
                       draft-ietf-detnet-yang-04
                       draft-ietf-detnet-yang-05

Abstract

   This document contains the specification for Deterministic Networking
   flow configuration YANG Model.  The model allows for provisioning of
   end-to-end DetNet service along the path without dependency on any
   signaling protocol.

   The YANG module defined in this document conforms to the Network
   Management Datastore Architecture (NMDA).

Requirements Language

   The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
   "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
   document are to be interpreted as described in RFC 2119 [RFC2119].

Status of This Memo

   This Internet-Draft is submitted in full conformance with the
   provisions of BCP 78 and BCP 79.

   Internet-Drafts are working documents of the Internet Engineering
   Task Force (IETF).  Note that other groups may also distribute
   working documents as Internet-Drafts.  The list of current Internet-
   Drafts is at https://datatracker.ietf.org/drafts/current/.

   Internet-Drafts are draft documents valid for a maximum of six months
   and may be updated, replaced, or obsoleted by other documents at any
   time.  It is inappropriate to use Internet-Drafts as reference
   material or to cite them other than as "work in progress."
   This Internet-Draft will expire on May 7, September 10, 2020.

Copyright Notice

   Copyright (c) 2019 2020 IETF Trust and the persons identified as the
   document authors.  All rights reserved.

   This document is subject to BCP 78 and the IETF Trust's Legal
   Provisions Relating to IETF Documents
   (https://trustee.ietf.org/license-info) in effect on the date of
   publication of this document.  Please review these documents
   carefully, as they describe your rights and restrictions with respect
   to this document.  Code Components extracted from this document must
   include Simplified BSD License text as described in Section 4.e of
   the Trust Legal Provisions and are provided without warranty as
   described in the Simplified BSD License.

Table of Contents

   1.  Introduction  . . . . . . . . . . . . . . . . . . . . . . . .   3   2
   2.  Terminologies . . . . . . . . . . . . . . . . . . . . . . . .   4   3
   3.  DetNet Service Module . . . . . . . . . . . . . . . . . . . .   4
     3.1.  Service Quality . . . . . . . . . . . . . . . . . . . . .   4
     3.2.  Service Endpoints . . . . . . . . . . . . . . . . . . . .   4
     3.3.  Service Encapsulation . . . . . . . . . . . . . . . . . .   5
   4.  DetNet Configuration Module . . . . . . . . . . . . . . . . .   5
     4.1.   3
     3.1.  DetNet Appliction Flow Configuration Attributes . . . . .   5
     4.2.   3
     3.2.  DetNet Service Sub-layer Configuration Attributes . . . .   5
     4.3.   3
     3.3.  DetNet Forwarding Sub-layer Configuration Attributes  . .   6
     4.4.  DetNet Sub-network Configurations Attributes  . . . . . .   6
   5.  Overview of DetNet YANG . . . . . . . . . . . . . . . . . . .   7
     5.1.   3
   4.  DetNet YANG Structure Considerations  . . . . . . . . . . . . . . .   7
       5.1.1.  DetNet Service YANG Considerations  . . . . . . . . .   7
       5.1.2.   4
   5.  DetNet Configuration YANG Considerations  . . . . . .   7
     5.2.  DetNet YANG Structures  . . . . . . . . . . . . . . . . .   8
       5.2.1.  DetNet Service YANG Structure . . . . . . . . . . . .   8
       5.2.2.  DetNet Configuration YANG Structure . . . . . . . . .   8   5
   6.  DetNet Service YANG Model . . . . . . . . . . . . . . . . . .  11
   7.  DetNet Configuration YANG Model . . . . . . . . . . . . . . .  11
   8.  18
   7.  Open Issues . . . . . . . . . . . . . . . . . . . . . . . . .  35
   9.
   8.  IANA Considerations . . . . . . . . . . . . . . . . . . . . .  36
   10.  35
   9.  Security Considerations . . . . . . . . . . . . . . . . . . .  36
   11.  35
   10. Acknowledgements  . . . . . . . . . . . . . . . . . . . . . .  36
   12.  35
   11. References  . . . . . . . . . . . . . . . . . . . . . . . . .  36
     12.1.  35
     11.1.  Normative References . . . . . . . . . . . . . . . . . .  36
     12.2.  35
     11.2.  Informative References . . . . . . . . . . . . . . . . .  37  36
   Authors' Addresses  . . . . . . . . . . . . . . . . . . . . . . .  39  38

1.  Introduction

   DetNet (Deterministic Networking) provides a capability to carry
   specified unicast or multicast data flows for real-time applications
   with extremely low packet loss rates and assured maximum end-to-end
   delivery latency.  A description of the general background and
   concepts of DetNet can be found in [I-D.ietf-detnet-architecture]. [RFC8655].

   This document defines a YANG model for DetNet based on YANG data
   types and modeling language defined in [RFC6991] and [RFC7950], which
   includes [RFC7950].
   DetNet service module and DetNet configuration module, and
   YANG model for topology discovery is defined in
   [I-D.ietf-detnet-topology-yang].  DetNet service module service, which is designed for describe describing the characteristics
   of services being provided for application flows over a network, while the and
   DetNet configuration
   module configuration, which is designed for DetNet flow path
   establishment, flow status reporting, and DetNet functions
   configuration in order to achieve end-to-end bounded latency and zero
   congestion loss.

     DetNet          Relay       Transit         Relay         DetNet
   End System        Node         Node           Node        End System
      (T-PE)        (S-PE)       (LSR)          (S-PE)         (T-PE)
   +----------+                                             +----------+
   |   Appl.  |<------------ End to End Service ----------->|   Appl.  |
   +----------+   +---------+                 +---------+   +----------+
   | Service  |<--| Service |-- DetNet flow --| Service |-->| Service  |
   +----------+   +---------+  +----------+   +---------+   +----------+
   |Forwarding|   |Fwd| |Fwd|  |Forwarding|   |Fwd| |Fwd|   |Forwarding|
   +-------.--+   +-.-+ +-.-+  +----.---.-+   +-.-+ +-.-+   +---.------+
           :  Link  :    /  ,-----.  \   : Link :    /  ,-----.  \
           +........+    +-[  Sub  ]-+   +......+    +-[  Sub  ]-+
                           [Network]                   [Network]
                            `-----'                     `-----'

                 Figure 1: An End-to-end DetNet-Enabled Network

   As showed loss, are both included in this document.

2.  Terminologies

   This documents uses the picture, terminologies defined in an end-to-end DetNet-enabled network,
   application flow is carried over a [RFC8655].

3.  DetNet service and the Configuration Module

   DetNet
   service is instantiated as different configuration parameters in
   different network device along the path.  DetNet service is an
   abstract concept for service provider, and module includes DetNet configuration needs
   device specific attributes.  YANG Models for App-flow configuration,
   DetNet service Service Sub-layer configuration, and DetNet configuration Forwarding Sub-
   layer configuration.  The corresponding attributes used in different
   sub-layers are defined in detail respectively in section 3
   and section 4.

   Editor's notes:

   Detnet YANG model and Section 3.1, 3.2, 3.3 respectively.

3.1.  DetNet information model are supposed to keep
   the same structure Appliction Flow Configuration Attributes

   DetNet application flow is responsible for mapping between
   application flows and describes DetNet flows at the same attributes by different
   methods.  But edge node(egress/ingress
   node).  Where the design of these two models are still under
   discussion.  The divergence will application flows can be settled in either layer 2 or layer 3
   flows.  To map a flow at the following
   versions.

2.  Terminologies

   This documents uses User Network Interface (UNI), the terminologies
   corresponding attributes are defined in
   [I-D.ietf-detnet-architecture].

3.
   [I-D.ietf-detnet-flow-information-model].

3.2.  DetNet Service Module Sub-layer Configuration Attributes

   DetNet Service Module includes service quality attributes, service
   endpoints attributes functions, e.g., DetNet tunnel initialization/
   termination and service encapsulation type attributes, which protection, are defined provided in Section 3.1, 3.2, 3.3 respectively.

3.1.  Service Quality DetNet service quality includes
   sub-layer.  To support these functions, the following attributes:

   o  Maximum Latency: MaxLatency is the maximum latency from Ingress service
   attributes need to
      Egress(es) for a single packet of the be configured:

   o  DetNet flow.  MaxLatency is
      specified as an integer number of nanoseconds. flow identification

   o  Maximum Latency Variation: MaxLatencyVariation is the difference
      between the minimum and the maximum end-to-end one-way latency.
      MaxLatencyVariation  Service function indication, indicates which service function will
      be invoked at a DetNet edge, relay node or end station.  (DetNet
      tunnel initialization or termination are default functions in
      DetNet service layer, so there is specified as an integer number of
      nanoseconds.

   o  Maximum Loss: MaxLoss defines the maximum Packet Loss Ratio (PLR)
      parameter no need for explicit
      indication).  The corresponding arguments for service functions
      also needs to be defined.

3.3.  DetNet Forwarding Sub-layer Configuration Attributes

   As defined in [RFC8655], DetNet forwarding sub-layer optionally
   provides congestion protection for DetNet flows over paths provided
   by the underlying network.  Explicit route is another mechanism that
   is used by DetNet service between to avoid temporary interruptions caused by the Ingress and
      Egress(es)
   convergence of routing or bridging protocols, and it is also
   implemented at the DetNet domain.

   o  Maximum Consecutive Loss: Maximum Consecutive Loss defines forwarding sub-layer.

   To support congestion protection and explicit route, the
      consecutive packet loss number. following
   transport layer related attributes are necessary:

   o  Maximum Misordering: MaxMisordering describes the maximum number  Traffic Specification, refers to Section 7.2 of packets that
      [I-D.ietf-detnet-flow-information-model].  It may used for
      resource reservation, flow shaping, filtering and policing.

   o  Explicit path, existing explicit route mechanisms can be received out of order.

3.2.  Service Endpoints

   Endpoints attribute defines reused.
      For example, if Segment Routing (SR) tunnel is used as the starting and termination reference
   points of
      transport tunnel, the DetNet flow by pointing to configuration is mainly at the ingress interface/node
   and egress interface(s)/node(s).

3.3.  Service Encapsulation

   Service Encapsulation attribute defines the data plane type node
      of the
   DetNet service in a DetNet domain, e.g., MPLS, IP.

   Editor's notes: DetNet service module transport layer; if the static MPLS tunnel is just defined in used as the document
   and
      transport tunnel, the yang model is still under work. configurations need to be at every transit
      node along the path; for pure IP based transport tunnel, it's
      similar to the static MPLS case.

4.  DetNet Configuration Module YANG Structure Considerations

   The picture shows that the general structure of the DetNet configuration module includes YANG
   Model:

                     +-----------+
                     |ietf-detnet|
                     +-----+-----+
                           |
             +-------------+---------------+
             |             |               |
       +-----+-----+ +-----+-----+ +-------+------+
       | App Flows | |service s-l| |forwarding s-l|
       +-----------+ +-----------+ +--------------+

   There are three instances in DetNet YANG Model: App-flow configuration,
   DetNet Service Sub-layer configuration, and DetNet Forwarding Sub-
   layer configuration instance,
   service sub-layer instance and DetNet sub-network.  The forwarding sub-layer instance,
   respectively corresponding
   attributes used in different sub-layers are to four parts of DetNet functions defined
   in Section 3.1,
   3.2, 3.3, 3.4 respectively.

4.1.  DetNet Appliction Flow Configuration Attributes

   DetNet application flow is responsible for mapping between
   application flows section 3.  In each instance, there are four elements: name, in-
   segments, out-segments and DetNet flows at operations, which means:

   o  Name: indicates the edge node(egress/ingress
   node).  Where key value of the application flows can be either layer instance identification.

   o  In-segments: indicates the key value of identification, e.g.,
      Layer 2 or layer App flow identification, Layer 3
   flows.  To identify a App flow at the User Network Interface (UNI), as
   defined in [I-D.ietf-detnet-flow-information-model], the following identification
      and DetNet flow attributes are introduced: identification.

   o  DetNet L3 Flow Identification, refers to Section 7.1.1  Out-segments: indicates the information of
      [I-D.ietf-detnet-flow-information-model]

   o DetNet L2 Flow Identification, refers to Section 7.1.2 of
      [I-D.ietf-detnet-flow-information-model]

   Application flow can also do flow filtering processing(e.g.,
      DetNet forwarding, DetNet header Encapsulation) and policing at the
   ingress mapping
      relationship to prevent the misbehaviored flows from going into the
   network, which needs: lower sub-layer/sub-network.

   o  Traffic Specification, refers to Section 7.2 of
      [I-D.ietf-detnet-flow-information-model]

4.2.  DetNet Service Sub-layer Configuration Attributes  Operations: indicates DetNet service functions, e.g., DetNet tunnel initialization/
   termination and service protection, are provided in DetNet service
   sub-layer.  To support these forwarding
      functions, the following service
   attributes need to be configured:

   o DetNet flow identification, refers to Section 8.1.3 of
      [I-D.ietf-detnet-flow-information-model].

   o Service function indication, indicates which service function will
      be invoked at a functions, DetNet edge, relay node or end station.  (DetNet
      tunnel initialization or termination Resource Reservation.

   These elements are default functions in
      DetNet service layer, so there is no need for explicit
      indication.)

   o  Flow Rank, refers to Section 8.3 of
      [I-D.ietf-detnet-flow-information-model].

   o  Service Rank, refers to Section 16 of
      [I-D.ietf-detnet-flow-information-model].

   o  Service Sub-layer, refers to Section 4.5 and Section 4.6 of
      [I-D.ietf-detnet-mpls]

   o  Forwarding Sub-layer, refers to Section 4.3 of
      [I-D.ietf-detnet-ip] and Section 4.5 and Section 4.6 of
      [I-D.ietf-detnet-mpls]

4.3.  DetNet Forwarding Sub-layer Configuration Attributes

   As defined in [I-D.ietf-detnet-architecture], DetNet forwarding sub-
   layer optionally provides congestion protection for DetNet flows over
   paths provided by the underlying network.  Explicit route is another
   mechanism that is used by DetNet to avoid temporary interruptions
   caused by the convergence of routing or bridging protocols, and it is
   also implemented at the DetNet forwarding sub-layer.

   To support congestion protection and explicit route, different when the following
   transport layer related attributes are necessary:

   o  Traffic Specification, refers to Section 7.2 of
      [I-D.ietf-detnet-flow-information-model].  It may technologies used for
      bandwidth reservation, flow shaping, filtering and policing.

   o  Explicit path, existing explicit route mechanisms can be reused.
      For example, if Segment Routing (SR) tunnel is used as the
      transport tunnel, the configuration
   specific instance is mainly at the ingress node
      of the transport layer; if the static MPLS tunnel different.  So this structure is used as the
      transport tunnel, the configurations need to be at every transit
      node along the path; for pure IP based transport tunnel, it's
      similar to the static MPLS case.

4.4.  DetNet Sub-network Configurations Attributes

   TBD

5.  Overview of DetNet YANG

5.1.  DetNet YANG Considerations

5.1.1.  DetNet Service YANG Considerations

   TBD

5.1.2.  DetNet Configuration YANG Considerations

   The picture shows that the general structure of the DetNet YANG
   Model:

                        +-----------+
                        |ietf-detnet|
                        +-----+-----+
                              |
         +-------------+------+--------+--------------+
         |             |               |              |
   +-----+-----+ +-----+-----+ +-------+------+ +-----+-----+
   | App Flows | |service s-l| |forwarding s-l| |sub-network|
   +-----------+ +-----------+ +--------------+ +-----------+

   There are four instances in DetNet YANG Model: App-flow instance,
   service sub-layer instance, forwarding sub-layer instance and sub-
   network instance, respectively corresponding to four parts of DetNet
   functions defined in section 3.  In each instance, there are four
   elements: name, in-segments, out-segments and operations, which
   means:

   o  Name: indicates the key value of the instance identification.

   o  In-segments: indicates the key value of identification, e.g.,
      Layer 2 App flow identification, Layer 3 App flow identification
      and DetNet flow identification.

   o  Out-segments: indicates the information of DetNet processing(e.g.,
      DetNet forwarding, DetNet header Encapsulation) and the mapping
      relationship to the lower sub-layer/sub-network.

   o  Operations: indicates DetNet functions, e.g., DetNet forwarding
      functions, DetNet Service functions, DetNet Resource Reservation.

   These elements are different when the technologies used for the
   specific instance is different.  So this structure is abstract, which
   allows for different technology specifics abstract, which
   allows for different technology specifics as defined in different
   data plane drafts.

5.2.  DetNet YANG Structures

5.2.1.  DetNet Service YANG Structure

   TBD

5.2.2.

5.  DetNet Configuration YANG Structure Structures

module: ietf-detnet-config
  +--rw app-flow app-flows
  |  +--rw operations app-flow* [name]
  |     +--rw name                      string
  |     +--rw sequence-number end-points
  |     |  +--rw sequence-number-generation-type?   sequence-number-generation-type source-endpoint?       inet:ip-address
  |     |  +--rw sequence-number-length?            uint8 destination-endpoints* inet:ip-address
  |     +--rw in-segments
         | app-flow-bidir-congruent? boolean
  |     +--rw app-flow-type?             flow-type-ref traffic-requirements
  |     |  +--rw source-mac-address?        yang:mac-address min-bandwidth?                  uint64
  |     |  +--rw destination-mac-address?   yang:mac-address max-latency?                    uint32
  |     |  +--rw ethertype?                 eth:ethertype max-latency-variation?          uint32
  |     |  +--rw vlan-id?                   uint16 max-loss?                       uint8
  |     |  +--rw pcp?                       uint8 max-consecutive-loss-tolerance? uint32
  |     |  +--rw src-ipv4-prefix            inet:ipv4-prefix
         | max-misordering?                uint32
  |     +--rw dest-ipv4-prefix           inet:ipv4-prefix traffic-specification
  |     |  +--rw protocol                   uint8 interval?                     uint32
  |     |  +--rw dscp?                      uint8
         |  |  +--rw dscp-bitmask?              uint8 max-packets-per-interval?     uint32
  |     |  +--rw src-ipv6-prefix            inet:ipv6-prefix max-payload-size?             uint32
  |     |  +--rw dest-ipv6-prefix           inet:ipv6-prefix average-packets-per-interval? uint32
  |     |  +--rw next-header                uint8
         | average-payload-size?         uint32
  |     +--rw traffic-class?             uint8 in-segment
  |     |  +--rw traffic-class-bitmask?     uint8 app-traffic* [interface]
  |     |     +--rw flow-label?                inet:ipv6-flow-label interface                if:interface-ref
  |     |     +--rw flow-label-flag?           boolean (data-flow-type)?
  |     |  +--rw lower-source-port?         inet:port-number        +--:(tsn-app-flow)
  |     |  +--rw upper-source-port?         inet:port-number
         |        |  +--rw lower-destination-port?    inet:port-number
         | source-mac-address?      yang:mac-address
  |  +--rw upper-destination-port?    inet:port-number     |  +--rw out-segments        |  +--rw detnet-service-sub-layer?   lower-layer-ref
         +--rw service-sub-layer destination-mac-address? yang:mac-address
  |  +--rw operations     |        |  +--rw service-operation ethertype?               eth:ethertype
  |     |        |  +--rw service-operation-type?   service-operation-ref
         | vlan-id?                 uint16
  |  +--rw service-protection     |        |  +--rw service-protection-type?   service-protection-type pcp?                     uint8
  |  +--rw in-segments     |        +--:(ip-app-flow)
  |  +--rw detnet-service-type?   flow-type-ref     |        |  +--rw detnet-service-list* [detnet-service-index]
         | src-ip-prefix?           inet:ip-prefix
  |     +--rw detnet-service-index        uint8     |        |  +--rw src-ipv4-prefix             inet:ipv4-prefix dest-ip-prefix?          inet:ip-prefix
  |     |     +--rw dest-ipv4-prefix            inet:ipv4-prefix
         |        |  +--rw protocol next-header?             uint8
  |     |     +--rw dscp?                       uint8
         |        |  +--rw dscp-bitmask? traffic-class?           uint8
  |     |     +--rw src-ipv6-prefix             inet:ipv6-prefix
         |        |  +--rw dest-ipv6-prefix            inet:ipv6-prefix
         | flow-label?              inet:ipv6-flow-label
  |     +--rw next-header                 uint8     |        |  +--rw traffic-class?              uint8 source-port
  |     |     +--rw traffic-class-bitmask?      uint8        |  |  +--rw flow-label?                 inet:ipv6-flow-label (port-range-or-operator)?
  |     |     +--rw flow-label-flag?            boolean        |  |     +--rw mpls-flow-identification     +--:(range)
  |     |        +--rw platform-label-flag?        boolean        |  |        +--rw non-platform-label-space     |  +--rw lower-port  inet:port-number
  |     |  +--rw incoming-interface?         if:interface-ref        |  |     |  +--rw non-platform-label-stack* [index]
         | upper-port  inet:port-number
  |     |     +--rw index    uint8        |  |     +--:(operator)
  |     +--rw label?   rt-type:mpls-label     |        |  |        +--rw tc?      uint8 operator?   operator
  |     |        +--rw platform-label-space        |  |        +--rw label?   rt-type:mpls-label port        inet:port-number
  |     |           +--rw tc?      uint8        |  +--rw out-segments destination-port
  |     +--rw detnet-service-processing-type?   flow-type-ref     |     +--rw detnet-service-encapsulation        |        +--rw detnet-service-processing-list* [detnet-service-processing-index]  |  +--rw detnet-service-processing-index     uint32 (port-range-or-operator)?
  |           +--rw ip-flow     |        |  +--rw ipv4-flow  |     +--:(range)
  |     |  +--rw src-ipv4-address     inet:ipv4-address        |  |     |  +--rw dest-ipv4-address    inet:ipv4-address
         | lower-port  inet:port-number
  |     |  +--rw protocol             uint8        |  |     |  +--rw dscp?                uint8 upper-port  inet:port-number
  |     |  +--rw ipv6-flow        |  |     +--:(operator)
  |  +--rw src-ipv6-address     inet:ipv6-address     |        |  |        +--rw dest-ipv6-address    inet:ipv6-address operator?   operator
  |     |        |  |        +--rw next-header          uint8 port        inet:port-number
  |     |        |  +--rw traffic-class?       uint8 ipsec-spi?               ipsec-spi
  |     |  |  +--rw flow-label?          inet:ipv6-flow-label        +--:(mpls-app-flow)
  |     |           +--rw l4-port-header (label-space)?
  |     |     +--rw source-port?        inet:port-number              +--:(non-platrom-label-space)
  |     |     +--rw destination-port?   inet:port-number              |  +--rw mpls-flow mpls-label-stack
  |     |              |     +--rw detnet-mpls-label-stack* [index] entry* [id]
  |     |              |        +--rw index id             uint8
  |     |              |        +--rw label?                   rt-type:mpls-label         rt-types:mpls-label
  |     |              |        +--rw tc? ttl?           uint8
  |     |              |        +--rw s-bit?                   boolean traffic-class? uint8
  |     |     +--rw d-cw-encapsulate-flag?   boolean              +--:(platform-label-space)
  |           +--rw detnet-forwarding-sub-layer-info     |                 +--rw detnet-forwarding-sub-layer?   lower-layer-ref
         +--rw forwarding-sub-layer label?                   rt-types:mpls-label
  |     +--rw operations
         | out-segment
  |        +--rw forwarding-operation (next-hop-options)
  |           +--:(simple-next-hop)
  |           |  +--rw forwarding-operation-type?   forwarding-operation-ref (header-type)?
  |           |  +--rw resource-allocate
         |  |  +--:(detnet-mpls-header)
  |  +--rw interval?                       uint32           |  |  |  +--rw max-packets-per-interval?       uint32
         | mpls-label-stack
  |           |  +--rw max-payload-size?               uint32
         |  |  |     +--rw average-packets-per-interval?   uint32 entry* [id]
  |           |  |  |        +--rw average-payload-size?           uint32 id             uint8
  |           |  |  +--rw qos  |        +--rw in-segments label?         rt-types:mpls-label
  |           |  +--rw detnet-forwarding-type?     flow-type-ref  |  |        +--rw src-ipv4-prefix             inet:ipv4-prefix ttl?           uint8
  |           |  +--rw dest-ipv4-prefix            inet:ipv4-prefix  |  |        +--rw protocol traffic-class? uint8
  |           |  +--rw dscp?                       uint8  |  +--:(detnet-ip-header)
  |  +--rw dscp-bitmask?               uint8           |  |     +--rw src-ipv6-prefix             inet:ipv6-prefix src-ip-address?   inet:ip-address
  |           |  |     +--rw dest-ipv6-prefix            inet:ipv6-prefix dest-ip-address?  inet:ip-address
  |           |  |     +--rw next-header next-header?      uint8
  |           |  |     +--rw traffic-class?    uint8
  |           |  +--rw traffic-class-bitmask?      uint8
         |  |     +--rw flow-label?       inet:ipv6-flow-label
  |           |  +--rw flow-label-flag?            boolean
         |  |  +--rw mpls-flow-identification
         |  |     +--rw platform-label-flag?        boolean
         |  |     +--rw non-platform-label-space source-port?      inet:port-number
  |           |  |     +--rw incoming-interface?         if:interface-ref
         | destination-port? inet:port-number
  |           |  +--rw non-platform-label-stack* lower-layer* [index]
  |           |     |     +--rw index                 uint8
  |           |     |     +--rw label?   rt-type:mpls-label (lower-layer-type)?
  |           |        +--:(service-sub-layer)
  |     +--rw tc?      uint8           |        |  +--rw platform-label-space service-sub-layer?    service-sub-layer-ref
  |           |        +--rw label?   rt-type:mpls-label        +--:(forwarding-sub-layer)
  |           |        +--rw tc?      uint8        |  +--rw out-segments forwarding-sub-layer? forwarding-sub-layer-ref
  |     +--rw detnet-forwarding-processing-type?   flow-type-ref           |     +--rw natively-detnet-forwarding        +--:(sub-network)
  |           |        |  +--rw ipv4-flow sub-network?          sub-network-ref
  |           |        +--:(interface)
  |           |           +--rw ipv4-next-hop-address?   inet:ipv4-address outgoing-interface?   if:interface-ref
  |           +--:(next-hop-list)
  |              +--rw ipv6-flow
         | next-hop-list
  |                 +--rw ipv6-next-hop-address?   inet:ipv6-address next-hop* [hop-index]
  |                    +--rw detnet-forwarding-encapsulation hop-index         uint8
  |                    +--rw ip-flow (header-type)?
  |                    |  +--rw ipv4-flow  +--:(detnet-mpls-header)
  |                    |  |  +--rw src-ipv4-address     inet:ipv4-address mpls-label-stack
  |                    |  |     +--rw dest-ipv4-address    inet:ipv4-address entry* [id]
  |                    |  |        +--rw protocol id             uint8
  |                    |  |        +--rw dscp?                uint8 label?         rt-types:mpls-label
  |                    |  |        +--rw ipv6-flow ttl?           uint8
  |                    |  |        +--rw src-ipv6-address     inet:ipv6-address traffic-class? uint8
  |                    |  +--:(detnet-ip-header)
  |                    |     +--rw dest-ipv6-address    inet:ipv6-address src-ip-address?   inet:ip-address
  |                    |     +--rw dest-ip-address?  inet:ip-address
  |                    |     +--rw next-header next-header?      uint8
  |                    |  |     +--rw traffic-class?    uint8
  |                    |  |     +--rw flow-label?       inet:ipv6-flow-label
  |                    |     +--rw l4-port-header
         |        |     +--rw source-port?      inet:port-number
  |                    |     +--rw destination-port? inet:port-number
  |                    +--rw mpls-flow
         |        |  +--rw detnet-mpls-label-stack* lower-layer* [index]
  |        |                       +--rw index                 uint8
  |        |                       +--rw label?                   rt-type:mpls-label (lower-layer-type)?
  |                          +--:(service-sub-layer)
  |                          |  +--rw service-sub-layer?    service-sub-layer-ref
  |                          +--:(forwarding-sub-layer)
  |                          |  +--rw forwarding-sub-layer? forwarding-sub-layer-ref
  |                          +--:(sub-network)
  |                          |  +--rw sub-network?          sub-network-ref
  |                          +--:(interface)
  |                             +--rw outgoing-interface?   if:interface-ref
  +--rw service-sub-layer
  |  +--rw service-sub-layer-list* [name]
  |     +--rw name                    string
  |     +--ro service-id?             uint16
  |     +--rw tc? service-rank?           uint8
  |     +--rw traffic-requirements
  |     |  +--rw s-bit?                   boolean min-bandwidth?                  uint64
  |     |  +--rw d-cw-encapsulate-flag?   boolean max-latency?                    uint32
  |     |  +--rw lower-layer-info max-latency-variation?          uint32
  |     |  +--rw lower-layer-type?   flow-type-ref max-loss?                       uint8
  |     |  +--rw interface max-consecutive-loss-tolerance? uint32
  |     |  +--rw outgoing-interface?   if:interface-ref max-misordering?                uint32
  |     +--rw sub-layer service-portection
  |     |  +--rw sub-layer?   lower-layer-ref

6.  DetNet Service YANG Model

   TBD

7.  DetNet Configuration YANG Model

<CODE BEGINS> file ietf-detnet-config@20190324.yang
module ietf-detnet-config {
  namespace "urn:ietf:params:xml:ns:yang:ietf-detnet-config";
  prefix "ietf-detnet";

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

  import ietf-inet-types{
    prefix "inet";
  }
  import ietf-ethertypes {
    prefix "eth";
  }

  import ietf-routing-types {
    prefix "rt-type";
  }

  import ietf-interfaces {
    prefix "if";
  }

  organization "IETF DetNet Working Group";

  contact
    "WG Web:   <http://tools.ietf.org/wg/detnet/>
     WG List:  <mailto: detnet@ietf.org>
     WG Chair: Lou Berger
                 <mailto:lberger@labn.net>

                 Janos Farkas
                 <mailto:janos.farkas@ericsson.com>

     Editor:   Xuesong Geng
                <mailto:gengxuesong@huawei.com>

     Editor:   Mach Chen
                <mailto:mach.chen@huawei.com>

     Editor:   Zhenqiang Li
                <mailto:lizhenqiang@chinamobile.com>

     Editor:   Reshad Rahman
                <mailto:rrahman@cisco.com>

     Editor:   Yeoncheol Ryoo
                <mailto:dbduscjf@etri.re.kr>";

  description
    "This YANG module describes the parameters needed
     for DetNet flow configuration and flow status reporting";

  revision 2019-03-24 {
    description "initial revision";
    reference "RFC XXXX: draft-ietf-detnet-yang-02";
  }

  identity ttl-action {
    description
      "Base identity from which all TTL
       actions are derived";
  }

  identity no-action {
    base "ttl-action";
    description
      "Do nothing regarding the TTL";
  }

  identity copy-to-inner {
    base "ttl-action";
    description
      "Copy the TTL of the outer header
       to the inner header";
  }

  identity decrease-and-copy-to-inner {
    base "ttl-action";
    description
      "Decrease TTL by one and copy the TTL
       to the inner header";
  }

  identity config-type {
    description
      "Base identity from which all configuration instances are derived";
  }

  identity App-flow {
    base "config-type";
    description
      "App-flow configuration";
  }

  identity service-sub-layer {
    base "config-type";
    description
      "A DetNet MPLS or IP service sub-layer configuration";
  }

  identity forwarding-sub-layer {
    base "config-type";
    description
      "A DetNet MPLS or IP forwarding sub-layer configuration";
  }
  identity tsn-sub-network {
    base "config-type";
    description
      "A TSN sub-net configuration";
  }

  identity flow-type {
    description
      "Base identity from which all flow type are derived";
  }

  identity ipv4 {
    base "flow-type";
    description
      "An IPv4 flow";
  }

  identity ipv6 {
    base "flow-type";
    description
      "An IPv6 flow";
  }

  identity mpls {
    base "flow-type";
    description
      "An MPLS flow";
  }

  identity l2 {
    base "flow-type";
    description
      "An MPLS flow";
  }

  identity tsn {
    base "flow-type";
    description
      "An MPLS flow";
  }

  identity service-operation {
    description
      "Base identity from which all service operation are derived";
  }

  identity service-initiation {
    base "service-operation";
    description
      "A DetNet service encapsulates";
  }

  identity service-termination {
    base "service-operation";
    description
      "A DetNet service decapsulates";
  }

  identity service-relay {
    base "service-operation";
    description
      "A DetNet service swap";
  }

  identity forwarding-operation {
    description
      "Base identity from which all data plane operation are derived";
  }

  identity natively-forward {
    base "forwarding-operation";
    description
      "A packet natively forward to lower-layer";
  }

  identity impose-and-forward {
    base "forwarding-operation";
    description
      "Impose a header(MPLS/IP) and forward to lower-layer";
  }

  identity pop-and-forward {
    base "forwarding-operation";
    description
      "Pop an identified packet header and forward to lower-layer";
  }

  identity pop-impose-and-forward {
    base "forwarding-operation";
    description
      "Pop an identified packet header, impose a one or more outgoing
       header and forward to lower-layer ";
  }

  identity swap-and-forward {
    base "forwarding-operation";
    description
      "Swap an identified packet header with outgoing header and forward
       to lower-layer ";
  }

  identity pop-and-lookup {
    base "forwarding-operation";
    description
      "Pop an identified packet header and perform a lookup";
  }
  identity label-space {
    description
      "Base identity from which all label space are derived";
  }

  identity platform-label {
    base "label-space";
    description
      "label allocated from the platform label space";
  }

  identity non-platform-label {
    base "label-space";
    description
      "label allocated from the non-platform label space";
  }

  typedef ttl-action-definition {
    type identityref {
      base "ttl-action";
    }
    description
      "TTL action definition";
  }

  typedef config-type-ref {
    type identityref {
      base "config-type";
    }
    description
      "config-type-ref";
  }

  typedef flow-type-ref {
    type identityref {
      base "flow-type";
    }
    description
      "flow-type-ref";
  }

  typedef service-operation-ref{
    type identityref {
      base "service-operation";
  }
  description
    "service-operation-ref";
  }

  typedef forwarding-operation-ref {
    type identityref {
      base "forwarding-operation";
    }
    description
      "forwarding-operation-ref";
  }

  typedef label-space-ref {
    type identityref {
      base "label-space";
    }
    description
      "label-space-ref";
  }

  typedef lower-layer-ref {
    type leafref {
      path "/ietf-detnet:detnet-config/ietf-detnet:detnet-config-list"
      + "/ietf-detnet:name";
    }
    description
     "lower-layer-ref";
  }

  typedef service-protection-type?     service-protection-type {
    type enumeration {
      enum none {
        description
          "no service protection provide";
    }
    enum replication {
      description
        "A Packet Replication Function (PRF) replicates
         DetNet flow packets and forwards them to one or
         more next hops in the DetNet domain.  The number
         of packet copies sent to each next hop is a
         DetNet flow specific parameter at the node doing
         the replication.  PRF can be implemented by an
         edge node, a relay node, or an end system";
      }
      enum elimination {
        description
          "A Packet Elimination Function (PEF) eliminates
           duplicate copies of packets to prevent excess
           packets flooding the network or duplicate
           packets being sent out of the DetNet domain.
           PEF can be implemented by an edge node, a relay
           node, or an end system.";
      }
      enum ordering {
        description
          "A Packet Ordering Function (POF) re-orders
           packets within a DetNet flow that are received
           out of order.  This function can be implemented
           by an edge node, a relay node, or an end system.";
      }
      enum elimination-ordering {
        description
          "A combination of PEF and POF that can be
           implemented by an edge node, a relay node, or
           an end system.";
      }
      enum elimination-replication {
        description
          "A combination of PEF and PRF that can be
           implemented by an edge node, a relay node, or
           an end system";
      }
      enum elimination-ordering-replicaiton {
        description
          "A combination of PEF, POF and PRF that can be
           implemented by an edge node, a relay node, or
           an end system";
      }
    }
    description
      "service-protection-type";
  }

  typedef
  |     |  +--rw sequence-number-length?      sequence-number-field
  |     |  +--rw sequence-number-window-size? uint32
  |     |  +--rw sequence-number-generation?  sequence-number-generation-type {
    type enumeration {
     enum none {
       description
          "No sequence number generation function provide";
    }
    enum copy-from-app-flow {
      description
        "Copy the app-flow sequence number to the DetNet-flow";
    }
    enum generate-by-detnet-flow {
      description
        "Generate the sequence number by DetNet flow";
    }
  }
  description
    "sequence-number-generation-type";
  }
  |     +--rw service-operation-type? service-operation-type
  |     +--rw in-segment
  |     |  +--rw app-flow*             app-flow-ref
  |     |  +--rw incoming-detnet-flow* [incoming-index]
  |     |     +--rw incoming-index    uint8
  |     |     +--rw (detnet-flow-type)?
  |     |        +--:(ip-detnet-flow)
  |     |        |  +--rw src-ip-prefix?    inet:ip-prefix
  |     |        |  +--rw dest-ip-prefix?   inet:ip-prefix
  |     |        |  +--rw next-header?      uint8
  |     |        |  +--rw traffic-class?    uint8
  |     |        |  +--rw flow-label?       inet:ipv6-flow-label
  |     |        |  +--rw source-port
  |     |        |  |  +--rw (port-range-or-operator)?
  |     |        |  |     +--:(range)
  |     |        |  |     |  +--rw lower-port  inet:port-number
  |     |        |  |     |  +--rw upper-port  inet:port-number
  |     |        |  |     +--:(operator)
  |     |        |  |        +--rw operator?   operator
  |     |        |  |        +--rw port        inet:port-number
  |     |        |  +--rw destination-port
  |     |        |  |  +--rw (port-range-or-operator)?
  |     |        |  |     +--:(range)
  |     |        |  |     |  +--rw lower-port  inet:port-number
  |     |        |  |     |  +--rw upper-port  inet:port-number
  |     |        |  |     +--:(operator)
  |     |        |  |        +--rw operator?   operator
  |     |        |  |        +--rw port        inet:port-number
  |     |        |  +--rw ipsec-spi?        ipsec-spi
  |     |        +--:(mpls-detnet-flow)
  |     |           +--rw (label-space)?
  |     |              +--:(non-platrom-label-space)
  |     |              |  +--rw mpls-label-stack
  |     |              |     +--rw entry* [id]
  |     |              |        +--rw id             uint8
  |     |              |        +--rw label?         rt-types:mpls-label
  |     |              |        +--rw ttl?           uint8
  |     |              |        +--rw traffic-class? uint8
  |     |              +--:(platform-label-space)
  |     |                 +--rw label?            rt-types:mpls-label
  |     +--rw out-sergment
  |        +--rw (next-hop-options)
  |        |  +--:(simple-next-hop)
  |        |  |  +--rw (header-type)?
  |        |  |  |  +--:(detnet-mpls-header)
  |        |  |  |  |  +--rw mpls-label-stack
  |        |  |  |  |     +--rw entry* [id]
  |        |  |  |  |        +--rw id             uint8
  |        |  |  |  |        +--rw label?         rt-types:mpls-label
  |        |  |  |  |        +--rw ttl?           uint8
  |        |  |  |  |        +--rw traffic-class? uint8
  |        |  |  |  +--:(detnet-ip-header)
  |        |  |  |     +--rw src-ip-address?   inet:ip-address
  |        |  |  |     +--rw dest-ip-address?  inet:ip-address
  |        |  |  |     +--rw next-header?      uint8
  |        |  |  |     +--rw traffic-class?    uint8
  |        |  |  |     +--rw flow-label?       inet:ipv6-flow-label
  |        |  |  |     +--rw source-port?      inet:port-number
  |        |  |  |     +--rw destination-port? inet:port-number
  |        |  |  +--rw lower-layer* [index]
  |        |  |     +--rw index                 uint8
  |        |  |     +--rw (lower-layer-type)?
  |        |  |        +--:(service-sub-layer)
  |        |  |        |  +--rw service-sub-layer?    service-sub-layer-ref
  |        |  |        +--:(forwarding-sub-layer)
  |        |  |        |  +--rw forwarding-sub-layer? forwarding-sub-layer-ref
  |        |  |        +--:(sub-network)
  |        |  |        |  +--rw sub-network?          sub-network-ref
  |        |  |        +--:(interface)
  |        |  |           +--rw outgoing-interface?   if:interface-ref
  |        |  +--:(next-hop-list)
  |        |     +--rw next-hop-list
  |        |        +--rw next-hop* [hop-index]
  |        |           +--rw hop-index         uint8
  |        |           +--rw (header-type)?
  |        |           |  +--:(detnet-mpls-header)
  |        |           |  |  +--rw mpls-label-stack
  |        |           |  |     +--rw entry* [id]
  |        |           |  |        +--rw id             uint8
  |        |           |  |        +--rw label?         rt-types:mpls-label
  |        |           |  |        +--rw ttl?           uint8
  |        |           |  |        +--rw traffic-class? uint8
  |        |           |  +--:(detnet-ip-header)
  |        |           |     +--rw src-ip-address?   inet:ip-address
  |        |           |     +--rw dest-ip-address?  inet:ip-address
  |        |           |     +--rw next-header?      uint8
  |        |           |     +--rw traffic-class?    uint8
  |        |           |     +--rw flow-label?       inet:ipv6-flow-label
  |        |           |     +--rw source-port?      inet:port-number
  |        |           |     +--rw destination-port? inet:port-number
  |        |           +--rw lower-layer* [index]
  |        |              +--rw index                 uint8
  |        |              +--rw (lower-layer-type)?
  |        |                 +--:(service-sub-layer)
  |        |                 |  +--rw service-sub-layer?    service-sub-layer-ref
  |        |                 +--:(forwarding-sub-layer)
  |        |                 |  +--rw forwarding-sub-layer? forwarding-sub-layer-ref
  |        |                 +--:(sub-network)
  |        |                 |  +--rw sub-network?          sub-network-ref
  |        |                 +--:(interface)
  |        |                    +--rw outgoing-interface?   if:interface-ref
  |        +--rw app-flow*         app-flow-ref
  +--rw forwarding-sub-layer
  |  +--rw forwarding-sub-layer-list* [name]
  |     +--rw name                       string
  |     +--rw resource-allocation
  |     |  +--rw traffic-specification
  |     |     +--rw interval?                     uint32
  |     |     +--rw max-packets-per-interval?     uint32
  |     |     +--rw max-payload-size?             uint32
  |     |     +--rw average-packets-per-interval? uint32
  |     |     +--rw average-payload-size?         uint32
  |     +--rw forwarding-operation-type? mpls-operations-type
  |     +--rw in-segment
  |     |  +--rw service-sub-layer?  service-sub-layer-ref
  |     |  +--rw forwarding-traffic* [interface]
  |     |     +--rw interface         if:interface-ref
  |     |     +--rw (detnet-flow-type)?
  |     |        +--:(ip-detnet-flow)
  |     |        |  +--rw src-ip-prefix?    inet:ip-prefix
  |     |        |  +--rw dest-ip-prefix?   inet:ip-prefix
  |     |        |  +--rw next-header?      uint8
  |     |        |  +--rw traffic-class?    uint8
  |     |        |  +--rw flow-label?       inet:ipv6-flow-label
  |     |        |  +--rw source-port
  |     |        |  |  +--rw (port-range-or-operator)?
  |     |        |  |     +--:(range)
  |     |        |  |     |  +--rw lower-port  inet:port-number
  |     |        |  |     |  +--rw upper-port  inet:port-number
  |     |        |  |     +--:(operator)
  |     |        |  |        +--rw operator?   operator
  |     |        |  |        +--rw port        inet:port-number
  |     |        |  +--rw destination-port
  |     |        |  |  +--rw (port-range-or-operator)?
  |     |        |  |     +--:(range)
  |     |        |  |     |  +--rw lower-port  inet:port-number
  |     |        |  |     |  +--rw upper-port  inet:port-number
  |     |        |  |     +--:(operator)
  |     |        |  |        +--rw operator?   operator
  |     |        |  |        +--rw port        inet:port-number
  |     |        |  +--rw ipsec-spi?        ipsec-spi
  |     |        +--:(mpls-detnet-flow)
  |     |           +--rw (label-space)?
  |     |              +--:(non-platrom-label-space)
  |     |              |  +--rw mpls-label-stack
  |     |              |     +--rw entry* [id]
  |     |              |        +--rw id             uint8
  |     |              |        +--rw label?         rt-types:mpls-label
  |     |              |        +--rw ttl?           uint8
  |     |              |        +--rw traffic-class? uint8
  |     |              +--:(platform-label-space)
  |     |                 +--rw label?            rt-types:mpls-label
  |     +--rw out-segment
  |        +--rw (next-hop-options)
  |        |  +--:(simple-next-hop)
  |        |  |  +--rw (header-type)?
  |        |  |  |  +--:(detnet-mpls-header)
  |        |  |  |  |  +--rw mpls-label-stack
  |        |  |  |  |     +--rw entry* [id]
  |        |  |  |  |        +--rw id             uint8
  |        |  |  |  |        +--rw label?         rt-types:mpls-label
  |        |  |  |  |        +--rw ttl?           uint8
  |        |  |  |  |        +--rw traffic-class? uint8
  |        |  |  |  +--:(detnet-ip-header)
  |        |  |  |     +--rw src-ip-address?    inet:ip-address
  |        |  |  |     +--rw dest-ip-address?   inet:ip-address
  |        |  |  |     +--rw next-header?       uint8
  |        |  |  |     +--rw traffic-class?     uint8
  |        |  |  |     +--rw flow-label?        inet:ipv6-flow-label
  |        |  |  |     +--rw source-port?       inet:port-number
  |        |  |  |     +--rw destination-port?  inet:port-number
  |        |  |  +--rw lower-layer* [index]
  |        |  |     +--rw index                 uint8
  |        |  |     +--rw (lower-layer-type)?
  |        |  |        +--:(service-sub-layer)
  |        |  |        |  +--rw service-sub-layer?    service-sub-layer-ref
  |        |  |        +--:(forwarding-sub-layer)
  |        |  |        |  +--rw forwarding-sub-layer? forwarding-sub-layer-ref
  |        |  |        +--:(sub-network)
  |        |  |        |  +--rw sub-network?          sub-network-ref
  |        |  |        +--:(interface)
  |        |  |           +--rw outgoing-interface?   if:interface-ref
  |        |  +--:(next-hop-list)
  |        |     +--rw next-hop-list
  |        |        +--rw next-hop* [hop-index]
  |        |           +--rw hop-index         uint8
  |        |           +--rw (header-type)?
  |        |           |  +--:(detnet-mpls-header)
  |        |           |  |  +--rw mpls-label-stack
  |        |           |  |     +--rw entry* [id]
  |        |           |  |        +--rw id             uint8
  |        |           |  |        +--rw label?         rt-types:mpls-label
  |        |           |  |        +--rw ttl?           uint8
  |        |           |  |        +--rw traffic-class? uint8
  |        |           |  +--:(detnet-ip-header)
  |        |           |     +--rw src-ip-address?   inet:ip-address
  |        |           |     +--rw dest-ip-address?  inet:ip-address
  |        |           |     +--rw next-header?      uint8
  |        |           |     +--rw traffic-class?    uint8
  |        |           |     +--rw flow-label?       inet:ipv6-flow-label
  |        |           |     +--rw source-port?      inet:port-number
  |        |           |     +--rw destination-port? inet:port-number
  |        |           +--rw lower-layer* [index]
  |        |              +--rw index                 uint8
  |        |              +--rw (lower-layer-type)?
  |        |                 +--:(service-sub-layer)
  |        |                 |  +--rw service-sub-layer?    service-sub-layer-ref
  |        |                 +--:(forwarding-sub-layer)
  |        |                 |  +--rw forwarding-sub-layer? forwarding-sub-layer-ref
  |        |                 +--:(sub-network)
  |        |                 |  +--rw sub-network?          sub-network-ref
  |        |                 +--:(interface)
  |        |                    +--rw outgoing-interface?   if:interface-ref
  |        +--rw service-sub-layer? service-sub-layer-ref
  +--rw sub-network
     +--rw sub-network-list* [name]
        +--rw name  string

  grouping ip-header:
    +--rw src-ip-address?   inet:ip-address
    +--rw dest-ip-address?  inet:ip-address
    +--rw next-header?      uint8
    +--rw traffic-class?    uint8
    +--rw flow-label?       inet:ipv6-flow-label
    +--rw source-port?      inet:port-number
    +--rw destination-port? inet:port-number
  grouping l2-header:
    +--rw source-mac-address?      yang:mac-address
    +--rw destination-mac-address? yang:mac-address
    +--rw ethertype?               eth:ethertype
    +--rw vlan-id?                 uint16
    +--rw pcp?                     uint8
  grouping destination-ip-port-identification:
    +--rw destination-port
       +--rw (port-range-or-operator)?
          +--:(range)
          |  +--rw lower-port  inet:port-number
          |  +--rw upper-port  inet:port-number
          +--:(operator)
             +--rw operator?   operator
             +--rw port        inet:port-number
  grouping source-ip-port-identification:
    +--rw source-port
       +--rw (port-range-or-operator)?
          +--:(range)
          |  +--rw lower-port  inet:port-number
          |  +--rw upper-port  inet:port-number
          +--:(operator)
             +--rw operator?   operator
             +--rw port        inet:port-number
  grouping ip-flow-identification:
    +--rw src-ip-prefix?    inet:ip-prefix
    +--rw dest-ip-prefix?   inet:ip-prefix
    +--rw next-header?      uint8
    +--rw traffic-class?    uint8
    +--rw flow-label?       inet:ipv6-flow-label
    +--rw source-port
    |  +--rw (port-range-or-operator)?
    |     +--:(range)
    |     |  +--rw lower-port  inet:port-number
    |     |  +--rw upper-port  inet:port-number
    |     +--:(operator)
    |        +--rw operator?   operator
    |        +--rw port        inet:port-number
    +--rw destination-port
    |  +--rw (port-range-or-operator)?
    |     +--:(range)
    |     |  +--rw lower-port  inet:port-number
    |     |  +--rw upper-port  inet:port-number
    |     +--:(operator)
    |        +--rw operator?   operator
    |        +--rw port        inet:port-number
    +--rw ipsec-spi?        ipsec-spi
  grouping mpls-flow-identification:
    +--rw (label-space)?
       +--:(non-platrom-label-space)
       |  +--rw mpls-label-stack
       |     +--rw entry* [id]
       |        +--rw id             uint8
       |        +--rw label?         rt-types:mpls-label
       |        +--rw ttl?           uint8
       |        +--rw traffic-class? uint8
       +--:(platform-label-space)
          +--rw label?            rt-types:mpls-label
  grouping traffic-specification:
    +--rw traffic-specification
       +--rw interval?                     uint32
       +--rw max-packets-per-interval?     uint32
       +--rw max-payload-size?             uint32
       +--rw average-packets-per-interval? uint32
       +--rw average-payload-size?         uint32
  grouping traffic-requirements:
    +--rw traffic-requirements
       +--rw min-bandwidth?                  uint64
       +--rw max-latency?                    uint32
       +--rw max-latency-variation?          uint32
       +--rw max-loss?                       uint8
       +--rw max-consecutive-loss-tolerance? uint32
       +--rw max-misordering?                uint32
  grouping data-flow-spec:
    +--rw (data-flow-type)?
       +--:(tsn-app-flow)
       |  +--rw source-mac-address?      yang:mac-address
       |  +--rw destination-mac-address? yang:mac-address
       |  +--rw ethertype?               eth:ethertype
       |  +--rw vlan-id?                 uint16
       |  +--rw pcp?                     uint8
       +--:(ip-app-flow)
       |  +--rw src-ip-prefix?           inet:ip-prefix
       |  +--rw dest-ip-prefix?          inet:ip-prefix
       |  +--rw next-header?             uint8
       |  +--rw traffic-class?           uint8
       |  +--rw flow-label?              inet:ipv6-flow-label
       |  +--rw source-port
       |  |  +--rw (port-range-or-operator)?
       |  |     +--:(range)
       |  |     |  +--rw lower-port  inet:port-number
       |  |     |  +--rw upper-port  inet:port-number
       |  |     +--:(operator)
       |  |        +--rw operator?   operator
       |  |        +--rw port        inet:port-number
       |  +--rw destination-port
       |  |  +--rw (port-range-or-operator)?
       |  |     +--:(range)
       |  |     |  +--rw lower-port  inet:port-number
       |  |     |  +--rw upper-port  inet:port-number
       |  |     +--:(operator)
       |  |        +--rw operator?   operator
       |  |        +--rw port        inet:port-number
       |  +--rw ipsec-spi?               ipsec-spi
       +--:(mpls-app-flow)
          +--rw (label-space)?
             +--:(non-platrom-label-space)
             |  +--rw mpls-label-stack
             |     +--rw entry* [id]
             |        +--rw id             uint8
             |        +--rw label?         rt-types:mpls-label
             |        +--rw ttl?           uint8
             |        +--rw traffic-class? uint8
             +--:(platform-label-space)
                +--rw label?                   rt-types:mpls-label
  grouping l4-port-header {
    description
      "The TCP/UDP port(source/destination) information";
    leaf detnet-flow-spec:
    +--rw (detnet-flow-type)?
       +--:(ip-detnet-flow)
       |  +--rw src-ip-prefix?    inet:ip-prefix
       |  +--rw dest-ip-prefix?   inet:ip-prefix
       |  +--rw next-header?      uint8
       |  +--rw traffic-class?    uint8
       |  +--rw flow-label?       inet:ipv6-flow-label
       |  +--rw source-port {
      type inet:port-number;
      description
        "The source
       |  |  +--rw (port-range-or-operator)?
       |  |     +--:(range)
       |  |     |  +--rw lower-port  inet:port-number
       |  |     |  +--rw upper-port  inet:port-number
       |  |     +--:(operator)
       |  |        +--rw operator?   operator
       |  |        +--rw port number";
    }
    leaf        inet:port-number
       |  +--rw destination-port {
      type inet:port-number;
      description
        "The destination
       |  |  +--rw (port-range-or-operator)?
       |  |     +--:(range)
       |  |     |  +--rw lower-port  inet:port-number
       |  |     |  +--rw upper-port  inet:port-number
       |  |     +--:(operator)
       |  |        +--rw operator?   operator
       |  |        +--rw port number";
    }
  }        inet:port-number
       |  +--rw ipsec-spi?        ipsec-spi
       +--:(mpls-detnet-flow)
          +--rw (label-space)?
             +--:(non-platrom-label-space)
             |  +--rw mpls-label-stack
             |     +--rw entry* [id]
             |        +--rw id             uint8
             |        +--rw label?         rt-types:mpls-label
             |        +--rw ttl?           uint8
             |        +--rw traffic-class? uint8
             +--:(platform-label-space)
                +--rw label?            rt-types:mpls-label
  grouping app-flows-ref:
    +--rw app-flow* app-flow-ref
  grouping incoming-detnet-flows:
    +--rw incoming-detnet-flow* [incoming-index]
       +--rw incoming-index    uint8
       +--rw (detnet-flow-type)?
          +--:(ip-detnet-flow)
          |  +--rw src-ip-prefix?    inet:ip-prefix
          |  +--rw dest-ip-prefix?   inet:ip-prefix
          |  +--rw next-header?      uint8
          |  +--rw traffic-class?    uint8
          |  +--rw flow-label?       inet:ipv6-flow-label
          |  +--rw source-port
          |  |  +--rw (port-range-or-operator)?
          |  |     +--:(range)
          |  |     |  +--rw lower-port  inet:port-number
          |  |     |  +--rw upper-port  inet:port-number
          |  |     +--:(operator)
          |  |        +--rw operator?   operator
          |  |        +--rw port        inet:port-number
          |  +--rw destination-port
          |  |  +--rw (port-range-or-operator)?
          |  |     +--:(range)
          |  |     |  +--rw lower-port  inet:port-number
          |  |     |  +--rw upper-port  inet:port-number
          |  |     +--:(operator)
          |  |        +--rw operator?   operator
          |  |        +--rw port        inet:port-number
          |  +--rw ipsec-spi?        ipsec-spi
          +--:(mpls-detnet-flow)
             +--rw (label-space)?
                +--:(non-platrom-label-space)
                |  +--rw mpls-label-stack
                |     +--rw entry* [id]
                |        +--rw id             uint8
                |        +--rw label?         rt-types:mpls-label
                |        +--rw ttl?           uint8
                |        +--rw traffic-class? uint8
                +--:(platform-label-space)
                   +--rw label?            rt-types:mpls-label
  grouping detnet-header:
    +--rw (header-type)?
       +--:(detnet-mpls-header)
       |  +--rw mpls-label-stack
       |     +--rw entry* [id]
       |        +--rw id             uint8
       |        +--rw label?         rt-types:mpls-label
       |        +--rw ttl?           uint8
       |        +--rw traffic-class? uint8
       +--:(detnet-ip-header)
          +--rw src-ip-address?   inet:ip-address
          +--rw dest-ip-address?  inet:ip-address
          +--rw next-header?      uint8
          +--rw traffic-class?    uint8
          +--rw flow-label?       inet:ipv6-flow-label
          +--rw source-port?      inet:port-number
          +--rw destination-port? inet:port-number
  grouping ipv4-header {
    description
      "The IPv4 packet header information";
    leaf src-ipv4-address {
      type inet:ipv4-address;
      mandatory true;
      description
        "The source IP address of the header";
    }
    leaf dest-ipv4-address {
      type inet:ipv4-address;
      mandatory true;
      description
        "The destination IP address of the header";
    }
    leaf protocol {
      type uint8;
      mandatory true;
      description
        "The protocol of the header";
    }
    leaf dscp {
      type uint8;
      description
        "The DSCP field of the header";
    }
  } lower-layer-ref:
    +--rw (lower-layer-type)?
       +--:(service-sub-layer)
       |  +--rw service-sub-layer?    service-sub-layer-ref
       +--:(forwarding-sub-layer)
       |  +--rw forwarding-sub-layer? forwarding-sub-layer-ref
       +--:(sub-network)
       |  +--rw sub-network?          sub-network-ref
       +--:(interface)
          +--rw outgoing-interface?   if:interface-ref
  grouping ipv6-header detnet-next-hop-content:
    +--rw (next-hop-options)
       +--:(simple-next-hop)
       |  +--rw (header-type)?
       |  |  +--:(detnet-mpls-header)
       |  |  |  +--rw mpls-label-stack
       |  |  |     +--rw entry* [id]
       |  |  |        +--rw id             uint8
       |  |  |        +--rw label?         rt-types:mpls-label
       |  |  |        +--rw ttl?           uint8
       |  |  |        +--rw traffic-class? uint8
       |  |  +--:(detnet-ip-header)
       |  |     +--rw src-ip-address?   inet:ip-address
       |  |     +--rw dest-ip-address?  inet:ip-address
       |  |     +--rw next-header?      uint8
       |  |     +--rw traffic-class?    uint8
       |  |     +--rw flow-label?       inet:ipv6-flow-label
       |  |     +--rw source-port?      inet:port-number
       |  |     +--rw destination-port? inet:port-number
       |  +--rw lower-layer* [index]
       |     +--rw index                 uint8
       |     +--rw (lower-layer-type)?
       |        +--:(service-sub-layer)
       |        |  +--rw service-sub-layer?    service-sub-layer-ref
       |        +--:(forwarding-sub-layer)
       |        |  +--rw forwarding-sub-layer? forwarding-sub-layer-ref
       |        +--:(sub-network)
       |        |  +--rw sub-network?          sub-network-ref
       |        +--:(interface)
       |           +--rw outgoing-interface?   if:interface-ref
       +--:(next-hop-list)
          +--rw next-hop-list
             +--rw next-hop* [hop-index]
                +--rw hop-index         uint8
                +--rw (header-type)?
                |  +--:(detnet-mpls-header)
                |  |  +--rw mpls-label-stack
                |  |     +--rw entry* [id]
                |  |        +--rw id             uint8
                |  |        +--rw label?         rt-types:mpls-label
                |  |        +--rw ttl?           uint8
                |  |        +--rw traffic-class? uint8
                |  +--:(detnet-ip-header)
                |     +--rw src-ip-address?   inet:ip-address
                |     +--rw dest-ip-address?  inet:ip-address
                |     +--rw next-header?      uint8
                |     +--rw traffic-class?    uint8
                |     +--rw flow-label?       inet:ipv6-flow-label
                |     +--rw source-port?      inet:port-number
                |     +--rw destination-port? inet:port-number
                +--rw lower-layer* [index]
                   +--rw index                 uint8
                   +--rw (lower-layer-type)?
                      +--:(service-sub-layer)
                      |  +--rw service-sub-layer?    service-sub-layer-ref
                      +--:(forwarding-sub-layer)
                      |  +--rw forwarding-sub-layer? forwarding-sub-layer-ref
                      +--:(sub-network)
                      |  +--rw sub-network?          sub-network-ref
                      +--:(interface)
                         +--rw outgoing-interface?   if:interface-ref

6.  DetNet Configuration YANG Model

module ietf-detnet-config {
    description
      "The IPv6 packet header information";
    leaf src-ipv6-address
  namespace "urn:ietf:params:xml:ns:yang:ietf-detnet-config";
  prefix "ietf-detnet";

  import ietf-yang-types {
      type inet:ipv6-address;
      mandatory true;
      description
        "The source IP address of the header";
    prefix "yang";
  }
    leaf dest-ipv6-address {
      type inet:ipv6-address;
      mandatory true;
      description
        "The destination IP address of the header";

  import ietf-inet-types{
    prefix "inet";
  }
    leaf next-header
  import ietf-ethertypes {
      type uint8;
      mandatory true;
      description
        "The next header of the IPv6 header";
    prefix "eth";
  }
    leaf traffic-class

  import ietf-routing-types {
      type uint8;
      description
        "The traffic class value of the header";
    prefix "rt-types";
  }
    leaf flow-label

  import ietf-routing {
      type inet:ipv6-flow-label;
      description
        "The flow label value of the header";
    }
    prefix "rt";
  }

  grouping mpls-header

  import ietf-packet-fields {
    description
      "The MPLS packet header information";
    leaf label
    prefix "packet-fields";
  }
  import ietf-interfaces {
      type rt-type:mpls-label;
    prefix "if";
  }

  organization "IETF DetNet Working Group";

  contact
    "WG Web:   <http://tools.ietf.org/wg/detnet/>
     WG List:  <mailto: detnet@ietf.org>
     WG Chair: Lou Berger
                 <mailto:lberger@labn.net>

                 Janos Farkas
                 <mailto:janos.farkas@ericsson.com>

     Editor:   Xuesong Geng
                <mailto:gengxuesong@huawei.com>

     Editor:   Mach Chen
                <mailto:mach.chen@huawei.com>

     Editor:   Zhenqiang Li
                <mailto:lizhenqiang@chinamobile.com>

     Editor:   Reshad Rahman
                <mailto:rrahman@cisco.com>

     Editor:   Yeoncheol Ryoo
                <mailto:dbduscjf@etri.re.kr>";

  description
        "The label value of
    "This YANG module describes the MPLS header";
    }
    leaf tc parameters needed
     for DetNet flow configuration and flow status
  reporting";

  revision 2020-03-04 {
      type uint8;
    description
        "The traffic class value of the MPLS header"; "initial revision";
    reference "RFC XXXX: draft-ietf-detnet-yang-02";
  }
    leaf s-bit

  typedef app-flow-ref {
    type boolean;
      description
        "The s-bit value of the MPLS header,
         which indicates the bottom of the label shack"; leafref {
      path "/ietf-detnet:app-flows"
         + "/ietf-detnet:app-flow"
         + "/ietf-detnet:name";
    }
    leaf d-cw-encapsulate-flag
  }
  typedef service-sub-layer-ref {
    type boolean;
      description
        "the indication of whether D-CW  is encapsulated or not,
         when the D-CW is encapsulated, the sequence number is
         determined by sequence generation type"; leafref {
      path "/ietf-detnet:service-sub-layer"
         + "/ietf-detnet:service-sub-layer-list"
         + "/ietf-detnet:name";
    }
  }

  grouping l2-header {
    description
      "The Ethernet or TSN packet header information";
    leaf source-mac-address

  typedef forwarding-sub-layer-ref {
    type yang:mac-address;
      description
        "The source MAC address value of the ethernet header"; leafref {
      path "/ietf-detnet:forwarding-sub-layer"
         + "/ietf-detnet:forwarding-sub-layer-list"
         + "/ietf-detnet:name";
    }
    leaf destination-mac-address
  }

  typedef sub-network-ref {
    type yang:mac-address;
      description
        "The destination MAC address value of the ethernet header"; leafref {
      path "/ietf-detnet:sub-network"
         + "/ietf-detnet:sub-network-list"
         + "/ietf-detnet:name";
    }
    leaf ethertype
  }

  typedef ipsec-spi {
    type eth:ethertype; uint32 {
      range "1..max";
    }
    description
        "The ethernet packet type value of the ethernet header";
      "SPI";
  }
    leaf vlan-id

  typedef service-operation-type {
    type uint16; enumeration {
      enum service-initiation {
        description
        "The Vlan value of the ethernet header";
          "Operation for DetNet service sub-layer encapsulation";
      }
    leaf pcp
      enum service-termination {
      type uint8;
        description
        "The priority value of the ethernet header";
          "Operation for DetNet service sub-layer decapsulation";
      }
      enum service-relay {
        description
          "Operation for DetNet service sub-layer swap";
      }

  grouping l4-port-identification
      enum non-detnet {
        description
      "The TCP/UDP port(source/destination) identification information";
    leaf lower-source-port
          "No operation for DetNet service sub-layer";
      }
    }
  }

  typedef mpls-operations-type {
    type inet:port-number; enumeration {
      enum impose-and-forward {
        description
        "The lower source port number of the source port range";
          "Operation impose outgoing label(s) and forward to
           next-hop";
      }
    leaf upper-source-port
      enum pop-and-forward {
      type inet:port-number;
        description
        "The upper source port number of the source port range";
          "Operation pop incoming label and forward to next-hop";
      }
    leaf lower-destination-port
      enum pop-impose-and-forward {
      type inet:port-number;
        description
        "The lower destination port number
          "Operation pop incoming label, impose one or the destination port range"; more
           outgoing label(s) and forward to next-hop";
      }
    leaf upper-destination-port
      enum swap-and-forward {
      type inet:port-number;
        description
        "The upper destination port number of the destination port range";
    }
          "Operation swap incoming label, with outgoing label and
           forward to next-hop";
      }

  grouping ipv4-flow-identification
      enum pop-and-lookup {
        description
      "The IPv4 packet header identification information";
    leaf src-ipv4-prefix
          "Operation pop incoming label and perform a lookup";
      }
    }
    description "MPLS operations types";
  }
  typedef service-protection-type {
    type inet:ipv4-prefix;
      mandatory true; enumeration {
      enum none {
        description
        "The source IP address of the header";
          "no service protection provide";
      }
    leaf dest-ipv4-prefix
      enum replication {
      type inet:ipv4-prefix;
      mandatory true;
        description
        "The destination IP address
          "A Packet Replication Function (PRF) replicates
           DetNet flow packets and forwards them to one or
           more next hops in the DetNet domain.  The number
           of packet copies sent to each next hop is a
           DetNet flow specific parameter at the header";
    }
    leaf protocol {
      type uint8;
      mandatory true;
      description
        "The protocol of node doing
           the header"; replication.  PRF can be implemented by an
           edge node, a relay node, or an end system";
      }
    leaf dscp
      enum elimination {
      type uint8;
        description
        "The DSCP field
          "A Packet Elimination Function (PEF) eliminates
           duplicate copies of the header";
    }
    leaf dscp-bitmask {
      type uint8;
      description
        "The bitmask value that determines whether packets to use prevent excess
           packets flooding the DSCP(IPv4) value for flow identification network or not";
     } duplicate
           packets being sent out of the DetNet domain.
           PEF can be implemented by an edge node, a relay
           node, or an end system.";
      }

  grouping ipv6-flow-identification {
    description
      "The IPv6 packet header identification information";
    leaf src-ipv6-prefix
      enum ordering {
      type inet:ipv6-prefix;
      mandatory true;
        description
        "The source IP address
          "A Packet Ordering Function (POF) re-orders
           packets within a DetNet flow that are received
           out of the header"; order.  This function can be implemented
           by an edge node, a relay node, or an end system.";
      }
    leaf dest-ipv6-prefix
      enum elimination-ordering {
      type inet:ipv6-prefix;
      mandatory true;
        description
        "The destination IP address
          "A combination of the header"; PEF and POF that can be
           implemented by an edge node, a relay node, or
           an end system.";
      }
    leaf next-header
      enum elimination-replication {
      type uint8;
      mandatory true;
        description
        "The next header
          "A combination of the IPv6 header"; PEF and PRF that can be
           implemented by an edge node, a relay node, or
           an end system";
      }
    leaf traffic-class
      enum elimination-ordering-replicaiton {
      type uint8;
        description
        "The traffic class value
          "A combination of the header"; PEF, POF and PRF that can be
           implemented by an edge node, a relay node, or
           an end system";
      }
    leaf traffic-class-bitmask
    }
  }

  typedef sequence-number-generation-type {
    type uint8; enumeration {
      enum copy-from-app-flow {
        description
        "The bitmask value that determines whether
          "Copy the app-flow sequence number to use the Traffic class(IPv6) value for flow identification or not"; DetNet-flow";
      }
    leaf flow-label
      enum generate-by-detnet-flow {
      type inet:ipv6-flow-label;
        description
        "The flow label value of
          "Generate the header"; sequence number by DetNet flow";
      }
    leaf flow-label-flag {
      type boolean;
      description
        "The flag that determines whether to use
         the Flow Label value for flow identification or not";
    }
  }

  grouping mpls-flow-identification

  typedef sequence-number-field {
    type enumeration {
      enum zero-sn {
        description
      "The MPLS packet header identification information";
    leaf label "there is no DetNet sequence number field.";
      }
      enum short-sn {
      type rt-type:mpls-label;
        description
        "The label "there is 16bit DetNet sequence number field";
        value of the MPLS header"; 16;
      }
    leaf tc
      enum long-sn {
      type uint8;
        description
        "The traffic class "there is 28bit DetNet sequence number field";
        value of the MPLS header"; 28;
      }
    }
  }

  grouping l2-flow-identification ip-header {
    description
      "The Ethernet or TSN IPv4/IPv6 packet header identification information";
    leaf source-mac-address src-ip-address {
      type yang:mac-address; inet:ip-address;
      description
        "The source MAC IP address value of the ethernet header";
    }
    leaf destination-mac-address dest-ip-address {
      type yang:mac-address; inet:ip-address;
      description
        "The destination MAC IP address value of the ethernet header";
    }
    leaf ethertype {
      type eth:ethertype;
      description
        "The ethernet packet type value of the ethernet header";
    }
    leaf vlan-id next-header {
      type uint16; uint8;
      description
        "The Vlan value next header of the ethernet IPv6 header";
    }
    leaf pcp traffic-class {
      type uint8;
      description
        "The priority traffic class value of the ethernet header";
    }
  }

  grouping traffic-specification {
    description
      "traffic-specification specifies how the Source
       transmits packets for the flow.  This is the
       promise/request of the Source to the network.
       The network uses this traffic specification
       to allocate resources and adjust queue
       parameters in network nodes.";
    reference
      "draft-ietf-detnet-flow-information-model";
    leaf interval flow-label {
      type uint32;
        description
          "The period of time in which the traffic
           specification cannot be exceeded";
    }
    leaf max-packets-per-interval{
      type uint32;
      description
        "The maximum number of packets that the
         source will transmit in one Interval.";
    }
    leaf max-payload-size{
      type uint32; inet:ipv6-flow-label;
      description
        "The maximum payload size that flow label value of the source
         will transmit."; header";
    }
    leaf average-packets-per-interval source-port {
      type uint32; inet:port-number;
      description
      "The average number of packets that the source will transmit in one Interval"; port number";
    }
    leaf average-payload-size destination-port {
      type uint32; inet:port-number;
      description
      "The average payload size that the
         source will transmit."; destination port number";
    }
  }

  container detnet-config

  grouping l2-header {
    description
      "DetNet configurations";
      "The Ethernet or TSN packet header information";
    leaf node-id source-mac-address {
      type yang:dotted-quad; yang:mac-address;
      description
        "A 32-bit number in the form
        "The source MAC address value of a dotted quad that is used by
         identifying a DetNet node"; the ethernet header";
    }
    list detnet-config-list
    leaf destination-mac-address {
      key "name";
      type yang:mac-address;
      description
        "list
        "The destination MAC address value of the DetNet configurations"; ethernet header";
    }
    leaf name ethertype {
      type string; eth:ethertype;
      description
        "The name to identify ethernet packet type value of the DetNet configuration"; ethernet header";
    }
    leaf config-type vlan-id {
      type config-type-ref; uint16;
      description
        "The DetNet configuration Vlan value of the ethernet header";

    }
    leaf pcp {
      type such as a App-flow, service
           sub-layer, forwarding sub-layer, and TSN sub-network"; uint8;
      description
        "The priority value of the ethernet header";
    }
      container App-flow
  }
  grouping destination-ip-port-identification {
        when "../config-type = 'ietf-detnet:App-flow'";
    description
    "The DetNet App-flow configuration"; TCP/UDP port(source/destination) identification information";
      container operations destination-port {
      uses packet-fields:port-range-or-operator;
      }
  }

  grouping source-ip-port-identification {
    description "operations";
    "The TCP/UDP port(source/destination) identification information";
      container sequence-number source-port {
      uses packet-fields:port-range-or-operator;
      }
  }

  grouping ip-flow-identification {
    description
    "The DetNet sequence number operations grouping"; IPv4/IPv6 packet header identification information";
    leaf sequence-number-generation-type src-ip-prefix {
      type sequence-number-generation-type; inet:ip-prefix;
      description
      "The DetNet sequence number generation type"; source IP address of the header";
    }
    leaf sequence-number-length dest-ip-prefix {
      type uint8; inet:ip-prefix;
      description
      "The DetNet sequence number length";
            }
          } destination IP address of the header";
    }
        container in-segments
    leaf next-header {
      type uint8;
      description
      "The App-flow identification information"; next header of the IPv6 header";
    }
    leaf app-flow-type traffic-class {
      type flow-type-ref; uint8;
      description
      "The App-flow type such as a L2, IPv4, and IPv6";
          }
          uses l2-flow-identification {
            when "app-flow-type = 'ietf-detnet:tsn' or 'ietf-detnet:l2'";
          }
          uses ipv4-flow-identification {
            when "app-flow-type = 'ietf-detnet:ipv4'";
          }
          uses ipv6-flow-identification {
            when "app-flow-type = 'ietf-detnet:ipv6'";
          }
          uses l4-port-identification {
when "app-flow-type = 'ietf-detnet:ipv6' or 'ietf-detnet:ipv4'";
            or 'ietf-detnet:ipv4'";
          } traffic class value of the header";
    }
        container out-segments
    leaf flow-label {
      type inet:ipv6-flow-label;
      description
            "The DetNet service information associated with this App-flow";
      "The flow label value of the header";
    }
      uses source-ip-port-identification;
      uses destination-ip-port-identification;
    leaf detnet-service-sub-layer ipsec-spi {
      type  lower-layer-ref; ipsec-spi;
      description "Specify associated service sub-layer";
          } "Security parameter index of SA entry";
    }
  }
      container service-sub-layer

  grouping mpls-flow-identification {
        when "../config-type = 'ietf-detnet:service-sub-layer'";
    description
    "The DetNet service sub-layer configuration";
        container operations MPLS packet header identification information";
    choice label-space {
      description
            "The DetNet service sub-layer operations grouping";
          container service-operation "";
      case non-platrom-label-space {
        uses rt-types:mpls-label-stack;
      }
      case platform-label-space {
            description "The DetNet service operations grouping";
        leaf service-operation-type label {
          type service-operation-ref;
              description
              "The DetNet service operations type such as DetNet
               service initiation, termination, and relay"; rt-types:mpls-label;
        }
      }
    }
  }

  grouping traffic-specification {
    container service-protection traffic-specification {
    description
              "The DetNet service protection operations grouping";
      "traffic-specification specifies how the Source
       transmits packets for the flow.  This is the
       promise/request of the Source to the network.
       The network uses this traffic specification
       to allocate resources and adjust queue
       parameters in network nodes.";
    reference
      "draft-ietf-detnet-flow-information-model";
    leaf service-protection-type interval {
      type service-protection-type; uint32;
        description
          "The DetNet service protection type such as PRF, PEF, PEOF,
                 PERF, and PEORF";
            }
          } period of time in which the traffic
           specification cannot be exceeded";
    }
        container in-segments {
          when "../operations/service-operation"
          + "/service-operation-type != 'service-initation'";
    leaf max-packets-per-interval{
      type uint32;
      description
            "DetNet service identification information";
        "The maximum number of packets that the
         source will transmit in one Interval.";
    }
    leaf detnet-service-type { max-payload-size{
      type flow-type-ref; uint32;
      description
            "incoming DetNet service flow type";
        "The maximum payload size that the source
         will transmit.";
    }
          list detnet-service-list
    leaf average-packets-per-interval {
            key "detnet-service-index";
      type uint32;
      description
              "Incoming DetNet member flows or a compound flow";
        "The average number of packets that the
         source will transmit in one Interval";
    }
    leaf detnet-service-index average-payload-size {
      type uint8; uint32;
      description
                "Incoming DetNet service index";
        "The average payload size that the
         source will transmit.";
    }
            uses ipv4-flow-identification {
      when "../detnet-service-type = 'ietf-detnet:ipv4'";
    }
            uses ipv6-flow-identification {
      when "../detnet-service-type = 'ietf-detnet:ipv6'";
  }

  grouping traffic-requirements {
    container mpls-flow-identification traffic-requirements {
              when "../../detnet-service-type = 'ietf-detnet:mpls'";
      description
                "MPLS
        "FlowRequirements: defines the attributes of the App-flow
        regarding bandwidth, latency, latency variation, loss, and
        misordering tolerance.";
      leaf min-bandwidth {
        type DetNet service identification"; uint64;
        description
          "MinBandwidth is the minimum bandwidth that has to be
          guaranteed for the DetNet service.  MinBandwidth is
          specified in octets per second.";
      }
      leaf label-space max-latency {
        type label-space-ref; uint32;
        description
                  "Indicate
          "MaxLatency is the incoming MPLS label maximum latency from Ingress to Egress(es)
          for a single packet of the DetNet flow.  MaxLatency is associated with
                   platform label space or not";
          specified as an integer number of nanoseconds";
      }
              container non-platform-label-space
      leaf max-latency-variation {
when "../label-space = 'ietf-detnet:non-platform-label'";
        type uint32;
        description
                  "MPLS label
          "MaxLatencyVariation is associated with non-platform label space,
                   all of the F-labels difference between the minimum and incoming interface information was
                   used for identification";
          the maximum end-to-end one-way latency.  MaxLatencyVariation
          is specified as an integer number of nanoseconds.";
      }
      leaf incoming-interface max-loss {
        type if:interface-ref; uint8;
        description
                    "DetNet
          "MaxLoss defines the maximum Packet Loss Ratio (PLR) parameter
          for the DetNet service incoming interface information"; between the Ingress and Egress(es) of
          the DetNet domain.";
      }
                list non-platform-label-stack
      leaf max-consecutive-loss-tolerance {
                  key "index";
        type uint32;
        description
                    "All of the label information from the outer label
                     to
          "Some applications have special loss requirement, such as
          MaxConsecutiveLossTolerance.  The maximum consecutive loss
          tolerance parameter describes the current label"; maximum number of
          consecutive packets whose loss can be tolerated.  The maximum
          consecutive loss tolerance can be measured for example based
          on sequence number";
      }
      leaf index max-misordering {
        type uint8; uint32;
        description
                      "Index
          "MaxMisordering describes the tolerable maximum number of
          packets that can be received out of order.  The maximum
          allowed misordering can be measured for example based on
          sequence number.  The value zero for the labels stack"; maximum allowed
          misordering indicates that in order delivery is required,
          misordering cannot be tolerated.";
      }
                  uses mpls-flow-identification;
      }
  }
              container platform-label-space

  grouping data-flow-spec {
        when "../label-space = 'ietf-detnet:platform-label'";
    description
                  "MPLS label is associated with platform label space, only
                   the F-label is used for "app-flow identification";
    choice data-flow-type {
      case tsn-app-flow {
        uses l2-header;
      }
      case ip-app-flow {
        uses ip-flow-identification;
      }
      case mpls-app-flow {
        uses mpls-flow-identification;
      }
    }
  }
  grouping detnet-flow-spec {
    description "detnet-flow identificatioin";
    choice detnet-flow-type {
      case ip-detnet-flow {
        uses ip-flow-identification;
      }
        container out-segments
      case mpls-detnet-flow {
        uses mpls-flow-identification;
      }
    }
  }

  grouping app-flows-ref {
          when "../operations/service-operation"
          + "/service-operation-type != 'service-termination'";
    description
            "DetNet Service "incoming or outgoing processing grouping";
          leaf detnet-service-processing-type app-flow reference group";
    leaf-list app-flow {
      type flow-type-ref; app-flow-ref;
      description
            "Outgoing DetNet service flow type"; "List of ingress or egress app-flows";
    }
          container detnet-service-encapsulation
  }

  grouping incoming-detnet-flows {
    description
              "DetNet service encapsulation information"; "incoming detnet member flows identification";
    list detnet-service-processing-list incoming-detnet-flow {
      key "detnet-service-processing-index"; "incoming-index";
      description
                "The list of single or multiple outgoing DetNet service(s)"; "";
      leaf detnet-service-processing-index incoming-index {
        type uint32; uint8;
        description "Outgoing segment entry"; "";
      }
      uses detnet-flow-spec;
    }
  }
              container ip-flow

  grouping detnet-header {
                when "../../../detnet-service-processing-type ="
                + "'ietf-detnet:ipv4' or 'ietf-detnet:ipv6'";
    description
                  "IP type "DetNet header info for DetNet flow(s) encapsulation information";
                container ipv4-flow or forwarding";
    choice header-type {
      case detnet-mpls-header {
                  when "../../../../detnet-service-processing-type ="
                  + "'ietf-detnet:ipv4'";
        description
                    "IPv4 packet header
          "MPLS label stack for DetNet MPLS encapsulation information"; or forwarding";
        uses ipv4-header; rt-types:mpls-label-stack;
      }
                container ipv6-flow
      case detnet-ip-header {
                  when "../../../../detnet-service-processing-type ="
                  + "'ietf-detnet:ipv6'";
        description
                      "IPv6
          "IPv4/IPv6 packet header encapsulation information"; for DetNet IP encapsulation";
        uses ipv6-header; ip-header;
      }
                container l4-port-header {
                  description
                    "TCP/UDP source or destination port number";
                  uses l4-port-header;
    }
  }
              container mpls-flow

  grouping lower-layer-ref {
                when "../../../detnet-service-processing-type ="
                + "'ietf-detnet:mpls'";
                description
                  "MPLS type DetNet flow(s) encapsulation information";
                  list detnet-mpls-label-stack
    choice lower-layer-type {
      case service-sub-layer {
                    key "index";
                    description
                      "The list of MPLS labels stack for swap or encapsulation";
        leaf index service-sub-layer {
          type uint8;
                      description "Index of the labels stack"; service-sub-layer-ref;
        }
                    uses mpls-header;
      }
      case forwarding-sub-layer {
        leaf forwarding-sub-layer {
          type forwarding-sub-layer-ref;
        }
      }
              container detnet-forwarding-sub-layer-info
      case sub-network {
                description
                  "The forwarding sub-layer information that associated with
                   this DetNet service sub-layer";
        leaf detnet-forwarding-sub-layer sub-network {
          type lower-layer-ref;
                  description
                    "Specify associated forwarding sub-layer"; sub-network-ref;
        }
      }
      case interface {
        leaf outgoing-interface {
          type if:interface-ref;
        }
      }
    }
  }
      container forwarding-sub-layer
  grouping detnet-next-hop-content {
        when "../config-type = 'ietf-detnet:forwarding-sub-layer'";
    description
                  "The
      "Generic parameters of DetNet forwarding sub-layer configuration";
        container operations next hops.";
    choice next-hop-options {
      mandatory true;
      description
                    "The DetNet forwarding sub-layer operations grouping";
          container forwarding-operation
        "Options for next hops.
         It is expected that further cases will be added through
         augments from other modules, e.g., for recursive
         next hops.";
      case simple-next-hop {
        description
              "DetNet forwarding function operations grouping";
          "This case represents a simple next hop consisting of the
           next-hop address and/or outgoing interface.
           Modules for address families MUST augment this case with a
           leaf forwarding-operation-type {
              type forwarding-operation-ref; containing a next-hop address of that address
           family.";
        uses detnet-header;
   list lower-layer{
          key "index";
   description
                "DetNet forwarding operation "lower-layer info";
          leaf index {
            type such as
                 natively forward, impose and forward, pop and forward,
                 pop and impose and forward, swap and forward,
                 and pop and lookup";
            } uint8;
          }
          container resource-allocate {
            description
              "resource-allocation function operations grouping";
          uses traffic-specification; lower-layer-ref;

   }
      }
      case next-hop-list {
        container qos next-hop-list {
          description
              "QoS function operations grouping";
          }
        }
        container in-segments
            "Container for multiple next hops.";
          list next-hop {
            key "hop-index";
            description
            "DetNet forwarding sub-layer packet identification information";
              "An entry in a next-hop list.

               Modules for address families MUST augment this list
               with a leaf containing a next-hop address of that
               address family.";
            leaf detnet-forwarding-type hop-index {
              type flow-type-ref; uint8;
              description
              "incoming DetNet forwarding packet type"; "";
            }
            uses ipv4-flow-identification detnet-header;
     list lower-layer{
              key "index";
       description "lower-layer info";
              leaf index {
    when "detnet-forwardinge-type = 'ietf-detnet:ipv4'";
                type uint8;
              }
              uses lower-layer-ref;
     }
          }
        }
      }
    }
          uses ipv6-flow-identification {
    when "detnet-forwarding-type = 'ietf-detnet:ipv6'";
  }

  container mpls-flow-identification app-flows {
            when "../detnet-forwarding-type = 'ietf-detnet:mpls'";
    description
              "MPLS type identification information";
    "The DetNet app-flow configuration";
    list app-flow {
      key "name";
      description "";
      leaf label-space name {
        type label-space-ref; "string";
        description
                "Indicate "The name to identify the incoming MPLS label is associated with platform
                 label space or not"; DetNet app-flow";
      }
      container non-platform-label-space end-points {
when "../label-space = 'ietf-detnet:non-platform-label'";
              description
                "MPLS label is associated with non-platform label space,
                 all of the F-labels and incoming interface information was
                 used for identification";
      leaf incoming-interface source-endpoint {
        type if:interface-ref; inet:ip-address;
        description
        "The information of DetNet forwarding packet incoming
                   interface"; application endpoint source address";
      }
              list non-platform-label-stack
      leaf-list destination-endpoints {
                key "index";
        type inet:ip-address;
        description
        "The DetNet application endpoint destination address list";
      }
      }
      leaf app-flow-bidir-congruent {
        type boolean;
        description
                  "All
        "Defines the data path requirement of the label information from App-flow whether it must share the outer label same data path and physical path for both directions through the network, e.g., to provide congruent paths in the current label"; two directions.";
      }
      uses traffic-requirements;
      uses traffic-specification;
      container in-segment {
   description "";
            list app-traffic {
            key "interface";
         description "";
        leaf index interface {
           type uint8; if:interface-ref;
           description
                    "index number 0 indicate last inner label"; "";
        }
         uses mpls-flow-identification; data-flow-spec;
       }
      }
      container platform-label-space out-segment {
             when "../label-space = 'ietf-detnet:platform-label'";
       description
                "MPLS label is associated with platform label space, only
                 the F-label is used
                "detnet-flows that must be mapped to received app-flow or route for identification"; outgoing app-flow";
       uses mpls-flow-identification; detnet-next-hop-content;
      }
    }
  }
  container out-segments service-sub-layer {
    description
            "DetNet forwarding "The DetNet service sub-layer packet processing information"; configuration";
    list service-sub-layer-list {
      key "name";
      description "";
      leaf detnet-forwarding-processing-type name {
        type flow-type-ref; string;
        description
              "outgoing "The name of the DetNet forwarding packet type"; service sub-layer";
      }
          container natively-detnet-forwarding {
            when "../../operations/forwarding-operation"
            + " /forwarding-operation-type = 'natively-forwarding'";
            description
            "Packet forwarding processing information";
            container ipv4-flow
      leaf service-id {
              when "../../detnet-forwarding-processing-type ="
              + "'ietf-detnet:ipv4'";
              description
                "IPv4
        type packet forwarding information"; uint16;
        config false;
        description
          "The DetNet service ID";

      }
      leaf ipv4-next-hop-address service-rank {
        type inet:ipv4-address; uint8;
        description
                  "IPv4 type Next hop IP address";
              }
          "The DetNet rank for this service";
      }
      uses traffic-requirements;
      container ipv6-flow service-portection {
              when "../../detnet-forwarding-processing-type ="
              + "'ietf-detnet:ipv6'";
              description
                "IPv6 type packet forwarding information";
       leaf ipv6-next-hop-address service-protection-type {
        type inet:ipv6-address; service-protection-type;
        description
                  "IPv6
        "The DetNet service protection type Next hop IP address";
              }
            } such as PRF, PEF, PEOF,PERF, and PEORF";
        }
          container detnet-forwarding-encapsulation
      leaf sequence-number-length {
            when "../../operations/forwarding-operation"
            + "/forwarding-operation-type != 'natively-forward'";
       type sequence-number-field;
      description
              "Packet encapsulation information";
            container ip-flow "sequence number filed can choice 0 bit, 16bit, 28 bit filed";
       }
       leaf sequence-number-window-size {
              when "../../detnet-forwarding-processing-type = "
              + "'ietf-detnet:ipv4' or 'ietf-detnet:ipv6'";
       type uint32;
       description
                "The IP "sequence number window size";
       }
       leaf sequence-number-generation {
       type DetNet flow(s) encapsulation information";
              container ipv4-flow sequence-number-generation-type;
       description "config sequence number source";
       }
      }
      leaf service-operation-type {
                when "../../../detnet-forwarding-processing-type = "
                + "'ietf-detnet:ipv4'";
                description
                  "IPv4 packet header encapsulation information";
                uses ipv4-header;
        type service-operation-type;
      }
      container ipv6-flow in-segment {
                when "../../../detnet-forwarding-processing-type = "
                + "'ietf-detnet:ipv6'";
                description
                  "IPv6 packet header encapsulation information";
            uses ipv6-header; app-flows-ref;
            uses incoming-detnet-flows;
      }
      container l4-port-header out-sergment {
                description
                   "TCP/UDP source or destination port number";
            uses l4-port-header; detnet-next-hop-content;
            uses app-flows-ref;
      }
    }
  }
  container mpls-flow forwarding-sub-layer {
              when "../../detnet-forwarding-processing-type = "
              + "'ietf-detnet:mpls'";
    description
                "MPLS label encapsulation information"; "The DetNet forwarding sub-layer configuration";
    list detnet-mpls-label-stack forwarding-sub-layer-list {
      key "index"; "name";
      description
                    "The list of MPLS labels stack for swap or encapsulation"; "";
      leaf index name {
        type uint8; string;
        description
                   "Index "The name of the labels stack"; DetNet forwarding sub-layer";
      }
      container resource-allocation {
        uses mpls-header; traffic-specification;
      }
      leaf forwarding-operation-type {
        type mpls-operations-type;
      }
      container lower-layer-info in-segment {
              description
                "The lower-layer information associated with
                 this forwarding sub-layer";
        leaf lower-layer-type service-sub-layer {
          type flow-type-ref; service-sub-layer-ref;
          description
                  "indicate lower-layer type"; "";
        }
              container interface
        list forwarding-traffic {
                when "../lower-layer-type = 'ietf-detnet:l2'";
          key "interface";
          description
                  "indicate the lower-layer is the outgoing interface"; "";
          leaf outgoing-interface interface {
            type if:interface-ref;
            description
                   "Outgoing interface"; "";
          }
          uses detnet-flow-spec;
        }
      }
      container sub-layer out-segment {
                when "../lower-layer-type != 'ietf-detnet:l2'";
                description
                  "indicate the lower-layer is some of the DetNet sub-layer
                   or TSN sub-network";
        uses detnet-next-hop-content;
        leaf sub-layer service-sub-layer {
          type lower-layer-ref; service-sub-layer-ref;
          description
                   "Specify associated DetNet sub-layer or TSN sub-network";
                }
              } "";
        }
      }
    }
  }
  container sub-network {
        when "../config-type = 'ietf-detnet:tsn-sub-network'";
    description
         "sub-network"; "";
    list sub-network-list {
      key "name";
      description "";
      leaf name {
        type string;
        description "";
      }
    }
  }
}

<CODE ENDS>

8.
7.  Open Issues

   There are some open issues that are still under discussion:

   o  The Relationship with 802.1 TSN YANG models is TBD.  TSN YANG
      models include: P802.1Qcw, which defines TSN YANG for Qbv, Qbu,
      and Qci, name of 'in-segment' and P802.1CBcv, which defines YANG for 802.1CB.  The
      possible problem here is how to avoid possible overlap among yang
      models defined 'out-segment' are still under
      discussion.  These terms are used in IETF and IEEE.  A common YANG model for MPLS, but they
      may be
      defined cause confusion in the future to shared by both TSN and DetNet.  More
      discussion are needed here.

   o  How  Whether application flow should be in service sub-layer is still
      under discussion.

   o  Whether we are supposed to support define a new YANG Model for DetNet OAM is TBD. as
      the current draft does, or we should augment the current YANG
      Model.

   These issues will be resolved in the following versions of the draft.

9.

8.  IANA Considerations

   This document makes no request of IANA.

   Note to RFC Editor: this section may be removed on publication as an
   RFC.

10.

9.  Security Considerations

   <TBD>

11.

10.  Acknowledgements

12.

11.  References

12.1.

11.1.  Normative References

   [I-D.finn-detnet-bounded-latency]
              Finn, N., Boudec, J., Mohammadpour, E., Zhang, J., Varga,
              B., and J. Farkas, "DetNet Bounded Latency", draft-finn-
              detnet-bounded-latency-04 (work in progress), June 2019.

   [I-D.ietf-detnet-architecture]
              Finn, N., Thubert, P., Varga, B., and J. Farkas,
              "Deterministic Networking Architecture", draft-ietf-
              detnet-architecture-13 (work in progress), May 2019.

   [I-D.ietf-detnet-flow-information-model]
              Farkas, J., Varga, B., Cummings, R., Jiang, Y., and D.
              Fedyk, "DetNet Flow Information Model", draft-ietf-detnet-
              flow-information-model-06
              flow-information-model-07 (work in progress), October
              2019. March 2020.

   [I-D.ietf-detnet-ip]
              Varga, B., Farkas, J., Berger, L., Fedyk, D., Malis, A.,
              Bryant, S.,
              and J. Korhonen, S. Bryant, "DetNet Data Plane: IP",
              draft-ietf-detnet-ip-03 draft-ietf-detnet-
              ip-05 (work in progress), October 2019. February 2020.

   [I-D.ietf-detnet-mpls]
              Varga, B., Farkas, J., Berger, L., Fedyk, D., Malis, A.,
              Bryant, S., and J. Korhonen, "DetNet Data Plane: MPLS",
              draft-ietf-detnet-mpls-03
              draft-ietf-detnet-mpls-05 (work in progress), October
              2019. February
              2020.

   [I-D.ietf-detnet-topology-yang]
              Geng, X., Chen, M., Li, Z., and R. Rahman, "Deterministic
              Networking (DetNet) Topology YANG Model", draft-ietf-
              detnet-topology-yang-00 (work in progress), January 2019.

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119,
              DOI 10.17487/RFC2119, March 1997,
              <https://www.rfc-editor.org/info/rfc2119>.

   [RFC6991]  Schoenwaelder, J., Ed., "Common YANG Data Types",
              RFC 6991, DOI 10.17487/RFC6991, July 2013,
              <https://www.rfc-editor.org/info/rfc6991>.

   [RFC7950]  Bjorklund, M., Ed., "The YANG 1.1 Data Modeling Language",
              RFC 7950, DOI 10.17487/RFC7950, August 2016,
              <https://www.rfc-editor.org/info/rfc7950>.

12.2.

   [RFC8655]  Finn, N., Thubert, P., Varga, B., and J. Farkas,
              "Deterministic Networking Architecture", RFC 8655,
              DOI 10.17487/RFC8655, October 2019,
              <https://www.rfc-editor.org/info/rfc8655>.

11.2.  Informative References

   [I-D.geng-detnet-info-distribution]
              Geng, X., Chen, M., Li, Z., Qin, F., and L. Qiang, "IGP-TE
              Extensions for DetNet Information Distribution", draft-
              geng-detnet-info-distribution-04 (work in progress), July
              2019.

   [I-D.ietf-detnet-use-cases]
              Grossman, E., "Deterministic Networking Use Cases", draft-
              ietf-detnet-use-cases-20 (work in progress), December
              2018.

   [I-D.ietf-teas-yang-te]
              Saad, T., Gandhi, R., Liu, X., Beeram, V., and I. Bryskin,
              "A YANG Data Model for Traffic Engineering Tunnels and
              Interfaces", draft-ietf-teas-yang-te-21 draft-ietf-teas-yang-te-22 (work in
              progress), April November 2019.

   [I-D.ietf-teas-yang-te-topo]
              Liu, X., Bryskin, I., Beeram, V., Saad, T., Shah, H., and
              O. Dios, "YANG Data Model for Traffic Engineering (TE)
              Topologies", draft-ietf-teas-yang-te-topo-22 (work in
              progress), June 2019.

   [I-D.thubert-tsvwg-detnet-transport]
              Thubert, P., "A Transport Layer for Deterministic
              Networks", draft-thubert-tsvwg-detnet-transport-01 (work
              in progress), October 2017.

   [I-D.varga-detnet-service-model]
              Varga, B. and J. Farkas, "DetNet Service Model", draft-
              varga-detnet-service-model-02 (work in progress), May
              2017.

   [IEEE802.1CB]
              IEEE, "IEEE, "Frame Replication and Elimination for
              Reliability (IEEE Draft P802.1CB)", 2017,
              <http://www.ieee802.org/1/files/private/cb-drafts/>.",
              2016.

   [IEEE802.1Q-2014]
              "IEEE, "IEEE Std 802.1Q Bridges and Bridged Networks",
              2014, <http://ieeexplore.ieee.org/document/6991462/>.",
              2014.

   [IEEE802.1Qbu]
              IEEE, "IEEE, "IEEE Std 802.1Qbu Bridges and Bridged
              Networks - Amendment 26: Frame Preemption", 2016,
              <http://ieeexplore.ieee.org/document/7553415/>.", 2016.

   [IEEE802.1Qbv]
              "IEEE, "IEEE Std 802.1Qbu Bridges and Bridged Networks -
              Amendment 25: Enhancements for Scheduled Traffic", 2015,
              <http://ieeexplore.ieee.org/document/7572858/>.", 2016.

   [IEEE802.1Qcc]
              IEEE, "IEEE, "Stream Reservation Protocol (SRP)
              Enhancements and Performance Improvements (IEEE Draft
              P802.1Qcc)", 2017,
              <http://www.ieee802.org/1/files/private/cc-drafts/>.".

   [IEEE802.1Qch]
              IEEE, "IEEE, "Cyclic Queuing and Forwarding (IEEE Draft
              P802.1Qch)", 2017,
              <http://www.ieee802.org/1/files/private/ch-drafts/>.",
              2016.

   [IEEE802.1Qci]
              IEEE, "IEEE, "Per-Stream Filtering and Policing (IEEE
              Draft P802.1Qci)", 2016,
              <http://www.ieee802.org/1/files/private/ci-drafts/>.",
              2016.

   [RFC3209]  Awduche, D., Berger, L., Gan, D., Li, T., Srinivasan, V.,
              and G. Swallow, "RSVP-TE: Extensions to RSVP for LSP
              Tunnels", RFC 3209, DOI 10.17487/RFC3209, December 2001,
              <https://www.rfc-editor.org/info/rfc3209>.

   [RFC4875]  Aggarwal, R., Ed., Papadimitriou, D., Ed., and S.
              Yasukawa, Ed., "Extensions to Resource Reservation
              Protocol - Traffic Engineering (RSVP-TE) for Point-to-
              Multipoint TE Label Switched Paths (LSPs)", RFC 4875,
              DOI 10.17487/RFC4875, May 2007,
              <https://www.rfc-editor.org/info/rfc4875>.

   [RFC8342]  Bjorklund, M., Schoenwaelder, J., Shafer, P., Watsen, K.,
              and R. Wilton, "Network Management Datastore Architecture
              (NMDA)", RFC 8342, DOI 10.17487/RFC8342, March 2018,
              <https://www.rfc-editor.org/info/rfc8342>.

Authors' Addresses

   Xuesong Geng
   Huawei Technologies

   Email: gengxuesong@huawei.com

   Mach(Guoyi) Chen
   Huawei Technologies

   Email: mach.chen@huawei.com

   Yeoncheol Ryoo
   ETRI

   Email: dbduscjf@etri.re.kr

   Zhenqiang Li
   China Mobile

   Email: lizhenqiang@chinamobile.com
   Reshad Rahman
   Cisco Systems

   Email: rrahman@cisco.com

   Don Fedyk
   LabN Consulting, L.L.C.

   Email: dfedyk@labn.net