Show PetSets in oc status

Make a minor change to prepare for generic controller references (since
PetSets and RCs could conflict over pods).

Author: smarterclayton

pkg/api/graph/graphview/dc_pipeline.go

@@ -80,5 +80,5 @@ type SortedDeploymentConfigPipeline []DeploymentConfigPipeline
 func (m SortedDeploymentConfigPipeline) Len() int      { return len(m) }
 func (m SortedDeploymentConfigPipeline) Swap(i, j int) { m[i], m[j] = m[j], m[i] }
 func (m SortedDeploymentConfigPipeline) Less(i, j int) bool {
-	return CompareObjectMeta(&m[i].Deployment.ObjectMeta, &m[j].Deployment.ObjectMeta)
+	return CompareObjectMeta(&m[i].Deployment.DeploymentConfig.ObjectMeta, &m[j].Deployment.DeploymentConfig.ObjectMeta)
 }

pkg/api/graph/graphview/petset.go

@@ -0,0 +1,51 @@
+package graphview
+
+import (
+	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"
+)
+
+type PetSet struct {
+	PetSet *kubegraph.PetSetNode
+
+	OwnedPods   []*kubegraph.PodNode
+	CreatedPods []*kubegraph.PodNode
+
+	// TODO: handle conflicting once controller refs are present, not worth it yet
+}
+
+// AllPetSets returns all the PetSets that aren't in the excludes set and the set of covered NodeIDs
+func AllPetSets(g osgraph.Graph, excludeNodeIDs IntSet) ([]PetSet, IntSet) {
+	covered := IntSet{}
+	views := []PetSet{}
+
+	for _, uncastNode := range g.NodesByKind(kubegraph.PetSetNodeKind) {
+		if excludeNodeIDs.Has(uncastNode.ID()) {
+			continue
+		}
+
+		view, covers := NewPetSet(g, uncastNode.(*kubegraph.PetSetNode))
+		covered.Insert(covers.List()...)
+		views = append(views, view)
+	}
+
+	return views, covered
+}
+
+// NewPetSet returns the PetSet and a set of all the NodeIDs covered by the PetSet
+func NewPetSet(g osgraph.Graph, node *kubegraph.PetSetNode) (PetSet, IntSet) {
+	covered := IntSet{}
+	covered.Insert(node.ID())
+
+	view := PetSet{}
+	view.PetSet = node
+
+	for _, uncastPodNode := range g.PredecessorNodesByEdgeKind(node, kubeedges.ManagedByControllerEdgeKind) {
+		podNode := uncastPodNode.(*kubegraph.PodNode)
+		covered.Insert(podNode.ID())
+		view.OwnedPods = append(view.OwnedPods, podNode)
+	}
+
+	return view, covered
+}

pkg/api/graph/graphview/rc.go

@@ -60,13 +60,13 @@ func NewReplicationController(g osgraph.Graph, rcNode *kubegraph.ReplicationCont
 	rcView.RC = rcNode
 	rcView.ConflictingRCIDToPods = map[int][]*kubegraph.PodNode{}
 
-	for _, uncastPodNode := range g.PredecessorNodesByEdgeKind(rcNode, kubeedges.ManagedByRCEdgeKind) {
+	for _, uncastPodNode := range g.PredecessorNodesByEdgeKind(rcNode, kubeedges.ManagedByControllerEdgeKind) {
 		podNode := uncastPodNode.(*kubegraph.PodNode)
 		covered.Insert(podNode.ID())
 		rcView.OwnedPods = append(rcView.OwnedPods, podNode)
 
 		// check to see if this pod is managed by more than one RC
-		uncastOwningRCs := g.SuccessorNodesByEdgeKind(podNode, kubeedges.ManagedByRCEdgeKind)
+		uncastOwningRCs := g.SuccessorNodesByEdgeKind(podNode, kubeedges.ManagedByControllerEdgeKind)
 		if len(uncastOwningRCs) > 1 {
 			for _, uncastOwningRC := range uncastOwningRCs {
 				if uncastOwningRC.ID() == rcNode.ID() {

pkg/api/graph/graphview/service_group.go

@@ -21,10 +21,13 @@ type ServiceGroup struct {
 
 	DeploymentConfigPipelines []DeploymentConfigPipeline
 	ReplicationControllers    []ReplicationController
+	PetSets                   []PetSet
 
-	FulfillingDCs  []*deploygraph.DeploymentConfigNode
-	FulfillingRCs  []*kubegraph.ReplicationControllerNode
-	FulfillingPods []*kubegraph.PodNode
+	// TODO: this has to stop
+	FulfillingPetSets []*kubegraph.PetSetNode
+	FulfillingDCs     []*deploygraph.DeploymentConfigNode
+	FulfillingRCs     []*kubegraph.ReplicationControllerNode
+	FulfillingPods    []*kubegraph.PodNode
 
 	ExposingRoutes []*routegraph.RouteNode
 }
@@ -66,6 +69,8 @@ func NewServiceGroup(g osgraph.Graph, serviceNode *kubegraph.ServiceNode) (Servi
 			service.FulfillingRCs = append(service.FulfillingRCs, castContainer)
 		case *kubegraph.PodNode:
 			service.FulfillingPods = append(service.FulfillingPods, castContainer)
+		case *kubegraph.PetSetNode:
+			service.FulfillingPetSets = append(service.FulfillingPetSets, castContainer)
 		default:
 			utilruntime.HandleError(fmt.Errorf("unrecognized container: %v", castContainer))
 		}
@@ -97,6 +102,13 @@ func NewServiceGroup(g osgraph.Graph, serviceNode *kubegraph.ServiceNode) (Servi
 		service.ReplicationControllers = append(service.ReplicationControllers, rcView)
 	}
 
+	for _, fulfillingPetSet := range service.FulfillingPetSets {
+		view, covers := NewPetSet(g, fulfillingPetSet)
+
+		covered.Insert(covers.List()...)
+		service.PetSets = append(service.PetSets, view)
+	}
+
 	for _, fulfillingPod := range service.FulfillingPods {
 		_, podCovers := NewPod(g, fulfillingPod)
 		covered.Insert(podCovers.List()...)

pkg/api/graph/graphview/veneering_test.go

@@ -78,7 +78,7 @@ func TestBareRCGroup(t *testing.T) {
 
 	kubeedges.AddAllExposedPodTemplateSpecEdges(g)
 	kubeedges.AddAllExposedPodEdges(g)
-	kubeedges.AddAllManagedByRCPodEdges(g)
+	kubeedges.AddAllManagedByControllerPodEdges(g)
 
 	coveredNodes := IntSet{}
 
@@ -399,7 +399,7 @@ func TestGraph(t *testing.T) {
 	}
 
 	for _, bareDCPipeline := range bareDCPipelines {
-		t.Logf("from %s", bareDCPipeline.Deployment.Name)
+		t.Logf("from %s", bareDCPipeline.Deployment.DeploymentConfig.Name)
 		for _, path := range bareDCPipeline.Images {
 			t.Logf("  %v", path)
 		}
@@ -413,7 +413,7 @@ func TestGraph(t *testing.T) {
 		indent := "  "
 
 		for _, deployment := range serviceGroup.DeploymentConfigPipelines {
-			t.Logf("%sdeployment %s", indent, deployment.Deployment.Name)
+			t.Logf("%sdeployment %s", indent, deployment.Deployment.DeploymentConfig.Name)
 			for _, image := range deployment.Images {
 				t.Logf("%s  image %s", indent, image.Image.ImageSpec())
 				if image.Build != nil {

pkg/api/kubegraph/analysis/rc.go

@@ -21,11 +21,11 @@ func FindDuelingReplicationControllers(g osgraph.Graph, f osgraph.Namer) []osgra
 	for _, uncastRCNode := range g.NodesByKind(kubegraph.ReplicationControllerNodeKind) {
 		rcNode := uncastRCNode.(*kubegraph.ReplicationControllerNode)
 
-		for _, uncastPodNode := range g.PredecessorNodesByEdgeKind(rcNode, kubeedges.ManagedByRCEdgeKind) {
+		for _, uncastPodNode := range g.PredecessorNodesByEdgeKind(rcNode, kubeedges.ManagedByControllerEdgeKind) {
 			podNode := uncastPodNode.(*kubegraph.PodNode)
 
 			// check to see if this pod is managed by more than one RC
-			uncastOwningRCs := g.SuccessorNodesByEdgeKind(podNode, kubeedges.ManagedByRCEdgeKind)
+			uncastOwningRCs := g.SuccessorNodesByEdgeKind(podNode, kubeedges.ManagedByControllerEdgeKind)
 			if len(uncastOwningRCs) > 1 {
 				involvedRCNames := []string{}
 				relatedNodes := []graph.Node{uncastPodNode}

pkg/api/kubegraph/analysis/rc_test.go

@@ -14,7 +14,7 @@ func TestDuelingRC(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 
-	kubeedges.AddAllManagedByRCPodEdges(g)
+	kubeedges.AddAllManagedByControllerPodEdges(g)
 
 	markers := FindDuelingReplicationControllers(g, osgraph.DefaultNamer)
 	if e, a := 2, len(markers); e != a {

pkg/api/kubegraph/edge_test.go

@@ -8,6 +8,8 @@ import (
 
 	kapi "k8s.io/kubernetes/pkg/api"
 	_ "k8s.io/kubernetes/pkg/api/install"
+	"k8s.io/kubernetes/pkg/api/unversioned"
+	kapps "k8s.io/kubernetes/pkg/apis/apps"
 	"k8s.io/kubernetes/pkg/apis/autoscaling"
 	"k8s.io/kubernetes/pkg/runtime"
 
@@ -38,6 +40,14 @@ func TestNamespaceEdgeMatching(t *testing.T) {
 		rc.Spec.Selector = map[string]string{"a": "1"}
 		kubegraph.EnsureReplicationControllerNode(g, rc)
 
+		p := &kapps.PetSet{}
+		p.Namespace = namespace
+		p.Name = "the-petset"
+		p.Spec.Selector = &unversioned.LabelSelector{
+			MatchLabels: map[string]string{"a": "1"},
+		}
+		kubegraph.EnsurePetSetNode(g, p)
+
 		svc := &kapi.Service{}
 		svc.Namespace = namespace
 		svc.Name = "the-svc"
@@ -49,7 +59,7 @@ func TestNamespaceEdgeMatching(t *testing.T) {
 	fn("other", g)
 	AddAllExposedPodEdges(g)
 	AddAllExposedPodTemplateSpecEdges(g)
-	AddAllManagedByRCPodEdges(g)
+	AddAllManagedByControllerPodEdges(g)
 
 	for _, edge := range g.Edges() {
 		nsTo, err := namespaceFor(edge.To())
@@ -79,6 +89,10 @@ func namespaceFor(node graph.Node) (string, error) {
 		return node.(*kubegraph.PodSpecNode).Namespace, nil
 	case *kapi.ReplicationControllerSpec:
 		return node.(*kubegraph.ReplicationControllerSpecNode).Namespace, nil
+	case *kapps.PetSetSpec:
+		return node.(*kubegraph.PetSetSpecNode).Namespace, nil
+	case *kapi.PodTemplateSpec:
+		return node.(*kubegraph.PodTemplateSpecNode).Namespace, nil
 	default:
 		return "", fmt.Errorf("unknown object: %#v", obj)
 	}

pkg/api/kubegraph/edges.go

@@ -20,8 +20,8 @@ import (
 const (
 	// ExposedThroughServiceEdgeKind goes from a PodTemplateSpec or a Pod to Service.  The head should make the service's selector.
 	ExposedThroughServiceEdgeKind = "ExposedThroughService"
-	// ManagedByRCEdgeKind goes from Pod to ReplicationController when the Pod satisfies the ReplicationController's label selector
-	ManagedByRCEdgeKind = "ManagedByRC"
+	// ManagedByControllerEdgeKind goes from Pod to controller when the Pod satisfies a controller's label selector
+	ManagedByControllerEdgeKind = "ManagedByController"
 	// MountedSecretEdgeKind goes from PodSpec to Secret indicating that is or will be a request to mount a volume with the Secret.
 	MountedSecretEdgeKind = "MountedSecret"
 	// MountableSecretEdgeKind goes from ServiceAccount to Secret indicating that the SA allows the Secret to be mounted
@@ -91,31 +91,36 @@ func AddAllExposedPodEdges(g osgraph.MutableUniqueGraph) {
 	}
 }
 
-// AddManagedByRCPodEdges ensures that a directed edge exists between an RC and all the pods
+// AddManagedByControllerPodEdges ensures that a directed edge exists between a controller and all the pods
 // in the graph that match the label selector
-func AddManagedByRCPodEdges(g osgraph.MutableUniqueGraph, rcNode *kubegraph.ReplicationControllerNode) {
-	if rcNode.Spec.Selector == nil {
+func AddManagedByControllerPodEdges(g osgraph.MutableUniqueGraph, to graph.Node, namespace string, selector map[string]string) {
+	if selector == nil {
 		return
 	}
-	query := labels.SelectorFromSet(rcNode.Spec.Selector)
+	query := labels.SelectorFromSet(selector)
 	for _, n := range g.(graph.Graph).Nodes() {
 		switch target := n.(type) {
 		case *kubegraph.PodNode:
-			if target.Namespace != rcNode.Namespace {
+			if target.Namespace != namespace {
 				continue
 			}
 			if query.Matches(labels.Set(target.Labels)) {
-				g.AddEdge(target, rcNode, ManagedByRCEdgeKind)
+				g.AddEdge(target, to, ManagedByControllerEdgeKind)
 			}
 		}
 	}
 }
 
-// AddAllManagedByRCPodEdges calls AddManagedByRCPodEdges for every ServiceNode in the graph
-func AddAllManagedByRCPodEdges(g osgraph.MutableUniqueGraph) {
+// AddAllManagedByControllerPodEdges calls AddManagedByControllerPodEdges for every node in the graph
+// TODO: should do this through an interface (selects pods)
+func AddAllManagedByControllerPodEdges(g osgraph.MutableUniqueGraph) {
 	for _, node := range g.(graph.Graph).Nodes() {
-		if rcNode, ok := node.(*kubegraph.ReplicationControllerNode); ok {
-			AddManagedByRCPodEdges(g, rcNode)
+		switch cast := node.(type) {
+		case *kubegraph.ReplicationControllerNode:
+			AddManagedByControllerPodEdges(g, cast, cast.ReplicationController.Namespace, cast.ReplicationController.Spec.Selector)
+		case *kubegraph.PetSetNode:
+			// TODO: refactor to handle expanded selectors (along with ReplicaSets and Deployments)
+			AddManagedByControllerPodEdges(g, cast, cast.PetSet.Namespace, cast.PetSet.Spec.Selector.MatchLabels)
 		}
 	}
 }

pkg/api/kubegraph/nodes/nodes.go

@@ -4,6 +4,7 @@ import (
 	"github.com/gonum/graph"
 
 	kapi "k8s.io/kubernetes/pkg/api"
+	kapps "k8s.io/kubernetes/pkg/apis/apps"
 	"k8s.io/kubernetes/pkg/apis/autoscaling"
 
 	osgraph "github.com/openshift/origin/pkg/api/graph"
@@ -154,3 +155,33 @@ func EnsureHorizontalPodAutoscalerNode(g osgraph.MutableUniqueGraph, hpa *autosc
 		},
 	).(*HorizontalPodAutoscalerNode)
 }
+
+func EnsurePetSetNode(g osgraph.MutableUniqueGraph, petset *kapps.PetSet) *PetSetNode {
+	nodeName := PetSetNodeName(petset)
+	node := osgraph.EnsureUnique(g,
+		nodeName,
+		func(node osgraph.Node) graph.Node {
+			return &PetSetNode{node, petset}
+		},
+	).(*PetSetNode)
+
+	specNode := EnsurePetSetSpecNode(g, &petset.Spec, petset.Namespace, nodeName)
+	g.AddEdge(node, specNode, osgraph.ContainsEdgeKind)
+
+	return node
+}
+
+func EnsurePetSetSpecNode(g osgraph.MutableUniqueGraph, spec *kapps.PetSetSpec, namespace string, ownerName osgraph.UniqueName) *PetSetSpecNode {
+	specName := PetSetSpecNodeName(spec, ownerName)
+	specNode := osgraph.EnsureUnique(g,
+		specName,
+		func(node osgraph.Node) graph.Node {
+			return &PetSetSpecNode{node, spec, namespace, ownerName}
+		},
+	).(*PetSetSpecNode)
+
+	ptSpecNode := EnsurePodTemplateSpecNode(g, &spec.Template, namespace, specName)
+	g.AddEdge(specNode, ptSpecNode, osgraph.ContainsEdgeKind)
+
+	return specNode
+}