New link struct - Vxlan

.github/workflows/cicd.yml

@@ -408,7 +408,14 @@ jobs:
           path: ./tests/coverage/*
           retention-days: 7
 
-    # create a job that downloads coverage artifact and uses codecov to upload it
+  vxlan-tests:
+    uses: ./.github/workflows/vxlan-tests.yml
+    needs:
+      - unit-test
+      - staticcheck
+      - build-containerlab
+
+  # a job that downloads coverage artifact and uses codecov to upload it
   coverage:
     runs-on: ubuntu-22.04
     needs:
@@ -418,6 +425,7 @@ jobs:
       - ceos-basic-tests
       - srlinux-basic-tests
       - ixiac-one-basic-tests
+      - vxlan-tests
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -473,11 +481,13 @@ jobs:
     if: startsWith(github.ref, 'refs/tags/v')
     needs:
       - docs-test
+      - unit-test
       - smoke-tests
       - ceos-basic-tests
       - srlinux-basic-tests
       - ixiac-one-basic-tests
       - ext-container-tests
+      - vxlan-tests
     steps:
       - name: Checkout
         uses: actions/checkout@v4

.github/workflows/vxlan-tests.yml

@@ -0,0 +1,61 @@
+name: vxlan-test
+
+"on":
+  workflow_call:
+
+jobs:
+  vxlan-tests:
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        runtime:
+          - "docker"
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: containerlab
+
+      - name: Move containerlab to usr/bin
+        run: sudo mv ./containerlab /usr/bin/containerlab && sudo chmod a+x /usr/bin/containerlab
+
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+          cache: pip
+          cache-dependency-path: "tests/requirements.txt"
+
+      - name: Install robotframework
+        run: |
+          pip install -r tests/requirements.txt
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Run tests
+        run: |
+          bash ./tests/rf-run.sh ${{ matrix.runtime }} ./tests/08-vxlan/
+
+      # upload test reports as a zip file
+      - uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: 08-vxlan-log
+          path: ./tests/out/*.html
+
+      # upload coverage report from unit tests, as they are then
+      # merged with e2e tests coverage
+      - uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: coverage
+          path: ./tests/coverage/*
+          retention-days: 7

clab/clab.go

@@ -602,6 +602,14 @@ func (c *CLab) DeleteNodes(ctx context.Context, workers uint, serialNodes map[st
 	close(concurrentChan)
 	close(serialChan)
 
+	// also call delete on the special nodes
+	for _, n := range c.GetSpecialLinkNodes() {
+		err := n.Delete(ctx)
+		if err != nil {
+			log.Warn(err)
+		}
+	}
+
 	wg.Wait()
 }
 
@@ -663,38 +671,9 @@ func (c *CLab) GetNodeRuntime(contName string) (runtime.ContainerRuntime, error)
 	return nil, fmt.Errorf("could not find a container matching name %q", contName)
 }
 
-// VethCleanup iterates over links found in clab topology to initiate removal of dangling veths
-// in host networking namespace or attached to linux bridge.
-// See https://github.com/srl-labs/containerlab/issues/842 for the reference.
-func (c *CLab) VethCleanup(ctx context.Context) error {
-	hostBasedEndpoints := []links.Endpoint{}
-
-	// collect the endpoints of regular nodes
-	for _, n := range c.Nodes {
-		if n.Config().IsRootNamespaceBased || n.Config().NetworkMode == "host" {
-			hostBasedEndpoints = append(hostBasedEndpoints, n.GetEndpoints()...)
-		}
-	}
-
-	// collect the endpoints of the fake nodes
-	hostBasedEndpoints = append(hostBasedEndpoints, links.GetHostLinkNode().GetEndpoints()...)
-	hostBasedEndpoints = append(hostBasedEndpoints, links.GetMgmtBrLinkNode().GetEndpoints()...)
-
-	var joinedErr error
-	for _, ep := range hostBasedEndpoints {
-		// finally remove all the collected endpoints
-		log.Debugf("removing endpoint %s", ep.String())
-		err := ep.Remove()
-		if err != nil {
-			joinedErr = errors.Join(joinedErr, err)
-		}
-	}
-
-	return joinedErr
-}
-
-// ResolveLinks resolves raw links to the actual link types and stores them in the CLab.Links map.
-func (c *CLab) ResolveLinks() error {
+// GetLinkNodes returns all CLab.Nodes nodes as links.Nodes enriched with the special nodes - host and mgmt-net.
+// The CLab nodes are copied to a new map and thus clab.Node interface is converted to link.Node.
+func (c *CLab) GetLinkNodes() map[string]links.Node {
 	// resolveNodes is a map of all nodes in the topology
 	// that is artificially created to combat circular dependencies.
 	// If no circ deps were in place we could've used c.Nodes map instead.
@@ -704,17 +683,32 @@ func (c *CLab) ResolveLinks() error {
 		resolveNodes[k] = v
 	}
 
+	// add the virtual host and mgmt-bridge nodes to the resolve nodes
+	specialNodes := c.GetSpecialLinkNodes()
+	for _, n := range specialNodes {
+		resolveNodes[n.GetShortName()] = n
+	}
+
+	return resolveNodes
+}
+
+// GetSpecialLinkNodes returns a map of special nodes that are used to resolve links.
+// Special nodes are host and mgmt-bridge nodes that are not typically present in the topology file
+// but are required to resolve links.
+func (c *CLab) GetSpecialLinkNodes() map[string]links.Node {
 	// add the virtual host and mgmt-bridge nodes to the resolve nodes
 	specialNodes := map[string]links.Node{
 		"host":     links.GetHostLinkNode(),
 		"mgmt-net": links.GetMgmtBrLinkNode(),
 	}
-	for _, n := range specialNodes {
-		resolveNodes[n.GetShortName()] = n
-	}
 
+	return specialNodes
+}
+
+// ResolveLinks resolves raw links to the actual link types and stores them in the CLab.Links map.
+func (c *CLab) ResolveLinks() error {
 	resolveParams := &links.ResolveParams{
-		Nodes:          resolveNodes,
+		Nodes:          c.GetLinkNodes(),
 		MgmtBridgeName: c.Config.Mgmt.Bridge,
 		NodesFilter:    c.nodeFilter,
 	}

clab/netlink.go

@@ -7,7 +7,6 @@ package clab
 import (
 	"fmt"
 	"net"
-	"strings"
 
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/google/uuid"
@@ -316,26 +315,3 @@ func genIfName() string {
 	s, _ := uuid.New().MarshalText() // .MarshalText() always return a nil error
 	return string(s[:8])
 }
-
-// GetLinksByNamePrefix returns a list of links whose name matches a prefix.
-func GetLinksByNamePrefix(prefix string) ([]netlink.Link, error) {
-	// filtered list of interfaces
-	if prefix == "" {
-		return nil, fmt.Errorf("prefix is not specified")
-	}
-	var fls []netlink.Link
-
-	ls, err := netlink.LinkList()
-	if err != nil {
-		return nil, err
-	}
-	for _, l := range ls {
-		if strings.HasPrefix(l.Attrs().Name, prefix) {
-			fls = append(fls, l)
-		}
-	}
-	if len(fls) == 0 {
-		return nil, fmt.Errorf("no links found by specified prefix %s", prefix)
-	}
-	return fls, nil
-}

cmd/destroy.go

@@ -221,10 +221,5 @@ func destroyLab(ctx context.Context, c *clab.CLab) (err error) {
 		}
 	}
 
-	// Remove any dangling veths from host netns or bridges
-	err = c.VethCleanup(ctx)
-	if err != nil {
-		return fmt.Errorf("error during veth cleanup procedure, %w", err)
-	}
 	return err
 }

cmd/vxlan.go

@@ -5,13 +5,15 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"net"
 
 	"github.com/jsimonetti/rtnetlink/rtnl"
 	log "github.com/sirupsen/logrus"
 	"github.com/spf13/cobra"
-	"github.com/srl-labs/containerlab/clab"
+	"github.com/srl-labs/containerlab/links"
+	"github.com/srl-labs/containerlab/utils"
 	"github.com/vishvananda/netlink"
 )
 
@@ -57,6 +59,9 @@ var vxlanCreateCmd = &cobra.Command{
 	Use:   "create",
 	Short: "create vxlan interface",
 	RunE: func(cmd *cobra.Command, args []string) error {
+
+		ctx := context.Background()
+
 		if _, err := netlink.LinkByName(cntLink); err != nil {
 			return fmt.Errorf("failed to lookup link %q: %v",
 				cntLink, err)
@@ -76,20 +81,48 @@ var vxlanCreateCmd = &cobra.Command{
 			parentDev = r.Interface.Name
 		}
 
-		vxlanCfg := clab.VxLAN{
-			Name:     "vx-" + cntLink,
-			ID:       vxlanID,
-			ParentIf: parentDev,
-			Remote:   net.ParseIP(vxlanRemote),
-			MTU:      vxlanMTU,
-			UDPPort:  vxlanUDPPort,
+		vxlraw := &links.LinkVxlanRaw{
+			Remote:          vxlanRemote,
+			Vni:             vxlanID,
+			ParentInterface: parentDev,
+			LinkCommonParams: links.LinkCommonParams{
+				MTU: vxlanMTU,
+			},
+			UdpPort:    vxlanUDPPort,
+			NoLearning: true,
+			NoL2Miss:   true,
+			NoL3Miss:   true,
+			LinkType:   links.LinkTypeVxlanStitch,
+			Endpoint: *links.NewEndpointRaw(
+				"host",
+				cntLink,
+				"",
+			),
+		}
+
+		rp := &links.ResolveParams{
+			Nodes: map[string]links.Node{
+				"host": links.GetHostLinkNode(),
+			},
+			VxlanIfaceNameOverwrite: cntLink,
 		}
 
-		if err := clab.AddVxLanInterface(vxlanCfg); err != nil {
+		link, err := vxlraw.Resolve(rp)
+		if err != nil {
 			return err
 		}
 
-		return clab.BindIfacesWithTC(vxlanCfg.Name, cntLink)
+		var vxl *links.VxlanStitched
+		var ok bool
+		if vxl, ok = link.(*links.VxlanStitched); !ok {
+			return fmt.Errorf("not a VxlanStitched link")
+		}
+
+		err = vxl.DeployWithExistingVeth(ctx)
+		if err != nil {
+			return err
+		}
+		return nil
 	},
 }
 
@@ -100,7 +133,7 @@ var vxlanDeleteCmd = &cobra.Command{
 		var ls []netlink.Link
 		var err error
 
-		ls, err = clab.GetLinksByNamePrefix(delPrefix)
+		ls, err = utils.GetLinksByNamePrefix(delPrefix)
 
 		if err != nil {
 			return err

docs/manual/topo-def-file.md

@@ -231,14 +231,51 @@ In comparison to the veth type, no bridge or other namespace is required to be r
       - node: <NodeA-Name>                  # mandatory
         interface: <NodeA-Interface-Name>   # mandatory
         mac: <NodeA-Interface-Mac>          # optional
-    host-interface: <interface-name         # mandatory
+    host-interface: <interface-name>        # mandatory
     mtu: <link-mtu>                         # optional
     vars: <link-variables>                  # optional (used in templating)
     labels: <link-labels>                   # optional (used in templating)
 ```
 
 The `host-interface` parameter defines the name of the veth interface in the host's network namespace.
 
+###### vxlan
+The vxlan type results in a vxlan tunnel interface that is created in the host namespace and subsequently pushed into the nodes network namespace.
+
+```yaml
+  links:
+    - type: vxlan                       
+      endpoint:                              # mandatory
+        node: <Node-Name>                    # mandatory
+        interface: <Node-Interface-Name>     # mandatory
+        mac: <Node-Interface-Mac>            # optional
+      remote: <Remote-VTEP-IP>               # mandatory
+      vni: <VNI>                             # mandatory
+      udp-port: <VTEP-UDP-Port>              # mandatory
+      mtu: <link-mtu>                        # optional
+      vars: <link-variables>                 # optional (used in templating)
+      labels: <link-labels>                  # optional (used in templating)
+```
+
+###### vxlan-stitched
+The vxlan-stitched type results in a veth pair linking the host namespace and the nodes namespace and a vxlan tunnel that also terminates in the host namespace.
+In addition to these interfaces, tc rules are being provisioned to stitch the vxlan tunnel and the host based veth interface together.
+
+```yaml
+  links:
+    - type: vxlan-stitch
+      endpoint:                              # mandatory
+        node: <Node-Name>                    # mandatory
+        interface: <Node-Interface-Name>     # mandatory
+        mac: <Node-Interface-Mac>            # optional
+      remote: <Remote-VTEP-IP>               # mandatory
+      vni: <VNI>                             # mandatory
+      udp-port: <VTEP-UDP-Port>              # mandatory
+      mtu: <link-mtu>                        # optional
+      vars: <link-variables>                 # optional (used in templating)
+      labels: <link-labels>                  # optional (used in templating)
+```
+
 #### Kinds
 
 Kinds define the behavior and the nature of a node, it says if the node is a specific containerized Network OS, virtualized router or something else. We go into details of kinds in its own [document section](kinds/index.md), so here we will discuss what happens when `kinds` section appears in the topology definition:

links/endpoint_bridge.go

@@ -12,6 +12,12 @@ type EndpointBridge struct {
 	EndpointGeneric
 }
 
+func NewEndpointBridge(eg *EndpointGeneric) *EndpointBridge {
+	return &EndpointBridge{
+		EndpointGeneric: *eg,
+	}
+}
+
 func (e *EndpointBridge) Verify(p *VerifyLinkParams) error {
 	var errs []error
 	err := CheckEndpointUniqueness(e)