Golang namespace.Namespace类代码示例

func (r *Reloader) Callback(ns namespace.Namespace) error {

	nsName := ns.Name()

	vxlanName, err := getVxlanName(nsName)
	if err != nil {
		return fmt.Errorf("get vxlan name: %s", err)
	}

	err = r.Watcher.StartMonitor(ns, vxlanName)
	if err != nil {
		return fmt.Errorf("start monitor: %s", err)
	}

	return nil
}

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 New(
	logger lager.Logger,
	namespace namespace.Namespace,
	invoker Invoker,
	linkFactory LinkFactory,
	watcher watcher.MissWatcher,
) Sandbox {
	logger = logger.Session("network-sandbox", lager.Data{"namespace": namespace.Name()})

	return &NetworkSandbox{
		logger:      logger,
		namespace:   namespace,
		invoker:     invoker,
		linkFactory: linkFactory,
		watcher:     watcher,
	}
}

func (w *missWatcher) StopMonitor(ns namespace.Namespace) error {
	w.Locker.Lock()
	defer w.Locker.Unlock()

	logger := w.Logger.Session("stop-monitor", lager.Data{"namespace": ns})
	logger.Info("called")
	defer logger.Info("complete")

	doneChan, ok := w.DoneChans[ns.Name()]
	if !ok {
		err := fmt.Errorf("namespace %s not monitored", ns.Name())
		logger.Error("done-channel-missing", err)
		return err
	}

	delete(w.DoneChans, ns.Name())
	close(doneChan)

	return nil
}

func (w *missWatcher) StartMonitor(ns namespace.Namespace, vxlanName string) error {
	logger := w.Logger.Session("start-monitor", lager.Data{"namespace": ns})
	logger.Info("called")
	defer logger.Info("complete")

	subChan := make(chan *Neigh)
	unresolvedMisses := make(chan Neighbor)
	resolvedNeighbors := make(chan Neighbor)

	doneChan := make(chan struct{})

	w.Locker.Lock()
	w.DoneChans[ns.Name()] = doneChan
	w.Locker.Unlock()

	err := w.startARPInserter(ns, vxlanName, resolvedNeighbors)
	if err != nil {
		return fmt.Errorf("arp inserter failed: %s", err)
	}

	err = w.Subscriber.Subscribe(ns, subChan, doneChan)
	if err != nil {
		return fmt.Errorf("subscribe in %s: %s", ns.Name(), err)
	}

	go func() {
		logger := logger.Session("forward-neighbor-messages")
		logger.Info("starting")
		for neigh := range subChan {
			unresolvedMisses <- Neighbor{
				SandboxName: ns.Name(),
				Neigh:       *neigh,
			}
		}
		logger.Info("complete")
	}()

	go w.Resolver.ResolveMisses(unresolvedMisses, resolvedNeighbors)

	return nil
}

	. "github.com/onsi/gomega"
	"github.com/onsi/gomega/gexec"
	"github.com/pivotal-golang/lager/lagertest"
)

var _ = Describe("Sandbox Consistency", func() {
	var (
		session        *gexec.Session
		ducatiCmd      *exec.Cmd
		address        string
		containerID    string
		vni            int
		sandboxName    string
		sandboxRepoDir string
		spaceID        string
		appID          string
		networkID      string

		logger *lagertest.TestLogger
		// sandboxRepo        namespace.Repository
		containerRepo      namespace.Repository
		containerNamespace namespace.Namespace

		configFilePath string
	)

	BeforeEach(func() {
		var err error
		address = fmt.Sprintf("127.0.0.1:%d", 4001+GinkgoParallelNode())
		sandboxRepoDir, err = ioutil.TempDir("", "sandbox")
		Expect(err).NotTo(HaveOccurred())

	"github.com/onsi/gomega/gbytes"
	"github.com/onsi/gomega/gexec"
	"github.com/pivotal-golang/lager/lagertest"
)

var _ = Describe("Networks", func() {
	var (
		session     *gexec.Session
		address     string
		containerID string
		vni         int
		spaceID     string
		networkID   string
		appID       string

		logger *lagertest.TestLogger

		sandboxRepo        namespace.Repository
		containerRepo      namespace.Repository
		containerNamespace namespace.Namespace

		upSpec       models.CNIAddPayload
		downSpec     models.CNIDelPayload
		daemonClient *client.DaemonClient
	)

	BeforeEach(func() {
		address = fmt.Sprintf("127.0.0.1:%d", 4001+GinkgoParallelNode())
		sandboxRepoDir, err := ioutil.TempDir("", "sandbox")
		Expect(err).NotTo(HaveOccurred())

				ns = &fakes.Namespace{}
			})

			It("returns an error", func() {
				err := repo.Destroy(ns)
				Expect(err).To(MatchError("namespace is not a Netns"))
			})

			It("logs the failure", func() {
				repo.Destroy(ns)
				Expect(logger).To(gbytes.Say("destroy.not-a-netns"))
			})
		})

		Context("when the namespace file is not a bind mount", func() {
			var ns namespace.Namespace

			BeforeEach(func() {
				var err error
				ns, err = repo.Create("already-destroyed")
				Expect(err).NotTo(HaveOccurred())

				err = repo.Destroy(ns)
				Expect(err).NotTo(HaveOccurred())

				f, err := os.Create(ns.Name())
				Expect(err).NotTo(HaveOccurred())
				f.Close()
			})

			AfterEach(func() {

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
}

	daemonConfig.Marshal(configFile)
	Expect(configFile.Close()).To(Succeed())

	return configFile.Name()
}

var _ = Describe("Networks", func() {
	var (
		session     *gexec.Session
		address     string
		containerID string
		vni         int
		sandboxName string
		hostAddress string
		spaceID     string
		appID       string
		networkID   string

		logger             *lagertest.TestLogger
		sandboxRepo        namespace.Repository
		containerRepo      namespace.Repository
		containerNamespace namespace.Namespace
	)

	BeforeEach(func() {
		address = fmt.Sprintf("127.0.0.1:%d", 4001+GinkgoParallelNode())
		sandboxRepoDir, err := ioutil.TempDir("", "sandbox")
		Expect(err).NotTo(HaveOccurred())

		logger = lagertest.NewTestLogger("test")
		threadLocker := &ossupport.OSLocker{}