@@ -3,9 +3,12 @@ package graph

 import (

 	"fmt"

 	"io"

+	"sort"

 	"github.com/gonum/graph"

 	"github.com/gonum/graph/concrete"

+

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"

 )

 type Node struct {

@@ -109,6 +112,35 @@ func New() Graph {

 	}

 }

+func (g Graph) String() string {

+	ret := ""

+

+	nodeList := g.NodeList()

+	sort.Sort(SortedNodeList(nodeList))

+	for _, node := range nodeList {

+		ret += fmt.Sprintf("%d: %v\n", node.ID(), g.GraphDescriber.Name(node))

+

+		// can't use SuccessorEdges, because I want stable ordering

+		successors := g.Successors(node)

+		sort.Sort(SortedNodeList(successors))

+		for _, successor := range successors {

+			edge := g.EdgeBetween(node, successor)

+			kind := g.EdgeKind(edge)

+			ret += fmt.Sprintf("\t%v to %d: %v\n", kind, successor.ID(), g.GraphDescriber.Name(successor))

+		}

+	}

+

+	return ret

+}

+

+type SortedNodeList []graph.Node

+

+func (m SortedNodeList) Len() int      { return len(m) }

+func (m SortedNodeList) Swap(i, j int) { m[i], m[j] = m[j], m[i] }

+func (m SortedNodeList) Less(i, j int) bool {

+	return m[i].ID() < m[j].ID()

+}

+

 // RootNodes returns all the roots of this graph.

 func (g Graph) RootNodes() []graph.Node {

 	roots := []graph.Node{}

@@ -153,6 +185,38 @@ func (g Graph) SuccessorEdges(node graph.Node, fn EdgeFunc, edgeKind ...string)

 	}

 }

+// OutboundEdges returns all the outbound edges from node that are in the list of edgeKinds

+// if edgeKinds is empty, then all edges are returned

+func (g Graph) OutboundEdges(node graph.Node, edgeKinds ...string) []graph.Edge {

+	ret := []graph.Edge{}

+

+	allowedKinds := util.NewStringSet(edgeKinds...)

+	for _, n := range g.Successors(node) {

+		edge := g.EdgeBetween(n, node)

+		if len(allowedKinds) == 0 || allowedKinds.Has(g.EdgeKind(edge)) {

+			ret = append(ret, edge)

+		}

+	}

+

+	return ret

+}

+

+// InboundEdges returns all the inbound edges to node that are in the list of edgeKinds

+// if edgeKinds is empty, then all edges are returned

+func (g Graph) InboundEdges(node graph.Node, edgeKinds ...string) []graph.Edge {

+	ret := []graph.Edge{}

+

+	allowedKinds := util.NewStringSet(edgeKinds...)

+	for _, n := range g.Predecessors(node) {

+		edge := g.EdgeBetween(n, node)

+		if len(allowedKinds) == 0 || allowedKinds.Has(g.EdgeKind(edge)) {

+			ret = append(ret, edge)

+		}

+	}

+

+	return ret

+}

+

 func (g Graph) EdgeList() []graph.Edge {

 	return g.internal.EdgeList()

 }

@@ -163,6 +227,16 @@ func (g Graph) AddNode(n graph.Node) {

 // AddEdge implements MutableUniqueGraph

 func (g Graph) AddEdge(head, tail graph.Node, edgeKind string) {

+	// a Contains edge has semantic meaning for osgraph.Graph objects.  It never makes sense

+	// to allow a single object to be "contained" by multiple nodes.

+	if edgeKind == ContainsEdgeKind {

+		// check incoming edges on the tail to be certain that we aren't already contained

+		containsEdges := g.InboundEdges(tail, ContainsEdgeKind)

+		if len(containsEdges) != 0 {

+			// TODO consider changing the AddEdge API to make this cleaner.  This is a pretty severe programming error

+			panic(fmt.Sprintf("%v is already contained by %v", tail, containsEdges))

+		}

+	}

 	g.internal.AddDirectedEdge(NewEdge(head, tail, edgeKind), 1)

 }

@@ -3,6 +3,8 @@ package graph

 import (

 	"fmt"

+	"github.com/gonum/graph"

+

 	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

 	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"

 )

@@ -12,8 +14,13 @@ var (

 )

 var (

-	UnknownEdgeKind      = "UnknownEdge"

+	UnknownEdgeKind = "UnknownEdge"

+	// ReferencedByEdgeKind is the kind to use if you're building reverse links that don't have a specific edge in the other direction

+	// other uses are discouraged.  You should create a kind for your edge

 	ReferencedByEdgeKind = "ReferencedBy"

+	// ContainsEdgeKind is the kind to use if one node's contents logically contain another node's contents.  A given node can only have

+	// a single inbound Contais edge.  The code does not prevent contains cycles, but that's insane, don't do that.

+	ContainsEdgeKind = "Contains"

 )

 func GetUniqueRuntimeObjectNodeName(nodeKind string, obj runtime.Object) UniqueName {

@@ -24,3 +31,43 @@ func GetUniqueRuntimeObjectNodeName(nodeKind string, obj runtime.Object) UniqueN

 	return UniqueName(fmt.Sprintf("%s|%s/%s", nodeKind, meta.Namespace, meta.Name))

 }

+

+// GetTopLevelContainerNode traverses the reverse ContainsEdgeKind edges until it finds a node

+// that does not have an inbound ContainsEdgeKind edge.  This could be the node itself

+func GetTopLevelContainerNode(g Graph, containedNode graph.Node) graph.Node {

+	// my kingdom for a LinkedHashSet

+	visited := map[int]bool{}

+	prevContainingNode := containedNode

+

+	for {

+		visited[prevContainingNode.ID()] = true

+		currContainingNode := GetContainingNode(g, prevContainingNode)

+

+		if currContainingNode == nil {

+			return prevContainingNode

+		}

+		if _, alreadyVisited := visited[currContainingNode.ID()]; alreadyVisited {

+			panic(fmt.Sprintf("contains cycle in %v", visited))

+		}

+

+		prevContainingNode = currContainingNode

+	}

+

+	// can't happen

+	panic(fmt.Sprintf("math failed %v", visited))

+	return nil

+}

+

+// GetContainingNode returns the direct predecessor that is linked to the node by a ContainsEdgeKind.  It returns

+// nil if no container is found.

+func GetContainingNode(g Graph, containedNode graph.Node) graph.Node {

+	for _, node := range g.Predecessors(containedNode) {

+		edge := g.EdgeBetween(node, containedNode)

+

+		if g.EdgeKind(edge) == ContainsEdgeKind {

+			return node

+		}

+	}

+

+	return nil

+}

new file mode 100644

@@ -0,0 +1,69 @@

+package graph

+

+import (

+	"testing"

+

+	"github.com/gonum/graph"

+)

+

+func makeTestNode(g MutableUniqueGraph, name string) graph.Node {

+	return EnsureUnique(g,

+		UniqueName(name),

+		func(node Node) graph.Node {

+			return node

+		},

+	)

+}

+

+func TestContainsNavigation(t *testing.T) {

+	g := New()

+

+	aNode := makeTestNode(g, "a")

+	bNode := makeTestNode(g, "b")

+	cNode := makeTestNode(g, "c")

+

+	g.AddEdge(aNode, bNode, ContainsEdgeKind)

+	g.AddEdge(bNode, cNode, ContainsEdgeKind)

+

+	topA := GetTopLevelContainerNode(g, aNode)

+	if e, a := aNode.ID(), topA.ID(); e != a {

+		t.Errorf("expected %v, got %v", e, a)

+	}

+

+	topB := GetTopLevelContainerNode(g, bNode)

+	if e, a := aNode.ID(), topB.ID(); e != a {

+		t.Errorf("expected %v, got %v", e, a)

+	}

+

+	topC := GetTopLevelContainerNode(g, cNode)

+	if e, a := aNode.ID(), topC.ID(); e != a {

+		t.Errorf("expected %v, got %v", e, a)

+	}

+

+	containsB := GetContainingNode(g, bNode)

+	if e, a := aNode.ID(), containsB.ID(); e != a {

+		t.Errorf("expected %v, got %v", e, a)

+	}

+

+	containsC := GetContainingNode(g, cNode)

+	if e, a := bNode.ID(), containsC.ID(); e != a {

+		t.Errorf("expected %v, got %v", e, a)

+	}

+}

+

+func TestOnlyOneContainseEdge(t *testing.T) {

+	g := New()

+

+	aNode := makeTestNode(g, "a")

+	bNode := makeTestNode(g, "b")

+	cNode := makeTestNode(g, "c")

+

+	g.AddEdge(aNode, bNode, ContainsEdgeKind)

+

+	defer func() {

+		if r := recover(); r == nil {

+			t.Errorf("expected to recover panic!")

+		}

+	}()

+	g.AddEdge(cNode, bNode, ContainsEdgeKind)

+}

@@ -9,6 +9,7 @@ import (

 	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

 	osgraph "github.com/openshift/origin/pkg/api/graph"

+	kubeedges "github.com/openshift/origin/pkg/api/kubegraph"

 	kubegraph "github.com/openshift/origin/pkg/api/kubegraph/nodes"

 	buildedges "github.com/openshift/origin/pkg/build/graph"

 	buildgraph "github.com/openshift/origin/pkg/build/graph/nodes"

@@ -37,6 +38,22 @@ type DeploymentFlow struct {

 	Images     []ImagePipeline

 }

+// ServiceReference is a service and the DeploymentConfigs it covers

+type ServiceReference struct {

+	Service     *kubegraph.ServiceNode

+	CoveredDCs  []*deploygraph.DeploymentConfigNode

+	CoveredRCs  []*kubegraph.ReplicationControllerNode

+	CoveredPods []*kubegraph.PodNode

+}

+

+// ServiceGroup is a related set of resources that should be displayed together

+// logically. They are usually sorted internally.

+type ServiceGroup struct {

+	Services    []ServiceReference

+	Deployments []DeploymentFlow

+	Builds      []ImagePipeline

+}

+

 // ImageTagLocation identifies the source or destination of an image. Represents

 // both a tag in a Docker image repository, as well as a tag in an OpenShift image stream.

 type ImageTagLocation interface {

@@ -195,16 +212,28 @@ func ServiceAndDeploymentGroups(g osgraph.Graph) []ServiceGroup {

 		svcs, dcs, _ := matches[0], matches[1], matches[2]

 		for _, n := range svcs {

-			covers := []*deploygraph.DeploymentConfigNode{}

+			coveredDCs := []*deploygraph.DeploymentConfigNode{}

+			coveredRCs := []*kubegraph.ReplicationControllerNode{}

+			coveredPods := []*kubegraph.PodNode{}

 			for _, neighbor := range other.Neighbors(n) {

 				switch other.EdgeKind(g.EdgeBetween(neighbor, n)) {

-				case deployedges.ExposedThroughServiceEdgeKind:

-					covers = append(covers, neighbor.(*deploygraph.DeploymentConfigNode))

+				case kubeedges.ExposedThroughServiceEdgeKind:

+					containerNode := osgraph.GetTopLevelContainerNode(g, neighbor)

+					switch castCoveredNode := containerNode.(type) {

+					case *deploygraph.DeploymentConfigNode:

+						coveredDCs = append(coveredDCs, castCoveredNode)

+					case *kubegraph.ReplicationControllerNode:

+						coveredRCs = append(coveredRCs, castCoveredNode)

+					case *kubegraph.PodNode:

+						coveredPods = append(coveredPods, castCoveredNode)

+					}

 				}

 			}

 			group.Services = append(group.Services, ServiceReference{

-				Service: n.(*kubegraph.ServiceNode),

-				Covers:  covers,

+				Service:     n.(*kubegraph.ServiceNode),

+				CoveredDCs:  coveredDCs,

+				CoveredRCs:  coveredRCs,

+				CoveredPods: coveredPods,

 			})

 		}

 		sort.Sort(SortedServiceReferences(group.Services))

@@ -243,7 +272,7 @@ func ServiceAndDeploymentGroups(g osgraph.Graph) []ServiceGroup {

 // Services and DeploymentConfigs.

 func UncoveredDeploymentFlowEdges(covered osgraph.NodeSet) osgraph.EdgeFunc {

 	return func(g osgraph.Interface, head, tail graph.Node, edgeKind string) bool {

-		if edgeKind == deployedges.ExposedThroughServiceEdgeKind {

+		if edgeKind == kubeedges.ExposedThroughServiceEdgeKind {

 			return osgraph.AddReversedEdge(g, head, tail, osgraph.ReferencedByEdgeKind)

 		}

 		if covered.Has(head.ID()) && covered.Has(tail.ID()) {

@@ -265,20 +294,6 @@ func UncoveredDeploymentFlowNodes(covered osgraph.NodeSet) osgraph.NodeFunc {

 	}

 }

-// ServiceReference is a service and the DeploymentConfigs it covers

-type ServiceReference struct {

-	Service *kubegraph.ServiceNode

-	Covers  []*deploygraph.DeploymentConfigNode

-}

-

-// ServiceGroup is a related set of resources that should be displayed together

-// logically. They are usually sorted internally.

-type ServiceGroup struct {

-	Services    []ServiceReference

-	Deployments []DeploymentFlow

-	Builds      []ImagePipeline

-}

-

 // Sorts on the provided objects.

 type SortedServiceReferences []ServiceReference

@@ -11,6 +11,7 @@ import (

 	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"

 	osgraph "github.com/openshift/origin/pkg/api/graph"

+	kubeedges "github.com/openshift/origin/pkg/api/kubegraph"

 	kubegraph "github.com/openshift/origin/pkg/api/kubegraph/nodes"

 	buildapi "github.com/openshift/origin/pkg/build/api"

 	buildedges "github.com/openshift/origin/pkg/build/graph"

@@ -52,7 +53,7 @@ func TestGraph(t *testing.T) {

 		},

 	}

-	bcNode := buildgraph.EnsureBuildConfigNode(g, &buildapi.BuildConfig{

+	bc1Node := buildgraph.EnsureBuildConfigNode(g, &buildapi.BuildConfig{

 		ObjectMeta: kapi.ObjectMeta{Namespace: "default", Name: "build1"},

 		Triggers: []buildapi.BuildTriggerPolicy{

 			{

@@ -72,7 +73,7 @@ func TestGraph(t *testing.T) {

 			},

 		},

 	})

-	buildedges.JoinBuilds(bcNode, builds)

+	buildedges.JoinBuilds(bc1Node, builds)

 	bcTestNode := buildgraph.EnsureBuildConfigNode(g, &buildapi.BuildConfig{

 		ObjectMeta: kapi.ObjectMeta{Namespace: "default", Name: "test"},

 		Parameters: buildapi.BuildParameters{

@@ -178,13 +179,14 @@ func TestGraph(t *testing.T) {

 		},

 	})

-	deployedges.AddAllFullfillingDeploymentConfigEdges(g)

+	kubeedges.AddAllExposedPodTemplateSpecEdges(g)

 	buildedges.AddAllInputOutputEdges(g)

 	deployedges.AddAllTriggerEdges(g)

+	t.Log(g)

+

 	ir, dc, bc, other := 0, 0, 0, 0

 	for _, node := range g.NodeList() {

-		t.Logf("node: %d %v", node.ID(), node)

 		switch g.Object(node).(type) {

 		case *deployapi.DeploymentConfig:

 			if g.Kind(node) != deploygraph.DeploymentConfigNodeKind {

@@ -206,18 +208,14 @@ func TestGraph(t *testing.T) {

 			other++

 		}

 	}

-	if dc != 2 || bc != 3 || ir != 3 || other != 6 {

+

+	if dc != 2 || bc != 3 || ir != 3 || other != 12 {

 		t.Errorf("unexpected nodes: %d %d %d %d", dc, bc, ir, other)

 	}

 	for _, edge := range g.EdgeList() {

 		if g.EdgeKind(edge) == osgraph.UnknownEdgeKind {

 			t.Errorf("edge reported unknown kind: %#v", edge)

 		}

-		t.Logf("edge: %v", edge)

-	}

-	reverse := g.EdgeSubgraph(osgraph.ReverseGraphEdge)

-	for _, edge := range reverse.EdgeList() {

-		t.Logf("redge: %v", edge)

 	}

 	// imagestreamtag default/other:base-image

@@ -233,7 +231,6 @@ func TestGraph(t *testing.T) {

 	if edge == nil {

 		t.Fatalf("failed to find edge between %d and %d", bcTestNode.ID(), istID)

 	}

-

 	if len(g.SubgraphWithNodes([]graph.Node{edge.Head(), edge.Tail()}, osgraph.ExistingDirectEdge).EdgeList()) != 1 {

 		t.Fatalf("expected one edge")

 	}

new file mode 100644

@@ -0,0 +1,68 @@

+package kubegraph

+

+import (

+	"github.com/gonum/graph"

+

+	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"

+

+	osgraph "github.com/openshift/origin/pkg/api/graph"

+	kubegraph "github.com/openshift/origin/pkg/api/kubegraph/nodes"

+)

+

+const (

+	// ExposedThroughServiceEdgeKind is an edge that goes from a podtemplatespec or a pod to service.

+	// The head should make the service's selector

+	ExposedThroughServiceEdgeKind = "ExposedThroughService"

+)

+

+// AddExposedPodTemplateSpecEdges ensures that a directed edge exists between a service and all the PodTemplateSpecs

+// in the graph that match the service selector

+func AddExposedPodTemplateSpecEdges(g osgraph.MutableUniqueGraph, node *kubegraph.ServiceNode) {

+	if node.Service.Spec.Selector == nil {

+		return

+	}

+	query := labels.SelectorFromSet(node.Service.Spec.Selector)

+	for _, n := range g.(graph.Graph).NodeList() {

+		switch target := n.(type) {

+		case *kubegraph.PodTemplateSpecNode:

+			if query.Matches(labels.Set(target.PodTemplateSpec.Labels)) {

+				g.AddEdge(target, node, ExposedThroughServiceEdgeKind)

+			}

+		}

+	}

+}

+

+// AddAllExposedPodTemplateSpecEdges calls AddExposedPodTemplateSpecEdges for every ServiceNode in the graph

+func AddAllExposedPodTemplateSpecEdges(g osgraph.MutableUniqueGraph) {

+	for _, node := range g.(graph.Graph).NodeList() {

+		if serviceNode, ok := node.(*kubegraph.ServiceNode); ok {

+			AddExposedPodTemplateSpecEdges(g, serviceNode)

+		}

+	}

+}

+

+// AddExposedPodEdges ensures that a directed edge exists between a service and all the pods

+// in the graph that match the service selector

+func AddExposedPodEdges(g osgraph.MutableUniqueGraph, node *kubegraph.ServiceNode) {

+	if node.Service.Spec.Selector == nil {

+		return

+	}

+	query := labels.SelectorFromSet(node.Service.Spec.Selector)

+	for _, n := range g.(graph.Graph).NodeList() {

+		switch target := n.(type) {

+		case *kubegraph.PodNode:

+			if query.Matches(labels.Set(target.Labels)) {

+				g.AddEdge(target, node, ExposedThroughServiceEdgeKind)

+			}

+		}

+	}

+}

+

+// AddAllExposedPodEdges calls AddExposedPodEdges for every ServiceNode in the graph

+func AddAllExposedPodEdges(g osgraph.MutableUniqueGraph) {

+	for _, node := range g.(graph.Graph).NodeList() {

+		if serviceNode, ok := node.(*kubegraph.ServiceNode); ok {

+			AddExposedPodEdges(g, serviceNode)

+		}

+	}

+}

@@ -9,12 +9,27 @@ import (

 )

 func EnsurePodNode(g osgraph.MutableUniqueGraph, pod *kapi.Pod) *PodNode {

-	return osgraph.EnsureUnique(g,

-		PodNodeName(pod),

+	podNodeName := PodNodeName(pod)

+	podNode := osgraph.EnsureUnique(g,

+		podNodeName,

 		func(node osgraph.Node) graph.Node {

 			return &PodNode{node, pod}

 		},

 	).(*PodNode)

+

+	podSpecNode := EnsurePodSpecNode(g, &pod.Spec, podNodeName)

+	g.AddEdge(podNode, podSpecNode, osgraph.ContainsEdgeKind)

+

+	return podNode

+}

+

+func EnsurePodSpecNode(g osgraph.MutableUniqueGraph, podSpec *kapi.PodSpec, ownerName osgraph.UniqueName) *PodSpecNode {

+	return osgraph.EnsureUnique(g,

+		PodSpecNodeName(podSpec, ownerName),

+		func(node osgraph.Node) graph.Node {

+			return &PodSpecNode{node, podSpec, ownerName}

+		},

+	).(*PodSpecNode)

 }

 // EnsureServiceNode adds the provided service to the graph if it does not already exist.

@@ -29,10 +44,48 @@ func EnsureServiceNode(g osgraph.MutableUniqueGraph, svc *kapi.Service) *Service

 // EnsureReplicationControllerNode adds a graph node for the ReplicationController if it does not already exist.

 func EnsureReplicationControllerNode(g osgraph.MutableUniqueGraph, rc *kapi.ReplicationController) *ReplicationControllerNode {

-	return osgraph.EnsureUnique(g,

-		ReplicationControllerNodeName(rc),

+	rcNodeName := ReplicationControllerNodeName(rc)

+	rcNode := osgraph.EnsureUnique(g,

+		rcNodeName,

 		func(node osgraph.Node) graph.Node {

 			return &ReplicationControllerNode{node, rc}

 		},

 	).(*ReplicationControllerNode)

+

+	rcSpecNode := EnsureReplicationControllerSpecNode(g, &rc.Spec, rcNodeName)

+	g.AddEdge(rcNode, rcSpecNode, osgraph.ContainsEdgeKind)

+

+	return rcNode

+}

+

+func EnsureReplicationControllerSpecNode(g osgraph.MutableUniqueGraph, rcSpec *kapi.ReplicationControllerSpec, ownerName osgraph.UniqueName) *ReplicationControllerSpecNode {

+	rcSpecName := ReplicationControllerSpecNodeName(rcSpec, ownerName)

+	rcSpecNode := osgraph.EnsureUnique(g,

+		rcSpecName,

+		func(node osgraph.Node) graph.Node {

+			return &ReplicationControllerSpecNode{node, rcSpec, ownerName}

+		},

+	).(*ReplicationControllerSpecNode)

+

+	if rcSpec.Template != nil {

+		ptSpecNode := EnsurePodTemplateSpecNode(g, rcSpec.Template, rcSpecName)

+		g.AddEdge(rcSpecNode, ptSpecNode, osgraph.ContainsEdgeKind)

+	}

+

+	return rcSpecNode

+}

+

+func EnsurePodTemplateSpecNode(g osgraph.MutableUniqueGraph, ptSpec *kapi.PodTemplateSpec, ownerName osgraph.UniqueName) *PodTemplateSpecNode {

+	ptSpecName := PodTemplateSpecNodeName(ptSpec, ownerName)

+	ptSpecNode := osgraph.EnsureUnique(g,

+		ptSpecName,

+		func(node osgraph.Node) graph.Node {

+			return &PodTemplateSpecNode{node, ptSpec, ownerName}

+		},

+	).(*PodTemplateSpecNode)

+

+	podSpecNode := EnsurePodSpecNode(g, &ptSpec.Spec, ptSpecName)

+	g.AddEdge(ptSpecNode, podSpecNode, osgraph.ContainsEdgeKind)

+

+	return ptSpecNode

 }

new file mode 100644

@@ -0,0 +1,90 @@

+package nodes

+

+import (

+	"testing"

+

+	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

+

+	osgraph "github.com/openshift/origin/pkg/api/graph"

+)

+

+func TestPodSpecNode(t *testing.T) {

+	g := osgraph.New()

+

+	pod := &kapi.Pod{}

+	pod.Namespace = "ns"

+	pod.Name = "foo"

+	pod.Spec.Host = "any-host"

+

+	podNode := EnsurePodNode(g, pod)

+

+	if len(g.NodeList()) != 2 {

+		t.Errorf("expected 2 nodes, got %v", g.NodeList())

+	}

+

+	if len(g.EdgeList()) != 1 {

+		t.Errorf("expected 1 edge, got %v", g.EdgeList())

+	}

+

+	edge := g.EdgeList()[0]

+	if g.EdgeKind(edge) != osgraph.ContainsEdgeKind {

+		t.Errorf("expected %v, got %v", osgraph.ContainsEdgeKind, g.EdgeKind(edge))

+	}

+	if edge.Head().ID() != podNode.ID() {

+		t.Errorf("expected %v, got %v", podNode.ID(), edge.Head())

+	}

+}

+

+func TestReplicationControllerSpecNode(t *testing.T) {

+	g := osgraph.New()

+

+	rc := &kapi.ReplicationController{}

+	rc.Namespace = "ns"

+	rc.Name = "foo"

+	rc.Spec.Template = &kapi.PodTemplateSpec{}

+

+	rcNode := EnsureReplicationControllerNode(g, rc)

+

+	if len(g.NodeList()) != 4 {

+		t.Errorf("expected 4 nodes, got %v", g.NodeList())

+	}

+

+	if len(g.EdgeList()) != 3 {

+		t.Errorf("expected 3 edge, got %v", g.EdgeList())

+	}

+

+	rcEdges := g.OutboundEdges(rcNode)

+	if len(rcEdges) != 1 {

+		t.Fatalf("expected 1 edge, got %v", rcEdges)

+	}

+	if g.EdgeKind(rcEdges[0]) != osgraph.ContainsEdgeKind {

+		t.Errorf("expected %v, got %v", osgraph.ContainsEdgeKind, rcEdges[0])

+	}

+

+	uncastRCSpec := rcEdges[0].Tail()

+	rcSpec, ok := uncastRCSpec.(*ReplicationControllerSpecNode)

+	if !ok {

+		t.Fatalf("expected rcSpec, got %v", uncastRCSpec)

+	}

+	rcSpecEdges := g.OutboundEdges(rcSpec)

+	if len(rcSpecEdges) != 1 {

+		t.Fatalf("expected 1 edge, got %v", rcSpecEdges)

+	}

+	if g.EdgeKind(rcSpecEdges[0]) != osgraph.ContainsEdgeKind {

+		t.Errorf("expected %v, got %v", osgraph.ContainsEdgeKind, rcSpecEdges[0])

+	}

+

+	uncastPTSpec := rcSpecEdges[0].Tail()

+	ptSpec, ok := uncastPTSpec.(*PodTemplateSpecNode)

+	if !ok {

+		t.Fatalf("expected ptspec, got %v", uncastPTSpec)

+	}

+	ptSpecEdges := g.OutboundEdges(ptSpec)

+	if len(ptSpecEdges) != 1 {

+		t.Fatalf("expected 1 edge, got %v", ptSpecEdges)

+	}

+	if g.EdgeKind(ptSpecEdges[0]) != osgraph.ContainsEdgeKind {

+		t.Errorf("expected %v, got %v", osgraph.ContainsEdgeKind, ptSpecEdges[0])

+	}

+

+}

@@ -10,9 +10,12 @@ import (

 )

 var (

-	ServiceNodeKind               = reflect.TypeOf(kapi.Service{}).Name()

-	PodNodeKind                   = reflect.TypeOf(kapi.Pod{}).Name()

-	ReplicationControllerNodeKind = reflect.TypeOf(kapi.ReplicationController{}).Name()

+	ServiceNodeKind                   = reflect.TypeOf(kapi.Service{}).Name()

+	PodNodeKind                       = reflect.TypeOf(kapi.Pod{}).Name()

+	PodSpecNodeKind                   = reflect.TypeOf(kapi.PodSpec{}).Name()

+	PodTemplateSpecNodeKind           = reflect.TypeOf(kapi.PodTemplateSpec{}).Name()

+	ReplicationControllerNodeKind     = reflect.TypeOf(kapi.ReplicationController{}).Name()

+	ReplicationControllerSpecNodeKind = reflect.TypeOf(kapi.ReplicationControllerSpec{}).Name()

 )

 func ServiceNodeName(o *kapi.Service) osgraph.UniqueName {

@@ -53,10 +56,41 @@ func (n PodNode) String() string {

 	return fmt.Sprintf("<pod %s/%s>", n.Namespace, n.Name)

 }

+func (n PodNode) UniqueName() osgraph.UniqueName {

+	return PodNodeName(n.Pod)

+}

+

 func (*PodNode) Kind() string {

 	return PodNodeKind

 }

+func PodSpecNodeName(o *kapi.PodSpec, ownerName osgraph.UniqueName) osgraph.UniqueName {

+	return osgraph.UniqueName(fmt.Sprintf("%s|%v", PodSpecNodeKind, ownerName))

+}

+

+type PodSpecNode struct {

+	osgraph.Node

+	*kapi.PodSpec

+

+	OwnerName osgraph.UniqueName

+}

+

+func (n PodSpecNode) Object() interface{} {

+	return n.PodSpec

+}

+

+func (n PodSpecNode) String() string {

+	return string(n.UniqueName())

+}

+

+func (n PodSpecNode) UniqueName() osgraph.UniqueName {

+	return PodSpecNodeName(n.PodSpec, n.OwnerName)

+}

+

+func (*PodSpecNode) Kind() string {

+	return PodSpecNodeKind

+}

+

 func ReplicationControllerNodeName(o *kapi.ReplicationController) osgraph.UniqueName {

 	return osgraph.GetUniqueRuntimeObjectNodeName(ReplicationControllerNodeKind, o)

 }

@@ -74,6 +108,64 @@ func (n ReplicationControllerNode) String() string {

 	return fmt.Sprintf("<replicationcontroller %s/%s>", n.Namespace, n.Name)

 }

+func (n ReplicationControllerNode) UniqueName() osgraph.UniqueName {

+	return ReplicationControllerNodeName(n.ReplicationController)

+}

+

 func (*ReplicationControllerNode) Kind() string {

 	return ReplicationControllerNodeKind

 }

+

+func ReplicationControllerSpecNodeName(o *kapi.ReplicationControllerSpec, ownerName osgraph.UniqueName) osgraph.UniqueName {

+	return osgraph.UniqueName(fmt.Sprintf("%s|%v", ReplicationControllerSpecNodeKind, ownerName))

+}

+

+type ReplicationControllerSpecNode struct {

+	osgraph.Node

+	*kapi.ReplicationControllerSpec

+

+	OwnerName osgraph.UniqueName

+}

+

+func (n ReplicationControllerSpecNode) Object() interface{} {

+	return n.ReplicationControllerSpec

+}

+

+func (n ReplicationControllerSpecNode) String() string {

+	return string(n.UniqueName())

+}

+

+func (n ReplicationControllerSpecNode) UniqueName() osgraph.UniqueName {

+	return ReplicationControllerSpecNodeName(n.ReplicationControllerSpec, n.OwnerName)

+}

+

+func (*ReplicationControllerSpecNode) Kind() string {

+	return ReplicationControllerSpecNodeKind

+}

+

+func PodTemplateSpecNodeName(o *kapi.PodTemplateSpec, ownerName osgraph.UniqueName) osgraph.UniqueName {

+	return osgraph.UniqueName(fmt.Sprintf("%s|%v", PodTemplateSpecNodeKind, ownerName))

+}

+

+type PodTemplateSpecNode struct {

+	osgraph.Node

+	*kapi.PodTemplateSpec

+

+	OwnerName osgraph.UniqueName

+}

+

+func (n PodTemplateSpecNode) Object() interface{} {

+	return n.PodTemplateSpec

+}

+

+func (n PodTemplateSpecNode) String() string {

+	return string(n.UniqueName())

+}

+

+func (n PodTemplateSpecNode) UniqueName() osgraph.UniqueName {

+	return PodTemplateSpecNodeName(n.PodTemplateSpec, n.OwnerName)

+}

+

+func (*PodTemplateSpecNode) Kind() string {

+	return PodTemplateSpecNodeKind

+}

@@ -14,6 +14,7 @@ import (

 	"github.com/openshift/origin/pkg/api/graph"

 	graphveneers "github.com/openshift/origin/pkg/api/graph/veneers"

+	kubeedges "github.com/openshift/origin/pkg/api/kubegraph"

 	kubegraph "github.com/openshift/origin/pkg/api/kubegraph/nodes"

 	buildapi "github.com/openshift/origin/pkg/build/api"

 	buildedges "github.com/openshift/origin/pkg/build/graph"

@@ -80,7 +81,7 @@ func (d *ProjectStatusDescriber) Describe(namespace, name string) (string, error

 	}

 	for i := range svcs.Items {

 		service := kubegraph.EnsureServiceNode(g, &svcs.Items[i])

-		deployedges.AddFullfillingDeploymentConfigEdges(g, service)

+		kubeedges.AddExposedPodTemplateSpecEdges(g, service)

 	}

 	groups := graphveneers.ServiceAndDeploymentGroups(g)

@@ -6,10 +6,8 @@ import (

 	"github.com/gonum/graph"

 	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"

-	"github.com/GoogleCloudPlatform/kubernetes/pkg/labels"

 	osgraph "github.com/openshift/origin/pkg/api/graph"

-	kubegraph "github.com/openshift/origin/pkg/api/kubegraph/nodes"

 	deploygraph "github.com/openshift/origin/pkg/deploy/graph/nodes"

 	deployutil "github.com/openshift/origin/pkg/deploy/util"

 	imagegraph "github.com/openshift/origin/pkg/image/graph/nodes"

@@ -18,41 +16,8 @@ import (

 const (

 	TriggersDeploymentEdgeKind = "TriggersDeployment"

 	UsedInDeploymentEdgeKind   = "UsedInDeployment"

-

-	ExposedThroughServiceEdgeKind = "ExposedThroughService"

 )

-// AddFullfillingDeploymentConfigEdges ensures that a directed edge exists between all deployment configs and the

-// services that expose them (via label selectors).

-func AddFullfillingDeploymentConfigEdges(g osgraph.MutableUniqueGraph, node *kubegraph.ServiceNode) *kubegraph.ServiceNode {

-	if node.Service.Spec.Selector == nil {

-		return node

-	}

-	query := labels.SelectorFromSet(node.Service.Spec.Selector)

-	for _, n := range g.(graph.Graph).NodeList() {

-		switch target := n.(type) {

-		case *deploygraph.DeploymentConfigNode:

-			template := target.DeploymentConfig.Template.ControllerTemplate.Template

-			if template == nil {

-				continue

-			}

-			if query.Matches(labels.Set(template.Labels)) {

-				g.AddEdge(target, node, ExposedThroughServiceEdgeKind)

-			}

-		}

-	}

-

-	return node

-}

-

-func AddAllFullfillingDeploymentConfigEdges(g osgraph.MutableUniqueGraph) {

-	for _, node := range g.(graph.Graph).NodeList() {

-		if serviceNode, ok := node.(*kubegraph.ServiceNode); ok {

-			AddFullfillingDeploymentConfigEdges(g, serviceNode)

-		}

-	}

-}

-

 // AddTriggerEdges creates edges that point to named Docker image repositories for each image used in the deployment.

 func AddTriggerEdges(g osgraph.MutableUniqueGraph, node *deploygraph.DeploymentConfigNode) *deploygraph.DeploymentConfigNode {

 	rcTemplate := node.DeploymentConfig.Template.ControllerTemplate.Template

@@ -4,16 +4,23 @@ import (

 	"github.com/gonum/graph"

 	osgraph "github.com/openshift/origin/pkg/api/graph"

+	kubegraph "github.com/openshift/origin/pkg/api/kubegraph/nodes"

 	depoyapi "github.com/openshift/origin/pkg/deploy/api"

 )

 // EnsureDeploymentConfigNode adds the provided deployment config to the graph if it does not exist

-func EnsureDeploymentConfigNode(g osgraph.MutableUniqueGraph, config *depoyapi.DeploymentConfig) *DeploymentConfigNode {

-	return osgraph.EnsureUnique(

+func EnsureDeploymentConfigNode(g osgraph.MutableUniqueGraph, dc *depoyapi.DeploymentConfig) *DeploymentConfigNode {

+	dcName := DeploymentConfigNodeName(dc)

+	dcNode := osgraph.EnsureUnique(

 		g,

-		DeploymentConfigNodeName(config),

+		dcName,

 		func(node osgraph.Node) graph.Node {

-			return &DeploymentConfigNode{Node: node, DeploymentConfig: config}

+			return &DeploymentConfigNode{Node: node, DeploymentConfig: dc}

 		},

 	).(*DeploymentConfigNode)

+

+	rcSpecNode := kubegraph.EnsureReplicationControllerSpecNode(g, &dc.Template.ControllerTemplate, dcName)

+	g.AddEdge(dcNode, rcSpecNode, osgraph.ContainsEdgeKind)

+

+	return dcNode