fast network membership check

render/container_test.go

@@ -2,7 +2,6 @@ package render_test
 
 import (
 	"fmt"
-	"net"
 	"testing"
 
 	"github.com/weaveworks/common/test"
@@ -46,11 +45,10 @@ type testcase struct {
 }
 
 func testMap(t *testing.T, f render.MapFunc, input testcase) {
-	_, ipNet, err := net.ParseCIDR("1.2.3.0/16")
-	if err != nil {
+	localNetworks := report.NewNetworks()
+	if err := localNetworks.AddCIDR("1.2.3.0/16"); err != nil {
 		t.Fatalf(err.Error())
 	}
-	localNetworks := report.Networks([]*net.IPNet{ipNet})
 	if have := f(input.n, localNetworks); input.ok != (len(have) > 0) {
 		name := input.name
 		if name == "" {

render/theinternet.go

@@ -1,7 +1,6 @@
 package render
 
 import (
-	"net"
 	"regexp"
 	"strings"
 
@@ -68,26 +67,15 @@ func isKnownService(hostname string) bool {
 // used to determine which nodes in the report are "remote", i.e. outside of
 // our infrastructure.
 func LocalNetworks(r report.Report) report.Networks {
-	var (
-		result   = report.Networks{}
-		networks = map[string]struct{}{}
-	)
+	networks := report.NewNetworks()
 
 	for _, topology := range []report.Topology{r.Host, r.Overlay} {
 		for _, md := range topology.Nodes {
 			nets, _ := md.Sets.Lookup(host.LocalNetworks)
 			for _, s := range nets {
-				_, ipNet, err := net.ParseCIDR(s)
-				if err != nil {
-					continue
-				}
-				_, ok := networks[ipNet.String()]
-				if !ok {
-					result = append(result, ipNet)
-					networks[ipNet.String()] = struct{}{}
-				}
+				networks.AddCIDR(s)
 			}
 		}
 	}
-	return result
+	return networks
 }

render/theinternet_test.go

@@ -1,7 +1,6 @@
 package render_test
 
 import (
-	"net"
 	"reflect"
 	"testing"
 
@@ -30,21 +29,14 @@ func TestReportLocalNetworks(t *testing.T) {
 			},
 		},
 	})
-	want := report.Networks([]*net.IPNet{
-		mustParseCIDR("10.0.0.1/8"),
-		mustParseCIDR("192.168.1.1/24"),
-		mustParseCIDR("10.32.0.1/12"),
-	})
+	want := report.NewNetworks()
+	for _, cidr := range []string{"10.0.0.1/8", "192.168.1.1/24", "10.32.0.1/12"} {
+		if err := want.AddCIDR(cidr); err != nil {
+			panic(err)
+		}
+	}
 	have := render.LocalNetworks(r)
 	if !reflect.DeepEqual(want, have) {
 		t.Errorf("%s", test.Diff(want, have))
 	}
 }
-
-func mustParseCIDR(s string) *net.IPNet {
-	_, ipNet, err := net.ParseCIDR(s)
-	if err != nil {
-		panic(err)
-	}
-	return ipNet
-}

report/networks.go

@@ -3,25 +3,38 @@ package report
 import (
 	"net"
 	"strings"
+
+	"github.com/k-sone/critbitgo"
 )
 
 // Networks represent a set of subnets
-type Networks []*net.IPNet
+type Networks struct{ *critbitgo.Net }
 
 // LocalNetworks helps in determining which addresses a probe reports
 // as being host-scoped.
 //
 // TODO this design is broken, make it consistent with probe networks.
-var LocalNetworks = Networks{}
+var LocalNetworks = NewNetworks()
+
+// NewNetworks creates a datastructure representing a set of networks.
+func NewNetworks() Networks {
+	return Networks{critbitgo.NewNet()}
+}
+
+// Add adds a network.
+func (n Networks) Add(ipnet *net.IPNet) error {
+	return n.Net.Add(ipnet, struct{}{})
+}
+
+// AddCIDR adds a network, represented as CIDR.
+func (n Networks) AddCIDR(cidr string) error {
+	return n.Net.AddCIDR(cidr, struct{}{})
+}
 
 // Contains returns true if IP is in Networks.
 func (n Networks) Contains(ip net.IP) bool {
-	for _, net := range n {
-		if net.Contains(ip) {
-			return true
-		}
-	}
-	return false
+	network, _, _ := n.MatchIP(ip)
+	return network != nil
 }
 
 // LocalAddresses returns a list of the local IP addresses.
@@ -67,7 +80,9 @@ func AddLocalBridge(name string) error {
 		return err
 	}
 
-	LocalNetworks = ipv4Nets(addrs)
+	for _, ipnet := range ipv4Nets(addrs) {
+		LocalNetworks.Add(ipnet)
+	}
 
 	return nil
 }
@@ -82,7 +97,7 @@ func GetLocalNetworks() ([]*net.IPNet, error) {
 }
 
 func ipv4Nets(addrs []net.Addr) []*net.IPNet {
-	nets := Networks{}
+	nets := []*net.IPNet{}
 	for _, addr := range addrs {
 		if ipnet, ok := addr.(*net.IPNet); ok && ipnet.IP.To4() != nil {
 			nets = append(nets, ipnet)

report/networks_test.go

@@ -8,10 +8,12 @@ import (
 )
 
 func TestContains(t *testing.T) {
-	networks := report.Networks([]*net.IPNet{
-		mustParseCIDR("10.0.0.1/8"),
-		mustParseCIDR("192.168.1.1/24"),
-	})
+	networks := report.NewNetworks()
+	for _, cidr := range []string{"10.0.0.1/8", "192.168.1.1/24"} {
+		if err := networks.AddCIDR(cidr); err != nil {
+			panic(err)
+		}
+	}
 
 	if networks.Contains(net.ParseIP("52.52.52.52")) {
 		t.Errorf("52.52.52.52 not in %v", networks)
@@ -21,11 +23,3 @@ func TestContains(t *testing.T) {
 		t.Errorf("10.0.0.1 in %v", networks)
 	}
 }
-
-func mustParseCIDR(s string) *net.IPNet {
-	_, ipNet, err := net.ParseCIDR(s)
-	if err != nil {
-		panic(err)
-	}
-	return ipNet
-}