From bbd69170f90abb19c51650bcbe2fba2be90f02ea Mon Sep 17 00:00:00 2001 From: Alvaro Saurin Date: Thu, 12 Feb 2015 15:07:27 +0100 Subject: [PATCH] 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) --- nameserver/mdns_server.go | 4 +- nameserver/mdns_server_test.go | 2 +- nameserver/server.go | 104 +++++++++++++++++++++++---------- nameserver/server_test.go | 8 ++- weavedns/main.go | 28 +++++---- 5 files changed, 99 insertions(+), 47 deletions(-) diff --git a/nameserver/mdns_server.go b/nameserver/mdns_server.go index a67a4b3e..18ddb82d 100644 --- a/nameserver/mdns_server.go +++ b/nameserver/mdns_server.go @@ -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) diff --git a/nameserver/mdns_server_test.go b/nameserver/mdns_server_test.go index 2ab473a9..bd7da6dc 100644 --- a/nameserver/mdns_server_test.go +++ b/nameserver/mdns_server_test.go @@ -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 diff --git a/nameserver/server.go b/nameserver/server.go index c2a680e8..22b225bc 100644 --- a/nameserver/server.go +++ b/nameserver/server.go @@ -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) diff --git a/nameserver/server_test.go b/nameserver/server_test.go index bde9d722..d132ae13 100644 --- a/nameserver/server_test.go +++ b/nameserver/server_test.go @@ -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 diff --git a/weavedns/main.go b/weavedns/main.go index 1c788b77..384e00a8 100644 --- a/weavedns/main.go +++ b/weavedns/main.go @@ -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) } }