Stop render package depending on probe

This dependency makes it harder to see the structure of the program,
and sometimes complicates compilation.

Mostly just changing the source of strings that are already exported
from the report package.  A few new strings have to be moved there,
plus the function `IsPauseImageName()`.

probe/docker/container.go

@@ -52,22 +52,10 @@ const (
 	CPUUsageInKernelmode = "docker_cpu_usage_in_kernelmode"
 	CPUSystemCPUUsage    = "docker_cpu_system_cpu_usage"
 
-	LabelPrefix = "docker_label_"
+	LabelPrefix = report.DockerLabelPrefix
 	EnvPrefix   = report.DockerEnvPrefix
 )
 
-// These 'constants' are used for node states.
-// We need to take pointers to them, so they are vars...
-var (
-	StateCreated    = "created"
-	StateDead       = "dead"
-	StateExited     = "exited"
-	StatePaused     = "paused"
-	StateRestarting = "restarting"
-	StateRunning    = "running"
-	StateDeleted    = "deleted"
-)
-
 // StatsGatherer gathers container stats
 type StatsGatherer interface {
 	Stats(docker.StatsOptions) error
@@ -479,7 +467,7 @@ func ExtractContainerIPsWithScopes(nmd report.Node) []string {
 // ContainerIsStopped checks if the docker container is in one of our "stopped" states
 func ContainerIsStopped(c Container) bool {
 	state := c.StateString()
-	return (state != StateRunning && state != StateRestarting && state != StatePaused)
+	return (state != report.StateRunning && state != report.StateRestarting && state != report.StatePaused)
 }
 
 // splitImageName returns parts of the full image name (image name, image tag).

probe/docker/registry.go

@@ -382,7 +382,7 @@ func (r *registry) deleteContainer(containerID string) {
 func (r *registry) sendDeletedUpdate(containerID string) {
 	node := report.MakeNodeWith(report.MakeContainerNodeID(containerID), map[string]string{
 		ContainerID:    containerID,
-		ContainerState: StateDeleted,
+		ContainerState: report.StateDeleted,
 	})
 	// Trigger anyone watching for updates
 	for _, f := range r.watchers {

probe/docker/registry_test.go

@@ -57,7 +57,7 @@ func (c *mockContainer) State() string {
 }
 
 func (c *mockContainer) StateString() string {
-	return docker.StateRunning
+	return report.StateRunning
 }
 
 func (c *mockContainer) StartGatheringStats(docker.StatsGatherer) error {

probe/docker/reporter.go

@@ -19,11 +19,11 @@ const (
 	ImageSize        = report.DockerImageSize
 	ImageVirtualSize = report.DockerImageVirtualSize
 	IsInHostNetwork  = report.DockerIsInHostNetwork
-	ImageLabelPrefix = "docker_image_label_"
+	ImageLabelPrefix = report.DockerImageLabelPrefix
 	ImageTableID     = "image_table"
 	ServiceName      = report.DockerServiceName
 	StackNamespace   = report.DockerStackNamespace
-	DefaultNamespace = "No stack"
+	DefaultNamespace = report.DockerDefaultNamespace
 )
 
 // Exposed for testing

probe/host/reporter.go

@@ -21,8 +21,8 @@ const (
 	KernelVersion = report.KernelVersion
 	Uptime        = report.Uptime
 	Load1         = report.Load1
-	CPUUsage      = report.CPUUsage
-	MemoryUsage   = report.MemoryUsage
+	CPUUsage      = report.HostCPUUsage
+	MemoryUsage   = report.HostMemoryUsage
 	ScopeVersion  = report.ScopeVersion
 )
 

probe/kubernetes/pod.go

@@ -16,12 +16,6 @@ const (
 	RestartCount    = report.KubernetesRestartCount
 )
 
-// Pod states we handle specially
-const (
-	StateDeleted = "deleted"
-	StateFailed  = "Failed"
-)
-
 // Pod represents a Kubernetes pod
 type Pod interface {
 	Meta

probe/kubernetes/reporter.go

@@ -2,7 +2,6 @@ package kubernetes
 
 import (
 	"fmt"
-	"strings"
 
 	"k8s.io/apimachinery/pkg/labels"
 
@@ -241,21 +240,13 @@ func (r *Reporter) podEvent(e Event, pod Pod) {
 		rpt.Pod.AddNode(
 			report.MakeNodeWith(
 				report.MakePodNodeID(pod.UID()),
-				map[string]string{State: StateDeleted},
+				map[string]string{State: report.StateDeleted},
 			),
 		)
 		r.probe.Publish(rpt)
 	}
 }
 
-// IsPauseImageName indicates whether an image name corresponds to a
-// kubernetes pause container image.
-func IsPauseImageName(imageName string) bool {
-	return strings.Contains(imageName, "google_containers/pause") ||
-		strings.Contains(imageName, "k8s.gcr.io/pause") ||
-		strings.Contains(imageName, "eks/pause")
-}
-
 func isPauseContainer(n report.Node, rpt report.Report) bool {
 	containerImageIDs, ok := n.Parents.Lookup(report.ContainerImage)
 	if !ok {
@@ -270,7 +261,7 @@ func isPauseContainer(n report.Node, rpt report.Report) bool {
 		if !ok {
 			continue
 		}
-		return IsPauseImageName(imageName)
+		return report.IsPauseImageName(imageName)
 	}
 	return false
 }

probe/overlay/weave.go

@@ -15,8 +15,8 @@ import (
 
 // Keys for use in Node
 const (
-	WeavePeerName                          = "weave_peer_name"
-	WeavePeerNickName                      = "weave_peer_nick_name"
+	WeavePeerName                          = report.WeavePeerName
+	WeavePeerNickName                      = report.WeavePeerNickName
 	WeaveDNSHostname                       = "weave_dns_hostname"
 	WeaveMACAddress                        = "weave_mac_address"
 	WeaveVersion                           = "weave_version"

render/container.go

@@ -5,7 +5,6 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/weaveworks/scope/probe/docker"
 	"github.com/weaveworks/scope/report"
 )
 
@@ -29,8 +28,8 @@ var UncontainedIDPrefix = MakePseudoNodeID(UncontainedID, "")
 var ContainerRenderer = Memoise(MakeFilter(
 	func(n report.Node) bool {
 		// Drop deleted containers
-		state, ok := n.Latest.Lookup(docker.ContainerState)
-		return !ok || state != docker.StateDeleted
+		state, ok := n.Latest.Lookup(report.DockerContainerState)
+		return !ok || state != report.StateDeleted
 	},
 	MakeReduce(
 		MakeMap(
@@ -130,7 +129,7 @@ func (r containerWithImageNameRenderer) Render(ctx context.Context, rpt report.R
 	outputs := make(report.Nodes, len(containers.Nodes))
 	for id, c := range containers.Nodes {
 		outputs[id] = c
-		imageID, ok := c.Latest.Lookup(docker.ImageID)
+		imageID, ok := c.Latest.Lookup(report.DockerImageID)
 		if !ok {
 			continue
 		}
@@ -143,8 +142,8 @@ func (r containerWithImageNameRenderer) Render(ctx context.Context, rpt report.R
 			continue
 		}
 
-		c.Latest = c.Latest.Propagate(image.Latest, docker.ImageName, docker.ImageTag,
-			docker.ImageSize, docker.ImageVirtualSize, docker.ImageLabelPrefix+"works.weave.role")
+		c.Latest = c.Latest.Propagate(image.Latest, report.DockerImageName, report.DockerImageTag,
+			report.DockerImageSize, report.DockerImageVirtualSize, report.DockerImageLabelPrefix+"works.weave.role")
 
 		c.Parents = c.Parents.
 			Delete(report.ContainerImage).
@@ -206,13 +205,13 @@ func MapContainer2IP(m report.Node) []string {
 	// if this container belongs to the host's networking namespace
 	// we cannot use its IP to attribute connections
 	// (they could come from any other process on the host or DNAT-ed IPs)
-	_, isInHostNetwork := m.Latest.Lookup(docker.IsInHostNetwork)
+	_, isInHostNetwork := m.Latest.Lookup(report.DockerIsInHostNetwork)
 	if doesntMakeConnections || isInHostNetwork {
 		return nil
 	}
 
 	result := []string{}
-	if addrs, ok := m.Sets.Lookup(docker.ContainerIPsWithScopes); ok {
+	if addrs, ok := m.Sets.Lookup(report.DockerContainerIPsWithScopes); ok {
 		for _, addr := range addrs {
 			scope, addr, ok := report.ParseAddressNodeID(addr)
 			if !ok {
@@ -230,7 +229,7 @@ func MapContainer2IP(m report.Node) []string {
 
 	// 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)
+	ports, _ := m.Sets.Lookup(report.DockerContainerPorts)
 	for _, portMapping := range ports {
 		if mapping := portMappingMatch.FindStringSubmatch(portMapping); mapping != nil {
 			ip, port := mapping[1], mapping[2]
@@ -266,7 +265,7 @@ func MapProcess2Container(n report.Node) report.Node {
 		id   string
 		node report.Node
 	)
-	if containerID, ok := n.Latest.Lookup(docker.ContainerID); ok {
+	if containerID, ok := n.Latest.Lookup(report.DockerContainerID); ok {
 		id = report.MakeContainerNodeID(containerID)
 		node = NewDerivedNode(id, n).WithTopology(report.Container)
 	} else {
@@ -297,7 +296,7 @@ func MapContainer2ContainerImage(n report.Node) report.Node {
 
 	// Otherwise, if some some reason the container doesn't have a image_id
 	// (maybe slightly out of sync reports), just drop it
-	imageID, ok := n.Latest.Lookup(docker.ImageID)
+	imageID, ok := n.Latest.Lookup(report.DockerImageID)
 	if !ok {
 		return report.Node{}
 	}
@@ -339,7 +338,7 @@ func MapContainerImage2Name(n report.Node) report.Node {
 	return n
 }
 
-var containerHostnameTopology = MakeGroupNodeTopology(report.Container, docker.ContainerHostname)
+var containerHostnameTopology = MakeGroupNodeTopology(report.Container, report.DockerContainerHostname)
 
 // MapContainer2Hostname maps container Nodes to 'hostname' renderabled nodes..
 func MapContainer2Hostname(n report.Node) report.Node {
@@ -350,7 +349,7 @@ func MapContainer2Hostname(n report.Node) report.Node {
 
 	// Otherwise, if some some reason the container doesn't have a hostname
 	// (maybe slightly out of sync reports), just drop it
-	id, ok := n.Latest.Lookup(docker.ContainerHostname)
+	id, ok := n.Latest.Lookup(report.DockerContainerHostname)
 	if !ok {
 		return report.Node{}
 	}

render/container_test.go

@@ -6,8 +6,6 @@ import (
 	"testing"
 
 	"github.com/weaveworks/common/test"
-	"github.com/weaveworks/scope/probe/docker"
-	"github.com/weaveworks/scope/probe/process"
 	"github.com/weaveworks/scope/render"
 	"github.com/weaveworks/scope/render/expected"
 	"github.com/weaveworks/scope/report"
@@ -30,8 +28,8 @@ var (
 func TestMapProcess2Container(t *testing.T) {
 	for _, input := range []testcase{
 		{"empty", report.MakeNode("empty"), true},
-		{"basic process", report.MakeNodeWith("basic", map[string]string{process.PID: "201", docker.ContainerID: "a1b2c3"}), true},
-		{"uncontained", report.MakeNodeWith("uncontained", map[string]string{process.PID: "201", report.HostNodeID: report.MakeHostNodeID("foo")}), true},
+		{"basic process", report.MakeNodeWith("basic", map[string]string{report.PID: "201", report.DockerContainerID: "a1b2c3"}), true},
+		{"uncontained", report.MakeNodeWith("uncontained", map[string]string{report.PID: "201", report.HostNodeID: report.MakeHostNodeID("foo")}), true},
 	} {
 		testMap(t, render.MapProcess2Container, input)
 	}
@@ -66,7 +64,7 @@ func TestContainerFilterRenderer(t *testing.T) {
 	// it is filtered out correctly.
 	input := fixture.Report.Copy()
 	input.Container.Nodes[fixture.ClientContainerNodeID] = input.Container.Nodes[fixture.ClientContainerNodeID].WithLatests(map[string]string{
-		docker.LabelPrefix + "works.weave.role": "system",
+		report.DockerLabelPrefix + "works.weave.role": "system",
 	})
 	have := utils.Prune(render.Render(context.Background(), input, render.ContainerWithImageNameRenderer, filterApplication).Nodes)
 	want := utils.Prune(expected.RenderedContainers.Copy())

render/detailed/node_test.go

@@ -73,7 +73,7 @@ func TestMakeDetailedHostNode(t *testing.T) {
 			},
 			Metrics: []report.MetricRow{
 				{
-					ID:       report.CPUUsage,
+					ID:       report.HostCPUUsage,
 					Label:    "CPU",
 					Format:   "percent",
 					Value:    0.07,
@@ -81,7 +81,7 @@ func TestMakeDetailedHostNode(t *testing.T) {
 					Metric:   &fixture.ClientHostCPUMetric,
 				},
 				{
-					ID:       report.MemoryUsage,
+					ID:       report.HostMemoryUsage,
 					Label:    "Memory",
 					Format:   "filesize",
 					Value:    0.08,

render/detailed/summary_test.go

@@ -250,7 +250,7 @@ func TestNodeMetadata(t *testing.T) {
 			node: report.MakeNodeWith(fixture.ClientContainerNodeID, map[string]string{
 				docker.ContainerID:            fixture.ClientContainerID,
 				docker.LabelPrefix + "label1": "label1value",
-				docker.ContainerStateHuman:    docker.StateRunning,
+				docker.ContainerStateHuman:    report.StateRunning,
 			}).WithTopology(report.Container).WithSets(report.MakeSets().
 				Add(docker.ContainerIPs, report.MakeStringSet("10.10.10.0/24", "10.10.10.1/24")),
 			),
@@ -336,7 +336,7 @@ func TestNodeMetrics(t *testing.T) {
 			node: fixture.Report.Host.Nodes[fixture.ClientHostNodeID],
 			want: []report.MetricRow{
 				{
-					ID:       report.CPUUsage,
+					ID:       report.HostCPUUsage,
 					Label:    "CPU",
 					Format:   "percent",
 					Group:    "",
@@ -345,7 +345,7 @@ func TestNodeMetrics(t *testing.T) {
 					Metric:   &fixture.ClientHostCPUMetric,
 				},
 				{
-					ID:       report.MemoryUsage,
+					ID:       report.HostMemoryUsage,
 					Label:    "Memory",
 					Format:   "filesize",
 					Group:    "",
@@ -424,7 +424,7 @@ func TestNodeTables(t *testing.T) {
 			node: report.MakeNodeWith(fixture.ClientContainerNodeID, map[string]string{
 				docker.ContainerID:            fixture.ClientContainerID,
 				docker.LabelPrefix + "label1": "label1value",
-				docker.ContainerState:         docker.StateRunning,
+				docker.ContainerState:         report.StateRunning,
 			}).WithTopology(report.Container).WithSets(report.MakeSets().
 				Add(docker.ContainerIPs, report.MakeStringSet("10.10.10.0/24", "10.10.10.1/24")),
 			),

render/filters.go

@@ -5,8 +5,6 @@ import (
 	"strings"
 
 	"github.com/weaveworks/common/mtime"
-	"github.com/weaveworks/scope/probe/docker"
-	"github.com/weaveworks/scope/probe/kubernetes"
 	"github.com/weaveworks/scope/report"
 )
 
@@ -229,8 +227,8 @@ func Noop(_ report.Node) bool { return true }
 
 // IsRunning checks if the node is a running docker container
 func IsRunning(n report.Node) bool {
-	state, ok := n.Latest.Lookup(docker.ContainerState)
-	return !ok || (state == docker.StateRunning || state == docker.StateRestarting || state == docker.StatePaused)
+	state, ok := n.Latest.Lookup(report.DockerContainerState)
+	return !ok || (state == report.StateRunning || state == report.StateRestarting || state == report.StatePaused)
 }
 
 // IsStopped checks if the node is *not* a running docker container
@@ -238,28 +236,28 @@ var IsStopped = Complement(IsRunning)
 
 // IsApplication checks if the node is an "application" node
 func IsApplication(n report.Node) bool {
-	containerName, _ := n.Latest.Lookup(docker.ContainerName)
+	containerName, _ := n.Latest.Lookup(report.DockerContainerName)
 	if _, ok := systemContainerNames[containerName]; ok {
 		return false
 	}
-	imageName, _ := n.Latest.Lookup(docker.ImageName)
+	imageName, _ := n.Latest.Lookup(report.DockerImageName)
 	imagePrefix := strings.SplitN(imageName, ":", 2)[0] // :(
-	if _, ok := systemImagePrefixes[imagePrefix]; ok || kubernetes.IsPauseImageName(imagePrefix) {
+	if _, ok := systemImagePrefixes[imagePrefix]; ok || report.IsPauseImageName(imagePrefix) {
 		return false
 	}
-	roleLabel, _ := n.Latest.Lookup(docker.LabelPrefix + "works.weave.role")
+	roleLabel, _ := n.Latest.Lookup(report.DockerLabelPrefix + "works.weave.role")
 	if roleLabel == "system" {
 		return false
 	}
-	roleLabel, _ = n.Latest.Lookup(docker.ImageLabelPrefix + "works.weave.role")
+	roleLabel, _ = n.Latest.Lookup(report.DockerImageLabelPrefix + "works.weave.role")
 	if roleLabel == "system" {
 		return false
 	}
-	namespace, _ := n.Latest.Lookup(docker.LabelPrefix + k8sNamespaceLabel)
+	namespace, _ := n.Latest.Lookup(report.DockerLabelPrefix + k8sNamespaceLabel)
 	if namespace == "kube-system" {
 		return false
 	}
-	podName, _ := n.Latest.Lookup(docker.LabelPrefix + "io.kubernetes.pod.name")
+	podName, _ := n.Latest.Lookup(report.DockerLabelPrefix + "io.kubernetes.pod.name")
 	if strings.HasPrefix(podName, "kube-system/") {
 		return false
 	}
@@ -272,7 +270,7 @@ var IsSystem = Complement(IsApplication)
 // HasLabel checks if the node has the desired docker label
 func HasLabel(labelKey string, labelValue string) FilterFunc {
 	return func(n report.Node) bool {
-		value, _ := n.Latest.Lookup(docker.LabelPrefix + labelKey)
+		value, _ := n.Latest.Lookup(report.DockerLabelPrefix + labelKey)
 		if value == labelValue {
 			return true
 		}
@@ -294,7 +292,7 @@ func IsNotPseudo(n report.Node) bool {
 // IsNamespace checks if the node is a pod/service in the specified namespace
 func IsNamespace(namespace string) FilterFunc {
 	return func(n report.Node) bool {
-		tryKeys := []string{kubernetes.Namespace, docker.LabelPrefix + k8sNamespaceLabel, docker.StackNamespace, docker.LabelPrefix + swarmNamespaceLabel}
+		tryKeys := []string{report.KubernetesNamespace, report.DockerLabelPrefix + k8sNamespaceLabel, report.DockerDefaultNamespace, report.DockerLabelPrefix + swarmNamespaceLabel}
 		gotNamespace := ""
 		for _, key := range tryKeys {
 			if value, ok := n.Latest.Lookup(key); ok {
@@ -303,7 +301,7 @@ func IsNamespace(namespace string) FilterFunc {
 			}
 		}
 		// Special case for docker
-		if namespace == docker.DefaultNamespace && gotNamespace == "" {
+		if namespace == report.DockerDefaultNamespace && gotNamespace == "" {
 			return true
 		}
 		return namespace == gotNamespace

render/persistentvolume.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"strings"
 
-	"github.com/weaveworks/scope/probe/kubernetes"
 	"github.com/weaveworks/scope/report"
 )
 
@@ -29,9 +28,9 @@ type volumesRenderer struct{}
 func (v volumesRenderer) Render(ctx context.Context, rpt report.Report) Nodes {
 	nodes := make(report.Nodes)
 	for id, n := range rpt.PersistentVolumeClaim.Nodes {
-		volume, _ := n.Latest.Lookup(kubernetes.VolumeName)
+		volume, _ := n.Latest.Lookup(report.KubernetesVolumeName)
 		for _, p := range rpt.PersistentVolume.Nodes {
-			volumeName, _ := p.Latest.Lookup(kubernetes.Name)
+			volumeName, _ := p.Latest.Lookup(report.KubernetesName)
 			if volume == volumeName {
 				n.Adjacency = n.Adjacency.Add(p.ID)
 				n.Children = n.Children.Add(p)
@@ -54,16 +53,16 @@ type podToVolumesRenderer struct{}
 func (v podToVolumesRenderer) Render(ctx context.Context, rpt report.Report) Nodes {
 	nodes := make(report.Nodes)
 	for podID, podNode := range rpt.Pod.Nodes {
-		claimNames, found := podNode.Latest.Lookup(kubernetes.VolumeClaim)
+		claimNames, found := podNode.Latest.Lookup(report.KubernetesVolumeClaim)
 		if !found {
 			continue
 		}
-		podNamespace, _ := podNode.Latest.Lookup(kubernetes.Namespace)
+		podNamespace, _ := podNode.Latest.Lookup(report.KubernetesNamespace)
 		claimNameList := strings.Split(claimNames, report.ScopeDelim)
 		for _, ClaimName := range claimNameList {
 			for _, pvcNode := range rpt.PersistentVolumeClaim.Nodes {
-				pvcName, _ := pvcNode.Latest.Lookup(kubernetes.Name)
-				pvcNamespace, _ := pvcNode.Latest.Lookup(kubernetes.Namespace)
+				pvcName, _ := pvcNode.Latest.Lookup(report.KubernetesName)
+				pvcNamespace, _ := pvcNode.Latest.Lookup(report.KubernetesNamespace)
 				if (pvcName == ClaimName) && (podNamespace == pvcNamespace) {
 					podNode.Adjacency = podNode.Adjacency.Add(pvcNode.ID)
 					podNode.Children = podNode.Children.Add(pvcNode)
@@ -87,9 +86,9 @@ type pvcToStorageClassRenderer struct{}
 func (v pvcToStorageClassRenderer) Render(ctx context.Context, rpt report.Report) Nodes {
 	nodes := make(report.Nodes)
 	for scID, scNode := range rpt.StorageClass.Nodes {
-		storageClass, _ := scNode.Latest.Lookup(kubernetes.Name)
+		storageClass, _ := scNode.Latest.Lookup(report.KubernetesName)
 		for _, pvcNode := range rpt.PersistentVolumeClaim.Nodes {
-			storageClassName, _ := pvcNode.Latest.Lookup(kubernetes.StorageClassName)
+			storageClassName, _ := pvcNode.Latest.Lookup(report.KubernetesStorageClassName)
 			if storageClassName == storageClass {
 				scNode.Adjacency = scNode.Adjacency.Add(pvcNode.ID)
 				scNode.Children = scNode.Children.Add(pvcNode)
@@ -110,9 +109,9 @@ type pvToSnapshotRenderer struct{}
 func (v pvToSnapshotRenderer) Render(ctx context.Context, rpt report.Report) Nodes {
 	nodes := make(report.Nodes)
 	for pvNodeID, p := range rpt.PersistentVolume.Nodes {
-		volumeName, _ := p.Latest.Lookup(kubernetes.Name)
+		volumeName, _ := p.Latest.Lookup(report.KubernetesName)
 		for _, volumeSnapshotNode := range rpt.VolumeSnapshot.Nodes {
-			snapshotPVName, _ := volumeSnapshotNode.Latest.Lookup(kubernetes.VolumeName)
+			snapshotPVName, _ := volumeSnapshotNode.Latest.Lookup(report.KubernetesVolumeName)
 			if volumeName == snapshotPVName {
 				p.Adjacency = p.Adjacency.Add(volumeSnapshotNode.ID)
 				p.Children = p.Children.Add(volumeSnapshotNode)
@@ -134,9 +133,9 @@ type volumeSnapshotRenderer struct{}
 func (v volumeSnapshotRenderer) Render(ctx context.Context, rpt report.Report) Nodes {
 	nodes := make(report.Nodes)
 	for volumeSnapshotID, volumeSnapshotNode := range rpt.VolumeSnapshot.Nodes {
-		snapshotData, _ := volumeSnapshotNode.Latest.Lookup(kubernetes.SnapshotData)
+		snapshotData, _ := volumeSnapshotNode.Latest.Lookup(report.KubernetesSnapshotData)
 		for volumeSnapshotDataID, volumeSnapshotDataNode := range rpt.VolumeSnapshotData.Nodes {
-			snapshotDataName, _ := volumeSnapshotDataNode.Latest.Lookup(kubernetes.Name)
+			snapshotDataName, _ := volumeSnapshotDataNode.Latest.Lookup(report.KubernetesName)
 			if snapshotDataName == snapshotData {
 				volumeSnapshotNode.Adjacency = volumeSnapshotNode.Adjacency.Add(volumeSnapshotDataNode.ID)
 				volumeSnapshotNode.Children = volumeSnapshotNode.Children.Add(volumeSnapshotDataNode)

render/pod.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"strings"
 
-	"github.com/weaveworks/scope/probe/docker"
-	"github.com/weaveworks/scope/probe/kubernetes"
 	"github.com/weaveworks/scope/report"
 )
 
@@ -41,8 +39,8 @@ func renderKubernetesTopologies(rpt report.Report) bool {
 }
 
 func isPauseContainer(n report.Node) bool {
-	image, ok := n.Latest.Lookup(docker.ImageName)
-	return ok && kubernetes.IsPauseImageName(image)
+	image, ok := n.Latest.Lookup(report.DockerImageName)
+	return ok && report.IsPauseImageName(image)
 }
 
 // PodRenderer is a Renderer which produces a renderable kubernetes
@@ -50,8 +48,8 @@ func isPauseContainer(n report.Node) bool {
 var PodRenderer = Memoise(ConditionalRenderer(renderKubernetesTopologies,
 	MakeFilter(
 		func(n report.Node) bool {
-			state, ok := n.Latest.Lookup(kubernetes.State)
-			return !ok || !(state == kubernetes.StateDeleted || state == kubernetes.StateFailed)
+			state, ok := n.Latest.Lookup(report.KubernetesState)
+			return !ok || !(state == report.StateDeleted || state == report.StateFailed)
 		},
 		MakeReduce(
 			PropagateSingleMetrics(report.Container,
@@ -141,11 +139,11 @@ func MapPod2IP(m report.Node) []string {
 	// if this pod belongs to the host's networking namespace
 	// we cannot use its IP to attribute connections
 	// (they could come from any other process on the host or DNAT-ed IPs)
-	if _, ok := m.Latest.Lookup(kubernetes.IsInHostNetwork); ok {
+	if _, ok := m.Latest.Lookup(report.KubernetesIsInHostNetwork); ok {
 		return nil
 	}
 
-	ip, ok := m.Latest.Lookup(kubernetes.IP)
+	ip, ok := m.Latest.Lookup(report.KubernetesIP)
 	if !ok || ip == "" {
 		return nil
 	}

render/pod_test.go

@@ -5,9 +5,9 @@ import (
 	"testing"
 
 	"github.com/weaveworks/common/test"
-	"github.com/weaveworks/scope/probe/kubernetes"
 	"github.com/weaveworks/scope/render"
 	"github.com/weaveworks/scope/render/expected"
+	"github.com/weaveworks/scope/report"
 	"github.com/weaveworks/scope/test/fixture"
 	"github.com/weaveworks/scope/test/reflect"
 	"github.com/weaveworks/scope/test/utils"
@@ -31,7 +31,7 @@ func TestPodFilterRenderer(t *testing.T) {
 	// it is filtered out correctly.
 	input := fixture.Report.Copy()
 	input.Pod.Nodes[fixture.ClientPodNodeID] = input.Pod.Nodes[fixture.ClientPodNodeID].WithLatests(map[string]string{
-		kubernetes.Namespace: "kube-system",
+		report.KubernetesNamespace: "kube-system",
 	})
 
 	have := utils.Prune(render.Render(context.Background(), input, render.PodRenderer, filterNonKubeSystem).Nodes)
@@ -55,7 +55,7 @@ func TestPodServiceFilterRenderer(t *testing.T) {
 	// it is filtered out correctly.
 	input := fixture.Report.Copy()
 	input.Service.Nodes[fixture.ServiceNodeID] = input.Service.Nodes[fixture.ServiceNodeID].WithLatests(map[string]string{
-		kubernetes.Namespace: "kube-system",
+		report.KubernetesNamespace: "kube-system",
 	})
 
 	have := utils.Prune(render.Render(context.Background(), input, render.PodServiceRenderer, filterNonKubeSystem).Nodes)

render/process.go

@@ -3,8 +3,6 @@ package render
 import (
 	"context"
 
-	"github.com/weaveworks/scope/probe/endpoint"
-	"github.com/weaveworks/scope/probe/process"
 	"github.com/weaveworks/scope/report"
 )
 
@@ -52,7 +50,7 @@ func (e endpoints2Processes) Render(ctx context.Context, rpt report.Report) Node
 	endpoints := SelectEndpoint.Render(ctx, rpt).Nodes
 	return MapEndpoints(
 		func(n report.Node) string {
-			pid, ok := n.Latest.Lookup(process.PID)
+			pid, ok := n.Latest.Lookup(report.PID)
 			if !ok {
 				return ""
 			}
@@ -81,7 +79,7 @@ func hasMoreThanOneConnection(n report.Node, endpoints report.Nodes) bool {
 	firstRealEndpointID := ""
 	for _, endpointID := range n.Adjacency {
 		if ep, ok := endpoints[endpointID]; ok {
-			if copyID, _, ok := ep.Latest.LookupEntry(endpoint.CopyOf); ok {
+			if copyID, _, ok := ep.Latest.LookupEntry(report.CopyOf); ok {
 				endpointID = copyID
 			}
 		}
@@ -94,7 +92,7 @@ func hasMoreThanOneConnection(n report.Node, endpoints report.Nodes) bool {
 	return false
 }
 
-var processNameTopology = MakeGroupNodeTopology(report.Process, process.Name)
+var processNameTopology = MakeGroupNodeTopology(report.Process, report.Name)
 
 // processes2Names maps process Nodes to Nodes for each process name.
 func processes2Names(processes Nodes) Nodes {
@@ -103,7 +101,7 @@ func processes2Names(processes Nodes) Nodes {
 	for _, n := range processes.Nodes {
 		if n.Topology == Pseudo {
 			ret.passThrough(n)
-		} else if name, ok := n.Latest.Lookup(process.Name); ok {
+		} else if name, ok := n.Latest.Lookup(report.Name); ok {
 			ret.addChildAndChildren(n, name, processNameTopology)
 		}
 	}

render/short_lived_connections_test.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/weaveworks/common/mtime"
 
-	"github.com/weaveworks/scope/probe/docker"
 	"github.com/weaveworks/scope/render"
 	"github.com/weaveworks/scope/report"
 	"github.com/weaveworks/scope/test/utils"
@@ -66,32 +65,32 @@ var (
 		Container: report.Topology{
 			Nodes: report.Nodes{
 				container1NodeID: report.MakeNodeWith(container1NodeID, map[string]string{
-					docker.ContainerID:   container1ID,
-					docker.ContainerName: container1Name,
-					report.HostNodeID:    serverHostNodeID,
+					report.DockerContainerID:   container1ID,
+					report.DockerContainerName: container1Name,
+					report.HostNodeID:          serverHostNodeID,
 				}).
 					WithSets(report.MakeSets().
-						Add(docker.ContainerIPs, report.MakeStringSet(container1IP)).
-						Add(docker.ContainerIPsWithScopes, report.MakeStringSet(report.MakeAddressNodeID("", container1IP))).
-						Add(docker.ContainerPorts, report.MakeStringSet(fmt.Sprintf("%s:%s->%s/tcp", serverIP, serverPort, serverPort))),
+						Add(report.DockerContainerIPs, report.MakeStringSet(container1IP)).
+						Add(report.DockerContainerIPsWithScopes, report.MakeStringSet(report.MakeAddressNodeID("", container1IP))).
+						Add(report.DockerContainerPorts, report.MakeStringSet(fmt.Sprintf("%s:%s->%s/tcp", serverIP, serverPort, serverPort))),
 					).WithTopology(report.Container),
 				container2NodeID: report.MakeNodeWith(container2NodeID, map[string]string{
-					docker.ContainerID:   container2ID,
-					docker.ContainerName: container2Name,
-					report.HostNodeID:    serverHostNodeID,
+					report.DockerContainerID:   container2ID,
+					report.DockerContainerName: container2Name,
+					report.HostNodeID:          serverHostNodeID,
 				}).
 					WithSets(report.MakeSets().
-						Add(docker.ContainerIPs, report.MakeStringSet(container2IP)).
-						Add(docker.ContainerIPsWithScopes, report.MakeStringSet(report.MakeAddressNodeID("", container2IP))),
+						Add(report.DockerContainerIPs, report.MakeStringSet(container2IP)).
+						Add(report.DockerContainerIPsWithScopes, report.MakeStringSet(report.MakeAddressNodeID("", container2IP))),
 					).WithTopology(report.Container),
 				pauseContainerNodeID: report.MakeNodeWith(pauseContainerNodeID, map[string]string{
-					docker.ContainerID:   pauseContainerID,
-					docker.ContainerName: pauseContainerName,
-					report.HostNodeID:    serverHostNodeID,
+					report.DockerContainerID:   pauseContainerID,
+					report.DockerContainerName: pauseContainerName,
+					report.HostNodeID:          serverHostNodeID,
 				}).
 					WithSets(report.MakeSets().
-						Add(docker.ContainerIPs, report.MakeStringSet(pauseContainerIP)).
-						Add(docker.ContainerIPsWithScopes, report.MakeStringSet(report.MakeAddressNodeID("", pauseContainerIP))),
+						Add(report.DockerContainerIPs, report.MakeStringSet(pauseContainerIP)).
+						Add(report.DockerContainerIPsWithScopes, report.MakeStringSet(report.MakeAddressNodeID("", pauseContainerIP))),
 					).WithTopology(report.Container).WithLatest(report.DoesNotMakeConnections, mtime.Now(), ""),
 			},
 		},

render/weave.go

@@ -1,7 +1,6 @@
 package render
 
 import (
-	"github.com/weaveworks/scope/probe/overlay"
 	"github.com/weaveworks/scope/report"
 )
 
@@ -22,7 +21,7 @@ func MapWeaveIdentity(m report.Node) report.Node {
 
 	var (
 		node        = m
-		nickname, _ = m.Latest.Lookup(overlay.WeavePeerNickName)
+		nickname, _ = m.Latest.Lookup(report.WeavePeerNickName)
 	)
 
 	// Nodes without a host id indicate they are not monitored by Scope

report/id.go

@@ -302,3 +302,11 @@ func IsLoopback(address string) bool {
 	ip := net.ParseIP(address)
 	return ip != nil && ip.IsLoopback()
 }
+
+// IsPauseImageName indicates whether an image name corresponds to a
+// kubernetes pause container image.
+func IsPauseImageName(imageName string) bool {
+	return strings.Contains(imageName, "google_containers/pause") ||
+		strings.Contains(imageName, "k8s.gcr.io/pause") ||
+		strings.Contains(imageName, "eks/pause")
+}

report/map_keys.go

@@ -22,6 +22,7 @@ const (
 	DockerIsInHostNetwork        = "docker_is_in_host_network"
 	DockerServiceName            = "service_name"
 	DockerStackNamespace         = "stack_namespace"
+	DockerDefaultNamespace       = "No stack"
 	DockerStopContainer          = "docker_stop_container"
 	DockerStartContainer         = "docker_start_container"
 	DockerRestartContainer       = "docker_restart_container"
@@ -105,9 +106,12 @@ const (
 	KernelVersion     = "kernel_version"
 	Uptime            = "uptime"
 	Load1             = "load1"
-	CPUUsage          = "host_cpu_usage_percent"
-	MemoryUsage       = "host_mem_usage_bytes"
+	HostCPUUsage      = "host_cpu_usage_percent"
+	HostMemoryUsage   = "host_mem_usage_bytes"
 	ScopeVersion      = "host_scope_version"
+	// probe/overlay/weave
+	WeavePeerName     = "weave_peer_name"
+	WeavePeerNickName = "weave_peer_nick_name"
 )
 
 /* Lookup table to allow msgpack/json decoder to avoid heap allocation
@@ -227,9 +231,12 @@ var commonKeys = map[string]string{
 	KernelVersion:     KernelVersion,
 	Uptime:            Uptime,
 	Load1:             Load1,
-	CPUUsage:          CPUUsage,
-	MemoryUsage:       MemoryUsage,
+	HostCPUUsage:      HostCPUUsage,
+	HostMemoryUsage:   HostMemoryUsage,
 	ScopeVersion:      ScopeVersion,
+
+	WeavePeerName:     WeavePeerName,
+	WeavePeerNickName: WeavePeerNickName,
 }
 
 func lookupCommonKey(b []byte) string {

report/map_values.go

@@ -0,0 +1,16 @@
+package report
+
+// constants used in node metadata values
+const (
+	DockerLabelPrefix      = "docker_label_"
+	DockerImageLabelPrefix = "docker_image_label_"
+
+	StateCreated    = "created"
+	StateDead       = "dead"
+	StateExited     = "exited"
+	StatePaused     = "paused"
+	StateRestarting = "restarting"
+	StateRunning    = "running"
+	StateDeleted    = "deleted"
+	StateFailed     = "Failed"
+)

test/fixture/report_fixture.go

@@ -224,8 +224,8 @@ var (
 						docker.LabelPrefix + "io.kubernetes.pod.uid": ClientPodUID,
 						docker.LabelPrefix + TestLabelKey1:           ApplicationLabelValue1,
 						kubernetes.Namespace:                         KubernetesNamespace,
-						docker.ContainerState:                        docker.StateRunning,
-						docker.ContainerStateHuman:                   docker.StateRunning,
+						docker.ContainerState:                        report.StateRunning,
+						docker.ContainerStateHuman:                   report.StateRunning,
 					}).
 					WithTopology(report.Container).WithParents(report.MakeSets().
 					Add("host", report.MakeStringSet(ClientHostNodeID)).
@@ -241,8 +241,8 @@ var (
 						docker.ContainerID:                                        ServerContainerID,
 						docker.ContainerName:                                      ServerContainerName,
 						docker.ContainerHostname:                                  ServerContainerHostname,
-						docker.ContainerState:                                     docker.StateRunning,
-						docker.ContainerStateHuman:                                docker.StateRunning,
+						docker.ContainerState:                                     report.StateRunning,
+						docker.ContainerStateHuman:                                report.StateRunning,
 						docker.ImageID:                                            ServerContainerImageID,
 						report.HostNodeID:                                         ServerHostNodeID,
 						docker.LabelPrefix + detailed.AmazonECSContainerNameLabel: "server",
@@ -299,9 +299,9 @@ var (
 					WithTopology(report.Host).WithSets(report.MakeSets().
 					Add(report.HostLocalNetworks, report.MakeStringSet("10.10.10.0/24")),
 				).WithMetrics(report.Metrics{
-					report.CPUUsage:    ClientHostCPUMetric,
-					report.MemoryUsage: ClientHostMemoryMetric,
-					report.Load1:       ClientHostLoad1Metric,
+					report.HostCPUUsage:    ClientHostCPUMetric,
+					report.HostMemoryUsage: ClientHostMemoryMetric,
+					report.Load1:           ClientHostLoad1Metric,
 				}),
 				ServerHostNodeID: report.MakeNodeWith(
 
@@ -313,9 +313,9 @@ var (
 					WithTopology(report.Host).WithSets(report.MakeSets().
 					Add(report.HostLocalNetworks, report.MakeStringSet("10.10.10.0/24")),
 				).WithMetrics(report.Metrics{
-					report.CPUUsage:    ServerHostCPUMetric,
-					report.MemoryUsage: ServerHostMemoryMetric,
-					report.Load1:       ServerHostLoad1Metric,
+					report.HostCPUUsage:    ServerHostCPUMetric,
+					report.HostMemoryUsage: ServerHostMemoryMetric,
+					report.Load1:           ServerHostLoad1Metric,
 				}),
 			},
 			MetadataTemplates: host.MetadataTemplates,