Golang Namespace.Execute方法代碼示例

func (a *ARPInserter) HandleResolvedNeighbors(ready chan error, ns namespace.Namespace, vxlanDeviceName string, resolvedChan <-chan watcher.Neighbor) {

	var vxlanLink netlink.Link
	err := ns.Execute(func(f *os.File) error {
		var err error
		vxlanLink, err = a.Netlinker.LinkByName(vxlanDeviceName)
		if err != nil {
			return fmt.Errorf("find link %q: %s", vxlanDeviceName, err)
		}
		return nil
	})
	if err != nil {
		ready <- fmt.Errorf("namespace execute failed: %s", err)
		close(ready)
		return
	}

	close(ready)

	a.addNeighbors(vxlanLink.Attrs().Index, ns, resolvedChan)
}

func (a *ARPInserter) addNeighbors(vxlanLinkIndex int, ns namespace.Namespace, resolvedChan <-chan watcher.Neighbor) {
	for msg := range resolvedChan {
		neigh := reverseConvert(msg.Neigh)
		neigh.State = netlink.NUD_REACHABLE

		fdb := &netlink.Neigh{
			LinkIndex:    vxlanLinkIndex,
			HardwareAddr: neigh.HardwareAddr,
			IP:           msg.VTEP,
			Family:       syscall.AF_BRIDGE,
			Flags:        netlink.NTF_SELF,
			State:        netlink.NUD_REACHABLE,
		}

		a.Logger.Info("adding-neigbor", lager.Data{
			"neigh":   neigh.String(),
			"fdb":     fdb,
			"hw_addr": neigh.HardwareAddr.String(),
		})

		err := ns.Execute(func(*os.File) error {
			err := a.Netlinker.SetNeigh(neigh)
			if err != nil {
				return fmt.Errorf("set L3 neighbor failed: %s", err)
			}

			err = a.Netlinker.SetNeigh(fdb)
			if err != nil {
				return fmt.Errorf("set L2 forward failed: %s", err)
			}

			return nil
		})
		if err != nil {
			a.Logger.Error("add-neighbor-failed", err)
		}
	}
}

func (s *Subscriber) Subscribe(
	sandboxNS namespace.Namespace,
	neighChan chan<- *watcher.Neigh,
	doneChan <-chan struct{},
) error {
	logger := s.Logger.Session("subscribe")
	logger.Info("called")
	defer logger.Info("complete")

	var sock nl.NLSocket
	err := sandboxNS.Execute(func(*os.File) error {
		var err error
		sock, err = s.Netlinker.Subscribe(syscall.NETLINK_ROUTE, syscall.RTNLGRP_NEIGH)
		if err != nil {
			logger.Error("netlink-subscribe-failed", err)
			return fmt.Errorf("failed to acquire netlink socket: %s", err)
		}
		return nil
	})
	if err != nil {
		return fmt.Errorf("namespace execute: %s", err)
	}

	go func() {
		<-doneChan
		logger.Info("closing-netlink-socket")
		sock.Close()
		logger.Info("closed-netlink-socket")
	}()

	go func() {
		defer func() {
			logger.Info("closing-neigh-chan")
			close(neighChan)
			logger.Info("closed-neigh-chan")
		}()

		for {
			msgs, err := sock.Receive()
			logger.Info("receive-message-count", lager.Data{"message-count": len(msgs)})
			if err != nil {
				s.Logger.Error("socket-receive", err)
				return
			}

			for _, m := range msgs {
				n, err := s.Netlinker.NeighDeserialize(m.Data)
				if err != nil {
					s.Logger.Error("neighbor-deserialize", err)
					return
				}

				if n.IP == nil || (n.HardwareAddr != nil && n.State != netlink.NUD_STALE) {
					continue
				}

				neigh := convertNeigh(n)

				neighChan <- neigh
			}
		}
	}()

	return nil
}

			ContainerNamespace: containerNamespace.Name(),
			ContainerID:        containerID,
		}

		By("adding the container to a network")
		_, err = daemonClient.ContainerUp(upSpec)
		Expect(err).NotTo(HaveOccurred())
	})

	AfterEach(func() {
		By("removing the container from the network")
		Expect(daemonClient.ContainerDown(downSpec)).To(Succeed())

		session.Interrupt()
		Eventually(session, DEFAULT_TIMEOUT).Should(gexec.Exit(0))
		Expect(containerRepo.Destroy(containerNamespace)).To(Succeed())
	})

	It("catches L3 misses", func() {
		time.Sleep(2 * time.Second)
		err := containerNamespace.Execute(func(_ *os.File) error {
			_, err := net.DialTimeout("tcp", "192.168.1.100:1234", 1*time.Second)
			Expect(err).To(HaveOccurred())
			return nil
		})
		Expect(err).NotTo(HaveOccurred())

		Eventually(session.Out, "5s").Should(gbytes.Say("ducatid.sandbox-miss.*dest_ip.*192.168.1.100.*sandbox.*vni-%d", vni))
	})
})

			By("removing the container from the network")
			Expect(daemonClient.ContainerDown(downSpec)).To(Succeed())

			By("checking that containers have been removed")
			containers, err := daemonClient.ListNetworkContainers(networkID)
			Expect(err).NotTo(HaveOccurred())
			Expect(containers).To(HaveLen(0))

			By("checking that the sandbox has been cleaned up")
			_, err = sandboxRepo.Get(sandboxName)
			Expect(err).To(MatchError(ContainSubstring("no such file or directory")))

			By("checking that the veth device is no longer in the container")
			err = containerNamespace.Execute(func(_ *os.File) error {
				_, err := netlink.LinkByName("vx-eth0")
				Expect(err).To(MatchError(ContainSubstring("Link not found")))
				return nil
			})
			Expect(err).NotTo(HaveOccurred())
		})

		It("makes container metadata available on the list network containers endpoint", func() {
			containers, err := daemonClient.ListNetworkContainers(networkID)
			Expect(err).NotTo(HaveOccurred())

			Expect(containers).To(HaveLen(1))
			Expect(containers[0].HostIP).To(Equal(hostAddress))
		})

		It("makes container metadata available on the /containers endpoint", func() {
			containers, err := daemonClient.ListContainers()