Add connection tables to details panel

app/api_topology.go

@@ -51,17 +51,18 @@ func handleWs(ctx context.Context, rep Reporter, renderer render.Renderer, w htt
 }
 
 // Individual nodes.
-func handleNode(nodeID string) func(context.Context, Reporter, render.Renderer, http.ResponseWriter, *http.Request) {
+func handleNode(topologyID, nodeID string) func(context.Context, Reporter, render.Renderer, http.ResponseWriter, *http.Request) {
 	return func(ctx context.Context, rep Reporter, renderer render.Renderer, w http.ResponseWriter, r *http.Request) {
 		var (
 			rpt      = rep.Report(ctx)
-			node, ok = renderer.Render(rep.Report(ctx))[nodeID]
+			rendered = renderer.Render(rep.Report(ctx))
+			node, ok = rendered[nodeID]
 		)
 		if !ok {
 			http.NotFound(w, r)
 			return
 		}
-		respondWith(w, http.StatusOK, APINode{Node: detailed.MakeNode(rpt, node)})
+		respondWith(w, http.StatusOK, APINode{Node: detailed.MakeNode(topologyID, rpt, rendered, node)})
 	}
 }
 

app/api_topology_test.go

@@ -54,27 +54,6 @@ func TestAll(t *testing.T) {
 	}
 }
 
-func TestAPITopologyContainers(t *testing.T) {
-	ts := topologyServer()
-	{
-		body := getRawJSON(t, ts, "/api/topology/containers")
-		var topo app.APITopology
-		decoder := codec.NewDecoderBytes(body, &codec.JsonHandle{})
-		if err := decoder.Decode(&topo); err != nil {
-			t.Fatal(err)
-		}
-		want := expected.RenderedContainers.Copy()
-		for id, node := range want {
-			node.ControlNode = ""
-			want[id] = node
-		}
-
-		if have := topo.Nodes.Prune(); !reflect.DeepEqual(want, have) {
-			t.Error(test.Diff(want, have))
-		}
-	}
-}
-
 func TestAPITopologyProcesses(t *testing.T) {
 	ts := topologyServer()
 	defer ts.Close()
@@ -124,13 +103,13 @@ func TestAPITopologyHosts(t *testing.T) {
 		}
 	}
 	{
-		body := getRawJSON(t, ts, "/api/topology/hosts/"+expected.ServerHostRenderedID)
+		body := getRawJSON(t, ts, "/api/topology/hosts/"+expected.ServerHostID)
 		var node app.APINode
 		decoder := codec.NewDecoderBytes(body, &codec.JsonHandle{})
 		if err := decoder.Decode(&node); err != nil {
 			t.Fatal(err)
 		}
-		equals(t, expected.ServerHostRenderedID, node.Node.ID)
+		equals(t, expected.ServerHostID, node.Node.ID)
 		equals(t, "server", node.Node.Label)
 		equals(t, false, node.Node.Pseudo)
 		// Let's not unit-test the specific content of the detail tables

app/router.go

@@ -122,7 +122,7 @@ func TopologyHandler(c Reporter, preRoutes *mux.Router, postRoutes http.Handler)
 		}
 
 		handler := gzipHandler(requestContextDecorator(topologyRegistry.captureRendererWithoutFilters(
-			c, topologyID, handleNode(nodeID),
+			c, topologyID, handleNode(topologyID, nodeID),
 		)))
 		handler.ServeHTTP(w, r)
 	})

client/app/scripts/components/node-details.js

@@ -174,6 +174,14 @@ export default class NodeDetails extends React.Component {
             <NodeDetailsInfo rows={details.metadata} />
           </div>}
 
+          {details.connections && details.connections.map(connections => {
+            return (
+              <div className="node-details-content-section" key={connections.id}>
+                <NodeDetailsTable {...connections} />
+              </div>
+            );
+          })}
+
           {details.children && details.children.map(children => {
             return (
               <div className="node-details-content-section" key={children.topologyId}>

client/app/scripts/components/node-details/node-details-table.js

@@ -5,6 +5,10 @@ import ShowMore from '../show-more';
 import NodeDetailsTableNodeLink from './node-details-table-node-link';
 import NodeDetailsTableNodeMetric from './node-details-table-node-metric';
 
+function isNumberField(field) {
+  return field.dataType && field.dataType === 'number';
+}
+
 export default class NodeDetailsTable extends React.Component {
 
   constructor(props, context) {
@@ -32,14 +36,28 @@ export default class NodeDetailsTable extends React.Component {
   }
 
   getDefaultSortBy() {
-    // first metric
+    // default sorter specified by columns
+    const defaultSortColumn = _.find(this.props.columns, {defaultSort: true});
+    if (defaultSortColumn) {
+      return defaultSortColumn.id;
+    }
+    // otherwise choose first metric
     return _.get(this.props.nodes, [0, 'metrics', 0, 'id']);
   }
 
   getMetaDataSorters() {
     // returns an array of sorters that will take a node
     return _.get(this.props.nodes, [0, 'metadata'], []).map((field, index) => {
-      return node => node.metadata[index] ? node.metadata[index].value : null;
+      return node => {
+        const nodeMetadataField = node.metadata[index];
+        if (nodeMetadataField) {
+          if (isNumberField(nodeMetadataField)) {
+            return parseFloat(nodeMetadataField.value);
+          }
+          return nodeMetadataField.value;
+        }
+        return null;
+      };
     });
   }
 
@@ -49,6 +67,9 @@ export default class NodeDetailsTable extends React.Component {
     if (sortBy !== null) {
       const field = _.union(node.metrics, node.metadata).find(f => f.id === sortBy);
       if (field) {
+        if (isNumberField(field)) {
+          return parseFloat(field.value);
+        }
         return field.value;
       }
     }

integration/300_internet_edge_test.sh

@@ -22,11 +22,9 @@ do_connections() {
 }
 do_connections&
 
-wait_for_containers $HOST1 60 nginx "Inbound"
+wait_for_containers $HOST1 60 nginx "The Internet"
 
-has_container $HOST1 nginx
-has_container $HOST1 "Inbound"
-has_connection containers $HOST1 "Inbound" nginx
+has_connection_by_id containers $HOST1 "in-theinternet" $(node_id containers $HOST1 nginx)
 
 kill %do_connections
 

integration/config.sh

@@ -59,14 +59,13 @@ container_id() {
 }
 
 # this checks we have an edge from container 1 to container 2
-has_connection() {
+has_connection_by_id() {
 	local view="$1"
 	local host="$2"
-	local from="$3"
-	local to="$4"
+	local from_id="$3"
+	local to_id="$4"
 	local timeout="${5:-60}"
-	local from_id=$(node_id "${view}" "${host}" "${from}")
-	local to_id=$(node_id "${view}" "${host}" "${to}")
+
 	for i in $(seq $timeout); do
 		local nodes="$(curl -s http://$host:4040/api/topology/${view}?system=show)"
 		local edge=$(echo "$nodes" |  jq -r ".nodes[\"$from_id\"].adjacency | contains([\"$to_id\"])" 2>/dev/null)
@@ -82,6 +81,18 @@ has_connection() {
 	assert "curl -s http://$host:4040/api/topology/${view}?system=show |  jq -r '.nodes[\"$from_id\"].adjacency | contains([\"$to_id\"])'" true
 }
 
+has_connection() {
+	local view="$1"
+	local host="$2"
+	local from="$3"
+	local to="$4"
+	local timeout="${5:-60}"
+    local from_id="$(node_id "${view}" "${host}" "${from}")"
+    local to_id="$(node_id "${view}" "${host}" "${to}")"
+
+    has_connection_by_id "${view}" "${host}" "${from_id}" "${to_id}" "${timeout}"
+}
+
 wait_for() {
 	local view="$1"
 	local host="$2"

render/detailed/connections.go

@@ -0,0 +1,197 @@
+package detailed
+
+import (
+	"sort"
+	"strconv"
+
+	"github.com/weaveworks/scope/render"
+	"github.com/weaveworks/scope/report"
+)
+
+const (
+	portKey    = "port"
+	portLabel  = "Port"
+	countKey   = "count"
+	countLabel = "Count"
+	number     = "number"
+)
+
+// Exported for testing
+var (
+	NormalColumns = []Column{
+		{ID: portKey, Label: portLabel},
+		{ID: countKey, Label: countLabel, DefaultSort: true},
+	}
+	InternetColumns = []Column{
+		{ID: "foo", Label: "Remote"},
+		{ID: portKey, Label: portLabel},
+		{ID: countKey, Label: countLabel, DefaultSort: true},
+	}
+)
+
+type connectionsRow struct {
+	remoteNode, localNode *render.RenderableNode
+	remoteAddr, localAddr string
+	port                  string // always the server-side port
+}
+
+func incomingConnectionsTable(topologyID string, n render.RenderableNode, ns render.RenderableNodes) NodeSummaryGroup {
+	localEndpointIDs := endpointChildIDsOf(n)
+
+	// For each node which has an edge TO me
+	counts := map[connectionsRow]int{}
+	for _, node := range ns {
+		if !node.Adjacency.Contains(n.ID) {
+			continue
+		}
+		remoteNode := node.Copy()
+
+		// Work out what port they are talking to, and count the number of
+		// connections to that port.
+		// This is complicated as for internet nodes we break out individual
+		// address, both when the internet node is remote (an incoming
+		// connection from the internet) and 'local' (ie you are loading
+		// details on the internet node)
+		for _, child := range endpointChildrenOf(node) {
+			for _, localEndpointID := range child.Adjacency.Intersection(localEndpointIDs) {
+				_, localAddr, port, ok := render.ParseEndpointID(localEndpointID)
+				if !ok {
+					continue
+				}
+				key := connectionsRow{
+					localNode:  &n,
+					remoteNode: &remoteNode,
+					port:       port,
+				}
+				if isInternetNode(n) {
+					key.localAddr = localAddr
+				}
+				counts[key] = counts[key] + 1
+			}
+		}
+	}
+
+	columnHeaders := NormalColumns
+	if isInternetNode(n) {
+		columnHeaders = InternetColumns
+	}
+	return NodeSummaryGroup{
+		ID:         "incoming-connections",
+		TopologyID: topologyID,
+		Label:      "Inbound",
+		Columns:    columnHeaders,
+		Nodes:      connectionRows(counts, isInternetNode(n)),
+	}
+}
+
+func outgoingConnectionsTable(topologyID string, n render.RenderableNode, ns render.RenderableNodes) NodeSummaryGroup {
+	localEndpoints := endpointChildrenOf(n)
+
+	// For each node which has an edge FROM me
+	counts := map[connectionsRow]int{}
+	for _, node := range ns {
+		if !n.Adjacency.Contains(node.ID) {
+			continue
+		}
+		remoteNode := node.Copy()
+		remoteEndpointIDs := endpointChildIDsOf(remoteNode)
+
+		for _, localEndpoint := range localEndpoints {
+			_, localAddr, _, ok := render.ParseEndpointID(localEndpoint.ID)
+			if !ok {
+				continue
+			}
+
+			for _, remoteEndpointID := range localEndpoint.Adjacency.Intersection(remoteEndpointIDs) {
+				_, _, port, ok := render.ParseEndpointID(remoteEndpointID)
+				if !ok {
+					continue
+				}
+				key := connectionsRow{
+					localNode:  &n,
+					remoteNode: &remoteNode,
+					port:       port,
+				}
+				if isInternetNode(n) {
+					key.localAddr = localAddr
+				}
+				counts[key] = counts[key] + 1
+			}
+		}
+	}
+
+	columnHeaders := NormalColumns
+	if isInternetNode(n) {
+		columnHeaders = InternetColumns
+	}
+	return NodeSummaryGroup{
+		ID:         "outgoing-connections",
+		TopologyID: topologyID,
+		Label:      "Outbound",
+		Columns:    columnHeaders,
+		Nodes:      connectionRows(counts, isInternetNode(n)),
+	}
+}
+
+func endpointChildrenOf(n render.RenderableNode) []render.RenderableNode {
+	result := []render.RenderableNode{}
+	n.Children.ForEach(func(child render.RenderableNode) {
+		if _, _, _, ok := render.ParseEndpointID(child.ID); ok {
+			result = append(result, child)
+		}
+	})
+	return result
+}
+
+func endpointChildIDsOf(n render.RenderableNode) report.IDList {
+	result := report.MakeIDList()
+	n.Children.ForEach(func(child render.RenderableNode) {
+		if _, _, _, ok := render.ParseEndpointID(child.ID); ok {
+			result = append(result, child.ID)
+		}
+	})
+	return result
+}
+
+func isInternetNode(n render.RenderableNode) bool {
+	return n.ID == render.IncomingInternetID || n.ID == render.OutgoingInternetID
+}
+
+func connectionRows(in map[connectionsRow]int, includeLocal bool) []NodeSummary {
+	nodes := []NodeSummary{}
+	for row, count := range in {
+		id, label, linkable := row.remoteNode.ID, row.remoteNode.LabelMajor, true
+		if row.remoteAddr != "" {
+			id, label, linkable = row.remoteAddr+":"+row.port, row.remoteAddr, false
+		}
+		metadata := []MetadataRow{}
+		if includeLocal {
+			metadata = append(metadata,
+				MetadataRow{
+					ID:       "foo",
+					Value:    row.localAddr,
+					Datatype: number,
+				})
+		}
+		metadata = append(metadata,
+			MetadataRow{
+				ID:       portKey,
+				Value:    row.port,
+				Datatype: number,
+			},
+			MetadataRow{
+				ID:       countKey,
+				Value:    strconv.Itoa(count),
+				Datatype: number,
+			},
+		)
+		nodes = append(nodes, NodeSummary{
+			ID:       id,
+			Label:    label,
+			Linkable: linkable,
+			Metadata: metadata,
+		})
+	}
+	sort.Sort(nodeSummariesByID(nodes))
+	return nodes
+}