legacy_examples

Documentation

Overview

Package legacy_examples contains sample code from prior versions of the CNI library, for use in verifying backwards compatibility.

Index

• Variables
• type Example
  • func (e Example) Build() (string, error)
• type ExampleRuntime

Variables

var ExpectedResult = &types020.Result{
	IP4: &types020.IPConfig{
		IP: net.IPNet{
			IP:   net.ParseIP("10.1.2.3"),
			Mask: net.CIDRMask(24, 32),
		},
		Gateway: net.ParseIP("10.1.2.1"),
		Routes: []types.Route{
			types.Route{
				Dst: net.IPNet{
					IP:   net.ParseIP("0.0.0.0"),
					Mask: net.CIDRMask(0, 32),
				},
				GW: net.ParseIP("10.1.0.1"),
			},
		},
	},
	DNS: types.DNS{
		Nameservers: []string{"8.8.8.8"},
		Domain:      "example.com",
	},
}

ExpectedResult is the current representation of the plugin result that is expected from each of the examples.

As we change the CNI spec, the Result type and this value may change. The text of the example plugins should not.

var NetConfs = map[string]string{
	"unversioned": `{
	"name": "default",
	"type": "ptp",
	"ipam": {
		"type": "host-local",
		"subnet": "10.1.2.0/24"
	}
}`,
	"0.1.0": `{
	"cniVersion": "0.1.0",
	"name": "default",
	"type": "ptp",
	"ipam": {
		"type": "host-local",
		"subnet": "10.1.2.0/24"
	}
}`,
}

NetConfs are various versioned network configuration files. Examples should specify which version they expect

var V010 = Example{
	Name:          "example_v010",
	CNIRepoGitRef: "2c482f4",
	PluginSource: `package main

import (
	"net"

	"github.com/containernetworking/cni/pkg/skel"
	"github.com/containernetworking/cni/pkg/types"
)

var result = types.Result{
	IP4: &types.IPConfig{
		IP: net.IPNet{
			IP:   net.ParseIP("10.1.2.3"),
			Mask: net.CIDRMask(24, 32),
		},
		Gateway: net.ParseIP("10.1.2.1"),
		Routes: []types.Route{
			types.Route{
				Dst: net.IPNet{
					IP:   net.ParseIP("0.0.0.0"),
					Mask: net.CIDRMask(0, 32),
				},
				GW: net.ParseIP("10.1.0.1"),
			},
		},
	},
	DNS: types.DNS{
		Nameservers: []string{"8.8.8.8"},
		Domain:      "example.com",
	},
}

func c(_ *skel.CmdArgs) error { result.Print(); return nil }

func main() { skel.PluginMain(c, c) }
`,
}

V010 acts like a CNI plugin from the v0.1.0 era

var V010_Runtime = ExampleRuntime{
	NetConfs: []string{"unversioned", "0.1.0"},
	Example: Example{
		Name:          "example_invoker_v010",
		CNIRepoGitRef: "c0d34c69",
		PluginSource: `package main

import (
	"fmt"
	"io/ioutil"
	"net"
	"os"

	"github.com/containernetworking/cni/pkg/ns"
	"github.com/containernetworking/cni/libcni"
)

func main(){
	code :=	exec()
	os.Exit(code)
}

func exec() int {
	confBytes, err := ioutil.ReadAll(os.Stdin)
	if err != nil {
		fmt.Printf("could not read netconfig from stdin: %+v", err)
		return 1
	}

	netConf, err := libcni.ConfFromBytes(confBytes)
	if err != nil {
		fmt.Printf("could not parse netconfig: %+v", err)
		return 1
	}
	fmt.Printf("Parsed network configuration: %+v\n", netConf.Network)

	if len(os.Args) == 1 {
		fmt.Printf("Expect CNI plugin paths in argv")
		return 1
	}

	targetNs, err := ns.NewNS()
	if err !=  nil {
		fmt.Printf("Could not create ns: %+v", err)
		return 1
	}
	defer targetNs.Close()

	ifName := "eth0"

	runtimeConf := &libcni.RuntimeConf{
		ContainerID: "some-container-id",
		NetNS:       targetNs.Path(),
		IfName:      ifName,
	}

	cniConfig := &libcni.CNIConfig{Path: os.Args[1:]}

	result, err := cniConfig.AddNetwork(netConf, runtimeConf)
	if err != nil {
		fmt.Printf("AddNetwork failed: %+v", err)
		return 2
	}
	fmt.Printf("AddNetwork result: %+v", result)

	expectedIP := result.IP4.IP

	err = targetNs.Do(func(ns.NetNS) error {
		netif, err := net.InterfaceByName(ifName)
		if err != nil {
			return fmt.Errorf("could not retrieve interface: %v", err)
		}

		addrs, err := netif.Addrs()
		if err != nil {
			return fmt.Errorf("could not retrieve addresses, %+v", err)
		}

		found := false
		for _, addr := range addrs {
			if addr.String() == expectedIP.String() {
				found = true
				break
			}
		}

		if !found {
			return fmt.Errorf("Far-side link did not have expected address %s", expectedIP)
		}
		return nil
	})
	if err != nil {
		fmt.Println(err)
		return 4
	}

	err = cniConfig.DelNetwork(netConf, runtimeConf)
	if err != nil {
		fmt.Printf("DelNetwork failed: %v", err)
		return 5
	}

	err = targetNs.Do(func(ns.NetNS) error {
		_, err := net.InterfaceByName(ifName)
		if err == nil {
			return fmt.Errorf("interface was not deleted")
		}
		return nil
	})
	if err != nil {
		fmt.Println(err)
		return 6
	}

	return 0
}
`,
	},
}

V010_Runtime creates a simple ptp network configuration, then executes libcni against the currently-built plugins.

Types

type Example

type Example struct {
	Name          string
	CNIRepoGitRef string
	PluginSource  string
}

An Example is a Git reference to the CNI repo and a Golang CNI plugin that builds against that version of the repo.

By convention, every Example plugin returns an ADD result that is semantically equivalent to the ExpectedResult.

func (Example) Build

func (e Example) Build() (string, error)

Build builds the example, returning the path to the binary

type ExampleRuntime

type ExampleRuntime struct {
	Example
	NetConfs []string // The network configuration names to pass
}

An ExampleRuntime is a small program that uses libcni to invoke a network plugin. It should call ADD and DELETE, verifying all intermediate steps and data structures.