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

Merge pull request #2997 from weaveworks/no-image-host-propagation

Browse Source 
don't map image adjacencies to hosts
This commit is contained in:
Matthias Radestock
2017-12-21 10:08:37 +00:00
committed by GitHub
parent dd2dfd54f5 724ea0c230
commit 7459014c63
2 changed files with 42 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
render/host.go
View File

@@ -16,6 +16,10 @@ var HostRenderer = MakeReduce(
endpoints2Hosts{},
)
func newHostNode(id string) report.Node {
return report.MakeNode(id).WithTopology(report.Host)
}
// nodes2Hosts maps any Nodes to host Nodes.
//
// If this function is given a node without a hostname
@@ -32,11 +36,19 @@ func nodes2Hosts(nodes Nodes) Nodes {
if n.Topology == Pseudo {
continue // Don't propagate pseudo nodes - we do this in endpoints2Hosts
}
isImage := n.Topology == report.ContainerImage
hostIDs, _ := n.Parents.Lookup(report.Host)
for _, id := range hostIDs {
ret.addChild(n, id, func(id string) report.Node {
return report.MakeNode(id).WithTopology(report.Host)
})
if isImage {
// We need to treat image nodes specially because they
// aggregate adjacencies of containers across multiple
// hosts, and hence mapping these adjacencies to host
// adjacencies would produce edges that aren't present
// in reality.
ret.addUnmappedChild(n, id, newHostNode)
} else {
ret.addChild(n, id, newHostNode)
}
}
}
return ret.result(nodes)
@@ -64,7 +76,7 @@ func (e endpoints2Hosts) Render(rpt report.Report) Nodes {
ret.addChild(n, id, func(id string) report.Node {
// we have a hostNodeID, but no matching host node;
// create a new one rather than dropping the data
return report.MakeNode(id).WithTopology(report.Host).
return newHostNode(id).
WithLatest(report.HostNodeID, timestamp, hostNodeID)
})
}

50
render/render.go
View File

@@ -176,47 +176,49 @@ func newJoinResults(inputNodes report.Nodes) joinResults {
return joinResults{nodes: nodes, mapped: map[string]string{}, multi: map[string][]string{}}
}
func (ret *joinResults) add(m report.Node, n report.Node) {
ret.nodes[n.ID] = n
if _, ok := ret.mapped[m.ID]; !ok {
ret.mapped[m.ID] = n.ID
func (ret *joinResults) mapChild(from, to string) {
if _, ok := ret.mapped[from]; !ok {
ret.mapped[from] = to
} else {
ret.multi[m.ID] = append(ret.multi[m.ID], n.ID)
ret.multi[from] = append(ret.multi[from], to)
}
}
// Add m as a child of the node at id, creating a new result node if
// not already there.
func (ret *joinResults) addUnmappedChild(m report.Node, id string, create func(string) report.Node) {
result, exists := ret.nodes[id]
if !exists {
result = create(id)
}
result.Children = result.Children.Add(m)
if m.Topology != report.Endpoint { // optimisation: we never look at endpoint counts
result.Counters = result.Counters.Add(m.Topology, 1)
}
ret.nodes[id] = result
}
// Add m as a child of the node at id, creating a new result node if
// not already there, and updating the mapping from old ID to new ID.
func (ret *joinResults) addChild(m report.Node, id string, create func(string) report.Node) {
result, exists := ret.nodes[id]
if !exists {
result = create(id)
}
result.Children = result.Children.Add(m)
if m.Topology != report.Endpoint { // optimisation: we never look at endpoint counts
result.Counters = result.Counters.Add(m.Topology, 1)
}
ret.add(m, result)
ret.addUnmappedChild(m, id, create)
ret.mapChild(m.ID, id)
}
// Like addChild, but also add m's children.
func (ret *joinResults) addChildAndChildren(m report.Node, id string, create func(string) report.Node) {
result, exists := ret.nodes[id]
if !exists {
result = create(id)
}
result.Children = result.Children.Add(m)
ret.addUnmappedChild(m, id, create)
result := ret.nodes[id]
result.Children = result.Children.Merge(m.Children)
if m.Topology != report.Endpoint { // optimisation: we never look at endpoint counts
result.Counters = result.Counters.Add(m.Topology, 1)
}
ret.add(m, result)
ret.nodes[id] = result
ret.mapChild(m.ID, id)
}
// Add a copy of n straight into the results
func (ret *joinResults) passThrough(n report.Node) {
n.Adjacency = nil // result() assumes all nodes start with no adjacencies
ret.add(n, n)
ret.nodes[n.ID] = n
ret.mapChild(n.ID, n.ID)
}
// Rewrite Adjacency of nodes in ret mapped from original nodes in