Status checks if resource was upgraded

All resources now have a Definition to which they need to conform in
order to make an actual status check

Author: nebril

pkg/interfaces/interfaces.go

@@ -23,9 +23,10 @@ type ResourceStatus string
 
 // Possible ResourceStatus values
 const (
-	ResourceReady    ResourceStatus = "ready"
-	ResourceNotReady ResourceStatus = "not ready"
-	ResourceError    ResourceStatus = "error"
+	ResourceReady             ResourceStatus = "ready"
+	ResourceNotReady          ResourceStatus = "not ready"
+	ResourceError             ResourceStatus = "error"
+	ResourceWaitingForUpgrade ResourceStatus = "waiting for upgrade"
 )
 
 // DefaultFlowName is the name of default flow (main dependency graph)
@@ -39,6 +40,7 @@ type BaseResource interface {
 	Create() error
 	Delete() error
 	Meta(string) interface{}
+	EqualToDefinition(interface{}) bool
 }
 
 // DependencyReport is a report of a single dependency of a node in graph

pkg/mocks/countingresource.go

@@ -80,6 +80,11 @@ func (c *CountingResource) NewExisting(name string, _ client.Interface) interfac
 	return report.SimpleReporter{BaseResource: NewResource(name, interfaces.ResourceReady)}
 }
 
+// EqualToDefinition returns is false
+func (c *CountingResource) EqualToDefinition(_ interface{}) bool {
+	return false
+}
+
 // NewCountingResource creates new instance of CountingResource
 func NewCountingResource(key string, counter *CounterWithMemo, timeout time.Duration) *CountingResource {
 	return &CountingResource{

pkg/mocks/daemonsets.go

@@ -14,7 +14,10 @@
 
 package mocks
 
-import extbeta1 "k8s.io/client-go/pkg/apis/extensions/v1beta1"
+import (
+	extbeta1 "k8s.io/client-go/pkg/apis/extensions/v1beta1"
+	"k8s.io/client-go/pkg/runtime"
+)
 
 type daemonSetClient struct {
 }
@@ -33,3 +36,11 @@ func MakeDaemonSet(name string) *extbeta1.DaemonSet {
 
 	return daemonSet
 }
+
+func DaemonSets(names ...string) runtime.Object {
+	var daemonsets []extbeta1.DaemonSet
+	for _, name := range names {
+		daemonsets = append(daemonsets, *MakeDaemonSet(name))
+	}
+	return &extbeta1.DaemonSetList{Items: daemonsets}
+}

pkg/mocks/resource.go

@@ -67,6 +67,11 @@ func (c *Resource) NewExisting(name string, _ client.Interface) interfaces.BaseR
 	return NewResource(name, "ready")
 }
 
+// EqualToDefinition returns is false
+func (c *Resource) EqualToDefinition(_ interface{}) bool {
+	return false
+}
+
 // NewResource creates new instance of Resource
 func NewResource(key string, status interfaces.ResourceStatus) *Resource {
 	return NewResourceWithMeta(key, status, nil)

pkg/resources/common.go

@@ -21,12 +21,16 @@ import (
 	"strconv"
 	"strings"
 
+	"k8s.io/client-go/pkg/api/v1"
+	appsbeta1 "k8s.io/client-go/pkg/apis/apps/v1beta1"
+	batchv1 "k8s.io/client-go/pkg/apis/batch/v1"
+	extbeta1 "k8s.io/client-go/pkg/apis/extensions/v1beta1"
+	"k8s.io/client-go/pkg/labels"
+
 	"github.com/Mirantis/k8s-AppController/pkg/client"
+	appsalpha1 "github.com/Mirantis/k8s-AppController/pkg/client/petsets/apis/apps/v1alpha1"
 	"github.com/Mirantis/k8s-AppController/pkg/copier"
 	"github.com/Mirantis/k8s-AppController/pkg/interfaces"
-
-	"k8s.io/client-go/pkg/api/v1"
-	"k8s.io/client-go/pkg/labels"
 )
 
 func init() {
@@ -52,7 +56,8 @@ func init() {
 
 // Base is a base struct that contains data common for all resources
 type Base struct {
-	meta map[string]interface{}
+	Definition client.ResourceDefinition
+	meta       map[string]interface{}
 }
 
 // Meta returns metadata parameter with given name, or empty string,
@@ -71,6 +76,13 @@ func (b Base) Meta(paramName string) interface{} {
 	return val
 }
 
+// EqualToDefinition returns false since there is no definition to compare Base resource against.
+func (b Base) EqualToDefinition(_ interface{}) bool {
+	//TODO: remove
+	panic("trololo")
+	return false
+}
+
 // KindToResourceTemplate is a map mapping kind strings to empty structs representing proper resources
 // structs implement interfaces.ResourceTemplate
 var KindToResourceTemplate = map[string]interfaces.ResourceTemplate{}
@@ -154,7 +166,9 @@ func podsStateFromLabels(apiClient client.Interface, objLabels map[string]string
 	resources := make([]interfaces.BaseResource, 0, len(pods.Items))
 	for _, pod := range pods.Items {
 		p := pod
-		resources = append(resources, createNewPod(&p, apiClient.Pods(), nil))
+		//resources = append(resources, createNewPod(&p, apiClient.Pods(), nil))
+		def := MakeDefinition(&p)
+		resources = append(resources, createNewPod(def, apiClient.Pods()))
 	}
 
 	status, err := resourceListStatus(resources)
@@ -215,3 +229,38 @@ func parametrizeResource(resource interface{}, context interfaces.GraphContext,
 		return value
 	}, append(replaceIn, "ObjectMeta")...)
 }
+
+func MakeDefinition(object interface{}) client.ResourceDefinition {
+	result := client.ResourceDefinition{}
+
+	switch object.(type) {
+	case *v1.ConfigMap:
+		result.ConfigMap = object.(*v1.ConfigMap)
+	case *extbeta1.DaemonSet:
+		result.DaemonSet = object.(*extbeta1.DaemonSet)
+	case *extbeta1.Deployment:
+		result.Deployment = object.(*extbeta1.Deployment)
+	case *batchv1.Job:
+		result.Job = object.(*batchv1.Job)
+	case *v1.PersistentVolumeClaim:
+		result.PersistentVolumeClaim = object.(*v1.PersistentVolumeClaim)
+	case *appsalpha1.PetSet:
+		result.PetSet = object.(*appsalpha1.PetSet)
+	case *v1.Pod:
+		result.Pod = object.(*v1.Pod)
+	case *extbeta1.ReplicaSet:
+		result.ReplicaSet = object.(*extbeta1.ReplicaSet)
+	case *v1.Secret:
+		result.Secret = object.(*v1.Secret)
+	case *v1.Service:
+		result.Service = object.(*v1.Service)
+	case *v1.ServiceAccount:
+		result.ServiceAccount = object.(*v1.ServiceAccount)
+	case *appsbeta1.StatefulSet:
+		result.StatefulSet = object.(*appsbeta1.StatefulSet)
+	default:
+		//TODO: remove it
+		panic("no type for definition")
+	}
+	return result
+}

pkg/resources/configmap.go

@@ -15,7 +15,9 @@
 package resources
 
 import (
+	"fmt"
 	"log"
+	"reflect"
 
 	"github.com/Mirantis/k8s-AppController/pkg/client"
 	"github.com/Mirantis/k8s-AppController/pkg/interfaces"
@@ -58,8 +60,21 @@ func (configMapTemplateFactory) Kind() string {
 
 // New returns configMap controller for new resource based on resource definition
 func (configMapTemplateFactory) New(def client.ResourceDefinition, c client.Interface, gc interfaces.GraphContext) interfaces.Resource {
-	cm := parametrizeResource(def.ConfigMap, gc, configMapParamFields).(*v1.ConfigMap)
-	return report.SimpleReporter{BaseResource: newConfigMap{Base: Base{def.Meta}, ConfigMap: cm, Client: c.ConfigMaps()}}
+	def.ConfigMap = parametrizeResource(def.ConfigMap, gc, configMapParamFields).(*v1.ConfigMap)
+	return createNewConfigMap(def, c)
+}
+
+func createNewConfigMap(def client.ResourceDefinition, c client.Interface) interfaces.Resource {
+	return report.SimpleReporter{
+		BaseResource: newConfigMap{
+			Base: Base{
+				Definition: def,
+				meta:       def.Meta,
+			},
+			ConfigMap: def.ConfigMap,
+			Client:    c.ConfigMaps(),
+		},
+	}
 }
 
 // NewExisting returns configMap controller for existing resource by its name
@@ -76,18 +91,25 @@ func (c newConfigMap) Key() string {
 	return configMapKey(c.ConfigMap.Name)
 }
 
-func configMapStatus(c corev1.ConfigMapInterface, name string) (interfaces.ResourceStatus, error) {
-	_, err := c.Get(name)
+// Status returns ConfigMap status. interfaces.ResourceReady means that its dependencies can be created
+func (c newConfigMap) Status(meta map[string]string) (interfaces.ResourceStatus, error) {
+	cm, err := c.Client.Get(c.ConfigMap.Name)
 	if err != nil {
 		return interfaces.ResourceError, err
 	}
 
+	if !c.EqualToDefinition(cm) {
+		return interfaces.ResourceWaitingForUpgrade, fmt.Errorf(string(interfaces.ResourceWaitingForUpgrade))
+	}
+
 	return interfaces.ResourceReady, nil
 }
 
-// Status returns configMap status. interfaces.ResourceReady means that its dependencies can be created
-func (c newConfigMap) Status(meta map[string]string) (interfaces.ResourceStatus, error) {
-	return configMapStatus(c.Client, c.ConfigMap.Name)
+// EqualToDefinition checks if definition in object is compatible with provided object
+func (c newConfigMap) EqualToDefinition(configmap interface{}) bool {
+	cm := configmap.(*v1.ConfigMap)
+
+	return reflect.DeepEqual(cm.Data, c.Definition.ConfigMap.Data) && reflect.DeepEqual(cm.ObjectMeta, c.Definition.ConfigMap.ObjectMeta)
 }
 
 // Create looks for DaemonSet in k8s and creates it if not present
@@ -110,9 +132,14 @@ func (c existingConfigMap) Key() string {
 	return configMapKey(c.Name)
 }
 
-// Status returns configMap status. interfaces.ResourceReady means that its dependencies can be created
+// Status returns ConfigMap status. interfaces.ResourceReady means that its dependencies can be created
 func (c existingConfigMap) Status(meta map[string]string) (interfaces.ResourceStatus, error) {
-	return configMapStatus(c.Client, c.Name)
+	_, err := c.Client.Get(c.Name)
+	if err != nil {
+		return interfaces.ResourceError, err
+	}
+
+	return interfaces.ResourceReady, nil
 }
 
 // Create looks for existing configMap and returns an error if there is no such configMap in a cluster

pkg/resources/configmap_test.go

@@ -23,8 +23,13 @@ import (
 
 // TestConfigMapSuccessCheck checks status of ready ConfigMap
 func TestConfigMapSuccessCheck(t *testing.T) {
-	c := mocks.NewClient(mocks.ConfigMaps("notfail"))
-	status, err := configMapStatus(c.ConfigMaps(), "notfail")
+	name := "notfail"
+	client := mocks.NewClient(mocks.ConfigMaps(name))
+
+	def := MakeDefinition(mocks.MakeConfigMap(name))
+	tested := createNewConfigMap(def, client)
+
+	status, err := tested.Status(nil)
 
 	if err != nil {
 		t.Error(err)
@@ -37,8 +42,13 @@ func TestConfigMapSuccessCheck(t *testing.T) {
 
 // TestConfigMapFailCheck checks status of not existing ConfigMap
 func TestConfigMapFailCheck(t *testing.T) {
-	c := mocks.NewClient(mocks.ConfigMaps())
-	status, err := configMapStatus(c.ConfigMaps(), "fail")
+	name := "fail"
+	client := mocks.NewClient()
+
+	def := MakeDefinition(mocks.MakeConfigMap(name))
+	tested := createNewConfigMap(def, client)
+
+	status, err := tested.Status(nil)
 
 	if err == nil {
 		t.Error("error not found, expected error")
@@ -48,3 +58,27 @@ func TestConfigMapFailCheck(t *testing.T) {
 		t.Errorf("status should be `error`, is `%s` instead.", status)
 	}
 }
+
+// TestConfigMapUpgraded tests status behaviour with resource definition differing from object in cluster
+func TestConfigMapUpgraded(t *testing.T) {
+	name := "notfail"
+	client := mocks.NewClient(mocks.ConfigMaps(name))
+
+	def := MakeDefinition(mocks.MakeConfigMap(name))
+
+	//Make definition differ from client version
+	def.ConfigMap.ObjectMeta.Labels = map[string]string{
+		"trolo": "lolo",
+	}
+
+	tested := createNewConfigMap(def, client)
+
+	status, err := tested.Status(nil)
+
+	if err == nil {
+		t.Error("Error not found, expected error")
+	}
+	if status != interfaces.ResourceWaitingForUpgrade {
+		t.Errorf("Status should be `waiting for upgrade`, is `%s` instead.", status)
+	}
+}

pkg/resources/daemonset.go

@@ -15,7 +15,9 @@
 package resources
 
 import (
+	"fmt"
 	"log"
+	"reflect"
 
 	"github.com/Mirantis/k8s-AppController/pkg/client"
 	"github.com/Mirantis/k8s-AppController/pkg/interfaces"
@@ -58,8 +60,8 @@ func (daemonSetTemplateFactory) Kind() string {
 
 // New returns DaemonSets controller for new resource based on resource definition
 func (d daemonSetTemplateFactory) New(def client.ResourceDefinition, c client.Interface, gc interfaces.GraphContext) interfaces.Resource {
-	newDaemonSet := parametrizeResource(def.DaemonSet, gc, daemonSetParamFields).(*extbeta1.DaemonSet)
-	return report.SimpleReporter{BaseResource: DaemonSet{Base: Base{def.Meta}, DaemonSet: newDaemonSet, Client: c.DaemonSets()}}
+	def.DaemonSet = parametrizeResource(def.DaemonSet, gc, daemonSetParamFields).(*extbeta1.DaemonSet)
+	return createNewDaemonSet(def, c.DaemonSets())
 }
 
 // NewExisting returns DaemonSets controller for existing resource by its name
@@ -71,12 +73,8 @@ func daemonSetKey(name string) string {
 	return "daemonset/" + name
 }
 
-func daemonSetStatus(d v1beta1.DaemonSetInterface, name string) (interfaces.ResourceStatus, error) {
-	daemonSet, err := d.Get(name)
-	if err != nil {
-		return interfaces.ResourceError, err
-	}
-	if daemonSet.Status.CurrentNumberScheduled == daemonSet.Status.DesiredNumberScheduled {
+func daemonSetStatus(d *extbeta1.DaemonSet) (interfaces.ResourceStatus, error) {
+	if d.Status.CurrentNumberScheduled == d.Status.DesiredNumberScheduled {
 		return interfaces.ResourceReady, nil
 	}
 	return interfaces.ResourceNotReady, nil
@@ -89,7 +87,22 @@ func (d DaemonSet) Key() string {
 
 // Status returns DaemonSet status. interfaces.ResourceReady means that its dependencies can be created
 func (d DaemonSet) Status(meta map[string]string) (interfaces.ResourceStatus, error) {
-	return daemonSetStatus(d.Client, d.DaemonSet.Name)
+	ds, err := d.Client.Get(d.DaemonSet.Name)
+	if err != nil {
+		return interfaces.ResourceError, err
+	}
+
+	if !d.EqualToDefinition(ds) {
+		return interfaces.ResourceWaitingForUpgrade, fmt.Errorf(string(interfaces.ResourceWaitingForUpgrade))
+	}
+	return daemonSetStatus(ds)
+}
+
+// EqualToDefinition returns whether the resource has the same values as provided object
+func (d DaemonSet) EqualToDefinition(daemonset interface{}) bool {
+	ds := daemonset.(*extbeta1.DaemonSet)
+
+	return reflect.DeepEqual(ds.ObjectMeta, d.DaemonSet.ObjectMeta) && reflect.DeepEqual(ds.Spec, d.DaemonSet.Spec)
 }
 
 // Create looks for DaemonSet in k8s and creates it if not present
@@ -107,6 +120,19 @@ func (d DaemonSet) Delete() error {
 	return d.Client.Delete(d.DaemonSet.Name, &v1.DeleteOptions{})
 }
 
+func createNewDaemonSet(def client.ResourceDefinition, client v1beta1.DaemonSetInterface) interfaces.Resource {
+	return report.SimpleReporter{
+		BaseResource: DaemonSet{
+			Base: Base{
+				Definition: def,
+				meta:       def.Meta,
+			},
+			DaemonSet: def.DaemonSet,
+			Client:    client,
+		},
+	}
+}
+
 // ExistingDaemonSet is a wrapper for K8s DaemonSet object which is deployed on a cluster before AppController
 type ExistingDaemonSet struct {
 	Base
@@ -121,7 +147,12 @@ func (d ExistingDaemonSet) Key() string {
 
 // Status returns DaemonSet status. interfaces.ResourceReady means that its dependencies can be created
 func (d ExistingDaemonSet) Status(meta map[string]string) (interfaces.ResourceStatus, error) {
-	return daemonSetStatus(d.Client, d.Name)
+	ds, err := d.Client.Get(d.Name)
+	if err != nil {
+		return interfaces.ResourceError, err
+	}
+
+	return daemonSetStatus(ds)
 }
 
 // Create looks for existing DaemonSet and returns error if there is no such DaemonSet