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())