Support of VXLAN based L2 connectivity across Datacenters¶

 container evpn-rd-to-networks {
     config false;
     description "Holds the networks to which given evpn is attached to";
     list evpn-rd-to-network {
        key rd;
        leaf rd {
          type string;
        }
        list evpn-networks {
         key network-id;
         leaf network-id {
           type string;
         }
        }
     }
 }

 grouping vrfEntryBase {
     list vrfEntry{
         key  "destPrefix";
         leaf destPrefix {
             type string;
             mandatory true;
         }
         leaf origin {
             type string;
             mandatory true;
         }
         leaf encap-type {
            type enumeration {
               enum mplsgre {
                  value "0";
                  description "MPLSOverGRE";
               }
               enum vxlan {
                  value "1";
                  description “VNI";
               }
            }
            default "mplsgre";
         }
         leaf l3vni {
            type uint32;
         }
         list route-paths {
             key "nexthop-address";
             leaf nexthop-address {
                 type string;
             }
             leaf label {
                 type uint32;
             }
             leaf gateway_mac_address {
                 type string;
             }
         }
     }
 }

 grouping vrfEntries{
     list vrfEntry{
         key  "destPrefix";
         uses vrfEntryBase;
     }
 }

 grouping macVrfEntries{
     list MacVrfEntry {
         key  "mac_address";
         uses vrfEntryBase;
         leaf l2vni {
            type uint32;
         }
     }
 }

container fibEntries {
      config true;
      list vrfTables {
         key "routeDistinguisher";
         leaf routeDistinguisher {type string;}
         uses vrfEntries;
         uses macVrfEntries;//new field
      }
      container ipv4Table{
         uses ipv4Entries;
      }
 }

 rpc createEVPN {
     description "Create one or more EVPN(s)";
     input {
         list evpn {
             uses evpn-instance;
         }
     }
     output {
         leaf-list response {
             type    string;
             description "Status response for createVPN RPC";
         }
     }
 }

 rpc deleteEVPN{
     description "delete EVPNs for specified Id list";
     input {
         leaf-list id {
             type    yang:uuid;
             description "evpn-id";
         }
     }
     output {
         leaf-list response {
             type    string;
             description "Status response for deleteEVPN RPC";
         }
     }
 }

 grouping evpn-instance {

     leaf id {
         mandatory "true";
         type    yang:uuid;
         description "evpn-id";
     }

     leaf name {
       type    string;
       description "EVPN name";
     }

     leaf tenant-id {
         type    yang:uuid;
         description "The UUID of the tenant that will own the subnet.";
     }

     leaf-list route-distinguisher {
         type string;
         description
         "configures a route distinguisher (RD) for the EVPN instance.
          Format is ASN:nn or IP-address:nn.";
     }

     leaf-list import-RT {
         type string;
         description
         "configures a list of import route target.
          Format is ASN:nn or IP-address:nn.";
     }

     leaf-list export-RT{
         type string;
         description
         "configures a list of export route targets.
          Format is ASN:nn or IP-address:nn.";
     }

     leaf l2vni {
        type uint32;
     }
 }

 augment "/elan:elan-instances/elan:elan-instance" {
     ext:augment-identifier "evpn";
     leaf evpn-name {
         type string;
     }
     leaf l3vpn-name {
         type string;
     }
 }

 container elan-instances {
     list elan-instance {
         key "elan-instance-name";
         leaf elan-instance-name {
             type string;
         }
         //omitted other existing fields
         list external-teps {
             key tep-ip;
             leaf tep-ip {
                 type inet:ip-address;
             }
         }
     }
 }

 container elan-interfaces {
     list elan-interface  {
         key "name";
         leaf name {
             type leafref {
                 path "/if:interfaces/if:interface/if:name";
             }
         }
         leaf elan-instance-name {
             mandatory true;
             type string;
         }
         list static-mac-entries {
             key "mac";
             leaf mac {
                 type yang:phys-address;
             }
             leaf prefix {//new field
                 mandatory false;
                 type inet:ip-address;
             }
         }
     }
 }

 grouping forwarding-entries {
     list mac-entry {
       key "mac-address";
       leaf mac-address {
           type yang:phys-address;
       }
       leaf interface {
          type leafref {
              path "/if:interfaces/if:interface/if:name";
          }
       }
       leaf controllerLearnedForwardingEntryTimestamp {
         type uint64;
       }
       leaf isStaticAddress {
         type boolean;
       }
       leaf prefix {//new field
         mandatory false;
         type inet:ip-address;
       }
     }
 }