From bbd69170f90abb19c51650bcbe2fba2be90f02ea Mon Sep 17 00:00:00 2001 From: Alvaro Saurin Date: Thu, 12 Feb 2015 15:07:27 +0100 Subject: [PATCH 1/6] 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) } } From 403520f4b6a7987d31989aa1b38437246b3e1401 Mon Sep 17 00:00:00 2001 From: Alvaro Saurin Date: Fri, 13 Feb 2015 13:18:41 +0100 Subject: [PATCH 2/6] zettio/weave#366 - move more initialization code to the constructor --- nameserver/server.go | 39 +++++++++++++++++++++++++++++---------- nameserver/server_test.go | 4 ++-- 2 files changed, 31 insertions(+), 12 deletions(-) diff --git a/nameserver/server.go b/nameserver/server.go index 22b225bc..18c813bb 100644 --- a/nameserver/server.go +++ b/nameserver/server.go @@ -12,7 +12,7 @@ const ( 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 + DEFAULT_UDP_BUFLEN = 4096 // bigger than the default 512 ) func makeDNSFailResponse(r *dns.Msg) *dns.Msg { @@ -81,13 +81,28 @@ func NewDNSServer(config DNSServerConfig) (s *DNSServer, err error) { ifaceName = config.Iface.Name } - return &DNSServer{ + s = &DNSServer{ config: &config, mdnsCli: mdnsClient, mdnsSrv: mdnsServer, IfaceName: ifaceName, ListenAddr: fmt.Sprintf(":%d", config.Port), - }, nil + } + + // 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(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 + } + + s.udpSrv = &dns.Server{Addr: s.ListenAddr, Net: "udp", Handler: mux(&dns.Client{Net: "udp", UDPSize: DEFAULT_UDP_BUFLEN})} + s.tcpSrv = &dns.Server{Addr: s.ListenAddr, Net: "tcp", Handler: mux(&dns.Client{Net: "tcp"})} + + return } // Start the DNS server @@ -108,15 +123,19 @@ func (s *DNSServer) Start() error { return m } - mdnsServer, err := NewMDNSServer(s.zone) - CheckFatal(err) + s.udpSrv = &dns.Server{Addr: s.ListenAddr, Net: "udp", Handler: mux(&dns.Client{Net: "udp", UDPSize: DEFAULT_UDP_BUFLEN})} + s.tcpSrv = &dns.Server{Addr: s.ListenAddr, Net: "tcp", Handler: mux(&dns.Client{Net: "tcp"})} - err = mdnsServer.Start(s.iface) - CheckFatal(err) + return +} - address := fmt.Sprintf(":%d", s.port) - s.udpSrv = &dns.Server{Addr: address, Net: "udp", Handler: mux(&dns.Client{Net: "udp", UDPSize: UDPBufSize})} - s.tcpSrv = &dns.Server{Addr: address, Net: "tcp", Handler: mux(&dns.Client{Net: "tcp"})} +// Start the DNS server +func (s *DNSServer) Start() error { + Info.Printf("Using mDNS on %s", s.IfaceName) + err := s.mdnsCli.Start(s.config.Iface) + CheckFatal(err) + err = s.mdnsSrv.Start(s.config.Iface, s.config.LocalDomain) + CheckFatal(err) wg := new(sync.WaitGroup) wg.Add(2) diff --git a/nameserver/server_test.go b/nameserver/server_test.go index d132ae13..542bc1e8 100644 --- a/nameserver/server_test.go +++ b/nameserver/server_test.go @@ -73,7 +73,7 @@ func TestUDPDNSServer(t *testing.T) { time.Sleep(100 * time.Millisecond) // Allow sever goroutine to start c := new(dns.Client) - c.UDPSize = UDPBufSize + c.UDPSize = DEFAULT_UDP_BUFLEN m := new(dns.Msg) m.SetQuestion(successTestName, dns.TypeA) m.RecursionDesired = true @@ -198,7 +198,7 @@ func TestTCPDNSServer(t *testing.T) { t.Logf("Creating a UDP and a TCP client") uc := new(dns.Client) - uc.UDPSize = UDPBufSize + uc.UDPSize = DEFAULT_UDP_BUFLEN tc := new(dns.Client) tc.Net = "tcp" From 0bc3e333f8ffa8e1b65a3503192e3fdaac7ae301 Mon Sep 17 00:00:00 2001 From: Alvaro Saurin Date: Mon, 23 Feb 2015 12:40:29 +0100 Subject: [PATCH 3/6] zettio/weave#366 - minor: fixed a typo and removed some superfluous code --- nameserver/server.go | 36 ++++++------------------------------ weavedns/main.go | 4 ++-- 2 files changed, 8 insertions(+), 32 deletions(-) diff --git a/nameserver/server.go b/nameserver/server.go index 18c813bb..ddaa22a9 100644 --- a/nameserver/server.go +++ b/nameserver/server.go @@ -25,7 +25,7 @@ func makeDNSFailResponse(r *dns.Msg) *dns.Msg { type DNSServerConfig struct { // (Optional) client config file for resolving upstream servers - UpstreamCfgFIle string + UpstreamCfgFile string // (Optional) DNS client config for the fallback server(s) UpstreamCfg *dns.ClientConfig // DNS zone served @@ -58,11 +58,11 @@ func NewDNSServer(config DNSServerConfig) (s *DNSServer, err error) { if len(config.LocalDomain) == 0 { config.LocalDomain = DEFAULT_LOCAL_DOMAIN } - if len(config.UpstreamCfgFIle) == 0 { - config.UpstreamCfgFIle = DEFAULT_CLI_CFG_FILE + 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 { + if config.UpstreamCfg, err = dns.ClientConfigFromFile(config.UpstreamCfgFile); err != nil { return nil, err } } @@ -105,30 +105,6 @@ func NewDNSServer(config DNSServerConfig) (s *DNSServer, err error) { return } -// Start the DNS server -func (s *DNSServer) Start() error { - Info.Printf("Using mDNS on %s", s.IfaceName) - err := s.mdnsCli.Start(s.config.Iface) - CheckFatal(err) - 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(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 - } - - s.udpSrv = &dns.Server{Addr: s.ListenAddr, Net: "udp", Handler: mux(&dns.Client{Net: "udp", UDPSize: DEFAULT_UDP_BUFLEN})} - s.tcpSrv = &dns.Server{Addr: s.ListenAddr, Net: "tcp", Handler: mux(&dns.Client{Net: "tcp"})} - - return -} - // Start the DNS server func (s *DNSServer) Start() error { Info.Printf("Using mDNS on %s", s.IfaceName) @@ -143,7 +119,7 @@ func (s *DNSServer) Start() error { go func() { defer wg.Done() - Debug.Printf("Listening for DNS on %s (UDP)", address) + Debug.Printf("Listening for DNS on %s (UDP)", s.ListenAddr) err = s.udpSrv.ListenAndServe() CheckFatal(err) Debug.Printf("DNS UDP server exiting...") @@ -152,7 +128,7 @@ func (s *DNSServer) Start() error { go func() { defer wg.Done() - Debug.Printf("Listening for DNS on %s (TCP)", address) + Debug.Printf("Listening for DNS on %s (TCP)", s.ListenAddr) err = s.tcpSrv.ListenAndServe() CheckFatal(err) Debug.Printf("DNS TCP server exiting...") diff --git a/weavedns/main.go b/weavedns/main.go index 384e00a8..6474be80 100644 --- a/weavedns/main.go +++ b/weavedns/main.go @@ -32,11 +32,11 @@ 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.StringVar(&localDomain, "localDomain", "", "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") - flag.StringVar(&fallback, "fallback", "", "Fallback server and port (ie, '8.8.8.8:53')") + flag.StringVar(&fallback, "fallback", "", "fallback server and port (ie, '8.8.8.8:53')") flag.BoolVar(&watch, "watch", true, "watch the docker socket for container events") flag.BoolVar(&debug, "debug", false, "output debugging info to stderr") flag.Parse() From 007873a402ef264cf02cf65fae55bb3b9507eae4 Mon Sep 17 00:00:00 2001 From: Alvaro Saurin Date: Fri, 27 Feb 2015 12:22:08 +0100 Subject: [PATCH 4/6] zettio/weave#366 - keep the DNSServerConfig inmutable --- nameserver/server.go | 83 ++++++++++++++++++++------------------- nameserver/server_test.go | 4 +- weavedns/main.go | 4 +- 3 files changed, 46 insertions(+), 45 deletions(-) diff --git a/nameserver/server.go b/nameserver/server.go index ddaa22a9..792c447c 100644 --- a/nameserver/server.go +++ b/nameserver/server.go @@ -13,6 +13,7 @@ const ( DEFAULT_SERVER_PORT = 53 // The default server port DEFAULT_CLI_CFG_FILE = "/etc/resolv.conf" // default "resolv.conf" file to try to load DEFAULT_UDP_BUFLEN = 4096 // bigger than the default 512 + DEFAULT_IFACE_NAME = "default interface" ) func makeDNSFailResponse(r *dns.Msg) *dns.Msg { @@ -28,10 +29,6 @@ type DNSServerConfig struct { 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.") @@ -39,62 +36,68 @@ type DNSServerConfig struct { } type DNSServer struct { - config *DNSServerConfig - udpSrv *dns.Server - tcpSrv *dns.Server - mdnsCli *MDNSClient - mdnsSrv *MDNSServer + config *DNSServerConfig + udpSrv *dns.Server + tcpSrv *dns.Server + mdnsCli *MDNSClient + mdnsSrv *MDNSServer + zone Zone + iface *net.Interface + upstream *dns.ClientConfig + Domain string // the local domain 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) { +func NewDNSServer(config DNSServerConfig, zone Zone, iface *net.Interface) (s *DNSServer, err error) { + s = &DNSServer{ + config: &config, + zone: zone, + iface: iface, + + Domain: DEFAULT_LOCAL_DOMAIN, + IfaceName: DEFAULT_IFACE_NAME, + ListenAddr: fmt.Sprintf(":%d", DEFAULT_SERVER_PORT), + } + // fill empty parameters with defaults... - if config.Port == 0 { - config.Port = DEFAULT_SERVER_PORT + if config.Port != 0 { + s.ListenAddr = fmt.Sprintf(":%d", config.Port) } - if len(config.LocalDomain) == 0 { - config.LocalDomain = DEFAULT_LOCAL_DOMAIN + if len(config.LocalDomain) > 0 { + s.Domain = config.LocalDomain } - 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 { + if config.UpstreamCfg != nil { + s.upstream = config.UpstreamCfg + } else { + cfgFile := DEFAULT_CLI_CFG_FILE + if len(config.UpstreamCfgFile) > 0 { + cfgFile = config.UpstreamCfgFile + } + if s.upstream, err = dns.ClientConfigFromFile(cfgFile); err != nil { return nil, err } } - - mdnsClient, err := NewMDNSClient() + s.mdnsCli, err = NewMDNSClient() if err != nil { return } - mdnsServer, err := NewMDNSServer(config.Zone) + s.mdnsSrv, err = NewMDNSServer(s.zone) if err != nil { return } - - ifaceName := "default interface" - if config.Iface != nil { - ifaceName = config.Iface.Name - } - - s = &DNSServer{ - config: &config, - mdnsCli: mdnsClient, - mdnsSrv: mdnsServer, - IfaceName: ifaceName, - ListenAddr: fmt.Sprintf(":%d", config.Port), + if iface != nil { + s.IfaceName = iface.Name } // 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(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.Domain, s.queryHandler([]Lookup{s.zone, s.mdnsCli})) + m.HandleFunc(RDNS_DOMAIN, s.rdnsHandler([]Lookup{s.zone, s.mdnsCli}, client)) m.HandleFunc(".", s.notUsHandler(client)) return m } @@ -108,9 +111,9 @@ func NewDNSServer(config DNSServerConfig) (s *DNSServer, err error) { // Start the DNS server func (s *DNSServer) Start() error { Info.Printf("Using mDNS on %s", s.IfaceName) - err := s.mdnsCli.Start(s.config.Iface) + err := s.mdnsCli.Start(s.iface) CheckFatal(err) - err = s.mdnsSrv.Start(s.config.Iface, s.config.LocalDomain) + err = s.mdnsSrv.Start(s.iface, s.Domain) CheckFatal(err) wg := new(sync.WaitGroup) @@ -199,8 +202,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.UpstreamCfg.Servers { - reply, _, err := dnsClient.Exchange(r, fmt.Sprintf("%s:%s", server, s.config.UpstreamCfg.Port)) + for _, server := range s.upstream.Servers { + reply, _, err := dnsClient.Exchange(r, fmt.Sprintf("%s:%s", server, s.upstream.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 542bc1e8..bc376ec1 100644 --- a/nameserver/server_test.go +++ b/nameserver/server_test.go @@ -66,7 +66,7 @@ func TestUDPDNSServer(t *testing.T) { wt.AssertNoErr(t, err) config := &dns.ClientConfig{Servers: []string{"127.0.0.1"}, Port: fallbackPort} - srv, err := NewDNSServer(DNSServerConfig{UpstreamCfg: config, Zone: zone, Port: port}) + srv, err := NewDNSServer(DNSServerConfig{UpstreamCfg: config, Port: port}, zone, nil) wt.AssertNoErr(t, err) defer srv.Stop() go srv.Start() @@ -190,7 +190,7 @@ 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, err := NewDNSServer(DNSServerConfig{UpstreamCfg: config, Zone: zone, Port: port}) + srv, err := NewDNSServer(DNSServerConfig{UpstreamCfg: config, Port: port}, zone, nil) wt.AssertNoErr(t, err) defer srv.Stop() go srv.Start() diff --git a/weavedns/main.go b/weavedns/main.go index 6474be80..235aa71d 100644 --- a/weavedns/main.go +++ b/weavedns/main.go @@ -70,8 +70,6 @@ func main() { } srvConfig := weavedns.DNSServerConfig{ - Zone: zone, - Iface: iface, Port: dnsPort, LocalDomain: localDomain, } @@ -86,7 +84,7 @@ func main() { } go weavedns.ListenHttp(localDomain, zone, httpPort) - srv, err := weavedns.NewDNSServer(srvConfig) + srv, err := weavedns.NewDNSServer(srvConfig, zone, iface) if err != nil { Error.Fatal("Failed to initialize the WeaveDNS server", err) } From 4682f7ed95cfa84ccc256eddb38ecfd8ce4f2464 Mon Sep 17 00:00:00 2001 From: Alvaro Saurin Date: Fri, 27 Feb 2015 15:40:32 +0100 Subject: [PATCH 5/6] zettio/weave#366 - removed reference to DNSServerConfig in the DNSServer struct --- nameserver/server.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/nameserver/server.go b/nameserver/server.go index 792c447c..44e3102c 100644 --- a/nameserver/server.go +++ b/nameserver/server.go @@ -36,7 +36,6 @@ type DNSServerConfig struct { } type DNSServer struct { - config *DNSServerConfig udpSrv *dns.Server tcpSrv *dns.Server mdnsCli *MDNSClient @@ -53,7 +52,6 @@ type DNSServer struct { // Creates a new DNS server func NewDNSServer(config DNSServerConfig, zone Zone, iface *net.Interface) (s *DNSServer, err error) { s = &DNSServer{ - config: &config, zone: zone, iface: iface, From 3137e4acddb0ef563816e49037fa0893fdbd08c5 Mon Sep 17 00:00:00 2001 From: Michael Bridgen Date: Fri, 27 Feb 2015 15:29:59 +0000 Subject: [PATCH 6/6] Smoke test for custom localDomain --- test/220_dns_custom_test.sh | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) create mode 100755 test/220_dns_custom_test.sh diff --git a/test/220_dns_custom_test.sh b/test/220_dns_custom_test.sh new file mode 100755 index 00000000..29f27dfd --- /dev/null +++ b/test/220_dns_custom_test.sh @@ -0,0 +1,25 @@ +#! /bin/bash + +. ./config.sh + +C1=10.2.56.34 +C2=10.2.54.91 + +start_suite "Resolve names in custom domain" + +run_on $HOST1 sudo $WEAVE stop || true +run_on $HOST1 sudo $WEAVE stop-dns || true +run_on $HOST1 sudo $WEAVE launch-dns 10.0.0.2/8 --localDomain foo.bar. + +docker_on $HOST1 rm -f c1 c2 || true + +run_on $HOST1 sudo $WEAVE run $C2/24 -t --name=c2 -h seetwo.foo.bar ubuntu +run_on $HOST1 sudo $WEAVE run --with-dns $C1/24 -t --name=c1 aanand/docker-dnsutils /bin/sh + +ok=$(docker -H tcp://$HOST1:2375 exec -i c1 sh -c "dig +short seetwo.foo.bar.") +assert "echo $ok" "$C2" + +ok=$(docker -H tcp://$HOST1:2375 exec -i c1 sh -c "dig +short -x $C2") +assert "echo $ok" "seetwo.foo.bar." + +end_suite