network: Remove unused CNI code

We dont really call CNI from Kata, this is done by the CRI layer.
All of the CNI code is unused.

Fixes #567

Signed-off-by: Archana Shinde <archana.m.shinde@intel.com>

virtcontainers/api_test.go

@@ -119,49 +119,6 @@ func newTestSandboxConfigHyperstartAgent() SandboxConfig {
 	return sandboxConfig
 }
 
-func newTestSandboxConfigHyperstartAgentCNINetwork() SandboxConfig {
-	// Define the container command and bundle.
-	container := ContainerConfig{
-		ID:          containerID,
-		RootFs:      filepath.Join(testDir, testBundle),
-		Cmd:         newBasicTestCmd(),
-		Annotations: containerAnnotations,
-	}
-
-	// Sets the hypervisor configuration.
-	hypervisorConfig := HypervisorConfig{
-		KernelPath:     filepath.Join(testDir, testKernel),
-		ImagePath:      filepath.Join(testDir, testImage),
-		HypervisorPath: filepath.Join(testDir, testHypervisor),
-	}
-
-	agentConfig := HyperConfig{
-		SockCtlName: testHyperstartCtlSocket,
-		SockTtyName: testHyperstartTtySocket,
-	}
-
-	netConfig := NetworkConfig{
-		NumInterfaces: 1,
-	}
-
-	sandboxConfig := SandboxConfig{
-		ID:               testSandboxID,
-		HypervisorType:   MockHypervisor,
-		HypervisorConfig: hypervisorConfig,
-
-		AgentType:   HyperstartAgent,
-		AgentConfig: agentConfig,
-
-		NetworkModel:  CNINetworkModel,
-		NetworkConfig: netConfig,
-
-		Containers:  []ContainerConfig{container},
-		Annotations: sandboxAnnotations,
-	}
-
-	return sandboxConfig
-}
-
 func newTestSandboxConfigHyperstartAgentCNMNetwork() SandboxConfig {
 	// Define the container command and bundle.
 	container := ContainerConfig{
@@ -1396,46 +1353,6 @@ func TestStartStopContainerHyperstartAgentSuccessful(t *testing.T) {
 	bindUnmountAllRootfs(defaultSharedDir, pImpl)
 }
 
-func TestStartStopSandboxHyperstartAgentSuccessfulWithCNINetwork(t *testing.T) {
-	if os.Geteuid() != 0 {
-		t.Skip(testDisabledAsNonRoot)
-	}
-
-	cleanUp()
-
-	config := newTestSandboxConfigHyperstartAgentCNINetwork()
-
-	sockDir, err := testGenerateCCProxySockDir()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.RemoveAll(sockDir)
-
-	testCCProxySockPath := fmt.Sprintf(testCCProxySockPathTempl, sockDir)
-	noopProxyURL = testCCProxyURLUnixScheme + testCCProxySockPath
-	proxy := mock.NewCCProxyMock(t, testCCProxySockPath)
-	proxy.Start()
-	defer proxy.Stop()
-
-	hyperConfig := config.AgentConfig.(HyperConfig)
-	config.AgentConfig = hyperConfig
-
-	p, _, err := createAndStartSandbox(config)
-	if p == nil || err != nil {
-		t.Fatal(err)
-	}
-
-	p, err = StopSandbox(p.ID())
-	if p == nil || err != nil {
-		t.Fatal(err)
-	}
-
-	p, err = DeleteSandbox(p.ID())
-	if p == nil || err != nil {
-		t.Fatal(err)
-	}
-}
-
 func TestStartStopSandboxHyperstartAgentSuccessfulWithCNMNetwork(t *testing.T) {
 	if os.Geteuid() != 0 {
 		t.Skip(testDisabledAsNonRoot)
@@ -2216,34 +2133,6 @@ func createStartStopDeleteContainers(b *testing.B, sandboxConfig SandboxConfig,
 	}
 }
 
-func BenchmarkCreateStartStopDeleteSandboxQemuHypervisorHyperstartAgentNetworkCNI(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		sandboxConfig := createNewSandboxConfig(QemuHypervisor, HyperstartAgent, HyperConfig{}, CNINetworkModel)
-
-		sockDir, err := testGenerateCCProxySockDir()
-		if err != nil {
-			b.Fatal(err)
-		}
-		defer os.RemoveAll(sockDir)
-
-		var t testing.T
-		testCCProxySockPath := fmt.Sprintf(testCCProxySockPathTempl, sockDir)
-		noopProxyURL = testCCProxyURLUnixScheme + testCCProxySockPath
-		proxy := mock.NewCCProxyMock(&t, testCCProxySockPath)
-		proxy.Start()
-		defer proxy.Stop()
-
-		createStartStopDeleteSandbox(b, sandboxConfig)
-	}
-}
-
-func BenchmarkCreateStartStopDeleteSandboxQemuHypervisorNoopAgentNetworkCNI(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		sandboxConfig := createNewSandboxConfig(QemuHypervisor, NoopAgentType, nil, CNINetworkModel)
-		createStartStopDeleteSandbox(b, sandboxConfig)
-	}
-}
-
 func BenchmarkCreateStartStopDeleteSandboxQemuHypervisorHyperstartAgentNetworkNoop(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		sandboxConfig := createNewSandboxConfig(QemuHypervisor, HyperstartAgent, HyperConfig{}, NoopNetworkModel)

virtcontainers/cni.go

@@ -1,172 +0,0 @@
-// Copyright (c) 2016 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-package virtcontainers
-
-import (
-	"fmt"
-
-	cniTypes "github.com/containernetworking/cni/pkg/types"
-	cniV2Types "github.com/containernetworking/cni/pkg/types/020"
-	cniLatestTypes "github.com/containernetworking/cni/pkg/types/current"
-	cniPlugin "github.com/kata-containers/runtime/virtcontainers/pkg/cni"
-	"github.com/sirupsen/logrus"
-)
-
-// CniPrimaryInterface Name chosen for the primary interface
-// If CNI ever support multiple primary interfaces this should be revisited
-const CniPrimaryInterface = "eth0"
-
-// cni is a network implementation for the CNI plugin.
-type cni struct{}
-
-// Logger returns a logrus logger appropriate for logging cni messages
-func (n *cni) Logger() *logrus.Entry {
-	return virtLog.WithField("subsystem", "cni")
-}
-
-func cniDNSToDNSInfo(cniDNS cniTypes.DNS) DNSInfo {
-	return DNSInfo{
-		Servers:  cniDNS.Nameservers,
-		Domain:   cniDNS.Domain,
-		Searches: cniDNS.Search,
-		Options:  cniDNS.Options,
-	}
-}
-
-func convertLatestCNIResult(result *cniLatestTypes.Result) NetworkInfo {
-	return NetworkInfo{
-		DNS: cniDNSToDNSInfo(result.DNS),
-	}
-}
-
-func convertV2CNIResult(result *cniV2Types.Result) NetworkInfo {
-	return NetworkInfo{
-		DNS: cniDNSToDNSInfo(result.DNS),
-	}
-}
-
-func convertCNIResult(cniResult cniTypes.Result) (NetworkInfo, error) {
-	switch result := cniResult.(type) {
-	case *cniLatestTypes.Result:
-		return convertLatestCNIResult(result), nil
-	case *cniV2Types.Result:
-		return convertV2CNIResult(result), nil
-	default:
-		return NetworkInfo{}, fmt.Errorf("Unknown CNI result type %T", result)
-	}
-}
-
-func (n *cni) invokePluginsAdd(sandbox *Sandbox, networkNS *NetworkNamespace) (*NetworkInfo, error) {
-	netPlugin, err := cniPlugin.NewNetworkPlugin()
-	if err != nil {
-		return nil, err
-	}
-
-	// Note: In the case of multus or cni-genie this will return only the results
-	// corresponding to the primary interface. The remaining results need to be
-	// derived
-	result, err := netPlugin.AddNetwork(sandbox.id, networkNS.NetNsPath, CniPrimaryInterface)
-	if err != nil {
-		return nil, err
-	}
-
-	netInfo, err := convertCNIResult(result)
-	if err != nil {
-		return nil, err
-	}
-
-	// We do not care about this for now but
-	// If present, the CNI DNS result has to be updated in resolv.conf
-	// if the kubelet has not supplied it already
-	n.Logger().Infof("AddNetwork results %s", result.String())
-
-	return &netInfo, nil
-}
-
-func (n *cni) invokePluginsDelete(sandbox *Sandbox, networkNS NetworkNamespace) error {
-	netPlugin, err := cniPlugin.NewNetworkPlugin()
-	if err != nil {
-		return err
-	}
-
-	err = netPlugin.RemoveNetwork(sandbox.id, networkNS.NetNsPath, CniPrimaryInterface)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (n *cni) updateEndpointsFromScan(networkNS *NetworkNamespace, netInfo *NetworkInfo, config NetworkConfig) error {
-	endpoints, err := createEndpointsFromScan(networkNS.NetNsPath, config)
-	if err != nil {
-		return err
-	}
-
-	for _, endpoint := range endpoints {
-		if CniPrimaryInterface == endpoint.Name() {
-			prop := endpoint.Properties()
-			prop.DNS = netInfo.DNS
-			endpoint.SetProperties(prop)
-			break
-		}
-	}
-
-	networkNS.Endpoints = endpoints
-	return nil
-}
-
-// init initializes the network, setting a new network namespace for the CNI network.
-func (n *cni) init(config NetworkConfig) (string, bool, error) {
-	return initNetworkCommon(config)
-}
-
-// run runs a callback in the specified network namespace.
-func (n *cni) run(networkNSPath string, cb func() error) error {
-	return runNetworkCommon(networkNSPath, cb)
-}
-
-// add adds all needed interfaces inside the network namespace for the CNI network.
-func (n *cni) add(sandbox *Sandbox, config NetworkConfig, netNsPath string, netNsCreated bool) (NetworkNamespace, error) {
-
-	networkNS := NetworkNamespace{
-		NetNsPath:    netNsPath,
-		NetNsCreated: netNsCreated,
-	}
-
-	netInfo, err := n.invokePluginsAdd(sandbox, &networkNS)
-	if err != nil {
-		return NetworkNamespace{}, err
-	}
-
-	if err := n.updateEndpointsFromScan(&networkNS, netInfo, config); err != nil {
-		return NetworkNamespace{}, err
-	}
-
-	if err := addNetworkCommon(sandbox, &networkNS); err != nil {
-		return NetworkNamespace{}, err
-	}
-
-	return networkNS, nil
-}
-
-// remove network endpoints in the network namespace. It also deletes the network
-// namespace in case the namespace has been created by us.
-func (n *cni) remove(sandbox *Sandbox, networkNS NetworkNamespace, netNsCreated bool) error {
-	if err := removeNetworkCommon(networkNS, netNsCreated); err != nil {
-		return err
-	}
-
-	if err := n.invokePluginsDelete(sandbox, networkNS); err != nil {
-		return err
-	}
-
-	if netNsCreated {
-		return deleteNetNS(networkNS.NetNsPath)
-	}
-
-	return nil
-}

virtcontainers/documentation/api/1.0/api.md

@@ -266,9 +266,6 @@ const (
 	// NoopNetworkModel is the No-Op network.
 	NoopNetworkModel NetworkModel = "noop"
 
-	// CNINetworkModel is the CNI network.
-	CNINetworkModel NetworkModel = "CNI"
-
 	// CNMNetworkModel is the CNM network.
 	CNMNetworkModel NetworkModel = "CNM"
 )

virtcontainers/network.go

@@ -540,9 +540,6 @@ const (
 	// NoopNetworkModel is the No-Op network.
 	NoopNetworkModel NetworkModel = "noop"
 
-	// CNINetworkModel is the CNI network.
-	CNINetworkModel NetworkModel = "CNI"
-
 	// CNMNetworkModel is the CNM network.
 	CNMNetworkModel NetworkModel = "CNM"
 )
@@ -553,9 +550,6 @@ func (networkType *NetworkModel) Set(value string) error {
 	case "noop":
 		*networkType = NoopNetworkModel
 		return nil
-	case "CNI":
-		*networkType = CNINetworkModel
-		return nil
 	case "CNM":
 		*networkType = CNMNetworkModel
 		return nil
@@ -569,8 +563,6 @@ func (networkType *NetworkModel) String() string {
 	switch *networkType {
 	case NoopNetworkModel:
 		return string(NoopNetworkModel)
-	case CNINetworkModel:
-		return string(CNINetworkModel)
 	case CNMNetworkModel:
 		return string(CNMNetworkModel)
 	default:
@@ -583,8 +575,6 @@ func newNetwork(networkType NetworkModel) network {
 	switch networkType {
 	case NoopNetworkModel:
 		return &noopNetwork{}
-	case CNINetworkModel:
-		return &cni{}
 	case CNMNetworkModel:
 		return &cnm{}
 	default:

virtcontainers/network_test.go

@@ -38,10 +38,6 @@ func TestNoopNetworkModelSet(t *testing.T) {
 	testNetworkModelSet(t, "noop", NoopNetworkModel)
 }
 
-func TestCNINetworkModelSet(t *testing.T) {
-	testNetworkModelSet(t, "CNI", CNINetworkModel)
-}
-
 func TestCNMNetworkModelSet(t *testing.T) {
 	testNetworkModelSet(t, "CNM", CNMNetworkModel)
 }
@@ -68,11 +64,6 @@ func TestNoopNetworkModelString(t *testing.T) {
 	testNetworkModelString(t, &netModel, string(NoopNetworkModel))
 }
 
-func TestCNINetworkModelString(t *testing.T) {
-	netModel := CNINetworkModel
-	testNetworkModelString(t, &netModel, string(CNINetworkModel))
-}
-
 func TestCNMNetworkModelString(t *testing.T) {
 	netModel := CNMNetworkModel
 	testNetworkModelString(t, &netModel, string(CNMNetworkModel))
@@ -95,10 +86,6 @@ func TestNewNoopNetworkFromNetworkModel(t *testing.T) {
 	testNewNetworkFromNetworkModel(t, NoopNetworkModel, &noopNetwork{})
 }
 
-func TestNewCNINetworkFromNetworkModel(t *testing.T) {
-	testNewNetworkFromNetworkModel(t, CNINetworkModel, &cni{})
-}
-
 func TestNewCNMNetworkFromNetworkModel(t *testing.T) {
 	testNewNetworkFromNetworkModel(t, CNMNetworkModel, &cnm{})
 }

virtcontainers/pkg/cni/OWNERS

@@ -1,6 +0,0 @@
-reviewers:
-- virtcontainers-maintainers
-
-approvers:
-- mcastelino
-- sboeuf

virtcontainers/pkg/cni/cni.go

@@ -1,156 +0,0 @@
-// Copyright (c) 2016 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-package cni
-
-import (
-	"fmt"
-	"sort"
-
-	"github.com/containernetworking/cni/libcni"
-	types "github.com/containernetworking/cni/pkg/types"
-)
-
-// CNI default values to find plugins and configurations.
-const (
-	LocalNetName  = "lo"
-	DefNetName    = "net"
-	PluginConfDir = "/etc/cni/net.d"
-	PluginBinDir  = "/opt/cni/bin"
-)
-
-var confExtensions = []string{".conf"}
-
-// NetworkPlugin is the CNI network plugin handler.
-type NetworkPlugin struct {
-	loNetwork  *cniNetwork
-	defNetwork *cniNetwork
-}
-
-type cniNetwork struct {
-	name          string
-	networkConfig *libcni.NetworkConfig
-	cniConfig     libcni.CNI
-}
-
-// NewNetworkPlugin initialize the CNI network plugin and returns
-// a handler to it.
-func NewNetworkPlugin() (*NetworkPlugin, error) {
-	return NewNetworkPluginWithArgs(PluginConfDir, PluginBinDir)
-}
-
-// NewNetworkPluginWithArgs initialize the CNI network plugin, specifying the
-// configuration and binary directories, and it returns a handler to it.
-func NewNetworkPluginWithArgs(confDir, binDir string) (*NetworkPlugin, error) {
-	var err error
-
-	plugin := &NetworkPlugin{}
-
-	plugin.loNetwork, err = getLoNetwork(confDir, binDir)
-	if err != nil {
-		return nil, err
-	}
-
-	plugin.defNetwork, err = getDefNetwork(confDir, binDir)
-	if err != nil {
-		return nil, err
-	}
-
-	return plugin, nil
-}
-
-func getNetwork(confDir, binDir, defaultName string, local bool) (*cniNetwork, error) {
-	confFiles, err := libcni.ConfFiles(confDir, confExtensions)
-	if err != nil || confFiles == nil {
-		return nil, fmt.Errorf("Invalid configuration directory %s", confDir)
-	}
-
-	if len(confFiles) == 0 {
-		return nil, fmt.Errorf("Could not find networks in %s", confDir)
-	}
-
-	if local == true {
-		sort.Sort(sort.Reverse(sort.StringSlice(confFiles)))
-	} else {
-		sort.Sort(sort.StringSlice(confFiles))
-	}
-
-	for _, confFile := range confFiles {
-		conf, err := libcni.ConfFromFile(confFile)
-		if err != nil {
-			continue
-		}
-
-		cninet := &libcni.CNIConfig{
-			Path: []string{binDir},
-		}
-
-		name := defaultName
-		if conf.Network.Name != "" {
-			name = conf.Network.Name
-		}
-
-		network := &cniNetwork{
-			name:          name,
-			networkConfig: conf,
-			cniConfig:     cninet,
-		}
-
-		return network, nil
-	}
-
-	return nil, fmt.Errorf("No valid networks found in %s", confDir)
-}
-
-func getLoNetwork(confDir, binDir string) (*cniNetwork, error) {
-	return getNetwork(confDir, binDir, LocalNetName, true)
-}
-
-func getDefNetwork(confDir, binDir string) (*cniNetwork, error) {
-	return getNetwork(confDir, binDir, DefNetName, false)
-}
-
-func buildRuntimeConf(sandboxID, sandboxNetNSPath, ifName string) *libcni.RuntimeConf {
-	return &libcni.RuntimeConf{
-		ContainerID: sandboxID,
-		NetNS:       sandboxNetNSPath,
-		IfName:      ifName,
-	}
-}
-
-// AddNetwork calls the CNI plugin to create a network between the host and the network namespace.
-func (plugin *NetworkPlugin) AddNetwork(sandboxID, netNSPath, ifName string) (types.Result, error) {
-	rt := buildRuntimeConf(sandboxID, netNSPath, ifName)
-
-	_, err := plugin.loNetwork.cniConfig.AddNetwork(plugin.loNetwork.networkConfig, rt)
-	if err != nil {
-		return nil, err
-	}
-
-	ifaceResult, err := plugin.defNetwork.cniConfig.AddNetwork(plugin.defNetwork.networkConfig, rt)
-	if err != nil {
-		return nil, err
-	}
-
-	return ifaceResult, nil
-}
-
-// RemoveNetwork calls the CNI plugin to remove a specific network previously created between
-// the host and the network namespace.
-func (plugin *NetworkPlugin) RemoveNetwork(sandboxID, netNSPath, ifName string) error {
-	rt := buildRuntimeConf(sandboxID, netNSPath, ifName)
-
-	err := plugin.defNetwork.cniConfig.DelNetwork(plugin.defNetwork.networkConfig, rt)
-	if err != nil {
-		return err
-	}
-
-	err = plugin.loNetwork.cniConfig.DelNetwork(plugin.loNetwork.networkConfig, rt)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}

virtcontainers/pkg/cni/cni_test.go

@@ -1,397 +0,0 @@
-// Copyright (c) 2016 Intel Corporation
-//
-// SPDX-License-Identifier: Apache-2.0
-//
-
-package cni
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"reflect"
-	"testing"
-
-	"github.com/containernetworking/cni/libcni"
-	"github.com/containernetworking/plugins/pkg/ns"
-)
-
-const (
-	dirMode = os.FileMode(0750)
-)
-
-var testDirBase = "../../utils/supportfiles/cni"
-var testConfDir = testDirBase + "/net.d"
-var testBinDir = testDirBase + "/bin"
-var testWrongConfDir = testDirBase + "/wrong"
-var testDefFile = "10-test_network.conf"
-var testLoFile = "99-test_loopback.conf"
-var testWrongFile = "100-test_error.conf"
-
-var testLoFileContent = []byte(`{
-    "cniVersion": "0.3.0",
-    "name": "testlonetwork",
-    "type": "loopback"
-}`)
-
-var testLoFileContentNoName = []byte(`{
-    "cniVersion": "0.3.0",
-    "type": "loopback"
-}`)
-
-var testDefFileContent = []byte(`{
-    "cniVersion": "0.3.0",
-    "name": "testdefnetwork",
-    "type": "cni-bridge",
-    "bridge": "cni0",
-    "isGateway": true,
-    "ipMasq": true,
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.88.0.0/16",
-        "routes": [
-            { "dst": "0.0.0.0/0" }
-        ]
-    }
-}`)
-
-var testDefFileContentNoName = []byte(`{
-    "cniVersion": "0.3.0",
-    "type": "cni-bridge",
-    "bridge": "cni0",
-    "isGateway": true,
-    "ipMasq": true,
-    "ipam": {
-        "type": "host-local",
-        "subnet": "10.88.0.0/16",
-        "routes": [
-            { "dst": "0.0.0.0/0" }
-        ]
-    }
-}`)
-
-var testWrongFileContent = []byte(`{
-    "cniVersion "0.3.0",
-    "type": "loopback"
-}`)
-
-func createLoNetwork(t *testing.T) {
-	loFile := filepath.Join(testConfDir, testLoFile)
-
-	f, err := os.Create(loFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-
-	_, err = f.Write(testLoFileContent)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func createLoNetworkNoName(t *testing.T) {
-	loFile := filepath.Join(testConfDir, testLoFile)
-
-	f, err := os.Create(loFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-
-	_, err = f.Write(testLoFileContentNoName)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func createDefNetwork(t *testing.T) {
-	defFile := filepath.Join(testConfDir, testDefFile)
-
-	f, err := os.Create(defFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-
-	_, err = f.Write(testDefFileContent)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func createDefNetworkNoName(t *testing.T) {
-	defFile := filepath.Join(testConfDir, testDefFile)
-
-	f, err := os.Create(defFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-
-	_, err = f.Write(testDefFileContentNoName)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func createWrongNetwork(t *testing.T) {
-	wrongFile := filepath.Join(testConfDir, testWrongFile)
-
-	f, err := os.Create(wrongFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-
-	_, err = f.Write(testWrongFileContent)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func removeLoNetwork(t *testing.T) {
-	loFile := filepath.Join(testConfDir, testLoFile)
-	err := os.Remove(loFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func removeDefNetwork(t *testing.T) {
-	defFile := filepath.Join(testConfDir, testDefFile)
-	err := os.Remove(defFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func removeWrongNetwork(t *testing.T) {
-	wrongFile := filepath.Join(testConfDir, testWrongFile)
-	err := os.Remove(wrongFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestNewNetworkPluginSuccessful(t *testing.T) {
-	createLoNetwork(t)
-	defer removeLoNetwork(t)
-	createDefNetwork(t)
-	defer removeDefNetwork(t)
-
-	netPlugin, err := NewNetworkPluginWithArgs(testConfDir, testBinDir)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if netPlugin.loNetwork == nil {
-		t.Fatal("Invalid local network")
-	}
-
-	if netPlugin.defNetwork == nil {
-		t.Fatal("Invalid default network")
-	}
-
-	if netPlugin.loNetwork.name != "testlonetwork" {
-		t.Fatal("Invalid local network name")
-	}
-
-	if netPlugin.defNetwork.name != "testdefnetwork" {
-		t.Fatal("Invalid default network name")
-	}
-}
-
-func TestNewNetworkPluginSuccessfulNoName(t *testing.T) {
-	createLoNetworkNoName(t)
-	defer removeLoNetwork(t)
-	createDefNetworkNoName(t)
-	defer removeDefNetwork(t)
-
-	netPlugin, err := NewNetworkPluginWithArgs(testConfDir, testBinDir)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if netPlugin.loNetwork == nil {
-		t.Fatal("Invalid local network")
-	}
-
-	if netPlugin.defNetwork == nil {
-		t.Fatal("Invalid default network")
-	}
-
-	if netPlugin.loNetwork.name != "lo" {
-		t.Fatal("Invalid local network name")
-	}
-
-	if netPlugin.defNetwork.name != "net" {
-		t.Fatal("Invalid default network name")
-	}
-}
-
-func TestNewNetworkPluginFailureNoNetwork(t *testing.T) {
-	netPlugin, err := NewNetworkPluginWithArgs(testConfDir, testBinDir)
-	if err == nil || netPlugin != nil {
-		t.Fatal("Should fail because no available network")
-	}
-}
-
-func TestNewNetworkPluginFailureNoConfDir(t *testing.T) {
-	netPlugin, err := NewNetworkPluginWithArgs(testWrongConfDir, testBinDir)
-	if err == nil || netPlugin != nil {
-		t.Fatal("Should fail because configuration directory does not exist")
-	}
-}
-
-func TestNewNetworkPluginFailureWrongNetwork(t *testing.T) {
-	createWrongNetwork(t)
-	defer removeWrongNetwork(t)
-
-	netPlugin, err := NewNetworkPluginWithArgs(testConfDir, testBinDir)
-	if err == nil || netPlugin != nil {
-		t.Fatal("Should fail because of wrong network definition")
-	}
-}
-
-func TestBuildRuntimeConf(t *testing.T) {
-	expected := libcni.RuntimeConf{
-		ContainerID: "testSandboxID",
-		NetNS:       "testSandboxNetNSPath",
-		IfName:      "testIfName",
-	}
-
-	runtimeConf := buildRuntimeConf("testSandboxID", "testSandboxNetNSPath", "testIfName")
-
-	if reflect.DeepEqual(*runtimeConf, expected) == false {
-		t.Fatal("Runtime configuration different from expected one")
-	}
-}
-
-func TestAddNetworkSuccessful(t *testing.T) {
-	createLoNetworkNoName(t)
-	defer removeLoNetwork(t)
-	createDefNetworkNoName(t)
-	defer removeDefNetwork(t)
-
-	netNsHandle, err := ns.NewNS()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer netNsHandle.Close()
-
-	testNetNsPath := netNsHandle.Path()
-
-	netPlugin, err := NewNetworkPluginWithArgs(testConfDir, testBinDir)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = netPlugin.AddNetwork("testSandboxID", testNetNsPath, "testIfName")
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestAddNetworkFailureUnknownNetNs(t *testing.T) {
-	createLoNetworkNoName(t)
-	defer removeLoNetwork(t)
-	createDefNetworkNoName(t)
-	defer removeDefNetwork(t)
-
-	const invalidNetNsPath = "/this/path/does/not/exist"
-
-	// ensure it really is invalid
-	_, err := os.Stat(invalidNetNsPath)
-	if err == nil {
-		t.Fatalf("directory %v unexpectedly exists", invalidNetNsPath)
-	}
-
-	netPlugin, err := NewNetworkPluginWithArgs(testConfDir, testBinDir)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = netPlugin.AddNetwork("testSandboxID", invalidNetNsPath, "testIfName")
-	if err == nil {
-		t.Fatalf("Should fail because netns %s does not exist", invalidNetNsPath)
-	}
-}
-
-func TestRemoveNetworkSuccessful(t *testing.T) {
-	createLoNetworkNoName(t)
-	defer removeLoNetwork(t)
-	createDefNetworkNoName(t)
-	defer removeDefNetwork(t)
-
-	netNsHandle, err := ns.NewNS()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer netNsHandle.Close()
-
-	testNetNsPath := netNsHandle.Path()
-
-	netPlugin, err := NewNetworkPluginWithArgs(testConfDir, testBinDir)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = netPlugin.AddNetwork("testSandboxID", testNetNsPath, "testIfName")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = netPlugin.RemoveNetwork("testSandboxID", testNetNsPath, "testIfName")
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestRemoveNetworkSuccessfulNetworkDoesNotExist(t *testing.T) {
-	createLoNetworkNoName(t)
-	defer removeLoNetwork(t)
-	createDefNetworkNoName(t)
-	defer removeDefNetwork(t)
-
-	netNsHandle, err := ns.NewNS()
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer netNsHandle.Close()
-
-	testNetNsPath := netNsHandle.Path()
-
-	netPlugin, err := NewNetworkPluginWithArgs(testConfDir, testBinDir)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	err = netPlugin.RemoveNetwork("testSandboxID", testNetNsPath, "testIfName")
-	if err != nil {
-		// CNI specification says that no error should be returned
-		// in case we try to tear down a non-existing network.
-		t.Fatalf("Should pass because network not previously added: %s", err)
-	}
-}
-
-func TestMain(m *testing.M) {
-	err := os.MkdirAll(testConfDir, dirMode)
-	if err != nil {
-		fmt.Println("Could not create test configuration directory:", err)
-		os.Exit(1)
-	}
-
-	_, err = os.Stat(testBinDir)
-	if err != nil {
-		fmt.Println("Test binary directory should exist:", err)
-		os.RemoveAll(testConfDir)
-		os.Exit(1)
-	}
-
-	ret := m.Run()
-
-	os.RemoveAll(testConfDir)
-
-	os.Exit(ret)
-}