github/weave-scope
1
0
Fork 0
mirror of https://github.com/weaveworks/scope.git synced 2026-03-03 18:20:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1127 from weaveworks/1098-remove-address-topology

Browse Source 
Remove address topology
This commit is contained in:
Tom Wilkie
2016-03-08 14:23:11 +00:00
parent cfc3d4f3bd e7c5fc7016
commit 77dce2b99e
17 changed files with 170 additions and 447 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
experimental/demoprobe/main.go
View File

@@ -11,7 +11,6 @@ import (
"github.com/weaveworks/scope/common/xfer"
"github.com/weaveworks/scope/probe/appclient"
"github.com/weaveworks/scope/probe/docker"
"github.com/weaveworks/scope/probe/process"
"github.com/weaveworks/scope/report"
)
@@ -79,14 +78,12 @@ func demoReport(nodeCount int) report.Report {
connectionCount := nodeCount * 2
for i := 0; i < connectionCount; i++ {
var (
c = procPool[rand.Intn(len(procPool))]
src = hosts[rand.Intn(len(hosts))]
dst = hosts[rand.Intn(len(hosts))]
srcPort = rand.Intn(50000) + 10000
srcPortID = report.MakeEndpointNodeID("", src, strconv.Itoa(srcPort))
dstPortID = report.MakeEndpointNodeID("", dst, strconv.Itoa(c.dstPort))
srcAddressID = report.MakeAddressNodeID("", src)
dstAddressID = report.MakeAddressNodeID("", dst)
c = procPool[rand.Intn(len(procPool))]
src = hosts[rand.Intn(len(hosts))]
dst = hosts[rand.Intn(len(hosts))]
srcPort = rand.Intn(50000) + 10000
srcPortID = report.MakeEndpointNodeID("", src, strconv.Itoa(srcPort))
dstPortID = report.MakeEndpointNodeID("", dst, strconv.Itoa(c.dstPort))
)
// Endpoint topology
@@ -101,14 +98,6 @@ func demoReport(nodeCount int) report.Report {
"domain": "node-" + dst,
}).WithEdge(srcPortID, report.EdgeMetadata{}))
// Address topology
r.Address = r.Address.AddNode(srcAddressID, report.MakeNode().WithLatests(map[string]string{
docker.Name: src,
}).WithAdjacent(dstAddressID))
r.Address = r.Address.AddNode(srcAddressID, report.MakeNode().WithLatests(map[string]string{
docker.Name: dst,
}).WithAdjacent(srcAddressID))
// Host data
r.Host = r.Host.AddNode("hostX", report.MakeNodeWith(map[string]string{
"ts": time.Now().UTC().Format(time.RFC3339Nano),

22
experimental/genreport/generate.go
View File

@@ -53,14 +53,12 @@ func DemoReport(nodeCount int) report.Report {
connectionCount := nodeCount * 8
for i := 0; i < connectionCount; i++ {
var (
c = procPool[rand.Intn(len(procPool))]
src = hosts[rand.Intn(len(hosts))]
dst = hosts[rand.Intn(len(hosts))]
srcPort = rand.Intn(50000) + 10000
srcPortID = report.MakeEndpointNodeID("", src, strconv.Itoa(srcPort))
dstPortID = report.MakeEndpointNodeID("", dst, strconv.Itoa(c.dstPort))
srcAddressID = report.MakeAddressNodeID("", src)
dstAddressID = report.MakeAddressNodeID("", dst)
c = procPool[rand.Intn(len(procPool))]
src = hosts[rand.Intn(len(hosts))]
dst = hosts[rand.Intn(len(hosts))]
srcPort = rand.Intn(50000) + 10000
srcPortID = report.MakeEndpointNodeID("", src, strconv.Itoa(srcPort))
dstPortID = report.MakeEndpointNodeID("", dst, strconv.Itoa(c.dstPort))
)
// Endpoint topology
@@ -75,14 +73,6 @@ func DemoReport(nodeCount int) report.Report {
"domain": "node-" + dst,
}).WithEdge(srcPortID, report.EdgeMetadata{}))
// Address topology
r.Address = r.Address.AddNode(srcAddressID, report.MakeNode().WithLatests(map[string]string{
"name": src,
}).WithAdjacent(dstAddressID))
r.Address = r.Address.AddNode(dstAddressID, report.MakeNode().WithLatests(map[string]string{
"name": dst,
}).WithAdjacent(srcAddressID))
// Host data
r.Host = r.Host.AddNode("hostX", report.MakeNodeWith(map[string]string{
"ts": time.Now().UTC().Format(time.RFC3339Nano),

33
experimental/sniff/sniffer.go
View File

@@ -297,39 +297,6 @@ func (s *Sniffer) Merge(p Packet, rpt *report.Report) {
return result
}
// For sure, we can add to the address topology.
{
var (
srcNodeID = report.MakeAddressNodeID(s.hostID, localIP)
dstNodeID = report.MakeAddressNodeID(s.hostID, remoteIP)
)
rpt.Address = addAdjacency(rpt.Address, srcNodeID, dstNodeID)
node := rpt.Address.Nodes[srcNodeID]
emd, _ := node.Edges.Lookup(dstNodeID)
if egress {
if emd.EgressPacketCount == nil {
emd.EgressPacketCount = new(uint64)
}
*emd.EgressPacketCount++
if emd.EgressByteCount == nil {
emd.EgressByteCount = new(uint64)
}
*emd.EgressByteCount += uint64(p.Network)
} else {
if emd.IngressPacketCount == nil {
emd.IngressPacketCount = new(uint64)
}
*emd.IngressPacketCount++
if emd.IngressByteCount == nil {
emd.IngressByteCount = new(uint64)
}
*emd.IngressByteCount += uint64(p.Network)
}
rpt.Address.Nodes[srcNodeID] = node.WithEdge(dstNodeID, emd)
}
// If we have ports, we can add to the endpoint topology, too.
if p.SrcPort != "" && p.DstPort != "" {
var (

1
probe/appclient/app_client_internal_test.go
View File

@@ -69,7 +69,6 @@ func TestAppClientPublish(t *testing.T) {
// tags, transforming empty slices into nils. So, we make DeepEqual
// happy by setting empty `json:"omitempty"` entries to nil
rpt.Endpoint.Controls = nil
rpt.Address.Controls = nil
rpt.Process.Controls = nil
rpt.Container.Controls = nil
rpt.ContainerImage.Controls = nil

84
probe/endpoint/reporter.go
View File

@@ -165,62 +165,38 @@ func (r *Reporter) Report() (report.Report, error) {
}
func (r *Reporter) addConnection(rpt *report.Report, t fourTuple, extraFromNode, extraToNode *report.Node) {
// Update address topology
{
var (
fromAddressNodeID = report.MakeAddressNodeID(r.hostID, t.fromAddr)
toAddressNodeID = report.MakeAddressNodeID(r.hostID, t.toAddr)
fromNode = report.MakeNodeWith(map[string]string{Addr: t.fromAddr}).WithEdge(toAddressNodeID, report.EdgeMetadata{})
toNode = report.MakeNodeWith(map[string]string{Addr: t.toAddr})
)
// In case we have a reverse resolution for the IP, we can use it for
// the name...
if toNames, err := r.reverseResolver.get(t.toAddr); err == nil {
toNode = toNode.WithSet("name", report.MakeStringSet(toNames...))
}
if extraFromNode != nil {
fromNode = fromNode.Merge(*extraFromNode)
}
if extraToNode != nil {
toNode = toNode.Merge(*extraToNode)
}
rpt.Address = rpt.Address.AddNode(fromAddressNodeID, fromNode)
rpt.Address = rpt.Address.AddNode(toAddressNodeID, toNode)
}
// Update endpoint topology
if r.includeProcesses {
var (
fromEndpointNodeID = report.MakeEndpointNodeID(r.hostID, t.fromAddr, strconv.Itoa(int(t.fromPort)))
toEndpointNodeID = report.MakeEndpointNodeID(r.hostID, t.toAddr, strconv.Itoa(int(t.toPort)))
fromNode = report.MakeNodeWith(map[string]string{
Addr: t.fromAddr,
Port: strconv.Itoa(int(t.fromPort)),
}).WithEdge(toEndpointNodeID, report.EdgeMetadata{})
toNode = report.MakeNodeWith(map[string]string{
Addr: t.toAddr,
Port: strconv.Itoa(int(t.toPort)),
})
)
// In case we have a reverse resolution for the IP, we can use it for
// the name...
if toNames, err := r.reverseResolver.get(t.toAddr); err == nil {
toNode = toNode.WithSet("name", report.MakeStringSet(toNames...))
}
if extraFromNode != nil {
fromNode = fromNode.Merge(*extraFromNode)
}
if extraToNode != nil {
toNode = toNode.Merge(*extraToNode)
}
rpt.Endpoint = rpt.Endpoint.AddNode(fromEndpointNodeID, fromNode)
rpt.Endpoint = rpt.Endpoint.AddNode(toEndpointNodeID, toNode)
if !r.includeProcesses {
return
}
var (
fromEndpointNodeID = report.MakeEndpointNodeID(r.hostID, t.fromAddr, strconv.Itoa(int(t.fromPort)))
toEndpointNodeID = report.MakeEndpointNodeID(r.hostID, t.toAddr, strconv.Itoa(int(t.toPort)))
fromNode = report.MakeNodeWith(map[string]string{
Addr: t.fromAddr,
Port: strconv.Itoa(int(t.fromPort)),
}).WithEdge(toEndpointNodeID, report.EdgeMetadata{})
toNode = report.MakeNodeWith(map[string]string{
Addr: t.toAddr,
Port: strconv.Itoa(int(t.toPort)),
})
)
// In case we have a reverse resolution for the IP, we can use it for
// the name...
if toNames, err := r.reverseResolver.get(t.toAddr); err == nil {
toNode = toNode.WithSet("name", report.MakeStringSet(toNames...))
}
if extraFromNode != nil {
fromNode = fromNode.Merge(*extraFromNode)
}
if extraToNode != nil {
toNode = toNode.Merge(*extraToNode)
}
rpt.Endpoint = rpt.Endpoint.AddNode(fromEndpointNodeID, fromNode)
rpt.Endpoint = rpt.Endpoint.AddNode(toEndpointNodeID, toNode)
}
func newu64(i uint64) *uint64 {

13
probe/endpoint/reporter_test.go
View File

@@ -78,19 +78,6 @@ func TestSpyNoProcesses(t *testing.T) {
if want, have := 0, len(r.Endpoint.Nodes); want != have {
t.Fatalf("want %d, have %d", want, have)
}
var (
scopedLocal = report.MakeAddressNodeID(nodeID, fixLocalAddress.String())
scopedRemote = report.MakeAddressNodeID(nodeID, fixRemoteAddress.String())
)
if want, have := 1, len(r.Address.Nodes[scopedRemote].Adjacency); want != have {
t.Fatalf("want %d, have %d", want, have)
}
if want, have := scopedLocal, r.Address.Nodes[scopedRemote].Adjacency[0]; want != have {
t.Fatalf("want %q, have %q", want, have)
}
}
func TestSpyWithProcesses(t *testing.T) {

5
probe/probe_internal_test.go
View File

@@ -15,9 +15,7 @@ import (
func TestApply(t *testing.T) {
var (
endpointNodeID = "c"
addressNodeID = "d"
endpointNode = report.MakeNodeWith(map[string]string{"5": "6"})
addressNode = report.MakeNodeWith(map[string]string{"7": "8"})
)
p := New(0, 0, nil)
@@ -25,7 +23,6 @@ func TestApply(t *testing.T) {
r := report.MakeReport()
r.Endpoint.AddNode(endpointNodeID, endpointNode)
r.Address.AddNode(addressNodeID, addressNode)
r = p.tag(r)
for _, tuple := range []struct {
@@ -34,7 +31,6 @@ func TestApply(t *testing.T) {
via string
}{
{endpointNode.Merge(report.MakeNode().WithID("c").WithTopology(report.Endpoint)), r.Endpoint, endpointNodeID},
{addressNode.Merge(report.MakeNode().WithID("d").WithTopology(report.Address)), r.Address, addressNodeID},
} {
if want, have := tuple.want, tuple.from.Nodes[tuple.via]; !reflect.DeepEqual(want, have) {
t.Errorf("want %+v, have %+v", want, have)
@@ -84,7 +80,6 @@ func TestProbe(t *testing.T) {
// omitempty
want.Endpoint.Controls = nil
want.Address.Controls = nil
want.Process.Controls = nil
want.Container.Controls = nil
want.ContainerImage.Controls = nil

1
probe/topology_tagger.go
View File

@@ -18,7 +18,6 @@ func (topologyTagger) Name() string { return "Topology" }
func (topologyTagger) Tag(r report.Report) (report.Report, error) {
for name, t := range map[string]*report.Topology{
report.Endpoint: &(r.Endpoint),
report.Address: &(r.Address),
report.Process: &(r.Process),
report.Container: &(r.Container),
report.ContainerImage: &(r.ContainerImage),

189
render/expected/expected.go
View File

@@ -415,143 +415,6 @@ var (
render.OutgoingInternetID: theOutgoingInternetNode,
}).Prune()
ClientAddressID = render.MakeAddressID(fixture.ClientHostID, fixture.ClientIP)
ServerAddressID = render.MakeAddressID(fixture.ServerHostID, fixture.ServerIP)
unknownPseudoAddress1ID = render.MakePseudoNodeID("10.10.10.10", fixture.ServerIP)
unknownPseudoAddress2ID = render.MakePseudoNodeID("10.10.10.11", fixture.ServerIP)
RenderedAddresses = (render.RenderableNodes{
ClientAddressID: {
ID: ClientAddressID,
LabelMajor: fixture.ClientIP,
LabelMinor: fixture.ClientHostID,
Shape: circle,
Node: report.MakeNode().WithAdjacent(ServerAddressID),
},
ServerAddressID: {
ID: ServerAddressID,
LabelMajor: fixture.ServerIP,
LabelMinor: fixture.ServerHostID,
Shape: circle,
Node: report.MakeNode(),
},
unknownPseudoAddress1ID: {
ID: unknownPseudoAddress1ID,
LabelMajor: "10.10.10.10",
Pseudo: true,
Shape: circle,
Node: report.MakeNode().WithAdjacent(ServerAddressID),
},
unknownPseudoAddress2ID: {
ID: unknownPseudoAddress2ID,
LabelMajor: "10.10.10.11",
Pseudo: true,
Shape: circle,
Node: report.MakeNode().WithAdjacent(ServerAddressID),
},
render.IncomingInternetID: {
ID: render.IncomingInternetID,
LabelMajor: render.InboundMajor,
LabelMinor: render.InboundMinor,
Pseudo: true,
Shape: cloud,
Node: report.MakeNode().WithAdjacent(ServerAddressID),
EdgeMetadata: report.EdgeMetadata{},
},
}).Prune()
ServerHostID = render.MakeHostID(fixture.ServerHostID)
ClientHostID = render.MakeHostID(fixture.ClientHostID)
pseudoHostID1 = render.MakePseudoNodeID(fixture.UnknownClient1IP, fixture.ServerIP)
pseudoHostID2 = render.MakePseudoNodeID(fixture.UnknownClient3IP, fixture.ServerIP)
RenderedHosts = (render.RenderableNodes{
ClientHostID: {
ID: ClientHostID,
LabelMajor: "client", // before first .
LabelMinor: "hostname.com", // after first .
Rank: "hostname.com",
Shape: circle,
Children: render.MakeRenderableNodeSet(
RenderedEndpoints[Client54001EndpointID],
RenderedEndpoints[Client54002EndpointID],
RenderedProcesses[ClientProcess1ID],
RenderedProcesses[ClientProcess2ID],
RenderedContainers[ClientContainerID],
RenderedContainerImages[ClientContainerImageID],
RenderedAddresses[ClientAddressID],
),
Node: report.MakeNode().WithAdjacent(ServerHostID),
EdgeMetadata: report.EdgeMetadata{
EgressPacketCount: newu64(30),
EgressByteCount: newu64(300),
},
},
ServerHostID: {
ID: ServerHostID,
LabelMajor: "server", // before first .
LabelMinor: "hostname.com", // after first .
Rank: "hostname.com",
Shape: circle,
Children: render.MakeRenderableNodeSet(
RenderedEndpoints[ServerEndpointID],
RenderedProcesses[ServerProcessID],
RenderedContainers[ServerContainerID],
RenderedContainerImages[ServerContainerImageID],
RenderedAddresses[ServerAddressID],
// See #1102
// RemappedEndpoints[NonContainerEndpointID],
// RenderedEndpoints[NonContainerPseudoEndpointID],
// RenderedProcesses[nonContainerProcessID],
),
Node: report.MakeNode(),
EdgeMetadata: report.EdgeMetadata{
IngressPacketCount: newu64(210),
IngressByteCount: newu64(2100),
},
},
pseudoHostID1: {
ID: pseudoHostID1,
LabelMajor: fixture.UnknownClient1IP,
Pseudo: true,
Shape: circle,
Node: report.MakeNode().WithAdjacent(ServerHostID),
EdgeMetadata: report.EdgeMetadata{},
Children: render.MakeRenderableNodeSet(
// RenderedEndpoints[unknownPseudoNode2ID],
// RenderedAddresses[unknownPseudoAddress1ID],
),
},
pseudoHostID2: {
ID: pseudoHostID2,
LabelMajor: fixture.UnknownClient3IP,
Pseudo: true,
Shape: circle,
Node: report.MakeNode().WithAdjacent(ServerHostID),
EdgeMetadata: report.EdgeMetadata{},
Children: render.MakeRenderableNodeSet(
// RenderedEndpoints[unknownPseudoNode2ID],
// RenderedAddresses[unknownPseudoAddress2ID],
),
},
render.IncomingInternetID: {
ID: render.IncomingInternetID,
LabelMajor: render.InboundMajor,
LabelMinor: render.InboundMinor,
Pseudo: true,
Shape: cloud,
Node: report.MakeNode().WithAdjacent(ServerHostID),
EdgeMetadata: report.EdgeMetadata{},
Children: render.MakeRenderableNodeSet(
// RenderedEndpoints[render.TheInternetID],
),
},
}).Prune()
ClientPodRenderedID = render.MakePodID("ping/pong-a")
ServerPodRenderedID = render.MakePodID("ping/pong-b")
@@ -612,6 +475,58 @@ var (
render.OutgoingInternetID: theOutgoingInternetNode,
}).Prune()
ServerHostID = render.MakeHostID(fixture.ServerHostID)
ClientHostID = render.MakeHostID(fixture.ClientHostID)
RenderedHosts = (render.RenderableNodes{
ClientHostID: {
ID: ClientHostID,
LabelMajor: "client", // before first .
LabelMinor: "hostname.com", // after first .
Rank: "hostname.com",
Shape: circle,
Children: render.MakeRenderableNodeSet(
RenderedEndpoints[Client54001EndpointID],
RenderedEndpoints[Client54002EndpointID],
RenderedProcesses[ClientProcess1ID],
RenderedProcesses[ClientProcess2ID],
RenderedContainers[ClientContainerID],
RenderedContainerImages[ClientContainerImageID],
//RenderedPods[ClientPodRenderedID], #1142
),
Node: report.MakeNode().WithAdjacent(ServerHostID),
EdgeMetadata: report.EdgeMetadata{
EgressPacketCount: newu64(30),
EgressByteCount: newu64(300),
},
},
ServerHostID: {
ID: ServerHostID,
LabelMajor: "server", // before first .
LabelMinor: "hostname.com", // after first .
Rank: "hostname.com",
Shape: circle,
Children: render.MakeRenderableNodeSet(
RenderedEndpoints[ServerEndpointID],
RenderedEndpoints[NonContainerEndpointID],
RenderedProcesses[ServerProcessID],
RenderedProcesses[nonContainerProcessID],
RenderedContainers[ServerContainerID],
RenderedContainerImages[ServerContainerImageID],
//RenderedPods[ServerPodRenderedID], #1142
),
Node: report.MakeNode().WithAdjacent(render.OutgoingInternetID),
EdgeMetadata: report.EdgeMetadata{
IngressPacketCount: newu64(210),
IngressByteCount: newu64(2100),
},
},
unknownPseudoNode1ID: unknownPseudoNode1(ServerHostID),
unknownPseudoNode2ID: unknownPseudoNode2(ServerHostID),
render.IncomingInternetID: theIncomingInternetNode(ServerHostID),
render.OutgoingInternetID: theOutgoingInternetNode,
}).Prune()
ServiceRenderedID = render.MakeServiceID("ping/pongservice")
RenderedPodServices = (render.RenderableNodes{

5
render/id.go
View File

@@ -29,11 +29,6 @@ func MakeProcessID(hostID, pid string) string {
return makeID("process", hostID, pid)
}
// MakeAddressID makes an address node ID for rendered nodes.
func MakeAddressID(hostID, addr string) string {
return makeID("address", hostID, addr)
}
// MakeContainerID makes a container node ID for rendered nodes.
func MakeContainerID(containerID string) string {
return makeID("container", containerID)

141
render/mapping.go
View File

@@ -213,50 +213,6 @@ func MapServiceIdentity(m RenderableNode, _ report.Networks) RenderableNodes {
return RenderableNodes{id: node}
}
// MapAddressIdentity maps an address topology node to an address renderable
// node. As it is only ever run on address topology nodes, we expect that
// certain keys are present.
func MapAddressIdentity(m RenderableNode, local report.Networks) RenderableNodes {
addr, ok := m.Latest.Lookup(endpoint.Addr)
if !ok {
return RenderableNodes{}
}
// Conntracked connections don't have a host id unless
// they were merged with a procspied connection. Filter
// out those that weren't.
_, hasHostID := m.Latest.Lookup(report.HostNodeID)
_, conntracked := m.Latest.Lookup(endpoint.Conntracked)
if !hasHostID && conntracked {
return RenderableNodes{}
}
// Nodes without a hostid are treated as psuedo nodes
if !hasHostID {
// If the addr is not in a network local to this report, we emit an
// internet node
if ip := net.ParseIP(addr); ip != nil && !local.Contains(ip) {
return RenderableNodes{TheInternetID: theInternetNode(m)}
}
// Otherwise generate a pseudo node for every
outputID := MakePseudoNodeID(addr, "")
if len(m.Adjacency) > 0 {
_, dstAddr, _ := report.ParseAddressNodeID(m.Adjacency[0])
outputID = MakePseudoNodeID(addr, dstAddr)
}
return RenderableNodes{outputID: newDerivedPseudoNode(outputID, addr, m)}
}
var (
id = MakeAddressID(report.ExtractHostID(m.Node), addr)
major = addr
minor = report.ExtractHostID(m.Node)
)
return RenderableNodes{id: NewRenderableNodeWith(id, major, minor, "", m)}
}
// MapHostIdentity maps a host topology node to a host renderable node. As it
// is only ever run on host topology nodes, we expect that certain keys are
// present.
@@ -376,6 +332,46 @@ func MapIP2Container(n RenderableNode, _ report.Networks) RenderableNodes {
return RenderableNodes{id: node}
}
// MapEndpoint2Pseudo makes internet of host pesudo nodes from a endpoint node.
func MapEndpoint2Pseudo(n RenderableNode, local report.Networks) RenderableNodes {
var node RenderableNode
addr, ok := n.Latest.Lookup(endpoint.Addr)
if !ok {
return RenderableNodes{}
}
port, ok := n.Latest.Lookup(endpoint.Port)
if !ok {
return RenderableNodes{}
}
if ip := net.ParseIP(addr); ip != nil && !local.Contains(ip) {
// If the dstNodeAddr is not in a network local to this report, we emit an
// internet node
node = theInternetNode(n)
} else if p, err := strconv.Atoi(port); err == nil && len(n.Adjacency) > 0 && p >= 32768 && p < 65535 {
// We are a 'client' pseudo node if the port is in the ephemeral port range.
// Linux uses 32768 to 61000, IANA suggests 49152 to 65535.
// We only exist if there is something in our adjacency
// Generate a single pseudo node for every (client ip, server ip, server port)
_, serverIP, serverPort, _ := ParseEndpointID(n.Adjacency[0])
node = newDerivedPseudoNode(MakePseudoNodeID(addr, serverIP, serverPort), addr, n)
} else if port != "" {
// Otherwise (the server node is missing), generate a pseudo node for every (server ip, server port)
node = newDerivedPseudoNode(MakePseudoNodeID(addr, port), addr+":"+port, n)
} else {
// Empty port for some reason...
node = newDerivedPseudoNode(MakePseudoNodeID(addr, port), addr, n)
}
node.Children = node.Children.Add(n)
return RenderableNodes{node.ID: node}
}
// MapEndpoint2Process maps endpoint RenderableNodes to process
// RenderableNodes.
//
@@ -390,42 +386,7 @@ func MapIP2Container(n RenderableNode, _ report.Networks) RenderableNodes {
func MapEndpoint2Process(n RenderableNode, local report.Networks) RenderableNodes {
// Nodes without a hostid are treated as psuedo nodes
if _, ok := n.Latest.Lookup(report.HostNodeID); !ok {
var node RenderableNode
addr, ok := n.Latest.Lookup(endpoint.Addr)
if !ok {
return RenderableNodes{}
}
port, ok := n.Latest.Lookup(endpoint.Port)
if !ok {
return RenderableNodes{}
}
if ip := net.ParseIP(addr); ip != nil && !local.Contains(ip) {
// If the dstNodeAddr is not in a network local to this report, we emit an
// internet node
node = theInternetNode(n)
} else if p, err := strconv.Atoi(port); err == nil && len(n.Adjacency) > 0 && p >= 32768 && p < 65535 {
// We are a 'client' pseudo node if the port is in the ephemeral port range.
// Linux uses 32768 to 61000, IANA suggests 49152 to 65535.
// We only exist if there is something in our adjacency
// Generate a single pseudo node for every (client ip, server ip, server port)
_, serverIP, serverPort, _ := ParseEndpointID(n.Adjacency[0])
node = newDerivedPseudoNode(MakePseudoNodeID(addr, serverIP, serverPort), addr, n)
} else if port != "" {
// Otherwise (the server node is missing), generate a pseudo node for every (server ip, server port)
node = newDerivedPseudoNode(MakePseudoNodeID(addr, port), addr+":"+port, n)
} else {
// Empty port for some reason...
node = newDerivedPseudoNode(MakePseudoNodeID(addr, port), addr, n)
}
node.Children = node.Children.Add(n)
return RenderableNodes{node.ID: node}
return MapEndpoint2Pseudo(n, local)
}
pid, ok := n.Node.Latest.Lookup(process.PID)
@@ -625,13 +586,29 @@ func MapContainerImage2Name(n RenderableNode, _ report.Networks) RenderableNodes
// It does not have enough info to do that, and the resulting graph
// must be merged with a container graph to get that info.
func MapX2Host(n RenderableNode, _ report.Networks) RenderableNodes {
// Propogate all pseudo nodes
// Don't propogate all pseudo nodes - we do this in MapEndpoint2Host
if n.Pseudo {
return RenderableNodes{n.ID: n}
return RenderableNodes{}
}
if _, ok := n.Node.Latest.Lookup(report.HostNodeID); !ok {
return RenderableNodes{}
}
id := MakeHostID(report.ExtractHostID(n.Node))
result := NewDerivedNode(id, n.WithParents(report.EmptySets))
result.Children = result.Children.Add(n)
result.Shape = Circle
result.EdgeMetadata = report.EdgeMetadata{} // Don't double count edge metadata
return RenderableNodes{id: result}
}
// MapEndpoint2Host takes nodes from the endpoint topology and produces
// host nodes or pseudo nodes.
func MapEndpoint2Host(n RenderableNode, local report.Networks) RenderableNodes {
// Nodes without a hostid are treated as psuedo nodes
if _, ok := n.Latest.Lookup(report.HostNodeID); !ok {
return MapEndpoint2Pseudo(n, local)
}
id := MakeHostID(report.ExtractHostID(n.Node))
result := NewDerivedNode(id, n.WithParents(report.EmptySets))
result.Children = result.Children.Add(n)

9
render/mapping_test.go
View File

@@ -67,15 +67,6 @@ func TestMapContainerImageIdentity(t *testing.T) {
}
}
func TestMapAddressIdentity(t *testing.T) {
for _, input := range []testcase{
{"empty", nrn(report.MakeNode()), false},
{"basic address", nrn(report.MakeNodeWith(map[string]string{endpoint.Addr: "192.168.1.1"})), true},
} {
testMap(t, render.MapAddressIdentity, input)
}
}
func TestMapHostIdentity(t *testing.T) {
for _, input := range []testcase{
{"empty", nrn(report.MakeNode()), true}, // TODO it's questionable if this is actually correct

5
render/selectors.go
View File

@@ -60,11 +60,6 @@ var (
return MakeRenderableNodes(r.ContainerImage)
})
// SelectAddress selects the address topology.
SelectAddress = TopologySelector(func(r report.Report) RenderableNodes {
return MakeRenderableNodes(r.Address)
})
// SelectHost selects the address topology.
SelectHost = TopologySelector(func(r report.Report) RenderableNodes {
return MakeRenderableNodes(r.Host)

32
render/topologies.go
View File

@@ -231,31 +231,33 @@ var ContainerHostnameRenderer = MakeMap(
),
)
// AddressRenderer is a Renderer which produces a renderable address
// graph from the address topology.
var AddressRenderer = MakeMap(
MapAddressIdentity,
SelectAddress,
)
// HostRenderer is a Renderer which produces a renderable host
// graph from the host topology and address graph.
// graph from the host topology.
var HostRenderer = MakeReduce(
MakeMap(
MapX2Host,
FilterPseudo(ContainerImageRenderer),
MapEndpoint2Host,
EndpointRenderer,
),
MakeMap(
MapX2Host,
MakeMap(
MapPodIdentity,
SelectPod,
),
ColorConnected(ProcessRenderer),
),
MakeMap(
MapX2Host,
AddressRenderer,
ContainerRenderer,
),
MakeMap(
MapX2Host,
ContainerImageRenderer,
),
// Pods don't have a host id - #1142
// MakeMap(
// MapX2Host,
// MakeMap(
// MapPodIdentity,
// SelectPod,
// ),
// ),
MakeMap(
MapHostIdentity,
SelectHost,

8
render/topologies_test.go
View File

@@ -87,14 +87,6 @@ func TestContainerImageRenderer(t *testing.T) {
}
}
func TestAddressRenderer(t *testing.T) {
have := render.AddressRenderer.Render(fixture.Report).Prune()
want := expected.RenderedAddresses
if !reflect.DeepEqual(want, have) {
t.Error(test.Diff(want, have))
}
}
func TestHostRenderer(t *testing.T) {
have := render.HostRenderer.Render(fixture.Report).Prune()
want := expected.RenderedHosts

10
report/report.go
View File

@@ -10,7 +10,6 @@ import (
// Names of the various topologies.
const (
Endpoint = "endpoint"
Address = "address"
Process = "process"
Container = "container"
Pod = "pod"
@@ -29,11 +28,6 @@ type Report struct {
// be traced back to a process. Edges are present.
Endpoint Topology
// Address nodes are addresses (e.g. ifconfig) on each host. Certain
// information may be present in this topology that can't be mapped to
// endpoints (e.g. ICMP). Edges are present.
Address Topology
// Process nodes are processes on each host. Edges are not present.
Process Topology
@@ -93,7 +87,6 @@ type Report struct {
func MakeReport() Report {
return Report{
Endpoint: MakeTopology(),
Address: MakeTopology(),
Process: MakeTopology(),
Container: MakeTopology(),
ContainerImage: MakeTopology(),
@@ -111,7 +104,6 @@ func MakeReport() Report {
func (r Report) Copy() Report {
return Report{
Endpoint: r.Endpoint.Copy(),
Address: r.Address.Copy(),
Process: r.Process.Copy(),
Container: r.Container.Copy(),
ContainerImage: r.ContainerImage.Copy(),
@@ -130,7 +122,6 @@ func (r Report) Copy() Report {
func (r Report) Merge(other Report) Report {
cp := r.Copy()
cp.Endpoint = r.Endpoint.Merge(other.Endpoint)
cp.Address = r.Address.Merge(other.Address)
cp.Process = r.Process.Merge(other.Process)
cp.Container = r.Container.Merge(other.Container)
cp.ContainerImage = r.ContainerImage.Merge(other.ContainerImage)
@@ -147,7 +138,6 @@ func (r Report) Merge(other Report) Report {
func (r Report) Topologies() []Topology {
return []Topology{
r.Endpoint,
r.Address,
r.Process,
r.Container,
r.ContainerImage,

36
test/fixture/report_fixture.go
View File

@@ -85,13 +85,6 @@ var (
ClientContainerImageName = "image/client"
ServerContainerImageName = "image/server"
ClientAddressNodeID = report.MakeAddressNodeID(ClientHostID, ClientIP)
ServerAddressNodeID = report.MakeAddressNodeID(ServerHostID, ServerIP)
UnknownAddress1NodeID = report.MakeAddressNodeID(ServerHostID, UnknownClient1IP)
UnknownAddress2NodeID = report.MakeAddressNodeID(ServerHostID, UnknownClient2IP)
UnknownAddress3NodeID = report.MakeAddressNodeID(ServerHostID, UnknownClient3IP)
RandomAddressNodeID = report.MakeAddressNodeID(ServerHostID, RandomClientIP) // this should become an internet node
KubernetesNamespace = "ping"
ClientPodID = "ping/pong-a"
ServerPodID = "ping/pong-b"
@@ -315,35 +308,6 @@ var (
).WithID(ServerContainerImageNodeID).WithTopology(report.ContainerImage),
},
},
Address: report.Topology{
Nodes: report.Nodes{
ClientAddressNodeID: report.MakeNode().WithLatests(map[string]string{
endpoint.Addr: ClientIP,
report.HostNodeID: ClientHostNodeID,
}).WithEdge(ServerAddressNodeID, report.EdgeMetadata{}),
ServerAddressNodeID: report.MakeNode().WithLatests(map[string]string{
endpoint.Addr: ServerIP,
report.HostNodeID: ServerHostNodeID,
}),
UnknownAddress1NodeID: report.MakeNode().WithLatests(map[string]string{
endpoint.Addr: UnknownClient1IP,
}).WithAdjacent(ServerAddressNodeID),
UnknownAddress2NodeID: report.MakeNode().WithLatests(map[string]string{
endpoint.Addr: UnknownClient2IP,
}).WithAdjacent(ServerAddressNodeID),
UnknownAddress3NodeID: report.MakeNode().WithLatests(map[string]string{
endpoint.Addr: UnknownClient3IP,
}).WithAdjacent(ServerAddressNodeID),
RandomAddressNodeID: report.MakeNode().WithLatests(map[string]string{
endpoint.Addr: RandomClientIP,
}).WithAdjacent(ServerAddressNodeID),
},
},
Host: report.Topology{
Nodes: report.Nodes{
ClientHostNodeID: report.MakeNodeWith(map[string]string{