L2VPN version5

module l2vpn {
  namespace "http://example.com/l2vpn";
  prefix l2vpn;

  import ietf-inet-types { prefix inet; }
  import tailf-ncs { prefix ncs; }

  description "A service for managing multiple L2VPN point-to-point connections.";

  revision 2025-08-12 {
    description "Refactored to define common endpoint data at the top level.";
  }

  grouping L2VPN-ENDPOINT-COMMON {
    leaf device {
      type leafref {
        path "/ncs:devices/ncs:device/ncs:name";
      }
      mandatory true;
      description "The PE device for this endpoint.";
    }
    leaf pe-neighbor-ip {
      type inet:ipv4-address;
      mandatory true;
      description "The IP address of this PE router for peering (e.g., Loopback IP).";
    }
  }

  grouping L2VPN-ENDPOINT-CONNECTION-DETAILS {
    leaf interface-type {
      type enumeration {
        enum "GigabitEthernet";
        enum "TenGigE";
        enum "HundredGigE";
      }
      mandatory true;
    }
    leaf interface-main-id { type string; mandatory true; }
    leaf subinterface-id { type uint32; }
    leaf p2p-name { type string; }
    leaf mtu { type uint16; }

    container rewrite-policy {
      leaf rewrite-type {
        type enumeration {
          enum "none";
          enum "pop1";
          enum "translate1to1";
        }
        default "none";
      }
      leaf rewrite-vlan-id {
        when "../rewrite-type = 'translate1to1'";
        type int32 { range "1..4000"; }
        mandatory true;
      }
    }
  }

  list l2vpn {
    key name;
    uses ncs:service-data;
    ncs:servicepoint "l2vpn-servicepoint";

    leaf name {
      type string;
      description "Unique name for this L2VPN service container.";
    }

    leaf group-name {
      type string;
      mandatory true;
    }

    container endpoint-A {
      uses L2VPN-ENDPOINT-COMMON;
    }

    container endpoint-B {
      uses L2VPN-ENDPOINT-COMMON;
    }

    list p2p-connection {
      key "connection-name";
      description "A list of individual P2P connections between the two endpoints defined above.";

      leaf connection-name { type string; }
      leaf pw-id { type uint32; mandatory true; }
      leaf pw-class-name { type string; }
      leaf control-word { type boolean; default "false"; }
      leaf vlan-id {
        type int32 {
          range "1..4000";
        }
        mandatory true;
      }
      leaf encapsulation-type {
        type enumeration {
          enum "dot1q";
          enum "untagged";
          enum "default";
        }
        mandatory true;
        description "Encapsulation type for the L2 transport interface (dot1q, untagged, or default).";
      }

      container endpoint-A {
        uses L2VPN-ENDPOINT-CONNECTION-DETAILS;
      }

      container endpoint-B {
        uses L2VPN-ENDPOINT-CONNECTION-DETAILS;
      }
    }
  }
}

import ncs
from ncs.application import Service

class ServiceCallbacks(Service):
    @Service.create
    def cb_create(self, tctx, root, service, proplist):
        self.log.info(f"Service create called for l2vpn: {service.name}")
        template = ncs.template.Template(service)

        for connection in service.p2p_connection:
            self.log.info(f"Processing connection: {connection.connection_name}")
            tvars_a = self.get_tvars(root, service, connection, 'A')
            template.apply('l2vpn-template', tvars_a)

            tvars_b = self.get_tvars(root, service, connection, 'B')
            template.apply('l2vpn-template', tvars_b)

    def get_tvars(self, root, service, conn, endpoint_id):
        tvars = ncs.template.Variables()
        if endpoint_id == 'A':
            common_ep = service.endpoint_A
            conn_ep = conn.endpoint_A
        else:
            common_ep = service.endpoint_B
            conn_ep = conn.endpoint_B


        tvars.add('XCONNECT_GROUP_NAME', service.group_name)
        tvars.add('PW_ID', conn.pw_id)
        tvars.add('CONTROL_WORD_ENABLED', 'true' if conn.control_word else 'false')
        tvars.add('L2_SERV_VLAN_ID', conn.vlan_id)
        tvars.add('L2_SERV_ENCAP', conn.encapsulation_type)

        tvars.add('PW_CLASS_NAME', conn.pw_class_name if conn.pw_class_name else conn.connection_name)
        tvars.add('P2P_NAME', conn_ep.p2p_name if conn_ep.p2p_name else conn.connection_name)
        tvars.add('PW_CLASS_REF', conn_ep.p2p_name if conn_ep.p2p_name else conn.connection_name)
        
        device_name = common_ep.device
        tvars.add('DEVICE', device_name)
        tvars.add('NEIGHBOR_IP', common_ep.pe_neighbor_ip)

        iface_type_str = str(conn_ep.interface_type)
        iface_main_id = conn_ep.interface_main_id
        sub_id = conn_ep.subinterface_id if conn_ep.subinterface_id else conn.vlan_id
        
        full_subif_name = f"{iface_type_str}{iface_main_id}.{sub_id}"

        tvars.add('INTERFACE_TYPE', iface_type_str)
        tvars.add('INTERFACE_ID', f"{iface_main_id}.{sub_id}")
        tvars.add('FULL_INTERFACE_NAME', full_subif_name)

        mtu_value = conn_ep.mtu if conn_ep.mtu else 1522 
        try:
            full_if_name = f"{iface_type_str}{iface_main_id}"
            self.log.info(f"Attempting to read MTU for {device_name}:{full_if_name}")
            interface_config = root.devices.device[device_name].config.interface
            phy_if = interface_config[iface_type_str][iface_main_id]

            if phy_if.mtu is not None:
                mtu_value = phy_if.mtu
                self.log.info(f"SUCCESS: Read existing MTU {mtu_value} from {device_name}:{full_if_name}")
            else:
                 self.log.info(f"INFO: MTU not configured on {device_name}:{full_if_name}. Using value from service: {mtu_value}.")
        except Exception as e:
            self.log.info(f"WARN: Could not read device MTU for {device_name}:{full_if_name}. Using value from service: {mtu_value}. Exception: {e}")
        tvars.add('MTU', mtu_value)


        l2_serv_ingress_rewrite_type = 'none'
        l2_serv_ingress_rewrite_vlan = 0
        if hasattr(conn_ep, 'rewrite_policy'):
            rewrite_policy = conn_ep.rewrite_policy
            l2_serv_ingress_rewrite_type = rewrite_policy.rewrite_type
            if l2_serv_ingress_rewrite_type == 'translate1to1' and hasattr(rewrite_policy, 'rewrite_vlan_id'):
                l2_serv_ingress_rewrite_vlan = rewrite_policy.rewrite_vlan_id

        tvars.add('L2_SERV_INGRESS_REWRITE_TYPE', l2_serv_ingress_rewrite_type)
        tvars.add('L2_SERV_INGRESS_REWRITE_VLAN', l2_serv_ingress_rewrite_vlan)

        self.log.info(f"Generated TVARS for {device_name} ({endpoint_id}): {tvars}")
        return tvars


class L2vpn(ncs.application.Application):
    def setup(self):
        self.log.info('L2vpn RUNNING')
        self.register_service('l2vpn-servicepoint', ServiceCallbacks)

    def teardown(self):
        self.log.info('L2vpn FINISHED')

<config xmlns="http://tail-f.com/ns/config/1.0"
                 xmlns:ncs="http://tail-f.com/ns/ncs">
  <devices xmlns="http://tail-f.com/ns/ncs">
    <device>
      <name>{$DEVICE}</name>
      <config>
        
        <interface xmlns="http://tail-f.com/ned/cisco-ios-xr">
          <GigabitEthernet-subinterface ncs:when="{$INTERFACE_TYPE = 'GigabitEthernet'}">
            <GigabitEthernet>
              <id>{$INTERFACE_ID}</id>
              <mode>l2transport</mode>
              <mtu>{$MTU}</mtu>
              <encapsulation>
                <dot1q>
                  <vlan-id>{$L2_SERV_VLAN_ID}</vlan-id>
                </dot1q>
              </encapsulation>
              <rewrite ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE != 'none'}">
                <ingress>
                  <tag>
                    <pop ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'pop1'}">1</pop>
                    <translate ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'translate1to1'}">1-to-1</translate>
                    <dot1q ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'translate1to1' and $L2_SERV_INGRESS_REWRITE_VLAN != 0}">{$L2_SERV_INGRESS_REWRITE_VLAN}</dot1q>
                    <mode ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'translate1to1'}">symmetric</mode>
                  </tag>
                </ingress>
              </rewrite>
            </GigabitEthernet>
          </GigabitEthernet-subinterface>

          <TenGigE-subinterface ncs:when="{$INTERFACE_TYPE = 'TenGigE'}">
            <TenGigE>
              <id>{$INTERFACE_ID}</id>
              <mode>l2transport</mode>
              <mtu>{$MTU}</mtu>
              <encapsulation>
                <dot1q>
                  <vlan-id>{$L2_SERV_VLAN_ID}</vlan-id>
                </dot1q>
              </encapsulation>
              <rewrite ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE != 'none'}">
                <ingress>
                  <tag>
                    <pop ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'pop1'}">1</pop>
                    <translate ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'translate1to1'}">1-to-1</translate>
                    <dot1q ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'translate1to1' and $L2_SERV_INGRESS_REWRITE_VLAN != 0}">{$L2_SERV_INGRESS_REWRITE_VLAN}</dot1q>
                    <mode ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'translate1to1'}">symmetric</mode>
                  </tag>
                </ingress>
              </rewrite>
            </TenGigE>
          </TenGigE-subinterface>
          
          <HundredGigE-subinterface ncs:when="{$INTERFACE_TYPE = 'HundredGigE'}">
            <HundredGigE>
              <id>{$INTERFACE_ID}</id>
              <mode>l2transport</mode>
              <mtu>{$MTU}</mtu>
              <encapsulation>
                <dot1q>
                  <vlan-id>{$L2_SERV_VLAN_ID}</vlan-id>
                </dot1q>
              </encapsulation>
              <rewrite ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE != 'none'}">
                <ingress>
                  <tag>
                    <pop ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'pop1'}">1</pop>
                    <translate ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'translate1to1'}">1-to-1</translate>
                    <dot1q ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'translate1to1' and $L2_SERV_INGRESS_REWRITE_VLAN != 0}">{$L2_SERV_INGRESS_REWRITE_VLAN}</dot1q>
                    <mode ncs:when="{$L2_SERV_INGRESS_REWRITE_TYPE = 'translate1to1'}">symmetric</mode>
                  </tag>
                </ingress>
              </rewrite>
            </HundredGigE>
          </HundredGigE-subinterface>
        </interface>
        
        <l2vpn xmlns="http://tail-f.com/ned/cisco-ios-xr">
          <pw-class>
            <name>{$PW_CLASS_NAME}</name>
            <encapsulation>
              <mpls>
                <control-word ncs:when="{$CONTROL_WORD_ENABLED = 'true'}"/>
              </mpls>
            </encapsulation>
          </pw-class>
          <xconnect>
            <group>
              <name>{$XCONNECT_GROUP_NAME}</name>
              <p2p>
                <name>{$P2P_NAME}</name>
                <interface>
                  <name>{$FULL_INTERFACE_NAME}</name>
                </interface>
                <neighbor>
                  <address>{$NEIGHBOR_IP}</address>
                  <pw-id>{$PW_ID}</pw-id>
                  <ip-version>ipv4</ip-version>
                  <pw-class>{$PW_CLASS_REF}</pw-class>
                </neighbor>
              </p2p>
            </group>
          </xconnect>
        </l2vpn>
      </config>
    </device>
  </devices>
</config>