Merge pull request #537 from dcbw/100

Port plugins to CNI 1.0.0 and increase old verison test coverage

plugins/ipam/dhcp/daemon.go

@@ -30,7 +30,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/coreos/go-systemd/activation"
 )
 
@@ -43,13 +43,15 @@ type DHCP struct {
 	leases          map[string]*DHCPLease
 	hostNetnsPrefix string
 	clientTimeout   time.Duration
+	clientResendMax time.Duration
 	broadcast       bool
 }
 
-func newDHCP(clientTimeout time.Duration) *DHCP {
+func newDHCP(clientTimeout, clientResendMax time.Duration) *DHCP {
 	return &DHCP{
-		leases:        make(map[string]*DHCPLease),
-		clientTimeout: clientTimeout,
+		leases:          make(map[string]*DHCPLease),
+		clientTimeout:   clientTimeout,
+		clientResendMax: clientResendMax,
 	}
 }
 
@@ -67,7 +69,7 @@ func (d *DHCP) Allocate(args *skel.CmdArgs, result *current.Result) error {
 
 	clientID := generateClientID(args.ContainerID, conf.Name, args.IfName)
 	hostNetns := d.hostNetnsPrefix + args.Netns
-	l, err := AcquireLease(clientID, hostNetns, args.IfName, d.clientTimeout, d.broadcast)
+	l, err := AcquireLease(clientID, hostNetns, args.IfName, d.clientTimeout, d.clientResendMax, d.broadcast)
 	if err != nil {
 		return err
 	}
@@ -81,7 +83,6 @@ func (d *DHCP) Allocate(args *skel.CmdArgs, result *current.Result) error {
 	d.setLease(clientID, l)
 
 	result.IPs = []*current.IPConfig{{
-		Version: "4",
 		Address: *ipn,
 		Gateway: l.Gateway(),
 	}}
@@ -162,7 +163,7 @@ func getListener(socketPath string) (net.Listener, error) {
 
 func runDaemon(
 	pidfilePath, hostPrefix, socketPath string,
-	dhcpClientTimeout time.Duration, broadcast bool,
+	dhcpClientTimeout time.Duration, resendMax time.Duration, broadcast bool,
 ) error {
 	// since other goroutines (on separate threads) will change namespaces,
 	// ensure the RPC server does not get scheduled onto those
@@ -183,7 +184,7 @@ func runDaemon(
 		return fmt.Errorf("Error getting listener: %v", err)
 	}
 
-	dhcp := newDHCP(dhcpClientTimeout)
+	dhcp := newDHCP(dhcpClientTimeout, resendMax)
 	dhcp.hostNetnsPrefix = hostPrefix
 	dhcp.broadcast = broadcast
 	rpc.Register(dhcp)

plugins/ipam/dhcp/dhcp2_test.go

@@ -23,7 +23,7 @@ import (
 	"time"
 
 	"github.com/containernetworking/cni/pkg/skel"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/containernetworking/plugins/pkg/testutils"
 

plugins/ipam/dhcp/dhcp_test.go

@@ -15,7 +15,9 @@
 package main
 
 import (
+	"bytes"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"net"
 	"os"
@@ -25,7 +27,7 @@ import (
 	"time"
 
 	"github.com/containernetworking/cni/pkg/skel"
-	"github.com/containernetworking/cni/pkg/types/current"
+	"github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/containernetworking/plugins/pkg/testutils"
 
@@ -208,6 +210,11 @@ var _ = Describe("DHCP Operations", func() {
 		dhcpPluginPath, err := exec.LookPath("dhcp")
 		Expect(err).NotTo(HaveOccurred())
 		clientCmd = exec.Command(dhcpPluginPath, "daemon", "-socketpath", socketPath)
+
+		// copy dhcp client's stdout/stderr to test stdout
+		clientCmd.Stdout = os.Stdout
+		clientCmd.Stderr = os.Stderr
+
 		err = clientCmd.Start()
 		Expect(err).NotTo(HaveOccurred())
 		Expect(clientCmd.Process).NotTo(BeNil())
@@ -226,118 +233,127 @@ var _ = Describe("DHCP Operations", func() {
 		clientCmd.Wait()
 
 		Expect(originalNS.Close()).To(Succeed())
+		Expect(testutils.UnmountNS(originalNS)).To(Succeed())
 		Expect(targetNS.Close()).To(Succeed())
-		defer os.RemoveAll(tmpDir)
+		Expect(testutils.UnmountNS(targetNS)).To(Succeed())
+
+		Expect(os.RemoveAll(tmpDir)).To(Succeed())
 	})
 
-	It("configures and deconfigures a link with ADD/DEL", func() {
-		conf := fmt.Sprintf(`{
-    "cniVersion": "0.3.1",
-    "name": "mynet",
-    "type": "ipvlan",
-    "ipam": {
-        "type": "dhcp",
-	"daemonSocketPath": "%s"
-    }
-}`, socketPath)
+	for _, ver := range testutils.AllSpecVersions {
+		// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+		// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+		ver := ver
 
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      contVethName,
-			StdinData:   []byte(conf),
-		}
+		It(fmt.Sprintf("[%s] configures and deconfigures a link with ADD/DEL", ver), func() {
+			conf := fmt.Sprintf(`{
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "ipvlan",
+			    "ipam": {
+				"type": "dhcp",
+				"daemonSocketPath": "%s"
+			    }
+			}`, ver, socketPath)
 
-		var addResult *current.Result
-		err := originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      contVethName,
+				StdinData:   []byte(conf),
+			}
 
-			r, _, err := testutils.CmdAddWithArgs(args, func() error {
-				return cmdAdd(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-
-			addResult, err = current.GetResult(r)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(len(addResult.IPs)).To(Equal(1))
-			Expect(addResult.IPs[0].Address.String()).To(Equal("192.168.1.5/24"))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		err = originalNS.Do(func(ns.NetNS) error {
-			return testutils.CmdDelWithArgs(args, func() error {
-				return cmdDel(args)
-			})
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("correctly handles multiple DELs for the same container", func() {
-		conf := fmt.Sprintf(`{
-    "cniVersion": "0.3.1",
-    "name": "mynet",
-    "type": "ipvlan",
-    "ipam": {
-        "type": "dhcp",
-	"daemonSocketPath": "%s"
-    }
-}`, socketPath)
-
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      contVethName,
-			StdinData:   []byte(conf),
-		}
-
-		var addResult *current.Result
-		err := originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			r, _, err := testutils.CmdAddWithArgs(args, func() error {
-				return cmdAdd(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-
-			addResult, err = current.GetResult(r)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(len(addResult.IPs)).To(Equal(1))
-			Expect(addResult.IPs[0].Address.String()).To(Equal("192.168.1.5/24"))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		wg := sync.WaitGroup{}
-		wg.Add(3)
-		started := sync.WaitGroup{}
-		started.Add(3)
-		for i := 0; i < 3; i++ {
-			go func() {
+			var addResult *types100.Result
+			err := originalNS.Do(func(ns.NetNS) error {
 				defer GinkgoRecover()
 
-				// Wait until all goroutines are running
-				started.Done()
-				started.Wait()
-
-				err = originalNS.Do(func(ns.NetNS) error {
-					return testutils.CmdDelWithArgs(args, func() error {
-						return cmdDel(args)
-					})
+				r, _, err := testutils.CmdAddWithArgs(args, func() error {
+					return cmdAdd(args)
 				})
 				Expect(err).NotTo(HaveOccurred())
-				wg.Done()
-			}()
-		}
-		wg.Wait()
 
-		err = originalNS.Do(func(ns.NetNS) error {
-			return testutils.CmdDelWithArgs(args, func() error {
-				return cmdDel(args)
+				addResult, err = types100.GetResult(r)
+				Expect(err).NotTo(HaveOccurred())
+				Expect(len(addResult.IPs)).To(Equal(1))
+				Expect(addResult.IPs[0].Address.String()).To(Equal("192.168.1.5/24"))
+				return nil
 			})
+			Expect(err).NotTo(HaveOccurred())
+
+			err = originalNS.Do(func(ns.NetNS) error {
+				return testutils.CmdDelWithArgs(args, func() error {
+					return cmdDel(args)
+				})
+			})
+			Expect(err).NotTo(HaveOccurred())
 		})
-		Expect(err).NotTo(HaveOccurred())
-	})
+
+		It(fmt.Sprintf("[%s] correctly handles multiple DELs for the same container", ver), func() {
+			conf := fmt.Sprintf(`{
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "ipvlan",
+			    "ipam": {
+				"type": "dhcp",
+				"daemonSocketPath": "%s"
+			    }
+			}`, ver, socketPath)
+
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      contVethName,
+				StdinData:   []byte(conf),
+			}
+
+			var addResult *types100.Result
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				r, _, err := testutils.CmdAddWithArgs(args, func() error {
+					return cmdAdd(args)
+				})
+				Expect(err).NotTo(HaveOccurred())
+
+				addResult, err = types100.GetResult(r)
+				Expect(err).NotTo(HaveOccurred())
+				Expect(len(addResult.IPs)).To(Equal(1))
+				Expect(addResult.IPs[0].Address.String()).To(Equal("192.168.1.5/24"))
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+
+			wg := sync.WaitGroup{}
+			wg.Add(3)
+			started := sync.WaitGroup{}
+			started.Add(3)
+			for i := 0; i < 3; i++ {
+				go func() {
+					defer GinkgoRecover()
+
+					// Wait until all goroutines are running
+					started.Done()
+					started.Wait()
+
+					err = originalNS.Do(func(ns.NetNS) error {
+						return testutils.CmdDelWithArgs(args, func() error {
+							return cmdDel(args)
+						})
+					})
+					Expect(err).NotTo(HaveOccurred())
+					wg.Done()
+				}()
+			}
+			wg.Wait()
+
+			err = originalNS.Do(func(ns.NetNS) error {
+				return testutils.CmdDelWithArgs(args, func() error {
+					return cmdDel(args)
+				})
+			})
+			Expect(err).NotTo(HaveOccurred())
+		})
+	}
 })
 
 const (
@@ -508,7 +524,19 @@ var _ = Describe("DHCP Lease Unavailable Operations", func() {
 		// Start the DHCP client daemon
 		dhcpPluginPath, err := exec.LookPath("dhcp")
 		Expect(err).NotTo(HaveOccurred())
-		clientCmd = exec.Command(dhcpPluginPath, "daemon", "-socketpath", socketPath)
+		// Use very short timeouts for lease-unavailable operations because
+		// the same test is run many times, and the delays will exceed the
+		// `go test` timeout with default delays. Since our DHCP server
+		// and client daemon are local processes anyway, we can depend on
+		// them to respond very quickly.
+		clientCmd = exec.Command(dhcpPluginPath, "daemon", "-socketpath", socketPath, "-timeout", "2s", "-resendmax", "8s")
+
+		// copy dhcp client's stdout/stderr to test stdout
+		var b bytes.Buffer
+		mw := io.MultiWriter(os.Stdout, &b)
+		clientCmd.Stdout = mw
+		clientCmd.Stderr = mw
+
 		err = clientCmd.Start()
 		Expect(err).NotTo(HaveOccurred())
 		Expect(clientCmd.Process).NotTo(BeNil())
@@ -527,92 +555,101 @@ var _ = Describe("DHCP Lease Unavailable Operations", func() {
 		clientCmd.Wait()
 
 		Expect(originalNS.Close()).To(Succeed())
+		Expect(testutils.UnmountNS(originalNS)).To(Succeed())
 		Expect(targetNS.Close()).To(Succeed())
-		defer os.RemoveAll(tmpDir)
+		Expect(testutils.UnmountNS(targetNS)).To(Succeed())
+
+		Expect(os.RemoveAll(tmpDir)).To(Succeed())
 	})
 
-	It("Configures multiple links with multiple ADD with second lease unavailable", func() {
-		conf := fmt.Sprintf(`{
-	    "cniVersion": "0.3.1",
-	    "name": "mynet",
-	    "type": "bridge",
-	    "bridge": "%s",
-	    "ipam": {
-	        "type": "dhcp",
-		"daemonSocketPath": "%s"
-	    }
-	}`, hostBridgeName, socketPath)
+	for _, ver := range testutils.AllSpecVersions {
+		// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+		// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+		ver := ver
 
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      contVethName0,
-			StdinData:   []byte(conf),
-		}
+		It(fmt.Sprintf("[%s] configures multiple links with multiple ADD with second lease unavailable", ver), func() {
+			conf := fmt.Sprintf(`{
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "bridge",
+			    "bridge": "%s",
+			    "ipam": {
+				"type": "dhcp",
+				"daemonSocketPath": "%s"
+			    }
+			}`, ver, hostBridgeName, socketPath)
 
-		var addResult *current.Result
-		err := originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      contVethName0,
+				StdinData:   []byte(conf),
+			}
 
-			r, _, err := testutils.CmdAddWithArgs(args, func() error {
-				return cmdAdd(args)
+			var addResult *types100.Result
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				r, _, err := testutils.CmdAddWithArgs(args, func() error {
+					return cmdAdd(args)
+				})
+				Expect(err).NotTo(HaveOccurred())
+
+				addResult, err = types100.GetResult(r)
+				Expect(err).NotTo(HaveOccurred())
+				Expect(len(addResult.IPs)).To(Equal(1))
+				Expect(addResult.IPs[0].Address.String()).To(Equal("192.168.1.5/24"))
+				return nil
 			})
 			Expect(err).NotTo(HaveOccurred())
 
-			addResult, err = current.GetResult(r)
+			args = &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      contVethName1,
+				StdinData:   []byte(conf),
+			}
+
+			err = originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				_, _, err := testutils.CmdAddWithArgs(args, func() error {
+					return cmdAdd(args)
+				})
+				Expect(err).To(HaveOccurred())
+				println(err.Error())
+				Expect(err.Error()).To(Equal("error calling DHCP.Allocate: no more tries"))
+				return nil
+			})
 			Expect(err).NotTo(HaveOccurred())
-			Expect(len(addResult.IPs)).To(Equal(1))
-			Expect(addResult.IPs[0].Address.String()).To(Equal("192.168.1.5/24"))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
 
-		args = &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      contVethName1,
-			StdinData:   []byte(conf),
-		}
+			args = &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      contVethName1,
+				StdinData:   []byte(conf),
+			}
 
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			_, _, err := testutils.CmdAddWithArgs(args, func() error {
-				return cmdAdd(args)
+			err = originalNS.Do(func(ns.NetNS) error {
+				return testutils.CmdDelWithArgs(args, func() error {
+					return cmdDel(args)
+				})
 			})
-			Expect(err).To(HaveOccurred())
-			println(err.Error())
-			Expect(err.Error()).To(Equal("error calling DHCP.Allocate: no more tries"))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
+			Expect(err).NotTo(HaveOccurred())
 
-		args = &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      contVethName1,
-			StdinData:   []byte(conf),
-		}
+			args = &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      contVethName0,
+				StdinData:   []byte(conf),
+			}
 
-		err = originalNS.Do(func(ns.NetNS) error {
-			return testutils.CmdDelWithArgs(args, func() error {
-				return cmdDel(args)
+			err = originalNS.Do(func(ns.NetNS) error {
+				return testutils.CmdDelWithArgs(args, func() error {
+					return cmdDel(args)
+				})
 			})
+			Expect(err).NotTo(HaveOccurred())
 		})
-		Expect(err).NotTo(HaveOccurred())
-
-		args = &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      contVethName0,
-			StdinData:   []byte(conf),
-		}
-
-		err = originalNS.Do(func(ns.NetNS) error {
-			return testutils.CmdDelWithArgs(args, func() error {
-				return cmdDel(args)
-			})
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
+	}
 })

plugins/ipam/dhcp/lease.go

@@ -57,6 +57,7 @@ type DHCPLease struct {
 	rebindingTime time.Time
 	expireTime    time.Time
 	timeout       time.Duration
+	resendMax     time.Duration
 	broadcast     bool
 	stopping      uint32
 	stop          chan struct{}
@@ -68,13 +69,14 @@ type DHCPLease struct {
 // calling DHCPLease.Stop()
 func AcquireLease(
 	clientID, netns, ifName string,
-	timeout time.Duration, broadcast bool,
+	timeout, resendMax time.Duration, broadcast bool,
 ) (*DHCPLease, error) {
 	errCh := make(chan error, 1)
 	l := &DHCPLease{
 		clientID:  clientID,
 		stop:      make(chan struct{}),
 		timeout:   timeout,
+		resendMax: resendMax,
 		broadcast: broadcast,
 	}
 
@@ -139,7 +141,7 @@ func (l *DHCPLease) acquire() error {
 	opts[dhcp4.OptionClientIdentifier] = []byte(l.clientID)
 	opts[dhcp4.OptionParameterRequestList] = []byte{byte(dhcp4.OptionRouter), byte(dhcp4.OptionSubnetMask)}
 
-	pkt, err := backoffRetry(func() (*dhcp4.Packet, error) {
+	pkt, err := backoffRetry(l.resendMax, func() (*dhcp4.Packet, error) {
 		ok, ack, err := DhcpRequest(c, opts)
 		switch {
 		case err != nil:
@@ -258,7 +260,7 @@ func (l *DHCPLease) renew() error {
 	opts := make(dhcp4.Options)
 	opts[dhcp4.OptionClientIdentifier] = []byte(l.clientID)
 
-	pkt, err := backoffRetry(func() (*dhcp4.Packet, error) {
+	pkt, err := backoffRetry(l.resendMax, func() (*dhcp4.Packet, error) {
 		ok, ack, err := DhcpRenew(c, *l.ack, opts)
 		switch {
 		case err != nil:
@@ -340,7 +342,7 @@ func jitter(span time.Duration) time.Duration {
 	return time.Duration(float64(span) * (2.0*rand.Float64() - 1.0))
 }
 
-func backoffRetry(f func() (*dhcp4.Packet, error)) (*dhcp4.Packet, error) {
+func backoffRetry(resendMax time.Duration, f func() (*dhcp4.Packet, error)) (*dhcp4.Packet, error) {
 	var baseDelay time.Duration = resendDelay0
 	var sleepTime time.Duration
 
@@ -358,7 +360,7 @@ func backoffRetry(f func() (*dhcp4.Packet, error)) (*dhcp4.Packet, error) {
 
 		time.Sleep(sleepTime)
 
-		if baseDelay < resendDelayMax {
+		if baseDelay < resendMax {
 			baseDelay *= 2
 		} else {
 			break

plugins/ipam/dhcp/main.go

@@ -26,7 +26,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 	bv "github.com/containernetworking/plugins/pkg/utils/buildversion"
 )
@@ -40,19 +40,21 @@ func main() {
 		var socketPath string
 		var broadcast bool
 		var timeout time.Duration
+		var resendMax time.Duration
 		daemonFlags := flag.NewFlagSet("daemon", flag.ExitOnError)
 		daemonFlags.StringVar(&pidfilePath, "pidfile", "", "optional path to write daemon PID to")
 		daemonFlags.StringVar(&hostPrefix, "hostprefix", "", "optional prefix to host root")
 		daemonFlags.StringVar(&socketPath, "socketpath", "", "optional dhcp server socketpath")
 		daemonFlags.BoolVar(&broadcast, "broadcast", false, "broadcast DHCP leases")
 		daemonFlags.DurationVar(&timeout, "timeout", 10*time.Second, "optional dhcp client timeout duration")
+		daemonFlags.DurationVar(&resendMax, "resendmax", resendDelayMax, "optional dhcp client resend max duration")
 		daemonFlags.Parse(os.Args[2:])
 
 		if socketPath == "" {
 			socketPath = defaultSocketPath
 		}
 
-		if err := runDaemon(pidfilePath, hostPrefix, socketPath, timeout, broadcast); err != nil {
+		if err := runDaemon(pidfilePath, hostPrefix, socketPath, timeout, resendMax, broadcast); err != nil {
 			log.Printf(err.Error())
 			os.Exit(1)
 		}
@@ -69,7 +71,7 @@ func cmdAdd(args *skel.CmdArgs) error {
 		return err
 	}
 
-	result := &current.Result{}
+	result := &current.Result{CNIVersion: current.ImplementedSpecVersion}
 	if err := rpcCall("DHCP.Allocate", args, result); err != nil {
 		return err
 	}
@@ -96,7 +98,7 @@ func cmdCheck(args *skel.CmdArgs) error {
 		return err
 	}
 
-	result := &current.Result{}
+	result := &current.Result{CNIVersion: current.ImplementedSpecVersion}
 	if err := rpcCall("DHCP.Allocate", args, result); err != nil {
 		return err
 	}

plugins/ipam/host-local/backend/allocator/allocator.go

@@ -21,7 +21,7 @@ import (
 	"os"
 	"strconv"
 
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/ip"
 	"github.com/containernetworking/plugins/plugins/ipam/host-local/backend"
 )
@@ -108,13 +108,8 @@ func (a *IPAllocator) Get(id string, ifname string, requestedIP net.IP) (*curren
 	if reservedIP == nil {
 		return nil, fmt.Errorf("no IP addresses available in range set: %s", a.rangeset.String())
 	}
-	version := "4"
-	if reservedIP.IP.To4() == nil {
-		version = "6"
-	}
 
 	return &current.IPConfig{
-		Version: version,
 		Address: *reservedIP,
 		Gateway: gw,
 	}, nil

plugins/ipam/host-local/backend/allocator/allocator_test.go

@@ -19,7 +19,7 @@ import (
 	"net"
 
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	fakestore "github.com/containernetworking/plugins/plugins/ipam/host-local/backend/testing"
 
 	. "github.com/onsi/ginkgo"

plugins/ipam/host-local/backend/allocator/config.go

@@ -20,7 +20,7 @@ import (
 	"net"
 
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/020"
+	"github.com/containernetworking/cni/pkg/version"
 )
 
 // The top-level network config - IPAM plugins are passed the full configuration
@@ -136,10 +136,8 @@ func LoadIPAMConfig(bytes []byte, envArgs string) (*IPAMConfig, string, error) {
 
 	// CNI spec 0.2.0 and below supported only one v4 and v6 address
 	if numV4 > 1 || numV6 > 1 {
-		for _, v := range types020.SupportedVersions {
-			if n.CNIVersion == v {
-				return nil, "", fmt.Errorf("CNI version %v does not support more than 1 address per family", n.CNIVersion)
-			}
+		if ok, _ := version.GreaterThanOrEqualTo(n.CNIVersion, "0.3.0"); !ok {
+			return nil, "", fmt.Errorf("CNI version %v does not support more than 1 address per family", n.CNIVersion)
 		}
 	}
 

plugins/ipam/host-local/main.go

@@ -25,7 +25,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 )
 
@@ -62,7 +62,7 @@ func cmdAdd(args *skel.CmdArgs) error {
 		return err
 	}
 
-	result := &current.Result{}
+	result := &current.Result{CNIVersion: current.ImplementedSpecVersion}
 
 	if ipamConf.ResolvConf != "" {
 		dns, err := parseResolvConf(ipamConf.ResolvConf)

plugins/ipam/static/main.go

@@ -22,8 +22,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	types020 "github.com/containernetworking/cni/pkg/types/020"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 	bv "github.com/containernetworking/plugins/pkg/utils/buildversion"
 )
@@ -225,20 +224,16 @@ func LoadIPAMConfig(bytes []byte, envArgs string) (*IPAMConfig, string, error) {
 		}
 
 		if n.IPAM.Addresses[i].Address.IP.To4() != nil {
-			n.IPAM.Addresses[i].Version = "4"
 			numV4++
 		} else {
-			n.IPAM.Addresses[i].Version = "6"
 			numV6++
 		}
 	}
 
 	// CNI spec 0.2.0 and below supported only one v4 and v6 address
 	if numV4 > 1 || numV6 > 1 {
-		for _, v := range types020.SupportedVersions {
-			if n.CNIVersion == v {
-				return nil, "", fmt.Errorf("CNI version %v does not support more than 1 address per family", n.CNIVersion)
-			}
+		if ok, _ := version.GreaterThanOrEqualTo(n.CNIVersion, "0.3.0"); !ok {
+			return nil, "", fmt.Errorf("CNI version %v does not support more than 1 address per family", n.CNIVersion)
 		}
 	}
 
@@ -254,14 +249,16 @@ func cmdAdd(args *skel.CmdArgs) error {
 		return err
 	}
 
-	result := &current.Result{}
-	result.DNS = ipamConf.DNS
-	result.Routes = ipamConf.Routes
+	result := &current.Result{
+		CNIVersion: current.ImplementedSpecVersion,
+		DNS:        ipamConf.DNS,
+		Routes:     ipamConf.Routes,
+	}
 	for _, v := range ipamConf.Addresses {
 		result.IPs = append(result.IPs, &current.IPConfig{
-			Version: v.Version,
 			Address: v.Address,
-			Gateway: v.Gateway})
+			Gateway: v.Gateway,
+		})
 	}
 
 	return types.PrintResult(result, confVersion)

plugins/ipam/static/static_test.go

@@ -15,12 +15,13 @@
 package main
 
 import (
+	"fmt"
 	"net"
 	"strings"
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	"github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/testutils"
 
 	. "github.com/onsi/ginkgo"
@@ -28,18 +29,101 @@ import (
 )
 
 var _ = Describe("static Operations", func() {
-	It("allocates and releases addresses with ADD/DEL", func() {
-		const ifname string = "eth0"
-		const nspath string = "/some/where"
+	for _, ver := range testutils.AllSpecVersions {
+		// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+		// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+		ver := ver
 
-		conf := `{
-			"cniVersion": "0.3.1",
-			"name": "mynet",
-			"type": "ipvlan",
-			"master": "foo0",
-			"ipam": {
-				"type": "static",
-				"addresses": [ {
+		It(fmt.Sprintf("[%s] allocates and releases addresses with ADD/DEL", ver), func() {
+			const ifname string = "eth0"
+			const nspath string = "/some/where"
+
+			conf := fmt.Sprintf(`{
+				"cniVersion": "%s",
+				"name": "mynet",
+				"type": "ipvlan",
+				"master": "foo0",
+				"ipam": {
+					"type": "static",
+					"addresses": [ {
+							"address": "10.10.0.1/24",
+							"gateway": "10.10.0.254"
+						},
+						{
+							"address": "3ffe:ffff:0:01ff::1/64",
+							"gateway": "3ffe:ffff:0::1"
+						}],
+					"routes": [
+						{ "dst": "0.0.0.0/0" },
+						{ "dst": "192.168.0.0/16", "gw": "10.10.5.1" },
+						{ "dst": "3ffe:ffff:0:01ff::1/64" }],
+					"dns": {
+						"nameservers" : ["8.8.8.8"],
+						"domain": "example.com",
+						"search": [ "example.com" ]
+					}
+				}
+			}`, ver)
+
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       nspath,
+				IfName:      ifname,
+				StdinData:   []byte(conf),
+			}
+
+			// Allocate the IP
+			r, raw, err := testutils.CmdAddWithArgs(args, func() error {
+				return cmdAdd(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+			if testutils.SpecVersionHasIPVersion(ver) {
+				Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
+			}
+
+			result, err := types100.GetResult(r)
+			Expect(err).NotTo(HaveOccurred())
+
+			// Gomega is cranky about slices with different caps
+			Expect(*result.IPs[0]).To(Equal(
+				types100.IPConfig{
+					Address: mustCIDR("10.10.0.1/24"),
+					Gateway: net.ParseIP("10.10.0.254"),
+				}))
+
+			Expect(*result.IPs[1]).To(Equal(
+				types100.IPConfig{
+					Address: mustCIDR("3ffe:ffff:0:01ff::1/64"),
+					Gateway: net.ParseIP("3ffe:ffff:0::1"),
+				},
+			))
+			Expect(len(result.IPs)).To(Equal(2))
+
+			Expect(result.Routes).To(Equal([]*types.Route{
+				{Dst: mustCIDR("0.0.0.0/0")},
+				{Dst: mustCIDR("192.168.0.0/16"), GW: net.ParseIP("10.10.5.1")},
+				{Dst: mustCIDR("3ffe:ffff:0:01ff::1/64")},
+			}))
+
+			// Release the IP
+			err = testutils.CmdDelWithArgs(args, func() error {
+				return cmdDel(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		It(fmt.Sprintf("[%s] doesn't error when passed an unknown ID on DEL", ver), func() {
+			const ifname string = "eth0"
+			const nspath string = "/some/where"
+
+			conf := fmt.Sprintf(`{
+				"cniVersion": "%s",
+				"name": "mynet",
+				"type": "ipvlan",
+				"master": "foo0",
+				"ipam": {
+					"type": "static",
+					"addresses": [ {
 						"address": "10.10.0.1/24",
 						"gateway": "10.10.0.254"
 					},
@@ -47,439 +131,370 @@ var _ = Describe("static Operations", func() {
 						"address": "3ffe:ffff:0:01ff::1/64",
 						"gateway": "3ffe:ffff:0::1"
 					}],
-				"routes": [
+					"routes": [
 					{ "dst": "0.0.0.0/0" },
 					{ "dst": "192.168.0.0/16", "gw": "10.10.5.1" },
 					{ "dst": "3ffe:ffff:0:01ff::1/64" }],
-				"dns": {
-					"nameservers" : ["8.8.8.8"],
-					"domain": "example.com",
-					"search": [ "example.com" ]
+					"dns": {
+						"nameservers" : ["8.8.8.8"],
+						"domain": "example.com",
+						"search": [ "example.com" ]
+					}
 				}
+			}`, ver)
+
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       nspath,
+				IfName:      ifname,
+				StdinData:   []byte(conf),
 			}
-		}`
 
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       nspath,
-			IfName:      ifname,
-			StdinData:   []byte(conf),
-		}
-
-		// Allocate the IP
-		r, raw, err := testutils.CmdAddWithArgs(args, func() error {
-			return cmdAdd(args)
+			// Release the IP
+			err := testutils.CmdDelWithArgs(args, func() error {
+				return cmdDel(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
 		})
-		Expect(err).NotTo(HaveOccurred())
-		Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
 
-		result, err := current.GetResult(r)
-		Expect(err).NotTo(HaveOccurred())
+		It(fmt.Sprintf("[%s] allocates and releases addresses with ADD/DEL, with ENV variables", ver), func() {
+			const ifname string = "eth0"
+			const nspath string = "/some/where"
 
-		// Gomega is cranky about slices with different caps
-		Expect(*result.IPs[0]).To(Equal(
-			current.IPConfig{
-				Version: "4",
-				Address: mustCIDR("10.10.0.1/24"),
-				Gateway: net.ParseIP("10.10.0.254"),
+			conf := fmt.Sprintf(`{
+				"cniVersion": "%s",
+				"name": "mynet",
+				"type": "ipvlan",
+				"master": "foo0",
+				"ipam": {
+					"type": "static",
+					"routes": [
+						{ "dst": "0.0.0.0/0" },
+						{ "dst": "192.168.0.0/16", "gw": "10.10.5.1" }],
+					"dns": {
+						"nameservers" : ["8.8.8.8"],
+						"domain": "example.com",
+						"search": [ "example.com" ]
+					}
+				}
+			}`, ver)
+
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       nspath,
+				IfName:      ifname,
+				StdinData:   []byte(conf),
+				Args:        "IP=10.10.0.1/24;GATEWAY=10.10.0.254",
+			}
+
+			// Allocate the IP
+			r, raw, err := testutils.CmdAddWithArgs(args, func() error {
+				return cmdAdd(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+			if testutils.SpecVersionHasIPVersion(ver) {
+				Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
+			}
+
+			result, err := types100.GetResult(r)
+			Expect(err).NotTo(HaveOccurred())
+
+			// Gomega is cranky about slices with different caps
+			Expect(*result.IPs[0]).To(Equal(
+				types100.IPConfig{
+					Address: mustCIDR("10.10.0.1/24"),
+					Gateway: net.ParseIP("10.10.0.254"),
+				}))
+
+			Expect(len(result.IPs)).To(Equal(1))
+
+			Expect(result.Routes).To(Equal([]*types.Route{
+				{Dst: mustCIDR("0.0.0.0/0")},
+				{Dst: mustCIDR("192.168.0.0/16"), GW: net.ParseIP("10.10.5.1")},
 			}))
 
-		Expect(*result.IPs[1]).To(Equal(
-			current.IPConfig{
-				Version: "6",
-				Address: mustCIDR("3ffe:ffff:0:01ff::1/64"),
-				Gateway: net.ParseIP("3ffe:ffff:0::1"),
-			},
-		))
-		Expect(len(result.IPs)).To(Equal(2))
-
-		Expect(result.Routes).To(Equal([]*types.Route{
-			{Dst: mustCIDR("0.0.0.0/0")},
-			{Dst: mustCIDR("192.168.0.0/16"), GW: net.ParseIP("10.10.5.1")},
-			{Dst: mustCIDR("3ffe:ffff:0:01ff::1/64")},
-		}))
-
-		// Release the IP
-		err = testutils.CmdDelWithArgs(args, func() error {
-			return cmdDel(args)
+			// Release the IP
+			err = testutils.CmdDelWithArgs(args, func() error {
+				return cmdDel(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
 		})
-		Expect(err).NotTo(HaveOccurred())
-	})
 
-	It("doesn't error when passed an unknown ID on DEL", func() {
-		const ifname string = "eth0"
-		const nspath string = "/some/where"
+		It(fmt.Sprintf("[%s] allocates and releases multiple addresses with ADD/DEL, with ENV variables", ver), func() {
+			const ifname string = "eth0"
+			const nspath string = "/some/where"
 
-		conf := `{
-			"cniVersion": "0.3.0",
-			"name": "mynet",
-			"type": "ipvlan",
-			"master": "foo0",
-			"ipam": {
-				"type": "static",
-				"addresses": [ {
-					"address": "10.10.0.1/24",
-					"gateway": "10.10.0.254"
+			conf := fmt.Sprintf(`{
+				"cniVersion": "%s",
+				"name": "mynet",
+				"type": "ipvlan",
+				"master": "foo0",
+				"ipam": {
+					"type": "static"
+				}
+			}`, ver)
+
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       nspath,
+				IfName:      ifname,
+				StdinData:   []byte(conf),
+				Args:        "IP=10.10.0.1/24,11.11.0.1/24;GATEWAY=10.10.0.254",
+			}
+
+			// Allocate the IP
+			r, raw, err := testutils.CmdAddWithArgs(args, func() error {
+				return cmdAdd(args)
+			})
+			if !testutils.SpecVersionHasMultipleIPs(ver) {
+				errStr := fmt.Sprintf("CNI version %s does not support more than 1 address per family", ver)
+				Expect(err).To(MatchError(errStr))
+				return
+			}
+
+			Expect(err).NotTo(HaveOccurred())
+			if testutils.SpecVersionHasIPVersion(ver) {
+				Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
+			}
+
+			result, err := types100.GetResult(r)
+			Expect(err).NotTo(HaveOccurred())
+
+			// Gomega is cranky about slices with different caps
+			Expect(*result.IPs[0]).To(Equal(
+				types100.IPConfig{
+					Address: mustCIDR("10.10.0.1/24"),
+					Gateway: net.ParseIP("10.10.0.254"),
+				}))
+			Expect(*result.IPs[1]).To(Equal(
+				types100.IPConfig{
+					Address: mustCIDR("11.11.0.1/24"),
+					Gateway: nil,
+				}))
+
+			Expect(len(result.IPs)).To(Equal(2))
+
+			// Release the IP
+			err = testutils.CmdDelWithArgs(args, func() error {
+				return cmdDel(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		It(fmt.Sprintf("[%s] allocates and releases multiple addresses with ADD/DEL, from RuntimeConfig", ver), func() {
+			const ifname string = "eth0"
+			const nspath string = "/some/where"
+
+			conf := fmt.Sprintf(`{
+				"cniVersion": "%s",
+				"name": "mynet",
+				"type": "ipvlan",
+				"master": "foo0",
+				"capabilities": {"ips": true},
+				"ipam": {
+					"type": "static",
+					"routes": [
+					{ "dst": "0.0.0.0/0", "gw": "10.10.0.254" },
+					{ "dst": "3ffe:ffff:0:01ff::1/64",
+		                          "gw": "3ffe:ffff:0::1" } ],
+					  "dns": {
+						"nameservers" : ["8.8.8.8"],
+						"domain": "example.com",
+						"search": [ "example.com" ]
+					}
 				},
-				{
-					"address": "3ffe:ffff:0:01ff::1/64",
-					"gateway": "3ffe:ffff:0::1"
-				}],
-				"routes": [
-				{ "dst": "0.0.0.0/0" },
-				{ "dst": "192.168.0.0/16", "gw": "10.10.5.1" },
-				{ "dst": "3ffe:ffff:0:01ff::1/64" }],
-				"dns": {
-					"nameservers" : ["8.8.8.8"],
-					"domain": "example.com",
-					"search": [ "example.com" ]
-				}}}`
-
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       nspath,
-			IfName:      ifname,
-			StdinData:   []byte(conf),
-		}
-
-		// Release the IP
-		err := testutils.CmdDelWithArgs(args, func() error {
-			return cmdDel(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("allocates and releases addresses with ADD/DEL, with ENV variables", func() {
-		const ifname string = "eth0"
-		const nspath string = "/some/where"
-
-		conf := `{
-			"cniVersion": "0.3.1",
-			"name": "mynet",
-			"type": "ipvlan",
-			"master": "foo0",
-			"ipam": {
-				"type": "static",
-				"routes": [
-					{ "dst": "0.0.0.0/0" },
-					{ "dst": "192.168.0.0/16", "gw": "10.10.5.1" }],
-				"dns": {
-					"nameservers" : ["8.8.8.8"],
-					"domain": "example.com",
-					"search": [ "example.com" ]
-				}
-			}
-		}`
-
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       nspath,
-			IfName:      ifname,
-			StdinData:   []byte(conf),
-			Args:        "IP=10.10.0.1/24;GATEWAY=10.10.0.254",
-		}
-
-		// Allocate the IP
-		r, raw, err := testutils.CmdAddWithArgs(args, func() error {
-			return cmdAdd(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-		Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
-
-		result, err := current.GetResult(r)
-		Expect(err).NotTo(HaveOccurred())
-
-		// Gomega is cranky about slices with different caps
-		Expect(*result.IPs[0]).To(Equal(
-			current.IPConfig{
-				Version: "4",
-				Address: mustCIDR("10.10.0.1/24"),
-				Gateway: net.ParseIP("10.10.0.254"),
-			}))
-
-		Expect(len(result.IPs)).To(Equal(1))
-
-		Expect(result.Routes).To(Equal([]*types.Route{
-			{Dst: mustCIDR("0.0.0.0/0")},
-			{Dst: mustCIDR("192.168.0.0/16"), GW: net.ParseIP("10.10.5.1")},
-		}))
-
-		// Release the IP
-		err = testutils.CmdDelWithArgs(args, func() error {
-			return cmdDel(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("allocates and releases multiple addresses with ADD/DEL, with ENV variables", func() {
-		const ifname string = "eth0"
-		const nspath string = "/some/where"
-
-		conf := `{
-			"cniVersion": "0.3.1",
-			"name": "mynet",
-			"type": "ipvlan",
-			"master": "foo0",
-			"ipam": {
-				"type": "static"
-			}
-		}`
-
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       nspath,
-			IfName:      ifname,
-			StdinData:   []byte(conf),
-			Args:        "IP=10.10.0.1/24,11.11.0.1/24;GATEWAY=10.10.0.254",
-		}
-
-		// Allocate the IP
-		r, raw, err := testutils.CmdAddWithArgs(args, func() error {
-			return cmdAdd(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-		Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
-
-		result, err := current.GetResult(r)
-		Expect(err).NotTo(HaveOccurred())
-
-		// Gomega is cranky about slices with different caps
-		Expect(*result.IPs[0]).To(Equal(
-			current.IPConfig{
-				Version: "4",
-				Address: mustCIDR("10.10.0.1/24"),
-				Gateway: net.ParseIP("10.10.0.254"),
-			}))
-		Expect(*result.IPs[1]).To(Equal(
-			current.IPConfig{
-				Version: "4",
-				Address: mustCIDR("11.11.0.1/24"),
-				Gateway: nil,
-			}))
-
-		Expect(len(result.IPs)).To(Equal(2))
-
-		// Release the IP
-		err = testutils.CmdDelWithArgs(args, func() error {
-			return cmdDel(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("allocates and releases multiple addresses with ADD/DEL, from RuntimeConfig", func() {
-		const ifname string = "eth0"
-		const nspath string = "/some/where"
-
-		conf := `{
-			"cniVersion": "0.3.1",
-			"name": "mynet",
-			"type": "ipvlan",
-			"master": "foo0",
-			"capabilities": {"ips": true},
-			"ipam": {
-				"type": "static",
-				"routes": [
-				{ "dst": "0.0.0.0/0", "gw": "10.10.0.254" },
-				{ "dst": "3ffe:ffff:0:01ff::1/64",
-                                  "gw": "3ffe:ffff:0::1" } ],
-				  "dns": {
-					"nameservers" : ["8.8.8.8"],
-					"domain": "example.com",
-					"search": [ "example.com" ]
-			        }
-			},
-			"RuntimeConfig": {
-				"ips" : ["10.10.0.1/24", "3ffe:ffff:0:01ff::1/64"]
-			}
-		}`
-
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       nspath,
-			IfName:      ifname,
-			StdinData:   []byte(conf),
-		}
-
-		// Allocate the IP
-		r, raw, err := testutils.CmdAddWithArgs(args, func() error {
-			return cmdAdd(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-		Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
-
-		result, err := current.GetResult(r)
-		Expect(err).NotTo(HaveOccurred())
-
-		// Gomega is cranky about slices with different caps
-		Expect(*result.IPs[0]).To(Equal(
-			current.IPConfig{
-				Version: "4",
-				Address: mustCIDR("10.10.0.1/24"),
-			}))
-		Expect(*result.IPs[1]).To(Equal(
-			current.IPConfig{
-				Version: "6",
-				Address: mustCIDR("3ffe:ffff:0:01ff::1/64"),
-			},
-		))
-		Expect(len(result.IPs)).To(Equal(2))
-		Expect(result.Routes).To(Equal([]*types.Route{
-			{Dst: mustCIDR("0.0.0.0/0"), GW: net.ParseIP("10.10.0.254")},
-			{Dst: mustCIDR("3ffe:ffff:0:01ff::1/64"), GW: net.ParseIP("3ffe:ffff:0::1")},
-		}))
-
-		// Release the IP
-		err = testutils.CmdDelWithArgs(args, func() error {
-			return cmdDel(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("allocates and releases multiple addresses with ADD/DEL, from args", func() {
-		const ifname string = "eth0"
-		const nspath string = "/some/where"
-
-		conf := `{
-			"cniVersion": "0.3.1",
-			"name": "mynet",
-			"type": "ipvlan",
-			"master": "foo0",
-			"ipam": {
-				"type": "static",
-				"routes": [
-				{ "dst": "0.0.0.0/0", "gw": "10.10.0.254" },
-				{ "dst": "3ffe:ffff:0:01ff::1/64",
-                                  "gw": "3ffe:ffff:0::1" } ],
-				  "dns": {
-					"nameservers" : ["8.8.8.8"],
-					"domain": "example.com",
-					"search": [ "example.com" ]
-			        }
-			},
-			"args": {
-				"cni": {
+				"RuntimeConfig": {
 					"ips" : ["10.10.0.1/24", "3ffe:ffff:0:01ff::1/64"]
-			        }
+				}
+			}`, ver)
+
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       nspath,
+				IfName:      ifname,
+				StdinData:   []byte(conf),
 			}
-		}`
 
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       nspath,
-			IfName:      ifname,
-			StdinData:   []byte(conf),
-		}
-
-		// Allocate the IP
-		r, raw, err := testutils.CmdAddWithArgs(args, func() error {
-			return cmdAdd(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-		Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
-
-		result, err := current.GetResult(r)
-		Expect(err).NotTo(HaveOccurred())
-
-		// Gomega is cranky about slices with different caps
-		Expect(*result.IPs[0]).To(Equal(
-			current.IPConfig{
-				Version: "4",
-				Address: mustCIDR("10.10.0.1/24"),
-			}))
-		Expect(*result.IPs[1]).To(Equal(
-			current.IPConfig{
-				Version: "6",
-				Address: mustCIDR("3ffe:ffff:0:01ff::1/64"),
-			},
-		))
-		Expect(len(result.IPs)).To(Equal(2))
-		Expect(result.Routes).To(Equal([]*types.Route{
-			{Dst: mustCIDR("0.0.0.0/0"), GW: net.ParseIP("10.10.0.254")},
-			{Dst: mustCIDR("3ffe:ffff:0:01ff::1/64"), GW: net.ParseIP("3ffe:ffff:0::1")},
-		}))
-
-		// Release the IP
-		err = testutils.CmdDelWithArgs(args, func() error {
-			return cmdDel(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("allocates and releases multiple addresses with ADD/DEL, from RuntimeConfig/ARGS/CNI_ARGS", func() {
-		const ifname string = "eth0"
-		const nspath string = "/some/where"
-
-		conf := `{
-			"cniVersion": "0.3.1",
-			"name": "mynet",
-			"type": "ipvlan",
-			"master": "foo0",
-			"capabilities": {"ips": true},
-			"ipam": {
-				"type": "static",
-				"routes": [
-				{ "dst": "0.0.0.0/0", "gw": "10.10.0.254" },
-				{ "dst": "3ffe:ffff:0:01ff::1/64",
-                                  "gw": "3ffe:ffff:0::1" } ],
-				  "dns": {
-					"nameservers" : ["8.8.8.8"],
-					"domain": "example.com",
-					"search": [ "example.com" ]
-			        }
-			},
-			"RuntimeConfig": {
-				"ips" : ["10.10.0.1/24", "3ffe:ffff:0:01ff::1/64"]
-			},
-			"args": {
-				"cni": {
-					"ips" : ["10.10.0.2/24", "3ffe:ffff:0:01ff::2/64"]
-			        }
+			// Allocate the IP
+			r, raw, err := testutils.CmdAddWithArgs(args, func() error {
+				return cmdAdd(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+			if testutils.SpecVersionHasIPVersion(ver) {
+				Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
 			}
-		}`
 
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       nspath,
-			IfName:      ifname,
-			StdinData:   []byte(conf),
-			Args:        "IP=10.10.0.3/24,11.11.0.3/24;GATEWAY=10.10.0.254",
-		}
+			result, err := types100.GetResult(r)
+			Expect(err).NotTo(HaveOccurred())
 
-		// Allocate the IP
-		r, raw, err := testutils.CmdAddWithArgs(args, func() error {
-			return cmdAdd(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-		Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
-
-		result, err := current.GetResult(r)
-		Expect(err).NotTo(HaveOccurred())
-
-		// only addresses in runtimeConfig configured because of its priorities
-		Expect(*result.IPs[0]).To(Equal(
-			current.IPConfig{
-				Version: "4",
-				Address: mustCIDR("10.10.0.1/24"),
+			// Gomega is cranky about slices with different caps
+			Expect(*result.IPs[0]).To(Equal(
+				types100.IPConfig{
+					Address: mustCIDR("10.10.0.1/24"),
+				}))
+			Expect(*result.IPs[1]).To(Equal(
+				types100.IPConfig{
+					Address: mustCIDR("3ffe:ffff:0:01ff::1/64"),
+				},
+			))
+			Expect(len(result.IPs)).To(Equal(2))
+			Expect(result.Routes).To(Equal([]*types.Route{
+				{Dst: mustCIDR("0.0.0.0/0"), GW: net.ParseIP("10.10.0.254")},
+				{Dst: mustCIDR("3ffe:ffff:0:01ff::1/64"), GW: net.ParseIP("3ffe:ffff:0::1")},
 			}))
-		Expect(*result.IPs[1]).To(Equal(
-			current.IPConfig{
-				Version: "6",
-				Address: mustCIDR("3ffe:ffff:0:01ff::1/64"),
-			},
-		))
-		Expect(len(result.IPs)).To(Equal(2))
-		Expect(result.Routes).To(Equal([]*types.Route{
-			{Dst: mustCIDR("0.0.0.0/0"), GW: net.ParseIP("10.10.0.254")},
-			{Dst: mustCIDR("3ffe:ffff:0:01ff::1/64"), GW: net.ParseIP("3ffe:ffff:0::1")},
-		}))
 
-		// Release the IP
-		err = testutils.CmdDelWithArgs(args, func() error {
-			return cmdDel(args)
+			// Release the IP
+			err = testutils.CmdDelWithArgs(args, func() error {
+				return cmdDel(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
 		})
-		Expect(err).NotTo(HaveOccurred())
-	})
 
+		It(fmt.Sprintf("[%s] allocates and releases multiple addresses with ADD/DEL, from args", ver), func() {
+			const ifname string = "eth0"
+			const nspath string = "/some/where"
+
+			conf := fmt.Sprintf(`{
+				"cniVersion": "%s",
+				"name": "mynet",
+				"type": "ipvlan",
+				"master": "foo0",
+				"ipam": {
+					"type": "static",
+					"routes": [
+					{ "dst": "0.0.0.0/0", "gw": "10.10.0.254" },
+					{ "dst": "3ffe:ffff:0:01ff::1/64",
+		                          "gw": "3ffe:ffff:0::1" } ],
+					  "dns": {
+						"nameservers" : ["8.8.8.8"],
+						"domain": "example.com",
+						"search": [ "example.com" ]
+					}
+				},
+				"args": {
+					"cni": {
+						"ips" : ["10.10.0.1/24", "3ffe:ffff:0:01ff::1/64"]
+					}
+				}
+			}`, ver)
+
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       nspath,
+				IfName:      ifname,
+				StdinData:   []byte(conf),
+			}
+
+			// Allocate the IP
+			r, raw, err := testutils.CmdAddWithArgs(args, func() error {
+				return cmdAdd(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+			if testutils.SpecVersionHasIPVersion(ver) {
+				Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
+			}
+
+			result, err := types100.GetResult(r)
+			Expect(err).NotTo(HaveOccurred())
+
+			// Gomega is cranky about slices with different caps
+			Expect(*result.IPs[0]).To(Equal(
+				types100.IPConfig{
+					Address: mustCIDR("10.10.0.1/24"),
+				}))
+			Expect(*result.IPs[1]).To(Equal(
+				types100.IPConfig{
+					Address: mustCIDR("3ffe:ffff:0:01ff::1/64"),
+				},
+			))
+			Expect(len(result.IPs)).To(Equal(2))
+			Expect(result.Routes).To(Equal([]*types.Route{
+				{Dst: mustCIDR("0.0.0.0/0"), GW: net.ParseIP("10.10.0.254")},
+				{Dst: mustCIDR("3ffe:ffff:0:01ff::1/64"), GW: net.ParseIP("3ffe:ffff:0::1")},
+			}))
+
+			// Release the IP
+			err = testutils.CmdDelWithArgs(args, func() error {
+				return cmdDel(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		It(fmt.Sprintf("[%s] allocates and releases multiple addresses with ADD/DEL, from RuntimeConfig/ARGS/CNI_ARGS", ver), func() {
+			const ifname string = "eth0"
+			const nspath string = "/some/where"
+
+			conf := fmt.Sprintf(`{
+				"cniVersion": "%s",
+				"name": "mynet",
+				"type": "ipvlan",
+				"master": "foo0",
+				"capabilities": {"ips": true},
+				"ipam": {
+					"type": "static",
+					"routes": [
+					{ "dst": "0.0.0.0/0", "gw": "10.10.0.254" },
+					{ "dst": "3ffe:ffff:0:01ff::1/64",
+		                          "gw": "3ffe:ffff:0::1" } ],
+					  "dns": {
+						"nameservers" : ["8.8.8.8"],
+						"domain": "example.com",
+						"search": [ "example.com" ]
+					}
+				},
+				"RuntimeConfig": {
+					"ips" : ["10.10.0.1/24", "3ffe:ffff:0:01ff::1/64"]
+				},
+				"args": {
+					"cni": {
+						"ips" : ["10.10.0.2/24", "3ffe:ffff:0:01ff::2/64"]
+					}
+				}
+			}`, ver)
+
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       nspath,
+				IfName:      ifname,
+				StdinData:   []byte(conf),
+				Args:        "IP=10.10.0.3/24,11.11.0.3/24;GATEWAY=10.10.0.254",
+			}
+
+			// Allocate the IP
+			r, raw, err := testutils.CmdAddWithArgs(args, func() error {
+				return cmdAdd(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+			if testutils.SpecVersionHasIPVersion(ver) {
+				Expect(strings.Index(string(raw), "\"version\":")).Should(BeNumerically(">", 0))
+			}
+
+			result, err := types100.GetResult(r)
+			Expect(err).NotTo(HaveOccurred())
+
+			// only addresses in runtimeConfig configured because of its priorities
+			Expect(*result.IPs[0]).To(Equal(
+				types100.IPConfig{
+					Address: mustCIDR("10.10.0.1/24"),
+				}))
+			Expect(*result.IPs[1]).To(Equal(
+				types100.IPConfig{
+					Address: mustCIDR("3ffe:ffff:0:01ff::1/64"),
+				},
+			))
+			Expect(len(result.IPs)).To(Equal(2))
+			Expect(result.Routes).To(Equal([]*types.Route{
+				{Dst: mustCIDR("0.0.0.0/0"), GW: net.ParseIP("10.10.0.254")},
+				{Dst: mustCIDR("3ffe:ffff:0:01ff::1/64"), GW: net.ParseIP("3ffe:ffff:0::1")},
+			}))
+
+			// Release the IP
+			err = testutils.CmdDelWithArgs(args, func() error {
+				return cmdDel(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+		})
+	}
 })
 
 func mustCIDR(s string) net.IPNet {

plugins/main/bridge/bridge.go

@@ -29,7 +29,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 	"github.com/containernetworking/plugins/pkg/ip"
 	"github.com/containernetworking/plugins/pkg/ipam"
@@ -412,7 +412,14 @@ func cmdAdd(args *skel.CmdArgs) error {
 	}
 
 	// Assume L2 interface only
-	result := &current.Result{CNIVersion: cniVersion, Interfaces: []*current.Interface{brInterface, hostInterface, containerInterface}}
+	result := &current.Result{
+		CNIVersion: current.ImplementedSpecVersion,
+		Interfaces: []*current.Interface{
+			brInterface,
+			hostInterface,
+			containerInterface,
+		},
+	}
 
 	if isLayer3 {
 		// run the IPAM plugin and get back the config to apply
@@ -453,7 +460,7 @@ func cmdAdd(args *skel.CmdArgs) error {
 			// bridge. Hairpin mode causes echos of neighbor solicitation
 			// packets, which causes DAD failures.
 			for _, ipc := range result.IPs {
-				if ipc.Version == "6" && (n.HairpinMode || n.PromiscMode) {
+				if ipc.Address.IP.To4() == nil && (n.HairpinMode || n.PromiscMode) {
 					if err := disableIPV6DAD(args.IfName); err != nil {
 						return err
 					}
@@ -496,7 +503,7 @@ func cmdAdd(args *skel.CmdArgs) error {
 			}
 
 			for _, ipc := range result.IPs {
-				if ipc.Version == "4" {
+				if ipc.Address.IP.To4() != nil {
 					_ = arping.GratuitousArpOverIface(ipc.Address.IP, *contVeth)
 				}
 			}

plugins/main/host-device/host-device.go

@@ -30,7 +30,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/ip"

plugins/main/ipvlan/ipvlan.go

@@ -24,7 +24,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/ip"

plugins/main/ipvlan/ipvlan_test.go

@@ -17,12 +17,17 @@ package main
 import (
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"net"
+	"os"
+	"strings"
 	"syscall"
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	"github.com/containernetworking/cni/pkg/types/020"
+	"github.com/containernetworking/cni/pkg/types/040"
+	"github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/containernetworking/plugins/pkg/testutils"
 
@@ -44,37 +49,33 @@ type Net struct {
 	IPAM          *allocator.IPAMConfig  `json:"ipam"`
 	DNS           types.DNS              `json:"dns"`
 	RawPrevResult map[string]interface{} `json:"prevResult,omitempty"`
-	PrevResult    current.Result         `json:"-"`
+	PrevResult    types100.Result        `json:"-"`
 }
 
-func buildOneConfig(netName string, cniVersion string, master string, orig *Net, prevResult types.Result) (*Net, error) {
-	var err error
-
-	inject := map[string]interface{}{
-		"name":       netName,
-		"cniVersion": cniVersion,
-	}
-	// Add previous plugin result
-	if prevResult != nil {
-		inject["prevResult"] = prevResult
-	}
-	if orig.IPAM == nil {
-		inject["master"] = master
-	}
-
-	// Ensure every config uses the same name and version
-	config := make(map[string]interface{})
-
+func buildOneConfig(cniVersion string, master string, orig *Net, prevResult types.Result) (*Net, error) {
 	confBytes, err := json.Marshal(orig)
 	if err != nil {
 		return nil, err
 	}
 
+	config := make(map[string]interface{})
 	err = json.Unmarshal(confBytes, &config)
 	if err != nil {
 		return nil, fmt.Errorf("unmarshal existing network bytes: %s", err)
 	}
 
+	inject := map[string]interface{}{
+		"name":       orig.Name,
+		"cniVersion": orig.CNIVersion,
+	}
+	// Add previous plugin result
+	if prevResult != nil && testutils.SpecVersionHasChaining(cniVersion) {
+		inject["prevResult"] = prevResult
+	}
+	if master != "" {
+		inject["master"] = master
+	}
+
 	for key, value := range inject {
 		config[key] = value
 	}
@@ -93,121 +94,49 @@ func buildOneConfig(netName string, cniVersion string, master string, orig *Net,
 
 }
 
-func ipvlanAddDelTest(conf, IFNAME string, originalNS ns.NetNS) {
-	targetNs, err := testutils.NewNS()
+func ipvlanAddCheckDelTest(conf, masterName string, originalNS, targetNS ns.NetNS) {
+	// Unmarshal to pull out CNI spec version
+	rawConfig := make(map[string]interface{})
+	err := json.Unmarshal([]byte(conf), &rawConfig)
 	Expect(err).NotTo(HaveOccurred())
-	defer targetNs.Close()
+	cniVersion := rawConfig["cniVersion"].(string)
 
 	args := &skel.CmdArgs{
 		ContainerID: "dummy",
-		Netns:       targetNs.Path(),
-		IfName:      IFNAME,
+		Netns:       targetNS.Path(),
+		IfName:      "ipvl0",
 		StdinData:   []byte(conf),
 	}
 
-	var result *current.Result
+	var result types.Result
+	var macAddress string
 	err = originalNS.Do(func(ns.NetNS) error {
 		defer GinkgoRecover()
 
-		r, _, err := testutils.CmdAddWithArgs(args, func() error {
+		result, _, err = testutils.CmdAddWithArgs(args, func() error {
 			return cmdAdd(args)
 		})
 		Expect(err).NotTo(HaveOccurred())
 
-		result, err = current.GetResult(r)
-		Expect(err).NotTo(HaveOccurred())
-
-		Expect(len(result.Interfaces)).To(Equal(1))
-		Expect(result.Interfaces[0].Name).To(Equal(IFNAME))
-		Expect(len(result.IPs)).To(Equal(1))
+		t := newTesterByVersion(cniVersion)
+		macAddress = t.verifyResult(result, args.IfName)
 		return nil
 	})
 	Expect(err).NotTo(HaveOccurred())
 
 	// Make sure ipvlan link exists in the target namespace
-	err = targetNs.Do(func(ns.NetNS) error {
+	err = targetNS.Do(func(ns.NetNS) error {
 		defer GinkgoRecover()
 
-		link, err := netlink.LinkByName(IFNAME)
+		link, err := netlink.LinkByName(args.IfName)
 		Expect(err).NotTo(HaveOccurred())
-		Expect(link.Attrs().Name).To(Equal(IFNAME))
+		Expect(link.Attrs().Name).To(Equal(args.IfName))
 
-		hwaddr, err := net.ParseMAC(result.Interfaces[0].Mac)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(link.Attrs().HardwareAddr).To(Equal(hwaddr))
-
-		addrs, err := netlink.AddrList(link, syscall.AF_INET)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(len(addrs)).To(Equal(1))
-		return nil
-	})
-	Expect(err).NotTo(HaveOccurred())
-
-	err = originalNS.Do(func(ns.NetNS) error {
-		defer GinkgoRecover()
-
-		err = testutils.CmdDelWithArgs(args, func() error {
-			return cmdDel(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-		return nil
-	})
-	Expect(err).NotTo(HaveOccurred())
-
-	// Make sure ipvlan link has been deleted
-	err = targetNs.Do(func(ns.NetNS) error {
-		defer GinkgoRecover()
-
-		link, err := netlink.LinkByName(IFNAME)
-		Expect(err).To(HaveOccurred())
-		Expect(link).To(BeNil())
-		return nil
-	})
-	Expect(err).NotTo(HaveOccurred())
-}
-
-func ipvlanAddCheckDelTest(conf string, netName string, IFNAME string, originalNS ns.NetNS) {
-	targetNs, err := testutils.NewNS()
-	Expect(err).NotTo(HaveOccurred())
-	defer targetNs.Close()
-
-	args := &skel.CmdArgs{
-		ContainerID: "dummy",
-		Netns:       targetNs.Path(),
-		IfName:      IFNAME,
-		StdinData:   []byte(conf),
-	}
-
-	var result *current.Result
-	err = originalNS.Do(func(ns.NetNS) error {
-		defer GinkgoRecover()
-
-		r, _, err := testutils.CmdAddWithArgs(args, func() error {
-			return cmdAdd(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		result, err = current.GetResult(r)
-		Expect(err).NotTo(HaveOccurred())
-
-		Expect(len(result.Interfaces)).To(Equal(1))
-		Expect(result.Interfaces[0].Name).To(Equal(IFNAME))
-		Expect(len(result.IPs)).To(Equal(1))
-		return nil
-	})
-	Expect(err).NotTo(HaveOccurred())
-
-	// Make sure ipvlan link exists in the target namespace
-	err = targetNs.Do(func(ns.NetNS) error {
-		defer GinkgoRecover()
-
-		link, err := netlink.LinkByName(IFNAME)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(link.Attrs().Name).To(Equal(IFNAME))
-
-		hwaddr, err := net.ParseMAC(result.Interfaces[0].Mac)
-		Expect(err).NotTo(HaveOccurred())
-		Expect(link.Attrs().HardwareAddr).To(Equal(hwaddr))
+		if macAddress != "" {
+			hwaddr, err := net.ParseMAC(macAddress)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(link.Attrs().HardwareAddr).To(Equal(hwaddr))
+		}
 
 		addrs, err := netlink.AddrList(link, syscall.AF_INET)
 		Expect(err).NotTo(HaveOccurred())
@@ -225,26 +154,26 @@ func ipvlanAddCheckDelTest(conf string, netName string, IFNAME string, originalN
 		Expect(err).NotTo(HaveOccurred())
 	}
 
-	cniVersion := "0.4.0"
-	newConf, err := buildOneConfig(netName, cniVersion, MASTER_NAME, n, result)
+	// build chained/cached config for DEL
+	newConf, err := buildOneConfig(cniVersion, masterName, n, result)
+	Expect(err).NotTo(HaveOccurred())
+	confBytes, err := json.Marshal(newConf)
 	Expect(err).NotTo(HaveOccurred())
 
-	confString, err := json.Marshal(newConf)
-	Expect(err).NotTo(HaveOccurred())
+	args.StdinData = confBytes
+	GinkgoT().Logf(string(confBytes))
 
-	args.StdinData = confString
+	if testutils.SpecVersionHasCHECK(cniVersion) {
+		// CNI Check on ipvlan in the target namespace
+		err = originalNS.Do(func(ns.NetNS) error {
+			defer GinkgoRecover()
 
-	// CNI Check on ipvlan in the target namespace
-	err = originalNS.Do(func(ns.NetNS) error {
-		defer GinkgoRecover()
-
-		err := testutils.CmdCheckWithArgs(args, func() error {
-			return cmdCheck(args)
+			return testutils.CmdCheckWithArgs(args, func() error {
+				return cmdCheck(args)
+			})
 		})
 		Expect(err).NotTo(HaveOccurred())
-		return nil
-	})
-	Expect(err).NotTo(HaveOccurred())
+	}
 
 	err = originalNS.Do(func(ns.NetNS) error {
 		defer GinkgoRecover()
@@ -258,10 +187,10 @@ func ipvlanAddCheckDelTest(conf string, netName string, IFNAME string, originalN
 	Expect(err).NotTo(HaveOccurred())
 
 	// Make sure ipvlan link has been deleted
-	err = targetNs.Do(func(ns.NetNS) error {
+	err = targetNS.Do(func(ns.NetNS) error {
 		defer GinkgoRecover()
 
-		link, err := netlink.LinkByName(IFNAME)
+		link, err := netlink.LinkByName(args.IfName)
 		Expect(err).To(HaveOccurred())
 		Expect(link).To(BeNil())
 		return nil
@@ -269,8 +198,70 @@ func ipvlanAddCheckDelTest(conf string, netName string, IFNAME string, originalN
 	Expect(err).NotTo(HaveOccurred())
 }
 
+type tester interface {
+	// verifyResult minimally verifies the Result and returns the interface's MAC address
+	verifyResult(result types.Result, name string) string
+}
+
+type testerBase struct{}
+
+type testerV10x testerBase
+type testerV04x testerBase
+type testerV02x testerBase
+
+func newTesterByVersion(version string) tester {
+	switch {
+	case strings.HasPrefix(version, "1.0."):
+		return &testerV10x{}
+	case strings.HasPrefix(version, "0.4.") || strings.HasPrefix(version, "0.3."):
+		return &testerV04x{}
+	case strings.HasPrefix(version, "0.1.") || strings.HasPrefix(version, "0.2."):
+		return &testerV02x{}
+	}
+	Fail(fmt.Sprintf("unsupported config version %s", version))
+	return nil
+}
+
+// verifyResult minimally verifies the Result and returns the interface's MAC address
+func (t *testerV10x) verifyResult(result types.Result, name string) string {
+	r, err := types100.GetResult(result)
+	Expect(err).NotTo(HaveOccurred())
+
+	Expect(len(r.Interfaces)).To(Equal(1))
+	Expect(r.Interfaces[0].Name).To(Equal(name))
+	Expect(len(r.IPs)).To(Equal(1))
+
+	return r.Interfaces[0].Mac
+}
+
+// verifyResult minimally verifies the Result and returns the interface's MAC address
+func (t *testerV04x) verifyResult(result types.Result, name string) string {
+	r, err := types040.GetResult(result)
+	Expect(err).NotTo(HaveOccurred())
+
+	Expect(len(r.Interfaces)).To(Equal(1))
+	Expect(r.Interfaces[0].Name).To(Equal(name))
+	Expect(len(r.IPs)).To(Equal(1))
+
+	return r.Interfaces[0].Mac
+}
+
+// verifyResult minimally verifies the Result and returns the interface's MAC address
+func (t *testerV02x) verifyResult(result types.Result, name string) string {
+	r, err := types020.GetResult(result)
+	Expect(err).NotTo(HaveOccurred())
+
+	Expect(r.IP4.IP).NotTo(BeNil())
+	Expect(r.IP4.IP.IP).NotTo(BeNil())
+	Expect(r.IP6).To(BeNil())
+
+	// 0.2 and earlier don't return MAC address
+	return ""
+}
+
 var _ = Describe("ipvlan Operations", func() {
-	var originalNS ns.NetNS
+	var originalNS, targetNS ns.NetNS
+	var dataDir string
 
 	BeforeEach(func() {
 		// Create a new NetNS so we don't modify the host
@@ -278,6 +269,12 @@ var _ = Describe("ipvlan Operations", func() {
 		originalNS, err = testutils.NewNS()
 		Expect(err).NotTo(HaveOccurred())
 
+		targetNS, err = testutils.NewNS()
+		Expect(err).NotTo(HaveOccurred())
+
+		dataDir, err = ioutil.TempDir("", "ipvlan_test")
+		Expect(err).NotTo(HaveOccurred())
+
 		err = originalNS.Do(func(ns.NetNS) error {
 			defer GinkgoRecover()
 
@@ -296,219 +293,170 @@ var _ = Describe("ipvlan Operations", func() {
 	})
 
 	AfterEach(func() {
+		Expect(os.RemoveAll(dataDir)).To(Succeed())
+
 		Expect(originalNS.Close()).To(Succeed())
 		Expect(testutils.UnmountNS(originalNS)).To(Succeed())
+
+		Expect(targetNS.Close()).To(Succeed())
+		Expect(testutils.UnmountNS(targetNS)).To(Succeed())
 	})
 
-	It("creates an ipvlan link in a non-default namespace", func() {
-		conf := &NetConf{
-			NetConf: types.NetConf{
-				CNIVersion: "0.3.1",
-				Name:       "testConfig",
-				Type:       "ipvlan",
-			},
-			Master: MASTER_NAME,
-			Mode:   "l2",
-			MTU:    1500,
-		}
+	for _, ver := range testutils.AllSpecVersions {
+		// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+		// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+		ver := ver
 
-		// Create ipvlan in other namespace
-		targetNs, err := testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-		defer targetNs.Close()
+		It(fmt.Sprintf("[%s] creates an ipvlan link in a non-default namespace", ver), func() {
+			conf := &NetConf{
+				NetConf: types.NetConf{
+					CNIVersion: ver,
+					Name:       "testConfig",
+					Type:       "ipvlan",
+				},
+				Master: MASTER_NAME,
+				Mode:   "l2",
+				MTU:    1500,
+			}
 
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				_, err := createIpvlan(conf, "foobar0", targetNS)
+				Expect(err).NotTo(HaveOccurred())
+				return nil
+			})
 
-			_, err := createIpvlan(conf, "foobar0", targetNs)
 			Expect(err).NotTo(HaveOccurred())
-			return nil
-		})
 
-		Expect(err).NotTo(HaveOccurred())
+			// Make sure ipvlan link exists in the target namespace
+			err = targetNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
 
-		// Make sure ipvlan link exists in the target namespace
-		err = targetNs.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			link, err := netlink.LinkByName("foobar0")
-			Expect(err).NotTo(HaveOccurred())
-			Expect(link.Attrs().Name).To(Equal("foobar0"))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("configures and deconfigures an iplvan link with ADD/DEL", func() {
-		const IFNAME = "ipvl0"
-
-		conf := fmt.Sprintf(`{
-    "cniVersion": "0.3.1",
-    "name": "mynet",
-    "type": "ipvlan",
-    "master": "%s",
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24"
-    }
-}`, MASTER_NAME)
-
-		ipvlanAddDelTest(conf, IFNAME, originalNS)
-	})
-
-	It("configures and deconfigures an iplvan link with ADD/DEL when chained", func() {
-		const IFNAME = "ipvl0"
-
-		conf := fmt.Sprintf(`{
-    "cniVersion": "0.3.1",
-    "name": "mynet",
-    "type": "ipvlan",
-    "prevResult": {
-            "interfaces": [
-                    {
-                            "name": "%s"
-                    }
-            ],
-            "ips": [
-                    {
-                            "version": "4",
-                            "address": "10.1.2.2/24",
-                            "gateway": "10.1.2.1",
-                            "interface": 0
-                    }
-            ],
-            "routes": []
-    }
-}`, MASTER_NAME)
-
-		ipvlanAddDelTest(conf, IFNAME, originalNS)
-	})
-
-	It("deconfigures an unconfigured ipvlan link with DEL", func() {
-		const IFNAME = "ipvl0"
-
-		conf := fmt.Sprintf(`{
-    "cniVersion": "0.3.0",
-    "name": "mynet",
-    "type": "ipvlan",
-    "master": "%s",
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24"
-    }
-}`, MASTER_NAME)
-
-		targetNs, err := testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-		defer targetNs.Close()
-
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNs.Path(),
-			IfName:      IFNAME,
-			StdinData:   []byte(conf),
-		}
-
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			err = testutils.CmdDelWithArgs(args, func() error {
-				return cmdDel(args)
+				link, err := netlink.LinkByName("foobar0")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(link.Attrs().Name).To(Equal("foobar0"))
+				return nil
 			})
 			Expect(err).NotTo(HaveOccurred())
-			return nil
 		})
-		Expect(err).NotTo(HaveOccurred())
-	})
 
-	It("configures and deconfigures a cniVersion 0.4.0 iplvan link with ADD/CHECK/DEL", func() {
-		const IFNAME = "ipvl0"
+		It(fmt.Sprintf("[%s] configures and deconfigures an iplvan link with ADD/DEL", ver), func() {
+			conf := fmt.Sprintf(`{
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "ipvlan",
+			    "master": "%s",
+			    "ipam": {
+				"type": "host-local",
+				"subnet": "10.1.2.0/24",
+				"dataDir": "%s"
+			    }
+			}`, ver, MASTER_NAME, dataDir)
 
-		conf := fmt.Sprintf(`{
-    "cniVersion": "0.4.0",
-    "name": "ipvlanTest1",
-    "type": "ipvlan",
-    "master": "%s",
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24"
-    }
-}`, MASTER_NAME)
+			ipvlanAddCheckDelTest(conf, "", originalNS, targetNS)
+		})
 
-		ipvlanAddCheckDelTest(conf, "ipvlanTest1", IFNAME, originalNS)
-	})
+		if testutils.SpecVersionHasChaining(ver) {
+			It(fmt.Sprintf("[%s] configures and deconfigures an iplvan link with ADD/DEL when chained", ver), func() {
+				conf := fmt.Sprintf(`{
+				    "cniVersion": "%s",
+				    "name": "mynet",
+				    "type": "ipvlan",
+				    "prevResult": {
+					    "interfaces": [
+						    {
+							    "name": "%s"
+						    }
+					    ],
+					    "ips": [
+						    {
+							    "version": "4",
+							    "address": "10.1.2.2/24",
+							    "gateway": "10.1.2.1",
+							    "interface": 0
+						    }
+					    ],
+					    "routes": []
+				    }
+				}`, ver, MASTER_NAME)
 
-	It("configures and deconfigures a cniVersion 0.4.0 iplvan link with ADD/CHECK/DEL when chained", func() {
-		const IFNAME = "ipvl0"
+				ipvlanAddCheckDelTest(conf, MASTER_NAME, originalNS, targetNS)
+			})
+		}
 
-		conf := fmt.Sprintf(`{
-	       "cniVersion": "0.4.0",
-	       "name": "ipvlanTest2",
-	       "type": "ipvlan",
-	       "prevResult": {
-	               "interfaces": [
-	                       {
-	                               "name": "%s"
-	                       }
-	               ],
-	               "ips": [
-	                       {
-	                               "version": "4",
-	                               "address": "10.1.2.2/24",
-	                               "gateway": "10.1.2.1",
-	                               "interface": 0
-	                       }
-	               ],
-	               "routes": []
-	       }
-	   }`, MASTER_NAME)
+		It(fmt.Sprintf("[%s] deconfigures an unconfigured ipvlan link with DEL", ver), func() {
+			conf := fmt.Sprintf(`{
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "ipvlan",
+			    "master": "%s",
+			    "ipam": {
+				"type": "host-local",
+				"subnet": "10.1.2.0/24",
+				"dataDir": "%s"
+			    }
+			}`, ver, MASTER_NAME, dataDir)
 
-		ipvlanAddCheckDelTest(conf, "ipvlanTest2", IFNAME, originalNS)
-	})
-
-	It("configures and deconfigures a ipvlan link with ADD/DEL, without master config", func() {
-		const IFNAME = "ipvl0"
-		conf := `{
-    "cniVersion": "0.3.1",
-    "name": "mynet",
-    "type": "ipvlan",
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24"
-    }
-}`
-
-		targetNs, err := testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-		defer targetNs.Close()
-
-		// Make MASTER_NAME as default route interface
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			link, err := netlink.LinkByName(MASTER_NAME)
-			Expect(err).NotTo(HaveOccurred())
-			err = netlink.LinkSetUp(link)
-			Expect(err).NotTo(HaveOccurred())
-
-			var address = &net.IPNet{IP: net.IPv4(192, 0, 0, 1), Mask: net.CIDRMask(24, 32)}
-			var addr = &netlink.Addr{IPNet: address}
-			err = netlink.AddrAdd(link, addr)
-			Expect(err).NotTo(HaveOccurred())
-
-			// add default gateway into MASTER
-			dst := &net.IPNet{
-				IP:   net.IPv4(0, 0, 0, 0),
-				Mask: net.CIDRMask(0, 0),
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      "ipvl0",
+				StdinData:   []byte(conf),
 			}
-			ip := net.IPv4(192, 0, 0, 254)
-			route := netlink.Route{LinkIndex: link.Attrs().Index, Dst: dst, Gw: ip}
-			err = netlink.RouteAdd(&route)
-			Expect(err).NotTo(HaveOccurred())
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
 
-		ipvlanAddDelTest(conf, IFNAME, originalNS)
-	})
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				err := testutils.CmdDelWithArgs(args, func() error {
+					return cmdDel(args)
+				})
+				Expect(err).NotTo(HaveOccurred())
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		It(fmt.Sprintf("[%s] configures and deconfigures a ipvlan link with ADD/DEL, without master config", ver), func() {
+			conf := fmt.Sprintf(`{
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "ipvlan",
+			    "ipam": {
+				"type": "host-local",
+				"subnet": "10.1.2.0/24",
+				"dataDir": "%s"
+			    }
+			}`, ver, dataDir)
+
+			// Make MASTER_NAME as default route interface
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				link, err := netlink.LinkByName(MASTER_NAME)
+				Expect(err).NotTo(HaveOccurred())
+				err = netlink.LinkSetUp(link)
+				Expect(err).NotTo(HaveOccurred())
+
+				var address = &net.IPNet{IP: net.IPv4(192, 0, 0, 1), Mask: net.CIDRMask(24, 32)}
+				var addr = &netlink.Addr{IPNet: address}
+				err = netlink.AddrAdd(link, addr)
+				Expect(err).NotTo(HaveOccurred())
+
+				// add default gateway into MASTER
+				dst := &net.IPNet{
+					IP:   net.IPv4(0, 0, 0, 0),
+					Mask: net.CIDRMask(0, 0),
+				}
+				ip := net.IPv4(192, 0, 0, 254)
+				route := netlink.Route{LinkIndex: link.Attrs().Index, Dst: dst, Gw: ip}
+				err = netlink.RouteAdd(&route)
+				Expect(err).NotTo(HaveOccurred())
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+
+			ipvlanAddCheckDelTest(conf, MASTER_NAME, originalNS, targetNS)
+		})
+	}
 })

plugins/main/loopback/loopback.go

@@ -24,7 +24,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/ns"
@@ -109,12 +109,19 @@ func cmdAdd(args *skel.CmdArgs) error {
 		// loopback should pass it transparently
 		result = conf.PrevResult
 	} else {
-		loopbackInterface := &current.Interface{Name: args.IfName, Mac: "00:00:00:00:00:00", Sandbox: args.Netns}
-		r := &current.Result{CNIVersion: conf.CNIVersion, Interfaces: []*current.Interface{loopbackInterface}}
+		r := &current.Result{
+			CNIVersion: conf.CNIVersion,
+			Interfaces: []*current.Interface{
+				&current.Interface{
+					Name:    args.IfName,
+					Mac:     "00:00:00:00:00:00",
+					Sandbox: args.Netns,
+				},
+			},
+		}
 
 		if v4Addr != nil {
 			r.IPs = append(r.IPs, &current.IPConfig{
-				Version:   "4",
 				Interface: current.Int(0),
 				Address:   *v4Addr,
 			})
@@ -122,7 +129,6 @@ func cmdAdd(args *skel.CmdArgs) error {
 
 		if v6Addr != nil {
 			r.IPs = append(r.IPs, &current.IPConfig{
-				Version:   "6",
 				Interface: current.Int(0),
 				Address:   *v6Addr,
 			})

plugins/main/loopback/loopback_test.go

@@ -28,6 +28,10 @@ import (
 	"github.com/onsi/gomega/gexec"
 )
 
+func generateConfig(cniVersion string) *strings.Reader {
+	return strings.NewReader(fmt.Sprintf(`{ "name": "loopback-test", "cniVersion": "%s" }`, cniVersion))
+}
+
 var _ = Describe("Loopback", func() {
 	var (
 		networkNS ns.NetNS
@@ -49,7 +53,6 @@ var _ = Describe("Loopback", func() {
 			fmt.Sprintf("CNI_ARGS=%s", "none"),
 			fmt.Sprintf("CNI_PATH=%s", "/some/test/path"),
 		}
-		command.Stdin = strings.NewReader(`{ "name": "loopback-test", "cniVersion": "0.1.0" }`)
 	})
 
 	AfterEach(func() {
@@ -57,45 +60,53 @@ var _ = Describe("Loopback", func() {
 		Expect(testutils.UnmountNS(networkNS)).To(Succeed())
 	})
 
-	Context("when given a network namespace", func() {
-		It("sets the lo device to UP", func() {
-			command.Env = append(environ, fmt.Sprintf("CNI_COMMAND=%s", "ADD"))
+	for _, ver := range testutils.AllSpecVersions {
+		// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+		// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+		ver := ver
 
-			session, err := gexec.Start(command, GinkgoWriter, GinkgoWriter)
-			Expect(err).NotTo(HaveOccurred())
+		Context("when given a network namespace", func() {
+			It(fmt.Sprintf("[%s] sets the lo device to UP", ver), func() {
+				command.Stdin = generateConfig(ver)
+				command.Env = append(environ, fmt.Sprintf("CNI_COMMAND=%s", "ADD"))
 
-			Eventually(session).Should(gbytes.Say(`{.*}`))
-			Eventually(session).Should(gexec.Exit(0))
+				session, err := gexec.Start(command, GinkgoWriter, GinkgoWriter)
+				Expect(err).NotTo(HaveOccurred())
 
-			var lo *net.Interface
-			err = networkNS.Do(func(ns.NetNS) error {
-				var err error
-				lo, err = net.InterfaceByName("lo")
-				return err
+				Eventually(session).Should(gbytes.Say(`{.*}`))
+				Eventually(session).Should(gexec.Exit(0))
+
+				var lo *net.Interface
+				err = networkNS.Do(func(ns.NetNS) error {
+					var err error
+					lo, err = net.InterfaceByName("lo")
+					return err
+				})
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(lo.Flags & net.FlagUp).To(Equal(net.FlagUp))
 			})
-			Expect(err).NotTo(HaveOccurred())
 
-			Expect(lo.Flags & net.FlagUp).To(Equal(net.FlagUp))
-		})
+			It(fmt.Sprintf("[%s] sets the lo device to DOWN", ver), func() {
+				command.Stdin = generateConfig(ver)
+				command.Env = append(environ, fmt.Sprintf("CNI_COMMAND=%s", "DEL"))
 
-		It("sets the lo device to DOWN", func() {
-			command.Env = append(environ, fmt.Sprintf("CNI_COMMAND=%s", "DEL"))
+				session, err := gexec.Start(command, GinkgoWriter, GinkgoWriter)
+				Expect(err).NotTo(HaveOccurred())
 
-			session, err := gexec.Start(command, GinkgoWriter, GinkgoWriter)
-			Expect(err).NotTo(HaveOccurred())
+				Eventually(session).Should(gbytes.Say(``))
+				Eventually(session).Should(gexec.Exit(0))
 
-			Eventually(session).Should(gbytes.Say(``))
-			Eventually(session).Should(gexec.Exit(0))
+				var lo *net.Interface
+				err = networkNS.Do(func(ns.NetNS) error {
+					var err error
+					lo, err = net.InterfaceByName("lo")
+					return err
+				})
+				Expect(err).NotTo(HaveOccurred())
 
-			var lo *net.Interface
-			err = networkNS.Do(func(ns.NetNS) error {
-				var err error
-				lo, err = net.InterfaceByName("lo")
-				return err
+				Expect(lo.Flags & net.FlagUp).NotTo(Equal(net.FlagUp))
 			})
-			Expect(err).NotTo(HaveOccurred())
-
-			Expect(lo.Flags & net.FlagUp).NotTo(Equal(net.FlagUp))
 		})
-	})
+	}
 })

plugins/main/macvlan/macvlan.go

@@ -26,7 +26,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/ip"
@@ -256,7 +256,10 @@ func cmdAdd(args *skel.CmdArgs) error {
 	}()
 
 	// Assume L2 interface only
-	result := &current.Result{CNIVersion: cniVersion, Interfaces: []*current.Interface{macvlanInterface}}
+	result := &current.Result{
+		CNIVersion: current.ImplementedSpecVersion,
+		Interfaces: []*current.Interface{macvlanInterface},
+	}
 
 	if isLayer3 {
 		// run the IPAM plugin and get back the config to apply
@@ -301,7 +304,7 @@ func cmdAdd(args *skel.CmdArgs) error {
 			}
 
 			for _, ipc := range result.IPs {
-				if ipc.Version == "4" {
+				if ipc.Address.IP.To4() != nil {
 					_ = arping.GratuitousArpOverIface(ipc.Address.IP, *contVeth)
 				}
 			}

plugins/main/ptp/ptp.go

@@ -27,7 +27,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/ip"
@@ -108,7 +108,7 @@ func setupContainerVeth(netns ns.NetNS, ifName string, mtu int, pr *current.Resu
 			}
 
 			addrBits := 32
-			if ipc.Version == "6" {
+			if ipc.Address.IP.To4() == nil {
 				addrBits = 128
 			}
 
@@ -141,7 +141,7 @@ func setupContainerVeth(netns ns.NetNS, ifName string, mtu int, pr *current.Resu
 
 		// Send a gratuitous arp for all v4 addresses
 		for _, ipc := range pr.IPs {
-			if ipc.Version == "4" {
+			if ipc.Address.IP.To4() != nil {
 				_ = arping.GratuitousArpOverIface(ipc.Address.IP, *contVeth)
 			}
 		}

plugins/main/ptp/ptp_test.go

@@ -17,11 +17,15 @@ package main
 import (
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"os"
+	"strings"
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	"github.com/containernetworking/cni/pkg/types/020"
+	"github.com/containernetworking/cni/pkg/types/040"
+	"github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/containernetworking/plugins/pkg/testutils"
 
@@ -41,7 +45,7 @@ type Net struct {
 	IPAM          *allocator.IPAMConfig  `json:"ipam"`
 	DNS           types.DNS              `json:"dns"`
 	RawPrevResult map[string]interface{} `json:"prevResult,omitempty"`
-	PrevResult    current.Result         `json:"-"`
+	PrevResult    types100.Result        `json:"-"`
 }
 
 func buildOneConfig(netName string, cniVersion string, orig *Net, prevResult types.Result) (*Net, error) {
@@ -87,43 +91,166 @@ func buildOneConfig(netName string, cniVersion string, orig *Net, prevResult typ
 
 }
 
+type tester interface {
+	// verifyResult minimally verifies the Result and returns the interface's IP addresses and MAC address
+	verifyResult(result types.Result, expectedIfName, expectedSandbox string, expectedDNS types.DNS) ([]resultIP, string)
+}
+
+type testerBase struct{}
+
+type testerV10x testerBase
+type testerV04x testerBase
+type testerV03x testerBase
+type testerV01xOr02x testerBase
+
+func newTesterByVersion(version string) tester {
+	switch {
+	case strings.HasPrefix(version, "1.0."):
+		return &testerV10x{}
+	case strings.HasPrefix(version, "0.4."):
+		return &testerV04x{}
+	case strings.HasPrefix(version, "0.3."):
+		return &testerV03x{}
+	default:
+		return &testerV01xOr02x{}
+	}
+}
+
+type resultIP struct {
+	ip string
+	gw string
+}
+
+// verifyResult minimally verifies the Result and returns the interface's IP addresses and MAC address
+func (t *testerV10x) verifyResult(result types.Result, expectedIfName, expectedSandbox string, expectedDNS types.DNS) ([]resultIP, string) {
+	r, err := types100.GetResult(result)
+	Expect(err).NotTo(HaveOccurred())
+
+	Expect(r.Interfaces).To(HaveLen(2))
+	Expect(r.Interfaces[0].Name).To(HavePrefix("veth"))
+	Expect(r.Interfaces[0].Mac).To(HaveLen(17))
+	Expect(r.Interfaces[0].Sandbox).To(BeEmpty())
+	Expect(r.Interfaces[1].Name).To(Equal(expectedIfName))
+	Expect(r.Interfaces[1].Sandbox).To(Equal(expectedSandbox))
+
+	Expect(r.DNS).To(Equal(expectedDNS))
+
+	// Grab IPs from container interface
+	ips := []resultIP{}
+	for _, ipc := range r.IPs {
+		if *ipc.Interface == 1 {
+			ips = append(ips, resultIP{
+				ip: ipc.Address.IP.String(),
+				gw: ipc.Gateway.String(),
+			})
+		}
+	}
+
+	return ips, r.Interfaces[1].Mac
+}
+
+func verify0403(result types.Result, expectedIfName, expectedSandbox string, expectedDNS types.DNS) ([]resultIP, string) {
+	r, err := types040.GetResult(result)
+	Expect(err).NotTo(HaveOccurred())
+
+	Expect(r.Interfaces).To(HaveLen(2))
+	Expect(r.Interfaces[0].Name).To(HavePrefix("veth"))
+	Expect(r.Interfaces[0].Mac).To(HaveLen(17))
+	Expect(r.Interfaces[0].Sandbox).To(BeEmpty())
+	Expect(r.Interfaces[1].Name).To(Equal(expectedIfName))
+	Expect(r.Interfaces[1].Sandbox).To(Equal(expectedSandbox))
+
+	Expect(r.DNS).To(Equal(expectedDNS))
+
+	// Grab IPs from container interface
+	ips := []resultIP{}
+	for _, ipc := range r.IPs {
+		if *ipc.Interface == 1 {
+			ips = append(ips, resultIP{
+				ip: ipc.Address.IP.String(),
+				gw: ipc.Gateway.String(),
+			})
+		}
+	}
+
+	return ips, r.Interfaces[1].Mac
+}
+
+// verifyResult minimally verifies the Result and returns the interface's IP addresses and MAC address
+func (t *testerV04x) verifyResult(result types.Result, expectedIfName, expectedSandbox string, expectedDNS types.DNS) ([]resultIP, string) {
+	return verify0403(result, expectedIfName, expectedSandbox, expectedDNS)
+}
+
+// verifyResult minimally verifies the Result and returns the interface's IP addresses and MAC address
+func (t *testerV03x) verifyResult(result types.Result, expectedIfName, expectedSandbox string, expectedDNS types.DNS) ([]resultIP, string) {
+	return verify0403(result, expectedIfName, expectedSandbox, expectedDNS)
+}
+
+// verifyResult minimally verifies the Result and returns the interface's IP addresses and MAC address
+func (t *testerV01xOr02x) verifyResult(result types.Result, expectedIfName, expectedSandbox string, expectedDNS types.DNS) ([]resultIP, string) {
+	r, err := types020.GetResult(result)
+	Expect(err).NotTo(HaveOccurred())
+
+	ips := []resultIP{}
+	if r.IP4 != nil && r.IP4.IP.IP != nil {
+		ips = append(ips, resultIP{
+			ip: r.IP4.IP.IP.String(),
+			gw: r.IP4.Gateway.String(),
+		})
+	}
+	if r.IP6 != nil && r.IP6.IP.IP != nil {
+		ips = append(ips, resultIP{
+			ip: r.IP6.IP.IP.String(),
+			gw: r.IP6.Gateway.String(),
+		})
+	}
+
+	// 0.2 and earlier don't return MAC address
+	return ips, ""
+}
+
 var _ = Describe("ptp Operations", func() {
-	var originalNS ns.NetNS
+	var originalNS, targetNS ns.NetNS
+	var dataDir string
 
 	BeforeEach(func() {
 		// Create a new NetNS so we don't modify the host
 		var err error
 		originalNS, err = testutils.NewNS()
 		Expect(err).NotTo(HaveOccurred())
+		targetNS, err = testutils.NewNS()
+		Expect(err).NotTo(HaveOccurred())
+
+		dataDir, err = ioutil.TempDir("", "ptp_test")
+		Expect(err).NotTo(HaveOccurred())
 	})
 
 	AfterEach(func() {
+		Expect(os.RemoveAll(dataDir)).To(Succeed())
 		Expect(originalNS.Close()).To(Succeed())
 		Expect(testutils.UnmountNS(originalNS)).To(Succeed())
+		Expect(targetNS.Close()).To(Succeed())
+		Expect(testutils.UnmountNS(targetNS)).To(Succeed())
 	})
 
-	doTest := func(conf string, numIPs int, expectedDNSConf types.DNS) {
+	doTest := func(conf, cniVersion string, numIPs int, expectedDNSConf types.DNS, targetNS ns.NetNS) {
 		const IFNAME = "ptp0"
 
-		targetNs, err := testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-		defer targetNs.Close()
-
 		args := &skel.CmdArgs{
 			ContainerID: "dummy",
-			Netns:       targetNs.Path(),
+			Netns:       targetNS.Path(),
 			IfName:      IFNAME,
 			StdinData:   []byte(conf),
 		}
 
-		var resI types.Result
-		var res *current.Result
+		var result types.Result
 
 		// Execute the plugin with the ADD command, creating the veth endpoints
-		err = originalNS.Do(func(ns.NetNS) error {
+		err := originalNS.Do(func(ns.NetNS) error {
 			defer GinkgoRecover()
 
-			resI, _, err = testutils.CmdAddWithArgs(args, func() error {
+			var err error
+			result, _, err = testutils.CmdAddWithArgs(args, func() error {
 				return cmdAdd(args)
 			})
 			Expect(err).NotTo(HaveOccurred())
@@ -131,32 +258,25 @@ var _ = Describe("ptp Operations", func() {
 		})
 		Expect(err).NotTo(HaveOccurred())
 
-		res, err = current.NewResultFromResult(resI)
-		Expect(err).NotTo(HaveOccurred())
+		t := newTesterByVersion(cniVersion)
+		ips, mac := t.verifyResult(result, IFNAME, targetNS.Path(), expectedDNSConf)
+		Expect(len(ips)).To(Equal(numIPs))
 
 		// Make sure ptp link exists in the target namespace
 		// Then, ping the gateway
-		seenIPs := 0
-
-		wantMac := ""
-		err = targetNs.Do(func(ns.NetNS) error {
+		err = targetNS.Do(func(ns.NetNS) error {
 			defer GinkgoRecover()
 
 			link, err := netlink.LinkByName(IFNAME)
 			Expect(err).NotTo(HaveOccurred())
-			wantMac = link.Attrs().HardwareAddr.String()
+			if mac != "" {
+				Expect(mac).To(Equal(link.Attrs().HardwareAddr.String()))
+			}
 
-			for _, ipc := range res.IPs {
-				if *ipc.Interface != 1 {
-					continue
-				}
-				seenIPs += 1
-				saddr := ipc.Address.IP.String()
-				daddr := ipc.Gateway.String()
-				fmt.Fprintln(GinkgoWriter, "ping", saddr, "->", daddr)
-
-				if err := testutils.Ping(saddr, daddr, (ipc.Version == "6"), 30); err != nil {
-					return fmt.Errorf("ping %s -> %s failed: %s", saddr, daddr, err)
+			for _, ipc := range ips {
+				fmt.Fprintln(GinkgoWriter, "ping", ipc.ip, "->", ipc.gw)
+				if err := testutils.Ping(ipc.ip, ipc.gw, 30); err != nil {
+					return fmt.Errorf("ping %s -> %s failed: %s", ipc.ip, ipc.gw, err)
 				}
 			}
 
@@ -164,121 +284,6 @@ var _ = Describe("ptp Operations", func() {
 		})
 		Expect(err).NotTo(HaveOccurred())
 
-		Expect(seenIPs).To(Equal(numIPs))
-
-		// make sure the interfaces are correct
-		Expect(res.Interfaces).To(HaveLen(2))
-
-		Expect(res.Interfaces[0].Name).To(HavePrefix("veth"))
-		Expect(res.Interfaces[0].Mac).To(HaveLen(17))
-		Expect(res.Interfaces[0].Sandbox).To(BeEmpty())
-
-		Expect(res.Interfaces[1].Name).To(Equal(IFNAME))
-		Expect(res.Interfaces[1].Mac).To(Equal(wantMac))
-		Expect(res.Interfaces[1].Sandbox).To(Equal(targetNs.Path()))
-
-		// make sure DNS is correct
-		Expect(res.DNS).To(Equal(expectedDNSConf))
-
-		// Call the plugins with the DEL command, deleting the veth endpoints
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			err := testutils.CmdDelWithArgs(args, func() error {
-				return cmdDel(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		// Make sure ptp link has been deleted
-		err = targetNs.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			link, err := netlink.LinkByName(IFNAME)
-			Expect(err).To(HaveOccurred())
-			Expect(link).To(BeNil())
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	}
-
-	doTestv4 := func(conf string, netName string, numIPs int) {
-		const IFNAME = "ptp0"
-
-		targetNs, err := testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-		defer targetNs.Close()
-
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNs.Path(),
-			IfName:      IFNAME,
-			StdinData:   []byte(conf),
-		}
-
-		var resI types.Result
-		var res *current.Result
-
-		// Execute the plugin with the ADD command, creating the veth endpoints
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			resI, _, err = testutils.CmdAddWithArgs(args, func() error {
-				return cmdAdd(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		res, err = current.NewResultFromResult(resI)
-		Expect(err).NotTo(HaveOccurred())
-
-		// Make sure ptp link exists in the target namespace
-		// Then, ping the gateway
-		seenIPs := 0
-
-		wantMac := ""
-		err = targetNs.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			link, err := netlink.LinkByName(IFNAME)
-			Expect(err).NotTo(HaveOccurred())
-			wantMac = link.Attrs().HardwareAddr.String()
-
-			for _, ipc := range res.IPs {
-				if *ipc.Interface != 1 {
-					continue
-				}
-				seenIPs += 1
-				saddr := ipc.Address.IP.String()
-				daddr := ipc.Gateway.String()
-				fmt.Fprintln(GinkgoWriter, "ping", saddr, "->", daddr)
-
-				if err := testutils.Ping(saddr, daddr, (ipc.Version == "6"), 30); err != nil {
-					return fmt.Errorf("ping %s -> %s failed: %s", saddr, daddr, err)
-				}
-			}
-
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		Expect(seenIPs).To(Equal(numIPs))
-
-		// make sure the interfaces are correct
-		Expect(res.Interfaces).To(HaveLen(2))
-
-		Expect(res.Interfaces[0].Name).To(HavePrefix("veth"))
-		Expect(res.Interfaces[0].Mac).To(HaveLen(17))
-		Expect(res.Interfaces[0].Sandbox).To(BeEmpty())
-
-		Expect(res.Interfaces[1].Name).To(Equal(IFNAME))
-		Expect(res.Interfaces[1].Mac).To(Equal(wantMac))
-		Expect(res.Interfaces[1].Sandbox).To(Equal(targetNs.Path()))
-
 		// call CmdCheck
 		n := &Net{}
 		err = json.Unmarshal([]byte(conf), &n)
@@ -287,8 +292,7 @@ var _ = Describe("ptp Operations", func() {
 		n.IPAM, _, err = allocator.LoadIPAMConfig([]byte(conf), "")
 		Expect(err).NotTo(HaveOccurred())
 
-		cniVersion := "0.4.0"
-		newConf, err := buildOneConfig(netName, cniVersion, n, res)
+		newConf, err := buildOneConfig(n.Name, cniVersion, n, result)
 		Expect(err).NotTo(HaveOccurred())
 
 		confString, err := json.Marshal(newConf)
@@ -299,11 +303,13 @@ var _ = Describe("ptp Operations", func() {
 		// CNI Check host-device in the target namespace
 		err = originalNS.Do(func(ns.NetNS) error {
 			defer GinkgoRecover()
-			var err error
-			err = testutils.CmdCheckWithArgs(args, func() error { return cmdCheck(args) })
-			return err
+			return testutils.CmdCheckWithArgs(args, func() error { return cmdCheck(args) })
 		})
-		Expect(err).NotTo(HaveOccurred())
+		if testutils.SpecVersionHasCHECK(cniVersion) {
+			Expect(err).NotTo(HaveOccurred())
+		} else {
+			Expect(err).To(MatchError("config version does not allow CHECK"))
+		}
 
 		args.StdinData = []byte(conf)
 
@@ -320,7 +326,7 @@ var _ = Describe("ptp Operations", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		// Make sure ptp link has been deleted
-		err = targetNs.Do(func(ns.NetNS) error {
+		err = targetNS.Do(func(ns.NetNS) error {
 			defer GinkgoRecover()
 
 			link, err := netlink.LinkByName(IFNAME)
@@ -331,227 +337,200 @@ var _ = Describe("ptp Operations", func() {
 		Expect(err).NotTo(HaveOccurred())
 	}
 
-	It("configures and deconfigures a ptp link with ADD/DEL", func() {
-		dnsConf := types.DNS{
-			Nameservers: []string{"10.1.2.123"},
-			Domain:      "some.domain.test",
-			Search:      []string{"search.test"},
-			Options:     []string{"option1:foo"},
-		}
-		dnsConfBytes, err := json.Marshal(dnsConf)
-		Expect(err).NotTo(HaveOccurred())
+	for _, ver := range testutils.AllSpecVersions {
+		// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+		// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+		ver := ver
 
-		conf := fmt.Sprintf(`{
-    "cniVersion": "0.3.1",
-    "name": "mynet",
-    "type": "ptp",
-    "ipMasq": true,
-    "mtu": 5000,
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24"
-    },
-    "dns": %s
-}`, string(dnsConfBytes))
-
-		doTest(conf, 1, dnsConf)
-	})
-
-	It("configures and deconfigures a dual-stack ptp link with ADD/DEL", func() {
-		conf := `{
-    "cniVersion": "0.3.1",
-    "name": "mynet",
-    "type": "ptp",
-    "ipMasq": true,
-    "mtu": 5000,
-    "ipam": {
-        "type": "host-local",
-		"ranges": [
-			[{ "subnet": "10.1.2.0/24"}],
-			[{ "subnet": "2001:db8:1::0/66"}]
-		]
-    }
-}`
-
-		doTest(conf, 2, types.DNS{})
-	})
-
-	It("does not override IPAM DNS settings if no DNS settings provided", func() {
-		ipamDNSConf := types.DNS{
-			Nameservers: []string{"10.1.2.123"},
-			Domain:      "some.domain.test",
-			Search:      []string{"search.test"},
-			Options:     []string{"option1:foo"},
-		}
-		resolvConfPath, err := testutils.TmpResolvConf(ipamDNSConf)
-		Expect(err).NotTo(HaveOccurred())
-		defer os.RemoveAll(resolvConfPath)
-
-		conf := fmt.Sprintf(`{
-    "cniVersion": "0.3.1",
-    "name": "mynet",
-    "type": "ptp",
-    "ipMasq": true,
-    "mtu": 5000,
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24",
-        "resolvConf": "%s"
-    }
-}`, resolvConfPath)
-
-		doTest(conf, 1, ipamDNSConf)
-	})
-
-	It("overrides IPAM DNS settings if any DNS settings provided", func() {
-		ipamDNSConf := types.DNS{
-			Nameservers: []string{"10.1.2.123"},
-			Domain:      "some.domain.test",
-			Search:      []string{"search.test"},
-			Options:     []string{"option1:foo"},
-		}
-		resolvConfPath, err := testutils.TmpResolvConf(ipamDNSConf)
-		Expect(err).NotTo(HaveOccurred())
-		defer os.RemoveAll(resolvConfPath)
-
-		for _, ptpDNSConf := range []types.DNS{
-			{
-				Nameservers: []string{"10.1.2.234"},
-			},
-			{
-				Domain: "someother.domain.test",
-			},
-			{
-				Search: []string{"search.elsewhere.test"},
-			},
-			{
-				Options: []string{"option2:bar"},
-			},
-		} {
-			dnsConfBytes, err := json.Marshal(ptpDNSConf)
+		It(fmt.Sprintf("[%s] configures and deconfigures a ptp link with ADD/DEL", ver), func() {
+			dnsConf := types.DNS{
+				Nameservers: []string{"10.1.2.123"},
+				Domain:      "some.domain.test",
+				Search:      []string{"search.test"},
+				Options:     []string{"option1:foo"},
+			}
+			dnsConfBytes, err := json.Marshal(dnsConf)
 			Expect(err).NotTo(HaveOccurred())
 
 			conf := fmt.Sprintf(`{
-    "cniVersion": "0.3.1",
-    "name": "mynet",
-    "type": "ptp",
-    "ipMasq": true,
-    "mtu": 5000,
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24",
-        "resolvConf": "%s"
-    },
-    "dns": %s
-}`, resolvConfPath, string(dnsConfBytes))
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "ptp",
+			    "ipMasq": true,
+			    "mtu": 5000,
+			    "ipam": {
+				"type": "host-local",
+				"subnet": "10.1.2.0/24",
+				"dataDir": "%s"
+			    },
+			    "dns": %s
+			}`, ver, dataDir, string(dnsConfBytes))
 
-			doTest(conf, 1, ptpDNSConf)
-		}
-	})
+			doTest(conf, ver, 1, dnsConf, targetNS)
+		})
 
-	It("overrides IPAM DNS settings if any empty list DNS settings provided", func() {
-		ipamDNSConf := types.DNS{
-			Nameservers: []string{"10.1.2.123"},
-			Domain:      "some.domain.test",
-			Search:      []string{"search.test"},
-			Options:     []string{"option1:foo"},
-		}
-		resolvConfPath, err := testutils.TmpResolvConf(ipamDNSConf)
-		Expect(err).NotTo(HaveOccurred())
-		defer os.RemoveAll(resolvConfPath)
+		It(fmt.Sprintf("[%s] configures and deconfigures a dual-stack ptp link with ADD/DEL", ver), func() {
+			conf := fmt.Sprintf(`{
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "ptp",
+			    "ipMasq": true,
+			    "mtu": 5000,
+			    "ipam": {
+				"type": "host-local",
+				"ranges": [
+					[{ "subnet": "10.1.2.0/24"}],
+					[{ "subnet": "2001:db8:1::0/66"}]
+				],
+				"dataDir": "%s"
+			    }
+			}`, ver, dataDir)
 
-		conf := fmt.Sprintf(`{
-    "cniVersion": "0.3.1",
-    "name": "mynet",
-    "type": "ptp",
-    "ipMasq": true,
-    "mtu": 5000,
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24",
-        "resolvConf": "%s"
-    },
-    "dns": {
-        "nameservers": [],
-        "search": [],
-        "options": []
-    }
-}`, resolvConfPath)
+			doTest(conf, ver, 2, types.DNS{}, targetNS)
+		})
 
-		doTest(conf, 1, types.DNS{})
-	})
+		It(fmt.Sprintf("[%s] does not override IPAM DNS settings if no DNS settings provided", ver), func() {
+			ipamDNSConf := types.DNS{
+				Nameservers: []string{"10.1.2.123"},
+				Domain:      "some.domain.test",
+				Search:      []string{"search.test"},
+				Options:     []string{"option1:foo"},
+			}
+			resolvConfPath, err := testutils.TmpResolvConf(ipamDNSConf)
+			Expect(err).NotTo(HaveOccurred())
+			defer os.RemoveAll(resolvConfPath)
 
-	It("deconfigures an unconfigured ptp link with DEL", func() {
-		const IFNAME = "ptp0"
+			conf := fmt.Sprintf(`{
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "ptp",
+			    "ipMasq": true,
+			    "mtu": 5000,
+			    "ipam": {
+				"type": "host-local",
+				"subnet": "10.1.2.0/24",
+				"resolvConf": "%s",
+				"dataDir": "%s"
+			    }
+			}`, ver, resolvConfPath, dataDir)
 
-		conf := `{
-    "cniVersion": "0.3.0",
-    "name": "mynet",
-    "type": "ptp",
-    "ipMasq": true,
-    "mtu": 5000,
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24"
-    }
-}`
+			doTest(conf, ver, 1, ipamDNSConf, targetNS)
+		})
 
-		targetNs, err := testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-		defer targetNs.Close()
+		It(fmt.Sprintf("[%s] overrides IPAM DNS settings if any DNS settings provided", ver), func() {
+			ipamDNSConf := types.DNS{
+				Nameservers: []string{"10.1.2.123"},
+				Domain:      "some.domain.test",
+				Search:      []string{"search.test"},
+				Options:     []string{"option1:foo"},
+			}
+			resolvConfPath, err := testutils.TmpResolvConf(ipamDNSConf)
+			Expect(err).NotTo(HaveOccurred())
+			defer os.RemoveAll(resolvConfPath)
 
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNs.Path(),
-			IfName:      IFNAME,
-			StdinData:   []byte(conf),
-		}
+			for _, ptpDNSConf := range []types.DNS{
+				{
+					Nameservers: []string{"10.1.2.234"},
+				},
+				{
+					Domain: "someother.domain.test",
+				},
+				{
+					Search: []string{"search.elsewhere.test"},
+				},
+				{
+					Options: []string{"option2:bar"},
+				},
+			} {
+				dnsConfBytes, err := json.Marshal(ptpDNSConf)
+				Expect(err).NotTo(HaveOccurred())
 
-		// Call the plugins with the DEL command. It should not error even though the veth doesn't exist.
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
+				conf := fmt.Sprintf(`{
+				    "cniVersion": "%s",
+				    "name": "mynet",
+				    "type": "ptp",
+				    "ipMasq": true,
+				    "mtu": 5000,
+				    "ipam": {
+					"type": "host-local",
+					"subnet": "10.1.2.0/24",
+					"resolvConf": "%s",
+					"dataDir": "%s"
+				    },
+				    "dns": %s
+				}`, ver, resolvConfPath, dataDir, string(dnsConfBytes))
 
-			err := testutils.CmdDelWithArgs(args, func() error {
-				return cmdDel(args)
+				doTest(conf, ver, 1, ptpDNSConf, targetNS)
+			}
+		})
+
+		It(fmt.Sprintf("[%s] overrides IPAM DNS settings if any empty list DNS settings provided", ver), func() {
+			ipamDNSConf := types.DNS{
+				Nameservers: []string{"10.1.2.123"},
+				Domain:      "some.domain.test",
+				Search:      []string{"search.test"},
+				Options:     []string{"option1:foo"},
+			}
+			resolvConfPath, err := testutils.TmpResolvConf(ipamDNSConf)
+			Expect(err).NotTo(HaveOccurred())
+			defer os.RemoveAll(resolvConfPath)
+
+			conf := fmt.Sprintf(`{
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "ptp",
+			    "ipMasq": true,
+			    "mtu": 5000,
+			    "ipam": {
+				"type": "host-local",
+				"subnet": "10.1.2.0/24",
+				"dataDir": "%s",
+				"resolvConf": "%s"
+			    },
+			    "dns": {
+				"nameservers": [],
+				"search": [],
+				"options": []
+			    }
+			}`, ver, dataDir, resolvConfPath)
+
+			doTest(conf, ver, 1, types.DNS{}, targetNS)
+		})
+
+		It(fmt.Sprintf("[%s] deconfigures an unconfigured ptp link with DEL", ver), func() {
+			const IFNAME = "ptp0"
+
+			conf := fmt.Sprintf(`{
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "ptp",
+			    "ipMasq": true,
+			    "mtu": 5000,
+			    "ipam": {
+				"type": "host-local",
+				"dataDir": "%s",
+				"subnet": "10.1.2.0/24"
+			    }
+			}`, ver, dataDir)
+
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      IFNAME,
+				StdinData:   []byte(conf),
+			}
+
+			// Call the plugins with the DEL command. It should not error even though the veth doesn't exist.
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				err := testutils.CmdDelWithArgs(args, func() error {
+					return cmdDel(args)
+				})
+				Expect(err).NotTo(HaveOccurred())
+				return nil
 			})
 			Expect(err).NotTo(HaveOccurred())
-			return nil
 		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("configures and deconfigures a CNI V4 ptp link with ADD/DEL", func() {
-		conf := `{
-    "cniVersion": "0.4.0",
-    "name": "ptpNetv4",
-    "type": "ptp",
-    "ipMasq": true,
-    "mtu": 5000,
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24"
-    }
-}`
-
-		doTestv4(conf, "ptpNetv4", 1)
-	})
-
-	It("configures and deconfigures a CNI V4 dual-stack ptp link with ADD/DEL", func() {
-		conf := `{
-    "cniVersion": "0.4.0",
-    "name": "ptpNetv4ds",
-    "type": "ptp",
-    "ipMasq": true,
-    "mtu": 5000,
-    "ipam": {
-        "type": "host-local",
-		"ranges": [
-			[{ "subnet": "10.1.2.0/24"}],
-			[{ "subnet": "2001:db8:1::0/66"}]
-		]
-    }
-}`
-
-		doTestv4(conf, "ptpNetv4ds", 2)
-	})
+	}
 })

plugins/main/vlan/vlan.go

@@ -24,7 +24,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/ip"

plugins/main/vlan/vlan_test.go

@@ -17,12 +17,17 @@ package main
 import (
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"net"
+	"os"
+	"strings"
 	"syscall"
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	"github.com/containernetworking/cni/pkg/types/020"
+	"github.com/containernetworking/cni/pkg/types/040"
+	"github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/containernetworking/plugins/pkg/testutils"
 
@@ -45,7 +50,7 @@ type Net struct {
 	IPAM          *allocator.IPAMConfig  `json:"ipam"`
 	DNS           types.DNS              `json:"dns"`
 	RawPrevResult map[string]interface{} `json:"prevResult,omitempty"`
-	PrevResult    current.Result         `json:"-"`
+	PrevResult    types100.Result        `json:"-"`
 }
 
 func buildOneConfig(netName string, cniVersion string, orig *Net, prevResult types.Result) (*Net, error) {
@@ -91,14 +96,90 @@ func buildOneConfig(netName string, cniVersion string, orig *Net, prevResult typ
 
 }
 
+type tester interface {
+	// verifyResult minimally verifies the Result and returns the interface's MAC address
+	verifyResult(result types.Result, name string) string
+}
+
+type testerBase struct{}
+
+type testerV10x testerBase
+type testerV04x testerBase
+type testerV03x testerBase
+type testerV01xOr02x testerBase
+
+func newTesterByVersion(version string) tester {
+	switch {
+	case strings.HasPrefix(version, "1.0."):
+		return &testerV10x{}
+	case strings.HasPrefix(version, "0.4."):
+		return &testerV04x{}
+	case strings.HasPrefix(version, "0.3."):
+		return &testerV03x{}
+	default:
+		return &testerV01xOr02x{}
+	}
+}
+
+// verifyResult minimally verifies the Result and returns the interface's MAC address
+func (t *testerV10x) verifyResult(result types.Result, name string) string {
+	r, err := types100.GetResult(result)
+	Expect(err).NotTo(HaveOccurred())
+
+	Expect(len(r.Interfaces)).To(Equal(1))
+	Expect(r.Interfaces[0].Name).To(Equal(name))
+	Expect(len(r.IPs)).To(Equal(1))
+
+	return r.Interfaces[0].Mac
+}
+
+func verify0403(result types.Result, name string) string {
+	r, err := types040.GetResult(result)
+	Expect(err).NotTo(HaveOccurred())
+
+	Expect(len(r.Interfaces)).To(Equal(1))
+	Expect(r.Interfaces[0].Name).To(Equal(name))
+	Expect(len(r.IPs)).To(Equal(1))
+
+	return r.Interfaces[0].Mac
+}
+
+// verifyResult minimally verifies the Result and returns the interface's MAC address
+func (t *testerV04x) verifyResult(result types.Result, name string) string {
+	return verify0403(result, name)
+}
+
+// verifyResult minimally verifies the Result and returns the interface's MAC address
+func (t *testerV03x) verifyResult(result types.Result, name string) string {
+	return verify0403(result, name)
+}
+
+// verifyResult minimally verifies the Result and returns the interface's MAC address
+func (t *testerV01xOr02x) verifyResult(result types.Result, name string) string {
+	r, err := types020.GetResult(result)
+	Expect(err).NotTo(HaveOccurred())
+
+	Expect(r.IP4.IP.IP).NotTo(BeNil())
+	Expect(r.IP6).To(BeNil())
+
+	// 0.2 and earlier don't return MAC address
+	return ""
+}
+
 var _ = Describe("vlan Operations", func() {
-	var originalNS ns.NetNS
+	var originalNS, targetNS ns.NetNS
+	var dataDir string
 
 	BeforeEach(func() {
 		// Create a new NetNS so we don't modify the host
 		var err error
 		originalNS, err = testutils.NewNS()
 		Expect(err).NotTo(HaveOccurred())
+		targetNS, err = testutils.NewNS()
+		Expect(err).NotTo(HaveOccurred())
+
+		dataDir, err = ioutil.TempDir("", "vlan_test")
+		Expect(err).NotTo(HaveOccurred())
 
 		err = originalNS.Do(func(ns.NetNS) error {
 			defer GinkgoRecover()
@@ -120,376 +201,290 @@ var _ = Describe("vlan Operations", func() {
 	})
 
 	AfterEach(func() {
+		Expect(os.RemoveAll(dataDir)).To(Succeed())
 		Expect(originalNS.Close()).To(Succeed())
 		Expect(testutils.UnmountNS(originalNS)).To(Succeed())
+		Expect(targetNS.Close()).To(Succeed())
+		Expect(testutils.UnmountNS(targetNS)).To(Succeed())
 	})
 
-	It("creates an vlan link in a non-default namespace with given MTU", func() {
-		conf := &NetConf{
-			NetConf: types.NetConf{
-				CNIVersion: "0.3.0",
-				Name:       "testConfig",
-				Type:       "vlan",
-			},
-			Master: MASTER_NAME,
-			VlanId: 33,
-			MTU:    1500,
-		}
+	for _, ver := range testutils.AllSpecVersions {
+		// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+		// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+		ver := ver
 
-		// Create vlan in other namespace
-		targetNs, err := testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-		defer targetNs.Close()
+		It(fmt.Sprintf("[%s] creates an vlan link in a non-default namespace with given MTU", ver), func() {
+			conf := &NetConf{
+				NetConf: types.NetConf{
+					CNIVersion: ver,
+					Name:       "testConfig",
+					Type:       "vlan",
+				},
+				Master: MASTER_NAME,
+				VlanId: 33,
+				MTU:    1500,
+			}
 
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
+			// Create vlan in other namespace
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
 
-			_, err := createVlan(conf, "foobar0", targetNs)
-			Expect(err).NotTo(HaveOccurred())
-			return nil
-		})
-
-		Expect(err).NotTo(HaveOccurred())
-
-		// Make sure vlan link exists in the target namespace
-		err = targetNs.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			link, err := netlink.LinkByName("foobar0")
-			Expect(err).NotTo(HaveOccurred())
-			Expect(link.Attrs().Name).To(Equal("foobar0"))
-			Expect(link.Attrs().MTU).To(Equal(1500))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("creates an vlan link in a non-default namespace with master's MTU", func() {
-		conf := &NetConf{
-			NetConf: types.NetConf{
-				CNIVersion: "0.3.0",
-				Name:       "testConfig",
-				Type:       "vlan",
-			},
-			Master: MASTER_NAME,
-			VlanId: 33,
-		}
-
-		// Create vlan in other namespace
-		targetNs, err := testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-		defer targetNs.Close()
-
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			m, err := netlink.LinkByName(MASTER_NAME)
-			Expect(err).NotTo(HaveOccurred())
-			err = netlink.LinkSetMTU(m, 1200)
-			Expect(err).NotTo(HaveOccurred())
-
-			_, err = createVlan(conf, "foobar0", targetNs)
-			Expect(err).NotTo(HaveOccurred())
-			return nil
-		})
-
-		Expect(err).NotTo(HaveOccurred())
-
-		// Make sure vlan link exists in the target namespace
-		err = targetNs.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			link, err := netlink.LinkByName("foobar0")
-			Expect(err).NotTo(HaveOccurred())
-			Expect(link.Attrs().Name).To(Equal("foobar0"))
-			Expect(link.Attrs().MTU).To(Equal(1200))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("configures and deconfigures an vlan link with ADD/DEL", func() {
-		const IFNAME = "eth0"
-
-		conf := fmt.Sprintf(`{
-    "cniVersion": "0.3.0",
-    "name": "mynet",
-    "type": "vlan",
-    "master": "%s",
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24"
-    }
-}`, MASTER_NAME)
-
-		targetNs, err := testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-		defer targetNs.Close()
-
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNs.Path(),
-			IfName:      IFNAME,
-			StdinData:   []byte(conf),
-		}
-
-		var result *current.Result
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			r, _, err := testutils.CmdAddWithArgs(args, func() error {
-				return cmdAdd(args)
+				_, err := createVlan(conf, "foobar0", targetNS)
+				Expect(err).NotTo(HaveOccurred())
+				return nil
 			})
 			Expect(err).NotTo(HaveOccurred())
 
-			result, err = current.GetResult(r)
-			Expect(err).NotTo(HaveOccurred())
+			// Make sure vlan link exists in the target namespace
+			err = targetNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
 
-			Expect(len(result.Interfaces)).To(Equal(1))
-			Expect(result.Interfaces[0].Name).To(Equal(IFNAME))
-			Expect(len(result.IPs)).To(Equal(1))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		// Make sure vlan link exists in the target namespace
-		err = targetNs.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			link, err := netlink.LinkByName(IFNAME)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(link.Attrs().Name).To(Equal(IFNAME))
-
-			hwaddr, err := net.ParseMAC(result.Interfaces[0].Mac)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(link.Attrs().HardwareAddr).To(Equal(hwaddr))
-
-			addrs, err := netlink.AddrList(link, syscall.AF_INET)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(len(addrs)).To(Equal(1))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			err = testutils.CmdDelWithArgs(args, func() error {
-				return cmdDel(args)
+				link, err := netlink.LinkByName("foobar0")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(link.Attrs().Name).To(Equal("foobar0"))
+				Expect(link.Attrs().MTU).To(Equal(1500))
+				return nil
 			})
 			Expect(err).NotTo(HaveOccurred())
-			return nil
 		})
-		Expect(err).NotTo(HaveOccurred())
 
-		// Make sure vlan link has been deleted
-		err = targetNs.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
+		It(fmt.Sprintf("[%s] creates an vlan link in a non-default namespace with master's MTU", ver), func() {
+			conf := &NetConf{
+				NetConf: types.NetConf{
+					CNIVersion: ver,
+					Name:       "testConfig",
+					Type:       "vlan",
+				},
+				Master: MASTER_NAME,
+				VlanId: 33,
+			}
 
-			link, err := netlink.LinkByName(IFNAME)
-			Expect(err).To(HaveOccurred())
-			Expect(link).To(BeNil())
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
+			// Create vlan in other namespace
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
 
-		// DEL can be called multiple times, make sure no error is returned
-		// if the device is already removed.
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
+				m, err := netlink.LinkByName(MASTER_NAME)
+				Expect(err).NotTo(HaveOccurred())
+				err = netlink.LinkSetMTU(m, 1200)
+				Expect(err).NotTo(HaveOccurred())
 
-			err = testutils.CmdDelWithArgs(args, func() error {
-				return cmdDel(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("configures and deconfigures an CNI V4 vlan link with ADD/CHECK/DEL", func() {
-		const IFNAME = "eth0"
-
-		conf := fmt.Sprintf(`{
-    "cniVersion": "0.4.0",
-    "name": "vlanTestv4",
-    "type": "vlan",
-    "master": "%s",
-    "vlanId": 1234,
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24"
-    }
-}`, MASTER_NAME)
-
-		targetNs, err := testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-		defer targetNs.Close()
-
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNs.Path(),
-			IfName:      IFNAME,
-			StdinData:   []byte(conf),
-		}
-
-		var result *current.Result
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			r, _, err := testutils.CmdAddWithArgs(args, func() error {
-				return cmdAdd(args)
+				_, err = createVlan(conf, "foobar0", targetNS)
+				Expect(err).NotTo(HaveOccurred())
+				return nil
 			})
 			Expect(err).NotTo(HaveOccurred())
 
-			result, err = current.GetResult(r)
-			Expect(err).NotTo(HaveOccurred())
+			// Make sure vlan link exists in the target namespace
+			err = targetNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
 
-			Expect(len(result.Interfaces)).To(Equal(1))
-			Expect(result.Interfaces[0].Name).To(Equal(IFNAME))
-			Expect(len(result.IPs)).To(Equal(1))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		// Make sure vlan link exists in the target namespace
-		err = targetNs.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			link, err := netlink.LinkByName(IFNAME)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(link.Attrs().Name).To(Equal(IFNAME))
-
-			hwaddr, err := net.ParseMAC(result.Interfaces[0].Mac)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(link.Attrs().HardwareAddr).To(Equal(hwaddr))
-
-			addrs, err := netlink.AddrList(link, syscall.AF_INET)
-			Expect(err).NotTo(HaveOccurred())
-			Expect(len(addrs)).To(Equal(1))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		// call CmdCheck
-		n := &Net{}
-		err = json.Unmarshal([]byte(conf), &n)
-		Expect(err).NotTo(HaveOccurred())
-
-		n.IPAM, _, err = allocator.LoadIPAMConfig([]byte(conf), "")
-		Expect(err).NotTo(HaveOccurred())
-
-		cniVersion := "0.4.0"
-		newConf, err := buildOneConfig("vlanTestv4", cniVersion, n, result)
-		Expect(err).NotTo(HaveOccurred())
-
-		confString, err := json.Marshal(newConf)
-		Expect(err).NotTo(HaveOccurred())
-
-		args.StdinData = confString
-
-		// CNI Check host-device in the target namespace
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-			var err error
-			err = testutils.CmdCheckWithArgs(args, func() error { return cmdCheck(args) })
-			return err
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		args.StdinData = []byte(conf)
-
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			err = testutils.CmdDelWithArgs(args, func() error {
-				return cmdDel(args)
+				link, err := netlink.LinkByName("foobar0")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(link.Attrs().Name).To(Equal("foobar0"))
+				Expect(link.Attrs().MTU).To(Equal(1200))
+				return nil
 			})
 			Expect(err).NotTo(HaveOccurred())
-			return nil
 		})
-		Expect(err).NotTo(HaveOccurred())
 
-		// Make sure vlan link has been deleted
-		err = targetNs.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
+		It(fmt.Sprintf("[%s] configures and deconfigures a vlan link with ADD/CHECK/DEL", ver), func() {
+			const IFNAME = "eth0"
 
-			link, err := netlink.LinkByName(IFNAME)
-			Expect(err).To(HaveOccurred())
-			Expect(link).To(BeNil())
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
+			conf := fmt.Sprintf(`{
+			    "cniVersion": "%s",
+			    "name": "vlanTestv4",
+			    "type": "vlan",
+			    "master": "%s",
+			    "vlanId": 1234,
+			    "ipam": {
+				"type": "host-local",
+				"subnet": "10.1.2.0/24",
+				"dataDir": "%s"
+			    }
+			}`, ver, MASTER_NAME, dataDir)
+
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      IFNAME,
+				StdinData:   []byte(conf),
+			}
+
+			t := newTesterByVersion(ver)
+
+			var result types.Result
+			var macAddress string
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				var err error
+				result, _, err = testutils.CmdAddWithArgs(args, func() error {
+					return cmdAdd(args)
+				})
+				Expect(err).NotTo(HaveOccurred())
+
+				macAddress = t.verifyResult(result, IFNAME)
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+
+			// Make sure vlan link exists in the target namespace
+			err = targetNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				link, err := netlink.LinkByName(IFNAME)
+				Expect(err).NotTo(HaveOccurred())
+				Expect(link.Attrs().Name).To(Equal(IFNAME))
+
+				if macAddress != "" {
+					hwaddr, err := net.ParseMAC(macAddress)
+					Expect(err).NotTo(HaveOccurred())
+					Expect(link.Attrs().HardwareAddr).To(Equal(hwaddr))
+				}
+
+				addrs, err := netlink.AddrList(link, syscall.AF_INET)
+				Expect(err).NotTo(HaveOccurred())
+				Expect(len(addrs)).To(Equal(1))
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+
+			// call CmdCheck
+			n := &Net{}
+			err = json.Unmarshal([]byte(conf), &n)
+			Expect(err).NotTo(HaveOccurred())
+
+			n.IPAM, _, err = allocator.LoadIPAMConfig([]byte(conf), "")
+			Expect(err).NotTo(HaveOccurred())
+
+			newConf, err := buildOneConfig("vlanTestv4", ver, n, result)
+			Expect(err).NotTo(HaveOccurred())
+
+			confString, err := json.Marshal(newConf)
+			Expect(err).NotTo(HaveOccurred())
+
+			args.StdinData = confString
+
+			// CNI Check host-device in the target namespace
+			err = originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+				return testutils.CmdCheckWithArgs(args, func() error { return cmdCheck(args) })
+			})
+			if testutils.SpecVersionHasCHECK(ver) {
+				Expect(err).NotTo(HaveOccurred())
+			} else {
+				Expect(err).To(MatchError("config version does not allow CHECK"))
+			}
+
+			args.StdinData = []byte(conf)
 
-	Describe("fails to create vlan link with invalid MTU", func() {
-		conf := `{
-    "cniVersion": "0.3.1",
-    "name": "mynet",
-    "type": "vlan",
-    "master": "%s",
-    "mtu": %d,
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.1.2.0/24"
-    }
-}`
-		BeforeEach(func() {
-			var err error
 			err = originalNS.Do(func(ns.NetNS) error {
 				defer GinkgoRecover()
 
-				// set master link's MTU to 1500
-				link, err := netlink.LinkByName(MASTER_NAME)
-				Expect(err).NotTo(HaveOccurred())
-				err = netlink.LinkSetMTU(link, 1500)
+				err = testutils.CmdDelWithArgs(args, func() error {
+					return cmdDel(args)
+				})
 				Expect(err).NotTo(HaveOccurred())
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
 
+			// Make sure vlan link has been deleted
+			err = targetNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				link, err := netlink.LinkByName(IFNAME)
+				Expect(err).To(HaveOccurred())
+				Expect(link).To(BeNil())
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+
+			// DEL can be called multiple times, make sure no error is returned
+			// if the device is already removed.
+			err = originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				err = testutils.CmdDelWithArgs(args, func() error {
+					return cmdDel(args)
+				})
+				Expect(err).NotTo(HaveOccurred())
 				return nil
 			})
 			Expect(err).NotTo(HaveOccurred())
 		})
 
-		It("fails to create vlan link with greater MTU than master interface", func() {
-			var err error
+		Describe("fails to create vlan link with invalid MTU", func() {
+			const confFmt = `{
+			    "cniVersion": "%s",
+			    "name": "mynet",
+			    "type": "vlan",
+			    "master": "%s",
+			    "mtu": %d,
+			    "ipam": {
+				"type": "host-local",
+				"subnet": "10.1.2.0/24",
+				"dataDir": "%s"
+			    }
+			}`
 
-			args := &skel.CmdArgs{
-				ContainerID: "dummy",
-				Netns:       "/var/run/netns/test",
-				IfName:      "eth0",
-				StdinData:   []byte(fmt.Sprintf(conf, MASTER_NAME, 1600)),
-			}
+			BeforeEach(func() {
+				var err error
+				err = originalNS.Do(func(ns.NetNS) error {
+					defer GinkgoRecover()
 
-			_ = originalNS.Do(func(netNS ns.NetNS) error {
-				defer GinkgoRecover()
+					// set master link's MTU to 1500
+					link, err := netlink.LinkByName(MASTER_NAME)
+					Expect(err).NotTo(HaveOccurred())
+					err = netlink.LinkSetMTU(link, 1500)
+					Expect(err).NotTo(HaveOccurred())
 
-				_, _, err = testutils.CmdAddWithArgs(args, func() error {
-					return cmdAdd(args)
+					return nil
+				})
+				Expect(err).NotTo(HaveOccurred())
+			})
+
+			It(fmt.Sprintf("[%s] fails to create vlan link with greater MTU than master interface", ver), func() {
+				var err error
+
+				args := &skel.CmdArgs{
+					ContainerID: "dummy",
+					Netns:       "/var/run/netns/test",
+					IfName:      "eth0",
+					StdinData:   []byte(fmt.Sprintf(confFmt, ver, MASTER_NAME, 1600, dataDir)),
+				}
+
+				_ = originalNS.Do(func(netNS ns.NetNS) error {
+					defer GinkgoRecover()
+
+					_, _, err = testutils.CmdAddWithArgs(args, func() error {
+						return cmdAdd(args)
+					})
+					Expect(err).To(Equal(fmt.Errorf("invalid MTU 1600, must be [0, master MTU(1500)]")))
+					return nil
+				})
+			})
+
+			It(fmt.Sprintf("[%s] fails to create vlan link with negative MTU", ver), func() {
+				var err error
+
+				args := &skel.CmdArgs{
+					ContainerID: "dummy",
+					Netns:       "/var/run/netns/test",
+					IfName:      "eth0",
+					StdinData:   []byte(fmt.Sprintf(confFmt, ver, MASTER_NAME, -100, dataDir)),
+				}
+
+				_ = originalNS.Do(func(netNS ns.NetNS) error {
+					defer GinkgoRecover()
+
+					_, _, err = testutils.CmdAddWithArgs(args, func() error {
+						return cmdAdd(args)
+					})
+					Expect(err).To(Equal(fmt.Errorf("invalid MTU -100, must be [0, master MTU(1500)]")))
+					return nil
 				})
-				Expect(err).To(Equal(fmt.Errorf("invalid MTU 1600, must be [0, master MTU(1500)]")))
-				return nil
 			})
 		})
-
-		It("fails to create vlan link with negative MTU", func() {
-			var err error
-
-			args := &skel.CmdArgs{
-				ContainerID: "dummy",
-				Netns:       "/var/run/netns/test",
-				IfName:      "eth0",
-				StdinData:   []byte(fmt.Sprintf(conf, MASTER_NAME, -100)),
-			}
-
-			_ = originalNS.Do(func(netNS ns.NetNS) error {
-				defer GinkgoRecover()
-
-				_, _, err = testutils.CmdAddWithArgs(args, func() error {
-					return cmdAdd(args)
-				})
-				Expect(err).To(Equal(fmt.Errorf("invalid MTU -100, must be [0, master MTU(1500)]")))
-				return nil
-			})
-		})
-	})
+	}
 })

plugins/main/windows/win-bridge/win-bridge_windows.go

@@ -25,7 +25,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/errors"

plugins/main/windows/win-overlay/win-overlay_windows.go

@@ -24,7 +24,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/errors"

plugins/meta/bandwidth/bandwidth_suite_test.go

@@ -106,7 +106,7 @@ func makeTcpClientInNS(netns string, address string, port int, numBytes int) {
 	Expect(string(out)).To(Equal(message))
 }
 
-func createVeth(hostNamespace string, hostVethIfName string, containerNamespace string, containerVethIfName string, hostIP []byte, containerIP []byte, hostIfaceMTU int) {
+func createVeth(hostNs ns.NetNS, hostVethIfName string, containerNs ns.NetNS, containerVethIfName string, hostIP []byte, containerIP []byte, hostIfaceMTU int) {
 	vethDeviceRequest := &netlink.Veth{
 		LinkAttrs: netlink.LinkAttrs{
 			Name:  hostVethIfName,
@@ -116,10 +116,7 @@ func createVeth(hostNamespace string, hostVethIfName string, containerNamespace
 		PeerName: containerVethIfName,
 	}
 
-	hostNs, err := ns.GetNS(hostNamespace)
-	Expect(err).NotTo(HaveOccurred())
-
-	err = hostNs.Do(func(_ ns.NetNS) error {
+	err := hostNs.Do(func(_ ns.NetNS) error {
 		if err := netlink.LinkAdd(vethDeviceRequest); err != nil {
 			return fmt.Errorf("creating veth pair: %s", err)
 		}
@@ -129,11 +126,6 @@ func createVeth(hostNamespace string, hostVethIfName string, containerNamespace
 			return fmt.Errorf("failed to find newly-created veth device %q: %v", containerVethIfName, err)
 		}
 
-		containerNs, err := ns.GetNS(containerNamespace)
-		if err != nil {
-			return err
-		}
-
 		err = netlink.LinkSetNsFd(containerVeth, int(containerNs.Fd()))
 		if err != nil {
 			return fmt.Errorf("failed to move veth to container namespace: %s", err)
@@ -169,8 +161,6 @@ func createVeth(hostNamespace string, hostVethIfName string, containerNamespace
 	})
 	Expect(err).NotTo(HaveOccurred())
 
-	containerNs, err := ns.GetNS(containerNamespace)
-	Expect(err).NotTo(HaveOccurred())
 	err = containerNs.Do(func(_ ns.NetNS) error {
 		peerAddr := &net.IPNet{
 			IP:   hostIP,
@@ -203,7 +193,7 @@ func createVeth(hostNamespace string, hostVethIfName string, containerNamespace
 	Expect(err).NotTo(HaveOccurred())
 }
 
-func createVethInOneNs(namespace, vethName, peerName string) {
+func createVethInOneNs(netNS ns.NetNS, vethName, peerName string) {
 	vethDeviceRequest := &netlink.Veth{
 		LinkAttrs: netlink.LinkAttrs{
 			Name:  vethName,
@@ -212,10 +202,7 @@ func createVethInOneNs(namespace, vethName, peerName string) {
 		PeerName: peerName,
 	}
 
-	netNS, err := ns.GetNS(namespace)
-	Expect(err).NotTo(HaveOccurred())
-
-	err = netNS.Do(func(_ ns.NetNS) error {
+	err := netNS.Do(func(_ ns.NetNS) error {
 		if err := netlink.LinkAdd(vethDeviceRequest); err != nil {
 			return fmt.Errorf("failed to create veth pair: %v", err)
 		}
@@ -229,11 +216,8 @@ func createVethInOneNs(namespace, vethName, peerName string) {
 	Expect(err).NotTo(HaveOccurred())
 }
 
-func createMacvlan(namespace, master, macvlanName string) {
-	netNS, err := ns.GetNS(namespace)
-	Expect(err).NotTo(HaveOccurred())
-
-	err = netNS.Do(func(_ ns.NetNS) error {
+func createMacvlan(netNS ns.NetNS, master, macvlanName string) {
+	err := netNS.Do(func(_ ns.NetNS) error {
 		m, err := netlink.LinkByName(master)
 		if err != nil {
 			return fmt.Errorf("failed to lookup master %q: %v", master, err)

plugins/meta/bandwidth/main.go

@@ -23,7 +23,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/ip"

plugins/meta/firewall/firewall.go

@@ -24,7 +24,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	bv "github.com/containernetworking/plugins/pkg/utils/buildversion"
@@ -130,7 +130,9 @@ func cmdAdd(args *skel.CmdArgs) error {
 	}
 
 	if result == nil {
-		result = &current.Result{}
+		result = &current.Result{
+			CNIVersion: current.ImplementedSpecVersion,
+		}
 	}
 	return types.PrintResult(result, conf.CNIVersion)
 }

plugins/meta/firewall/firewall_firewalld_test.go

@@ -24,7 +24,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/invoke"
 	"github.com/containernetworking/cni/pkg/skel"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/containernetworking/plugins/pkg/testutils"
 
@@ -34,30 +34,7 @@ import (
 	. "github.com/onsi/gomega"
 )
 
-const (
-	confTmpl = `{
-  "cniVersion": "0.3.1",
-  "name": "firewalld-test",
-  "type": "firewall",
-  "backend": "firewalld",
-  "zone": "trusted",
-  "prevResult": {
-    "cniVersion": "0.3.0",
-    "interfaces": [
-      {"name": "%s", "sandbox": "%s"}
-    ],
-    "ips": [
-      {
-        "version": "4",
-        "address": "10.0.0.2/24",
-        "gateway": "10.0.0.1",
-        "interface": 0
-      }
-    ]
-  }
-}`
-	ifname = "eth0"
-)
+const ifname = "eth0"
 
 type fakeFirewalld struct {
 	zone   string
@@ -125,6 +102,30 @@ func spawnSessionDbus(wg *sync.WaitGroup) (string, *exec.Cmd) {
 	return busAddr, cmd
 }
 
+func makeFirewalldConf(ver, ifname string, ns ns.NetNS) []byte {
+	return []byte(fmt.Sprintf(`{
+	  "cniVersion": "%s",
+	  "name": "firewalld-test",
+	  "type": "firewall",
+	  "backend": "firewalld",
+	  "zone": "trusted",
+	  "prevResult": {
+	    "cniVersion": "%s",
+	    "interfaces": [
+	      {"name": "%s", "sandbox": "%s"}
+	    ],
+	    "ips": [
+	      {
+		"version": "4",
+		"address": "10.0.0.2/24",
+		"gateway": "10.0.0.1",
+		"interface": 0
+	      }
+	    ]
+	  }
+	}`, ver, ver, ifname, ns.Path()))
+}
+
 var _ = Describe("firewalld test", func() {
 	var (
 		targetNs ns.NetNS
@@ -177,167 +178,119 @@ var _ = Describe("firewalld test", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		wg.Wait()
+
+		Expect(targetNs.Close()).To(Succeed())
+		Expect(testutils.UnmountNS(targetNs)).To(Succeed())
 	})
 
-	It("works with a 0.3.1 config", func() {
-		Expect(isFirewalldRunning()).To(BeTrue())
+	// firewall plugin requires a prevResult and thus only supports 0.3.0
+	// and later CNI versions
+	for _, ver := range []string{"0.3.0", "0.3.1", "0.4.0", "1.0.0"} {
+		// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+		// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+		ver := ver
 
-		conf := fmt.Sprintf(confTmpl, ifname, targetNs.Path())
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNs.Path(),
-			IfName:      ifname,
-			StdinData:   []byte(conf),
-		}
-		_, _, err := testutils.CmdAdd(targetNs.Path(), args.ContainerID, ifname, []byte(conf), func() error {
-			return cmdAdd(args)
+		It(fmt.Sprintf("[%s] works with a config", ver), func() {
+			Expect(isFirewalldRunning()).To(BeTrue())
+
+			conf := makeFirewalldConf(ver, ifname, targetNs)
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNs.Path(),
+				IfName:      ifname,
+				StdinData:   []byte(conf),
+			}
+			_, _, err := testutils.CmdAdd(targetNs.Path(), args.ContainerID, ifname, []byte(conf), func() error {
+				return cmdAdd(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fwd.zone).To(Equal("trusted"))
+			Expect(fwd.source).To(Equal("10.0.0.2/32"))
+			fwd.clear()
+
+			err = testutils.CmdDel(targetNs.Path(), args.ContainerID, ifname, func() error {
+				return cmdDel(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fwd.zone).To(Equal("trusted"))
+			Expect(fwd.source).To(Equal("10.0.0.2/32"))
 		})
-		Expect(err).NotTo(HaveOccurred())
-		Expect(fwd.zone).To(Equal("trusted"))
-		Expect(fwd.source).To(Equal("10.0.0.2/32"))
-		fwd.clear()
 
-		err = testutils.CmdDel(targetNs.Path(), args.ContainerID, ifname, func() error {
-			return cmdDel(args)
+		It(fmt.Sprintf("[%s] defaults to the firewalld backend", ver), func() {
+			Expect(isFirewalldRunning()).To(BeTrue())
+
+			conf := makeFirewalldConf(ver, ifname, targetNs)
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNs.Path(),
+				IfName:      ifname,
+				StdinData:   []byte(conf),
+			}
+			_, _, err := testutils.CmdAdd(targetNs.Path(), args.ContainerID, ifname, []byte(conf), func() error {
+				return cmdAdd(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fwd.zone).To(Equal("trusted"))
+			Expect(fwd.source).To(Equal("10.0.0.2/32"))
 		})
-		Expect(err).NotTo(HaveOccurred())
-		Expect(fwd.zone).To(Equal("trusted"))
-		Expect(fwd.source).To(Equal("10.0.0.2/32"))
-	})
 
-	It("defaults to the firewalld backend", func() {
-		conf := `{
-		  "cniVersion": "0.3.1",
-		  "name": "firewalld-test",
-		  "type": "firewall",
-		  "zone": "trusted",
-		  "prevResult": {
-		    "cniVersion": "0.3.0",
-		    "interfaces": [
-		      {"name": "eth0", "sandbox": "/foobar"}
-		    ],
-		    "ips": [
-		      {
-			"version": "4",
-			"address": "10.0.0.2/24",
-			"gateway": "10.0.0.1",
-			"interface": 0
-		      }
-		    ]
-		  }
-		}`
+		It(fmt.Sprintf("[%s] passes through the prevResult", ver), func() {
+			Expect(isFirewalldRunning()).To(BeTrue())
 
-		Expect(isFirewalldRunning()).To(BeTrue())
+			conf := makeFirewalldConf(ver, ifname, targetNs)
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNs.Path(),
+				IfName:      ifname,
+				StdinData:   []byte(conf),
+			}
+			r, _, err := testutils.CmdAdd(targetNs.Path(), args.ContainerID, ifname, []byte(conf), func() error {
+				return cmdAdd(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
 
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNs.Path(),
-			IfName:      ifname,
-			StdinData:   []byte(conf),
-		}
-		_, _, err := testutils.CmdAdd(targetNs.Path(), args.ContainerID, ifname, []byte(conf), func() error {
-			return cmdAdd(args)
+			result, err := current.GetResult(r)
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(len(result.Interfaces)).To(Equal(1))
+			Expect(result.Interfaces[0].Name).To(Equal("eth0"))
+			Expect(len(result.IPs)).To(Equal(1))
+			Expect(result.IPs[0].Address.String()).To(Equal("10.0.0.2/24"))
 		})
-		Expect(err).NotTo(HaveOccurred())
-		Expect(fwd.zone).To(Equal("trusted"))
-		Expect(fwd.source).To(Equal("10.0.0.2/32"))
-	})
 
-	It("passes through the prevResult", func() {
-		conf := `{
-		  "cniVersion": "0.3.1",
-		  "name": "firewalld-test",
-		  "type": "firewall",
-		  "zone": "trusted",
-		  "prevResult": {
-		    "cniVersion": "0.3.0",
-		    "interfaces": [
-		      {"name": "eth0", "sandbox": "/foobar"}
-		    ],
-		    "ips": [
-		      {
-			"version": "4",
-			"address": "10.0.0.2/24",
-			"gateway": "10.0.0.1",
-			"interface": 0
-		      }
-		    ]
-		  }
-		}`
+		It(fmt.Sprintf("[%s] works with Check", ver), func() {
+			Expect(isFirewalldRunning()).To(BeTrue())
 
-		Expect(isFirewalldRunning()).To(BeTrue())
+			conf := makeFirewalldConf(ver, ifname, targetNs)
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNs.Path(),
+				IfName:      ifname,
+				StdinData:   []byte(conf),
+			}
+			r, _, err := testutils.CmdAddWithArgs(args, func() error {
+				return cmdAdd(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fwd.zone).To(Equal("trusted"))
+			Expect(fwd.source).To(Equal("10.0.0.2/32"))
 
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNs.Path(),
-			IfName:      ifname,
-			StdinData:   []byte(conf),
-		}
-		r, _, err := testutils.CmdAdd(targetNs.Path(), args.ContainerID, ifname, []byte(conf), func() error {
-			return cmdAdd(args)
+			if testutils.SpecVersionHasCHECK(ver) {
+				_, err = current.GetResult(r)
+				Expect(err).NotTo(HaveOccurred())
+
+				err = testutils.CmdCheckWithArgs(args, func() error {
+					return cmdCheck(args)
+				})
+				Expect(err).NotTo(HaveOccurred())
+			}
+
+			err = testutils.CmdDelWithArgs(args, func() error {
+				return cmdDel(args)
+			})
+			Expect(err).NotTo(HaveOccurred())
+			Expect(fwd.zone).To(Equal("trusted"))
+			Expect(fwd.source).To(Equal("10.0.0.2/32"))
 		})
-		Expect(err).NotTo(HaveOccurred())
-
-		result, err := current.GetResult(r)
-		Expect(err).NotTo(HaveOccurred())
-
-		Expect(len(result.Interfaces)).To(Equal(1))
-		Expect(result.Interfaces[0].Name).To(Equal("eth0"))
-		Expect(len(result.IPs)).To(Equal(1))
-		Expect(result.IPs[0].Address.String()).To(Equal("10.0.0.2/24"))
-	})
-
-	It("works with a 0.4.0 config, including Check", func() {
-		Expect(isFirewalldRunning()).To(BeTrue())
-
-		conf := `{
-			  "cniVersion": "0.4.0",
-			  "name": "firewalld-test",
-			  "type": "firewall",
-			  "backend": "firewalld",
-			  "zone": "trusted",
-			  "prevResult": {
-			    "cniVersion": "0.4.0",
-			    "interfaces": [
-			      {"name": "eth0", "sandbox": "/foobar"}
-			    ],
-			    "ips": [
-			      {
-				"version": "4",
-				"address": "10.0.0.2/24",
-				"gateway": "10.0.0.1",
-				"interface": 0
-			      }
-			    ]
-			  }
-			}`
-
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNs.Path(),
-			IfName:      ifname,
-			StdinData:   []byte(conf),
-		}
-		r, _, err := testutils.CmdAddWithArgs(args, func() error {
-			return cmdAdd(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-		Expect(fwd.zone).To(Equal("trusted"))
-		Expect(fwd.source).To(Equal("10.0.0.2/32"))
-
-		_, err = current.GetResult(r)
-		Expect(err).NotTo(HaveOccurred())
-
-		err = testutils.CmdCheckWithArgs(args, func() error {
-			return cmdCheck(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-
-		err = testutils.CmdDelWithArgs(args, func() error {
-			return cmdDel(args)
-		})
-		Expect(err).NotTo(HaveOccurred())
-		Expect(fwd.zone).To(Equal("trusted"))
-		Expect(fwd.source).To(Equal("10.0.0.2/32"))
-	})
+	}
 })

plugins/meta/firewall/firewall_iptables_test.go

@@ -21,7 +21,8 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	"github.com/containernetworking/cni/pkg/types/040"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/containernetworking/plugins/pkg/testutils"
@@ -165,35 +166,38 @@ func validateCleanedUp(bytes []byte) {
 	}
 }
 
+func makeIptablesConf(ver string) []byte {
+	return []byte(fmt.Sprintf(`{
+		"name": "test",
+		"type": "firewall",
+		"backend": "iptables",
+		"ifName": "dummy0",
+		"cniVersion": "%s",
+		"prevResult": {
+			"cniVersion": "%s",
+			"interfaces": [
+				{"name": "dummy0"}
+			],
+			"ips": [
+				{
+					"version": "4",
+					"address": "10.0.0.2/24",
+					"interface": 0
+				},
+				{
+					"version": "6",
+					"address": "2001:db8:1:2::1/64",
+					"interface": 0
+				}
+			]
+		}
+	}`, ver, ver))
+}
+
 var _ = Describe("firewall plugin iptables backend", func() {
 	var originalNS, targetNS ns.NetNS
 	const IFNAME string = "dummy0"
 
-	fullConf := []byte(`{
-		"name": "test",
-		"type": "firewall",
-		"backend": "iptables",
-		"ifName": "dummy0",
-		"cniVersion": "0.3.1",
-		"prevResult": {
-			"interfaces": [
-				{"name": "dummy0"}
-			],
-			"ips": [
-				{
-					"version": "4",
-					"address": "10.0.0.2/24",
-					"interface": 0
-				},
-				{
-					"version": "6",
-					"address": "2001:db8:1:2::1/64",
-					"interface": 0
-				}
-			]
-		}
-	}`)
-
 	BeforeEach(func() {
 		// Create a new NetNS so we don't modify the host
 		var err error
@@ -224,296 +228,174 @@ var _ = Describe("firewall plugin iptables backend", func() {
 		Expect(targetNS.Close()).To(Succeed())
 	})
 
-	It("passes prevResult through unchanged", func() {
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      IFNAME,
-			StdinData:   fullConf,
-		}
+	// firewall plugin requires a prevResult and thus only supports 0.3.0
+	// and later CNI versions
+	for _, ver := range []string{"0.3.0", "0.3.1", "0.4.0", "1.0.0"} {
+		// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+		// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+		ver := ver
 
-		err := originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			r, _, err := testutils.CmdAdd(targetNS.Path(), args.ContainerID, IFNAME, fullConf, func() error {
-				return cmdAdd(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-
-			result, err := current.GetResult(r)
-			Expect(err).NotTo(HaveOccurred())
-
-			Expect(len(result.Interfaces)).To(Equal(1))
-			Expect(result.Interfaces[0].Name).To(Equal(IFNAME))
-			Expect(len(result.IPs)).To(Equal(2))
-			Expect(result.IPs[0].Address.String()).To(Equal("10.0.0.2/24"))
-			Expect(result.IPs[1].Address.String()).To(Equal("2001:db8:1:2::1/64"))
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("installs the right iptables rules on the host", func() {
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      IFNAME,
-			StdinData:   fullConf,
-		}
-
-		err := originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			_, _, err := testutils.CmdAdd(targetNS.Path(), args.ContainerID, IFNAME, fullConf, func() error {
-				return cmdAdd(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-
-			validateFullRuleset(fullConf)
-
-			// ensure creation is idempotent
-			_, _, err = testutils.CmdAdd(targetNS.Path(), args.ContainerID, IFNAME, fullConf, func() error {
-				return cmdAdd(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("correctly handles a custom IptablesAdminChainName", func() {
-		conf := []byte(`{
-	"name": "test",
-	"type": "firewall",
-	"backend": "iptables",
-	"ifName": "dummy0",
-	"cniVersion": "0.3.1",
-	"iptablesAdminChainName": "CNI-foobar",
-	"prevResult": {
-		"interfaces": [
-			{"name": "dummy0"}
-		],
-		"ips": [
-			{
-				"version": "4",
-				"address": "10.0.0.2/24",
-				"interface": 0
-			},
-			{
-				"version": "6",
-				"address": "2001:db8:1:2::1/64",
-				"interface": 0
+		It(fmt.Sprintf("[%s] passes prevResult through unchanged", ver), func() {
+			fullConf := makeIptablesConf(ver)
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      IFNAME,
+				StdinData:   fullConf,
 			}
-		]
-	}
-}`)
 
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      IFNAME,
-			StdinData:   conf,
-		}
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
 
-		err := originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
+				r, _, err := testutils.CmdAdd(targetNS.Path(), args.ContainerID, IFNAME, fullConf, func() error {
+					return cmdAdd(args)
+				})
+				Expect(err).NotTo(HaveOccurred())
 
-			_, _, err := testutils.CmdAdd(targetNS.Path(), args.ContainerID, IFNAME, conf, func() error {
-				return cmdAdd(args)
+				result, err := current.GetResult(r)
+				Expect(err).NotTo(HaveOccurred())
+
+				Expect(len(result.Interfaces)).To(Equal(1))
+				Expect(result.Interfaces[0].Name).To(Equal(IFNAME))
+				Expect(len(result.IPs)).To(Equal(2))
+				Expect(result.IPs[0].Address.String()).To(Equal("10.0.0.2/24"))
+				Expect(result.IPs[1].Address.String()).To(Equal("2001:db8:1:2::1/64"))
+				return nil
 			})
 			Expect(err).NotTo(HaveOccurred())
+		})
 
-			var ipt *iptables.IPTables
-			for _, proto := range []iptables.Protocol{iptables.ProtocolIPv4, iptables.ProtocolIPv6} {
-				ipt, err = iptables.NewWithProtocol(proto)
+		It(fmt.Sprintf("[%s] installs the right iptables rules on the host", ver), func() {
+			fullConf := makeIptablesConf(ver)
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      IFNAME,
+				StdinData:   fullConf,
+			}
+
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				_, _, err := testutils.CmdAdd(targetNS.Path(), args.ContainerID, IFNAME, fullConf, func() error {
+					return cmdAdd(args)
+				})
 				Expect(err).NotTo(HaveOccurred())
 
-				// Ensure custom admin chain name
-				chains, err := ipt.ListChains("filter")
+				validateFullRuleset(fullConf)
+
+				// ensure creation is idempotent
+				_, _, err = testutils.CmdAdd(targetNS.Path(), args.ContainerID, IFNAME, fullConf, func() error {
+					return cmdAdd(args)
+				})
 				Expect(err).NotTo(HaveOccurred())
-				var foundAdmin bool
-				for _, ch := range chains {
-					if ch == "CNI-foobar" {
-						foundAdmin = true
+
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		It(fmt.Sprintf("[%s] correctly handles a custom IptablesAdminChainName", ver), func() {
+			conf := []byte(fmt.Sprintf(`{
+				"name": "test",
+				"type": "firewall",
+				"backend": "iptables",
+				"ifName": "dummy0",
+				"cniVersion": "%s",
+				"iptablesAdminChainName": "CNI-foobar",
+				"prevResult": {
+					"cniVersion": "%s",
+					"interfaces": [
+						{"name": "dummy0"}
+					],
+					"ips": [
+						{
+							"version": "4",
+							"address": "10.0.0.2/24",
+							"interface": 0
+						},
+						{
+							"version": "6",
+							"address": "2001:db8:1:2::1/64",
+							"interface": 0
+						}
+					]
+				}
+			}`, ver, ver))
+
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      IFNAME,
+				StdinData:   conf,
+			}
+
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
+
+				_, _, err := testutils.CmdAdd(targetNS.Path(), args.ContainerID, IFNAME, conf, func() error {
+					return cmdAdd(args)
+				})
+				Expect(err).NotTo(HaveOccurred())
+
+				var ipt *iptables.IPTables
+				for _, proto := range []iptables.Protocol{iptables.ProtocolIPv4, iptables.ProtocolIPv6} {
+					ipt, err = iptables.NewWithProtocol(proto)
+					Expect(err).NotTo(HaveOccurred())
+
+					// Ensure custom admin chain name
+					chains, err := ipt.ListChains("filter")
+					Expect(err).NotTo(HaveOccurred())
+					var foundAdmin bool
+					for _, ch := range chains {
+						if ch == "CNI-foobar" {
+							foundAdmin = true
+						}
 					}
+					Expect(foundAdmin).To(Equal(true))
 				}
-				Expect(foundAdmin).To(Equal(true))
+
+				return nil
+			})
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		It(fmt.Sprintf("[%s] installs iptables rules, checks rules, then cleans up on delete", ver), func() {
+			fullConf := makeIptablesConf(ver)
+			args := &skel.CmdArgs{
+				ContainerID: "dummy",
+				Netns:       targetNS.Path(),
+				IfName:      IFNAME,
+				StdinData:   fullConf,
 			}
 
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
+			err := originalNS.Do(func(ns.NetNS) error {
+				defer GinkgoRecover()
 
-	It("cleans up on delete", func() {
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      IFNAME,
-			StdinData:   fullConf,
-		}
+				r, _, err := testutils.CmdAddWithArgs(args, func() error {
+					return cmdAdd(args)
+				})
+				Expect(err).NotTo(HaveOccurred())
 
-		err := originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
+				_, err = types040.GetResult(r)
+				Expect(err).NotTo(HaveOccurred())
 
-			_, _, err := testutils.CmdAdd(targetNS.Path(), args.ContainerID, IFNAME, fullConf, func() error {
-				return cmdAdd(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-			validateFullRuleset(fullConf)
-
-			err = testutils.CmdDel(targetNS.Path(), args.ContainerID, IFNAME, func() error {
-				return cmdDel(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-			validateCleanedUp(fullConf)
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("installs the right iptables rules on the host v4.0.x and check is successful", func() {
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      IFNAME,
-			StdinData:   fullConf,
-		}
-
-		err := originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			_, _, err := testutils.CmdAdd(targetNS.Path(), args.ContainerID, IFNAME, fullConf, func() error {
-				return cmdAdd(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-
-			validateFullRuleset(fullConf)
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	It("cleans up on delete v4.0.x", func() {
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      IFNAME,
-			StdinData:   fullConf,
-		}
-
-		err := originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			_, _, err := testutils.CmdAdd(targetNS.Path(), args.ContainerID, IFNAME, fullConf, func() error {
-				return cmdAdd(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-			validateFullRuleset(fullConf)
-
-			err = testutils.CmdDel(targetNS.Path(), args.ContainerID, IFNAME, func() error {
-				return cmdDel(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-			validateCleanedUp(fullConf)
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
-})
-
-var _ = Describe("firewall plugin iptables backend v0.4.x", func() {
-	var originalNS, targetNS ns.NetNS
-	const IFNAME string = "dummy0"
-
-	fullConf := []byte(`{
-		"name": "test",
-		"type": "firewall",
-		"backend": "iptables",
-		"ifName": "dummy0",
-		"cniVersion": "0.4.0",
-		"prevResult": {
-			"interfaces": [
-				{"name": "dummy0"}
-			],
-			"ips": [
-				{
-					"version": "4",
-					"address": "10.0.0.2/24",
-					"interface": 0
-				},
-				{
-					"version": "6",
-					"address": "2001:db8:1:2::1/64",
-					"interface": 0
+				if testutils.SpecVersionHasCHECK(ver) {
+					err = testutils.CmdCheckWithArgs(args, func() error {
+						return cmdCheck(args)
+					})
+					Expect(err).NotTo(HaveOccurred())
+					validateFullRuleset(fullConf)
 				}
-			]
-		}
-	}`)
 
-	BeforeEach(func() {
-		// Create a new NetNS so we don't modify the host
-		var err error
-		originalNS, err = testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-
-		err = originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			err = netlink.LinkAdd(&netlink.Dummy{
-				LinkAttrs: netlink.LinkAttrs{
-					Name: IFNAME,
-				},
+				err = testutils.CmdDelWithArgs(args, func() error {
+					return cmdDel(args)
+				})
+				Expect(err).NotTo(HaveOccurred())
+				validateCleanedUp(fullConf)
+				return nil
 			})
 			Expect(err).NotTo(HaveOccurred())
-			_, err = netlink.LinkByName(IFNAME)
-			Expect(err).NotTo(HaveOccurred())
-			return nil
 		})
-		Expect(err).NotTo(HaveOccurred())
-
-		targetNS, err = testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	AfterEach(func() {
-		Expect(originalNS.Close()).To(Succeed())
-		Expect(targetNS.Close()).To(Succeed())
-	})
-
-	It("installs iptables rules, Check rules then cleans up on delete using v4.0.x", func() {
-		args := &skel.CmdArgs{
-			ContainerID: "dummy",
-			Netns:       targetNS.Path(),
-			IfName:      IFNAME,
-			StdinData:   fullConf,
-		}
-
-		err := originalNS.Do(func(ns.NetNS) error {
-			defer GinkgoRecover()
-
-			r, _, err := testutils.CmdAddWithArgs(args, func() error {
-				return cmdAdd(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-
-			_, err = current.GetResult(r)
-			Expect(err).NotTo(HaveOccurred())
-
-			err = testutils.CmdCheckWithArgs(args, func() error {
-				return cmdCheck(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-			validateFullRuleset(fullConf)
-
-			err = testutils.CmdDelWithArgs(args, func() error {
-				return cmdDel(args)
-			})
-			Expect(err).NotTo(HaveOccurred())
-			validateCleanedUp(fullConf)
-			return nil
-		})
-		Expect(err).NotTo(HaveOccurred())
-	})
+	}
 })

plugins/meta/firewall/firewalld.go

@@ -18,7 +18,7 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/godbus/dbus"
 )
 

plugins/meta/firewall/iptables.go

@@ -21,7 +21,7 @@ import (
 	"fmt"
 	"net"
 
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/utils"
 	"github.com/coreos/go-iptables/iptables"
 )

plugins/meta/flannel/flannel.go

@@ -189,7 +189,7 @@ func consumeScratchNetConf(containerID, dataDir string) (func(error), []byte, er
 	return cleanup, netConfBytes, err
 }
 
-func delegateAdd(cid, dataDir string, netconf map[string]interface{}) error {
+func delegateAdd(cid, dataDir, cniVersion string, netconf map[string]interface{}) error {
 	netconfBytes, err := json.Marshal(netconf)
 	if err != nil {
 		return fmt.Errorf("error serializing delegate netconf: %v", err)
@@ -205,7 +205,7 @@ func delegateAdd(cid, dataDir string, netconf map[string]interface{}) error {
 		return err
 	}
 
-	return result.Print()
+	return types.PrintResult(result, cniVersion)
 }
 
 func hasKey(m map[string]interface{}, k string) bool {
@@ -247,7 +247,10 @@ func cmdAdd(args *skel.CmdArgs) error {
 		n.Delegate["runtimeConfig"] = n.RuntimeConfig
 	}
 
-	return doCmdAdd(args, n, fenv)
+	// Delegate CNI config version must match flannel plugin config version
+	n.Delegate["cniVersion"] = n.CNIVersion
+
+	return doCmdAdd(args, n.CNIVersion, n, fenv)
 }
 
 func cmdDel(args *skel.CmdArgs) error {

plugins/meta/flannel/flannel_linux.go

@@ -72,7 +72,7 @@ func getDelegateIPAM(n *NetConf, fenv *subnetEnv) (map[string]interface{}, error
 	return ipam, nil
 }
 
-func doCmdAdd(args *skel.CmdArgs, n *NetConf, fenv *subnetEnv) error {
+func doCmdAdd(args *skel.CmdArgs, cniVersion string, n *NetConf, fenv *subnetEnv) error {
 	n.Delegate["name"] = n.Name
 
 	if !hasKey(n.Delegate, "type") {
@@ -105,7 +105,7 @@ func doCmdAdd(args *skel.CmdArgs, n *NetConf, fenv *subnetEnv) error {
 	}
 	n.Delegate["ipam"] = ipam
 
-	return delegateAdd(args.ContainerID, n.DataDir, n.Delegate)
+	return delegateAdd(args.ContainerID, n.DataDir, cniVersion, n.Delegate)
 }
 
 func doCmdDel(args *skel.CmdArgs, n *NetConf) (err error) {

plugins/meta/flannel/flannel_linux_test.go

@@ -20,7 +20,7 @@ import (
 	"os"
 
 	"github.com/containernetworking/cni/pkg/skel"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/containernetworking/plugins/pkg/testutils"
 
@@ -31,6 +31,7 @@ import (
 var _ = Describe("Flannel", func() {
 	var (
 		originalNS          ns.NetNS
+		targetNS            ns.NetNS
 		onlyIpv4Input       string
 		onlyIpv6Input       string
 		dualStackInput      string
@@ -40,22 +41,12 @@ var _ = Describe("Flannel", func() {
 		dataDir             string
 	)
 
-	BeforeEach(func() {
-		var err error
-		originalNS, err = testutils.NewNS()
-		Expect(err).NotTo(HaveOccurred())
-	})
-
-	AfterEach(func() {
-		Expect(originalNS.Close()).To(Succeed())
-	})
-
-	const inputTemplate = `
-{
-    "name": "cni-flannel",
-    "type": "flannel",
-    "subnetFile": "%s",
-    "dataDir": "%s"%s
+	const inputTemplate = `{
+	"name": "cni-flannel",
+	"type": "flannel",
+	"cniVersion": "%s",
+	"subnetFile": "%s",
+	"dataDir": "%s"%s
 }`
 
 	const inputIPAMTemplate = `
@@ -95,6 +86,8 @@ FLANNEL_MTU=1472
 FLANNEL_IPMASQ=true
 `
 
+	const IFNAME = "eth0"
+
 	var writeSubnetEnv = func(contents string) string {
 		file, err := ioutil.TempFile("", "subnet.env")
 		Expect(err).NotTo(HaveOccurred())
@@ -114,17 +107,29 @@ FLANNEL_IPMASQ=true
 		return c
 	}
 
-	var makeInput = func(inputIPAM string, subnetFile string) string {
+	var makeInput = func(cniVersion, inputIPAM string, subnetFile string) string {
 		ipamPart := ""
 		if len(inputIPAM) > 0 {
 			ipamPart = ",\n  \"ipam\":\n" + inputIPAM
 		}
 
-		return fmt.Sprintf(inputTemplate, subnetFile, dataDir, ipamPart)
+		return fmt.Sprintf(inputTemplate, cniVersion, subnetFile, dataDir, ipamPart)
+	}
+
+	var makeHostLocalIPAM = func(dataDir string) string {
+		return fmt.Sprintf(`{
+			"type": "host-local",
+			"dataDir": "%s"
+		}`, dataDir)
 	}
 
 	BeforeEach(func() {
 		var err error
+		originalNS, err = testutils.NewNS()
+		Expect(err).NotTo(HaveOccurred())
+		targetNS, err = testutils.NewNS()
+		Expect(err).NotTo(HaveOccurred())
+
 		// flannel subnet.env
 		onlyIpv4SubnetFile = writeSubnetEnv(onlyIpv4FlannelSubnetEnv)
 		onlyIpv6SubnetFile = writeSubnetEnv(onlyIpv6FlannelSubnetEnv)
@@ -133,264 +138,274 @@ FLANNEL_IPMASQ=true
 		// flannel state dir
 		dataDir, err = ioutil.TempDir("", "dataDir")
 		Expect(err).NotTo(HaveOccurred())
-		onlyIpv4Input = makeInput("", onlyIpv4SubnetFile)
-		onlyIpv6Input = makeInput("", onlyIpv6SubnetFile)
-		dualStackInput = makeInput("", dualStackSubnetFile)
 	})
 
 	AfterEach(func() {
+		Expect(targetNS.Close()).To(Succeed())
+		Expect(testutils.UnmountNS(targetNS)).To(Succeed())
+		Expect(originalNS.Close()).To(Succeed())
+		Expect(testutils.UnmountNS(originalNS)).To(Succeed())
+
 		os.Remove(onlyIpv4SubnetFile)
 		os.Remove(onlyIpv6SubnetFile)
 		os.Remove(dualStackSubnetFile)
-		os.Remove(dataDir)
+		Expect(os.RemoveAll(dataDir)).To(Succeed())
 	})
 
 	Describe("CNI lifecycle", func() {
-		Context("when using only ipv4 stack", func() {
-			It("uses dataDir for storing network configuration with ipv4 stack", func() {
-				const IFNAME = "eth0"
+		for _, ver := range testutils.AllSpecVersions {
+			// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+			// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+			ver := ver
 
-				targetNs, err := testutils.NewNS()
-				Expect(err).NotTo(HaveOccurred())
-				defer targetNs.Close()
+			Context("when using only ipv4 stack", func() {
+				It(fmt.Sprintf("[%s] uses dataDir for storing network configuration with ipv4 stack", ver), func() {
+					inputIPAM := makeHostLocalIPAM(dataDir)
+					args := &skel.CmdArgs{
+						ContainerID: "some-container-id-ipv4",
+						Netns:       targetNS.Path(),
+						IfName:      IFNAME,
+						StdinData:   []byte(makeInput(ver, inputIPAM, onlyIpv4SubnetFile)),
+					}
 
-				args := &skel.CmdArgs{
-					ContainerID: "some-container-id-ipv4",
-					Netns:       targetNs.Path(),
-					IfName:      IFNAME,
-					StdinData:   []byte(onlyIpv4Input),
-				}
+					err := originalNS.Do(func(ns.NetNS) error {
+						defer GinkgoRecover()
 
-				err = originalNS.Do(func(ns.NetNS) error {
-					defer GinkgoRecover()
+						By("calling ADD with ipv4 stack")
+						GinkgoT().Logf("dataDir is %s", dataDir)
+						GinkgoT().Logf("conf is %s", args.StdinData)
+						resI, _, err := testutils.CmdAddWithArgs(args, func() error {
+							return cmdAdd(args)
+						})
+						Expect(err).NotTo(HaveOccurred())
 
-					By("calling ADD with ipv4 stack")
-					resI, _, err := testutils.CmdAddWithArgs(args, func() error {
-						return cmdAdd(args)
+						By("check that plugin writes the net config to dataDir with ipv4 stack")
+						path := fmt.Sprintf("%s/%s", dataDir, "some-container-id-ipv4")
+						Expect(path).Should(BeAnExistingFile())
+
+						netConfBytes, err := ioutil.ReadFile(path)
+						Expect(err).NotTo(HaveOccurred())
+						expected := fmt.Sprintf(`{
+						    "cniVersion": "%s",
+						    "ipMasq": false,
+						    "ipam": {
+							"routes": [
+							    {
+								"dst": "10.1.0.0/16"
+							    }
+							],
+							"ranges": [
+							    [{
+								"subnet": "10.1.17.0/24"
+							    }]
+							],
+							"type": "host-local",
+							"dataDir": "%s"
+						    },
+						    "isGateway": true,
+						    "mtu": 1472,
+						    "name": "cni-flannel",
+						    "type": "bridge"
+						}`, ver, dataDir)
+						Expect(netConfBytes).Should(MatchJSON(expected))
+
+						result, err := current.NewResultFromResult(resI)
+						Expect(err).NotTo(HaveOccurred())
+						Expect(result.IPs).To(HaveLen(1))
+
+						By("calling DEL with ipv4 stack")
+						err = testutils.CmdDelWithArgs(args, func() error {
+							return cmdDel(args)
+						})
+						Expect(err).NotTo(HaveOccurred())
+
+						By("check that plugin removes net config from state dir with ipv4 stack")
+						Expect(path).ShouldNot(BeAnExistingFile())
+
+						By("calling DEL again with ipv4 stack")
+						err = testutils.CmdDelWithArgs(args, func() error {
+							return cmdDel(args)
+						})
+						By("check that plugin does not fail due to missing net config with ipv4 stack")
+						Expect(err).NotTo(HaveOccurred())
+
+						return nil
 					})
 					Expect(err).NotTo(HaveOccurred())
-
-					By("check that plugin writes the net config to dataDir with ipv4 stack")
-					path := fmt.Sprintf("%s/%s", dataDir, "some-container-id-ipv4")
-					Expect(path).Should(BeAnExistingFile())
-
-					netConfBytes, err := ioutil.ReadFile(path)
-					Expect(err).NotTo(HaveOccurred())
-					expected := `{
-    "ipMasq": false,
-    "ipam": {
-        "routes": [
-            {
-                "dst": "10.1.0.0/16"
-            }
-        ],
-        "ranges": [
-            [{
-                "subnet": "10.1.17.0/24"
-            }]
-        ],
-        "type": "host-local"
-    },
-    "isGateway": true,
-    "mtu": 1472,
-    "name": "cni-flannel",
-    "type": "bridge"
-}
-`
-					Expect(netConfBytes).Should(MatchJSON(expected))
-
-					result, err := current.NewResultFromResult(resI)
-					Expect(err).NotTo(HaveOccurred())
-					Expect(result.IPs).To(HaveLen(1))
-
-					By("calling DEL with ipv4 stack")
-					err = testutils.CmdDelWithArgs(args, func() error {
-						return cmdDel(args)
-					})
-					Expect(err).NotTo(HaveOccurred())
-
-					By("check that plugin removes net config from state dir with ipv4 stack")
-					Expect(path).ShouldNot(BeAnExistingFile())
-
-					By("calling DEL again with ipv4 stack")
-					err = testutils.CmdDelWithArgs(args, func() error {
-						return cmdDel(args)
-					})
-					By("check that plugin does not fail due to missing net config with ipv4 stack")
-					Expect(err).NotTo(HaveOccurred())
-
-					return nil
 				})
-				Expect(err).NotTo(HaveOccurred())
 			})
-		})
 
-		Context("when using only ipv6 stack", func() {
-			It("uses dataDir for storing network configuration with ipv6 stack", func() {
-				const IFNAME = "eth0"
+			Context("when using only ipv6 stack", func() {
+				It(fmt.Sprintf("[%s] uses dataDir for storing network configuration with ipv6 stack", ver), func() {
+					inputIPAM := makeHostLocalIPAM(dataDir)
+					args := &skel.CmdArgs{
+						ContainerID: "some-container-id-ipv6",
+						Netns:       targetNS.Path(),
+						IfName:      IFNAME,
+						StdinData:   []byte(makeInput(ver, inputIPAM, onlyIpv6SubnetFile)),
+					}
 
-				targetNs, err := testutils.NewNS()
-				Expect(err).NotTo(HaveOccurred())
-				defer targetNs.Close()
+					err := originalNS.Do(func(ns.NetNS) error {
+						defer GinkgoRecover()
 
-				args := &skel.CmdArgs{
-					ContainerID: "some-container-id-ipv6",
-					Netns:       targetNs.Path(),
-					IfName:      IFNAME,
-					StdinData:   []byte(onlyIpv6Input),
-				}
+						By("calling ADD with ipv6 stack")
+						resI, _, err := testutils.CmdAddWithArgs(args, func() error {
+							return cmdAdd(args)
+						})
+						Expect(err).NotTo(HaveOccurred())
 
-				err = originalNS.Do(func(ns.NetNS) error {
-					defer GinkgoRecover()
+						By("check that plugin writes the net config to dataDir with ipv6 stack")
+						path := fmt.Sprintf("%s/%s", dataDir, "some-container-id-ipv6")
+						Expect(path).Should(BeAnExistingFile())
 
-					By("calling ADD with ipv6 stack")
-					resI, _, err := testutils.CmdAddWithArgs(args, func() error {
-						return cmdAdd(args)
+						netConfBytes, err := ioutil.ReadFile(path)
+						Expect(err).NotTo(HaveOccurred())
+						expected := fmt.Sprintf(`{
+						    "cniVersion": "%s",
+						    "ipMasq": false,
+						    "ipam": {
+							"routes": [
+							    {
+								"dst": "fc00::/48"
+							    }
+							],
+							"ranges": [
+							    [{
+								"subnet": "fc00::/64"
+							    }]
+							],
+							"type": "host-local",
+							"dataDir": "%s"
+						    },
+						    "isGateway": true,
+						    "mtu": 1472,
+						    "name": "cni-flannel",
+						    "type": "bridge"
+						}`, ver, dataDir)
+						Expect(netConfBytes).Should(MatchJSON(expected))
+
+						result, err := current.NewResultFromResult(resI)
+						Expect(err).NotTo(HaveOccurred())
+						Expect(result.IPs).To(HaveLen(1))
+
+						By("calling DEL with ipv6 stack")
+						err = testutils.CmdDelWithArgs(args, func() error {
+							return cmdDel(args)
+						})
+						Expect(err).NotTo(HaveOccurred())
+
+						By("check that plugin removes net config from state dir with ipv6 stack")
+						Expect(path).ShouldNot(BeAnExistingFile())
+
+						By("calling DEL again with ipv6 stack")
+						err = testutils.CmdDelWithArgs(args, func() error {
+							return cmdDel(args)
+						})
+						By("check that plugin does not fail due to missing net config with ipv6 stack")
+						Expect(err).NotTo(HaveOccurred())
+
+						return nil
 					})
 					Expect(err).NotTo(HaveOccurred())
-
-					By("check that plugin writes the net config to dataDir with ipv6 stack")
-					path := fmt.Sprintf("%s/%s", dataDir, "some-container-id-ipv6")
-					Expect(path).Should(BeAnExistingFile())
-
-					netConfBytes, err := ioutil.ReadFile(path)
-					Expect(err).NotTo(HaveOccurred())
-					expected := `{
-    "ipMasq": false,
-    "ipam": {
-        "routes": [
-            {
-                "dst": "fc00::/48"
-            }
-        ],
-        "ranges": [
-            [{
-                "subnet": "fc00::/64"
-            }]
-        ],
-        "type": "host-local"
-    },
-    "isGateway": true,
-    "mtu": 1472,
-    "name": "cni-flannel",
-    "type": "bridge"
-}
-`
-					Expect(netConfBytes).Should(MatchJSON(expected))
-
-					result, err := current.NewResultFromResult(resI)
-					Expect(err).NotTo(HaveOccurred())
-					Expect(result.IPs).To(HaveLen(1))
-
-					By("calling DEL with ipv6 stack")
-					err = testutils.CmdDelWithArgs(args, func() error {
-						return cmdDel(args)
-					})
-					Expect(err).NotTo(HaveOccurred())
-
-					By("check that plugin removes net config from state dir with ipv6 stack")
-					Expect(path).ShouldNot(BeAnExistingFile())
-
-					By("calling DEL again with ipv6 stack")
-					err = testutils.CmdDelWithArgs(args, func() error {
-						return cmdDel(args)
-					})
-					By("check that plugin does not fail due to missing net config with ipv6 stack")
-					Expect(err).NotTo(HaveOccurred())
-
-					return nil
 				})
-				Expect(err).NotTo(HaveOccurred())
 			})
-		})
 
-		Context("when using dual stack", func() {
-			It("uses dataDir for storing network configuration with dual stack", func() {
-				const IFNAME = "eth0"
+			Context("when using dual stack", func() {
+				It(fmt.Sprintf("[%s] uses dataDir for storing network configuration with dual stack", ver), func() {
+					inputIPAM := makeHostLocalIPAM(dataDir)
+					args := &skel.CmdArgs{
+						ContainerID: "some-container-id-dual-stack",
+						Netns:       targetNS.Path(),
+						IfName:      IFNAME,
+						StdinData:   []byte(makeInput(ver, inputIPAM, dualStackSubnetFile)),
+					}
 
-				targetNs, err := testutils.NewNS()
-				Expect(err).NotTo(HaveOccurred())
-				defer targetNs.Close()
+					err := originalNS.Do(func(ns.NetNS) error {
+						defer GinkgoRecover()
 
-				args := &skel.CmdArgs{
-					ContainerID: "some-container-id-dual-stack",
-					Netns:       targetNs.Path(),
-					IfName:      IFNAME,
-					StdinData:   []byte(dualStackInput),
-				}
+						By("calling ADD with dual stack")
+						resI, _, err := testutils.CmdAddWithArgs(args, func() error {
+							return cmdAdd(args)
+						})
+						Expect(err).NotTo(HaveOccurred())
 
-				err = originalNS.Do(func(ns.NetNS) error {
-					defer GinkgoRecover()
+						By("check that plugin writes the net config to dataDir with dual stack")
+						path := fmt.Sprintf("%s/%s", dataDir, "some-container-id-dual-stack")
+						Expect(path).Should(BeAnExistingFile())
 
-					By("calling ADD with dual stack")
-					resI, _, err := testutils.CmdAddWithArgs(args, func() error {
-						return cmdAdd(args)
+						netConfBytes, err := ioutil.ReadFile(path)
+						Expect(err).NotTo(HaveOccurred())
+						expected := fmt.Sprintf(`{
+						    "cniVersion": "%s",
+						    "ipMasq": false,
+						    "ipam": {
+							"routes": [
+							    {
+								"dst": "10.1.0.0/16"
+							    },
+							    {
+								"dst": "fc00::/48"
+							    }
+							],
+							"ranges": [
+							    [{
+								"subnet": "10.1.17.0/24"
+							    }],
+							    [{
+								"subnet": "fc00::/64"
+							    }]
+							],
+							"type": "host-local",
+							"dataDir": "%s"
+						    },
+						    "isGateway": true,
+						    "mtu": 1472,
+						    "name": "cni-flannel",
+						    "type": "bridge"
+						}`, ver, dataDir)
+						Expect(netConfBytes).Should(MatchJSON(expected))
+
+						result, err := current.NewResultFromResult(resI)
+						Expect(err).NotTo(HaveOccurred())
+						Expect(result.IPs).To(HaveLen(2))
+
+						By("calling DEL with dual stack")
+						err = testutils.CmdDelWithArgs(args, func() error {
+							return cmdDel(args)
+						})
+						Expect(err).NotTo(HaveOccurred())
+
+						By("check that plugin removes net config from state dir with dual stack")
+						Expect(path).ShouldNot(BeAnExistingFile())
+
+						By("calling DEL again with dual stack")
+						err = testutils.CmdDelWithArgs(args, func() error {
+							return cmdDel(args)
+						})
+						By("check that plugin does not fail due to missing net config with dual stack")
+						Expect(err).NotTo(HaveOccurred())
+
+						return nil
 					})
 					Expect(err).NotTo(HaveOccurred())
-
-					By("check that plugin writes the net config to dataDir with dual stack")
-					path := fmt.Sprintf("%s/%s", dataDir, "some-container-id-dual-stack")
-					Expect(path).Should(BeAnExistingFile())
-
-					netConfBytes, err := ioutil.ReadFile(path)
-					Expect(err).NotTo(HaveOccurred())
-					expected := `{
-    "ipMasq": false,
-    "ipam": {
-        "routes": [
-            {
-                "dst": "10.1.0.0/16"
-            },
-            {
-                "dst": "fc00::/48"
-            }
-        ],
-        "ranges": [
-            [{
-                "subnet": "10.1.17.0/24"
-            }],
-            [{
-                "subnet": "fc00::/64"
-            }]
-        ],
-        "type": "host-local"
-    },
-    "isGateway": true,
-    "mtu": 1472,
-    "name": "cni-flannel",
-    "type": "bridge"
-}
-`
-					Expect(netConfBytes).Should(MatchJSON(expected))
-
-					result, err := current.NewResultFromResult(resI)
-					Expect(err).NotTo(HaveOccurred())
-					Expect(result.IPs).To(HaveLen(2))
-
-					By("calling DEL with dual stack")
-					err = testutils.CmdDelWithArgs(args, func() error {
-						return cmdDel(args)
-					})
-					Expect(err).NotTo(HaveOccurred())
-
-					By("check that plugin removes net config from state dir with dual stack")
-					Expect(path).ShouldNot(BeAnExistingFile())
-
-					By("calling DEL again with dual stack")
-					err = testutils.CmdDelWithArgs(args, func() error {
-						return cmdDel(args)
-					})
-					By("check that plugin does not fail due to missing net config with dual stack")
-					Expect(err).NotTo(HaveOccurred())
-
-					return nil
 				})
-				Expect(err).NotTo(HaveOccurred())
 			})
-		})
+		}
 	})
 
 	Describe("loadFlannelNetConf", func() {
+		var (
+			onlyIpv4Input  string
+			onlyIpv6Input  string
+			dualStackInput string
+		)
+
+		BeforeEach(func() {
+			onlyIpv4Input = makeInput(current.ImplementedSpecVersion, "", onlyIpv4SubnetFile)
+			onlyIpv6Input = makeInput(current.ImplementedSpecVersion, "", onlyIpv6SubnetFile)
+			dualStackInput = makeInput(current.ImplementedSpecVersion, "", dualStackSubnetFile)
+		})
+
 		Context("when subnetFile and dataDir are specified with ipv4 stack", func() {
 			It("loads flannel network config with ipv4 stack", func() {
 				conf, err := loadFlannelNetConf([]byte(onlyIpv4Input))
@@ -553,7 +568,7 @@ FLANNEL_IPMASQ=true
 		Context("when input IPAM is provided with ipv4 stack", func() {
 			BeforeEach(func() {
 				inputIPAM := makeInputIPAM(inputIPAMType, inputIPAMRoutes, "")
-				onlyIpv4Input = makeInput(inputIPAM, onlyIpv4SubnetFile)
+				onlyIpv4Input = makeInput(current.ImplementedSpecVersion, inputIPAM, onlyIpv4SubnetFile)
 			})
 			It("configures Delegate IPAM accordingly with ipv4 stack", func() {
 				conf, err := loadFlannelNetConf([]byte(onlyIpv4Input))
@@ -575,7 +590,7 @@ FLANNEL_IPMASQ=true
 		Context("when input IPAM is provided with ipv6 stack", func() {
 			BeforeEach(func() {
 				inputIPAM := makeInputIPAM(inputIPAMType, inputIPAMRoutes, "")
-				onlyIpv6Input = makeInput(inputIPAM, onlyIpv6SubnetFile)
+				onlyIpv6Input = makeInput(current.ImplementedSpecVersion, inputIPAM, onlyIpv6SubnetFile)
 			})
 			It("configures Delegate IPAM accordingly with ipv6 stack", func() {
 				conf, err := loadFlannelNetConf([]byte(onlyIpv6Input))
@@ -597,7 +612,7 @@ FLANNEL_IPMASQ=true
 		Context("when input IPAM is provided with dual stack", func() {
 			BeforeEach(func() {
 				inputIPAM := makeInputIPAM(inputIPAMType, inputIPAMRoutes, "")
-				dualStackInput = makeInput(inputIPAM, dualStackSubnetFile)
+				dualStackInput = makeInput(current.ImplementedSpecVersion, inputIPAM, dualStackSubnetFile)
 			})
 			It("configures Delegate IPAM accordingly with dual stack", func() {
 				conf, err := loadFlannelNetConf([]byte(dualStackInput))
@@ -619,7 +634,7 @@ FLANNEL_IPMASQ=true
 		Context("when input IPAM is provided without 'type' with ipv4 stack", func() {
 			BeforeEach(func() {
 				inputIPAM := makeInputIPAM("", inputIPAMRoutes, "")
-				onlyIpv4Input = makeInput(inputIPAM, onlyIpv4SubnetFile)
+				onlyIpv4Input = makeInput(current.ImplementedSpecVersion, inputIPAM, onlyIpv4SubnetFile)
 			})
 			It("configures Delegate IPAM with 'host-local' ipam with ipv4 stack", func() {
 				conf, err := loadFlannelNetConf([]byte(onlyIpv4Input))
@@ -640,7 +655,7 @@ FLANNEL_IPMASQ=true
 		Context("when input IPAM is provided without 'type' with ipv6 stack", func() {
 			BeforeEach(func() {
 				inputIPAM := makeInputIPAM("", inputIPAMRoutes, "")
-				onlyIpv6Input = makeInput(inputIPAM, onlyIpv6SubnetFile)
+				onlyIpv6Input = makeInput(current.ImplementedSpecVersion, inputIPAM, onlyIpv6SubnetFile)
 			})
 			It("configures Delegate IPAM with 'host-local' ipam with ipv6 stack", func() {
 				conf, err := loadFlannelNetConf([]byte(onlyIpv6Input))
@@ -661,7 +676,7 @@ FLANNEL_IPMASQ=true
 		Context("when input IPAM is provided without 'type' with dual stack", func() {
 			BeforeEach(func() {
 				inputIPAM := makeInputIPAM("", inputIPAMRoutes, "")
-				dualStackInput = makeInput(inputIPAM, dualStackSubnetFile)
+				dualStackInput = makeInput(current.ImplementedSpecVersion, inputIPAM, dualStackSubnetFile)
 			})
 			It("configures Delegate IPAM with 'host-local' ipam with dual stack", func() {
 				conf, err := loadFlannelNetConf([]byte(dualStackInput))

plugins/meta/flannel/flannel_windows.go

@@ -30,7 +30,7 @@ import (
 	"os"
 )
 
-func doCmdAdd(args *skel.CmdArgs, n *NetConf, fenv *subnetEnv) error {
+func doCmdAdd(args *skel.CmdArgs, cniVersion string, n *NetConf, fenv *subnetEnv) error {
 	n.Delegate["name"] = n.Name
 
 	if !hasKey(n.Delegate, "type") {
@@ -52,7 +52,8 @@ func doCmdAdd(args *skel.CmdArgs, n *NetConf, fenv *subnetEnv) error {
 		"subnet": fenv.sn.String(),
 	}
 
-	return delegateAdd(hns.GetSandboxContainerID(args.ContainerID, args.Netns), n.DataDir, n.Delegate)
+	sandboxID := hns.GetSandboxContainerID(args.ContainerID, args.Netns)
+	return delegateAdd(sandboxID, n.DataDir, cniVersion, n.Delegate)
 }
 
 func doCmdDel(args *skel.CmdArgs, n *NetConf) (err error) {

plugins/meta/portmap/main.go

@@ -33,7 +33,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 	"golang.org/x/sys/unix"
 
@@ -223,9 +223,10 @@ func parseConfig(stdin []byte, ifName string) (*PortMapConf, *current.Result, er
 
 	if conf.PrevResult != nil {
 		for _, ip := range result.IPs {
-			if ip.Version == "6" && conf.ContIPv6.IP != nil {
+			isIPv4 := ip.Address.IP.To4() != nil
+			if !isIPv4 && conf.ContIPv6.IP != nil {
 				continue
-			} else if ip.Version == "4" && conf.ContIPv4.IP != nil {
+			} else if isIPv4 && conf.ContIPv4.IP != nil {
 				continue
 			}
 
@@ -239,11 +240,10 @@ func parseConfig(stdin []byte, ifName string) (*PortMapConf, *current.Result, er
 					continue
 				}
 			}
-			switch ip.Version {
-			case "6":
-				conf.ContIPv6 = ip.Address
-			case "4":
+			if ip.Address.IP.To4() != nil {
 				conf.ContIPv4 = ip.Address
+			} else {
+				conf.ContIPv6 = ip.Address
 			}
 		}
 	}

plugins/meta/portmap/portmap_integ_test.go

@@ -25,7 +25,7 @@ import (
 	"path/filepath"
 
 	"github.com/containernetworking/cni/libcni"
-	"github.com/containernetworking/cni/pkg/types/current"
+	"github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/containernetworking/plugins/pkg/testutils"
 	"github.com/coreos/go-iptables/iptables"
@@ -37,9 +37,36 @@ import (
 
 const TIMEOUT = 90
 
+func makeConfig(ver string) *libcni.NetworkConfigList {
+	configList, err := libcni.ConfListFromBytes([]byte(fmt.Sprintf(`{
+		"cniVersion": "%s",
+		"name": "cni-portmap-unit-test",
+		"plugins": [
+			{
+				"type": "ptp",
+				"ipMasq": true,
+				"ipam": {
+					"type": "host-local",
+					"subnet": "172.16.31.0/24",
+					"routes": [
+						{"dst": "0.0.0.0/0"}
+					]
+				}
+			},
+			{
+				"type": "portmap",
+				"capabilities": {
+					"portMappings": true
+				}
+			}
+		]
+	}`, ver)))
+	Expect(err).NotTo(HaveOccurred())
+	return configList
+}
+
 var _ = Describe("portmap integration tests", func() {
 	var (
-		configList    *libcni.NetworkConfigList
 		cniConf       *libcni.CNIConfig
 		targetNS      ns.NetNS
 		containerPort int
@@ -47,38 +74,11 @@ var _ = Describe("portmap integration tests", func() {
 	)
 
 	BeforeEach(func() {
-		var err error
-		rawConfig := `{
-	"cniVersion": "0.3.0",
-	"name": "cni-portmap-unit-test",
-	"plugins": [
-		{
-			"type": "ptp",
-			"ipMasq": true,
-			"ipam": {
-				"type": "host-local",
-				"subnet": "172.16.31.0/24",
-				"routes": [
-					{"dst": "0.0.0.0/0"}
-				]
-			}
-		},
-		{
-			"type": "portmap",
-			"capabilities": {
-				"portMappings": true
-			}
-		}
-	]
-}`
-
-		configList, err = libcni.ConfListFromBytes([]byte(rawConfig))
-		Expect(err).NotTo(HaveOccurred())
-
 		// turn PATH in to CNI_PATH
 		dirs := filepath.SplitList(os.Getenv("PATH"))
 		cniConf = &libcni.CNIConfig{Path: dirs}
 
+		var err error
 		targetNS, err = testutils.NewNS()
 		Expect(err).NotTo(HaveOccurred())
 		fmt.Fprintln(GinkgoWriter, "namespace:", targetNS.Path())
@@ -90,333 +90,340 @@ var _ = Describe("portmap integration tests", func() {
 
 	AfterEach(func() {
 		session.Terminate().Wait()
-		if targetNS != nil {
-			targetNS.Close()
-		}
+		targetNS.Close()
+		testutils.UnmountNS(targetNS)
 	})
 
-	Describe("Creating an interface in a namespace with the ptp plugin", func() {
-		// This needs to be done using Ginkgo's asynchronous testing mode.
-		It("forwards a TCP port on ipv4", func(done Done) {
-			var err error
-			hostPort := rand.Intn(10000) + 1025
-			runtimeConfig := libcni.RuntimeConf{
-				ContainerID: fmt.Sprintf("unit-test-%d", hostPort),
-				NetNS:       targetNS.Path(),
-				IfName:      "eth0",
-				CapabilityArgs: map[string]interface{}{
-					"portMappings": []map[string]interface{}{
-						{
-							"hostPort":      hostPort,
-							"containerPort": containerPort,
-							"protocol":      "tcp",
+	for _, ver := range []string{"0.3.0", "0.3.1", "0.4.0", "1.0.0"} {
+		// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+		// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+		ver := ver
+
+		Describe("Creating an interface in a namespace with the ptp plugin", func() {
+			// This needs to be done using Ginkgo's asynchronous testing mode.
+			It(fmt.Sprintf("[%s] forwards a TCP port on ipv4", ver), func(done Done) {
+				var err error
+				hostPort := rand.Intn(10000) + 1025
+				runtimeConfig := libcni.RuntimeConf{
+					ContainerID: fmt.Sprintf("unit-test-%d", hostPort),
+					NetNS:       targetNS.Path(),
+					IfName:      "eth0",
+					CapabilityArgs: map[string]interface{}{
+						"portMappings": []map[string]interface{}{
+							{
+								"hostPort":      hostPort,
+								"containerPort": containerPort,
+								"protocol":      "tcp",
+							},
 						},
 					},
-				},
-			}
-
-			// Make delete idempotent, so we can clean up on failure
-			netDeleted := false
-			deleteNetwork := func() error {
-				if netDeleted {
-					return nil
 				}
-				netDeleted = true
-				return cniConf.DelNetworkList(context.TODO(), configList, &runtimeConfig)
-			}
+				configList := makeConfig(ver)
 
-			// we'll also manually check the iptables chains
-			ipt, err := iptables.NewWithProtocol(iptables.ProtocolIPv4)
-			Expect(err).NotTo(HaveOccurred())
-			dnatChainName := genDnatChain("cni-portmap-unit-test", runtimeConfig.ContainerID).name
-
-			// Create the network
-			resI, err := cniConf.AddNetworkList(context.TODO(), configList, &runtimeConfig)
-			Expect(err).NotTo(HaveOccurred())
-			defer deleteNetwork()
-
-			// Undo Docker's forwarding policy
-			cmd := exec.Command("iptables", "-t", "filter",
-				"-P", "FORWARD", "ACCEPT")
-			cmd.Stderr = GinkgoWriter
-			err = cmd.Run()
-			Expect(err).NotTo(HaveOccurred())
-
-			// Check the chain exists
-			_, err = ipt.List("nat", dnatChainName)
-			Expect(err).NotTo(HaveOccurred())
-
-			result, err := current.GetResult(resI)
-			Expect(err).NotTo(HaveOccurred())
-			var contIP net.IP
-
-			for _, ip := range result.IPs {
-				intfIndex := *ip.Interface
-				if result.Interfaces[intfIndex].Sandbox == "" {
-					continue
+				// Make delete idempotent, so we can clean up on failure
+				netDeleted := false
+				deleteNetwork := func() error {
+					if netDeleted {
+						return nil
+					}
+					netDeleted = true
+					return cniConf.DelNetworkList(context.TODO(), configList, &runtimeConfig)
 				}
-				contIP = ip.Address.IP
-			}
-			if contIP == nil {
-				Fail("could not determine container IP")
-			}
 
-			hostIP := getLocalIP()
-			fmt.Fprintf(GinkgoWriter, "hostIP: %s:%d, contIP: %s:%d\n",
-				hostIP, hostPort, contIP, containerPort)
+				// we'll also manually check the iptables chains
+				ipt, err := iptables.NewWithProtocol(iptables.ProtocolIPv4)
+				Expect(err).NotTo(HaveOccurred())
+				dnatChainName := genDnatChain("cni-portmap-unit-test", runtimeConfig.ContainerID).name
 
-			// dump iptables-save output for debugging
-			cmd = exec.Command("iptables-save")
-			cmd.Stderr = GinkgoWriter
-			cmd.Stdout = GinkgoWriter
-			Expect(cmd.Run()).To(Succeed())
+				// Create the network
+				resI, err := cniConf.AddNetworkList(context.TODO(), configList, &runtimeConfig)
+				Expect(err).NotTo(HaveOccurred())
+				defer deleteNetwork()
 
-			// dump ip routes output for debugging
-			cmd = exec.Command("ip", "route")
-			cmd.Stderr = GinkgoWriter
-			cmd.Stdout = GinkgoWriter
-			Expect(cmd.Run()).To(Succeed())
+				// Undo Docker's forwarding policy
+				cmd := exec.Command("iptables", "-t", "filter",
+					"-P", "FORWARD", "ACCEPT")
+				cmd.Stderr = GinkgoWriter
+				err = cmd.Run()
+				Expect(err).NotTo(HaveOccurred())
 
-			// dump ip addresses output for debugging
-			cmd = exec.Command("ip", "addr")
-			cmd.Stderr = GinkgoWriter
-			cmd.Stdout = GinkgoWriter
-			Expect(cmd.Run()).To(Succeed())
+				// Check the chain exists
+				_, err = ipt.List("nat", dnatChainName)
+				Expect(err).NotTo(HaveOccurred())
 
-			// Sanity check: verify that the container is reachable directly
-			contOK := testEchoServer(contIP.String(), "tcp", containerPort, "")
+				result, err := types100.GetResult(resI)
+				Expect(err).NotTo(HaveOccurred())
+				var contIP net.IP
 
-			// Verify that a connection to the forwarded port works
-			dnatOK := testEchoServer(hostIP, "tcp", hostPort, "")
+				for _, ip := range result.IPs {
+					intfIndex := *ip.Interface
+					if result.Interfaces[intfIndex].Sandbox == "" {
+						continue
+					}
+					contIP = ip.Address.IP
+				}
+				if contIP == nil {
+					Fail("could not determine container IP")
+				}
 
-			// Verify that a connection to localhost works
-			snatOK := testEchoServer("127.0.0.1", "tcp", hostPort, "")
+				hostIP := getLocalIP()
+				fmt.Fprintf(GinkgoWriter, "hostIP: %s:%d, contIP: %s:%d\n",
+					hostIP, hostPort, contIP, containerPort)
 
-			// verify that hairpin works
-			hairpinOK := testEchoServer(hostIP, "tcp", hostPort, targetNS.Path())
+				// dump iptables-save output for debugging
+				cmd = exec.Command("iptables-save")
+				cmd.Stderr = GinkgoWriter
+				cmd.Stdout = GinkgoWriter
+				Expect(cmd.Run()).To(Succeed())
 
-			// Cleanup
-			session.Terminate()
-			err = deleteNetwork()
-			Expect(err).NotTo(HaveOccurred())
+				// dump ip routes output for debugging
+				cmd = exec.Command("ip", "route")
+				cmd.Stderr = GinkgoWriter
+				cmd.Stdout = GinkgoWriter
+				Expect(cmd.Run()).To(Succeed())
 
-			// Verify iptables rules are gone
-			_, err = ipt.List("nat", dnatChainName)
-			Expect(err).To(MatchError(ContainSubstring("iptables: No chain/target/match by that name.")))
+				// dump ip addresses output for debugging
+				cmd = exec.Command("ip", "addr")
+				cmd.Stderr = GinkgoWriter
+				cmd.Stdout = GinkgoWriter
+				Expect(cmd.Run()).To(Succeed())
 
-			// Check that everything succeeded *after* we clean up the network
-			if !contOK {
-				Fail("connection direct to " + contIP.String() + " failed")
-			}
-			if !dnatOK {
-				Fail("Connection to " + hostIP + " was not forwarded")
-			}
-			if !snatOK {
-				Fail("connection to 127.0.0.1 was not forwarded")
-			}
-			if !hairpinOK {
-				Fail("Hairpin connection failed")
-			}
+				// Sanity check: verify that the container is reachable directly
+				contOK := testEchoServer(contIP.String(), "tcp", containerPort, "")
 
-			close(done)
-		}, TIMEOUT*9)
+				// Verify that a connection to the forwarded port works
+				dnatOK := testEchoServer(hostIP, "tcp", hostPort, "")
 
-		It("forwards a UDP port on ipv4 and keep working after creating a second container with the same HostPort", func(done Done) {
-			var err error
-			hostPort := rand.Intn(10000) + 1025
-			runtimeConfig := libcni.RuntimeConf{
-				ContainerID: fmt.Sprintf("unit-test-%d", hostPort),
-				NetNS:       targetNS.Path(),
-				IfName:      "eth0",
-				CapabilityArgs: map[string]interface{}{
-					"portMappings": []map[string]interface{}{
-						{
-							"hostPort":      hostPort,
-							"containerPort": containerPort,
-							"protocol":      "udp",
+				// Verify that a connection to localhost works
+				snatOK := testEchoServer("127.0.0.1", "tcp", hostPort, "")
+
+				// verify that hairpin works
+				hairpinOK := testEchoServer(hostIP, "tcp", hostPort, targetNS.Path())
+
+				// Cleanup
+				session.Terminate()
+				err = deleteNetwork()
+				Expect(err).NotTo(HaveOccurred())
+
+				// Verify iptables rules are gone
+				_, err = ipt.List("nat", dnatChainName)
+				Expect(err).To(MatchError(ContainSubstring("iptables: No chain/target/match by that name.")))
+
+				// Check that everything succeeded *after* we clean up the network
+				if !contOK {
+					Fail("connection direct to " + contIP.String() + " failed")
+				}
+				if !dnatOK {
+					Fail("Connection to " + hostIP + " was not forwarded")
+				}
+				if !snatOK {
+					Fail("connection to 127.0.0.1 was not forwarded")
+				}
+				if !hairpinOK {
+					Fail("Hairpin connection failed")
+				}
+
+				close(done)
+			}, TIMEOUT*9)
+
+			It(fmt.Sprintf("[%s] forwards a UDP port on ipv4 and keep working after creating a second container with the same HostPort", ver), func(done Done) {
+				var err error
+				hostPort := rand.Intn(10000) + 1025
+				runtimeConfig := libcni.RuntimeConf{
+					ContainerID: fmt.Sprintf("unit-test-%d", hostPort),
+					NetNS:       targetNS.Path(),
+					IfName:      "eth0",
+					CapabilityArgs: map[string]interface{}{
+						"portMappings": []map[string]interface{}{
+							{
+								"hostPort":      hostPort,
+								"containerPort": containerPort,
+								"protocol":      "udp",
+							},
 						},
 					},
-				},
-			}
-
-			// Make delete idempotent, so we can clean up on failure
-			netDeleted := false
-			deleteNetwork := func() error {
-				if netDeleted {
-					return nil
 				}
-				netDeleted = true
-				return cniConf.DelNetworkList(context.TODO(), configList, &runtimeConfig)
-			}
+				configList := makeConfig(ver)
 
-			// Create the network
-			resI, err := cniConf.AddNetworkList(context.TODO(), configList, &runtimeConfig)
-			Expect(err).NotTo(HaveOccurred())
-			defer deleteNetwork()
-
-			// Undo Docker's forwarding policy
-			cmd := exec.Command("iptables", "-t", "filter",
-				"-P", "FORWARD", "ACCEPT")
-			cmd.Stderr = GinkgoWriter
-			err = cmd.Run()
-			Expect(err).NotTo(HaveOccurred())
-
-			result, err := current.GetResult(resI)
-			Expect(err).NotTo(HaveOccurred())
-			var contIP net.IP
-
-			for _, ip := range result.IPs {
-				intfIndex := *ip.Interface
-				if result.Interfaces[intfIndex].Sandbox == "" {
-					continue
+				// Make delete idempotent, so we can clean up on failure
+				netDeleted := false
+				deleteNetwork := func() error {
+					if netDeleted {
+						return nil
+					}
+					netDeleted = true
+					return cniConf.DelNetworkList(context.TODO(), configList, &runtimeConfig)
 				}
-				contIP = ip.Address.IP
-			}
-			if contIP == nil {
-				Fail("could not determine container IP")
-			}
 
-			hostIP := getLocalIP()
-			fmt.Fprintf(GinkgoWriter, "First container hostIP: %s:%d, contIP: %s:%d\n",
-				hostIP, hostPort, contIP, containerPort)
+				// Create the network
+				resI, err := cniConf.AddNetworkList(context.TODO(), configList, &runtimeConfig)
+				Expect(err).NotTo(HaveOccurred())
+				defer deleteNetwork()
 
-			// dump iptables-save output for debugging
-			cmd = exec.Command("iptables-save")
-			cmd.Stderr = GinkgoWriter
-			cmd.Stdout = GinkgoWriter
-			Expect(cmd.Run()).To(Succeed())
+				// Undo Docker's forwarding policy
+				cmd := exec.Command("iptables", "-t", "filter",
+					"-P", "FORWARD", "ACCEPT")
+				cmd.Stderr = GinkgoWriter
+				err = cmd.Run()
+				Expect(err).NotTo(HaveOccurred())
 
-			// dump ip routes output for debugging
-			cmd = exec.Command("ip", "route")
-			cmd.Stderr = GinkgoWriter
-			cmd.Stdout = GinkgoWriter
-			Expect(cmd.Run()).To(Succeed())
+				result, err := types100.GetResult(resI)
+				Expect(err).NotTo(HaveOccurred())
+				var contIP net.IP
 
-			// dump ip addresses output for debugging
-			cmd = exec.Command("ip", "addr")
-			cmd.Stderr = GinkgoWriter
-			cmd.Stdout = GinkgoWriter
-			Expect(cmd.Run()).To(Succeed())
+				for _, ip := range result.IPs {
+					intfIndex := *ip.Interface
+					if result.Interfaces[intfIndex].Sandbox == "" {
+						continue
+					}
+					contIP = ip.Address.IP
+				}
+				if contIP == nil {
+					Fail("could not determine container IP")
+				}
 
-			// Sanity check: verify that the container is reachable directly
-			fmt.Fprintln(GinkgoWriter, "Connect to container:", contIP.String(), containerPort)
-			contOK := testEchoServer(contIP.String(), "udp", containerPort, "")
+				hostIP := getLocalIP()
+				fmt.Fprintf(GinkgoWriter, "First container hostIP: %s:%d, contIP: %s:%d\n",
+					hostIP, hostPort, contIP, containerPort)
 
-			// Verify that a connection to the forwarded port works
-			fmt.Fprintln(GinkgoWriter, "Connect to host:", hostIP, hostPort)
-			dnatOK := testEchoServer(hostIP, "udp", hostPort, "")
+				// dump iptables-save output for debugging
+				cmd = exec.Command("iptables-save")
+				cmd.Stderr = GinkgoWriter
+				cmd.Stdout = GinkgoWriter
+				Expect(cmd.Run()).To(Succeed())
 
-			// Cleanup
-			session.Terminate()
-			err = deleteNetwork()
-			Expect(err).NotTo(HaveOccurred())
+				// dump ip routes output for debugging
+				cmd = exec.Command("ip", "route")
+				cmd.Stderr = GinkgoWriter
+				cmd.Stdout = GinkgoWriter
+				Expect(cmd.Run()).To(Succeed())
 
-			// Check that everything succeeded *after* we clean up the network
-			if !contOK {
-				Fail("connection direct to " + contIP.String() + " failed")
-			}
-			if !dnatOK {
-				Fail("Connection to " + hostIP + " was not forwarded")
-			}
-			// Create a second container
-			targetNS2, err := testutils.NewNS()
-			Expect(err).NotTo(HaveOccurred())
-			fmt.Fprintln(GinkgoWriter, "namespace:", targetNS2.Path())
+				// dump ip addresses output for debugging
+				cmd = exec.Command("ip", "addr")
+				cmd.Stderr = GinkgoWriter
+				cmd.Stdout = GinkgoWriter
+				Expect(cmd.Run()).To(Succeed())
 
-			// Start an echo server and get the port
-			containerPort, session2, err := StartEchoServerInNamespace(targetNS2)
-			Expect(err).NotTo(HaveOccurred())
+				// Sanity check: verify that the container is reachable directly
+				fmt.Fprintln(GinkgoWriter, "Connect to container:", contIP.String(), containerPort)
+				contOK := testEchoServer(contIP.String(), "udp", containerPort, "")
 
-			runtimeConfig2 := libcni.RuntimeConf{
-				ContainerID: fmt.Sprintf("unit-test2-%d", hostPort),
-				NetNS:       targetNS2.Path(),
-				IfName:      "eth0",
-				CapabilityArgs: map[string]interface{}{
-					"portMappings": []map[string]interface{}{
-						{
-							"hostPort":      hostPort,
-							"containerPort": containerPort,
-							"protocol":      "udp",
+				// Verify that a connection to the forwarded port works
+				fmt.Fprintln(GinkgoWriter, "Connect to host:", hostIP, hostPort)
+				dnatOK := testEchoServer(hostIP, "udp", hostPort, "")
+
+				// Cleanup
+				session.Terminate()
+				err = deleteNetwork()
+				Expect(err).NotTo(HaveOccurred())
+
+				// Check that everything succeeded *after* we clean up the network
+				if !contOK {
+					Fail("connection direct to " + contIP.String() + " failed")
+				}
+				if !dnatOK {
+					Fail("Connection to " + hostIP + " was not forwarded")
+				}
+				// Create a second container
+				targetNS2, err := testutils.NewNS()
+				Expect(err).NotTo(HaveOccurred())
+				fmt.Fprintln(GinkgoWriter, "namespace:", targetNS2.Path())
+
+				// Start an echo server and get the port
+				containerPort, session2, err := StartEchoServerInNamespace(targetNS2)
+				Expect(err).NotTo(HaveOccurred())
+
+				runtimeConfig2 := libcni.RuntimeConf{
+					ContainerID: fmt.Sprintf("unit-test2-%d", hostPort),
+					NetNS:       targetNS2.Path(),
+					IfName:      "eth0",
+					CapabilityArgs: map[string]interface{}{
+						"portMappings": []map[string]interface{}{
+							{
+								"hostPort":      hostPort,
+								"containerPort": containerPort,
+								"protocol":      "udp",
+							},
 						},
 					},
-				},
-			}
-
-			// Make delete idempotent, so we can clean up on failure
-			net2Deleted := false
-			deleteNetwork2 := func() error {
-				if net2Deleted {
-					return nil
 				}
-				net2Deleted = true
-				return cniConf.DelNetworkList(context.TODO(), configList, &runtimeConfig2)
-			}
 
-			// Create the network
-			resI2, err := cniConf.AddNetworkList(context.TODO(), configList, &runtimeConfig2)
-			Expect(err).NotTo(HaveOccurred())
-			defer deleteNetwork2()
-
-			result2, err := current.GetResult(resI2)
-			Expect(err).NotTo(HaveOccurred())
-			var contIP2 net.IP
-
-			for _, ip := range result2.IPs {
-				intfIndex := *ip.Interface
-				if result2.Interfaces[intfIndex].Sandbox == "" {
-					continue
+				// Make delete idempotent, so we can clean up on failure
+				net2Deleted := false
+				deleteNetwork2 := func() error {
+					if net2Deleted {
+						return nil
+					}
+					net2Deleted = true
+					return cniConf.DelNetworkList(context.TODO(), configList, &runtimeConfig2)
 				}
-				contIP2 = ip.Address.IP
-			}
-			if contIP2 == nil {
-				Fail("could not determine container IP")
-			}
 
-			fmt.Fprintf(GinkgoWriter, "Second container: hostIP: %s:%d, contIP: %s:%d\n",
-				hostIP, hostPort, contIP2, containerPort)
+				// Create the network
+				resI2, err := cniConf.AddNetworkList(context.TODO(), configList, &runtimeConfig2)
+				Expect(err).NotTo(HaveOccurred())
+				defer deleteNetwork2()
 
-			// dump iptables-save output for debugging
-			cmd = exec.Command("iptables-save")
-			cmd.Stderr = GinkgoWriter
-			cmd.Stdout = GinkgoWriter
-			Expect(cmd.Run()).To(Succeed())
+				result2, err := types100.GetResult(resI2)
+				Expect(err).NotTo(HaveOccurred())
+				var contIP2 net.IP
 
-			// dump ip routes output for debugging
-			cmd = exec.Command("ip", "route")
-			cmd.Stderr = GinkgoWriter
-			cmd.Stdout = GinkgoWriter
-			Expect(cmd.Run()).To(Succeed())
+				for _, ip := range result2.IPs {
+					intfIndex := *ip.Interface
+					if result2.Interfaces[intfIndex].Sandbox == "" {
+						continue
+					}
+					contIP2 = ip.Address.IP
+				}
+				if contIP2 == nil {
+					Fail("could not determine container IP")
+				}
 
-			// dump ip addresses output for debugging
-			cmd = exec.Command("ip", "addr")
-			cmd.Stderr = GinkgoWriter
-			cmd.Stdout = GinkgoWriter
-			Expect(cmd.Run()).To(Succeed())
+				fmt.Fprintf(GinkgoWriter, "Second container: hostIP: %s:%d, contIP: %s:%d\n",
+					hostIP, hostPort, contIP2, containerPort)
 
-			// Sanity check: verify that the container is reachable directly
-			fmt.Fprintln(GinkgoWriter, "Connect to container:", contIP2.String(), containerPort)
-			cont2OK := testEchoServer(contIP2.String(), "udp", containerPort, "")
+				// dump iptables-save output for debugging
+				cmd = exec.Command("iptables-save")
+				cmd.Stderr = GinkgoWriter
+				cmd.Stdout = GinkgoWriter
+				Expect(cmd.Run()).To(Succeed())
 
-			// Verify that a connection to the forwarded port works
-			fmt.Fprintln(GinkgoWriter, "Connect to host:", hostIP, hostPort)
-			dnat2OK := testEchoServer(hostIP, "udp", hostPort, "")
+				// dump ip routes output for debugging
+				cmd = exec.Command("ip", "route")
+				cmd.Stderr = GinkgoWriter
+				cmd.Stdout = GinkgoWriter
+				Expect(cmd.Run()).To(Succeed())
 
-			// Cleanup
-			session2.Terminate()
-			err = deleteNetwork2()
-			Expect(err).NotTo(HaveOccurred())
+				// dump ip addresses output for debugging
+				cmd = exec.Command("ip", "addr")
+				cmd.Stderr = GinkgoWriter
+				cmd.Stdout = GinkgoWriter
+				Expect(cmd.Run()).To(Succeed())
 
-			// Check that everything succeeded *after* we clean up the network
-			if !cont2OK {
-				Fail("connection direct to " + contIP2.String() + " failed")
-			}
-			if !dnat2OK {
-				Fail("Connection to " + hostIP + " was not forwarded")
-			}
+				// Sanity check: verify that the container is reachable directly
+				fmt.Fprintln(GinkgoWriter, "Connect to container:", contIP2.String(), containerPort)
+				cont2OK := testEchoServer(contIP2.String(), "udp", containerPort, "")
 
-			close(done)
-		}, TIMEOUT*9)
-	})
+				// Verify that a connection to the forwarded port works
+				fmt.Fprintln(GinkgoWriter, "Connect to host:", hostIP, hostPort)
+				dnat2OK := testEchoServer(hostIP, "udp", hostPort, "")
+
+				// Cleanup
+				session2.Terminate()
+				err = deleteNetwork2()
+				Expect(err).NotTo(HaveOccurred())
+
+				// Check that everything succeeded *after* we clean up the network
+				if !cont2OK {
+					Fail("connection direct to " + contIP2.String() + " failed")
+				}
+				if !dnat2OK {
+					Fail("Connection to " + hostIP + " was not forwarded")
+				}
+
+				close(done)
+			}, TIMEOUT*9)
+		})
+	}
 })
 
 // testEchoServer returns true if we found an echo server on the port

plugins/meta/portmap/portmap_test.go

@@ -27,336 +27,342 @@ var _ = Describe("portmapping configuration", func() {
 	netName := "testNetName"
 	containerID := "icee6giejonei6sohng6ahngee7laquohquee9shiGo7fohferakah3Feiyoolu2pei7ciPhoh7shaoX6vai3vuf0ahfaeng8yohb9ceu0daez5hashee8ooYai5wa3y"
 
-	Context("config parsing", func() {
-		It("Correctly parses an ADD config", func() {
-			configBytes := []byte(`{
-	"name": "test",
-	"type": "portmap",
-	"cniVersion": "0.3.1",
-	"runtimeConfig": {
-		"portMappings": [
-			{ "hostPort": 8080, "containerPort": 80, "protocol": "tcp"},
-			{ "hostPort": 8081, "containerPort": 81, "protocol": "udp"}
-		]
-	},
-	"snat": false,
-	"conditionsV4": ["a", "b"],
-	"conditionsV6": ["c", "d"],
-	"prevResult": {
-		"interfaces": [
-			{"name": "host"},
-			{"name": "container", "sandbox":"netns"}
-		],
-		"ips": [
-			{
-				"version": "4",
-				"address": "10.0.0.1/24",
-				"gateway": "10.0.0.1",
-				"interface": 0
-			},
-			{
-				"version": "6",
-				"address": "2001:db8:1::2/64",
-				"gateway": "2001:db8:1::1",
-				"interface": 1
-			},
-			{
-				"version": "4",
-				"address": "10.0.0.2/24",
-				"gateway": "10.0.0.1",
-				"interface": 1
-			}
-		]
-	}
-}`)
-			c, _, err := parseConfig(configBytes, "container")
-			Expect(err).NotTo(HaveOccurred())
-			Expect(c.CNIVersion).To(Equal("0.3.1"))
-			Expect(c.ConditionsV4).To(Equal(&[]string{"a", "b"}))
-			Expect(c.ConditionsV6).To(Equal(&[]string{"c", "d"}))
-			fvar := false
-			Expect(c.SNAT).To(Equal(&fvar))
-			Expect(c.Name).To(Equal("test"))
+	for _, ver := range []string{"0.3.0", "0.3.1", "0.4.0", "1.0.0"} {
+		// Redefine ver inside for scope so real value is picked up by each dynamically defined It()
+		// See Gingkgo's "Patterns for dynamically generating tests" documentation.
+		ver := ver
 
-			n, err := types.ParseCIDR("10.0.0.2/24")
-			Expect(c.ContIPv4).To(Equal(*n))
-			n, err = types.ParseCIDR("2001:db8:1::2/64")
-			Expect(c.ContIPv6).To(Equal(*n))
-		})
-
-		It("Correctly parses a DEL config", func() {
-			// When called with DEL, neither runtimeConfig nor prevResult may be specified
-			configBytes := []byte(`{
-	"name": "test",
-	"type": "portmap",
-	"cniVersion": "0.3.1",
-	"snat": false,
-	"conditionsV4": ["a", "b"],
-	"conditionsV6": ["c", "d"]
-}`)
-			c, _, err := parseConfig(configBytes, "container")
-			Expect(err).NotTo(HaveOccurred())
-			Expect(c.CNIVersion).To(Equal("0.3.1"))
-			Expect(c.ConditionsV4).To(Equal(&[]string{"a", "b"}))
-			Expect(c.ConditionsV6).To(Equal(&[]string{"c", "d"}))
-			fvar := false
-			Expect(c.SNAT).To(Equal(&fvar))
-			Expect(c.Name).To(Equal("test"))
-		})
-
-		It("fails with invalid mappings", func() {
-			configBytes := []byte(`{
-	"name": "test",
-	"type": "portmap",
-	"cniVersion": "0.3.1",
-	"snat": false,
-	"conditionsV4": ["a", "b"],
-	"conditionsV6": ["c", "d"],
-	"runtimeConfig": {
-		"portMappings": [
-			{ "hostPort": 0, "containerPort": 80, "protocol": "tcp"}
-		]
-	}
-}`)
-			_, _, err := parseConfig(configBytes, "container")
-			Expect(err).To(MatchError("Invalid host port number: 0"))
-		})
-
-		It("Does not fail on missing prevResult interface index", func() {
-			configBytes := []byte(`{
-	"name": "test",
-	"type": "portmap",
-	"cniVersion": "0.3.1",
-	"runtimeConfig": {
-		"portMappings": [
-			{ "hostPort": 8080, "containerPort": 80, "protocol": "tcp"}
-		]
-	},
-	"conditionsV4": ["a", "b"],
-	"prevResult": {
-		"interfaces": [
-			{"name": "host"}
-		],
-		"ips": [
-			{
-				"version": "4",
-				"address": "10.0.0.1/24",
-				"gateway": "10.0.0.1"
-			}
-		]
-	}
-}`)
-			_, _, err := parseConfig(configBytes, "container")
-			Expect(err).NotTo(HaveOccurred())
-		})
-	})
-
-	Describe("Generating chains", func() {
-		Context("for DNAT", func() {
-			It("generates a correct standard container chain", func() {
-				ch := genDnatChain(netName, containerID)
-
-				Expect(ch).To(Equal(chain{
-					table:       "nat",
-					name:        "CNI-DN-bfd599665540dd91d5d28",
-					entryChains: []string{TopLevelDNATChainName},
-				}))
-				configBytes := []byte(`{
-	"name": "test",
-	"type": "portmap",
-	"cniVersion": "0.3.1",
-	"runtimeConfig": {
-		"portMappings": [
-			{ "hostPort": 8080, "containerPort": 80, "protocol": "tcp"},
-			{ "hostPort": 8081, "containerPort": 80, "protocol": "tcp"},
-			{ "hostPort": 8080, "containerPort": 81, "protocol": "udp"},
-			{ "hostPort": 8082, "containerPort": 82, "protocol": "udp"},
-			{ "hostPort": 8083, "containerPort": 83, "protocol": "tcp", "hostIP": "192.168.0.2"},
-			{ "hostPort": 8084, "containerPort": 84, "protocol": "tcp", "hostIP": "0.0.0.0"},
-			{ "hostPort": 8085, "containerPort": 85, "protocol": "tcp", "hostIP": "2001:db8:a::1"},
-			{ "hostPort": 8086, "containerPort": 86, "protocol": "tcp", "hostIP": "::"}
-		]
-	},
-	"snat": true,
-	"conditionsV4": ["a", "b"],
-	"conditionsV6": ["c", "d"]
-}`)
-
-				conf, _, err := parseConfig(configBytes, "foo")
+		Context("config parsing", func() {
+			It(fmt.Sprintf("[%s] correctly parses an ADD config", ver), func() {
+				configBytes := []byte(fmt.Sprintf(`{
+					"name": "test",
+					"type": "portmap",
+					"cniVersion": "%s",
+					"runtimeConfig": {
+						"portMappings": [
+							{ "hostPort": 8080, "containerPort": 80, "protocol": "tcp"},
+							{ "hostPort": 8081, "containerPort": 81, "protocol": "udp"}
+						]
+					},
+					"snat": false,
+					"conditionsV4": ["a", "b"],
+					"conditionsV6": ["c", "d"],
+					"prevResult": {
+						"interfaces": [
+							{"name": "host"},
+							{"name": "container", "sandbox":"netns"}
+						],
+						"ips": [
+							{
+								"version": "4",
+								"address": "10.0.0.1/24",
+								"gateway": "10.0.0.1",
+								"interface": 0
+							},
+							{
+								"version": "6",
+								"address": "2001:db8:1::2/64",
+								"gateway": "2001:db8:1::1",
+								"interface": 1
+							},
+							{
+								"version": "4",
+								"address": "10.0.0.2/24",
+								"gateway": "10.0.0.1",
+								"interface": 1
+							}
+						]
+					}
+				}`, ver))
+				c, _, err := parseConfig(configBytes, "container")
 				Expect(err).NotTo(HaveOccurred())
-				conf.ContainerID = containerID
-
-				ch = genDnatChain(conf.Name, containerID)
-				Expect(ch).To(Equal(chain{
-					table:       "nat",
-					name:        "CNI-DN-67e92b96e692a494b6b85",
-					entryChains: []string{"CNI-HOSTPORT-DNAT"},
-				}))
-
-				n, err := types.ParseCIDR("10.0.0.2/24")
-				fillDnatRules(&ch, conf, *n)
-
-				Expect(ch.entryRules).To(Equal([][]string{
-					{"-m", "comment", "--comment",
-						fmt.Sprintf("dnat name: \"test\" id: \"%s\"", containerID),
-						"-m", "multiport",
-						"-p", "tcp",
-						"--destination-ports", "8080,8081,8083,8084,8085,8086",
-						"a", "b"},
-					{"-m", "comment", "--comment",
-						fmt.Sprintf("dnat name: \"test\" id: \"%s\"", containerID),
-						"-m", "multiport",
-						"-p", "udp",
-						"--destination-ports", "8080,8082",
-						"a", "b"},
-				}))
-
-				Expect(ch.rules).To(Equal([][]string{
-					// tcp rules and not hostIP
-					{"-p", "tcp", "--dport", "8080", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8080", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8080", "-j", "DNAT", "--to-destination", "10.0.0.2:80"},
-					{"-p", "tcp", "--dport", "8081", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8081", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8081", "-j", "DNAT", "--to-destination", "10.0.0.2:80"},
-					// udp rules and not hostIP
-					{"-p", "udp", "--dport", "8080", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "udp", "--dport", "8080", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "udp", "--dport", "8080", "-j", "DNAT", "--to-destination", "10.0.0.2:81"},
-					{"-p", "udp", "--dport", "8082", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "udp", "--dport", "8082", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "udp", "--dport", "8082", "-j", "DNAT", "--to-destination", "10.0.0.2:82"},
-					// tcp rules and hostIP
-					{"-p", "tcp", "--dport", "8083", "-d", "192.168.0.2", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8083", "-d", "192.168.0.2", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8083", "-d", "192.168.0.2", "-j", "DNAT", "--to-destination", "10.0.0.2:83"},
-					// tcp rules and hostIP = "0.0.0.0"
-					{"-p", "tcp", "--dport", "8084", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8084", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8084", "-j", "DNAT", "--to-destination", "10.0.0.2:84"},
-				}))
-
-				ch.rules = nil
-				ch.entryRules = nil
-
-				n, err = types.ParseCIDR("2001:db8::2/64")
-				fillDnatRules(&ch, conf, *n)
-
-				Expect(ch.rules).To(Equal([][]string{
-					// tcp rules and not hostIP
-					{"-p", "tcp", "--dport", "8080", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8080", "-j", "DNAT", "--to-destination", "[2001:db8::2]:80"},
-					{"-p", "tcp", "--dport", "8081", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8081", "-j", "DNAT", "--to-destination", "[2001:db8::2]:80"},
-					// udp rules and not hostIP
-					{"-p", "udp", "--dport", "8080", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "udp", "--dport", "8080", "-j", "DNAT", "--to-destination", "[2001:db8::2]:81"},
-					{"-p", "udp", "--dport", "8082", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "udp", "--dport", "8082", "-j", "DNAT", "--to-destination", "[2001:db8::2]:82"},
-					// tcp rules and hostIP
-					{"-p", "tcp", "--dport", "8085", "-d", "2001:db8:a::1", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8085", "-d", "2001:db8:a::1", "-j", "DNAT", "--to-destination", "[2001:db8::2]:85"},
-					// tcp rules and hostIP = "::"
-					{"-p", "tcp", "--dport", "8086", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
-					{"-p", "tcp", "--dport", "8086", "-j", "DNAT", "--to-destination", "[2001:db8::2]:86"},
-				}))
-
-				// Disable snat, generate rules
-				ch.rules = nil
-				ch.entryRules = nil
+				Expect(c.CNIVersion).To(Equal(ver))
+				Expect(c.ConditionsV4).To(Equal(&[]string{"a", "b"}))
+				Expect(c.ConditionsV6).To(Equal(&[]string{"c", "d"}))
 				fvar := false
-				conf.SNAT = &fvar
+				Expect(c.SNAT).To(Equal(&fvar))
+				Expect(c.Name).To(Equal("test"))
 
-				n, err = types.ParseCIDR("10.0.0.2/24")
-				fillDnatRules(&ch, conf, *n)
-				Expect(ch.rules).To(Equal([][]string{
-					{"-p", "tcp", "--dport", "8080", "-j", "DNAT", "--to-destination", "10.0.0.2:80"},
-					{"-p", "tcp", "--dport", "8081", "-j", "DNAT", "--to-destination", "10.0.0.2:80"},
-					{"-p", "udp", "--dport", "8080", "-j", "DNAT", "--to-destination", "10.0.0.2:81"},
-					{"-p", "udp", "--dport", "8082", "-j", "DNAT", "--to-destination", "10.0.0.2:82"},
-					{"-p", "tcp", "--dport", "8083", "-d", "192.168.0.2", "-j", "DNAT", "--to-destination", "10.0.0.2:83"},
-					{"-p", "tcp", "--dport", "8084", "-j", "DNAT", "--to-destination", "10.0.0.2:84"},
-				}))
-			})
-
-			It("generates a correct chain with external mark", func() {
-				ch := genDnatChain(netName, containerID)
-
-				Expect(ch).To(Equal(chain{
-					table:       "nat",
-					name:        "CNI-DN-bfd599665540dd91d5d28",
-					entryChains: []string{TopLevelDNATChainName},
-				}))
-				configBytes := []byte(`{
-	"name": "test",
-	"type": "portmap",
-	"cniVersion": "0.3.1",
-	"runtimeConfig": {
-		"portMappings": [
-			{ "hostPort": 8080, "containerPort": 80, "protocol": "tcp"}
-		]
-	},
-	"externalSetMarkChain": "PLZ-SET-MARK",
-	"conditionsV4": ["a", "b"],
-	"conditionsV6": ["c", "d"]
-}`)
-
-				conf, _, err := parseConfig(configBytes, "foo")
-				Expect(err).NotTo(HaveOccurred())
-				conf.ContainerID = containerID
-
-				ch = genDnatChain(conf.Name, containerID)
 				n, err := types.ParseCIDR("10.0.0.2/24")
-				fillDnatRules(&ch, conf, *n)
-				Expect(ch.rules).To(Equal([][]string{
-					{"-p", "tcp", "--dport", "8080", "-s", "10.0.0.2/24", "-j", "PLZ-SET-MARK"},
-					{"-p", "tcp", "--dport", "8080", "-s", "127.0.0.1", "-j", "PLZ-SET-MARK"},
-					{"-p", "tcp", "--dport", "8080", "-j", "DNAT", "--to-destination", "10.0.0.2:80"},
-				}))
+				Expect(c.ContIPv4).To(Equal(*n))
+				n, err = types.ParseCIDR("2001:db8:1::2/64")
+				Expect(c.ContIPv6).To(Equal(*n))
 			})
 
-			It("generates a correct top-level chain", func() {
-				ch := genToplevelDnatChain()
-
-				Expect(ch).To(Equal(chain{
-					table:       "nat",
-					name:        "CNI-HOSTPORT-DNAT",
-					entryChains: []string{"PREROUTING", "OUTPUT"},
-					entryRules:  [][]string{{"-m", "addrtype", "--dst-type", "LOCAL"}},
-				}))
+			It(fmt.Sprintf("[%s] correctly parses a DEL config", ver), func() {
+				// When called with DEL, neither runtimeConfig nor prevResult may be specified
+				configBytes := []byte(fmt.Sprintf(`{
+					"name": "test",
+					"type": "portmap",
+					"cniVersion": "%s",
+					"snat": false,
+					"conditionsV4": ["a", "b"],
+					"conditionsV6": ["c", "d"]
+				}`, ver))
+				c, _, err := parseConfig(configBytes, "container")
+				Expect(err).NotTo(HaveOccurred())
+				Expect(c.CNIVersion).To(Equal(ver))
+				Expect(c.ConditionsV4).To(Equal(&[]string{"a", "b"}))
+				Expect(c.ConditionsV6).To(Equal(&[]string{"c", "d"}))
+				fvar := false
+				Expect(c.SNAT).To(Equal(&fvar))
+				Expect(c.Name).To(Equal("test"))
 			})
 
-			It("generates the correct mark chains", func() {
-				masqBit := 5
-				ch := genSetMarkChain(masqBit)
-				Expect(ch).To(Equal(chain{
-					table: "nat",
-					name:  "CNI-HOSTPORT-SETMARK",
-					rules: [][]string{{
-						"-m", "comment",
-						"--comment", "CNI portfwd masquerade mark",
-						"-j", "MARK",
-						"--set-xmark", "0x20/0x20",
-					}},
-				}))
+			It(fmt.Sprintf("[%s] fails with invalid mappings", ver), func() {
+				configBytes := []byte(fmt.Sprintf(`{
+					"name": "test",
+					"type": "portmap",
+					"cniVersion": "%s",
+					"snat": false,
+					"conditionsV4": ["a", "b"],
+					"conditionsV6": ["c", "d"],
+					"runtimeConfig": {
+						"portMappings": [
+							{ "hostPort": 0, "containerPort": 80, "protocol": "tcp"}
+						]
+					}
+				}`, ver))
+				_, _, err := parseConfig(configBytes, "container")
+				Expect(err).To(MatchError("Invalid host port number: 0"))
+			})
 
-				ch = genMarkMasqChain(masqBit)
-				Expect(ch).To(Equal(chain{
-					table:       "nat",
-					name:        "CNI-HOSTPORT-MASQ",
-					entryChains: []string{"POSTROUTING"},
-					entryRules: [][]string{{
-						"-m", "comment",
-						"--comment", "CNI portfwd requiring masquerade",
-					}},
-					rules: [][]string{{
-						"-m", "mark",
-						"--mark", "0x20/0x20",
-						"-j", "MASQUERADE",
-					}},
-					prependEntry: true,
-				}))
+			It(fmt.Sprintf("[%s] does not fail on missing prevResult interface index", ver), func() {
+				configBytes := []byte(fmt.Sprintf(`{
+					"name": "test",
+					"type": "portmap",
+					"cniVersion": "%s",
+					"runtimeConfig": {
+						"portMappings": [
+							{ "hostPort": 8080, "containerPort": 80, "protocol": "tcp"}
+						]
+					},
+					"conditionsV4": ["a", "b"],
+					"prevResult": {
+						"interfaces": [
+							{"name": "host"}
+						],
+						"ips": [
+							{
+								"version": "4",
+								"address": "10.0.0.1/24",
+								"gateway": "10.0.0.1"
+							}
+						]
+					}
+				}`, ver))
+				_, _, err := parseConfig(configBytes, "container")
+				Expect(err).NotTo(HaveOccurred())
 			})
 		})
-	})
+
+		Describe("Generating chains", func() {
+			Context("for DNAT", func() {
+				It(fmt.Sprintf("[%s] generates a correct standard container chain", ver), func() {
+					ch := genDnatChain(netName, containerID)
+
+					Expect(ch).To(Equal(chain{
+						table:       "nat",
+						name:        "CNI-DN-bfd599665540dd91d5d28",
+						entryChains: []string{TopLevelDNATChainName},
+					}))
+					configBytes := []byte(fmt.Sprintf(`{
+						"name": "test",
+						"type": "portmap",
+						"cniVersion": "%s",
+						"runtimeConfig": {
+							"portMappings": [
+								{ "hostPort": 8080, "containerPort": 80, "protocol": "tcp"},
+								{ "hostPort": 8081, "containerPort": 80, "protocol": "tcp"},
+								{ "hostPort": 8080, "containerPort": 81, "protocol": "udp"},
+								{ "hostPort": 8082, "containerPort": 82, "protocol": "udp"},
+								{ "hostPort": 8083, "containerPort": 83, "protocol": "tcp", "hostIP": "192.168.0.2"},
+								{ "hostPort": 8084, "containerPort": 84, "protocol": "tcp", "hostIP": "0.0.0.0"},
+								{ "hostPort": 8085, "containerPort": 85, "protocol": "tcp", "hostIP": "2001:db8:a::1"},
+								{ "hostPort": 8086, "containerPort": 86, "protocol": "tcp", "hostIP": "::"}
+							]
+						},
+						"snat": true,
+						"conditionsV4": ["a", "b"],
+						"conditionsV6": ["c", "d"]
+					}`, ver))
+
+					conf, _, err := parseConfig(configBytes, "foo")
+					Expect(err).NotTo(HaveOccurred())
+					conf.ContainerID = containerID
+
+					ch = genDnatChain(conf.Name, containerID)
+					Expect(ch).To(Equal(chain{
+						table:       "nat",
+						name:        "CNI-DN-67e92b96e692a494b6b85",
+						entryChains: []string{"CNI-HOSTPORT-DNAT"},
+					}))
+
+					n, err := types.ParseCIDR("10.0.0.2/24")
+					fillDnatRules(&ch, conf, *n)
+
+					Expect(ch.entryRules).To(Equal([][]string{
+						{"-m", "comment", "--comment",
+							fmt.Sprintf("dnat name: \"test\" id: \"%s\"", containerID),
+							"-m", "multiport",
+							"-p", "tcp",
+							"--destination-ports", "8080,8081,8083,8084,8085,8086",
+							"a", "b"},
+						{"-m", "comment", "--comment",
+							fmt.Sprintf("dnat name: \"test\" id: \"%s\"", containerID),
+							"-m", "multiport",
+							"-p", "udp",
+							"--destination-ports", "8080,8082",
+							"a", "b"},
+					}))
+
+					Expect(ch.rules).To(Equal([][]string{
+						// tcp rules and not hostIP
+						{"-p", "tcp", "--dport", "8080", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8080", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8080", "-j", "DNAT", "--to-destination", "10.0.0.2:80"},
+						{"-p", "tcp", "--dport", "8081", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8081", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8081", "-j", "DNAT", "--to-destination", "10.0.0.2:80"},
+						// udp rules and not hostIP
+						{"-p", "udp", "--dport", "8080", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "udp", "--dport", "8080", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "udp", "--dport", "8080", "-j", "DNAT", "--to-destination", "10.0.0.2:81"},
+						{"-p", "udp", "--dport", "8082", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "udp", "--dport", "8082", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "udp", "--dport", "8082", "-j", "DNAT", "--to-destination", "10.0.0.2:82"},
+						// tcp rules and hostIP
+						{"-p", "tcp", "--dport", "8083", "-d", "192.168.0.2", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8083", "-d", "192.168.0.2", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8083", "-d", "192.168.0.2", "-j", "DNAT", "--to-destination", "10.0.0.2:83"},
+						// tcp rules and hostIP = "0.0.0.0"
+						{"-p", "tcp", "--dport", "8084", "-s", "10.0.0.2/24", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8084", "-s", "127.0.0.1", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8084", "-j", "DNAT", "--to-destination", "10.0.0.2:84"},
+					}))
+
+					ch.rules = nil
+					ch.entryRules = nil
+
+					n, err = types.ParseCIDR("2001:db8::2/64")
+					fillDnatRules(&ch, conf, *n)
+
+					Expect(ch.rules).To(Equal([][]string{
+						// tcp rules and not hostIP
+						{"-p", "tcp", "--dport", "8080", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8080", "-j", "DNAT", "--to-destination", "[2001:db8::2]:80"},
+						{"-p", "tcp", "--dport", "8081", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8081", "-j", "DNAT", "--to-destination", "[2001:db8::2]:80"},
+						// udp rules and not hostIP
+						{"-p", "udp", "--dport", "8080", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "udp", "--dport", "8080", "-j", "DNAT", "--to-destination", "[2001:db8::2]:81"},
+						{"-p", "udp", "--dport", "8082", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "udp", "--dport", "8082", "-j", "DNAT", "--to-destination", "[2001:db8::2]:82"},
+						// tcp rules and hostIP
+						{"-p", "tcp", "--dport", "8085", "-d", "2001:db8:a::1", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8085", "-d", "2001:db8:a::1", "-j", "DNAT", "--to-destination", "[2001:db8::2]:85"},
+						// tcp rules and hostIP = "::"
+						{"-p", "tcp", "--dport", "8086", "-s", "2001:db8::2/64", "-j", "CNI-HOSTPORT-SETMARK"},
+						{"-p", "tcp", "--dport", "8086", "-j", "DNAT", "--to-destination", "[2001:db8::2]:86"},
+					}))
+
+					// Disable snat, generate rules
+					ch.rules = nil
+					ch.entryRules = nil
+					fvar := false
+					conf.SNAT = &fvar
+
+					n, err = types.ParseCIDR("10.0.0.2/24")
+					fillDnatRules(&ch, conf, *n)
+					Expect(ch.rules).To(Equal([][]string{
+						{"-p", "tcp", "--dport", "8080", "-j", "DNAT", "--to-destination", "10.0.0.2:80"},
+						{"-p", "tcp", "--dport", "8081", "-j", "DNAT", "--to-destination", "10.0.0.2:80"},
+						{"-p", "udp", "--dport", "8080", "-j", "DNAT", "--to-destination", "10.0.0.2:81"},
+						{"-p", "udp", "--dport", "8082", "-j", "DNAT", "--to-destination", "10.0.0.2:82"},
+						{"-p", "tcp", "--dport", "8083", "-d", "192.168.0.2", "-j", "DNAT", "--to-destination", "10.0.0.2:83"},
+						{"-p", "tcp", "--dport", "8084", "-j", "DNAT", "--to-destination", "10.0.0.2:84"},
+					}))
+				})
+
+				It(fmt.Sprintf("[%s] generates a correct chain with external mark", ver), func() {
+					ch := genDnatChain(netName, containerID)
+
+					Expect(ch).To(Equal(chain{
+						table:       "nat",
+						name:        "CNI-DN-bfd599665540dd91d5d28",
+						entryChains: []string{TopLevelDNATChainName},
+					}))
+					configBytes := []byte(fmt.Sprintf(`{
+						"name": "test",
+						"type": "portmap",
+						"cniVersion": "%s",
+						"runtimeConfig": {
+							"portMappings": [
+								{ "hostPort": 8080, "containerPort": 80, "protocol": "tcp"}
+							]
+						},
+						"externalSetMarkChain": "PLZ-SET-MARK",
+						"conditionsV4": ["a", "b"],
+						"conditionsV6": ["c", "d"]
+					}`, ver))
+
+					conf, _, err := parseConfig(configBytes, "foo")
+					Expect(err).NotTo(HaveOccurred())
+					conf.ContainerID = containerID
+
+					ch = genDnatChain(conf.Name, containerID)
+					n, err := types.ParseCIDR("10.0.0.2/24")
+					fillDnatRules(&ch, conf, *n)
+					Expect(ch.rules).To(Equal([][]string{
+						{"-p", "tcp", "--dport", "8080", "-s", "10.0.0.2/24", "-j", "PLZ-SET-MARK"},
+						{"-p", "tcp", "--dport", "8080", "-s", "127.0.0.1", "-j", "PLZ-SET-MARK"},
+						{"-p", "tcp", "--dport", "8080", "-j", "DNAT", "--to-destination", "10.0.0.2:80"},
+					}))
+				})
+
+				It(fmt.Sprintf("[%s] generates a correct top-level chain", ver), func() {
+					ch := genToplevelDnatChain()
+
+					Expect(ch).To(Equal(chain{
+						table:       "nat",
+						name:        "CNI-HOSTPORT-DNAT",
+						entryChains: []string{"PREROUTING", "OUTPUT"},
+						entryRules:  [][]string{{"-m", "addrtype", "--dst-type", "LOCAL"}},
+					}))
+				})
+
+				It(fmt.Sprintf("[%s] generates the correct mark chains", ver), func() {
+					masqBit := 5
+					ch := genSetMarkChain(masqBit)
+					Expect(ch).To(Equal(chain{
+						table: "nat",
+						name:  "CNI-HOSTPORT-SETMARK",
+						rules: [][]string{{
+							"-m", "comment",
+							"--comment", "CNI portfwd masquerade mark",
+							"-j", "MARK",
+							"--set-xmark", "0x20/0x20",
+						}},
+					}))
+
+					ch = genMarkMasqChain(masqBit)
+					Expect(ch).To(Equal(chain{
+						table:       "nat",
+						name:        "CNI-HOSTPORT-MASQ",
+						entryChains: []string{"POSTROUTING"},
+						entryRules: [][]string{{
+							"-m", "comment",
+							"--comment", "CNI portfwd requiring masquerade",
+						}},
+						rules: [][]string{{
+							"-m", "mark",
+							"--mark", "0x20/0x20",
+							"-j", "MASQUERADE",
+						}},
+						prependEntry: true,
+					}))
+				})
+			})
+		})
+	}
 })

plugins/meta/sbr/main.go

@@ -26,7 +26,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/ns"
@@ -234,7 +234,7 @@ func doRoutes(ipCfgs []*current.IPConfig, origRoutes []*types.Route, iface strin
 		// Source must be restricted to a single IP, not a full subnet
 		var src net.IPNet
 		src.IP = ipCfg.Address.IP
-		if ipCfg.Version == "4" {
+		if src.IP.To4() != nil {
 			src.Mask = net.CIDRMask(32, 32)
 		} else {
 			src.Mask = net.CIDRMask(128, 128)
@@ -253,7 +253,7 @@ func doRoutes(ipCfgs []*current.IPConfig, origRoutes []*types.Route, iface strin
 			log.Printf("Adding default route to gateway %s", ipCfg.Gateway.String())
 
 			var dest net.IPNet
-			if ipCfg.Version == "4" {
+			if ipCfg.Address.IP.To4() != nil {
 				dest.IP = net.IPv4zero
 				dest.Mask = net.CIDRMask(0, 32)
 			} else {

plugins/meta/sbr/sbr_linux_test.go

@@ -241,6 +241,7 @@ var _ = Describe("sbr test", func() {
 	"name": "cni-plugin-sbr-test",
 	"type": "sbr",
 	"prevResult": {
+		"cniVersion": "0.3.0",
 		"interfaces": [
 			{
 				"name": "%s",
@@ -332,6 +333,7 @@ var _ = Describe("sbr test", func() {
 	"name": "cni-plugin-sbr-test",
 	"type": "sbr",
 	"prevResult": {
+		"cniVersion": "0.3.0",
 		"interfaces": [
 			{
 				"name": "%s",
@@ -399,19 +401,12 @@ var _ = Describe("sbr test", func() {
 		Expect(equalRoutes(expNet1.Routes, devNet1.Routes)).To(BeTrue())
 	})
 
-	It("works with a 0.2.0 config", func() {
+	It("fails with CNI spec versions that don't support plugin chaining", func() {
 		conf := `{
 	"cniVersion": "0.2.0",
 	"name": "cni-plugin-sbr-test",
 	"type": "sbr",
-	"anotherAwesomeArg": "foo",
-	"prevResult": {
-		"ip4": {
-        	"ip": "192.168.1.209/24",
-		    "gateway": "192.168.1.1",
-			"routes": []
-		}
-	}
+	"anotherAwesomeArg": "foo"
 }`
 
 		args := &skel.CmdArgs{
@@ -424,7 +419,7 @@ var _ = Describe("sbr test", func() {
 		Expect(err).NotTo(HaveOccurred())
 
 		_, _, err = testutils.CmdAddWithArgs(args, func() error { return cmdAdd(args) })
-		Expect(err).NotTo(HaveOccurred())
+		Expect(err).To(MatchError("This plugin must be called as chained plugin"))
 	})
 
 })

plugins/meta/tuning/tuning.go

@@ -32,7 +32,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/ns"
@@ -322,7 +322,7 @@ func cmdAdd(args *skel.CmdArgs) error {
 			}
 
 			for _, ipc := range result.IPs {
-				if ipc.Version == "4" {
+				if ipc.Address.IP.To4() != nil {
 					_ = arping.GratuitousArpOverIfaceByName(ipc.Address.IP, args.IfName)
 				}
 			}

plugins/meta/vrf/main.go

@@ -22,7 +22,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	"github.com/containernetworking/plugins/pkg/ns"

plugins/meta/vrf/vrf_test.go

@@ -20,7 +20,7 @@ import (
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/plugins/pkg/ns"
 	"github.com/containernetworking/plugins/pkg/testutils"
 

plugins/sample/main.go

@@ -19,11 +19,10 @@ package main
 import (
 	"encoding/json"
 	"fmt"
-	"net"
 
 	"github.com/containernetworking/cni/pkg/skel"
 	"github.com/containernetworking/cni/pkg/types"
-	"github.com/containernetworking/cni/pkg/types/current"
+	current "github.com/containernetworking/cni/pkg/types/100"
 	"github.com/containernetworking/cni/pkg/version"
 
 	bv "github.com/containernetworking/plugins/pkg/utils/buildversion"
@@ -33,21 +32,15 @@ import (
 // is passed in on stdin. Your plugin may wish to expose its functionality via
 // runtime args, see CONVENTIONS.md in the CNI spec.
 type PluginConf struct {
-	types.NetConf // You may wish to not nest this type
+	// This embeds the standard NetConf structure which allows your plugin
+	// to more easily parse standard fields like Name, Type, CNIVersion,
+	// and PrevResult.
+	types.NetConf
+
 	RuntimeConfig *struct {
 		SampleConfig map[string]interface{} `json:"sample"`
 	} `json:"runtimeConfig"`
 
-	// This is the previous result, when called in the context of a chained
-	// plugin. Because this plugin supports multiple versions, we'll have to
-	// parse this in two passes. If your plugin is not chained, this can be
-	// removed (though you may wish to error if a non-chainable plugin is
-	// chained.
-	// If you need to modify the result before returning it, you will need
-	// to actually convert it to a concrete versioned struct.
-	RawPrevResult *map[string]interface{} `json:"prevResult"`
-	PrevResult    *current.Result         `json:"-"`
-
 	// Add plugin-specifc flags here
 	MyAwesomeFlag     bool   `json:"myAwesomeFlag"`
 	AnotherAwesomeArg string `json:"anotherAwesomeArg"`
@@ -61,21 +54,12 @@ func parseConfig(stdin []byte) (*PluginConf, error) {
 		return nil, fmt.Errorf("failed to parse network configuration: %v", err)
 	}
 
-	// Parse previous result. Remove this if your plugin is not chained.
-	if conf.RawPrevResult != nil {
-		resultBytes, err := json.Marshal(conf.RawPrevResult)
-		if err != nil {
-			return nil, fmt.Errorf("could not serialize prevResult: %v", err)
-		}
-		res, err := version.NewResult(conf.CNIVersion, resultBytes)
-		if err != nil {
-			return nil, fmt.Errorf("could not parse prevResult: %v", err)
-		}
-		conf.RawPrevResult = nil
-		conf.PrevResult, err = current.NewResultFromResult(res)
-		if err != nil {
-			return nil, fmt.Errorf("could not convert result to current version: %v", err)
-		}
+	// Parse previous result. This will parse, validate, and place the
+	// previous result object into conf.PrevResult. If you need to modify
+	// or inspect the PrevResult you will need to convert it to a concrete
+	// versioned Result struct.
+	if err := version.ParsePrevResult(&conf.NetConf); err != nil {
+		return nil, fmt.Errorf("could not parse prevResult: %v", err)
 	}
 	// End previous result parsing
 
@@ -94,50 +78,62 @@ func cmdAdd(args *skel.CmdArgs) error {
 		return err
 	}
 
-	// Remove this if this is an "originating" plugin
+	// A plugin can be either an "originating" plugin or a "chained" plugin.
+	// Originating plugins perform initial sandbox setup and do not require
+	// any result from a previous plugin in the chain. A chained plugin
+	// modifies sandbox configuration that was previously set up by an
+	// originating plugin and may optionally require a PrevResult from
+	// earlier plugins in the chain.
+
+	// START chained plugin code
 	if conf.PrevResult == nil {
 		return fmt.Errorf("must be called as chained plugin")
 	}
 
-	// Uncomment if this is an "originating" plugin
-
-	//if conf.PrevResult != nil {
-	//		return fmt.Errorf("must be called as the first plugin")
-	//	}
-
-	// This is some sample code to generate the list of container-side IPs.
-	// We're casting the prevResult to a 0.3.0 response, which can also include
-	// host-side IPs (but doesn't when converted from a 0.2.0 response).
-	//
-	// You don't need this if you are writing an "originating" plugin.
-	containerIPs := make([]net.IP, 0, len(conf.PrevResult.IPs))
-	if conf.CNIVersion != "0.3.0" {
-		for _, ip := range conf.PrevResult.IPs {
-			containerIPs = append(containerIPs, ip.Address.IP)
-		}
-	} else {
-		for _, ip := range conf.PrevResult.IPs {
-			if ip.Interface == nil {
-				continue
-			}
-			intIdx := *ip.Interface
-			// Every IP is indexed in to the interfaces array, with "-1" standing
-			// for an unknown interface (which we'll assume to be Container-side
-			// Skip all IPs we know belong to an interface with the wrong name.
-			if intIdx >= 0 && intIdx < len(conf.PrevResult.Interfaces) && conf.PrevResult.Interfaces[intIdx].Name != args.IfName {
-				continue
-			}
-			containerIPs = append(containerIPs, ip.Address.IP)
-		}
+	// Convert the PrevResult to a concrete Result type that can be modified.
+	prevResult, err := current.GetResult(conf.PrevResult)
+	if err != nil {
+		return fmt.Errorf("failed to convert prevResult: %v", err)
 	}
-	if len(containerIPs) == 0 {
+
+	if len(prevResult.IPs) == 0 {
 		return fmt.Errorf("got no container IPs")
 	}
 
+	// Pass the prevResult through this plugin to the next one
+	result := prevResult
+
+	// END chained plugin code
+
+	// START originating plugin code
+	// if conf.PrevResult != nil {
+	//	return fmt.Errorf("must be called as the first plugin")
+	// }
+
+	// Generate some fake container IPs and add to the result
+	// result := &current.Result{CNIVersion: current.ImplementedSpecVersion}
+	// result.Interfaces = []*current.Interface{
+	// 	{
+	// 		Name:    "intf0",
+	// 		Sandbox: args.Netns,
+	// 		Mac:     "00:11:22:33:44:55",
+	// 	},
+	// }
+	// result.IPs = []*current.IPConfig{
+	// 	{
+	// 		Address:   "1.2.3.4/24",
+	// 		Gateway:   "1.2.3.1",
+	// 		// Interface is an index into the Interfaces array
+	// 		// of the Interface element this IP applies to
+	// 		Interface: current.Int(0),
+	// 	}
+	// }
+	// END originating plugin code
+
 	// Implement your plugin here
 
 	// Pass through the result for the next plugin
-	return types.PrintResult(conf.PrevResult, conf.CNIVersion)
+	return types.PrintResult(result, conf.CNIVersion)
 }
 
 // cmdDel is called for DELETE requests

plugins/sample/sample_linux_test.go

@@ -45,6 +45,7 @@ var _ = Describe("sample test", func() {
 	"type": "sample",
 	"anotherAwesomeArg": "awesome",
 	"prevResult": {
+		"cniVersion": "0.3.0",
 		"interfaces": [
 			{
 				"name": "%s",
@@ -71,7 +72,6 @@ var _ = Describe("sample test", func() {
 		}
 		_, _, err := testutils.CmdAddWithArgs(args, func() error { return cmdAdd(args) })
 		Expect(err).NotTo(HaveOccurred())
-
 	})
 
 	It("fails an invalid config", func() {
@@ -106,22 +106,14 @@ var _ = Describe("sample test", func() {
 		}
 		_, _, err := testutils.CmdAddWithArgs(args, func() error { return cmdAdd(args) })
 		Expect(err).To(MatchError("anotherAwesomeArg must be specified"))
-
 	})
 
-	It("works with a 0.2.0 config", func() {
+	It("fails with CNI spec versions that don't support plugin chaining", func() {
 		conf := `{
 	"cniVersion": "0.2.0",
 	"name": "cni-plugin-sample-test",
 	"type": "sample",
-	"anotherAwesomeArg": "foo",
-	"prevResult": {
-		"ip4": {
-			"ip": "10.0.0.2/24",
-			"gateway": "10.0.0.1",
-			"routes": []
-		}
-	}
+	"anotherAwesomeArg": "foo"
 }`
 
 		args := &skel.CmdArgs{
@@ -131,8 +123,7 @@ var _ = Describe("sample test", func() {
 			StdinData:   []byte(conf),
 		}
 		_, _, err := testutils.CmdAddWithArgs(args, func() error { return cmdAdd(args) })
-		Expect(err).NotTo(HaveOccurred())
-
+		Expect(err).To(MatchError("must be called as chained plugin"))
 	})
 
 })