func TestSetupGatewayIPv4(t *testing.T) { defer testutils.SetupTestOSContext(t)() nh, err := netlink.NewHandle() if err != nil { t.Fatal(err) } defer nh.Delete() ip, nw, _ := net.ParseCIDR("192.168.0.24/16") nw.IP = ip gw := net.ParseIP("192.168.2.254") config := &networkConfiguration{ BridgeName: DefaultBridgeName, DefaultGatewayIPv4: gw} br := &bridgeInterface{bridgeIPv4: nw, nlh: nh} if err := setupGatewayIPv4(config, br); err != nil { t.Fatalf("Set Default Gateway failed: %v", err) } if !gw.Equal(br.gatewayIPv4) { t.Fatalf("Set Default Gateway failed. Expected %v, Found %v", gw, br.gatewayIPv4) } }
func TestSetupFixedCIDRv6(t *testing.T) { defer testutils.SetupTestOSContext(t)() config := &networkConfiguration{} br := newInterface(config) _, config.FixedCIDRv6, _ = net.ParseCIDR("2002:db8::/48") if err := setupDevice(config, br); err != nil { t.Fatalf("Bridge creation failed: %v", err) } if err := setupBridgeIPv4(config, br); err != nil { t.Fatalf("Assign IPv4 to bridge failed: %v", err) } if err := setupBridgeIPv6(config, br); err != nil { t.Fatalf("Assign IPv4 to bridge failed: %v", err) } if err := setupFixedCIDRv6(config, br); err != nil { t.Fatalf("Failed to setup bridge FixedCIDRv6: %v", err) } var ip net.IP if ip, err := ipAllocator.RequestIP(config.FixedCIDRv6, nil); err != nil { t.Fatalf("Failed to request IP to allocator: %v", err) } else if expected := "2002:db8::1"; ip.String() != expected { t.Fatalf("Expected allocated IP %s, got %s", expected, ip) } if err := ipAllocator.ReleaseIP(config.FixedCIDRv6, ip); err != nil { t.Fatalf("Failed to release IP from allocator: %v", err) } else if _, err := ipAllocator.RequestIP(config.FixedCIDRv6, ip); err != nil { t.Fatalf("Failed to request a released IP: %v", err) } }
func TestEndpointDeleteWithActiveContainer(t *testing.T) { if !testutils.IsRunningInContainer() { defer testutils.SetupTestOSContext(t)() } n, err := createTestNetwork(bridgeNetType, "testnetwork", options.Generic{ netlabel.GenericData: options.Generic{ "BridgeName": "testnetwork", }, }, nil, nil) if err != nil { t.Fatal(err) } defer func() { if err := n.Delete(); err != nil { t.Fatal(err) } }() ep, err := n.CreateEndpoint("ep1") if err != nil { t.Fatal(err) } defer func() { err = ep.Delete(false) if err != nil { t.Fatal(err) } }() cnt, err := controller.NewSandbox(containerID, libnetwork.OptionHostname("test"), libnetwork.OptionDomainname("docker.io"), libnetwork.OptionExtraHost("web", "192.168.0.1")) defer func() { if err := cnt.Delete(); err != nil { t.Fatal(err) } }() err = ep.Join(cnt) if err != nil { t.Fatal(err) } defer func() { err = ep.Leave(cnt) if err != nil { t.Fatal(err) } }() err = ep.Delete(false) if err == nil { t.Fatal("Expected to fail. But instead succeeded") } if _, ok := err.(*libnetwork.ActiveContainerError); !ok { t.Fatalf("Did not fail with expected error. Actual error: %v", err) } }
func TestNetworkName(t *testing.T) { if !testutils.IsRunningInContainer() { defer testutils.SetupTestOSContext(t)() } netOption := options.Generic{ netlabel.GenericData: options.Generic{ "BridgeName": "testnetwork", }, } _, err := createTestNetwork(bridgeNetType, "", netOption, nil, nil) if err == nil { t.Fatal("Expected to fail. But instead succeeded") } if _, ok := err.(libnetwork.ErrInvalidName); !ok { t.Fatalf("Expected to fail with ErrInvalidName error. Got %v", err) } networkName := "testnetwork" n, err := createTestNetwork(bridgeNetType, networkName, netOption, nil, nil) if err != nil { t.Fatal(err) } defer func() { if err := n.Delete(); err != nil { t.Fatal(err) } }() if n.Name() != networkName { t.Fatalf("Expected network name %s, got %s", networkName, n.Name()) } }
func TestSetupNewBridge(t *testing.T) { defer testutils.SetupTestOSContext(t)() nh, err := netlink.NewHandle() if err != nil { t.Fatal(err) } defer nh.Delete() config := &networkConfiguration{BridgeName: DefaultBridgeName} br := &bridgeInterface{nlh: nh} if err := setupDevice(config, br); err != nil { t.Fatalf("Bridge creation failed: %v", err) } if br.Link == nil { t.Fatal("bridgeInterface link is nil (expected valid link)") } if _, err := nh.LinkByName(DefaultBridgeName); err != nil { t.Fatalf("Failed to retrieve bridge device: %v", err) } if br.Link.Attrs().Flags&net.FlagUp == net.FlagUp { t.Fatalf("bridgeInterface should be created down") } }
func TestSetupFixedCIDRv4(t *testing.T) { defer testutils.SetupTestOSContext(t)() config := &networkConfiguration{ BridgeName: DefaultBridgeName, AddressIPv4: &net.IPNet{IP: net.ParseIP("192.168.1.1"), Mask: net.CIDRMask(16, 32)}, FixedCIDR: &net.IPNet{IP: net.ParseIP("192.168.2.0"), Mask: net.CIDRMask(24, 32)}} br := &bridgeInterface{} if err := setupDevice(config, br); err != nil { t.Fatalf("Bridge creation failed: %v", err) } if err := setupBridgeIPv4(config, br); err != nil { t.Fatalf("Assign IPv4 to bridge failed: %v", err) } if err := setupFixedCIDRv4(config, br); err != nil { t.Fatalf("Failed to setup bridge FixedCIDRv4: %v", err) } if ip, err := ipAllocator.RequestIP(config.FixedCIDR, nil); err != nil { t.Fatalf("Failed to request IP to allocator: %v", err) } else if expected := "192.168.2.1"; ip.String() != expected { t.Fatalf("Expected allocated IP %s, got %s", expected, ip) } }
func TestSetupBadFixedCIDRv4(t *testing.T) { defer testutils.SetupTestOSContext(t)() config := &networkConfiguration{ BridgeName: DefaultBridgeName, AddressIPv4: &net.IPNet{IP: net.ParseIP("192.168.1.1"), Mask: net.CIDRMask(24, 32)}, FixedCIDR: &net.IPNet{IP: net.ParseIP("192.168.2.0"), Mask: net.CIDRMask(24, 32)}} br := &bridgeInterface{} if err := setupDevice(config, br); err != nil { t.Fatalf("Bridge creation failed: %v", err) } if err := setupBridgeIPv4(config, br); err != nil { t.Fatalf("Assign IPv4 to bridge failed: %v", err) } err := setupFixedCIDRv4(config, br) if err == nil { t.Fatal("Setup bridge FixedCIDRv4 should have failed") } if _, ok := err.(*FixedCIDRv4Error); !ok { t.Fatalf("Did not fail with expected error. Actual error: %v", err) } }
func TestSetupIPv6(t *testing.T) { defer testutils.SetupTestOSContext(t)() config, br := setupTestInterface(t) if err := setupBridgeIPv6(config, br); err != nil { t.Fatalf("Failed to setup bridge IPv6: %v", err) } procSetting, err := ioutil.ReadFile(fmt.Sprintf("/proc/sys/net/ipv6/conf/%s/disable_ipv6", config.BridgeName)) if err != nil { t.Fatalf("Failed to read disable_ipv6 kernel setting: %v", err) } if expected := []byte("0\n"); bytes.Compare(expected, procSetting) != 0 { t.Fatalf("Invalid kernel setting disable_ipv6: expected %q, got %q", string(expected), string(procSetting)) } addrsv6, err := netlink.AddrList(br.Link, netlink.FAMILY_V6) if err != nil { t.Fatalf("Failed to list device IPv6 addresses: %v", err) } var found bool for _, addr := range addrsv6 { if bridgeIPv6Str == addr.IPNet.String() { found = true break } } if !found { t.Fatalf("Bridge device does not have requested IPv6 address %v", bridgeIPv6Str) } }
func TestProgramIPTable(t *testing.T) { // Create a test bridge with a basic bridge configuration (name + IPv4). defer testutils.SetupTestOSContext(t)() nh, err := netlink.NewHandle() if err != nil { t.Fatal(err) } createTestBridge(getBasicTestConfig(), &bridgeInterface{nlh: nh}, t) // Store various iptables chain rules we care for. rules := []struct { rule iptRule descr string }{ {iptRule{table: iptables.Filter, chain: "FORWARD", args: []string{"-d", "127.1.2.3", "-i", "lo", "-o", "lo", "-j", "DROP"}}, "Test Loopback"}, {iptRule{table: iptables.Nat, chain: "POSTROUTING", preArgs: []string{"-t", "nat"}, args: []string{"-s", iptablesTestBridgeIP, "!", "-o", DefaultBridgeName, "-j", "MASQUERADE"}}, "NAT Test"}, {iptRule{table: iptables.Filter, chain: "FORWARD", args: []string{"-i", DefaultBridgeName, "!", "-o", DefaultBridgeName, "-j", "ACCEPT"}}, "Test ACCEPT NON_ICC OUTGOING"}, {iptRule{table: iptables.Filter, chain: "FORWARD", args: []string{"-o", DefaultBridgeName, "-m", "conntrack", "--ctstate", "RELATED,ESTABLISHED", "-j", "ACCEPT"}}, "Test ACCEPT INCOMING"}, {iptRule{table: iptables.Filter, chain: "FORWARD", args: []string{"-i", DefaultBridgeName, "-o", DefaultBridgeName, "-j", "ACCEPT"}}, "Test enable ICC"}, {iptRule{table: iptables.Filter, chain: "FORWARD", args: []string{"-i", DefaultBridgeName, "-o", DefaultBridgeName, "-j", "DROP"}}, "Test disable ICC"}, } // Assert the chain rules' insertion and removal. for _, c := range rules { assertIPTableChainProgramming(c.rule, c.descr, t) } }
func TestUnknownNetwork(t *testing.T) { if !testutils.IsRunningInContainer() { defer testutils.SetupTestOSContext(t)() } netOption := options.Generic{ "BridgeName": "testnetwork", } option := options.Generic{ netlabel.GenericData: netOption, } network, err := createTestNetwork(bridgeNetType, "testnetwork", option, nil, nil) if err != nil { t.Fatal(err) } err = network.Delete() if err != nil { t.Fatal(err) } err = network.Delete() if err == nil { t.Fatal("Expected to fail. But instead succeeded") } if _, ok := err.(*libnetwork.UnknownNetworkError); !ok { t.Fatalf("Did not fail with expected error. Actual error: %v", err) } }
func TestSetDefaultGw(t *testing.T) { defer testutils.SetupTestOSContext(t)() d := newDriver() if err := d.configure(nil); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } _, subnetv6, _ := net.ParseCIDR("2001:db8:ea9:9abc:b0c4::/80") var nw *net.IPNet for _, n := range bridgeNetworks { if err := netutils.CheckRouteOverlaps(n); err == nil { nw = n break } } if nw == nil { t.Skipf("Skip as no more automatic networks available") } gw4 := types.GetIPCopy(nw.IP).To4() gw4[3] = 254 gw6 := net.ParseIP("2001:db8:ea9:9abc:b0c4::254") config := &networkConfiguration{ BridgeName: DefaultBridgeName, EnableIPv6: true, FixedCIDRv6: subnetv6, DefaultGatewayIPv4: gw4, DefaultGatewayIPv6: gw6, } genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config err := d.CreateNetwork("dummy", genericOption) if err != nil { t.Fatalf("Failed to create bridge: %v", err) } te := &testEndpoint{} err = d.CreateEndpoint("dummy", "ep", te, nil) if err != nil { t.Fatalf("Failed to create endpoint: %v", err) } err = d.Join("dummy", "ep", "sbox", te, nil) if err != nil { t.Fatalf("Failed to join endpoint: %v", err) } if !gw4.Equal(te.gw) { t.Fatalf("Failed to configure default gateway. Expected %v. Found %v", gw4, te.gw) } if !gw6.Equal(te.gw6) { t.Fatalf("Failed to configure default gateway. Expected %v. Found %v", gw6, te.gw6) } }
func TestNetworkType(t *testing.T) { if !testutils.IsRunningInContainer() { defer testutils.SetupTestOSContext(t)() } netOption := options.Generic{ netlabel.GenericData: options.Generic{ "BridgeName": "testnetwork", }, } n, err := createTestNetwork(bridgeNetType, "testnetwork", netOption, nil, nil) if err != nil { t.Fatal(err) } defer func() { if err := n.Delete(); err != nil { t.Fatal(err) } }() if n.Type() != bridgeNetType { t.Fatalf("Expected network type %s, got %s", bridgeNetType, n.Type()) } }
func TestLinkCreateNoEnableIPv6(t *testing.T) { defer testutils.SetupTestOSContext(t)() d := newDriver() if err := d.Config(nil); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } config := &networkConfiguration{ BridgeName: DefaultBridgeName} genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config err := d.CreateNetwork("dummy", genericOption) if err != nil { t.Fatalf("Failed to create bridge: %v", err) } te := &testEndpoint{ifaces: []*testInterface{}} err = d.CreateEndpoint("dummy", "ep", te, nil) if err != nil { t.Fatalf("Failed to create a link: %s", err.Error()) } interfaces := te.ifaces if interfaces[0].addrv6.IP.To16() != nil { t.Fatalf("Expectd IPv6 address to be nil when IPv6 is not enabled. Got IPv6 = %s", interfaces[0].addrv6.String()) } if te.gw6.To16() != nil { t.Fatalf("Expected GatewayIPv6 to be nil when IPv6 is not enabled. Got GatewayIPv6 = %s", te.gw6.String()) } }
func TestIpamReleaseOnNetDriverFailures(t *testing.T) { if !testutils.IsRunningInContainer() { defer testutils.SetupTestOSContext(t)() } cfgOptions, err := OptionBoltdbWithRandomDBFile() c, err := New(cfgOptions...) if err != nil { t.Fatal(err) } defer c.Stop() cc := c.(*controller) bd := badDriver{failNetworkCreation: true} cc.drivers[badDriverName] = &driverData{driver: &bd, capability: driverapi.Capability{DataScope: datastore.LocalScope}} // Test whether ipam state release is invoked on network create failure from net driver // by checking whether subsequent network creation requesting same gateway IP succeeds ipamOpt := NetworkOptionIpam(ipamapi.DefaultIPAM, "", []*IpamConf{&IpamConf{PreferredPool: "10.34.0.0/16", Gateway: "10.34.255.254"}}, nil) if _, err := c.NewNetwork(badDriverName, "badnet1", ipamOpt); err == nil { t.Fatalf("bad network driver should have failed network creation") } gnw, err := c.NewNetwork("bridge", "goodnet1", ipamOpt) if err != nil { t.Fatal(err) } gnw.Delete() // Now check whether ipam release works on endpoint creation failure bd.failNetworkCreation = false bnw, err := c.NewNetwork(badDriverName, "badnet2", ipamOpt) if err != nil { t.Fatal(err) } defer bnw.Delete() if _, err := bnw.CreateEndpoint("ep0"); err == nil { t.Fatalf("bad network driver should have failed endpoint creation") } // Now create good bridge network with different gateway ipamOpt2 := NetworkOptionIpam(ipamapi.DefaultIPAM, "", []*IpamConf{&IpamConf{PreferredPool: "10.34.0.0/16", Gateway: "10.34.255.253"}}, nil) gnw, err = c.NewNetwork("bridge", "goodnet2", ipamOpt2) if err != nil { t.Fatal(err) } defer gnw.Delete() ep, err := gnw.CreateEndpoint("ep1") if err != nil { t.Fatal(err) } defer ep.Delete() expectedIP, _ := types.ParseCIDR("10.34.0.1/16") if !types.CompareIPNet(ep.Info().Iface().Address(), expectedIP) { t.Fatalf("Ipam release must have failed, endpoint has unexpected address: %v", ep.Info().Iface().Address()) } }
func TestSetupIPChains(t *testing.T) { // Create a test bridge with a basic bridge configuration (name + IPv4). defer testutils.SetupTestOSContext(t)() nh, err := netlink.NewHandle() if err != nil { t.Fatal(err) } driverconfig := &configuration{ EnableIPTables: true, } d := &driver{ config: driverconfig, } assertChainConfig(d, t) config := getBasicTestConfig() br := &bridgeInterface{nlh: nh} createTestBridge(config, br, t) assertBridgeConfig(config, br, d, t) config.EnableIPMasquerade = true assertBridgeConfig(config, br, d, t) config.EnableICC = true assertBridgeConfig(config, br, d, t) config.EnableIPMasquerade = false assertBridgeConfig(config, br, d, t) }
func TestSetupGatewayIPv6(t *testing.T) { defer testutils.SetupTestOSContext(t)() _, nw, _ := net.ParseCIDR("2001:db8:ea9:9abc:ffff::/80") gw := net.ParseIP("2001:db8:ea9:9abc:ffff::254") config := &networkConfiguration{ BridgeName: DefaultBridgeName, AddressIPv6: nw, DefaultGatewayIPv6: gw} nh, err := netlink.NewHandle() if err != nil { t.Fatal(err) } defer nh.Delete() br := &bridgeInterface{nlh: nh} if err := setupGatewayIPv6(config, br); err != nil { t.Fatalf("Set Default Gateway failed: %v", err) } if !gw.Equal(br.gatewayIPv6) { t.Fatalf("Set Default Gateway failed. Expected %v, Found %v", gw, br.gatewayIPv6) } }
func TestSandboxCreateTwice(t *testing.T) { defer testutils.SetupTestOSContext(t)() key, err := newKey(t) if err != nil { t.Fatalf("Failed to obtain a key: %v", err) } _, err = NewSandbox(key, true, false) if err != nil { t.Fatalf("Failed to create a new sandbox: %v", err) } runtime.LockOSThread() // Create another sandbox with the same key to see if we handle it // gracefully. s, err := NewSandbox(key, true, false) if err != nil { t.Fatalf("Failed to create a new sandbox: %v", err) } runtime.LockOSThread() err = s.Destroy() if err != nil { t.Fatal(err) } GC() verifyCleanup(t, s, false) }
func TestAddRemoveInterface(t *testing.T) { defer testutils.SetupTestOSContext(t)() key, err := newKey(t) if err != nil { t.Fatalf("Failed to obtain a key: %v", err) } s, err := NewSandbox(key, true, false) if err != nil { t.Fatalf("Failed to create a new sandbox: %v", err) } runtime.LockOSThread() if s.Key() != key { t.Fatalf("s.Key() returned %s. Expected %s", s.Key(), key) } tbox, err := newInfo(ns.NlHandle(), t) if err != nil { t.Fatalf("Failed to generate new sandbox info: %v", err) } for _, i := range tbox.Info().Interfaces() { err = s.AddInterface(i.SrcName(), i.DstName(), tbox.InterfaceOptions().Bridge(i.Bridge()), tbox.InterfaceOptions().Address(i.Address()), tbox.InterfaceOptions().AddressIPv6(i.AddressIPv6())) if err != nil { t.Fatalf("Failed to add interfaces to sandbox: %v", err) } } verifySandbox(t, s, []string{"0", "1", "2"}) interfaces := s.Info().Interfaces() if err := interfaces[0].Remove(); err != nil { t.Fatalf("Failed to remove interfaces from sandbox: %v", err) } verifySandbox(t, s, []string{"1", "2"}) i := tbox.Info().Interfaces()[0] if err := s.AddInterface(i.SrcName(), i.DstName(), tbox.InterfaceOptions().Bridge(i.Bridge()), tbox.InterfaceOptions().Address(i.Address()), tbox.InterfaceOptions().AddressIPv6(i.AddressIPv6())); err != nil { t.Fatalf("Failed to add interfaces to sandbox: %v", err) } verifySandbox(t, s, []string{"1", "2", "3"}) err = s.Destroy() if err != nil { t.Fatal(err) } GC() verifyCleanup(t, s, false) }
func TestCreate(t *testing.T) { defer testutils.SetupTestOSContext(t)() d := newDriver() if err := d.configure(nil); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } netconfig := &networkConfiguration{BridgeName: DefaultBridgeName} genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = netconfig if err := d.CreateNetwork("dummy", genericOption); err != nil { t.Fatalf("Failed to create bridge: %v", err) } err := d.CreateNetwork("dummy", genericOption) if err == nil { t.Fatalf("Expected bridge driver to refuse creation of second network with default name") } if _, ok := err.(types.ForbiddenError); !ok { t.Fatalf("Creation of second network with default name failed with unexpected error type") } err = d.DeleteNetwork("dummy") if err == nil { t.Fatalf("deletion of network with default name should fail on this driver") } if _, ok := err.(types.ForbiddenError); !ok { t.Fatalf("deletion of network with default name failed with unexpected error type") } }
func TestPortMappingConfig(t *testing.T) { defer testutils.SetupTestOSContext(t)() d := newDriver() config := &configuration{ EnableIPTables: true, } genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config if err := d.configure(genericOption); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } binding1 := types.PortBinding{Proto: types.UDP, Port: uint16(400), HostPort: uint16(54000)} binding2 := types.PortBinding{Proto: types.TCP, Port: uint16(500), HostPort: uint16(65000)} portBindings := []types.PortBinding{binding1, binding2} epOptions := make(map[string]interface{}) epOptions[netlabel.PortMap] = portBindings netConfig := &networkConfiguration{ BridgeName: DefaultBridgeName, } netOptions := make(map[string]interface{}) netOptions[netlabel.GenericData] = netConfig err := d.CreateNetwork("dummy", netOptions) if err != nil { t.Fatalf("Failed to create bridge: %v", err) } te := &testEndpoint{} err = d.CreateEndpoint("dummy", "ep1", te, epOptions) if err != nil { t.Fatalf("Failed to create the endpoint: %s", err.Error()) } network, ok := d.networks["dummy"] if !ok { t.Fatalf("Cannot find network %s inside driver", "dummy") } ep, _ := network.endpoints["ep1"] if len(ep.portMapping) != 2 { t.Fatalf("Failed to store the port bindings into the sandbox info. Found: %v", ep.portMapping) } if ep.portMapping[0].Proto != binding1.Proto || ep.portMapping[0].Port != binding1.Port || ep.portMapping[1].Proto != binding2.Proto || ep.portMapping[1].Port != binding2.Port { t.Fatalf("bridgeEndpoint has incorrect port mapping values") } if ep.portMapping[0].HostIP == nil || ep.portMapping[0].HostPort == 0 || ep.portMapping[1].HostIP == nil || ep.portMapping[1].HostPort == 0 { t.Fatalf("operational port mapping data not found on bridgeEndpoint") } err = network.releasePorts(ep) if err != nil { t.Fatalf("Failed to release mapped ports: %v", err) } }
func TestNetworkID(t *testing.T) { if !testutils.IsRunningInContainer() { defer testutils.SetupTestOSContext(t)() } netOption := options.Generic{ netlabel.GenericData: options.Generic{ "BridgeName": "testnetwork", }, } n, err := createTestNetwork(bridgeNetType, "testnetwork", netOption, nil, nil) if err != nil { t.Fatal(err) } defer func() { if err := n.Delete(); err != nil { t.Fatal(err) } }() if n.ID() == "" { t.Fatal("Expected non-empty network id") } }
func TestSetupBridgeIPv4Fixed(t *testing.T) { defer testutils.SetupTestOSContext(t)() ip, netw, err := net.ParseCIDR("192.168.1.1/24") if err != nil { t.Fatalf("Failed to parse bridge IPv4: %v", err) } config, br := setupTestInterface(t) config.AddressIPv4 = &net.IPNet{IP: ip, Mask: netw.Mask} if err := setupBridgeIPv4(config, br); err != nil { t.Fatalf("Failed to setup bridge IPv4: %v", err) } addrsv4, err := netlink.AddrList(br.Link, netlink.FAMILY_V4) if err != nil { t.Fatalf("Failed to list device IPv4 addresses: %v", err) } var found bool for _, addr := range addrsv4 { if config.AddressIPv4.String() == addr.IPNet.String() { found = true break } } if !found { t.Fatalf("Bridge device does not have requested IPv4 address %v", config.AddressIPv4) } }
func TestCreateMultipleNetworks(t *testing.T) { defer testutils.SetupTestOSContext(t)() d := newDriver() config := &configuration{ EnableIPTables: true, } genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config if err := d.configure(genericOption); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } config1 := &networkConfiguration{BridgeName: "net_test_1"} genericOption = make(map[string]interface{}) genericOption[netlabel.GenericData] = config1 if err := d.CreateNetwork("1", genericOption, getIPv4Data(t), nil); err != nil { t.Fatalf("Failed to create bridge: %v", err) } config2 := &networkConfiguration{BridgeName: "net_test_2"} genericOption[netlabel.GenericData] = config2 if err := d.CreateNetwork("2", genericOption, getIPv4Data(t), nil); err != nil { t.Fatalf("Failed to create bridge: %v", err) } // Verify the network isolation rules are installed, each network subnet should appear 2 times verifyV4INCEntries(d.networks, 2, t) config3 := &networkConfiguration{BridgeName: "net_test_3"} genericOption[netlabel.GenericData] = config3 if err := d.CreateNetwork("3", genericOption, getIPv4Data(t), nil); err != nil { t.Fatalf("Failed to create bridge: %v", err) } // Verify the network isolation rules are installed, each network subnet should appear 4 times verifyV4INCEntries(d.networks, 6, t) config4 := &networkConfiguration{BridgeName: "net_test_4"} genericOption[netlabel.GenericData] = config4 if err := d.CreateNetwork("4", genericOption, getIPv4Data(t), nil); err != nil { t.Fatalf("Failed to create bridge: %v", err) } // Now 6 times verifyV4INCEntries(d.networks, 12, t) d.DeleteNetwork("1") verifyV4INCEntries(d.networks, 6, t) d.DeleteNetwork("2") verifyV4INCEntries(d.networks, 2, t) d.DeleteNetwork("3") verifyV4INCEntries(d.networks, 0, t) d.DeleteNetwork("4") verifyV4INCEntries(d.networks, 0, t) }
func TestLinkCreateTwo(t *testing.T) { defer testutils.SetupTestOSContext(t)() d := newDriver() if err := d.Config(nil); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } config := &networkConfiguration{ BridgeName: DefaultBridgeName, EnableIPv6: true} genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config err := d.CreateNetwork("dummy", genericOption) if err != nil { t.Fatalf("Failed to create bridge: %v", err) } te1 := &testEndpoint{ifaces: []*testInterface{}} err = d.CreateEndpoint("dummy", "ep", te1, nil) if err != nil { t.Fatalf("Failed to create a link: %s", err.Error()) } te2 := &testEndpoint{ifaces: []*testInterface{}} err = d.CreateEndpoint("dummy", "ep", te2, nil) if err != nil { if _, ok := err.(driverapi.ErrEndpointExists); !ok { t.Fatalf("Failed with a wrong error: %s", err.Error()) } } else { t.Fatalf("Expected to fail while trying to add same endpoint twice") } }
func TestInterfaceDefaultName(t *testing.T) { defer testutils.SetupTestOSContext(t)() config := &networkConfiguration{} if _ = newInterface(config); config.BridgeName != DefaultBridgeName { t.Fatalf("Expected default interface name %q, got %q", DefaultBridgeName, config.BridgeName) } }
func TestService(t *testing.T) { if testutils.RunningOnCircleCI() { t.Skipf("Skipping as not supported on CIRCLE CI kernel") } defer testutils.SetupTestOSContext(t)() i, err := New("") require.NoError(t, err) for _, protocol := range protocols { for _, schedMethod := range schedMethods { var serviceAddress string s := Service{ AddressFamily: nl.FAMILY_V4, SchedName: schedMethod, } switch protocol { case "FWM": s.FWMark = 1234 serviceAddress = fmt.Sprintf("%d", 1234) case "TCP": s.Protocol = syscall.IPPROTO_TCP s.Port = 80 s.Address = net.ParseIP("1.2.3.4") s.Netmask = 0xFFFFFFFF serviceAddress = "1.2.3.4:80" case "UDP": s.Protocol = syscall.IPPROTO_UDP s.Port = 53 s.Address = net.ParseIP("2.3.4.5") serviceAddress = "2.3.4.5:53" } err := i.NewService(&s) assert.NoError(t, err) checkService(t, true, protocol, schedMethod, serviceAddress) var lastMethod string for _, updateSchedMethod := range schedMethods { if updateSchedMethod == schedMethod { continue } s.SchedName = updateSchedMethod err = i.UpdateService(&s) assert.NoError(t, err) checkService(t, true, protocol, updateSchedMethod, serviceAddress) lastMethod = updateSchedMethod } err = i.DelService(&s) checkService(t, false, protocol, lastMethod, serviceAddress) } } }
func TestSandboxAddSamePrio(t *testing.T) { if !testutils.IsRunningInContainer() { defer testutils.SetupTestOSContext(t)() } c, nw1, nw2 := getTestEnv(t) ctrlr := c.(*controller) sbx, err := ctrlr.NewSandbox("sandbox1") if err != nil { t.Fatal(err) } sid := sbx.ID() ep1, err := nw1.CreateEndpoint("ep1") if err != nil { t.Fatal(err) } ep2, err := nw2.CreateEndpoint("ep2") if err != nil { t.Fatal(err) } if err := ep1.Join(sbx); err != nil { t.Fatal(err) } if err := ep2.Join(sbx); err != nil { t.Fatal(err) } if ctrlr.sandboxes[sid].endpoints[0] != ep1 { t.Fatal("Expected ep1 to be at the top of the heap. But did not find ep1 at the top of the heap") } if err := ep1.Leave(sbx); err != nil { t.Fatal(err) } if ctrlr.sandboxes[sid].endpoints[0] != ep2 { t.Fatal("Expected ep2 to be at the top of the heap after removing ep3. But did not find ep2 at the top of the heap") } if err := ep2.Leave(sbx); err != nil { t.Fatal(err) } if err := sbx.Delete(); err != nil { t.Fatal(err) } if len(ctrlr.sandboxes) != 0 { t.Fatalf("controller containers is not empty. len = %d", len(ctrlr.sandboxes)) } osl.GC() }
func TestGenerateRandomMAC(t *testing.T) { defer testutils.SetupTestOSContext(t)() mac1 := netutils.GenerateRandomMAC() mac2 := netutils.GenerateRandomMAC() if bytes.Compare(mac1, mac2) == 0 { t.Fatalf("Generated twice the same MAC address %v", mac1) } }
func TestSandboxCreate(t *testing.T) { defer testutils.SetupTestOSContext(t)() key, err := newKey(t) if err != nil { t.Fatalf("Failed to obtain a key: %v", err) } s, err := NewSandbox(key, true) if err != nil { t.Fatalf("Failed to create a new sandbox: %v", err) } runtime.LockOSThread() if s.Key() != key { t.Fatalf("s.Key() returned %s. Expected %s", s.Key(), key) } tbox, err := newInfo(t) if err != nil { t.Fatalf("Failed to generate new sandbox info: %v", err) } for _, i := range tbox.Info().Interfaces() { err = s.AddInterface(i.SrcName(), i.DstName(), tbox.InterfaceOptions().Bridge(i.Bridge()), tbox.InterfaceOptions().Address(i.Address()), tbox.InterfaceOptions().AddressIPv6(i.AddressIPv6())) if err != nil { t.Fatalf("Failed to add interfaces to sandbox: %v", err) } runtime.LockOSThread() } err = s.SetGateway(tbox.Info().Gateway()) if err != nil { t.Fatalf("Failed to set gateway to sandbox: %v", err) } runtime.LockOSThread() err = s.SetGatewayIPv6(tbox.Info().GatewayIPv6()) if err != nil { t.Fatalf("Failed to set ipv6 gateway to sandbox: %v", err) } runtime.LockOSThread() verifySandbox(t, s, []string{"0", "1", "2"}) runtime.LockOSThread() err = s.Destroy() if err != nil { t.Fatal(err) } verifyCleanup(t, s, true) }
func TestCreateFullOptions(t *testing.T) { defer testutils.SetupTestOSContext(t)() d := newDriver() config := &configuration{ EnableIPForwarding: true, EnableIPTables: true, } // Test this scenario: Default gw address does not belong to // container network and it's greater than bridge address cnw, _ := types.ParseCIDR("172.16.122.0/24") bnw, _ := types.ParseCIDR("172.16.0.0/24") br, _ := types.ParseCIDR("172.16.0.1/16") defgw, _ := types.ParseCIDR("172.16.0.100/16") netConfig := &networkConfiguration{ BridgeName: DefaultBridgeName, EnableIPv6: true, } genericOption := make(map[string]interface{}) genericOption[netlabel.GenericData] = config if err := d.configure(genericOption); err != nil { t.Fatalf("Failed to setup driver config: %v", err) } netOption := make(map[string]interface{}) netOption[netlabel.GenericData] = netConfig ipdList := []driverapi.IPAMData{ driverapi.IPAMData{ Pool: bnw, Gateway: br, AuxAddresses: map[string]*net.IPNet{DefaultGatewayV4AuxKey: defgw}, }, } err := d.CreateNetwork("dummy", netOption, ipdList, nil) if err != nil { t.Fatalf("Failed to create bridge: %v", err) } // Verify the IP address allocated for the endpoint belongs to the container network epOptions := make(map[string]interface{}) te := newTestEndpoint(cnw, 10) err = d.CreateEndpoint("dummy", "ep1", te.Interface(), epOptions) if err != nil { t.Fatalf("Failed to create an endpoint : %s", err.Error()) } if !cnw.Contains(te.Interface().Address().IP) { t.Fatalf("endpoint got assigned address outside of container network(%s): %s", cnw.String(), te.Interface().Address()) } }