func (cn CreateSandbox) Execute(context executor.Context) error { logger := context.Logger().WithData(lager.Data{"sandbox-name": cn.Name}) logger.Info("create-sandbox") defer logger.Info("create-sandbox-complete") _, err := context.SandboxRepository().Create(cn.Name) if err != nil { return fmt.Errorf("create sandbox: %s", err) } return nil }
func (c CleanupSandbox) Execute(context executor.Context) error { logger := context.Logger().Session("cleanup-sandbox", lager.Data{"sandbox-name": c.SandboxName}) logger.Info("start") defer logger.Info("complete") sandboxRepo := context.SandboxRepository() sbox, err := sandboxRepo.Get(c.SandboxName) if err != nil { if err == sandbox.NotFoundError { return nil } logger.Error("get-sandbox-failed", err) return fmt.Errorf("get sandbox: %s", err) } // TODO: move into sandbox sbox.Lock() defer sbox.Unlock() vethLinkCount, err := sbox.VethDeviceCount() if err != nil { return fmt.Errorf("counting veth devices: %s", err) } logger.Info("veth-links-remaining", lager.Data{"count": vethLinkCount}) if vethLinkCount == 0 { err = sbox.Namespace().Execute(func(*os.File) error { err := context.LinkFactory().DeleteLinkByName(c.VxlanDeviceName) if err != nil { if context.LinkFactory().Exists(c.VxlanDeviceName) { return fmt.Errorf("destroying vxlan %s: %s", c.VxlanDeviceName, err) } } return nil }) if err != nil { return fmt.Errorf("in namespace %s: %s", c.SandboxName, err) } err = sandboxRepo.Destroy(c.SandboxName) switch err { case nil: case sandbox.AlreadyDestroyedError: case sandbox.NotFoundError: default: return fmt.Errorf("sandbox destroy: %s", err) } } return nil }
func (s MoveLink) Execute(context executor.Context) error { sbox, err := context.SandboxRepository().Get(s.SandboxName) if err != nil { return fmt.Errorf("get sandbox: %s", err) } err = context.LinkFactory().SetNamespace(s.Name, sbox.Namespace().Fd()) if err != nil { return fmt.Errorf("move link: %s", err) } return nil }
func (sd StartDNSServer) Execute(context executor.Context) error { listenerFactory := context.ListenerFactory() listenAddress, err := net.ResolveUDPAddr("udp", sd.ListenAddress) if err != nil { return fmt.Errorf("resolve udp address: %s", err) } sbox, err := context.SandboxRepository().Get(sd.SandboxName) if err != nil { return fmt.Errorf("get sandbox: %s", err) } sbox.Lock() defer sbox.Unlock() namespace := sbox.Namespace() var conn *net.UDPConn err = namespace.Execute(func(*os.File) error { linkFactory := context.LinkFactory() err := linkFactory.CreateDummy(DNS_INTERFACE_NAME) if err != nil { return fmt.Errorf("create dummy: %s", err) } dnsAddress := &net.IPNet{ IP: listenAddress.IP, Mask: net.CIDRMask(32, 32), } err = context.AddressManager().AddAddress(DNS_INTERFACE_NAME, dnsAddress) if err != nil { return fmt.Errorf("add address: %s", err) } err = linkFactory.SetUp(DNS_INTERFACE_NAME) if err != nil { return fmt.Errorf("set up: %s", err) } conn, err = listenerFactory.ListenUDP("udp", listenAddress) if err != nil { return fmt.Errorf("listen udp: %s", err) } return nil }) if err != nil { return fmt.Errorf("namespace execute: %s", err) } dnsServerRunner := context.DNSServerFactory().New(conn, namespace) err = sbox.LaunchDNS(dnsServerRunner) if err != nil { return fmt.Errorf("sandbox launch dns: %s", err) } return nil }
Describe("RouteManager", func() { It("returns the route manager", func() { Expect(context.RouteManager()).To(Equal(routeManager)) }) }) Describe("SandboxNamespaceRepository", func() { It("returns the SandboxNamespaceRepository", func() { Expect(context.SandboxNamespaceRepository()).To(Equal(sandboxNamespaceRepository)) }) }) Describe("SandboxRepository", func() { It("returns the SandboxRepository", func() { Expect(context.SandboxRepository()).To(Equal(sandboxRepository)) }) }) Describe("ListenerFactory", func() { It("returns the ListenerFactory", func() { Expect(context.ListenerFactory()).To(Equal(listenerFactory)) }) }) Describe("DNSServerFactory", func() { It("returns the DNSServerFactory", func() { Expect(context.DNSServerFactory()).To(Equal(dnsServerFactory)) }) })