module ietf-tunnel-steering {

    yang-version 1;

    namespace
      "urn:ietf:params:xml:ns:yang:ietf-tunnel-steering";

    prefix tnl-steer;

    import ietf-inet-types {
      prefix inet;
    }
    import ietf-te-types {
      prefix te-types;
    }

    organization
      "IETF Traffic Engineering Architecture and Signaling (TEAS)
     Working Group";

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

     Editors:  Igor Bryskin
               <mailto:Igor.Bryskin@huawei.com>

     Editor:   Vishnu Pavan Beeram
               <mailto:vbeeram@juniper.net>

     Editor:   Tarek Saad
               <mailto:tsaad@cisco.com>

     Editor:   Xufeng Liu
               <mailto:xufeng.liu.ietf@gmail.com>

     Editor:   Young Lee
               <mailto:leeyoung@huawei.com> ";

    description
      "This data model is for steering client service to server
     tunnels.

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

     Redistribution and use in source and binary forms, with or
     without modification, is permitted pursuant to, and subject to
     the license terms contained in, the Simplified BSD License set
     forth in Section 4.c of the IETF Trust's Legal Provisions
     Relating to IETF Documents
     (http://trustee.ietf.org/license-info).

     This version of this YANG module is part of RFC XXXX; see the
     RFC itself for full legal notices.";

    revision "2020-01-05" {
      description "Initial revision";
      reference
        "TBD";

    }


    identity service-type {
      description
        "Base identity for client service type.";
    }

    identity service-type-l3vpn {
      base service-type;
      description "L3VPN service.";
    }

    identity service-type-l2vpn {
      base service-type;
      description "L2VPN service.";
    }

    identity service-type-evpn {
      base service-type;
      description "EVPN service.";
    }

    identity service-type-eline {
      base service-type;
      description "ELINE service.";
    }

    identity service-type-epl {
      base service-type;
      description "EPL service.";
    }

    identity service-type-evpl {
      base service-type;
      description "EVPL service.";
    }

    identity service-type-l1vpn {
      base service-type;
      description "L1VPN service.";
    }

    identity service-type-actn-vn {
      base service-type;
      description "ACTN VN service.";
    }

    identity service-type-transparent {
      base service-type;
      description "Transparent LAN service.";
    }

    identity tunnel-type {
      description
        "Base identity for tunnel type.";
    }

    identity tunnel-type-te-p2p {
      base tunnel-type;
      description
        "TE point-to-point tunnel type.";
    }

    identity tunnel-type-te-p2mp {
      base tunnel-type;
      description
        "TE point-to-multipoint tunnel type.";
      reference
        "RFC4875";

    }

    identity tunnel-type-te-sr {
      base tunnel-type;
      description
        "Segment Rouging TE tunnel type.";
    }

    identity tunnel-type-sr {
      base tunnel-type;
      description
        "Segment Rouging tunnel type.";
    }

    identity tunnel-type-ldp-p2p {
      base tunnel-type;
      description
        "LDP point-to-point tunnel type.";
    }

    identity tunnel-type-ldp-mp2mp {
      base tunnel-type;
      description
        "Multicast LDP multipoint-to-multipoint tunnel type.";
    }

    identity tunnel-type-gre {
      base tunnel-type;
      description "GRE tunnel type.";
    }

    identity tunnel-type-pbb {
      base tunnel-type;
      description "PBB tunnel type.";
    }

    identity service-encapsulation-type {
      description
        "Base identity for tunnel encapsulation.";
    }

    identity service-encapsulation-type-mpls-label {
      base service-encapsulation-type;
      description
        "Encapsulated by MPLS label stack, as an inner lable to
       identify the customer service.";
    }

    identity service-encapsulation-type-ethernet-c-tag {
      base service-encapsulation-type;
      description
        "Encapsulated by Ethernet C-TAG, to identify the customer
       service.";
    }

    identity tunnel-encapsulation-type {
      description
        "Base identity for tunnel encapsulation.";
    }

    identity tunnel-encapsulation-type-mpls-label {
      base tunnel-encapsulation-type;
      description
        "Encapsulated by MPLS label stack, as an outer label to
       be pushed into the tunnel.";
    }

    identity tunnel-encapsulation-type-ethernet-s-tag {
      base tunnel-encapsulation-type;
      description
        "Encapsulated by Ethernet S-TAG.";
    }

    identity tunnel-encapsulation-type-pbb {
      base tunnel-encapsulation-type;
      description
        "Encapsulated by PBB header.";
    }

    identity tunnel-encapsulation-type-gre {
      base tunnel-encapsulation-type;
      description
        "Encapsulated by GRE header.";
    }

    container tunnel-pools {
      description
        "A list of mappings that steer client services to transport
       tunnel pools. The tunnel pools are managed independently from
       the services steered on them.";
      list tunnel-pool {
        key "color";
        description
          "A set of transport tunnels (presumably with similar
         characteristics) identified by a network unique ID, named
         'color'.";
        leaf color {
          type uint32;
          description
            "Unique ID of a tunnel pool.";
        }

        leaf description {
          type string;
          description
            "Client provided description of the tunnel pool.";
        }

        uses te-types:te-topology-identifier;

        list service {
          key "service-type id";
          description
            "A list of client services that are steered on this tunnel
           pool.";
          leaf service-type {
            type identityref {
              base service-type;
            }
            description
              "Service type required by the client.";
          }

          leaf id {
            type string;
            description
              "Unique ID of a client service for the specified
             service type.";
          }

          container encapsulation {
            description
              "The encapsulation information used to identify the
             customer service for multiplexing over shared tunnels.";
            leaf type {
              type identityref {
                base service-encapsulation-type;
              }
              description
                "The encapsulation type used to identify the customer
               service for multiplexing over shared tunnels.";
            }

            leaf value {
              type binary;
              description
                "The encapsulation value pushed to the tunnel to
               identify this service.
               If not specified, the system decides what
               value to be used for multiplexing.";
            }
          }  // container encapsulation

          list access-point {
            key "node-address link-termination-point";
            description
              "A list of client ports (Link Termination Points) for the
             service to enter or exist.";
            leaf node-address {
              type inet:ip-address;
              description
                "Node over which the service enters or exists.";
            }

            leaf link-termination-point {
              type string;
              description
                "Client port (Link Termination Point) over which the
               service enters or exits.";
            }

            leaf direction {
              type enumeration {
                enum "in" {
                  value 0;
                  description
                    "The service enters to the network.";
                }
                enum "out" {
                  value 1;
                  description
                    "The service exists from the network.";
                }
                enum "in-out" {
                  value 2;
                  description
                    "The service enters to and exists from the
                   network.";
                }
              }
              description
                "Whether the service enters to or exits from the
               network.";
            }
          }  // list access-point
        }  // list service

        list tunnel {
          key "tunnel-type source destination tunnel-id";
          description
            "A list of tunnels in the tunnel pool.";
          leaf tunnel-type {
            type identityref {
              base tunnel-type;
            }
            description
              "Tunnel type based on constructing technologies and
             multipoint types, including P2P-TE, P2MP-TE, SR-TE,
             SR P2P, LDP P2P, LDP MP2MP, GRE, PBB, etc";
          }

          leaf source {
            type inet:ip-address;
            description
              "For a p2p or p2mp tunnel, this is the source address;
             for a mp2mp tunnel, this is the root address.";
            reference
              "RFC3209, RFC4875, RFC6388, RFC7582.";

          }

          leaf destination {
            type inet:ip-address;
            description
              "For a p2p tunnel, this is the tunnel endpoint address
             extracted from SESSION object;
             for a p2mp tunnel, this identifies the destination
             group, or p2mp-id;
             for a mp2mp tunnel identified by root and opaque-value,
             this value is set to '0.0.0.0'.";
            reference
              "RFC3209, RFC4875, RFC6388, RFC7582.";

          }

          leaf tunnel-id {
            type binary;
            description
              "For a p2p or p2mp tunnel, this is the tunnel identifier
             used in the SESSION that remains constant over the life
             of the tunnel;
             for a mp2mp tunnel, this is the opaque-value in the
             FEC element.";
            reference
              "RFC3209, RFC4875, RFC6388, RFC7582.";

          }

          container encapsulation {
            description
              "The encapsulation information used by the tunnel.";
            leaf type {
              type identityref {
                base service-encapsulation-type;
              }
              description
                "The encapsulation type used by the tunnel.";
            }

            leaf value {
              type binary;
              description
                "The encapsulation value pushed to the tunnel data to
               identify the traffic in this tunnel.
               If not specified, the system decides what
               value to be used.";
            }
          }  // container encapsulation
        }  // list tunnel
      }  // list tunnel-pool
    }  // container tunnel-pools
  }  // module ietf-tunnel-steering