From 24702e3a7a5f27bcf21d2046747d3dd681107d99 Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Thu, 27 Nov 2014 16:13:06 +0000 Subject: [PATCH 1/2] stop weavedns from complaining when a container has no docker ip e.g. when it was started with --net=none weavedns wasn't actually using the docker-assigned ip for anything, so this change is a simple matter of eradicating it from the code. --- nameserver/http.go | 13 +++---------- nameserver/mdns_server_test.go | 3 +-- nameserver/zone.go | 7 +++---- nameserver/zone_test.go | 14 +++++--------- weave | 4 ++-- 5 files changed, 14 insertions(+), 27 deletions(-) diff --git a/nameserver/http.go b/nameserver/http.go index d6895d7d..885e9434 100644 --- a/nameserver/http.go +++ b/nameserver/http.go @@ -47,18 +47,11 @@ func ListenHttp(domain string, db Zone, port int) { case "PUT": ident, weaveIPstr, err := parseUrl(r.URL.Path) name := r.FormValue("fqdn") - localIPstr := r.FormValue("local_ip") - if ident == "" || weaveIPstr == "" || name == "" || localIPstr == "" { + if ident == "" || weaveIPstr == "" || name == "" { reqError("Invalid request", "Invalid request: %s, %s", r.URL, r.Form) return } - localIP := net.ParseIP(localIPstr) - if localIP == nil { - reqError("Invalid IP in request", "Invalid IP in request: %s", localIPstr) - return - } - weaveIP := net.ParseIP(weaveIPstr) if weaveIP == nil { reqError("Invalid weave IP", "Invalid weave IP in request: %s", weaveIPstr) @@ -66,8 +59,8 @@ func ListenHttp(domain string, db Zone, port int) { } if dns.IsSubDomain(domain, name) { - Info.Printf("Adding %s (%s) -> %s", name, localIPstr, weaveIPstr) - if err = db.AddRecord(ident, name, localIP, weaveIP); err != nil { + Info.Printf("Adding %s -> %s", name, weaveIPstr) + if err = db.AddRecord(ident, name, weaveIP); err != nil { if dup, ok := err.(DuplicateError); !ok { httpErrorAndLog( Error, w, "Internal error", http.StatusInternalServerError, diff --git a/nameserver/mdns_server_test.go b/nameserver/mdns_server_test.go index fbab25ae..d1019fb5 100644 --- a/nameserver/mdns_server_test.go +++ b/nameserver/mdns_server_test.go @@ -32,9 +32,8 @@ func sendQuery(name string, querytype uint16) error { func TestServerSimpleQuery(t *testing.T) { log.Println("TestServerSimpleQuery starting") var zone = new(ZoneDb) - dockerIP := net.ParseIP("9.8.7.6") weaveIP, _, _ := net.ParseCIDR(testAddr1) - zone.AddRecord(containerID, "test.weave.", dockerIP, weaveIP) + zone.AddRecord(containerID, "test.weave.", weaveIP) mdnsServer, err := NewMDNSServer(zone) assertNoErr(t, err) diff --git a/nameserver/zone.go b/nameserver/zone.go index 97c88cd5..6f0d12fd 100644 --- a/nameserver/zone.go +++ b/nameserver/zone.go @@ -7,7 +7,7 @@ import ( ) type Zone interface { - AddRecord(ident string, name string, localIP net.IP, weaveIP net.IP) error + AddRecord(ident string, name string, weaveIP net.IP) error DeleteRecord(ident string, weaveIp net.IP) error DeleteRecordsFor(ident string) error MatchLocal(name string) (net.IP, error) @@ -17,7 +17,6 @@ type Zone interface { type Record struct { Ident string Name string - LocalIP net.IP WeaveIP net.IP } @@ -75,7 +74,7 @@ func (zone *ZoneDb) MatchLocalIP(ip net.IP) (string, error) { return "", LookupError(ip.String()) } -func (zone *ZoneDb) AddRecord(ident string, name string, localIP net.IP, weaveIP net.IP) error { +func (zone *ZoneDb) AddRecord(ident string, name string, weaveIP net.IP) error { zone.mx.Lock() defer zone.mx.Unlock() fqdn := dns.Fqdn(name) @@ -83,7 +82,7 @@ func (zone *ZoneDb) AddRecord(ident string, name string, localIP net.IP, weaveIP func(r Record) bool { return r.Name == fqdn && r.WeaveIP.Equal(weaveIP) }); index != -1 { return DuplicateError{fqdn, weaveIP, zone.recs[index].Ident} } - zone.recs = append(zone.recs, Record{ident, fqdn, localIP, weaveIP}) + zone.recs = append(zone.recs, Record{ident, fqdn, weaveIP}) return nil } diff --git a/nameserver/zone_test.go b/nameserver/zone_test.go index 3ada988c..d9f7842d 100644 --- a/nameserver/zone_test.go +++ b/nameserver/zone_test.go @@ -10,20 +10,18 @@ func TestZone(t *testing.T) { containerID = "deadbeef" successTestName = "test1.weave." testAddr1 = "10.0.2.1/24" - dockerIP = "9.8.7.6" ) var zone = new(ZoneDb) - ip := net.ParseIP(dockerIP) weaveIP, _, _ := net.ParseCIDR(testAddr1) - err := zone.AddRecord(containerID, successTestName, ip, weaveIP) + err := zone.AddRecord(containerID, successTestName, weaveIP) assertNoErr(t, err) // Add a few more records to make the job harder - err = zone.AddRecord("abcdef0123", "adummy.weave.", net.ParseIP("1.1.1.1"), net.ParseIP("10.0.0.1")) + err = zone.AddRecord("abcdef0123", "adummy.weave.", net.ParseIP("10.0.0.1")) assertNoErr(t, err) - err = zone.AddRecord("0123abcdef", "zdummy.weave.", net.ParseIP("2.2.2.2"), net.ParseIP("10.0.0.2")) + err = zone.AddRecord("0123abcdef", "zdummy.weave.", net.ParseIP("10.0.0.2")) assertNoErr(t, err) // Check that the address is now there. @@ -43,7 +41,7 @@ func TestZone(t *testing.T) { } // Now try to add the same address again - err = zone.AddRecord(containerID, successTestName, ip, weaveIP) + err = zone.AddRecord(containerID, successTestName, weaveIP) assertErrorType(t, err, (*DuplicateError)(nil), "duplicate add") // Now delete the record @@ -65,13 +63,11 @@ func TestDeleteFor(t *testing.T) { name = "foo.weave." addr1 = "10.1.2.3/24" addr2 = "10.2.7.8/24" - dockerIP = "172.16.0.4" ) zone := new(ZoneDb) - ip := net.ParseIP(dockerIP) for _, addr := range []string{addr1, addr2} { weaveIP, _, _ := net.ParseCIDR(addr) - err := zone.AddRecord(id, name, ip, weaveIP) + err := zone.AddRecord(id, name, weaveIP) assertNoErr(t, err) } diff --git a/weave b/weave index 7d0dfd40..316ff410 100755 --- a/weave +++ b/weave @@ -316,7 +316,7 @@ tell_dns() { CONTAINER=$(docker inspect --format '{{.Id}}' $2 2>/dev/null) # extract IP address and routing prefix from CIDR WEAVE_ADDR_IP=$(echo $3 | sed -e 's/\([^/]*\)\/\(.*\)/\1/') - MORE_ARGS=$(docker inspect --format '--data-urlencode local_ip={{ .NetworkSettings.IPAddress }} --data-urlencode fqdn={{ .Config.Hostname }}.{{ .Config.Domainname }}.' $CONTAINER 2>/dev/null) && true + MORE_ARGS=$(docker inspect --format '--data-urlencode fqdn={{ .Config.Hostname }}.{{ .Config.Domainname }}.' $CONTAINER 2>/dev/null) && true http_call $DNS_CONTAINER_NAME $DNS_HTTP_PORT $1 /name/$CONTAINER/$WEAVE_ADDR_IP $MORE_ARGS } @@ -334,7 +334,7 @@ populate_dns() { fi for CONTAINER in $(docker ps -q); do - MORE_ARGS=$(docker inspect --format '--data-urlencode local_ip={{ .NetworkSettings.IPAddress }} --data-urlencode fqdn={{ .Config.Hostname }}.{{ .Config.Domainname }}.' $CONTAINER 2>/dev/null) && true + MORE_ARGS=$(docker inspect --format '--data-urlencode fqdn={{ .Config.Hostname }}.{{ .Config.Domainname }}.' $CONTAINER 2>/dev/null) && true if CONTAINER_ADDRS=$(with_container_netns $CONTAINER container_weave_addrs 2>&1) ; then CONTAINER_IPS=$(echo "$CONTAINER_ADDRS" | grep -o 'inet .*' | sed -e 's/inet \([^/]*\)\/\(.*\)/\1/') for IP in $CONTAINER_IPS; do From 56bfb09656b17616018d3b9d4287a73d7874a04b Mon Sep 17 00:00:00 2001 From: Matthias Radestock Date: Thu, 27 Nov 2014 16:31:42 +0000 Subject: [PATCH 2/2] s/weaveIP/ip --- nameserver/http.go | 28 ++++++++++++++-------------- nameserver/http_test.go | 8 ++++---- nameserver/mdns_server_test.go | 6 +++--- nameserver/zone.go | 34 +++++++++++++++++----------------- nameserver/zone_test.go | 18 +++++++++--------- 5 files changed, 47 insertions(+), 47 deletions(-) diff --git a/nameserver/http.go b/nameserver/http.go index 885e9434..7ab19550 100644 --- a/nameserver/http.go +++ b/nameserver/http.go @@ -45,22 +45,22 @@ func ListenHttp(domain string, db Zone, port int) { switch r.Method { case "PUT": - ident, weaveIPstr, err := parseUrl(r.URL.Path) + ident, ipStr, err := parseUrl(r.URL.Path) name := r.FormValue("fqdn") - if ident == "" || weaveIPstr == "" || name == "" { + if ident == "" || ipStr == "" || name == "" { reqError("Invalid request", "Invalid request: %s, %s", r.URL, r.Form) return } - weaveIP := net.ParseIP(weaveIPstr) - if weaveIP == nil { - reqError("Invalid weave IP", "Invalid weave IP in request: %s", weaveIPstr) + ip := net.ParseIP(ipStr) + if ip == nil { + reqError("Invalid IP", "Invalid IP in request: %s", ipStr) return } if dns.IsSubDomain(domain, name) { - Info.Printf("Adding %s -> %s", name, weaveIPstr) - if err = db.AddRecord(ident, name, weaveIP); err != nil { + Info.Printf("Adding %s -> %s", name, ipStr) + if err = db.AddRecord(ident, name, ip); err != nil { if dup, ok := err.(DuplicateError); !ok { httpErrorAndLog( Error, w, "Internal error", http.StatusInternalServerError, @@ -76,19 +76,19 @@ func ListenHttp(domain string, db Zone, port int) { } case "DELETE": - ident, weaveIPstr, err := parseUrl(r.URL.Path) - if ident == "" || weaveIPstr == "" { + ident, ipStr, err := parseUrl(r.URL.Path) + if ident == "" || ipStr == "" { reqError("Invalid Request", "Invalid request: %s, %s", r.URL, r.Form) return } - weaveIP := net.ParseIP(weaveIPstr) - if weaveIP == nil { - reqError("Invalid IP in request", "Invalid IP in request: %s", weaveIPstr) + ip := net.ParseIP(ipStr) + if ip == nil { + reqError("Invalid IP in request", "Invalid IP in request: %s", ipStr) return } - Info.Printf("Deleting %s (%s)", ident, weaveIPstr) - if err = db.DeleteRecord(ident, weaveIP); err != nil { + Info.Printf("Deleting %s (%s)", ident, ipStr) + if err = db.DeleteRecord(ident, ip); err != nil { if _, ok := err.(LookupError); !ok { httpErrorAndLog( Error, w, "Internal error", http.StatusInternalServerError, diff --git a/nameserver/http_test.go b/nameserver/http_test.go index 9e41dbd8..b7b300e7 100644 --- a/nameserver/http_test.go +++ b/nameserver/http_test.go @@ -42,11 +42,11 @@ func TestHttp(t *testing.T) { assertStatus(t, resp.StatusCode, http.StatusOK, "http response") // Check that the address is now there. - ip, err := zone.MatchLocal(successTestName) + foundIP, err := zone.MatchLocal(successTestName) assertNoErr(t, err) - weaveIP, _, _ := net.ParseCIDR(testAddr1) - if !ip.Equal(weaveIP) { - t.Fatal("Unexpected result for", successTestName, ip) + ip, _, _ := net.ParseCIDR(testAddr1) + if !foundIP.Equal(ip) { + t.Fatal("Unexpected result for", successTestName, foundIP) } // Adding exactly the same address should be OK diff --git a/nameserver/mdns_server_test.go b/nameserver/mdns_server_test.go index d1019fb5..b3550ec8 100644 --- a/nameserver/mdns_server_test.go +++ b/nameserver/mdns_server_test.go @@ -32,8 +32,8 @@ func sendQuery(name string, querytype uint16) error { func TestServerSimpleQuery(t *testing.T) { log.Println("TestServerSimpleQuery starting") var zone = new(ZoneDb) - weaveIP, _, _ := net.ParseCIDR(testAddr1) - zone.AddRecord(containerID, "test.weave.", weaveIP) + ip, _, _ := net.ParseCIDR(testAddr1) + zone.AddRecord(containerID, "test.weave.", ip) mdnsServer, err := NewMDNSServer(zone) assertNoErr(t, err) @@ -73,7 +73,7 @@ func TestServerSimpleQuery(t *testing.T) { if receivedCount != 1 { t.Fatal("Unexpected result count for test.weave", receivedCount) } - if !receivedAddr.Equal(weaveIP) { + if !receivedAddr.Equal(ip) { t.Fatal("Unexpected result for test.weave", receivedAddr) } diff --git a/nameserver/zone.go b/nameserver/zone.go index 6f0d12fd..051ac497 100644 --- a/nameserver/zone.go +++ b/nameserver/zone.go @@ -7,17 +7,17 @@ import ( ) type Zone interface { - AddRecord(ident string, name string, weaveIP net.IP) error - DeleteRecord(ident string, weaveIp net.IP) error + AddRecord(ident string, name string, ip net.IP) error + DeleteRecord(ident string, ip net.IP) error DeleteRecordsFor(ident string) error MatchLocal(name string) (net.IP, error) MatchLocalIP(ip net.IP) (string, error) } type Record struct { - Ident string - Name string - WeaveIP net.IP + Ident string + Name string + IP net.IP } // Very simple data structure for now, with linear searching. @@ -34,13 +34,13 @@ func (ops LookupError) Error() string { } type DuplicateError struct { - Name string - WeaveIP net.IP - Ident string + Name string + IP net.IP + Ident string } func (err DuplicateError) Error() string { - return "Duplicate " + err.Name + "," + err.WeaveIP.String() + " for identity " + err.Ident + return "Duplicate " + err.Name + "," + err.IP.String() + " for identity " + err.Ident } func (zone *ZoneDb) indexOf(match func(Record) bool) int { @@ -57,7 +57,7 @@ func (zone *ZoneDb) MatchLocal(name string) (net.IP, error) { defer zone.mx.RUnlock() for _, r := range zone.recs { if r.Name == name { - return r.WeaveIP, nil + return r.IP, nil } } return nil, LookupError(name) @@ -67,30 +67,30 @@ func (zone *ZoneDb) MatchLocalIP(ip net.IP) (string, error) { zone.mx.RLock() defer zone.mx.RUnlock() for _, r := range zone.recs { - if r.WeaveIP.Equal(ip) { + if r.IP.Equal(ip) { return r.Name, nil } } return "", LookupError(ip.String()) } -func (zone *ZoneDb) AddRecord(ident string, name string, weaveIP net.IP) error { +func (zone *ZoneDb) AddRecord(ident string, name string, ip net.IP) error { zone.mx.Lock() defer zone.mx.Unlock() fqdn := dns.Fqdn(name) if index := zone.indexOf( - func(r Record) bool { return r.Name == fqdn && r.WeaveIP.Equal(weaveIP) }); index != -1 { - return DuplicateError{fqdn, weaveIP, zone.recs[index].Ident} + func(r Record) bool { return r.Name == fqdn && r.IP.Equal(ip) }); index != -1 { + return DuplicateError{fqdn, ip, zone.recs[index].Ident} } - zone.recs = append(zone.recs, Record{ident, fqdn, weaveIP}) + zone.recs = append(zone.recs, Record{ident, fqdn, ip}) return nil } -func (zone *ZoneDb) DeleteRecord(ident string, weaveIP net.IP) error { +func (zone *ZoneDb) DeleteRecord(ident string, ip net.IP) error { zone.mx.Lock() defer zone.mx.Unlock() if index := zone.indexOf( - func(r Record) bool { return r.Ident == ident && r.WeaveIP.Equal(weaveIP) }); index == -1 { + func(r Record) bool { return r.Ident == ident && r.IP.Equal(ip) }); index == -1 { return LookupError(ident) } else { zone.recs = append(zone.recs[:index], zone.recs[index+1:]...) diff --git a/nameserver/zone_test.go b/nameserver/zone_test.go index d9f7842d..66c7cdd7 100644 --- a/nameserver/zone_test.go +++ b/nameserver/zone_test.go @@ -14,8 +14,8 @@ func TestZone(t *testing.T) { var zone = new(ZoneDb) - weaveIP, _, _ := net.ParseCIDR(testAddr1) - err := zone.AddRecord(containerID, successTestName, weaveIP) + ip, _, _ := net.ParseCIDR(testAddr1) + err := zone.AddRecord(containerID, successTestName, ip) assertNoErr(t, err) // Add a few more records to make the job harder @@ -28,24 +28,24 @@ func TestZone(t *testing.T) { foundIP, err := zone.MatchLocal(successTestName) assertNoErr(t, err) - if !foundIP.Equal(weaveIP) { + if !foundIP.Equal(ip) { t.Fatal("Unexpected result for", successTestName, foundIP) } // See if we can find the address by IP. - foundName, err := zone.MatchLocalIP(weaveIP) + foundName, err := zone.MatchLocalIP(ip) assertNoErr(t, err) if foundName != successTestName { - t.Fatal("Unexpected result for", weaveIP, foundName) + t.Fatal("Unexpected result for", ip, foundName) } // Now try to add the same address again - err = zone.AddRecord(containerID, successTestName, weaveIP) + err = zone.AddRecord(containerID, successTestName, ip) assertErrorType(t, err, (*DuplicateError)(nil), "duplicate add") // Now delete the record - err = zone.DeleteRecord(containerID, weaveIP) + err = zone.DeleteRecord(containerID, ip) assertNoErr(t, err) // Check that the address is not there now. @@ -66,8 +66,8 @@ func TestDeleteFor(t *testing.T) { ) zone := new(ZoneDb) for _, addr := range []string{addr1, addr2} { - weaveIP, _, _ := net.ParseCIDR(addr) - err := zone.AddRecord(id, name, weaveIP) + ip, _, _ := net.ParseCIDR(addr) + err := zone.AddRecord(id, name, ip) assertNoErr(t, err) }