func createGlobalInstance(t *testing.T) { var err error defer close(start) origns, err = netns.Get() if err != nil { t.Fatal(err) } if netutils.IsRunningInContainer() { testns = origns } else { testns, err = netns.New() if err != nil { t.Fatal(err) } } netOption := options.Generic{ netlabel.GenericData: options.Generic{ "BridgeName": "network", "AllowNonDefaultBridge": true, }, } net, err := createTestNetwork(bridgeNetType, "network", netOption) if err != nil { t.Fatal("new network") } _, err = net.CreateEndpoint("ep1") if err != nil { t.Fatal("createendpoint") } }
func createGlobalInstance(t *testing.T) { var err error defer close(start) origns, err = netns.Get() if err != nil { t.Fatal(err) } if netutils.IsRunningInContainer() { testns = origns } else { testns, err = netns.New() if err != nil { t.Fatal(err) } } netOption := options.Generic{ netlabel.GenericData: options.Generic{ "BridgeName": "network", "AllowNonDefaultBridge": true, }, } net1, err := controller.NetworkByName("testhost") if err != nil { t.Fatal(err) } net2, err := createTestNetwork("bridge", "network2", netOption) if err != nil { t.Fatal(err) } _, err = net1.CreateEndpoint("pep1") if err != nil { t.Fatal(err) } _, err = net2.CreateEndpoint("pep2") if err != nil { t.Fatal(err) } _, err = net2.CreateEndpoint("pep3") if err != nil { t.Fatal(err) } if sboxes[first-1], err = controller.NewSandbox(fmt.Sprintf("%drace", first), libnetwork.OptionUseDefaultSandbox()); err != nil { t.Fatal(err) } for thd := first + 1; thd <= last; thd++ { if sboxes[thd-1], err = controller.NewSandbox(fmt.Sprintf("%drace", thd)); err != nil { t.Fatal(err) } } }
func initParallel() { ns1, initError = netns.New() if initError != nil { return } handle1, initError = NewHandleAt(ns1) if initError != nil { return } ns2, initError = netns.New() if initError != nil { return } handle2, initError = NewHandleAt(ns2) if initError != nil { return } }
func TestRouteSubscribeAt(t *testing.T) { // Create an handle on a custom netns newNs, err := netns.New() if err != nil { t.Fatal(err) } defer newNs.Close() nh, err := NewHandleAt(newNs) if err != nil { t.Fatal(err) } defer nh.Delete() // Subscribe for Route events on the custom netns ch := make(chan RouteUpdate) done := make(chan struct{}) defer close(done) if err := RouteSubscribeAt(newNs, ch, done); err != nil { t.Fatal(err) } // get loopback interface link, err := nh.LinkByName("lo") if err != nil { t.Fatal(err) } // bring the interface up if err = nh.LinkSetUp(link); err != nil { t.Fatal(err) } // add a gateway route dst := &net.IPNet{ IP: net.IPv4(192, 169, 0, 0), Mask: net.CIDRMask(24, 32), } ip := net.IPv4(127, 100, 1, 1) route := Route{LinkIndex: link.Attrs().Index, Dst: dst, Src: ip} if err := nh.RouteAdd(&route); err != nil { t.Fatal(err) } if !expectRouteUpdate(ch, syscall.RTM_NEWROUTE, dst.IP) { t.Fatal("Add update not received as expected") } if err := nh.RouteDel(&route); err != nil { t.Fatal(err) } if !expectRouteUpdate(ch, syscall.RTM_DELROUTE, dst.IP) { t.Fatal("Del update not received as expected") } }
func createGlobalInstance(t *testing.T) { var err error defer close(start) origns, err = netns.Get() if err != nil { t.Fatal(err) } if netutils.IsRunningInContainer() { testns = origns } else { testns, err = netns.New() if err != nil { t.Fatal(err) } } netOption := options.Generic{ netlabel.GenericData: options.Generic{ "BridgeName": "network", "AllowNonDefaultBridge": true, }, } net1, err := controller.NetworkByName("testhost") if err != nil { t.Fatal(err) } net2, err := createTestNetwork("bridge", "network2", netOption) if err != nil { t.Fatal(err) } _, err = net1.CreateEndpoint("pep1") if err != nil { t.Fatal(err) } _, err = net2.CreateEndpoint("pep2") if err != nil { t.Fatal(err) } _, err = net2.CreateEndpoint("pep3") if err != nil { t.Fatal(err) } }
// NewNs creates a new network namespace and returns a handle to it. The caller // is responsible for calling Close on the handle when done with it. func NewNs() netns.NsHandle { runtime.LockOSThread() defer runtime.UnlockOSThread() origns, err := netns.Get() if err != nil { panic(err) } n, err := netns.New() if err != nil { panic(err) } if err := netns.Set(origns); err != nil { panic(err) } return n }
func TestLinkSubscribeAt(t *testing.T) { // Create an handle on a custom netns newNs, err := netns.New() if err != nil { t.Fatal(err) } defer newNs.Close() nh, err := NewHandleAt(newNs) if err != nil { t.Fatal(err) } defer nh.Delete() // Subscribe for Link events on the custom netns ch := make(chan LinkUpdate) done := make(chan struct{}) defer close(done) if err := LinkSubscribeAt(newNs, ch, done); err != nil { t.Fatal(err) } link := &Veth{LinkAttrs{Name: "test", TxQLen: testTxQLen, MTU: 1400}, "bar"} if err := nh.LinkAdd(link); err != nil { t.Fatal(err) } if !expectLinkUpdate(ch, "test", false) { t.Fatal("Add update not received as expected") } if err := nh.LinkSetUp(link); err != nil { t.Fatal(err) } if !expectLinkUpdate(ch, "test", true) { t.Fatal("Link Up update not received as expected") } if err := nh.LinkDel(link); err != nil { t.Fatal(err) } if !expectLinkUpdate(ch, "test", false) { t.Fatal("Del update not received as expected") } }
func setUpNetlinkTest(t *testing.T) tearDownNetlinkTest { if os.Getuid() != 0 { msg := "Skipped test because it requires root privileges." log.Printf(msg) t.Skip(msg) } // new temporary namespace so we don't pollute the host // lock thread since the namespace is thread local runtime.LockOSThread() var err error ns, err := netns.New() if err != nil { t.Fatal("Failed to create newns", ns) } return func() { ns.Close() runtime.UnlockOSThread() } }
func createGlobalInstance(t *testing.T) { var err error defer close(start) origns, err = netns.Get() if err != nil { t.Fatal(err) } if netutils.IsRunningInContainer() { testns = origns } else { testns, err = netns.New() if err != nil { t.Fatal(err) } } ctrlr, err = libnetwork.New() if err != nil { t.Fatal(err) } err = ctrlr.ConfigureNetworkDriver(bridgeNetType, getEmptyGenericOption()) if err != nil { t.Fatal("configure driver") } net, err := ctrlr.NewNetwork(bridgeNetType, "network1") if err != nil { t.Fatal("new network") } _, err = net.CreateEndpoint("ep1") if err != nil { t.Fatal("createendpoint") } }
func ensureNetwork(t *testing.T) *netns.NsHandle { addrs, err := netlink.AddrList(nil, netlink.FAMILY_V4) if err != nil { t.Fatal("Failed to list addresses", err) } for _, a := range addrs { if a.Label == "lo-wormhole" { // NOTE(vish): We are already namespaced so just continue. This // means we can leak data between tests if wormhole // doesn't cleanup afeter itself, but it makes the // tests run 5x faster. return nil } } ns, err := netns.New() if err != nil { t.Fatal("Failed to create newns", ns) } link, err := netlink.LinkByName("lo") if err != nil { t.Fatal(err) } err = netlink.LinkSetUp(link) if err != nil { t.Fatal(err) } addrAdd(t, link, "127.0.0.1/32 lo-wormhole") addrAdd(t, link, "127.0.0.2/32") _, dst, _ := net.ParseCIDR("0.0.0.0/0") err = netlink.RouteAdd(&netlink.Route{LinkIndex: link.Attrs().Index, Dst: dst}) if err != nil { t.Fatal(err) } return &ns }
func createNetworkNamespace(path string, osCreate bool) (*Info, error) { runtime.LockOSThread() defer runtime.UnlockOSThread() origns, err := netns.Get() if err != nil { return nil, err } defer origns.Close() if err := createNamespaceFile(path); err != nil { return nil, err } if osCreate { defer netns.Set(origns) newns, err := netns.New() if err != nil { return nil, err } defer newns.Close() if err := loopbackUp(); err != nil { return nil, err } } procNet := fmt.Sprintf("/proc/%d/task/%d/ns/net", os.Getpid(), syscall.Gettid()) if err := syscall.Mount(procNet, path, "bind", syscall.MS_BIND, ""); err != nil { return nil, err } interfaces := []*Interface{} info := &Info{Interfaces: interfaces} return info, nil }
func TestLinkSetNs(t *testing.T) { tearDown := setUpNetlinkTest(t) defer tearDown() basens, err := netns.Get() if err != nil { t.Fatal("Failed to get basens") } defer basens.Close() newns, err := netns.New() if err != nil { t.Fatal("Failed to create newns") } defer newns.Close() link := &Veth{LinkAttrs{Name: "foo"}, "bar"} if err := LinkAdd(link); err != nil { t.Fatal(err) } peer, err := LinkByName("bar") if err != nil { t.Fatal(err) } LinkSetNsFd(peer, int(basens)) if err != nil { t.Fatal("Failed to set newns for link") } _, err = LinkByName("bar") if err == nil { t.Fatal("Link bar is still in newns") } err = netns.Set(basens) if err != nil { t.Fatal("Failed to set basens") } peer, err = LinkByName("bar") if err != nil { t.Fatal("Link is not in basens") } if err := LinkDel(peer); err != nil { t.Fatal(err) } err = netns.Set(newns) if err != nil { t.Fatal("Failed to set newns") } _, err = LinkByName("foo") if err == nil { t.Fatal("Other half of veth pair not deleted") } }
func TestHandleCreateNetns(t *testing.T) { id := make([]byte, 4) if _, err := io.ReadFull(rand.Reader, id); err != nil { t.Fatal(err) } ifName := "dummy-" + hex.EncodeToString(id) // Create an handle on the current netns curNs, err := netns.Get() if err != nil { t.Fatal(err) } defer curNs.Close() ch, err := NewHandleAt(curNs) if err != nil { t.Fatal(err) } defer ch.Delete() // Create an handle on a custom netns newNs, err := netns.New() if err != nil { t.Fatal(err) } defer newNs.Close() nh, err := NewHandleAt(newNs) if err != nil { t.Fatal(err) } defer nh.Delete() // Create an interface using the current handle err = ch.LinkAdd(&Dummy{LinkAttrs{Name: ifName}}) if err != nil { t.Fatal(err) } l, err := ch.LinkByName(ifName) if err != nil { t.Fatal(err) } if l.Type() != "dummy" { t.Fatalf("Unexpected link type: %s", l.Type()) } // Verify the new handle cannot find the interface ll, err := nh.LinkByName(ifName) if err == nil { t.Fatalf("Unexpected link found on netns %s: %v", newNs, ll) } // Move the interface to the new netns err = ch.LinkSetNsFd(l, int(newNs)) if err != nil { t.Fatal(err) } // Verify new netns handle can find the interface while current cannot ll, err = nh.LinkByName(ifName) if err != nil { t.Fatal(err) } if ll.Type() != "dummy" { t.Fatalf("Unexpected link type: %s", ll.Type()) } ll, err = ch.LinkByName(ifName) if err == nil { t.Fatalf("Unexpected link found on netns %s: %v", curNs, ll) } }
func (s *NetSetup) SetUpTest(c *C) { la := netlink.NewLinkAttrs() s.ifName = "testlinkfoo" la.Name = s.ifName runtime.LockOSThread() locked := true defer func() { if locked { runtime.UnlockOSThread() } }() globalNS, err := netns.Get() if err != nil { c.Fatalf("failed to get the global network namespace: %v", err) } s.globalNS = globalNS defer func() { netns.Set(globalNS) }() newNS, err := netns.New() if err != nil { c.Fatal("failed to create new network namespace") } s.newNS = newNS cmd := exec.Command("sleep", "infinity") if err = cmd.Start(); err != nil { c.Fatalf("failed to start the 'sleep 9999' process: %v", err) } s.cmd = cmd s.pid = cmd.Process.Pid if err = netns.Set(globalNS); err != nil { c.Fatalf("failed to return to the global netns: %v", err) } // the rest of the code should run without a locked thread if locked { runtime.UnlockOSThread() locked = false } dummy := &netlink.Dummy{LinkAttrs: la} if err := netlink.LinkAdd(dummy); err != nil { c.Fatalf("failed to add dummy interface: %v", err) } link, err := netlink.LinkByName(la.Name) if err != nil { c.Fatalf("failed to get interface by name: %v", err) } s.link = link netIf, err := net.InterfaceByName(la.Name) if err != nil { c.Fatalf("InterfaceByName failed: %v", err) } if netIf.Flags&net.FlagUp != 0 { c.Fatalf("expected interface to be down, but it's up") } }