From cd71f82d4de65fed4f93139b7ccd319a71fcdf9d Mon Sep 17 00:00:00 2001 From: Paul Bellamy Date: Mon, 29 Jun 2015 14:25:02 +0100 Subject: [PATCH] aggregate connection details table List Local and Remote endpoints for each TCP connection on the node. --- render/detailed_node.go | 36 ++++++++++++++++++----------- render/detailed_node_test.go | 44 +++++++++++++++++++++++++++--------- report/id.go | 11 +++++++++ report/id_test.go | 36 +++++++++++++++++++++++++++++ test/report_fixture.go | 25 ++++++++++++-------- 5 files changed, 119 insertions(+), 33 deletions(-) diff --git a/render/detailed_node.go b/render/detailed_node.go index 59d8b6ac9..2fd77a187 100644 --- a/render/detailed_node.go +++ b/render/detailed_node.go @@ -79,6 +79,7 @@ func MakeDetailedNode(r report.Report, n RenderableNode) DetailedNode { // multiple origins. The ultimate goal here is to generate tables to view // in the UI, so we skip the intermediate representations, but we could // add them later. + connections := []Row{} outer: for _, id := range n.Origins { if table, ok := OriginTable(r, id); ok { @@ -89,8 +90,13 @@ outer: } } tables = append(tables, table) + } else if nmd, ok := r.Endpoint.NodeMetadatas[id]; ok { + connections = append(connections, connectionDetailsRows(r.Endpoint, id, nmd)...) } } + if len(connections) > 0 { + tables = append(tables, connectionDetailsTable(connections)) + } // Sort tables by rank sort.Sort(tables) @@ -107,9 +113,6 @@ outer: // OriginTable produces a table (to be consumed directly by the UI) based on // an origin ID, which is (optimistically) a node ID in one of our topologies. func OriginTable(r report.Report, originID string) (Table, bool) { - if nmd, ok := r.Endpoint.NodeMetadatas[originID]; ok { - return endpointOriginTable(nmd) - } if nmd, ok := r.Address.NodeMetadatas[originID]; ok { return addressOriginTable(nmd) } @@ -128,22 +131,29 @@ func OriginTable(r report.Report, originID string) (Table, bool) { return Table{}, false } -func endpointOriginTable(nmd report.NodeMetadata) (Table, bool) { +func connectionDetailsRows(endpointTopology report.Topology, originID string, nmd report.NodeMetadata) []Row { rows := []Row{} - for _, tuple := range []struct{ key, human string }{ - {"addr", "Endpoint"}, - {"port", "Port"}, - } { - if val, ok := nmd[tuple.key]; ok { - rows = append(rows, Row{Key: tuple.human, ValueMajor: val, ValueMinor: ""}) + local := fmt.Sprintf("%s:%s", nmd["addr"], nmd["port"]) + adjacencies := endpointTopology.Adjacency[report.MakeAdjacencyID(originID)] + sort.Strings(adjacencies) + for _, adj := range adjacencies { + if _, address, port, ok := report.ParseEndpointNodeID(adj); ok { + rows = append(rows, Row{ + Key: local, + ValueMajor: fmt.Sprintf("%s:%s", address, port), + }) } } + return rows +} + +func connectionDetailsTable(connectionRows []Row) Table { return Table{ - Title: "Origin Endpoint", + Title: "Connection Details", Numeric: false, - Rows: rows, + Rows: append([]Row{{Key: "Local", ValueMajor: "Remote"}}, connectionRows...), Rank: endpointRank, - }, len(rows) > 0 + } } func addressOriginTable(nmd report.NodeMetadata) (Table, bool) { diff --git a/render/detailed_node_test.go b/render/detailed_node_test.go index e2dc91183..bc754b4e1 100644 --- a/render/detailed_node_test.go +++ b/render/detailed_node_test.go @@ -1,6 +1,7 @@ package render_test import ( + "fmt" "reflect" "testing" @@ -13,14 +14,6 @@ func TestOriginTable(t *testing.T) { t.Errorf("unknown origin ID gave unexpected success") } for originID, want := range map[string]render.Table{ - test.Client54001NodeID: { - Title: "Origin Endpoint", - Numeric: false, - Rows: []render.Row{ - {"Endpoint", test.ClientIP, ""}, - {"Port", test.ClientPort54001, ""}, - }, - }, test.ClientAddressNodeID: { Title: "Origin Address", Numeric: false, @@ -107,11 +100,40 @@ func TestMakeDetailedNode(t *testing.T) { }, }, { - Title: "Origin Endpoint", + Title: "Connection Details", Numeric: false, Rows: []render.Row{ - {"Endpoint", test.ServerIP, ""}, - {"Port", test.ServerPort, ""}, + {"Local", "Remote", ""}, + { + fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort), + fmt.Sprintf("%s:%s", test.UnknownClient1IP, test.ClientPort54010), + "", + }, + { + fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort), + fmt.Sprintf("%s:%s", test.UnknownClient1IP, test.ClientPort54020), + "", + }, + { + fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort), + fmt.Sprintf("%s:%s", test.UnknownClient3IP, test.ClientPort54020), + "", + }, + { + fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort), + fmt.Sprintf("%s:%s", test.ClientIP, test.ClientPort54001), + "", + }, + { + fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort), + fmt.Sprintf("%s:%s", test.ClientIP, test.ClientPort54002), + "", + }, + { + fmt.Sprintf("%s:%s", test.ServerIP, test.ServerPort), + fmt.Sprintf("%s:%s", test.RandomClientIP, test.ClientPort12345), + "", + }, }, }, }, diff --git a/report/id.go b/report/id.go index f6205a21d..b975eb9bd 100644 --- a/report/id.go +++ b/report/id.go @@ -103,6 +103,17 @@ func ParseNodeID(nodeID string) (hostID string, remainder string, ok bool) { return fields[0], fields[1], true } +// ParseEndpointNodeID produces the host ID, address, and port and remainder +// (typically an address) from an endpoint node ID. Note that hostID may be +// blank. +func ParseEndpointNodeID(endpointNodeID string) (hostID, address, port string, ok bool) { + fields := strings.SplitN(endpointNodeID, ScopeDelim, 3) + if len(fields) != 3 { + return "", "", "", false + } + return fields[0], fields[1], fields[2], true +} + // ExtractHostID extracts the host id from NodeMetadata func ExtractHostID(m NodeMetadata) string { hostid, _, _ := ParseNodeID(m[HostNodeID]) diff --git a/report/id_test.go b/report/id_test.go index 8b1984afe..6ec9158b6 100644 --- a/report/id_test.go +++ b/report/id_test.go @@ -75,6 +75,42 @@ func TestAdjacencyID(t *testing.T) { } } +func TestEndpointNodeID(t *testing.T) { + for _, bad := range []string{ + clientAddressNodeID, + serverAddressNodeID, + unknownAddressNodeID, + clientHostNodeID, + serverHostNodeID, + "host.com;1.2.3.4", + "a;b", + "a;", + ";b", + ";", + "", + } { + if haveName, haveAddress, havePort, ok := report.ParseEndpointNodeID(bad); ok { + t.Errorf("%q: expected failure, but got {%q, %q, %q}", bad, haveName, haveAddress, havePort) + } + } + + for input, want := range map[string]struct{ name, address, port string }{ + report.MakeEndpointNodeID("host.com", "1.2.3.4", "c"): {"", "1.2.3.4", "c"}, + "a;b;c": {"a", "b", "c"}, + } { + haveName, haveAddress, havePort, ok := report.ParseEndpointNodeID(input) + if !ok { + t.Errorf("%q: not OK", input) + continue + } + if want.name != haveName || + want.address != haveAddress || + want.port != havePort { + t.Errorf("%q: want %q, have {%q, %q, %q}", input, want, haveName, haveAddress, havePort) + } + } +} + func TestEdgeID(t *testing.T) { for _, bad := range []string{ client54001EndpointNodeID, diff --git a/test/report_fixture.go b/test/report_fixture.go index 189cfbecd..1c84a3116 100644 --- a/test/report_fixture.go +++ b/test/report_fixture.go @@ -12,11 +12,18 @@ var ( ServerHostID = "server.hostname.com" UnknownHostID = "" - ClientIP = "10.10.10.20" - ServerIP = "192.168.1.1" - ClientPort54001 = "54001" - ClientPort54002 = "54002" - ServerPort = "80" + ClientIP = "10.10.10.20" + ServerIP = "192.168.1.1" + ClientPort54001 = "54001" + ClientPort54010 = "54010" + ClientPort54002 = "54002" + ClientPort54020 = "54020" + ClientPort12345 = "12345" + ServerPort = "80" + UnknownClient1IP = "10.10.10.10" + UnknownClient2IP = "10.10.10.10" + UnknownClient3IP = "10.10.10.11" + RandomClientIP = "51.52.53.54" ClientHostName = ClientHostID ServerHostName = ServerHostID @@ -32,10 +39,10 @@ var ( Client54001NodeID = report.MakeEndpointNodeID(ClientHostID, ClientIP, ClientPort54001) // curl (1) Client54002NodeID = report.MakeEndpointNodeID(ClientHostID, ClientIP, ClientPort54002) // curl (2) Server80NodeID = report.MakeEndpointNodeID(ServerHostID, ServerIP, ServerPort) // apache - UnknownClient1NodeID = report.MakeEndpointNodeID(ServerHostID, "10.10.10.10", "54010") // we want to ensure two unknown clients, connnected - UnknownClient2NodeID = report.MakeEndpointNodeID(ServerHostID, "10.10.10.10", "54020") // to the same server, are deduped. - UnknownClient3NodeID = report.MakeEndpointNodeID(ServerHostID, "10.10.10.11", "54020") // Check this one isn't deduped - RandomClientNodeID = report.MakeEndpointNodeID(ServerHostID, "51.52.53.54", "12345") // this should become an internet node + UnknownClient1NodeID = report.MakeEndpointNodeID(ServerHostID, UnknownClient1IP, "54010") // we want to ensure two unknown clients, connnected + UnknownClient2NodeID = report.MakeEndpointNodeID(ServerHostID, UnknownClient2IP, "54020") // to the same server, are deduped. + UnknownClient3NodeID = report.MakeEndpointNodeID(ServerHostID, UnknownClient3IP, "54020") // Check this one isn't deduped + RandomClientNodeID = report.MakeEndpointNodeID(ServerHostID, RandomClientIP, "12345") // this should become an internet node ClientProcess1NodeID = report.MakeProcessNodeID(ClientHostID, Client1PID) ClientProcess2NodeID = report.MakeProcessNodeID(ClientHostID, Client2PID)