Remove specialised knowledge of IPAM from weave status formatter

and unnecessary info from `weave report` output

ipam/ring/ring.go

@@ -316,24 +316,25 @@ func (r *Ring) OwnedRanges() (result []address.Range) {
 	return r.splitRangesOverZero(result)
 }
 
-func (r *Ring) OwnedRangesByPeer() map[mesh.PeerName][]address.Range {
+// For printing status
+type RangeInfo struct {
+	Peer mesh.PeerName
+	address.Range
+	Version uint32
+}
+
+func (r *Ring) AllRangeInfo() (result []RangeInfo) {
 	r.assertInvariants()
 
-	result := make(map[mesh.PeerName][]address.Range)
 	for i, entry := range r.Entries {
 		nextEntry := r.Entries.entry(i + 1)
-		resultPeer, found := result[entry.Peer]
-		r := address.Range{Start: entry.Token, End: nextEntry.Token}
-		if !found {
-			result[entry.Peer] = []address.Range{r}
-		} else {
-			result[entry.Peer] = append(resultPeer, r)
+		ranges := []address.Range{{Start: entry.Token, End: nextEntry.Token}}
+		ranges = r.splitRangesOverZero(ranges)
+		for _, r := range ranges {
+			result = append(result, RangeInfo{entry.Peer, r, entry.Version})
 		}
 	}
-	for peer, resultPeer := range result {
-		result[peer] = r.splitRangesOverZero(resultPeer)
-	}
-	return result
+	return
 }
 
 // ClaimForPeers claims the entire ring for the array of peers passed

ipam/status.go

@@ -2,9 +2,6 @@ package ipam
 
 import (
 	"github.com/weaveworks/weave/ipam/paxos"
-	"github.com/weaveworks/weave/ipam/ring"
-	"github.com/weaveworks/weave/ipam/space"
-	"github.com/weaveworks/weave/mesh"
 	"github.com/weaveworks/weave/net/address"
 )
 
@@ -13,21 +10,18 @@ type Status struct {
 	Range            string
 	RangeNumIPs      int
 	DefaultSubnet    string
-	Ring             *ring.Ring                   // information on ranges owned by all peers
-	Space            space.Space                  // more detail on ranges owned by us
-	Owned            map[string][]address.Address // addresses by container-ID
-	OurName          mesh.PeerName
-	Nicknames        map[mesh.PeerName]string `json:"-"`
-	IsKnownPeer      func(mesh.PeerName) bool `json:"-"`
 	Entries          []EntryStatus
 	PendingClaims    []ClaimStatus
 	PendingAllocates []string
 }
 
 type EntryStatus struct {
-	Token   string
-	Peer    string
-	Version uint32
+	Token       string
+	Size        uint32
+	Peer        string
+	Nickname    string
+	IsKnownPeer bool
+	Version     uint32
 }
 
 type ClaimStatus struct {
@@ -52,12 +46,6 @@ func NewStatus(allocator *Allocator, defaultSubnet address.CIDR) *Status {
 			allocator.universe.String(),
 			int(allocator.universe.Size()),
 			defaultSubnet.String(),
-			allocator.ring,
-			allocator.space,
-			allocator.owned,
-			allocator.ourName,
-			allocator.nicknames,
-			allocator.isKnownPeer,
 			newEntryStatusSlice(allocator),
 			newClaimStatusSlice(allocator),
 			newAllocateIdentSlice(allocator)}
@@ -73,8 +61,15 @@ func newEntryStatusSlice(allocator *Allocator) []EntryStatus {
 		return slice
 	}
 
-	for _, entry := range allocator.ring.Entries {
-		slice = append(slice, EntryStatus{entry.Token.String(), entry.Peer.String(), entry.Version})
+	for _, r := range allocator.ring.AllRangeInfo() {
+		slice = append(slice, EntryStatus{
+			Token:       r.Start.String(),
+			Size:        uint32(r.Size()),
+			Peer:        r.Peer.String(),
+			Nickname:    allocator.nicknames[r.Peer],
+			IsKnownPeer: allocator.isKnownPeer(r.Peer),
+			Version:     r.Version,
+		})
 	}
 
 	return slice

prog/weaver/http.go

@@ -33,72 +33,59 @@ var rootTemplate = template.New("root").Funcs(map[string]interface{}{
 		}
 		return strings.Join(servers, ", ")
 	},
-	"printIPAMRanges": func(status ipam.Status) string {
+	"printIPAMRanges": func(router weave.NetworkRouterStatus, status ipam.Status) string {
 		var buffer bytes.Buffer
 
 		type stats struct {
-			Ranges    []address.Range
-			Reachable bool
+			ips       uint32
+			nickname  string
+			reachable bool
 		}
 
-		peerStats := make(map[mesh.PeerName]*stats)
+		peerStats := make(map[string]*stats)
 
-		for peer, ranges := range status.Ring.OwnedRangesByPeer() {
-			s, found := peerStats[peer]
+		for _, entry := range status.Entries {
+			s, found := peerStats[entry.Peer]
 			if !found {
-				s = &stats{Reachable: status.IsKnownPeer(peer)}
-				peerStats[peer] = s
+				s = &stats{nickname: entry.Nickname, reachable: entry.IsKnownPeer}
+				peerStats[entry.Peer] = s
 			}
-			s.Ranges = append(s.Ranges, ranges...)
+			s.ips += entry.Size
 		}
 
-		appendOwned := func(peer mesh.PeerName, nickName string, reachable bool, ranges []address.Range) {
+		printOwned := func(name string, nickName string, reachable bool, ips uint32) {
 			reachableStr := ""
 			if !reachable {
 				reachableStr = "- unreachable!"
 			}
-			ipsInRange := 0
-			for _, chunk := range ranges {
-				ipsInRange += int(chunk.Size())
-			}
-			percentageRanges := float32(ipsInRange) * 100.0 / float32(status.RangeNumIPs)
+			percentageRanges := float32(ips) * 100.0 / float32(status.RangeNumIPs)
 
-			displayName := peer.String() + "(" + nickName + ")"
-			fmt.Fprintf(&buffer, "%20s: %8d IPs (%04.1f%% of total) %s\n",
-				displayName, ipsInRange, percentageRanges, reachableStr)
+			displayName := name + " (" + nickName + ")"
+			fmt.Fprintf(&buffer, "%30s: %8d IPs (%04.1f%% of total) %s\n",
+				displayName, ips, percentageRanges, reachableStr)
 		}
 
-		// print the local addresses
-		if ourStats := peerStats[status.OurName]; ourStats != nil {
-			appendOwned(status.OurName, "local", true, ourStats.Ranges)
+		// print the local info first
+		if ourStats := peerStats[router.Name]; ourStats != nil {
+			printOwned(router.Name, "local", true, ourStats.ips)
 		}
 
 		// and then the rest
 		for peer, stats := range peerStats {
-			if peer != status.OurName {
-				nickname, found := status.Nicknames[peer]
-				if !found {
-					nickname = peer.String()
-				}
-				appendOwned(peer, nickname, stats.Reachable, stats.Ranges)
+			if peer != router.Name {
+				printOwned(peer, stats.nickname, stats.reachable, stats.ips)
 			}
 		}
 
 		return buffer.String()
 	},
-	"printIPAMWarning": func(status ipam.Status) string {
-		ipsReachable := 0
-		for peer, ranges := range status.Ring.OwnedRangesByPeer() {
-			if status.IsKnownPeer(peer) {
-				for _, chunk := range ranges {
-					ipsReachable += int(chunk.Size())
-				}
+	"allIPAMOwnersUnreachable": func(status ipam.Status) bool {
+		for _, entry := range status.Entries {
+			if entry.Size > 0 && entry.IsKnownPeer {
+				return false
 			}
 		}
-		if ipsReachable == 0 {
-			return "- all IPs owned by unreachable peers!"
-		}
-		return ""
+		return true
 	},
 	"printConnectionCounts": func(conns []mesh.LocalConnectionStatus) string {
 		counts := make(map[string]int)
@@ -170,7 +157,11 @@ var statusTemplate = defTemplate("status", `\
 
        Service: ipam
 {{if .IPAM.Entries}}\
-     Consensus: achieved {{printIPAMWarning .IPAM}}
+{{if allIPAMOwnersUnreachable .IPAM}}\
+        Halted: all IPs owned by unreachable peers
+{{else}}\
+     Consensus: achieved
+{{end}}\
 {{else if .IPAM.Paxos}}\
      Consensus: waiting (quorum: {{.IPAM.Paxos.Quorum}}, known: {{.IPAM.Paxos.KnownNodes}})
 {{else}}\
@@ -221,7 +212,7 @@ var dnsEntriesTemplate = defTemplate("dnsEntries", `\
 {{end}}\
 `)
 
-var ipamTemplate = defTemplate("ipamTemplate", `{{printIPAMRanges .IPAM}}`)
+var ipamTemplate = defTemplate("ipamTemplate", `{{printIPAMRanges .Router .IPAM}}`)
 
 type WeaveStatus struct {
 	Version string