func TestHPARCEdges(t *testing.T) {
hpa := &autoscaling.HorizontalPodAutoscaler{}
hpa.Namespace = "test-ns"
hpa.Name = "test-hpa"
hpa.Spec = autoscaling.HorizontalPodAutoscalerSpec{
ScaleTargetRef: autoscaling.CrossVersionObjectReference{
Name: "test-rc",
Kind: "ReplicationController",
},
}
rc := &kapi.ReplicationController{}
rc.Name = "test-rc"
rc.Namespace = "test-ns"
g := osgraph.New()
hpaNode := kubegraph.EnsureHorizontalPodAutoscalerNode(g, hpa)
rcNode := kubegraph.EnsureReplicationControllerNode(g, rc)
AddHPAScaleRefEdges(g)
if edge := g.Edge(hpaNode, rcNode); edge == nil {
t.Fatalf("edge between HPA and RC missing")
} else {
if !g.EdgeKinds(edge).Has(ScalingEdgeKind) {
t.Errorf("expected edge to have kind %v, got %v", ScalingEdgeKind, edge)
}
}
}
func (l *rcLoader) AddToGraph(g osgraph.Graph) error {
for i := range l.items {
kubegraph.EnsureReplicationControllerNode(g, &l.items[i])
}
return nil
}
// addReplicationControllersToGraph adds replication controllers to the graph.
//
// Edges are added to the graph from each replication controller to the images
// specified by its pod spec's list of containers, as long as the image is
// managed by OpenShift.
func addReplicationControllersToGraph(g graph.Graph, rcs *kapi.ReplicationControllerList) {
for i := range rcs.Items {
rc := &rcs.Items[i]
glog.V(4).Infof("Examining replication controller %s/%s", rc.Namespace, rc.Name)
rcNode := kubegraph.EnsureReplicationControllerNode(g, rc)
addPodSpecToGraph(g, &rc.Spec.Template.Spec, rcNode)
}
}
func TestNamespaceEdgeMatching(t *testing.T) {
g := osgraph.New()
fn := func(namespace string, g osgraph.Interface) {
pod := &kapi.Pod{}
pod.Namespace = namespace
pod.Name = "the-pod"
pod.Labels = map[string]string{"a": "1"}
kubegraph.EnsurePodNode(g, pod)
rc := &kapi.ReplicationController{}
rc.Namespace = namespace
rc.Name = "the-rc"
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"
svc.Spec.Selector = map[string]string{"a": "1"}
kubegraph.EnsureServiceNode(g, svc)
}
fn("ns", g)
fn("other", g)
AddAllExposedPodEdges(g)
AddAllExposedPodTemplateSpecEdges(g)
AddAllManagedByControllerPodEdges(g)
for _, edge := range g.Edges() {
nsTo, err := namespaceFor(edge.To())
if err != nil {
t.Fatal(err)
}
nsFrom, err := namespaceFor(edge.From())
if err != nil {
t.Fatal(err)
}
if nsFrom != nsTo {
t.Errorf("edge %#v crosses namespace: %s %s", edge, nsFrom, nsTo)
}
}
}
func loadReplicationControllers(g osgraph.Graph, graphLock sync.Mutex, namespace string, kclient kclient.Interface, client client.Interface) error {
rcs, err := kclient.ReplicationControllers(namespace).List(labels.Everything())
if err != nil {
return err
}
graphLock.Lock()
defer graphLock.Unlock()
for i := range rcs.Items {
kubegraph.EnsureReplicationControllerNode(g, &rcs.Items[i])
}
return nil
}
// Describe returns the description of the latest deployments for a config
func (d *LatestDeploymentsDescriber) Describe(namespace, name string) (string, error) {
var f formatter
config, err := d.client.getDeploymentConfig(namespace, name)
if err != nil {
return "", err
}
var deployments []kapi.ReplicationController
if d.count == -1 || d.count > 1 {
list, err := d.client.listDeployments(namespace, labels.Everything())
if err != nil && !kerrors.IsNotFound(err) {
return "", err
}
deployments = list.Items
} else {
deploymentName := deployutil.LatestDeploymentNameForConfig(config)
deployment, err := d.client.getDeployment(config.Namespace, deploymentName)
if err != nil && !kerrors.IsNotFound(err) {
return "", err
}
if deployment != nil {
deployments = []kapi.ReplicationController{*deployment}
}
}
g := graph.New()
dcNode := deploygraph.EnsureDeploymentConfigNode(g, config)
for i := range deployments {
kubegraph.EnsureReplicationControllerNode(g, &deployments[i])
}
deployedges.AddTriggerEdges(g, dcNode)
deployedges.AddDeploymentEdges(g, dcNode)
activeDeployment, inactiveDeployments := deployedges.RelevantDeployments(g, dcNode)
return tabbedString(func(out *tabwriter.Writer) error {
descriptions := describeDeployments(f, dcNode, activeDeployment, inactiveDeployments, d.count)
for i, description := range descriptions {
descriptions[i] = fmt.Sprintf("%v %v", name, description)
}
printLines(out, "", 0, descriptions...)
return nil
})
}
func TestNamespaceEdgeMatching(t *testing.T) {
g := osgraph.New()
fn := func(namespace string, g osgraph.Interface) {
dc := &api.DeploymentConfig{}
dc.Namespace = namespace
dc.Name = "the-dc"
dc.Spec.Selector = map[string]string{"a": "1"}
nodes.EnsureDeploymentConfigNode(g, dc)
rc := &kapi.ReplicationController{}
rc.Namespace = namespace
rc.Name = "the-rc"
rc.Annotations = map[string]string{api.DeploymentConfigAnnotation: "the-dc"}
kubegraph.EnsureReplicationControllerNode(g, rc)
}
fn("ns", g)
fn("other", g)
AddAllDeploymentEdges(g)
if len(g.Edges()) != 4 {
t.Fatal(g)
}
for _, edge := range g.Edges() {
nsTo, err := namespaceFor(edge.To())
if err != nil {
t.Fatal(err)
}
nsFrom, err := namespaceFor(edge.From())
if err != nil {
t.Fatal(err)
}
if nsFrom != nsTo {
t.Errorf("edge %#v crosses namespace: %s %s", edge, nsFrom, nsTo)
}
}
}
