From 337919d741acb86d8a47fdd0906dc0da9e1ac7ac Mon Sep 17 00:00:00 2001 From: Michael Bridgen Date: Mon, 20 Oct 2014 18:18:16 +0100 Subject: [PATCH] Replaced ad-hoc printf with log levels --- main.go | 18 ++++++++++++------ server/http.go | 21 ++++++++++----------- server/mdns_client.go | 1 - server/mdns_server.go | 4 +--- server/server.go | 22 ++++++++++++---------- server/updater.go | 7 +++---- 6 files changed, 38 insertions(+), 35 deletions(-) diff --git a/main.go b/main.go index 906e6fd3..847b8e72 100644 --- a/main.go +++ b/main.go @@ -3,14 +3,12 @@ package main import ( "flag" "github.com/zettio/weavedns/server" - "log" + "io/ioutil" "net" "os" ) func main() { - log.Println(os.Args) - var ( ifaceName string apiPath string @@ -18,6 +16,7 @@ func main() { httpPort int wait int watch bool + debug bool ) flag.StringVar(&ifaceName, "iface", "", "name of interface to use for multicast") @@ -26,14 +25,21 @@ func main() { flag.IntVar(&dnsPort, "dnsport", 53, "port to listen to dns requests (defaults to 53)") flag.IntVar(&httpPort, "httpport", 6785, "port to listen to HTTP requests (defaults to 6785)") flag.BoolVar(&watch, "watch", true, "watch the docker socket for container events") + flag.BoolVar(&debug, "debug", false, "output debugging info to stderr") flag.Parse() + debugOut := ioutil.Discard + if debug { + debugOut = os.Stderr + } + weavedns.InitLogging(debugOut, os.Stdout, os.Stdout, os.Stderr) + var zone = new(weavedns.ZoneDb) if watch { err := weavedns.StartUpdater(apiPath, zone) if err != nil { - log.Fatal("Unable to start watcher", err) + weavedns.Error.Fatal("Unable to start watcher", err) } } @@ -42,12 +48,12 @@ func main() { var err error iface, err = weavedns.EnsureInterface(ifaceName, wait) if err != nil { - log.Fatal(err) + weavedns.Error.Fatal(err) } } err := weavedns.StartServer(zone, iface, dnsPort, httpPort, wait) if err != nil { - log.Fatal("Failed to start server", err) + weavedns.Error.Fatal("Failed to start server", err) } } diff --git a/server/http.go b/server/http.go index dedb8234..ae5be5ce 100644 --- a/server/http.go +++ b/server/http.go @@ -3,7 +3,6 @@ package weavedns import ( "errors" "fmt" - "log" "github.com/miekg/dns" "net" "net/http" @@ -28,60 +27,60 @@ func ListenHttp(domain string, db Zone, port int) { prefix := r.FormValue("routing_prefix") local_ip := r.FormValue("local_ip") if identifier == "" || weave_ipstr == "" || name == "" || prefix == "" || local_ip == "" { - log.Printf("Invalid request: %s, %s", r.URL, r.Form) + Warning.Printf("Invalid request: %s, %s", r.URL, r.Form) http.Error(w, "Invalid Request", http.StatusBadRequest) return } ip := net.ParseIP(local_ip) if ip == nil { - log.Printf("Invalid IP in request: %s", local_ip) + Warning.Printf("Invalid IP in request: %s", local_ip) http.Error(w, "Invalid IP in request", http.StatusBadRequest) return } weave_cidr := weave_ipstr + "/" + prefix weave_ip, subnet, err := net.ParseCIDR(weave_cidr) if err != nil { - log.Printf("Invalid CIDR in request: %s", weave_cidr) + Warning.Printf("Invalid CIDR in request: %s", weave_cidr) http.Error(w, fmt.Sprintf("Invalid CIDR: %s", weave_cidr), http.StatusBadRequest) return } if dns.IsSubDomain(domain, name) { - log.Printf("Adding %s (%s) -> %s", name, local_ip, weave_cidr) + Info.Printf("Adding %s (%s) -> %s", name, local_ip, weave_cidr) err = db.AddRecord(identifier, name, ip, weave_ip, subnet) if err != nil { http.Error(w, err.Error(), http.StatusConflict) return } } else { - log.Printf("Ignoring name %s, not in %s", name, domain) + Info.Printf("Ignoring name %s, not in %s", name, domain) } case "DELETE": identifier, weave_ipstr, err := parseUrl(r.URL.Path) if identifier == "" || weave_ipstr == "" { - log.Printf("Invalid request: %s, %s", r.URL, r.Form) + Warning.Printf("Invalid request: %s, %s", r.URL, r.Form) http.Error(w, "Invalid Request", http.StatusBadRequest) return } weave_ip := net.ParseIP(weave_ipstr) if weave_ip == nil { - log.Printf("Invalid IP in request: %s", weave_ipstr) + Warning.Printf("Invalid IP in request: %s", weave_ipstr) http.Error(w, "Invalid IP in request", http.StatusBadRequest) return } - log.Printf("Deleting %s (%s)", identifier, weave_ipstr) + Info.Printf("Deleting %s (%s)", identifier, weave_ipstr) err = db.DeleteRecord(identifier, weave_ip) if err != nil { http.Error(w, err.Error(), http.StatusBadRequest) return } default: - log.Println("Unexpected http method", r.Method) + Warning.Println("Unexpected http method", r.Method) http.Error(w, "Unexpected http method: "+r.Method, http.StatusBadRequest) } }) address := fmt.Sprintf(":%d", port) err := http.ListenAndServe(address, nil) if err != nil { - log.Fatal("Unable to create http listener: ", err) + Error.Fatal("Unable to create http listener: ", err) } } diff --git a/server/mdns_client.go b/server/mdns_client.go index 213bb61e..26c23bbe 100644 --- a/server/mdns_client.go +++ b/server/mdns_client.go @@ -79,7 +79,6 @@ func (c *MDNSClient) Start(ifi *net.Interface) error { } handleMDNS := func(w dns.ResponseWriter, r *dns.Msg) { - //log.Println("client received:", r) // Don't want to handle queries here, so filter anything out that isn't a response if len(r.Answer) > 0 { c.ResponseCallback(r) diff --git a/server/mdns_server.go b/server/mdns_server.go index 4bb8fe10..8c13de8b 100644 --- a/server/mdns_server.go +++ b/server/mdns_server.go @@ -2,7 +2,6 @@ package weavedns import ( "github.com/miekg/dns" - "log" "net" ) @@ -13,7 +12,6 @@ type MDNSServer struct { } func NewMDNSServer(zone Zone) (*MDNSServer, error) { - //log.Println("minimalServer sending:", buf) // This is a bit of a kludge - per the RFC we should send responses from 5353, but that doesn't seem to work sendconn, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4zero, Port: 0}) if err != nil { @@ -69,7 +67,7 @@ func (s *MDNSServer) Start(ifi *net.Interface) error { } else if s.addrIsLocal(w.RemoteAddr()) { // ignore this - it's our own query received via multicast } else { - log.Printf("Failed MDNS lookup for %s", q.Name) + Debug.Printf("Failed MDNS lookup for %s", q.Name) } } } diff --git a/server/server.go b/server/server.go index 975ccac1..239d0bdd 100644 --- a/server/server.go +++ b/server/server.go @@ -3,7 +3,6 @@ package weavedns import ( "fmt" "github.com/miekg/dns" - "log" "net" ) @@ -22,19 +21,20 @@ func makeDNSFailResponse(r *dns.Msg) *dns.Msg { func queryHandler(zone Zone, mdnsClient *MDNSClient) dns.HandlerFunc { return func(w dns.ResponseWriter, r *dns.Msg) { q := r.Question[0] + Debug.Printf("Local query: %s", q) ip, err := zone.MatchLocal(q.Name) if err == nil { m := makeDNSReply(r, q.Name, dns.TypeA, []net.IP{ip}) w.WriteMsg(m) } else { - log.Printf("Failed lookup for %s; sending mDNS query", q.Name) + Debug.Printf("Failed lookup for %s; sending mDNS query", q.Name) // We don't know the answer; see if someone else does channel := make(chan *ResponseA, ChannelSize) replies := make([]net.IP, 0) go func() { // Loop terminates when channel is closed by MDNSClient on timeout for resp := range channel { - log.Printf("Got address response %s to query %s addr %s", resp.Name, q.Name, resp.Addr) + Debug.Printf("Got address response %s to query %s addr %s", resp.Name, q.Name, resp.Addr) replies = append(replies, resp.Addr) } var response_msg *dns.Msg @@ -58,12 +58,14 @@ func queryHandler(zone Zone, mdnsClient *MDNSClient) dns.HandlerFunc { func notUsHandler() dns.HandlerFunc { return func(w dns.ResponseWriter, r *dns.Msg) { q := r.Question[0] + Debug.Printf("Non-local query: %s", q) addrs, err := net.LookupIP(q.Name) var response_msg *dns.Msg if err == nil { response_msg = makeDNSReply(r, q.Name, q.Qtype, addrs) } else { response_msg = makeDNSFailResponse(r) + Debug.Print("Failed fallback lookup", err) } w.WriteMsg(response_msg) } @@ -74,13 +76,13 @@ func StartServer(zone Zone, iface *net.Interface, dnsPort int, httpPort int, wai mdnsClient, err := NewMDNSClient() if err != nil { - log.Fatal(err) + Error.Fatal(err) } else { - log.Printf("Using mDNS on %s", iface.Name) + Info.Printf("Using mDNS on %s", iface.Name) } err = mdnsClient.Start(iface) if err != nil { - log.Fatal(err) + Error.Fatal(err) } LocalServeMux := dns.NewServeMux() @@ -89,19 +91,19 @@ func StartServer(zone Zone, iface *net.Interface, dnsPort int, httpPort int, wai mdnsServer, err := NewMDNSServer(zone) if err != nil { - log.Fatal(err) + Error.Fatal(err) } err = mdnsServer.Start(iface) if err != nil { - log.Fatal(err) + Error.Fatal(err) } address := fmt.Sprintf(":%d", dnsPort) err = dns.ListenAndServe(address, "udp", LocalServeMux) if err != nil { - log.Fatal(err) + Error.Fatal(err) } else { - log.Printf("Listening for DNS on %s", address) + Info.Printf("Listening for DNS on %s", address) } return nil } diff --git a/server/updater.go b/server/updater.go index dee375c7..c0d71f04 100644 --- a/server/updater.go +++ b/server/updater.go @@ -2,19 +2,18 @@ package weavedns import ( "github.com/fsouza/go-dockerclient" - "log" ) func StartUpdater(apiPath string, zone Zone) error { client, err := docker.NewClient(apiPath) if err != nil { - log.Fatalf("Unable to connect to Docker API on %s: %s", apiPath, err) + Error.Fatalf("Unable to connect to Docker API on %s: %s", apiPath, err) } events := make(chan *docker.APIEvents) client.AddEventListener(events) - log.Printf("Using Docker API on %s", apiPath) + Info.Printf("Using Docker API on %s", apiPath) go func() { for event := range events { @@ -28,7 +27,7 @@ func handleEvent(zone Zone, event *docker.APIEvents, client *docker.Client) erro switch event.Status { case "die": id := event.ID - log.Printf("Container %s down. Removing records", id) + Info.Printf("Container %s down. Removing records", id) zone.DeleteRecordsFor(id) } return nil