reweave/weave
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

zettio/weave#366 - improved configuration for th DNSServer, where we can specify the local domain name among other things... (missing some unit tests for this customized local domain)

Browse Source
This commit is contained in:
Alvaro Saurin committed 2015-02-26 10:51:48 +01:00
1 parent d1400bc233
commit bbd69170f9
5 files changed
+99 -47
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

nameserver/mdns_server.go
+2 -2
View File
@@ -35,7 +35,7 @@ func (s *MDNSServer) addrIsLocal(testaddr net.Addr) bool {
return false
}
func (s *MDNSServer) Start(ifi *net.Interface) error {
func (s *MDNSServer) Start(ifi *net.Interface, localDomain string) error {
conn, err := LinkLocalMulticastListener(ifi)
if err != nil {
return err
@@ -69,7 +69,7 @@ func (s *MDNSServer) Start(ifi *net.Interface) error {
})
mux := dns.NewServeMux()
mux.HandleFunc(LOCAL_DOMAIN, handleLocal)
mux.HandleFunc(localDomain, handleLocal)
mux.HandleFunc(RDNS_DOMAIN, handleReverse)
go dns.ActivateAndServe(nil, conn, mux)
nameserver/mdns_server_test.go
+1 -1
View File
@@ -44,7 +44,7 @@ func TestServerSimpleQuery(t *testing.T) {
mdnsServer, err := NewMDNSServer(zone)
wt.AssertNoErr(t, err)
err = mdnsServer.Start(nil)
err = mdnsServer.Start(nil, DEFAULT_LOCAL_DOMAIN)
wt.AssertNoErr(t, err)
var receivedAddr net.IP
nameserver/server.go
+74 -30
View File
@@ -9,8 +9,10 @@ import (
)
const (
LOCAL_DOMAIN = "weave.local."
UDPBufSize = 4096 // bigger than the default 512
DEFAULT_LOCAL_DOMAIN = "weave.local." // The default name used for the local domain
DEFAULT_SERVER_PORT = 53 // The default server port
DEFAULT_CLI_CFG_FILE = "/etc/resolv.conf" // default "resolv.conf" file to try to load
UDPBufSize = 4096 // bigger than the default 512
)
func makeDNSFailResponse(r *dns.Msg) *dns.Msg {
@@ -21,46 +23,87 @@ func makeDNSFailResponse(r *dns.Msg) *dns.Msg {
return m
}
type DNSServer struct {
config *dns.ClientConfig
zone Zone
iface *net.Interface
port int
udpSrv *dns.Server
tcpSrv *dns.Server
type DNSServerConfig struct {
// (Optional) client config file for resolving upstream servers
UpstreamCfgFIle string
// (Optional) DNS client config for the fallback server(s)
UpstreamCfg *dns.ClientConfig
// DNS zone served
Zone Zone
// Interface where serving
Iface *net.Interface
// (Optional) port number (for TCP and UDP)
Port int
// (Optional) local domain (ie, "weave.local.")
LocalDomain string
}
// Creates a new DNS server with a given config
func NewDNSServer(config *dns.ClientConfig, zone Zone, iface *net.Interface, port int) *DNSServer {
return &DNSServer{
config: config,
zone: zone,
iface: iface,
port: port,
type DNSServer struct {
config *DNSServerConfig
udpSrv *dns.Server
tcpSrv *dns.Server
mdnsCli *MDNSClient
mdnsSrv *MDNSServer
IfaceName string // the interface where mDNS is working on
ListenAddr string // the address the server is listening at
}
// Creates a new DNS server
func NewDNSServer(config DNSServerConfig) (s *DNSServer, err error) {
// fill empty parameters with defaults...
if config.Port == 0 {
config.Port = DEFAULT_SERVER_PORT
}
if len(config.LocalDomain) == 0 {
config.LocalDomain = DEFAULT_LOCAL_DOMAIN
}
if len(config.UpstreamCfgFIle) == 0 {
config.UpstreamCfgFIle = DEFAULT_CLI_CFG_FILE
}
if config.UpstreamCfg == nil {
if config.UpstreamCfg, err = dns.ClientConfigFromFile(config.UpstreamCfgFIle); err != nil {
return nil, err
}
}
mdnsClient, err := NewMDNSClient()
if err != nil {
return
}
mdnsServer, err := NewMDNSServer(config.Zone)
if err != nil {
return
}
ifaceName := "default interface"
if config.Iface != nil {
ifaceName = config.Iface.Name
}
return &DNSServer{
config: &config,
mdnsCli: mdnsClient,
mdnsSrv: mdnsServer,
IfaceName: ifaceName,
ListenAddr: fmt.Sprintf(":%d", config.Port),
}, nil
}
// Start the DNS server
func (s *DNSServer) Start() error {
Info.Printf("WeaveDNS server starting...")
mdnsClient, err := NewMDNSClient()
Info.Printf("Using mDNS on %s", s.IfaceName)
err := s.mdnsCli.Start(s.config.Iface)
CheckFatal(err)
ifaceName := "default interface"
if s.iface != nil {
ifaceName = s.iface.Name
}
Info.Printf("Using mDNS on %s", ifaceName)
err = mdnsClient.Start(s.iface)
err = s.mdnsSrv.Start(s.config.Iface, s.config.LocalDomain)
CheckFatal(err)
// create two DNS request multiplexerers, depending on the protocol used by clients
// (we use the same protocol for asking upstream servers)
mux := func(client *dns.Client) *dns.ServeMux {
m := dns.NewServeMux()
m.HandleFunc(LOCAL_DOMAIN, s.queryHandler([]Lookup{s.zone, mdnsClient}))
m.HandleFunc(RDNS_DOMAIN, s.rdnsHandler([]Lookup{s.zone, mdnsClient}, client))
m.HandleFunc(s.config.LocalDomain, s.queryHandler([]Lookup{s.config.Zone, s.mdnsCli}))
m.HandleFunc(RDNS_DOMAIN, s.rdnsHandler([]Lookup{s.config.Zone, s.mdnsCli}, client))
m.HandleFunc(".", s.notUsHandler(client))
return m
}
@@ -111,6 +154,7 @@ func (s *DNSServer) Stop() error {
if err := s.udpSrv.Shutdown(); err != nil {
return err
}
// TODO: shutdown the mDNS client/server
return nil
}
@@ -160,8 +204,8 @@ func (s *DNSServer) notUsHandler(dnsClient *dns.Client) dns.HandlerFunc {
return func(w dns.ResponseWriter, r *dns.Msg) {
q := r.Question[0]
Debug.Printf("[dns msgid %d] Fallback query: %+v", r.MsgHdr.Id, q)
for _, server := range s.config.Servers {
reply, _, err := dnsClient.Exchange(r, fmt.Sprintf("%s:%s", server, s.config.Port))
for _, server := range s.config.UpstreamCfg.Servers {
reply, _, err := dnsClient.Exchange(r, fmt.Sprintf("%s:%s", server, s.config.UpstreamCfg.Port))
if err != nil {
Debug.Printf("[dns msgid %d] Network error trying %s (%s)",
r.MsgHdr.Id, server, err)
nameserver/server_test.go
+5 -3
View File
@@ -25,7 +25,7 @@ func TestUDPDNSServer(t *testing.T) {
nonLocalName = "weave.works."
testAddr1 = "10.0.2.1"
)
dnsAddr := fmt.Sprintf("localhost:%d", port)
dnsAddr := fmt.Sprintf("127.0.0.1:%d", port)
testCIDR1 := testAddr1 + "/24"
InitDefaultLogging(true)
@@ -66,7 +66,8 @@ func TestUDPDNSServer(t *testing.T) {
wt.AssertNoErr(t, err)
config := &dns.ClientConfig{Servers: []string{"127.0.0.1"}, Port: fallbackPort}
srv := NewDNSServer(config, zone, nil, port)
srv, err := NewDNSServer(DNSServerConfig{UpstreamCfg: config, Zone: zone, Port: port})
wt.AssertNoErr(t, err)
defer srv.Stop()
go srv.Start()
time.Sleep(100 * time.Millisecond) // Allow sever goroutine to start
@@ -189,7 +190,8 @@ func TestTCPDNSServer(t *testing.T) {
t.Logf("Creating a WeaveDNS server instance, falling back to 127.0.0.1:%s", fallbackPort)
config := &dns.ClientConfig{Servers: []string{"127.0.0.1"}, Port: fallbackPort}
srv := NewDNSServer(config, zone, nil, port)
srv, err := NewDNSServer(DNSServerConfig{UpstreamCfg: config, Zone: zone, Port: port})
wt.AssertNoErr(t, err)
defer srv.Stop()
go srv.Start()
time.Sleep(100 * time.Millisecond) // Allow sever goroutine to start
weavedns/main.go
+17 -11
View File
@@ -19,6 +19,7 @@ func main() {
justVersion bool
ifaceName string
apiPath string
localDomain string
fallback string
dnsPort int
httpPort int
@@ -31,6 +32,7 @@ func main() {
flag.BoolVar(&justVersion, "version", false, "print version and exit")
flag.StringVar(&ifaceName, "iface", "", "name of interface to use for multicast")
flag.StringVar(&apiPath, "api", "unix:///var/run/docker.sock", "Path to Docker API socket")
flag.StringVar(&localDomain, "localDomain", weavedns.DEFAULT_LOCAL_DOMAIN, "local domain (ie, 'weave.local.')")
flag.IntVar(&wait, "wait", 0, "number of seconds to wait for interface to be created and come up")
flag.IntVar(&dnsPort, "dnsport", 53, "port to listen to DNS requests")
flag.IntVar(&httpPort, "httpport", 6785, "port to listen to HTTP requests")
@@ -67,25 +69,29 @@ func main() {
}
}
var config *dns.ClientConfig
srvConfig := weavedns.DNSServerConfig{
Zone: zone,
Iface: iface,
Port: dnsPort,
LocalDomain: localDomain,
}
if len(fallback) > 0 {
fallbackHost, fallbackPort, err := net.SplitHostPort(fallback)
if err != nil {
Error.Fatal("Fould not parse fallback host and port", err)
}
config = &dns.ClientConfig{Servers: []string{fallbackHost}, Port: fallbackPort}
srvConfig.UpstreamCfg = &dns.ClientConfig{Servers: []string{fallbackHost}, Port: fallbackPort}
Debug.Printf("DNS fallback at %s:%s", fallbackHost, fallbackPort)
} else {
config, err = dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil {
Error.Fatal("Failed obtain DNS client configuration", err)
}
}
go weavedns.ListenHttp(weavedns.LOCAL_DOMAIN, zone, httpPort)
srv := weavedns.NewDNSServer(config, zone, iface, dnsPort)
go weavedns.ListenHttp(localDomain, zone, httpPort)
srv, err := weavedns.NewDNSServer(srvConfig)
if err != nil {
Error.Fatal("Failed to initialize the WeaveDNS server", err)
}
err = srv.Start()
if err != nil {
Error.Fatal("Failed to start server", err)
Error.Fatal("Failed to start the WeaveDNS server", err)
}
}