ietf-tunnel-steering

This data model is for steering client service to server tunnels. Copyright (c) 2020 IETF Trust and the persons identified as a...

  • Version: 2020-01-05

    ietf-tunnel-steering@2020-01-05


    
      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.";
            }
    
            container te-topology-identifier {
              description
                "TE topology identifier container.";
              leaf provider-id {
                type te-global-id;
                default "0";
                description
                  "An identifier to uniquely identify a provider.
    If omitted, it assumes that the topology provider ID
    value = 0 (the default).";
              }
    
              leaf client-id {
                type te-global-id;
                default "0";
                description
                  "An identifier to uniquely identify a client.
    If omitted, it assumes that the topology client ID
    value = 0 (the default).";
              }
    
              leaf topology-id {
                type te-topology-id;
                default "";
                description
                  "When the datastore contains several topologies,
    'topology-id' distinguishes between them.  If omitted,
    the default (empty) string for this leaf is assumed.";
              }
            }  // container 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
    

© 2023 YumaWorks, Inc. All rights reserved.