WIP

Author: Jim Minter

pkg/template/apis/template/helpers.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"fmt"
 
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	kapi "k8s.io/kubernetes/pkg/api"
@@ -47,16 +48,42 @@ func AddObjectsToTemplate(template *Template, objects []runtime.Object, targetVe
 	return nil
 }
 
-// FilterTemplateInstanceCondition returns a new []TemplateInstanceCondition,
-// ensuring that it does not contain conditions of condType.
-func FilterTemplateInstanceCondition(conditions []TemplateInstanceCondition, condType TemplateInstanceConditionType) []TemplateInstanceCondition {
-	newConditions := make([]TemplateInstanceCondition, 0, len(conditions)+1)
+func (templateInstance *TemplateInstance) DeleteCondition(typ TemplateInstanceConditionType) {
+	newConditions := make([]TemplateInstanceCondition, 0, len(templateInstance.Status.Conditions))
 
-	for _, c := range conditions {
-		if c.Type != condType {
+	for _, c := range templateInstance.Status.Conditions {
+		if c.Type != typ {
 			newConditions = append(newConditions, c)
 		}
 	}
 
-	return newConditions
+	templateInstance.Status.Conditions = newConditions
+}
+
+func (templateInstance *TemplateInstance) HasCondition(typ TemplateInstanceConditionType, status kapi.ConditionStatus) bool {
+	for _, c := range templateInstance.Status.Conditions {
+		if c.Type == typ && c.Status == status {
+			return true
+		}
+	}
+	return false
+}
+
+func (templateInstance *TemplateInstance) SetCondition(condition TemplateInstanceCondition) {
+	condition.LastTransitionTime = metav1.Now()
+
+	for i, c := range templateInstance.Status.Conditions {
+		if c.Type == condition.Type {
+			if c.Message == condition.Message &&
+				c.Reason == condition.Reason &&
+				c.Status == condition.Status {
+				return
+			}
+
+			templateInstance.Status.Conditions[i] = condition
+			return
+		}
+	}
+
+	templateInstance.Status.Conditions = append(templateInstance.Status.Conditions, condition)
 }

pkg/template/controller/readiness.go

@@ -0,0 +1,99 @@
+package controller
+
+import (
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+	kapi "k8s.io/kubernetes/pkg/api"
+	"k8s.io/kubernetes/pkg/apis/apps"
+	"k8s.io/kubernetes/pkg/apis/batch"
+	"k8s.io/kubernetes/pkg/apis/extensions"
+	deploymentutil "k8s.io/kubernetes/pkg/controller/deployment/util"
+
+	deployapi "github.com/openshift/origin/pkg/deploy/apis/apps"
+)
+
+func checkDeploymentReadiness(obj runtime.Object) (bool, bool) {
+	d := obj.(*extensions.Deployment)
+
+	var progressing, available *extensions.DeploymentCondition
+	for i, condition := range d.Status.Conditions {
+		switch condition.Type {
+		case extensions.DeploymentProgressing:
+			progressing = &d.Status.Conditions[i]
+
+		case extensions.DeploymentAvailable:
+			available = &d.Status.Conditions[i]
+		}
+	}
+
+	ready := progressing != nil &&
+		progressing.Status == kapi.ConditionTrue &&
+		progressing.Reason == deploymentutil.NewRSAvailableReason &&
+		available != nil &&
+		available.Status == kapi.ConditionTrue
+
+	failed := progressing != nil && progressing.Status == kapi.ConditionFalse
+
+	return ready, failed
+}
+
+func checkDeploymentConfigReadiness(obj runtime.Object) (bool, bool) {
+	dc := obj.(*deployapi.DeploymentConfig)
+
+	var progressing, available *deployapi.DeploymentCondition
+	for i, condition := range dc.Status.Conditions {
+		switch condition.Type {
+		case deployapi.DeploymentProgressing:
+			progressing = &dc.Status.Conditions[i]
+
+		case deployapi.DeploymentAvailable:
+			available = &dc.Status.Conditions[i]
+		}
+	}
+
+	ready := progressing != nil &&
+		progressing.Status == kapi.ConditionTrue &&
+		progressing.Reason == deployapi.NewRcAvailableReason &&
+		available != nil &&
+		available.Status == kapi.ConditionTrue
+
+	failed := progressing != nil && progressing.Status == kapi.ConditionFalse
+
+	return ready, failed
+}
+
+func checkStatefulSetReadiness(obj runtime.Object) (bool, bool) {
+	ss := obj.(*apps.StatefulSet)
+
+	ready := ss.Status.ReadyReplicas == ss.Spec.Replicas
+	failed := false
+
+	return ready, failed
+}
+
+func checkJobReadiness(obj runtime.Object) (bool, bool) {
+	job := obj.(*batch.Job)
+
+	ready := job.Status.CompletionTime != nil
+	failed := job.Status.Failed > 0
+
+	return ready, failed
+}
+
+var readinessCheckers = map[schema.GroupKind]func(runtime.Object) (bool, bool){
+	apps.Kind("Deployment"):                  checkDeploymentReadiness,
+	extensions.Kind("Deployment"):            checkDeploymentReadiness,
+	deployapi.LegacyKind("DeploymentConfig"): checkDeploymentConfigReadiness,
+	deployapi.Kind("DeploymentConfig"):       checkDeploymentConfigReadiness,
+	batch.Kind("Job"):                        checkJobReadiness,
+	apps.Kind("StatefulSet"):                 checkStatefulSetReadiness,
+}
+
+func canCheckReadiness(ref kapi.ObjectReference) bool {
+	_, found := readinessCheckers[ref.GroupVersionKind().GroupKind()]
+	return found
+}
+
+func checkReadiness(ref kapi.ObjectReference, obj runtime.Object) (bool, bool) {
+	return readinessCheckers[ref.GroupVersionKind().GroupKind()](obj)
+}