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

Review feedback

Browse Source
This commit is contained in:
Tom Wilkie
2015-08-17 15:51:00 +00:00
parent 7fb1a98eca
commit 6f1f453098
5 changed files with 59 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
probe/endpoint/reporter.go
View File

@@ -80,18 +80,18 @@ func (r *Reporter) addConnection(rpt *report.Report, c *procspy.Connection) {
localIsClient = int(c.LocalPort) > int(c.RemotePort)
localAddressNodeID = report.MakeAddressNodeID(r.hostID, c.LocalAddress.String())
remoteAddressNodeID = report.MakeAddressNodeID(r.hostID, c.RemoteAddress.String())
adjecencyID = ""
adjacencyID = ""
edgeID = ""
)
if localIsClient {
adjecencyID = report.MakeAdjacencyID(localAddressNodeID)
rpt.Address.Adjacency[adjecencyID] = rpt.Address.Adjacency[adjecencyID].Add(remoteAddressNodeID)
adjacencyID = report.MakeAdjacencyID(localAddressNodeID)
rpt.Address.Adjacency[adjacencyID] = rpt.Address.Adjacency[adjacencyID].Add(remoteAddressNodeID)
edgeID = report.MakeEdgeID(localAddressNodeID, remoteAddressNodeID)
} else {
adjecencyID = report.MakeAdjacencyID(remoteAddressNodeID)
rpt.Address.Adjacency[adjecencyID] = rpt.Address.Adjacency[adjecencyID].Add(localAddressNodeID)
adjacencyID = report.MakeAdjacencyID(remoteAddressNodeID)
rpt.Address.Adjacency[adjacencyID] = rpt.Address.Adjacency[adjacencyID].Add(localAddressNodeID)
edgeID = report.MakeEdgeID(remoteAddressNodeID, localAddressNodeID)
}
@@ -109,18 +109,18 @@ func (r *Reporter) addConnection(rpt *report.Report, c *procspy.Connection) {
var (
localEndpointNodeID = report.MakeEndpointNodeID(r.hostID, c.LocalAddress.String(), strconv.Itoa(int(c.LocalPort)))
remoteEndpointNodeID = report.MakeEndpointNodeID(r.hostID, c.RemoteAddress.String(), strconv.Itoa(int(c.RemotePort)))
adjecencyID = ""
adjacencyID = ""
edgeID = ""
)
if localIsClient {
adjecencyID = report.MakeAdjacencyID(localEndpointNodeID)
rpt.Endpoint.Adjacency[adjecencyID] = rpt.Endpoint.Adjacency[adjecencyID].Add(remoteEndpointNodeID)
adjacencyID = report.MakeAdjacencyID(localEndpointNodeID)
rpt.Endpoint.Adjacency[adjacencyID] = rpt.Endpoint.Adjacency[adjacencyID].Add(remoteEndpointNodeID)
edgeID = report.MakeEdgeID(localEndpointNodeID, remoteEndpointNodeID)
} else {
adjecencyID = report.MakeAdjacencyID(remoteEndpointNodeID)
rpt.Endpoint.Adjacency[adjecencyID] = rpt.Endpoint.Adjacency[adjecencyID].Add(localEndpointNodeID)
adjacencyID = report.MakeAdjacencyID(remoteEndpointNodeID)
rpt.Endpoint.Adjacency[adjacencyID] = rpt.Endpoint.Adjacency[adjacencyID].Add(localEndpointNodeID)
edgeID = report.MakeEdgeID(remoteEndpointNodeID, localEndpointNodeID)
}

43
render/detailed_node.go
View File

@@ -184,25 +184,38 @@ func connectionDetailsRows(topology report.Topology, originID string) []Row {
if !ok {
return rows
}
for _, serverNodeID := range topology.Adjacency[report.MakeAdjacencyID(originID)] {
if remote, ok := labeler(serverNodeID); ok {
rows = append(rows, Row{
Key: local,
ValueMajor: remote,
})
// Firstly, collection outgoing connections from this node.
originAdjID := report.MakeAdjacencyID(originID)
for _, serverNodeID := range topology.Adjacency[originAdjID] {
remote, ok := labeler(serverNodeID)
if !ok {
continue
}
rows = append(rows, Row{
Key: local,
ValueMajor: remote,
})
}
// Next, scan the topology for incoming connections to this node.
for clientAdjID, serverNodeIDs := range topology.Adjacency {
if serverNodeIDs.Contains(originID) {
if clientNodeID, ok := report.ParseAdjacencyID(clientAdjID); ok {
if remote, ok := labeler(clientNodeID); ok {
rows = append(rows, Row{
Key: remote,
ValueMajor: local,
})
}
}
if clientAdjID == originAdjID {
continue
}
if !serverNodeIDs.Contains(originID) {
continue
}
clientNodeID, ok := report.ParseAdjacencyID(clientAdjID)
if !ok {
continue
}
remote, ok := labeler(clientNodeID)
if !ok {
continue
}
rows = append(rows, Row{
Key: remote,
ValueMajor: local,
})
}
return rows
}

4
render/detailed_node_test.go
View File

@@ -94,8 +94,8 @@ func TestMakeDetailedHostNode(t *testing.T) {
Rank: 0,
Rows: []render.Row{
{
Key: "Local",
ValueMajor: "Remote",
Key: "Client",
ValueMajor: "Server",
ValueMinor: "",
},
{

32
render/mapping.go
View File

@@ -33,12 +33,12 @@ const (
// rendered topology.
type LeafMapFunc func(report.NodeMetadata) (RenderableNode, bool)
// PseudoFunc creates RenderableNode representing pseudo nodes given the nodeID.
// dstNodeID is the node id of one of the nodes this node is attached to.
// nodeID and dstNodeID are node IDs prior to mapping. isClient indicated the direction
// of the edge to dstNodeID - true indicates nodeID is the client, false indicates
// nodeID is the server.
type PseudoFunc func(nodeID string, dstNodeID string, isClient bool, local report.Networks) (RenderableNode, bool)
// PseudoFunc creates RenderableNode representing pseudo nodes given the
// srcNodeID. dstNodeID is the node id of one of the nodes this node has an
// edge to. srcNodeID and dstNodeID are node IDs prior to mapping. srcIsClient
// indicates the direction of the edge to dstNodeID - true indicates srcNodeID
// is the client, false indicates dstNodeID is the server.
type PseudoFunc func(srcNodeID, dstNodeID string, srcIsClient bool, local report.Networks) (RenderableNode, bool)
// MapFunc is anything which can take an arbitrary RenderableNode and
// return another RenderableNode.
@@ -324,25 +324,25 @@ func MapAddress2Host(n RenderableNode) (RenderableNode, bool) {
// the report's local networks. Otherwise, the returned function will
// produce a single pseudo node per (dst address, src address, src port).
func GenericPseudoNode(addresser func(id string) net.IP) PseudoFunc {
return func(nodeID, dstNodeId string, isClient bool, local report.Networks) (RenderableNode, bool) {
return func(srcNodeID, dstNodeID string, srcIsClient bool, local report.Networks) (RenderableNode, bool) {
// Use the addresser to extract the IP of the missing node
nodeAddr := addresser(nodeID)
srcNodeAddr := addresser(srcNodeID)
// If the dstNodeAddr is not in a network local to this report, we emit an
// internet node
if !local.Contains(nodeAddr) {
if !local.Contains(srcNodeAddr) {
return newPseudoNode(TheInternetID, TheInternetMajor, ""), true
}
if isClient {
// If the client node is missing, generate a single pseudo node for every (client ip, server ip, server por)
serverIP, serverPort := trySplitAddr(dstNodeId)
outputID := MakePseudoNodeID(nodeAddr.String(), serverIP, serverPort)
major := nodeAddr.String()
if srcIsClient {
// If the client node is missing, generate a single pseudo node for every (client ip, server ip, server port)
serverIP, serverPort := trySplitAddr(dstNodeID)
outputID := MakePseudoNodeID(srcNodeAddr.String(), serverIP, serverPort)
major := srcNodeAddr.String()
return newPseudoNode(outputID, major, ""), true
}
// Othereise (the server node is missing), generate a pseudo node for every (server ip, server port)
serverIP, serverPort := trySplitAddr(nodeID)
// Otherwise (the server node is missing), generate a pseudo node for every (server ip, server port)
serverIP, serverPort := trySplitAddr(srcNodeID)
outputID := MakePseudoNodeID(serverIP, serverPort)
if serverPort != "" {
return newPseudoNode(outputID, serverIP+":"+serverPort, ""), true

6
render/render.go
View File

@@ -177,8 +177,8 @@ func (m LeafMap) Render(rpt report.Report) RenderableNodes {
source2mapped[nodeID] = mapped.ID
}
mkPseudoNode := func(srcID, dstId string, srcIsClient bool) (string, bool) {
pseudoNode, ok := m.Pseudo(srcID, dstId, srcIsClient, localNetworks)
mkPseudoNode := func(srcNodeID, dstNodeID string, srcIsClient bool) (string, bool) {
pseudoNode, ok := m.Pseudo(srcNodeID, dstNodeID, srcIsClient, localNetworks)
if !ok {
return "", false
}
@@ -191,7 +191,7 @@ func (m LeafMap) Render(rpt report.Report) RenderableNodes {
}
nodes[pseudoNode.ID] = pseudoNode
source2mapped[pseudoNode.ID] = srcID
source2mapped[pseudoNode.ID] = srcNodeID
return pseudoNode.ID, true
}