Golang Namespace.Name方法代碼示例

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 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
}

		var (
			upSpec       models.CNIAddPayload
			downSpec     models.CNIDelPayload
			daemonClient *client.DaemonClient
			ipamResult   types.Result
		)

		BeforeEach(func() {
			Eventually(serverIsAvailable).Should(Succeed())

			daemonClient = client.New("http://"+address, http.DefaultClient)

			By("generating config and creating the request")
			upSpec = models.CNIAddPayload{
				Args:               "FOO=BAR;ABC=123",
				ContainerNamespace: containerNamespace.Name(),
				InterfaceName:      "vx-eth0",
				Network: models.NetworkPayload{
					models.Properties{
						AppID:   appID,
						SpaceID: spaceID,
					},
				},
				ContainerID: containerID,
			}

			downSpec = models.CNIDelPayload{
				InterfaceName:      "vx-eth0",
				ContainerNamespace: containerNamespace.Name(),
				ContainerID:        containerID,
			}

				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() {
				os.Remove(ns.Name())
			})

			It("returns an error", func() {
				err := repo.Destroy(ns)
				Expect(err).To(HaveOccurred())
			})

			It("does not remove the file", func() {
				Expect(ns.Name()).To(BeAnExistingFile())