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
}
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))
})
})
Describe("Logger", func() {
It("returns the Logger with a new session", func() {
Expect(context.Logger().SessionName()).NotTo(Equal(logger.SessionName()))
})
})
})
})