diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 00000000..5657f6ea --- /dev/null +++ b/.dockerignore @@ -0,0 +1 @@ +vendor \ No newline at end of file diff --git a/.version b/.version index bc6ec852..b82608c0 100644 --- a/.version +++ b/.version @@ -1 +1 @@ -v0.0.36 +v0.1.0 diff --git a/Makefile b/Makefile index 184f9a02..5d312881 100644 --- a/Makefile +++ b/Makefile @@ -20,7 +20,7 @@ LDFLAGS = default: build test install: - "$(GLIDECMD)" install + "$(GLIDECMD)" install --strip-vendor build: "$(GOCMD)" build ${GOFLAGS} ${LDFLAGS} -o "${BINARY}" diff --git a/README.md b/README.md index 8cfd5644..2c8e600e 100644 --- a/README.md +++ b/README.md @@ -13,11 +13,11 @@ ## Problem -We would like to watch if some change happens in `ConfigMap` and/or `Secret`; then perform a rolling upgrade on relevant `Deployment`, `Daemonset` and `Statefulset` +We would like to watch if some change happens in `ConfigMap` and/or `Secret`; then perform a rolling upgrade on relevant `DeploymentConfig`, `Deployment`, `Daemonset` and `Statefulset` ## Solution -Reloader can watch changes in `ConfigMap` and `Secret` and do rolling upgrades on Pods with their associated `Deployments`, `Daemonsets` and `Statefulsets`. +Reloader can watch changes in `ConfigMap` and `Secret` and do rolling upgrades on Pods with their associated `DeploymentConfigs`, `Deployments`, `Daemonsets` and `Statefulsets`. ## How to use Reloader @@ -96,7 +96,7 @@ spec: ### NOTES - Reloader also supports [sealed-secrets](https://github.com/bitnami-labs/sealed-secrets). [Here](docs/Reloader-with-Sealed-Secrets.md) are the steps to use sealed-secrets with reloader. -- `reloader.stakater.com/auto: "true"` will only reload the pod, if the configmap or secret is used (as a volume mount or as an env) in `Deployment/Daemonsets/Statefulsets` +- `reloader.stakater.com/auto: "true"` will only reload the pod, if the configmap or secret is used (as a volume mount or as an env) in `DeploymentConfigs/Deployment/Daemonsets/Statefulsets` - `secret.reloader.stakater.com/reload` or `configmap.reloader.stakater.com/reload` annotation will reload the pod upon changes in specified configmap or secret, irrespective of the usage of configmap or secret. - you may override the auto annotation with the `--auto-annotation` flag - you may override the configmap annotation with the `--configmap-annotation` flag diff --git a/Reloader b/Reloader new file mode 100755 index 00000000..693921d4 Binary files /dev/null and b/Reloader differ diff --git a/build/package/Dockerfile.build b/build/package/Dockerfile.build index 517ee45e..1bfeb2ce 100644 --- a/build/package/Dockerfile.build +++ b/build/package/Dockerfile.build @@ -1,4 +1,4 @@ -FROM stakater/go-glide:1.9.3 +FROM stakater/go-glide:1.12.6 MAINTAINER "Stakater Team" RUN apk update @@ -11,7 +11,7 @@ RUN apk -v --update \ ADD . "$GOPATH/src/github.com/stakater/Reloader" RUN cd "$GOPATH/src/github.com/stakater/Reloader" && \ - glide update && \ + glide install --strip-vendor && \ CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -a --installsuffix cgo --ldflags="-s" -o /Reloader COPY build/package/Dockerfile.run / diff --git a/deployments/kubernetes/chart/reloader/templates/clusterrole.yaml b/deployments/kubernetes/chart/reloader/templates/clusterrole.yaml index 8075763e..f5d5c8ee 100644 --- a/deployments/kubernetes/chart/reloader/templates/clusterrole.yaml +++ b/deployments/kubernetes/chart/reloader/templates/clusterrole.yaml @@ -26,6 +26,18 @@ rules: - list - get - watch +{{- if .Capabilities.APIVersions.Has "apps.openshift.io/v1" }} + - apiGroups: + - "apps.openshift.io" + - "" + resources: + - deploymentconfigs + verbs: + - list + - get + - update + - patch +{{- end }} - apiGroups: - "apps" resources: diff --git a/deployments/kubernetes/chart/reloader/templates/role.yaml b/deployments/kubernetes/chart/reloader/templates/role.yaml index 90a348f6..cf23cb82 100644 --- a/deployments/kubernetes/chart/reloader/templates/role.yaml +++ b/deployments/kubernetes/chart/reloader/templates/role.yaml @@ -26,6 +26,18 @@ rules: - list - get - watch +{{- if .Capabilities.APIVersions.Has "apps.openshift.io/v1" }} + - apiGroups: + - "apps.openshift.io" + - "" + resources: + - deploymentconfigs + verbs: + - list + - get + - update + - patch +{{- end }} - apiGroups: - "apps" resources: diff --git a/glide.lock b/glide.lock index bc2e3f20..122c2c36 100644 --- a/glide.lock +++ b/glide.lock @@ -1,26 +1,12 @@ -hash: b6fe060028bdb1249ba2413746476c2550b267eeab3c166c36a86e000a8dd354 -updated: 2018-07-24T21:12:43.027181463+05:00 +hash: 0a37eeebda95f7ac050377c5b8ca8a6f7ab051ef66ba1752471090157e6a6ea2 +updated: 2019-07-03T21:04:13.576837+02:00 imports: - name: github.com/davecgh/go-spew version: 782f4967f2dc4564575ca782fe2d04090b5faca8 subpackages: - spew -- name: github.com/emicklei/go-restful - version: ff4f55a206334ef123e4f79bbf348980da81ca46 - subpackages: - - log -- name: github.com/emicklei/go-restful-swagger12 - version: dcef7f55730566d41eae5db10e7d6981829720f6 - name: github.com/ghodss/yaml version: 73d445a93680fa1a78ae23a5839bad48f32ba1ee -- name: github.com/go-openapi/jsonpointer - version: 46af16f9f7b149af66e5d1bd010e3574dc06de98 -- name: github.com/go-openapi/jsonreference - version: 13c6e3589ad90f49bd3e3bbe2c2cb3d7a4142272 -- name: github.com/go-openapi/spec - version: 6aced65f8501fe1217321abf0749d354824ba2ff -- name: github.com/go-openapi/swag - version: 1d0bd113de87027671077d3c71eb3ac5d7dbba72 - name: github.com/gogo/protobuf version: c0656edd0d9eab7c66d1eb0c568f9039345796f7 subpackages: @@ -29,7 +15,7 @@ imports: - name: github.com/golang/glog version: 44145f04b68cf362d9c4df2182967c2275eaefed - name: github.com/golang/protobuf - version: 4bd1920723d7b7c925de087aa32e2187708897f7 + version: b4deda0973fb4c70b50d226b1af49f3da59f5265 subpackages: - proto - ptypes @@ -54,32 +40,34 @@ imports: version: a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4 subpackages: - simplelru -- name: github.com/howeyc/gopass - version: bf9dde6d0d2c004a008c27aaee91170c786f6db8 - name: github.com/imdario/mergo version: 6633656539c1639d9d78127b7d47c622b5d7b6dc - name: github.com/inconshreveable/mousetrap version: 76626ae9c91c4f2a10f34cad8ce83ea42c93bb75 - name: github.com/json-iterator/go - version: 36b14963da70d11297d313183d7e6388c8510e1e -- name: github.com/juju/ratelimit - version: 5b9ff866471762aa2ab2dced63c9fb6f53921342 -- name: github.com/mailru/easyjson - version: d5b7844b561a7bc640052f1b935f7b800330d7e0 + version: f2b4162afba35581b6d4a50d3b8f34e33c144682 +- name: github.com/modern-go/concurrent + version: bacd9c7ef1dd9b15be4a9909b8ac7a4e313eec94 +- name: github.com/modern-go/reflect2 + version: 05fbef0ca5da472bbf96c9322b84a53edc03c9fd +- name: github.com/openshift/api + version: d5b34b957e91dbf64013a866951c3ed5770db0b5 subpackages: - - buffer - - jlexer - - jwriter + - apps/v1 +- name: github.com/openshift/client-go + version: 431ec9a26e5021f35fa41ee9a89842db9bfdb370 + subpackages: + - apps/clientset/versioned + - apps/clientset/versioned/scheme + - apps/clientset/versioned/typed/apps/v1 +- name: github.com/openshift/library-go + version: 0b8367a4679859036c27a30dbe010d76409e7075 - name: github.com/peterbourgon/diskv version: 5f041e8faa004a95c88a202771f4cc3e991971e6 -- name: github.com/PuerkitoBio/purell - version: 8a290539e2e8629dbc4e6bad948158f790ec31f4 -- name: github.com/PuerkitoBio/urlesc - version: 5bd2802263f21d8788851d5305584c82a5c75d7e - name: github.com/sirupsen/logrus version: c155da19408a8799da419ed3eeb0cb5db0ad5dbc - name: github.com/spf13/cobra - version: ef82de70bb3f60c65fb8eebacbb2d122ef517385 + version: f62e98d28ab7ad31d707ba837a966378465c7b57 - name: github.com/spf13/pflag version: 583c0c0531f06d5278b7d917446061adc344b5cd - name: golang.org/x/crypto @@ -95,32 +83,31 @@ imports: - idna - lex/httplex - name: golang.org/x/sys - version: 7ddbeae9ae08c6a06a59597f0c9edbc5ff2444ce + version: 95c6576299259db960f6c5b9b69ea52422860fce subpackages: - unix - windows - name: golang.org/x/text version: b19bf474d317b857955b12035d2c5acb57ce8b01 subpackages: - - cases - - internal - - internal/tag - - language - - runes - secure/bidirule - - secure/precis - transform - unicode/bidi - unicode/norm - - width +- name: golang.org/x/time + version: f51c12702a4d776e4c1fa9b0fabab841babae631 + subpackages: + - rate - name: gopkg.in/inf.v0 version: 3887ee99ecf07df5b447e9b00d9c0b2adaa9f3e4 - name: gopkg.in/yaml.v2 - version: 53feefa2559fb8dfa8d81baad31be332c97d6c77 + version: 670d4cfef0544295bc27a114dbac37980d83185a - name: k8s.io/api - version: fe29995db37613b9c5b2a647544cf627bfa8d299 + version: 2d6f90ab1293a1fb871cf149423ebb72aa7423aa subpackages: - admissionregistration/v1alpha1 + - admissionregistration/v1beta1 + - apps/v1 - apps/v1beta1 - apps/v1beta2 - authentication/v1 @@ -134,6 +121,7 @@ imports: - batch/v2alpha1 - certificates/v1beta1 - core/v1 + - events/v1beta1 - extensions/v1beta1 - networking/v1 - policy/v1beta1 @@ -141,23 +129,23 @@ imports: - rbac/v1alpha1 - rbac/v1beta1 - scheduling/v1alpha1 + - scheduling/v1beta1 - settings/v1alpha1 - storage/v1 + - storage/v1alpha1 - storage/v1beta1 - name: k8s.io/apimachinery - version: 019ae5ada31de202164b118aee88ee2d14075c31 + version: 103fd098999dc9c0c88536f5c9ad2e5da39373ae subpackages: - - pkg/api/equality - pkg/api/errors - pkg/api/meta - pkg/api/resource - pkg/apis/meta/internalversion - pkg/apis/meta/v1 - pkg/apis/meta/v1/unstructured - - pkg/apis/meta/v1alpha1 + - pkg/apis/meta/v1beta1 - pkg/conversion - pkg/conversion/queryparams - - pkg/conversion/unstructured - pkg/fields - pkg/labels - pkg/runtime @@ -177,18 +165,21 @@ imports: - pkg/util/framer - pkg/util/intstr - pkg/util/json + - pkg/util/mergepatch - pkg/util/net - pkg/util/runtime - pkg/util/sets + - pkg/util/strategicpatch - pkg/util/validation - pkg/util/validation/field - pkg/util/wait - pkg/util/yaml - pkg/version - pkg/watch + - third_party/forked/golang/json - third_party/forked/golang/reflect - name: k8s.io/client-go - version: 35874c597fed17ca62cd197e516d7d5ff9a2958c + version: 59698c7d9724b0f95f9dc9e7f7dfdcc3dfeceb82 subpackages: - discovery - discovery/fake @@ -197,6 +188,10 @@ imports: - kubernetes/scheme - kubernetes/typed/admissionregistration/v1alpha1 - kubernetes/typed/admissionregistration/v1alpha1/fake + - kubernetes/typed/admissionregistration/v1beta1 + - kubernetes/typed/admissionregistration/v1beta1/fake + - kubernetes/typed/apps/v1 + - kubernetes/typed/apps/v1/fake - kubernetes/typed/apps/v1beta1 - kubernetes/typed/apps/v1beta1/fake - kubernetes/typed/apps/v1beta2 @@ -223,6 +218,8 @@ imports: - kubernetes/typed/certificates/v1beta1/fake - kubernetes/typed/core/v1 - kubernetes/typed/core/v1/fake + - kubernetes/typed/events/v1beta1 + - kubernetes/typed/events/v1beta1/fake - kubernetes/typed/extensions/v1beta1 - kubernetes/typed/extensions/v1beta1/fake - kubernetes/typed/networking/v1 @@ -237,13 +234,21 @@ imports: - kubernetes/typed/rbac/v1beta1/fake - kubernetes/typed/scheduling/v1alpha1 - kubernetes/typed/scheduling/v1alpha1/fake + - kubernetes/typed/scheduling/v1beta1 + - kubernetes/typed/scheduling/v1beta1/fake - kubernetes/typed/settings/v1alpha1 - kubernetes/typed/settings/v1alpha1/fake - kubernetes/typed/storage/v1 - kubernetes/typed/storage/v1/fake + - kubernetes/typed/storage/v1alpha1 + - kubernetes/typed/storage/v1alpha1/fake - kubernetes/typed/storage/v1beta1 - kubernetes/typed/storage/v1beta1/fake + - pkg/apis/clientauthentication + - pkg/apis/clientauthentication/v1alpha1 + - pkg/apis/clientauthentication/v1beta1 - pkg/version + - plugin/pkg/client/auth/exec - rest - rest/watch - testing @@ -257,13 +262,16 @@ imports: - tools/pager - tools/reference - transport + - util/buffer - util/cert + - util/connrotation - util/flowcontrol - util/homedir - util/integer + - util/retry - util/workqueue - name: k8s.io/kube-openapi - version: 868f2f29720b192240e18284659231b440f9cda5 + version: 91cfa479c814065e420cee7ed227db0f63a5854e subpackages: - - pkg/common + - pkg/util/proto testImports: [] diff --git a/glide.yaml b/glide.yaml index f87819b4..0215b260 100644 --- a/glide.yaml +++ b/glide.yaml @@ -1,14 +1,10 @@ package: github.com/stakater/Reloader import: -- package: k8s.io/api - version: kubernetes-1.10.0 -- package: k8s.io/apimachinery - version: kubernetes-1.10.0 -- package: k8s.io/client-go - version: 6.0.0 +- package: github.com/openshift/client-go + version: release-3.11 - package: github.com/spf13/cobra - version: 0.0.3 -- package: github.com/spf13/pflag - version: 1.0.1 -- package: github.com/sirupsen/logrus - version: 1.0.5 + version: f62e98d28ab7ad31d707ba837a966378465c7b57 +- package: github.com/openshift/library-go + version: release-3.11 +- package: github.com/openshift/api + version: master \ No newline at end of file diff --git a/internal/pkg/callbacks/rolling_upgrade.go b/internal/pkg/callbacks/rolling_upgrade.go index 803ce78e..d92e16a2 100644 --- a/internal/pkg/callbacks/rolling_upgrade.go +++ b/internal/pkg/callbacks/rolling_upgrade.go @@ -3,15 +3,17 @@ package callbacks import ( "github.com/sirupsen/logrus" "github.com/stakater/Reloader/internal/pkg/util" + "github.com/stakater/Reloader/pkg/kube" apps_v1beta1 "k8s.io/api/apps/v1beta1" v1 "k8s.io/api/core/v1" "k8s.io/api/extensions/v1beta1" meta_v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/client-go/kubernetes" + + openshiftv1 "github.com/openshift/api/apps/v1" ) //ItemsFunc is a generic function to return a specific resource array in given namespace -type ItemsFunc func(kubernetes.Interface, string) []interface{} +type ItemsFunc func(kube.Clients, string) []interface{} //ContainersFunc is a generic func to return containers type ContainersFunc func(interface{}) []v1.Container @@ -23,7 +25,7 @@ type InitContainersFunc func(interface{}) []v1.Container type VolumesFunc func(interface{}) []v1.Volume //UpdateFunc performs the resource update -type UpdateFunc func(kubernetes.Interface, string, interface{}) error +type UpdateFunc func(kube.Clients, string, interface{}) error //RollingUpgradeFuncs contains generic functions to perform rolling upgrade type RollingUpgradeFuncs struct { @@ -36,32 +38,41 @@ type RollingUpgradeFuncs struct { } // GetDeploymentItems returns the deployments in given namespace -func GetDeploymentItems(client kubernetes.Interface, namespace string) []interface{} { - deployments, err := client.ExtensionsV1beta1().Deployments(namespace).List(meta_v1.ListOptions{}) +func GetDeploymentItems(clients kube.Clients, namespace string) []interface{} { + deployments, err := clients.KubernetesClient.ExtensionsV1beta1().Deployments(namespace).List(meta_v1.ListOptions{}) if err != nil { logrus.Errorf("Failed to list deployments %v", err) } return util.InterfaceSlice(deployments.Items) } -// GetDaemonSetItems returns the daemonSet in given namespace -func GetDaemonSetItems(client kubernetes.Interface, namespace string) []interface{} { - daemonSets, err := client.ExtensionsV1beta1().DaemonSets(namespace).List(meta_v1.ListOptions{}) +// GetDaemonSetItems returns the daemonSets in given namespace +func GetDaemonSetItems(clients kube.Clients, namespace string) []interface{} { + daemonSets, err := clients.KubernetesClient.ExtensionsV1beta1().DaemonSets(namespace).List(meta_v1.ListOptions{}) if err != nil { logrus.Errorf("Failed to list daemonSets %v", err) } return util.InterfaceSlice(daemonSets.Items) } -// GetStatefulSetItems returns the statefulSet in given namespace -func GetStatefulSetItems(client kubernetes.Interface, namespace string) []interface{} { - statefulSets, err := client.AppsV1beta1().StatefulSets(namespace).List(meta_v1.ListOptions{}) +// GetStatefulSetItems returns the statefulSets in given namespace +func GetStatefulSetItems(clients kube.Clients, namespace string) []interface{} { + statefulSets, err := clients.KubernetesClient.AppsV1beta1().StatefulSets(namespace).List(meta_v1.ListOptions{}) if err != nil { logrus.Errorf("Failed to list statefulSets %v", err) } return util.InterfaceSlice(statefulSets.Items) } +// GetDeploymentConfigItems returns the deploymentConfigs in given namespace +func GetDeploymentConfigItems(clients kube.Clients, namespace string) []interface{} { + deploymentConfigs, err := clients.OpenshiftAppsClient.Apps().DeploymentConfigs(namespace).List(meta_v1.ListOptions{}) + if err != nil { + logrus.Errorf("Failed to list deploymentConfigs %v", err) + } + return util.InterfaceSlice(deploymentConfigs.Items) +} + // GetDeploymentContainers returns the containers of given deployment func GetDeploymentContainers(item interface{}) []v1.Container { return item.(v1beta1.Deployment).Spec.Template.Spec.Containers @@ -77,6 +88,11 @@ func GetStatefulsetContainers(item interface{}) []v1.Container { return item.(apps_v1beta1.StatefulSet).Spec.Template.Spec.Containers } +// GetDeploymentConfigContainers returns the containers of given deploymentConfig +func GetDeploymentConfigContainers(item interface{}) []v1.Container { + return item.(openshiftv1.DeploymentConfig).Spec.Template.Spec.Containers +} + // GetDeploymentInitContainers returns the containers of given deployment func GetDeploymentInitContainers(item interface{}) []v1.Container { return item.(v1beta1.Deployment).Spec.Template.Spec.InitContainers @@ -92,24 +108,36 @@ func GetStatefulsetInitContainers(item interface{}) []v1.Container { return item.(apps_v1beta1.StatefulSet).Spec.Template.Spec.InitContainers } +// GetDeploymentConfigInitContainers returns the containers of given deploymentConfig +func GetDeploymentConfigInitContainers(item interface{}) []v1.Container { + return item.(openshiftv1.DeploymentConfig).Spec.Template.Spec.InitContainers +} + // UpdateDeployment performs rolling upgrade on deployment -func UpdateDeployment(client kubernetes.Interface, namespace string, resource interface{}) error { +func UpdateDeployment(clients kube.Clients, namespace string, resource interface{}) error { deployment := resource.(v1beta1.Deployment) - _, err := client.ExtensionsV1beta1().Deployments(namespace).Update(&deployment) + _, err := clients.KubernetesClient.ExtensionsV1beta1().Deployments(namespace).Update(&deployment) return err } // UpdateDaemonSet performs rolling upgrade on daemonSet -func UpdateDaemonSet(client kubernetes.Interface, namespace string, resource interface{}) error { +func UpdateDaemonSet(clients kube.Clients, namespace string, resource interface{}) error { daemonSet := resource.(v1beta1.DaemonSet) - _, err := client.ExtensionsV1beta1().DaemonSets(namespace).Update(&daemonSet) + _, err := clients.KubernetesClient.ExtensionsV1beta1().DaemonSets(namespace).Update(&daemonSet) return err } // UpdateStatefulset performs rolling upgrade on statefulSet -func UpdateStatefulset(client kubernetes.Interface, namespace string, resource interface{}) error { +func UpdateStatefulset(clients kube.Clients, namespace string, resource interface{}) error { statefulSet := resource.(apps_v1beta1.StatefulSet) - _, err := client.AppsV1beta1().StatefulSets(namespace).Update(&statefulSet) + _, err := clients.KubernetesClient.AppsV1beta1().StatefulSets(namespace).Update(&statefulSet) + return err +} + +// UpdateDeploymentConfig performs rolling upgrade on deploymentConfig +func UpdateDeploymentConfig(clients kube.Clients, namespace string, resource interface{}) error { + deploymentConfig := resource.(openshiftv1.DeploymentConfig) + _, err := clients.OpenshiftAppsClient.AppsV1().DeploymentConfigs(namespace).Update(&deploymentConfig) return err } @@ -127,3 +155,8 @@ func GetDaemonSetVolumes(item interface{}) []v1.Volume { func GetStatefulsetVolumes(item interface{}) []v1.Volume { return item.(apps_v1beta1.StatefulSet).Spec.Template.Spec.Volumes } + +// GetDeploymentConfigVolumes returns the Volumes of given deploymentConfig +func GetDeploymentConfigVolumes(item interface{}) []v1.Volume { + return item.(openshiftv1.DeploymentConfig).Spec.Template.Spec.Volumes +} diff --git a/internal/pkg/cmd/reloader.go b/internal/pkg/cmd/reloader.go index 426b5e0d..f6ff480e 100644 --- a/internal/pkg/cmd/reloader.go +++ b/internal/pkg/cmd/reloader.go @@ -9,7 +9,7 @@ import ( "github.com/stakater/Reloader/internal/pkg/options" "github.com/stakater/Reloader/internal/pkg/util" "github.com/stakater/Reloader/pkg/kube" - "k8s.io/apimachinery/pkg/apis/meta/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) // NewReloaderCommand starts the reloader controller @@ -41,7 +41,7 @@ func startReloader(cmd *cobra.Command, args []string) { } // create the clientset - clientset, err := kube.GetClient() + clientset, err := kube.GetKubernetesClient() if err != nil { logrus.Fatal(err) } diff --git a/internal/pkg/controller/controller_test.go b/internal/pkg/controller/controller_test.go index 624a9ed9..18c8ac7c 100644 --- a/internal/pkg/controller/controller_test.go +++ b/internal/pkg/controller/controller_test.go @@ -15,7 +15,7 @@ import ( ) var ( - client = testutil.GetClient() + clients = kube.GetClients() namespace = "test-reloader-" + testutil.RandSeq(5) configmapNamePrefix = "testconfigmap-reloader" secretNamePrefix = "testsecret-reloader" @@ -26,11 +26,11 @@ var ( func TestMain(m *testing.M) { - testutil.CreateNamespace(namespace, client) + testutil.CreateNamespace(namespace, clients.KubernetesClient) logrus.Infof("Creating controller") for k := range kube.ResourceMap { - c, err := NewController(client, k, namespace) + c, err := NewController(clients.KubernetesClient, k, namespace) if err != nil { logrus.Fatalf("%s", err) } @@ -40,28 +40,84 @@ func TestMain(m *testing.M) { defer close(stop) go c.Run(1, stop) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) logrus.Infof("Running Testcases") retCode := m.Run() - testutil.DeleteNamespace(namespace, client) + testutil.DeleteNamespace(namespace, clients.KubernetesClient) os.Exit(retCode) } +// Perform rolling upgrade on deploymentConfig and create env var upon updating the configmap +func TestControllerUpdatingConfigmapShouldCreateEnvInDeploymentConfig(t *testing.T) { + // Don't run test on non-openshift environment + if !kube.IsOpenshift { + return + } + + // Creating configmap + configmapName := configmapNamePrefix + "-update-" + testutil.RandSeq(5) + configmapClient, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com") + if err != nil { + t.Errorf("Error while creating the configmap %v", err) + } + + // Creating deployment + _, err = testutil.CreateDeploymentConfig(clients.OpenshiftAppsClient, configmapName, namespace, true) + if err != nil { + t.Errorf("Error in deploymentConfig creation: %v", err) + } + + // Updating configmap for first time + updateErr := testutil.UpdateConfigMap(configmapClient, namespace, configmapName, "", "www.stakater.com") + if updateErr != nil { + t.Errorf("Configmap was not updated") + } + + // Verifying deployment update + logrus.Infof("Verifying env var has been created") + shaData := testutil.ConvertResourceToSHA(testutil.ConfigmapResourceType, namespace, configmapName, "www.stakater.com") + config := util.Config{ + Namespace: namespace, + ResourceName: configmapName, + SHAValue: shaData, + Annotation: options.ConfigmapUpdateOnChangeAnnotation, + } + deploymentConfigFuncs := handler.GetDeploymentConfigRollingUpgradeFuncs() + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentConfigFuncs) + if !updated { + t.Errorf("DeploymentConfig was not updated") + } + time.Sleep(5 * time.Second) + + // Deleting deployment + err = testutil.DeleteDeploymentConfig(clients.OpenshiftAppsClient, namespace, configmapName) + if err != nil { + logrus.Errorf("Error while deleting the deploymentConfig %v", err) + } + + // Deleting configmap + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) + if err != nil { + logrus.Errorf("Error while deleting the configmap %v", err) + } + time.Sleep(3 * time.Second) +} + // Perform rolling upgrade on deployment and create env var upon updating the configmap func TestControllerUpdatingConfigmapShouldCreateEnvInDeployment(t *testing.T) { // Creating configmap configmapName := configmapNamePrefix + "-update-" + testutil.RandSeq(5) - configmapClient, err := testutil.CreateConfigMap(client, namespace, configmapName, "www.google.com") + configmapClient, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com") if err != nil { t.Errorf("Error while creating the configmap %v", err) } // Creating deployment - _, err = testutil.CreateDeployment(client, configmapName, namespace, true) + _, err = testutil.CreateDeployment(clients.KubernetesClient, configmapName, namespace, true) if err != nil { t.Errorf("Error in deployment creation: %v", err) } @@ -82,24 +138,24 @@ func TestControllerUpdatingConfigmapShouldCreateEnvInDeployment(t *testing.T) { Annotation: options.ConfigmapUpdateOnChangeAnnotation, } deploymentFuncs := handler.GetDeploymentRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Deleting deployment - err = testutil.DeleteDeployment(client, namespace, configmapName) + err = testutil.DeleteDeployment(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the deployment %v", err) } // Deleting configmap - err = testutil.DeleteConfigMap(client, namespace, configmapName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the configmap %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on deployment and create env var upon updating the configmap @@ -107,13 +163,13 @@ func TestControllerUpdatingConfigmapShouldAutoCreateEnvInDeployment(t *testing.T // Creating configmap configmapName := configmapNamePrefix + "-update-" + testutil.RandSeq(5) - configmapClient, err := testutil.CreateConfigMap(client, namespace, configmapName, "www.google.com") + configmapClient, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com") if err != nil { t.Errorf("Error while creating the configmap %v", err) } // Creating deployment - _, err = testutil.CreateDeployment(client, configmapName, namespace, false) + _, err = testutil.CreateDeployment(clients.KubernetesClient, configmapName, namespace, false) if err != nil { t.Errorf("Error in deployment creation: %v", err) } @@ -134,24 +190,24 @@ func TestControllerUpdatingConfigmapShouldAutoCreateEnvInDeployment(t *testing.T Annotation: options.ConfigmapUpdateOnChangeAnnotation, } deploymentFuncs := handler.GetDeploymentRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Deleting deployment - err = testutil.DeleteDeployment(client, namespace, configmapName) + err = testutil.DeleteDeployment(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the deployment %v", err) } // Deleting configmap - err = testutil.DeleteConfigMap(client, namespace, configmapName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the configmap %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on deployment and create env var upon creating the configmap @@ -159,31 +215,31 @@ func TestControllerCreatingConfigmapShouldCreateEnvInDeployment(t *testing.T) { // Creating configmap configmapName := configmapNamePrefix + "-create-" + testutil.RandSeq(5) - _, err := testutil.CreateConfigMap(client, namespace, configmapName, "www.google.com") + _, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com") if err != nil { t.Errorf("Error while creating the configmap %v", err) } // Creating deployment - _, err = testutil.CreateDeployment(client, configmapName, namespace, true) + _, err = testutil.CreateDeployment(clients.KubernetesClient, configmapName, namespace, true) if err != nil { t.Errorf("Error in deployment creation: %v", err) } // Deleting configmap for first time - err = testutil.DeleteConfigMap(client, namespace, configmapName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the configmap %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) - _, err = testutil.CreateConfigMap(client, namespace, configmapName, "www.stakater.com") + _, err = testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.stakater.com") if err != nil { t.Errorf("Error while creating the configmap second time %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Verifying deployment update logrus.Infof("Verifying env var has been created") @@ -195,37 +251,37 @@ func TestControllerCreatingConfigmapShouldCreateEnvInDeployment(t *testing.T) { Annotation: options.ConfigmapUpdateOnChangeAnnotation, } deploymentFuncs := handler.GetDeploymentRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Deleting deployment - err = testutil.DeleteDeployment(client, namespace, configmapName) + err = testutil.DeleteDeployment(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the deployment %v", err) } // Deleting configmap - err = testutil.DeleteConfigMap(client, namespace, configmapName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the configmap %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on deployment and update env var upon updating the configmap func TestControllerForUpdatingConfigmapShouldUpdateDeployment(t *testing.T) { // Creating secret configmapName := configmapNamePrefix + "-update-" + testutil.RandSeq(5) - configmapClient, err := testutil.CreateConfigMap(client, namespace, configmapName, "www.google.com") + configmapClient, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com") if err != nil { t.Errorf("Error while creating the configmap %v", err) } // Creating deployment - _, err = testutil.CreateDeployment(client, configmapName, namespace, true) + _, err = testutil.CreateDeployment(clients.KubernetesClient, configmapName, namespace, true) if err != nil { t.Errorf("Error in deployment creation: %v", err) } @@ -254,37 +310,37 @@ func TestControllerForUpdatingConfigmapShouldUpdateDeployment(t *testing.T) { deploymentFuncs := handler.GetDeploymentRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Deleting deployment - err = testutil.DeleteDeployment(client, namespace, configmapName) + err = testutil.DeleteDeployment(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the deployment %v", err) } // Deleting configmap - err = testutil.DeleteConfigMap(client, namespace, configmapName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the configmap %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Do not Perform rolling upgrade on deployment and create env var upon updating the labels configmap func TestControllerUpdatingConfigmapLabelsShouldNotCreateorUpdateEnvInDeployment(t *testing.T) { // Creating configmap configmapName := configmapNamePrefix + "-update-" + testutil.RandSeq(5) - configmapClient, err := testutil.CreateConfigMap(client, namespace, configmapName, "www.google.com") + configmapClient, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com") if err != nil { t.Errorf("Error while creating the configmap %v", err) } // Creating deployment - _, err = testutil.CreateDeployment(client, configmapName, namespace, true) + _, err = testutil.CreateDeployment(clients.KubernetesClient, configmapName, namespace, true) if err != nil { t.Errorf("Error in deployment creation: %v", err) } @@ -305,54 +361,54 @@ func TestControllerUpdatingConfigmapLabelsShouldNotCreateorUpdateEnvInDeployment Annotation: options.ConfigmapUpdateOnChangeAnnotation, } deploymentFuncs := handler.GetDeploymentRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) if updated { t.Errorf("Deployment should not be updated by changing label") } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Deleting deployment - err = testutil.DeleteDeployment(client, namespace, configmapName) + err = testutil.DeleteDeployment(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the deployment %v", err) } // Deleting configmap - err = testutil.DeleteConfigMap(client, namespace, configmapName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the configmap %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on pod and create a env var upon creating the secret func TestControllerCreatingSecretShouldCreateEnvInDeployment(t *testing.T) { // Creating secret secretName := secretNamePrefix + "-create-" + testutil.RandSeq(5) - _, err := testutil.CreateSecret(client, namespace, secretName, data) + _, err := testutil.CreateSecret(clients.KubernetesClient, namespace, secretName, data) if err != nil { t.Errorf("Error in secret creation: %v", err) } // Creating deployment - _, err = testutil.CreateDeployment(client, secretName, namespace, true) + _, err = testutil.CreateDeployment(clients.KubernetesClient, secretName, namespace, true) if err != nil { t.Errorf("Error in deployment creation: %v", err) } //Deleting Secret - err = testutil.DeleteSecret(client, namespace, secretName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the secret %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) - _, err = testutil.CreateSecret(client, namespace, secretName, newData) + _, err = testutil.CreateSecret(clients.KubernetesClient, namespace, secretName, newData) if err != nil { t.Errorf("Error in secret creation: %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Verifying Upgrade logrus.Infof("Verifying env var has been created") @@ -364,37 +420,37 @@ func TestControllerCreatingSecretShouldCreateEnvInDeployment(t *testing.T) { Annotation: options.SecretUpdateOnChangeAnnotation, } deploymentFuncs := handler.GetDeploymentRollingUpgradeFuncs() - time.Sleep(5 * time.Second) - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, deploymentFuncs) + time.Sleep(3 * time.Second) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } // Deleting Deployment - err = testutil.DeleteDeployment(client, namespace, secretName) + err = testutil.DeleteDeployment(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the deployment %v", err) } //Deleting Secret - err = testutil.DeleteSecret(client, namespace, secretName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the secret %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on pod and create a env var upon updating the secret func TestControllerUpdatingSecretShouldCreateEnvInDeployment(t *testing.T) { // Creating secret secretName := secretNamePrefix + "-update-" + testutil.RandSeq(5) - secretClient, err := testutil.CreateSecret(client, namespace, secretName, data) + secretClient, err := testutil.CreateSecret(clients.KubernetesClient, namespace, secretName, data) if err != nil { t.Errorf("Error in secret creation: %v", err) } // Creating deployment - _, err = testutil.CreateDeployment(client, secretName, namespace, true) + _, err = testutil.CreateDeployment(clients.KubernetesClient, secretName, namespace, true) if err != nil { t.Errorf("Error in deployment creation: %v", err) } @@ -415,36 +471,36 @@ func TestControllerUpdatingSecretShouldCreateEnvInDeployment(t *testing.T) { Annotation: options.SecretUpdateOnChangeAnnotation, } deploymentFuncs := handler.GetDeploymentRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } // Deleting Deployment - err = testutil.DeleteDeployment(client, namespace, secretName) + err = testutil.DeleteDeployment(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the deployment %v", err) } //Deleting Secret - err = testutil.DeleteSecret(client, namespace, secretName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the secret %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on deployment and update env var upon updating the secret func TestControllerUpdatingSecretShouldUpdateEnvInDeployment(t *testing.T) { // Creating secret secretName := secretNamePrefix + "-update-" + testutil.RandSeq(5) - secretClient, err := testutil.CreateSecret(client, namespace, secretName, data) + secretClient, err := testutil.CreateSecret(clients.KubernetesClient, namespace, secretName, data) if err != nil { t.Errorf("Error in secret creation: %v", err) } // Creating deployment - _, err = testutil.CreateDeployment(client, secretName, namespace, true) + _, err = testutil.CreateDeployment(clients.KubernetesClient, secretName, namespace, true) if err != nil { t.Errorf("Error in deployment creation: %v", err) } @@ -471,36 +527,36 @@ func TestControllerUpdatingSecretShouldUpdateEnvInDeployment(t *testing.T) { Annotation: options.SecretUpdateOnChangeAnnotation, } deploymentFuncs := handler.GetDeploymentRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } // Deleting Deployment - err = testutil.DeleteDeployment(client, namespace, secretName) + err = testutil.DeleteDeployment(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the deployment %v", err) } //Deleting Secret - err = testutil.DeleteSecret(client, namespace, secretName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the secret %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Do not Perform rolling upgrade on pod and create or update a env var upon updating the label in secret func TestControllerUpdatingSecretLabelsShouldNotCreateorUpdateEnvInDeployment(t *testing.T) { // Creating secret secretName := secretNamePrefix + "-update-" + testutil.RandSeq(5) - secretClient, err := testutil.CreateSecret(client, namespace, secretName, data) + secretClient, err := testutil.CreateSecret(clients.KubernetesClient, namespace, secretName, data) if err != nil { t.Errorf("Error in secret creation: %v", err) } // Creating deployment - _, err = testutil.CreateDeployment(client, secretName, namespace, true) + _, err = testutil.CreateDeployment(clients.KubernetesClient, secretName, namespace, true) if err != nil { t.Errorf("Error in deployment creation: %v", err) } @@ -520,36 +576,36 @@ func TestControllerUpdatingSecretLabelsShouldNotCreateorUpdateEnvInDeployment(t Annotation: options.SecretUpdateOnChangeAnnotation, } deploymentFuncs := handler.GetDeploymentRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, deploymentFuncs) if updated { t.Errorf("Deployment should not be updated by changing label in secret") } // Deleting Deployment - err = testutil.DeleteDeployment(client, namespace, secretName) + err = testutil.DeleteDeployment(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the deployment %v", err) } //Deleting Secret - err = testutil.DeleteSecret(client, namespace, secretName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the secret %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on DaemonSet and create env var upon updating the configmap func TestControllerUpdatingConfigmapShouldCreateEnvInDaemonSet(t *testing.T) { // Creating configmap configmapName := configmapNamePrefix + "-update-" + testutil.RandSeq(5) - configmapClient, err := testutil.CreateConfigMap(client, namespace, configmapName, "www.google.com") + configmapClient, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com") if err != nil { t.Errorf("Error while creating the configmap %v", err) } // Creating DaemonSet - _, err = testutil.CreateDaemonSet(client, configmapName, namespace, true) + _, err = testutil.CreateDaemonSet(clients.KubernetesClient, configmapName, namespace, true) if err != nil { t.Errorf("Error in DaemonSet creation: %v", err) } @@ -570,37 +626,37 @@ func TestControllerUpdatingConfigmapShouldCreateEnvInDaemonSet(t *testing.T) { Annotation: options.ConfigmapUpdateOnChangeAnnotation, } daemonSetFuncs := handler.GetDaemonSetRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, daemonSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, daemonSetFuncs) if !updated { t.Errorf("DaemonSet was not updated") } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Deleting DaemonSet - err = testutil.DeleteDaemonSet(client, namespace, configmapName) + err = testutil.DeleteDaemonSet(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the DaemonSet %v", err) } // Deleting configmap - err = testutil.DeleteConfigMap(client, namespace, configmapName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the configmap %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on DaemonSet and update env var upon updating the configmap func TestControllerForUpdatingConfigmapShouldUpdateDaemonSet(t *testing.T) { // Creating secret configmapName := configmapNamePrefix + "-update-" + testutil.RandSeq(5) - configmapClient, err := testutil.CreateConfigMap(client, namespace, configmapName, "www.google.com") + configmapClient, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com") if err != nil { t.Errorf("Error while creating the configmap %v", err) } // Creating DaemonSet - _, err = testutil.CreateDaemonSet(client, configmapName, namespace, true) + _, err = testutil.CreateDaemonSet(clients.KubernetesClient, configmapName, namespace, true) if err != nil { t.Errorf("Error in DaemonSet creation: %v", err) } @@ -611,7 +667,7 @@ func TestControllerForUpdatingConfigmapShouldUpdateDaemonSet(t *testing.T) { t.Errorf("Configmap was not updated") } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Updating configmap for second time updateErr = testutil.UpdateConfigMap(configmapClient, namespace, configmapName, "", "aurorasolutions.io") @@ -619,7 +675,7 @@ func TestControllerForUpdatingConfigmapShouldUpdateDaemonSet(t *testing.T) { t.Errorf("Configmap was not updated") } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Verifying DaemonSet update logrus.Infof("Verifying env var has been updated") @@ -631,37 +687,37 @@ func TestControllerForUpdatingConfigmapShouldUpdateDaemonSet(t *testing.T) { Annotation: options.ConfigmapUpdateOnChangeAnnotation, } daemonSetFuncs := handler.GetDaemonSetRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, daemonSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, daemonSetFuncs) if !updated { t.Errorf("DaemonSet was not updated") } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Deleting DaemonSet - err = testutil.DeleteDaemonSet(client, namespace, configmapName) + err = testutil.DeleteDaemonSet(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the DaemonSet %v", err) } // Deleting configmap - err = testutil.DeleteConfigMap(client, namespace, configmapName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the configmap %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on pod and create a env var upon updating the secret func TestControllerUpdatingSecretShouldCreateEnvInDaemonSet(t *testing.T) { // Creating secret secretName := secretNamePrefix + "-update-" + testutil.RandSeq(5) - secretClient, err := testutil.CreateSecret(client, namespace, secretName, data) + secretClient, err := testutil.CreateSecret(clients.KubernetesClient, namespace, secretName, data) if err != nil { t.Errorf("Error in secret creation: %v", err) } // Creating DaemonSet - _, err = testutil.CreateDaemonSet(client, secretName, namespace, true) + _, err = testutil.CreateDaemonSet(clients.KubernetesClient, secretName, namespace, true) if err != nil { t.Errorf("Error in DaemonSet creation: %v", err) } @@ -682,36 +738,36 @@ func TestControllerUpdatingSecretShouldCreateEnvInDaemonSet(t *testing.T) { Annotation: options.SecretUpdateOnChangeAnnotation, } daemonSetFuncs := handler.GetDaemonSetRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, daemonSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, daemonSetFuncs) if !updated { t.Errorf("DaemonSet was not updated") } // Deleting DaemonSet - err = testutil.DeleteDaemonSet(client, namespace, secretName) + err = testutil.DeleteDaemonSet(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the DaemonSet %v", err) } //Deleting Secret - err = testutil.DeleteSecret(client, namespace, secretName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the secret %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on DaemonSet and update env var upon updating the secret func TestControllerUpdatingSecretShouldUpdateEnvInDaemonSet(t *testing.T) { // Creating secret secretName := secretNamePrefix + "-update-" + testutil.RandSeq(5) - secretClient, err := testutil.CreateSecret(client, namespace, secretName, data) + secretClient, err := testutil.CreateSecret(clients.KubernetesClient, namespace, secretName, data) if err != nil { t.Errorf("Error in secret creation: %v", err) } // Creating DaemonSet - _, err = testutil.CreateDaemonSet(client, secretName, namespace, true) + _, err = testutil.CreateDaemonSet(clients.KubernetesClient, secretName, namespace, true) if err != nil { t.Errorf("Error in DaemonSet creation: %v", err) } @@ -721,7 +777,7 @@ func TestControllerUpdatingSecretShouldUpdateEnvInDaemonSet(t *testing.T) { if err != nil { t.Errorf("Error while updating secret %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Updating Secret err = testutil.UpdateSecret(secretClient, namespace, secretName, "", updatedData) @@ -739,36 +795,36 @@ func TestControllerUpdatingSecretShouldUpdateEnvInDaemonSet(t *testing.T) { Annotation: options.SecretUpdateOnChangeAnnotation, } daemonSetFuncs := handler.GetDaemonSetRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, daemonSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, daemonSetFuncs) if !updated { t.Errorf("DaemonSet was not updated") } // Deleting DaemonSet - err = testutil.DeleteDaemonSet(client, namespace, secretName) + err = testutil.DeleteDaemonSet(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the DaemonSet %v", err) } //Deleting Secret - err = testutil.DeleteSecret(client, namespace, secretName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the secret %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Do not Perform rolling upgrade on pod and create or update a env var upon updating the label in secret func TestControllerUpdatingSecretLabelsShouldNotCreateorUpdateEnvInDaemonSet(t *testing.T) { // Creating secret secretName := secretNamePrefix + "-update-" + testutil.RandSeq(5) - secretClient, err := testutil.CreateSecret(client, namespace, secretName, data) + secretClient, err := testutil.CreateSecret(clients.KubernetesClient, namespace, secretName, data) if err != nil { t.Errorf("Error in secret creation: %v", err) } // Creating DaemonSet - _, err = testutil.CreateDaemonSet(client, secretName, namespace, true) + _, err = testutil.CreateDaemonSet(clients.KubernetesClient, secretName, namespace, true) if err != nil { t.Errorf("Error in DaemonSet creation: %v", err) } @@ -788,36 +844,36 @@ func TestControllerUpdatingSecretLabelsShouldNotCreateorUpdateEnvInDaemonSet(t * Annotation: options.SecretUpdateOnChangeAnnotation, } daemonSetFuncs := handler.GetDaemonSetRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, daemonSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, daemonSetFuncs) if updated { t.Errorf("DaemonSet should not be updated by changing label in secret") } // Deleting DaemonSet - err = testutil.DeleteDaemonSet(client, namespace, secretName) + err = testutil.DeleteDaemonSet(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the DaemonSet %v", err) } //Deleting Secret - err = testutil.DeleteSecret(client, namespace, secretName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the secret %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on StatefulSet and create env var upon updating the configmap func TestControllerUpdatingConfigmapShouldCreateEnvInStatefulSet(t *testing.T) { // Creating configmap configmapName := configmapNamePrefix + "-update-" + testutil.RandSeq(5) - configmapClient, err := testutil.CreateConfigMap(client, namespace, configmapName, "www.google.com") + configmapClient, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com") if err != nil { t.Errorf("Error while creating the configmap %v", err) } // Creating StatefulSet - _, err = testutil.CreateStatefulSet(client, configmapName, namespace, true) + _, err = testutil.CreateStatefulSet(clients.KubernetesClient, configmapName, namespace, true) if err != nil { t.Errorf("Error in StatefulSet creation: %v", err) } @@ -838,37 +894,37 @@ func TestControllerUpdatingConfigmapShouldCreateEnvInStatefulSet(t *testing.T) { Annotation: options.ConfigmapUpdateOnChangeAnnotation, } statefulSetFuncs := handler.GetStatefulSetRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, statefulSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, statefulSetFuncs) if !updated { t.Errorf("StatefulSet was not updated") } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Deleting StatefulSet - err = testutil.DeleteStatefulSet(client, namespace, configmapName) + err = testutil.DeleteStatefulSet(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the StatefulSet %v", err) } // Deleting configmap - err = testutil.DeleteConfigMap(client, namespace, configmapName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the configmap %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on StatefulSet and update env var upon updating the configmap func TestControllerForUpdatingConfigmapShouldUpdateStatefulSet(t *testing.T) { // Creating secret configmapName := configmapNamePrefix + "-update-" + testutil.RandSeq(5) - configmapClient, err := testutil.CreateConfigMap(client, namespace, configmapName, "www.google.com") + configmapClient, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com") if err != nil { t.Errorf("Error while creating the configmap %v", err) } // Creating StatefulSet - _, err = testutil.CreateStatefulSet(client, configmapName, namespace, true) + _, err = testutil.CreateStatefulSet(clients.KubernetesClient, configmapName, namespace, true) if err != nil { t.Errorf("Error in StatefulSet creation: %v", err) } @@ -895,37 +951,37 @@ func TestControllerForUpdatingConfigmapShouldUpdateStatefulSet(t *testing.T) { Annotation: options.ConfigmapUpdateOnChangeAnnotation, } statefulSetFuncs := handler.GetStatefulSetRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, statefulSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, statefulSetFuncs) if !updated { t.Errorf("StatefulSet was not updated") } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) // Deleting StatefulSet - err = testutil.DeleteStatefulSet(client, namespace, configmapName) + err = testutil.DeleteStatefulSet(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the StatefulSet %v", err) } // Deleting configmap - err = testutil.DeleteConfigMap(client, namespace, configmapName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the configmap %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on pod and create a env var upon updating the secret func TestControllerUpdatingSecretShouldCreateEnvInStatefulSet(t *testing.T) { // Creating secret secretName := secretNamePrefix + "-update-" + testutil.RandSeq(5) - secretClient, err := testutil.CreateSecret(client, namespace, secretName, data) + secretClient, err := testutil.CreateSecret(clients.KubernetesClient, namespace, secretName, data) if err != nil { t.Errorf("Error in secret creation: %v", err) } // Creating StatefulSet - _, err = testutil.CreateStatefulSet(client, secretName, namespace, true) + _, err = testutil.CreateStatefulSet(clients.KubernetesClient, secretName, namespace, true) if err != nil { t.Errorf("Error in StatefulSet creation: %v", err) } @@ -946,36 +1002,36 @@ func TestControllerUpdatingSecretShouldCreateEnvInStatefulSet(t *testing.T) { Annotation: options.SecretUpdateOnChangeAnnotation, } statefulSetFuncs := handler.GetStatefulSetRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, statefulSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, statefulSetFuncs) if !updated { t.Errorf("StatefulSet was not updated") } // Deleting StatefulSet - err = testutil.DeleteStatefulSet(client, namespace, secretName) + err = testutil.DeleteStatefulSet(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the StatefulSet %v", err) } //Deleting Secret - err = testutil.DeleteSecret(client, namespace, secretName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the secret %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } // Perform rolling upgrade on StatefulSet and update env var upon updating the secret func TestControllerUpdatingSecretShouldUpdateEnvInStatefulSet(t *testing.T) { // Creating secret secretName := secretNamePrefix + "-update-" + testutil.RandSeq(5) - secretClient, err := testutil.CreateSecret(client, namespace, secretName, data) + secretClient, err := testutil.CreateSecret(clients.KubernetesClient, namespace, secretName, data) if err != nil { t.Errorf("Error in secret creation: %v", err) } // Creating StatefulSet - _, err = testutil.CreateStatefulSet(client, secretName, namespace, true) + _, err = testutil.CreateStatefulSet(clients.KubernetesClient, secretName, namespace, true) if err != nil { t.Errorf("Error in StatefulSet creation: %v", err) } @@ -1002,21 +1058,21 @@ func TestControllerUpdatingSecretShouldUpdateEnvInStatefulSet(t *testing.T) { Annotation: options.SecretUpdateOnChangeAnnotation, } statefulSetFuncs := handler.GetStatefulSetRollingUpgradeFuncs() - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, statefulSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, statefulSetFuncs) if !updated { t.Errorf("StatefulSet was not updated") } // Deleting StatefulSet - err = testutil.DeleteStatefulSet(client, namespace, secretName) + err = testutil.DeleteStatefulSet(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the StatefulSet %v", err) } //Deleting Secret - err = testutil.DeleteSecret(client, namespace, secretName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the secret %v", err) } - time.Sleep(5 * time.Second) + time.Sleep(3 * time.Second) } diff --git a/internal/pkg/handler/create.go b/internal/pkg/handler/create.go index cbfaa7c8..ebc71350 100644 --- a/internal/pkg/handler/create.go +++ b/internal/pkg/handler/create.go @@ -3,7 +3,7 @@ package handler import ( "github.com/sirupsen/logrus" "github.com/stakater/Reloader/internal/pkg/util" - "k8s.io/api/core/v1" + v1 "k8s.io/api/core/v1" ) // ResourceCreatedHandler contains new objects diff --git a/internal/pkg/handler/update.go b/internal/pkg/handler/update.go index 543f0ae3..c7e6e58d 100644 --- a/internal/pkg/handler/update.go +++ b/internal/pkg/handler/update.go @@ -3,7 +3,7 @@ package handler import ( "github.com/sirupsen/logrus" "github.com/stakater/Reloader/internal/pkg/util" - "k8s.io/api/core/v1" + v1 "k8s.io/api/core/v1" ) // ResourceUpdatedHandler contains updated objects diff --git a/internal/pkg/handler/upgrade.go b/internal/pkg/handler/upgrade.go index 653f10b6..5b6a1096 100644 --- a/internal/pkg/handler/upgrade.go +++ b/internal/pkg/handler/upgrade.go @@ -11,7 +11,6 @@ import ( "github.com/stakater/Reloader/internal/pkg/util" "github.com/stakater/Reloader/pkg/kube" v1 "k8s.io/api/core/v1" - "k8s.io/client-go/kubernetes" ) // GetDeploymentRollingUpgradeFuncs returns all callback funcs for a deployment @@ -50,27 +49,41 @@ func GetStatefulSetRollingUpgradeFuncs() callbacks.RollingUpgradeFuncs { } } -func doRollingUpgrade(config util.Config) { - rollingUpgrade(config, GetDeploymentRollingUpgradeFuncs()) - rollingUpgrade(config, GetDaemonSetRollingUpgradeFuncs()) - rollingUpgrade(config, GetStatefulSetRollingUpgradeFuncs()) +// GetDeploymentConfigRollingUpgradeFuncs returns all callback funcs for a deploymentConfig +func GetDeploymentConfigRollingUpgradeFuncs() callbacks.RollingUpgradeFuncs { + return callbacks.RollingUpgradeFuncs{ + ItemsFunc: callbacks.GetDeploymentConfigItems, + ContainersFunc: callbacks.GetDeploymentConfigContainers, + InitContainersFunc: callbacks.GetDeploymentConfigInitContainers, + UpdateFunc: callbacks.UpdateDeploymentConfig, + VolumesFunc: callbacks.GetDeploymentConfigVolumes, + ResourceType: "DeploymentConfig", + } } -func rollingUpgrade(config util.Config, upgradeFuncs callbacks.RollingUpgradeFuncs) { - client, err := kube.GetClient() - if err != nil { - logrus.Fatalf("Unable to create Kubernetes client error = %v", err) - } +func doRollingUpgrade(config util.Config) { + clients := kube.GetClients() - err = PerformRollingUpgrade(client, config, upgradeFuncs) + rollingUpgrade(clients, config, GetDeploymentRollingUpgradeFuncs()) + rollingUpgrade(clients, config, GetDaemonSetRollingUpgradeFuncs()) + rollingUpgrade(clients, config, GetStatefulSetRollingUpgradeFuncs()) + + if kube.IsOpenshift { + rollingUpgrade(clients, config, GetDeploymentConfigRollingUpgradeFuncs()) + } +} + +func rollingUpgrade(clients kube.Clients, config util.Config, upgradeFuncs callbacks.RollingUpgradeFuncs) { + + err := PerformRollingUpgrade(clients, config, upgradeFuncs) if err != nil { logrus.Errorf("Rolling upgrade for '%s' failed with error = %v", config.ResourceName, err) } } // PerformRollingUpgrade upgrades the deployment if there is any change in configmap or secret data -func PerformRollingUpgrade(client kubernetes.Interface, config util.Config, upgradeFuncs callbacks.RollingUpgradeFuncs) error { - items := upgradeFuncs.ItemsFunc(client, config.Namespace) +func PerformRollingUpgrade(clients kube.Clients, config util.Config, upgradeFuncs callbacks.RollingUpgradeFuncs) error { + items := upgradeFuncs.ItemsFunc(clients, config.Namespace) var err error for _, i := range items { // find correct annotation and update the resource @@ -95,7 +108,7 @@ func PerformRollingUpgrade(client kubernetes.Interface, config util.Config, upgr } if result == constants.Updated { - err = upgradeFuncs.UpdateFunc(client, config.Namespace, i) + err = upgradeFuncs.UpdateFunc(clients, config.Namespace, i) resourceName := util.ToObjectMeta(i).Name if err != nil { logrus.Errorf("Update for '%s' of type '%s' in namespace '%s' failed with error %v", resourceName, upgradeFuncs.ResourceType, config.Namespace, err) diff --git a/internal/pkg/handler/upgrade_test.go b/internal/pkg/handler/upgrade_test.go index 9b40806a..c7780006 100644 --- a/internal/pkg/handler/upgrade_test.go +++ b/internal/pkg/handler/upgrade_test.go @@ -10,20 +10,21 @@ import ( "github.com/stakater/Reloader/internal/pkg/options" "github.com/stakater/Reloader/internal/pkg/testutil" "github.com/stakater/Reloader/internal/pkg/util" + "github.com/stakater/Reloader/pkg/kube" testclient "k8s.io/client-go/kubernetes/fake" ) var ( - client = testclient.NewSimpleClientset() + clients = kube.Clients{KubernetesClient: testclient.NewSimpleClientset()} namespace = "test-handler-" + testutil.RandSeq(5) configmapName = "testconfigmap-handler-" + testutil.RandSeq(5) secretName = "testsecret-handler-" + testutil.RandSeq(5) - configmapWithInitContainer = "testconfigmapInitContainerhandler-" + testutil.RandSeq(3) - secretWithInitContainer = "testsecretWithInitContainer-handler-" + testutil.RandSeq(3) - configmapWithInitEnv = "configmapWithInitEnv-" + testutil.RandSeq(3) - secretWithInitEnv = "secretWithInitEnv-handler-" + testutil.RandSeq(3) - configmapWithEnvName = "testconfigmapWithEnv-handler-" + testutil.RandSeq(3) - configmapWithEnvFromName = "testconfigmapWithEnvFrom-handler-" + testutil.RandSeq(3) + configmapWithInitContainer = "testconfigmapInitContainerhandler-" + testutil.RandSeq(5) + secretWithInitContainer = "testsecretWithInitContainer-handler-" + testutil.RandSeq(5) + configmapWithInitEnv = "configmapWithInitEnv-" + testutil.RandSeq(5) + secretWithInitEnv = "secretWithInitEnv-handler-" + testutil.RandSeq(5) + configmapWithEnvName = "testconfigmapWithEnv-handler-" + testutil.RandSeq(5) + configmapWithEnvFromName = "testconfigmapWithEnvFrom-handler-" + testutil.RandSeq(5) secretWithEnvName = "testsecretWithEnv-handler-" + testutil.RandSeq(5) secretWithEnvFromName = "testsecretWithEnvFrom-handler-" + testutil.RandSeq(5) ) @@ -31,7 +32,7 @@ var ( func TestMain(m *testing.M) { // Creating namespace - testutil.CreateNamespace(namespace, client) + testutil.CreateNamespace(namespace, clients.KubernetesClient) logrus.Infof("Setting up the test resources") setup() @@ -47,166 +48,166 @@ func TestMain(m *testing.M) { func setup() { // Creating configmap - _, err := testutil.CreateConfigMap(client, namespace, configmapName, "www.google.com") + _, err := testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapName, "www.google.com") if err != nil { logrus.Errorf("Error in configmap creation: %v", err) } // Creating secret data := "dGVzdFNlY3JldEVuY29kaW5nRm9yUmVsb2FkZXI=" - _, err = testutil.CreateSecret(client, namespace, secretName, data) + _, err = testutil.CreateSecret(clients.KubernetesClient, namespace, secretName, data) if err != nil { logrus.Errorf("Error in secret creation: %v", err) } - _, err = testutil.CreateConfigMap(client, namespace, configmapWithEnvName, "www.google.com") + _, err = testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapWithEnvName, "www.google.com") if err != nil { logrus.Errorf("Error in configmap creation: %v", err) } // Creating secret - _, err = testutil.CreateSecret(client, namespace, secretWithEnvName, data) + _, err = testutil.CreateSecret(clients.KubernetesClient, namespace, secretWithEnvName, data) if err != nil { logrus.Errorf("Error in secret creation: %v", err) } - _, err = testutil.CreateConfigMap(client, namespace, configmapWithEnvFromName, "www.google.com") + _, err = testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapWithEnvFromName, "www.google.com") if err != nil { logrus.Errorf("Error in configmap creation: %v", err) } // Creating secret - _, err = testutil.CreateSecret(client, namespace, secretWithInitEnv, data) + _, err = testutil.CreateSecret(clients.KubernetesClient, namespace, secretWithInitEnv, data) if err != nil { logrus.Errorf("Error in secret creation: %v", err) } - _, err = testutil.CreateConfigMap(client, namespace, configmapWithInitContainer, "www.google.com") + _, err = testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapWithInitContainer, "www.google.com") if err != nil { logrus.Errorf("Error in configmap creation: %v", err) } // Creating secret - _, err = testutil.CreateSecret(client, namespace, secretWithEnvFromName, data) + _, err = testutil.CreateSecret(clients.KubernetesClient, namespace, secretWithEnvFromName, data) if err != nil { logrus.Errorf("Error in secret creation: %v", err) } - _, err = testutil.CreateConfigMap(client, namespace, configmapWithInitContainer, "www.google.com") + _, err = testutil.CreateConfigMap(clients.KubernetesClient, namespace, configmapWithInitEnv, "www.google.com") if err != nil { logrus.Errorf("Error in configmap creation: %v", err) } // Creating secret - _, err = testutil.CreateSecret(client, namespace, secretWithInitContainer, data) + _, err = testutil.CreateSecret(clients.KubernetesClient, namespace, secretWithInitContainer, data) if err != nil { logrus.Errorf("Error in secret creation: %v", err) } // Creating Deployment with configmap - _, err = testutil.CreateDeployment(client, configmapName, namespace, true) + _, err = testutil.CreateDeployment(clients.KubernetesClient, configmapName, namespace, true) if err != nil { logrus.Errorf("Error in Deployment with configmap creation: %v", err) } // Creating Deployment with configmap mounted in init container - _, err = testutil.CreateDeploymentWithInitContainer(client, configmapWithInitContainer, namespace, true) + _, err = testutil.CreateDeploymentWithInitContainer(clients.KubernetesClient, configmapWithInitContainer, namespace, true) if err != nil { logrus.Errorf("Error in Deployment with configmap creation: %v", err) } // Creating Deployment with secret mounted in init container - _, err = testutil.CreateDeploymentWithInitContainer(client, secretWithInitContainer, namespace, true) + _, err = testutil.CreateDeploymentWithInitContainer(clients.KubernetesClient, secretWithInitContainer, namespace, true) if err != nil { logrus.Errorf("Error in Deployment with secret creation: %v", err) } // Creating Deployment with configmap mounted as Env in init container - _, err = testutil.CreateDeploymentWithInitContainer(client, configmapWithInitEnv, namespace, false) + _, err = testutil.CreateDeploymentWithInitContainer(clients.KubernetesClient, configmapWithInitEnv, namespace, false) if err != nil { logrus.Errorf("Error in Deployment with configmap creation: %v", err) } // Creating Deployment with secret mounted as Env in init container - _, err = testutil.CreateDeploymentWithInitContainer(client, secretWithInitEnv, namespace, false) + _, err = testutil.CreateDeploymentWithInitContainer(clients.KubernetesClient, secretWithInitEnv, namespace, false) if err != nil { logrus.Errorf("Error in Deployment with secret creation: %v", err) } // Creating Deployment with secret - _, err = testutil.CreateDeployment(client, secretName, namespace, true) + _, err = testutil.CreateDeployment(clients.KubernetesClient, secretName, namespace, true) if err != nil { logrus.Errorf("Error in Deployment with secret creation: %v", err) } // Creating Deployment with env var source as configmap - _, err = testutil.CreateDeployment(client, configmapWithEnvName, namespace, false) + _, err = testutil.CreateDeployment(clients.KubernetesClient, configmapWithEnvName, namespace, false) if err != nil { logrus.Errorf("Error in Deployment with configmap configmap as env var source creation: %v", err) } // Creating Deployment with env var source as secret - _, err = testutil.CreateDeployment(client, secretWithEnvName, namespace, false) + _, err = testutil.CreateDeployment(clients.KubernetesClient, secretWithEnvName, namespace, false) if err != nil { logrus.Errorf("Error in Deployment with secret configmap as env var source creation: %v", err) } // Creating Deployment with envFrom source as secret - _, err = testutil.CreateDeploymentWithEnvVarSource(client, configmapWithEnvFromName, namespace) + _, err = testutil.CreateDeploymentWithEnvVarSource(clients.KubernetesClient, configmapWithEnvFromName, namespace) if err != nil { logrus.Errorf("Error in Deployment with secret configmap as envFrom source creation: %v", err) } // Creating Deployment with envFrom source as secret - _, err = testutil.CreateDeploymentWithEnvVarSource(client, secretWithEnvFromName, namespace) + _, err = testutil.CreateDeploymentWithEnvVarSource(clients.KubernetesClient, secretWithEnvFromName, namespace) if err != nil { logrus.Errorf("Error in Deployment with secret configmap as envFrom source creation: %v", err) } // Creating DaemonSet with configmap - _, err = testutil.CreateDaemonSet(client, configmapName, namespace, true) + _, err = testutil.CreateDaemonSet(clients.KubernetesClient, configmapName, namespace, true) if err != nil { logrus.Errorf("Error in DaemonSet with configmap creation: %v", err) } // Creating DaemonSet with secret - _, err = testutil.CreateDaemonSet(client, secretName, namespace, true) + _, err = testutil.CreateDaemonSet(clients.KubernetesClient, secretName, namespace, true) if err != nil { logrus.Errorf("Error in DaemonSet with secret creation: %v", err) } // Creating DaemonSet with env var source as configmap - _, err = testutil.CreateDaemonSet(client, configmapWithEnvName, namespace, false) + _, err = testutil.CreateDaemonSet(clients.KubernetesClient, configmapWithEnvName, namespace, false) if err != nil { logrus.Errorf("Error in DaemonSet with configmap as env var source creation: %v", err) } // Creating DaemonSet with env var source as secret - _, err = testutil.CreateDaemonSet(client, secretWithEnvName, namespace, false) + _, err = testutil.CreateDaemonSet(clients.KubernetesClient, secretWithEnvName, namespace, false) if err != nil { logrus.Errorf("Error in DaemonSet with secret configmap as env var source creation: %v", err) } // Creating StatefulSet with configmap - _, err = testutil.CreateStatefulSet(client, configmapName, namespace, true) + _, err = testutil.CreateStatefulSet(clients.KubernetesClient, configmapName, namespace, true) if err != nil { logrus.Errorf("Error in StatefulSet with configmap creation: %v", err) } // Creating StatefulSet with secret - _, err = testutil.CreateStatefulSet(client, secretName, namespace, true) + _, err = testutil.CreateStatefulSet(clients.KubernetesClient, secretName, namespace, true) if err != nil { logrus.Errorf("Error in StatefulSet with secret creation: %v", err) } // Creating StatefulSet with env var source as configmap - _, err = testutil.CreateStatefulSet(client, configmapWithEnvName, namespace, false) + _, err = testutil.CreateStatefulSet(clients.KubernetesClient, configmapWithEnvName, namespace, false) if err != nil { logrus.Errorf("Error in StatefulSet with configmap configmap as env var source creation: %v", err) } // Creating StatefulSet with env var source as secret - _, err = testutil.CreateStatefulSet(client, secretWithEnvName, namespace, false) + _, err = testutil.CreateStatefulSet(clients.KubernetesClient, secretWithEnvName, namespace, false) if err != nil { logrus.Errorf("Error in StatefulSet with secret configmap as env var source creation: %v", err) } @@ -215,175 +216,175 @@ func setup() { func teardown() { // Deleting Deployment with configmap - deploymentError := testutil.DeleteDeployment(client, namespace, configmapName) + deploymentError := testutil.DeleteDeployment(clients.KubernetesClient, namespace, configmapName) if deploymentError != nil { logrus.Errorf("Error while deleting deployment with configmap %v", deploymentError) } // Deleting Deployment with secret - deploymentError = testutil.DeleteDeployment(client, namespace, secretName) + deploymentError = testutil.DeleteDeployment(clients.KubernetesClient, namespace, secretName) if deploymentError != nil { logrus.Errorf("Error while deleting deployment with secret %v", deploymentError) } // Deleting Deployment with configmap as env var source - deploymentError = testutil.DeleteDeployment(client, namespace, configmapWithEnvName) + deploymentError = testutil.DeleteDeployment(clients.KubernetesClient, namespace, configmapWithEnvName) if deploymentError != nil { logrus.Errorf("Error while deleting deployment with configmap as env var source %v", deploymentError) } // Deleting Deployment with secret - deploymentError = testutil.DeleteDeployment(client, namespace, secretWithEnvName) + deploymentError = testutil.DeleteDeployment(clients.KubernetesClient, namespace, secretWithEnvName) if deploymentError != nil { logrus.Errorf("Error while deleting deployment with secret as env var source %v", deploymentError) } // Deleting Deployment with configmap mounted in init container - deploymentError = testutil.DeleteDeployment(client, namespace, configmapWithInitContainer) + deploymentError = testutil.DeleteDeployment(clients.KubernetesClient, namespace, configmapWithInitContainer) if deploymentError != nil { logrus.Errorf("Error while deleting deployment with configmap mounted in init container %v", deploymentError) } // Deleting Deployment with secret mounted in init container - deploymentError = testutil.DeleteDeployment(client, namespace, secretWithInitContainer) + deploymentError = testutil.DeleteDeployment(clients.KubernetesClient, namespace, secretWithInitContainer) if deploymentError != nil { logrus.Errorf("Error while deleting deployment with secret mounted in init container %v", deploymentError) } // Deleting Deployment with configmap mounted as env in init container - deploymentError = testutil.DeleteDeployment(client, namespace, configmapWithInitEnv) + deploymentError = testutil.DeleteDeployment(clients.KubernetesClient, namespace, configmapWithInitEnv) if deploymentError != nil { logrus.Errorf("Error while deleting deployment with configmap mounted as env in init container %v", deploymentError) } // Deleting Deployment with secret mounted as env in init container - deploymentError = testutil.DeleteDeployment(client, namespace, secretWithInitEnv) + deploymentError = testutil.DeleteDeployment(clients.KubernetesClient, namespace, secretWithInitEnv) if deploymentError != nil { logrus.Errorf("Error while deleting deployment with secret mounted as env in init container %v", deploymentError) } // Deleting Deployment with configmap as envFrom source - deploymentError = testutil.DeleteDeployment(client, namespace, configmapWithEnvFromName) + deploymentError = testutil.DeleteDeployment(clients.KubernetesClient, namespace, configmapWithEnvFromName) if deploymentError != nil { logrus.Errorf("Error while deleting deployment with configmap as envFrom source %v", deploymentError) } // Deleting Deployment with secret as envFrom source - deploymentError = testutil.DeleteDeployment(client, namespace, secretWithEnvFromName) + deploymentError = testutil.DeleteDeployment(clients.KubernetesClient, namespace, secretWithEnvFromName) if deploymentError != nil { logrus.Errorf("Error while deleting deployment with secret as envFrom source %v", deploymentError) } // Deleting DaemonSet with configmap - daemonSetError := testutil.DeleteDaemonSet(client, namespace, configmapName) + daemonSetError := testutil.DeleteDaemonSet(clients.KubernetesClient, namespace, configmapName) if daemonSetError != nil { logrus.Errorf("Error while deleting daemonSet with configmap %v", daemonSetError) } // Deleting Deployment with secret - daemonSetError = testutil.DeleteDaemonSet(client, namespace, secretName) + daemonSetError = testutil.DeleteDaemonSet(clients.KubernetesClient, namespace, secretName) if daemonSetError != nil { logrus.Errorf("Error while deleting daemonSet with secret %v", daemonSetError) } // Deleting Deployment with configmap as env var source - daemonSetError = testutil.DeleteDaemonSet(client, namespace, configmapWithEnvName) + daemonSetError = testutil.DeleteDaemonSet(clients.KubernetesClient, namespace, configmapWithEnvName) if daemonSetError != nil { logrus.Errorf("Error while deleting daemonSet with configmap as env var source %v", daemonSetError) } // Deleting Deployment with secret as env var source - daemonSetError = testutil.DeleteDaemonSet(client, namespace, secretWithEnvName) + daemonSetError = testutil.DeleteDaemonSet(clients.KubernetesClient, namespace, secretWithEnvName) if daemonSetError != nil { logrus.Errorf("Error while deleting daemonSet with secret as env var source %v", daemonSetError) } // Deleting StatefulSet with configmap - statefulSetError := testutil.DeleteStatefulSet(client, namespace, configmapName) + statefulSetError := testutil.DeleteStatefulSet(clients.KubernetesClient, namespace, configmapName) if statefulSetError != nil { logrus.Errorf("Error while deleting statefulSet with configmap %v", statefulSetError) } // Deleting Deployment with secret - statefulSetError = testutil.DeleteStatefulSet(client, namespace, secretName) + statefulSetError = testutil.DeleteStatefulSet(clients.KubernetesClient, namespace, secretName) if statefulSetError != nil { logrus.Errorf("Error while deleting statefulSet with secret %v", statefulSetError) } // Deleting StatefulSet with configmap as env var source - statefulSetError = testutil.DeleteStatefulSet(client, namespace, configmapWithEnvName) + statefulSetError = testutil.DeleteStatefulSet(clients.KubernetesClient, namespace, configmapWithEnvName) if statefulSetError != nil { logrus.Errorf("Error while deleting statefulSet with configmap as env var source %v", statefulSetError) } // Deleting Deployment with secret as env var source - statefulSetError = testutil.DeleteStatefulSet(client, namespace, secretWithEnvName) + statefulSetError = testutil.DeleteStatefulSet(clients.KubernetesClient, namespace, secretWithEnvName) if statefulSetError != nil { logrus.Errorf("Error while deleting statefulSet with secret as env var source %v", statefulSetError) } // Deleting Configmap - err := testutil.DeleteConfigMap(client, namespace, configmapName) + err := testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapName) if err != nil { logrus.Errorf("Error while deleting the configmap %v", err) } // Deleting Secret - err = testutil.DeleteSecret(client, namespace, secretName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretName) if err != nil { logrus.Errorf("Error while deleting the secret %v", err) } // Deleting Configmap used as env var source - err = testutil.DeleteConfigMap(client, namespace, configmapWithEnvName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapWithEnvName) if err != nil { logrus.Errorf("Error while deleting the configmap used as env var source %v", err) } // Deleting Secret used as env var source - err = testutil.DeleteSecret(client, namespace, secretWithEnvName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretWithEnvName) if err != nil { logrus.Errorf("Error while deleting the secret used as env var source %v", err) } // Deleting Configmap used in init container - err = testutil.DeleteConfigMap(client, namespace, configmapWithInitContainer) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapWithInitContainer) if err != nil { logrus.Errorf("Error while deleting the configmap used in init container %v", err) } // Deleting Secret used in init container - err = testutil.DeleteSecret(client, namespace, secretWithInitContainer) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretWithInitContainer) if err != nil { logrus.Errorf("Error while deleting the secret used in init container %v", err) } // Deleting Configmap used as env var source - err = testutil.DeleteConfigMap(client, namespace, configmapWithEnvFromName) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapWithEnvFromName) if err != nil { logrus.Errorf("Error while deleting the configmap used as env var source %v", err) } // Deleting Secret used as env var source - err = testutil.DeleteSecret(client, namespace, secretWithEnvFromName) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretWithEnvFromName) if err != nil { logrus.Errorf("Error while deleting the secret used as env var source %v", err) } // Deleting Configmap used as env var source - err = testutil.DeleteConfigMap(client, namespace, configmapWithInitEnv) + err = testutil.DeleteConfigMap(clients.KubernetesClient, namespace, configmapWithInitEnv) if err != nil { logrus.Errorf("Error while deleting the configmap used as env var source in init container %v", err) } // Deleting Secret used as env var source - err = testutil.DeleteSecret(client, namespace, secretWithInitEnv) + err = testutil.DeleteSecret(clients.KubernetesClient, namespace, secretWithInitEnv) if err != nil { logrus.Errorf("Error while deleting the secret used as env var source in init container %v", err) } // Deleting namespace - testutil.DeleteNamespace(namespace, client) + testutil.DeleteNamespace(namespace, clients.KubernetesClient) } @@ -402,14 +403,14 @@ func TestRollingUpgradeForDeploymentWithConfigmap(t *testing.T) { config := getConfigWithAnnotations(constants.ConfigmapEnvVarPostfix, configmapName, shaData, options.ConfigmapUpdateOnChangeAnnotation) deploymentFuncs := GetDeploymentRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, deploymentFuncs) + err := PerformRollingUpgrade(clients, config, deploymentFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for Deployment with Configmap") } logrus.Infof("Verifying deployment update") - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } @@ -420,14 +421,14 @@ func TestRollingUpgradeForDeploymentWithConfigmapInInitContainer(t *testing.T) { config := getConfigWithAnnotations(constants.ConfigmapEnvVarPostfix, configmapWithInitContainer, shaData, options.ConfigmapUpdateOnChangeAnnotation) deploymentFuncs := GetDeploymentRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, deploymentFuncs) + err := PerformRollingUpgrade(clients, config, deploymentFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for Deployment with Configmap") } logrus.Infof("Verifying deployment update") - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } @@ -438,14 +439,14 @@ func TestRollingUpgradeForDeploymentWithConfigmapAsEnvVar(t *testing.T) { config := getConfigWithAnnotations(constants.ConfigmapEnvVarPostfix, configmapWithEnvName, shaData, options.ReloaderAutoAnnotation) deploymentFuncs := GetDeploymentRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, deploymentFuncs) + err := PerformRollingUpgrade(clients, config, deploymentFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for Deployment with Configmap used as env var") } logrus.Infof("Verifying deployment update") - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } @@ -456,14 +457,14 @@ func TestRollingUpgradeForDeploymentWithConfigmapAsEnvVarInInitContainer(t *test config := getConfigWithAnnotations(constants.ConfigmapEnvVarPostfix, configmapWithInitEnv, shaData, options.ReloaderAutoAnnotation) deploymentFuncs := GetDeploymentRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, deploymentFuncs) + err := PerformRollingUpgrade(clients, config, deploymentFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for Deployment with Configmap used as env var") } logrus.Infof("Verifying deployment update") - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } @@ -474,14 +475,14 @@ func TestRollingUpgradeForDeploymentWithConfigmapAsEnvVarFrom(t *testing.T) { config := getConfigWithAnnotations(constants.ConfigmapEnvVarPostfix, configmapWithEnvFromName, shaData, options.ReloaderAutoAnnotation) deploymentFuncs := GetDeploymentRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, deploymentFuncs) + err := PerformRollingUpgrade(clients, config, deploymentFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for Deployment with Configmap used as env var") } logrus.Infof("Verifying deployment update") - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } @@ -492,14 +493,14 @@ func TestRollingUpgradeForDeploymentWithSecret(t *testing.T) { config := getConfigWithAnnotations(constants.SecretEnvVarPostfix, secretName, shaData, options.SecretUpdateOnChangeAnnotation) deploymentFuncs := GetDeploymentRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, deploymentFuncs) + err := PerformRollingUpgrade(clients, config, deploymentFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for Deployment with Secret") } logrus.Infof("Verifying deployment update") - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } @@ -510,14 +511,14 @@ func TestRollingUpgradeForDeploymentWithSecretinInitContainer(t *testing.T) { config := getConfigWithAnnotations(constants.SecretEnvVarPostfix, secretWithInitContainer, shaData, options.SecretUpdateOnChangeAnnotation) deploymentFuncs := GetDeploymentRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, deploymentFuncs) + err := PerformRollingUpgrade(clients, config, deploymentFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for Deployment with Secret") } logrus.Infof("Verifying deployment update") - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } @@ -528,14 +529,14 @@ func TestRollingUpgradeForDeploymentWithSecretAsEnvVar(t *testing.T) { config := getConfigWithAnnotations(constants.SecretEnvVarPostfix, secretWithEnvName, shaData, options.ReloaderAutoAnnotation) deploymentFuncs := GetDeploymentRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, deploymentFuncs) + err := PerformRollingUpgrade(clients, config, deploymentFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for Deployment with Secret") } logrus.Infof("Verifying deployment update") - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } @@ -546,14 +547,14 @@ func TestRollingUpgradeForDeploymentWithSecretAsEnvVarFrom(t *testing.T) { config := getConfigWithAnnotations(constants.SecretEnvVarPostfix, secretWithEnvFromName, shaData, options.ReloaderAutoAnnotation) deploymentFuncs := GetDeploymentRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, deploymentFuncs) + err := PerformRollingUpgrade(clients, config, deploymentFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for Deployment with Secret") } logrus.Infof("Verifying deployment update") - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } @@ -564,14 +565,14 @@ func TestRollingUpgradeForDeploymentWithSecretAsEnvVarInInitContainer(t *testing config := getConfigWithAnnotations(constants.SecretEnvVarPostfix, secretWithInitEnv, shaData, options.ReloaderAutoAnnotation) deploymentFuncs := GetDeploymentRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, deploymentFuncs) + err := PerformRollingUpgrade(clients, config, deploymentFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for Deployment with Secret") } logrus.Infof("Verifying deployment update") - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, deploymentFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, deploymentFuncs) if !updated { t.Errorf("Deployment was not updated") } @@ -582,14 +583,14 @@ func TestRollingUpgradeForDaemonSetWithConfigmap(t *testing.T) { config := getConfigWithAnnotations(constants.ConfigmapEnvVarPostfix, configmapName, shaData, options.ConfigmapUpdateOnChangeAnnotation) daemonSetFuncs := GetDaemonSetRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, daemonSetFuncs) + err := PerformRollingUpgrade(clients, config, daemonSetFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for DaemonSet with configmap") } logrus.Infof("Verifying daemonSet update") - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, daemonSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, daemonSetFuncs) if !updated { t.Errorf("DaemonSet was not updated") } @@ -600,14 +601,14 @@ func TestRollingUpgradeForDaemonSetWithConfigmapAsEnvVar(t *testing.T) { config := getConfigWithAnnotations(constants.ConfigmapEnvVarPostfix, configmapWithEnvName, shaData, options.ReloaderAutoAnnotation) daemonSetFuncs := GetDaemonSetRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, daemonSetFuncs) + err := PerformRollingUpgrade(clients, config, daemonSetFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for DaemonSet with configmap used as env var") } logrus.Infof("Verifying daemonSet update") - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, daemonSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, daemonSetFuncs) if !updated { t.Errorf("DaemonSet was not updated") } @@ -618,14 +619,14 @@ func TestRollingUpgradeForDaemonSetWithSecret(t *testing.T) { config := getConfigWithAnnotations(constants.SecretEnvVarPostfix, secretName, shaData, options.SecretUpdateOnChangeAnnotation) daemonSetFuncs := GetDaemonSetRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, daemonSetFuncs) + err := PerformRollingUpgrade(clients, config, daemonSetFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for DaemonSet with secret") } logrus.Infof("Verifying daemonSet update") - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, daemonSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, daemonSetFuncs) if !updated { t.Errorf("DaemonSet was not updated") } @@ -636,14 +637,14 @@ func TestRollingUpgradeForStatefulSetWithConfigmap(t *testing.T) { config := getConfigWithAnnotations(constants.ConfigmapEnvVarPostfix, configmapName, shaData, options.ConfigmapUpdateOnChangeAnnotation) statefulSetFuncs := GetStatefulSetRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, statefulSetFuncs) + err := PerformRollingUpgrade(clients, config, statefulSetFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for StatefulSet with configmap") } logrus.Infof("Verifying statefulSet update") - updated := testutil.VerifyResourceUpdate(client, config, constants.ConfigmapEnvVarPostfix, statefulSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.ConfigmapEnvVarPostfix, statefulSetFuncs) if !updated { t.Errorf("StatefulSet was not updated") } @@ -654,14 +655,14 @@ func TestRollingUpgradeForStatefulSetWithSecret(t *testing.T) { config := getConfigWithAnnotations(constants.SecretEnvVarPostfix, secretName, shaData, options.SecretUpdateOnChangeAnnotation) statefulSetFuncs := GetStatefulSetRollingUpgradeFuncs() - err := PerformRollingUpgrade(client, config, statefulSetFuncs) + err := PerformRollingUpgrade(clients, config, statefulSetFuncs) time.Sleep(5 * time.Second) if err != nil { t.Errorf("Rolling upgrade failed for StatefulSet with secret") } logrus.Infof("Verifying statefulSet update") - updated := testutil.VerifyResourceUpdate(client, config, constants.SecretEnvVarPostfix, statefulSetFuncs) + updated := testutil.VerifyResourceUpdate(clients, config, constants.SecretEnvVarPostfix, statefulSetFuncs) if !updated { t.Errorf("StatefulSet was not updated") } diff --git a/internal/pkg/testutil/kube.go b/internal/pkg/testutil/kube.go index feaec282..a676059b 100644 --- a/internal/pkg/testutil/kube.go +++ b/internal/pkg/testutil/kube.go @@ -7,6 +7,8 @@ import ( "strings" "time" + openshiftv1 "github.com/openshift/api/apps/v1" + appsclient "github.com/openshift/client-go/apps/clientset/versioned" "github.com/sirupsen/logrus" "github.com/stakater/Reloader/internal/pkg/callbacks" "github.com/stakater/Reloader/internal/pkg/constants" @@ -30,14 +32,6 @@ var ( SecretResourceType = "secrets" ) -func GetClient() *kubernetes.Clientset { - newClient, err := kube.GetClient() - if err != nil { - logrus.Fatalf("Unable to create Kubernetes client error = %v", err) - } - return newClient -} - // CreateNamespace creates namespace for testing func CreateNamespace(namespace string, client kubernetes.Interface) { _, err := client.CoreV1().Namespaces().Create(&v1.Namespace{ObjectMeta: metav1.ObjectMeta{Name: namespace}}) @@ -185,8 +179,8 @@ func getPodTemplateSpecWithEnvVarSources(name string) v1.PodTemplateSpec { Spec: v1.PodSpec{ Containers: []v1.Container{ { - Image: "tutum/hello-world", - Name: name, + Image: "tutum/hello-world", + Name: name, EnvFrom: getEnvVarSources(name), }, }, @@ -226,8 +220,8 @@ func getPodTemplateSpecWithInitContainer(name string) v1.PodTemplateSpec { Spec: v1.PodSpec{ InitContainers: []v1.Container{ { - Image: "busybox", - Name: "busyBox", + Image: "busybox", + Name: "busyBox", VolumeMounts: getVolumeMounts(name), }, }, @@ -256,8 +250,8 @@ func getPodTemplateSpecWithInitContainerAndEnv(name string) v1.PodTemplateSpec { Spec: v1.PodSpec{ InitContainers: []v1.Container{ { - Image: "busybox", - Name: "busyBox", + Image: "busybox", + Name: "busyBox", EnvFrom: getEnvVarSources(name), }, }, @@ -292,6 +286,22 @@ func GetDeployment(namespace string, deploymentName string) *v1beta1.Deployment } } +// GetDeploymentConfig provides deployment for testing +func GetDeploymentConfig(namespace string, deploymentConfigName string) *openshiftv1.DeploymentConfig { + replicaset := int32(1) + podTemplateSpecWithVolume := getPodTemplateSpecWithVolumes(deploymentConfigName) + return &openshiftv1.DeploymentConfig{ + ObjectMeta: getObjectMeta(namespace, deploymentConfigName, false), + Spec: openshiftv1.DeploymentConfigSpec{ + Replicas: replicaset, + Strategy: openshiftv1.DeploymentStrategy{ + Type: openshiftv1.DeploymentStrategyTypeRolling, + }, + Template: &podTemplateSpecWithVolume, + }, + } +} + // GetDeploymentWithInitContainer provides deployment with init container and volumeMounts func GetDeploymentWithInitContainer(namespace string, deploymentName string) *v1beta1.Deployment { replicaset := int32(1) @@ -336,6 +346,21 @@ func GetDeploymentWithEnvVars(namespace string, deploymentName string) *v1beta1. } } +func GetDeploymentConfigWithEnvVars(namespace string, deploymentConfigName string) *openshiftv1.DeploymentConfig { + replicaset := int32(1) + podTemplateSpecWithEnvVars := getPodTemplateSpecWithEnvVars(deploymentConfigName) + return &openshiftv1.DeploymentConfig{ + ObjectMeta: getObjectMeta(namespace, deploymentConfigName, false), + Spec: openshiftv1.DeploymentConfigSpec{ + Replicas: replicaset, + Strategy: openshiftv1.DeploymentStrategy{ + Type: openshiftv1.DeploymentStrategyTypeRolling, + }, + Template: &podTemplateSpecWithEnvVars, + }, + } +} + func GetDeploymentWithEnvVarSources(namespace string, deploymentName string) *v1beta1.Deployment { replicaset := int32(1) return &v1beta1.Deployment{ @@ -485,7 +510,7 @@ func CreateConfigMap(client kubernetes.Interface, namespace string, configmapNam logrus.Infof("Creating configmap") configmapClient := client.CoreV1().ConfigMaps(namespace) _, err := configmapClient.Create(GetConfigmap(namespace, configmapName, data)) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return configmapClient, err } @@ -494,7 +519,7 @@ func CreateSecret(client kubernetes.Interface, namespace string, secretName stri logrus.Infof("Creating secret") secretClient := client.CoreV1().Secrets(namespace) _, err := secretClient.Create(GetSecret(namespace, secretName, data)) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return secretClient, err } @@ -509,22 +534,37 @@ func CreateDeployment(client kubernetes.Interface, deploymentName string, namesp deploymentObj = GetDeploymentWithEnvVars(namespace, deploymentName) } deployment, err := deploymentClient.Create(deploymentObj) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return deployment, err } +// CreateDeploymentConfig creates a deploymentConfig in given namespace and returns the DeploymentConfig +func CreateDeploymentConfig(client appsclient.Interface, deploymentName string, namespace string, volumeMount bool) (*openshiftv1.DeploymentConfig, error) { + logrus.Infof("Creating DeploymentConfig") + deploymentConfigsClient := client.AppsV1().DeploymentConfigs(namespace) + var deploymentConfigObj *openshiftv1.DeploymentConfig + if volumeMount { + deploymentConfigObj = GetDeploymentConfig(namespace, deploymentName) + } else { + deploymentConfigObj = GetDeploymentConfigWithEnvVars(namespace, deploymentName) + } + deploymentConfig, err := deploymentConfigsClient.Create(deploymentConfigObj) + time.Sleep(5 * time.Second) + return deploymentConfig, err +} + // CreateDeploymentWithInitContainer creates a deployment in given namespace with init container and returns the Deployment func CreateDeploymentWithInitContainer(client kubernetes.Interface, deploymentName string, namespace string, volumeMount bool) (*v1beta1.Deployment, error) { logrus.Infof("Creating Deployment") deploymentClient := client.ExtensionsV1beta1().Deployments(namespace) var deploymentObj *v1beta1.Deployment if volumeMount { - deploymentObj = GetDeploymentWithInitContainer(namespace, deploymentName) + deploymentObj = GetDeploymentWithInitContainer(namespace, deploymentName) } else { deploymentObj = GetDeploymentWithInitContainerAndEnv(namespace, deploymentName) } deployment, err := deploymentClient.Create(deploymentObj) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return deployment, err } @@ -534,7 +574,7 @@ func CreateDeploymentWithEnvVarSource(client kubernetes.Interface, deploymentNam deploymentClient := client.ExtensionsV1beta1().Deployments(namespace) deploymentObj := GetDeploymentWithEnvVarSources(namespace, deploymentName) deployment, err := deploymentClient.Create(deploymentObj) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return deployment, err } @@ -549,7 +589,7 @@ func CreateDaemonSet(client kubernetes.Interface, daemonsetName string, namespac daemonsetObj = GetDaemonSetWithEnvVars(namespace, daemonsetName) } daemonset, err := daemonsetClient.Create(daemonsetObj) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return daemonset, err } @@ -564,7 +604,7 @@ func CreateStatefulSet(client kubernetes.Interface, statefulsetName string, name statefulsetObj = GetStatefulSetWithEnvVar(namespace, statefulsetName) } statefulset, err := statefulsetClient.Create(statefulsetObj) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return statefulset, err } @@ -572,15 +612,23 @@ func CreateStatefulSet(client kubernetes.Interface, statefulsetName string, name func DeleteDeployment(client kubernetes.Interface, namespace string, deploymentName string) error { logrus.Infof("Deleting Deployment") deploymentError := client.ExtensionsV1beta1().Deployments(namespace).Delete(deploymentName, &metav1.DeleteOptions{}) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return deploymentError } +// DeleteDeploymentConfig deletes a deploymentConfig in given namespace and returns the error if any +func DeleteDeploymentConfig(client appsclient.Interface, namespace string, deploymentConfigName string) error { + logrus.Infof("Deleting DeploymentConfig") + deploymentConfigError := client.AppsV1().DeploymentConfigs(namespace).Delete(deploymentConfigName, &metav1.DeleteOptions{}) + time.Sleep(3 * time.Second) + return deploymentConfigError +} + // DeleteDaemonSet creates a daemonset in given namespace and returns the error if any func DeleteDaemonSet(client kubernetes.Interface, namespace string, daemonsetName string) error { logrus.Infof("Deleting DaemonSet %s", daemonsetName) daemonsetError := client.ExtensionsV1beta1().DaemonSets(namespace).Delete(daemonsetName, &metav1.DeleteOptions{}) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return daemonsetError } @@ -588,7 +636,7 @@ func DeleteDaemonSet(client kubernetes.Interface, namespace string, daemonsetNam func DeleteStatefulSet(client kubernetes.Interface, namespace string, statefulsetName string) error { logrus.Infof("Deleting StatefulSet %s", statefulsetName) statefulsetError := client.AppsV1beta1().StatefulSets(namespace).Delete(statefulsetName, &metav1.DeleteOptions{}) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return statefulsetError } @@ -602,7 +650,7 @@ func UpdateConfigMap(configmapClient core_v1.ConfigMapInterface, namespace strin configmap = GetConfigmap(namespace, configmapName, data) } _, updateErr := configmapClient.Update(configmap) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return updateErr } @@ -616,7 +664,7 @@ func UpdateSecret(secretClient core_v1.SecretInterface, namespace string, secret secret = GetSecret(namespace, secretName, data) } _, updateErr := secretClient.Update(secret) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return updateErr } @@ -624,7 +672,7 @@ func UpdateSecret(secretClient core_v1.SecretInterface, namespace string, secret func DeleteConfigMap(client kubernetes.Interface, namespace string, configmapName string) error { logrus.Infof("Deleting configmap %q.\n", configmapName) err := client.CoreV1().ConfigMaps(namespace).Delete(configmapName, &metav1.DeleteOptions{}) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return err } @@ -632,7 +680,7 @@ func DeleteConfigMap(client kubernetes.Interface, namespace string, configmapNam func DeleteSecret(client kubernetes.Interface, namespace string, secretName string) error { logrus.Infof("Deleting secret %q.\n", secretName) err := client.CoreV1().Secrets(namespace).Delete(secretName, &metav1.DeleteOptions{}) - time.Sleep(10 * time.Second) + time.Sleep(3 * time.Second) return err } @@ -647,8 +695,8 @@ func RandSeq(n int) string { } // VerifyResourceUpdate verifies whether the rolling upgrade happened or not -func VerifyResourceUpdate(client kubernetes.Interface, config util.Config, envVarPostfix string, upgradeFuncs callbacks.RollingUpgradeFuncs) bool { - items := upgradeFuncs.ItemsFunc(client, config.Namespace) +func VerifyResourceUpdate(clients kube.Clients, config util.Config, envVarPostfix string, upgradeFuncs callbacks.RollingUpgradeFuncs) bool { + items := upgradeFuncs.ItemsFunc(clients, config.Namespace) for _, i := range items { containers := upgradeFuncs.ContainersFunc(i) // match statefulsets with the correct annotation diff --git a/pkg/kube/client.go b/pkg/kube/client.go index 11c61e16..2d10ff92 100644 --- a/pkg/kube/client.go +++ b/pkg/kube/client.go @@ -3,13 +3,80 @@ package kube import ( "os" + "k8s.io/client-go/tools/clientcmd" + + appsclient "github.com/openshift/client-go/apps/clientset/versioned" + "github.com/sirupsen/logrus" "k8s.io/client-go/kubernetes" "k8s.io/client-go/rest" - "k8s.io/client-go/tools/clientcmd" ) -// GetClient gets the client for k8s, if ~/.kube/config exists so get that config else incluster config -func GetClient() (*kubernetes.Clientset, error) { +// Clients struct exposes interfaces for kubernetes as well as openshift if available +type Clients struct { + KubernetesClient kubernetes.Interface + OpenshiftAppsClient appsclient.Interface +} + +var ( + // IsOpenshift is true if environment is Openshift, it is false if environment is Kubernetes + IsOpenshift = isOpenshift() +) + +// GetClients returns a `Clients` object containing both openshift and kubernetes clients with an openshift identifier +func GetClients() Clients { + client, err := GetKubernetesClient() + if err != nil { + logrus.Fatalf("Unable to create Kubernetes client error = %v", err) + } + + var appsClient *appsclient.Clientset + + if IsOpenshift { + appsClient, err = GetOpenshiftAppsClient() + if err != nil { + logrus.Warnf("Unable to create Openshift Apps client error = %v", err) + } + } + + return Clients{ + KubernetesClient: client, + OpenshiftAppsClient: appsClient, + } +} + +func isOpenshift() bool { + client, err := GetKubernetesClient() + if err != nil { + logrus.Fatalf("Unable to create Kubernetes client error = %v", err) + } + _, err = client.RESTClient().Get().AbsPath("/apis/project.openshift.io").Do().Raw() + if err == nil { + logrus.Info("Environment: Openshift") + return true + } + logrus.Info("Environment: Kubernetes") + return false +} + +// GetOpenshiftAppsClient returns an Openshift Client that can query on Apps +func GetOpenshiftAppsClient() (*appsclient.Clientset, error) { + config, err := getConfig() + if err != nil { + return nil, err + } + return appsclient.NewForConfig(config) +} + +// GetKubernetesClient gets the client for k8s, if ~/.kube/config exists so get that config else incluster config +func GetKubernetesClient() (*kubernetes.Clientset, error) { + config, err := getConfig() + if err != nil { + return nil, err + } + return kubernetes.NewForConfig(config) +} + +func getConfig() (*rest.Config, error) { var config *rest.Config var err error kubeconfigPath := os.Getenv("KUBECONFIG") @@ -31,5 +98,6 @@ func GetClient() (*kubernetes.Clientset, error) { if err != nil { return nil, err } - return kubernetes.NewForConfig(config) + + return config, nil } diff --git a/pkg/kube/resourcemapper.go b/pkg/kube/resourcemapper.go index bf62cc01..2d82ca28 100644 --- a/pkg/kube/resourcemapper.go +++ b/pkg/kube/resourcemapper.go @@ -1,7 +1,7 @@ package kube import ( - "k8s.io/api/core/v1" + v1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/runtime" )