// MapContainer2IP maps container nodes to their IP addresses (outputs // multiple nodes). This allows container to be joined directly with // the endpoint topology. func MapContainer2IP(m RenderableNode, _ report.Networks) RenderableNodes { result := RenderableNodes{} if addrs, ok := m.Sets.Lookup(docker.ContainerIPsWithScopes); ok { for _, addr := range addrs { scope, addr, ok := report.ParseAddressNodeID(addr) if !ok { continue } id := report.MakeScopedEndpointNodeID(scope, addr, "") node := NewRenderableNodeWith(id, "", "", "", m) node.Counters = node.Counters.Add(ipsKey, 1) result[id] = node } } // Also output all the host:port port mappings (see above comment). // In this case we assume this doesn't need a scope, as they are for host IPs. ports, _ := m.Sets.Lookup(docker.ContainerPorts) for _, portMapping := range ports { if mapping := portMappingMatch.FindStringSubmatch(portMapping); mapping != nil { ip, port := mapping[1], mapping[2] id := report.MakeScopedEndpointNodeID("", ip, port) node := NewRenderableNodeWith(id, "", "", "", m.WithParents(report.EmptySets)) node.Counters = node.Counters.Add(ipsKey, 1) result[id] = node } } return result }
// MapContainer2IP maps container nodes to their IP addresses (outputs // multiple nodes). This allows container to be joined directly with // the endpoint topology. func MapContainer2IP(m report.Node) []string { // if this container doesn't make connections, we can ignore it _, doesntMakeConnections := m.Latest.Lookup(report.DoesNotMakeConnections) if doesntMakeConnections { return nil } result := []string{} if addrs, ok := m.Sets.Lookup(docker.ContainerIPsWithScopes); ok { for _, addr := range addrs { scope, addr, ok := report.ParseAddressNodeID(addr) if !ok { continue } id := report.MakeScopedEndpointNodeID(scope, addr, "") result = append(result, id) } } // Also output all the host:port port mappings (see above comment). // In this case we assume this doesn't need a scope, as they are for host IPs. ports, _ := m.Sets.Lookup(docker.ContainerPorts) for _, portMapping := range ports { if mapping := portMappingMatch.FindStringSubmatch(portMapping); mapping != nil { ip, port := mapping[1], mapping[2] id := report.MakeScopedEndpointNodeID("", ip, port) result = append(result, id) } } return result }
// 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.Metadata[endpoint.Addr] if !ok { return RenderableNodes{} } // Nodes without a hostid are treated as psuedo nodes _, ok = m.Metadata[report.HostNodeID] if !ok { // If the addr is not in a network local to this report, we emit an // internet node if !local.Contains(net.ParseIP(addr)) { return RenderableNodes{TheInternetID: newDerivedPseudoNode(TheInternetID, TheInternetMajor, 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) rank = major ) return RenderableNodes{id: NewRenderableNodeWith(id, major, minor, rank, m)} }
func connectionDetailsRows(topology report.Topology, originID string) []Row { rows := []Row{} labeler := func(nodeID string, meta map[string]string) (string, bool) { if _, addr, port, ok := report.ParseEndpointNodeID(nodeID); ok { if name, ok := meta["name"]; ok { return fmt.Sprintf("%s:%s", name, port), true } return fmt.Sprintf("%s:%s", addr, port), true } if _, addr, ok := report.ParseAddressNodeID(nodeID); ok { return addr, true } return "", false } local, ok := labeler(originID, topology.Nodes[originID].Metadata) if !ok { return rows } // Firstly, collection outgoing connections from this node. for _, serverNodeID := range topology.Nodes[originID].Adjacency { remote, ok := labeler(serverNodeID, topology.Nodes[serverNodeID].Metadata) if !ok { continue } rows = append(rows, Row{ Key: local, ValueMajor: remote, Expandable: true, }) } // Next, scan the topology for incoming connections to this node. for clientNodeID, clientNode := range topology.Nodes { if clientNodeID == originID { continue } serverNodeIDs := clientNode.Adjacency if !serverNodeIDs.Contains(originID) { continue } remote, ok := labeler(clientNodeID, clientNode.Metadata) if !ok { continue } rows = append(rows, Row{ Key: remote, ValueMajor: local, ValueMinor: "", Expandable: true, }) } return rows }
func connectionDetailsRows(topology report.Topology, originID string) []Row { rows := []Row{} labeler := func(nodeID string) (string, bool) { if _, addr, port, ok := report.ParseEndpointNodeID(nodeID); ok { return fmt.Sprintf("%s:%s", addr, port), true } if _, addr, ok := report.ParseAddressNodeID(nodeID); ok { return addr, true } return "", false } local, ok := labeler(originID) if !ok { return rows } // 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, Expandable: true, }) } // Next, scan the topology for incoming connections to this node. for clientAdjID, serverNodeIDs := range topology.Adjacency { 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, Expandable: true, }) } return rows }
// 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.Metadata[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.Metadata[report.HostNodeID] _, conntracked := m.Metadata[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 !local.Contains(net.ParseIP(addr)) { return RenderableNodes{TheInternetID: newDerivedPseudoNode(TheInternetID, TheInternetMajor, 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) rank = major ) return RenderableNodes{id: NewRenderableNodeWith(id, major, minor, rank, m)} }