inNamespace commands.InNamespace
)
BeforeEach(func() {
context = &fakes.Context{}
command = &fakes.Command{}
command.StringReturns("some-command")
namespace = &fakes.Namespace{}
namespace.NameReturns("namespace-name")
namespace.ExecuteStub = func(callback func(*os.File) error) error {
Expect(command.ExecuteCallCount()).To(Equal(0))
err := callback(nil)
Expect(command.ExecuteCallCount()).To(Equal(1))
return err
}
inNamespace = commands.InNamespace{
Namespace: namespace,
Command: command,
}
})
It("executes the command in the specified namespace", func() {
err := inNamespace.Execute(context)
Expect(err).NotTo(HaveOccurred())
Expect(namespace.ExecuteCallCount()).To(Equal(1))
dnsServer = &fakes.Runner{}
dnsServerFactory.NewReturns(dnsServer)
context = &fakes.Context{}
context.ListenerFactoryReturns(listenerFactory)
context.LinkFactoryReturns(linkFactory)
context.AddressManagerReturns(addressManager)
context.DNSServerFactoryReturns(dnsServerFactory)
context.SandboxRepositoryReturns(sandboxRepo)
sandboxRepo.GetReturns(sbox, nil)
returnedListener = &net.UDPConn{}
listenerFactory.ListenUDPReturns(returnedListener, nil)
ns.ExecuteStub = func(callback func(*os.File) error) error {
return callback(nil)
}
startDNS = commands.StartDNSServer{
ListenAddress: "10.10.10.10:53",
SandboxName: "some-sandbox-name",
}
})
It("gets the namespace from the sandbox", func() {
err := startDNS.Execute(context)
Expect(err).NotTo(HaveOccurred())
Expect(sandboxRepo.GetCallCount()).To(Equal(1))
Expect(sandboxRepo.GetArgsForCall(0)).To(Equal("some-sandbox-name"))
targetNS *fakes.Namespace
mySubscriber *subscriber.Subscriber
neighChan chan *watcher.Neigh
doneChan chan struct{}
logger *lagertest.TestLogger
)
BeforeEach(func() {
fakeNetlinker = &nlfakes.Netlinker{}
fakeSocket = &nlfakes.NLSocket{}
neighChan = make(chan *watcher.Neigh, 100)
doneChan = make(chan struct{})
logger = lagertest.NewTestLogger("test")
targetNS = &fakes.Namespace{}
targetNS.ExecuteStub = func(callback func(*os.File) error) error {
return callback(nil)
}
mySubscriber = &subscriber.Subscriber{
Netlinker: fakeNetlinker,
Logger: logger,
}
fakeNetlinker.SubscribeReturns(fakeSocket, nil)
fakeSocket.ReceiveReturns([]syscall.NetlinkMessage{{Data: []byte("something")}}, nil)
fakeNetlinker.NeighDeserializeReturns(&netlink.Neigh{}, nil)
})
It("subscribes in the sandbox namespace", func() {
targetNS.ExecuteStub = func(callback func(*os.File) error) error {
defer GinkgoRecover()
"github.com/onsi/gomega/gbytes"
)
var _ = Describe("NamespaceWriter", func() {
var (
nsWriter *executor.NamespaceWriter
ns *fakes.Namespace
writer *fakes.Writer
logger *lagertest.TestLogger
)
BeforeEach(func() {
ns = &fakes.Namespace{}
ns.MarshalJSONReturns([]byte(`{ "namespace": "my-namespace", "inode": "some-inode" }`), nil)
ns.ExecuteStub = func(callback func(*os.File) error) error {
return callback(nil)
}
logger = lagertest.NewTestLogger("test")
writer = &fakes.Writer{}
nsWriter = &executor.NamespaceWriter{
Logger: logger,
Namespace: ns,
Writer: writer,
}
})
It("writes to the wrapped writer in the associated namespace", func() {
ns.ExecuteStub = func(callback func(*os.File) error) error {
Expect(writer.WriteCallCount()).To(Equal(0))
vxlanLink *netlink.Vxlan
logger *lagertest.TestLogger
)
BeforeEach(func() {
ns = &fakes.Namespace{}
netlinker = &nl_fakes.Netlinker{}
logger = lagertest.NewTestLogger("test")
vxlanLink = &netlink.Vxlan{
LinkAttrs: netlink.LinkAttrs{
Index: 9876,
},
}
ns.ExecuteStub = func(callback func(ns *os.File) error) error {
return callback(nil)
}
netlinker.LinkByNameStub = func(linkName string) (netlink.Link, error) {
return vxlanLink, nil
}
inserter = &neigh.ARPInserter{
Logger: logger,
Netlinker: netlinker,
}
})
Describe("HandleResolvedNeighbors", func() {
var (
neigh watcher.Neigh
sandboxNS = &fakes.Namespace{}
sandboxRepository.GetReturns(sandboxNS, nil)
hostNS = &fakes.Namespace{}
fakeWatcher = &fakes.MissWatcher{}
startMonitor = commands.StartMonitor{
HostNamespace: hostNS,
Watcher: fakeWatcher,
SandboxName: "some-sandbox",
VxlanLinkName: "some-vxlan-name",
}
hostNS.ExecuteStub = func(callback func(_ *os.File) error) error {
return callback(nil)
}
})
Describe("Execute", func() {
It("it calls StartMonitor inside the HostNamespace", func() {
hostNS.ExecuteStub = func(callback func(_ *os.File) error) error {
Expect(fakeWatcher.StartMonitorCallCount()).To(Equal(0))
callback(nil)
Expect(fakeWatcher.StartMonitorCallCount()).To(Equal(1))
return nil
}
err := startMonitor.Execute(context)
Expect(err).NotTo(HaveOccurred())
ns.MarshalJSONReturns([]byte("{}"), nil)
vxlanLinkName = "some-vxlan-name"
resolver = &fakes.Resolver{}
arpInserter = &fakes.ARPInserter{}
arpInserter.HandleResolvedNeighborsStub = func(ready chan error, _ namespace.Namespace, _ string, _ <-chan watcher.Neighbor) {
close(ready)
}
missWatcher = watcher.New(logger, sub, locker, resolver, arpInserter)
ns.ExecuteStub = func(callback func(ns *os.File) error) error {
err := callback(nil)
if err != nil {
return fmt.Errorf("callback failed: %s", err)
}
return nil
}
ns.NameReturns("some-namespace")
})
Describe("StartMonitor", func() {
It("subscribes to sandbox l3 misses", func() {
missWatcher.StartMonitor(ns, vxlanLinkName)
Expect(sub.SubscribeCallCount()).To(Equal(1))
targetNS, _, doneCh := sub.SubscribeArgsForCall(0)
Expect(targetNS).To(Equal(ns))
Consistently(doneCh).ShouldNot(BeClosed())
sb sandbox.Sandbox
logger *lagertest.TestLogger
sbNamespace *fakes.Namespace
invoker *fakes.Invoker
watcher *fakes.MissWatcher
linkFactory *fakes.LinkFactory
)
BeforeEach(func() {
logger = lagertest.NewTestLogger("test")
invoker = &fakes.Invoker{}
watcher = &fakes.MissWatcher{}
linkFactory = &fakes.LinkFactory{}
sbNamespace = &fakes.Namespace{}
sbNamespace.ExecuteStub = func(callback func(*os.File) error) error {
return callback(nil)
}
sb = sandbox.New(logger, sbNamespace, invoker, linkFactory, watcher)
})
Describe("Setup", func() {
It("brings up the loopback adapter in the sandbox namespace", func() {
sbNamespace.ExecuteStub = func(callback func(*os.File) error) error {
Expect(linkFactory.SetUpCallCount()).To(Equal(0))
err := callback(nil)
Expect(linkFactory.SetUpCallCount()).To(Equal(1))
return err
}
err := sb.Setup()
}
return nil, sandbox.NotFoundError
}
context.SandboxRepositoryReturns(sandboxRepo)
context.SandboxNamespaceRepositoryReturns(namespaceRepository)
cleanupSandboxCommand = commands.CleanupSandbox{
SandboxName: "sandbox-name",
VxlanDeviceName: "some-vxlan",
}
sandboxNS.ExecuteStub = func(callback func(ns *os.File) error) error {
err := callback(nil)
if err != nil {
return fmt.Errorf("callback failed: %s", err)
}
return nil
}
})
It("gets the sandbox by name", func() {
err := cleanupSandboxCommand.Execute(context)
Expect(err).NotTo(HaveOccurred())
Expect(sandboxRepo.GetCallCount()).To(Equal(1))
Expect(sandboxRepo.GetArgsForCall(0)).To(Equal("sandbox-name"))
})
Context("when sandbox doesn't exist", func() {
It("returns without an error", func() {