Bump Version to v0.0.38

Add openshift flag to explicitly add rbac for openshift if desired

.dockerignore

@@ -0,0 +1 @@
+vendor

.version

@@ -1 +1 @@
-v0.0.32
+v0.0.38

Makefile

@@ -20,7 +20,7 @@ LDFLAGS =
 default: build test
 
 install:
-	"$(GLIDECMD)" install
+	"$(GLIDECMD)" install --strip-vendor
 
 build:
 	"$(GOCMD)" build ${GOFLAGS} ${LDFLAGS} -o "${BINARY}"

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
@@ -114,7 +114,41 @@ You can apply vanilla manifests by running the following command
 kubectl apply -f https://raw.githubusercontent.com/stakater/Reloader/master/deployments/kubernetes/reloader.yaml
 ```
 
-By default Reloader gets deployed in `default` namespace and watches changes `secrets` and `configmaps` in all namespaces.
+By default Reloader gets deployed in `default` namespace and watches changes `secrets` and `configmaps` in all namespaces. 
+
+Reloader can be configured to ignore the resources `secrets` and `configmaps` by passing the following args (`spec.template.spec.containers.args`) to its container :
+
+| Args | Description |
+|---|---|
+| --resources-to-ignore=configMaps | To ignore configMaps |
+| --resources-to-ignore=secrets | To ignore secrets |
+
+`Note`: At one time only one of these resource can be ignored, trying to do it will cause error in Reloader. Workaround for ignoring both resources is by scaling down the reloader pods to `0`. 
+
+
+### Vanilla kustomize
+
+You can also apply the vanilla manifests by running the following command
+```bash
+kubectl apply -k https://github.com/stakater/Reloader/deployments/kubernetes
+```
+Similarly to vanilla manifests get deployed in `default` namespace and watches changes `secrets` and `configmaps` in all namespaces.
+
+### Kustomize
+
+You can write your own `kustomization.yaml` using ours as a 'base' and write patches to tweak the configuration.
+
+```yaml
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+
+namePrefix: reloader-
+
+bases:
+  - https://github.com/stakater/Reloader/deployments/kubernetes
+
+namespace: reloader
+```
 
 ### Helm Charts
 
@@ -134,6 +168,17 @@ helm install stakater/reloader
 helm install stakater/reloader --set reloader.watchGlobally=false --namespace test
 ```
 
+Reloader can be configured to ignore the resources `secrets` and `configmaps` by using the following parameters of `values.yaml` file:
+
+| Parameter | Description | Type |
+|---|---|---|
+| ignoreSecrets | To ignore secrets. Valid value are either `true` or `false` | boolean |
+| ignoreConfigMaps | To ignore configMaps. Valid value are either `true` or `false` | boolean |
+
+`Note`: At one time only one of these resource can be ignored, trying to do it will cause error in helm template compilation.
+
+
+
 ## Help
 
 ### Documentation

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 /

deployments/kubernetes/chart/reloader/Chart.yaml

@@ -3,8 +3,8 @@
 apiVersion: v1
 name: reloader
 description: Reloader chart that runs on kubernetes
-version: v0.0.32
-appVersion: v0.0.32
+version: v0.0.38
+appVersion: v0.0.38
 keywords:
   - Reloader
   - kubernetes

deployments/kubernetes/chart/reloader/templates/clusterrole.yaml

@@ -16,12 +16,28 @@ rules:
   - apiGroups:
       - ""
     resources:
+{{- if .Values.reloader.ignoreSecrets }}{{- else }}
       - secrets
+{{- end }}
+{{- if .Values.reloader.ignoreConfigMaps }}{{- else }}
       - configmaps
+{{- end }}
     verbs:
       - list
       - get
       - watch
+{{- if or (.Capabilities.APIVersions.Has "apps.openshift.io/v1") (.Values.isOpenshift) }}
+  - apiGroups:
+      - "apps.openshift.io"
+      - ""
+    resources:
+      - deploymentconfigs
+    verbs:
+      - list
+      - get
+      - update
+      - patch
+{{- end }}
   - apiGroups:
       - "apps"
     resources:

deployments/kubernetes/chart/reloader/templates/deployment.yaml

@@ -87,21 +87,30 @@ spec:
           - mountPath: /tmp/
             name: tmp-volume
       {{- end }}
-      {{- if .Values.reloader.custom_annotations }}
         args:
-          {{- if .Values.reloader.custom_annotations.configmap }}
-          - "--configmap-annotation"
-          - "{{ .Values.reloader.custom_annotations.configmap }}"
+          
+          {{- if .Values.reloader.ignoreSecrets }}
+          - "--resources-to-ignore=secrets"
           {{- end }}
-          {{- if .Values.reloader.custom_annotations.secret }}
-          - "--secret-annotation"
-          - "{{ .Values.reloader.custom_annotations.secret }}"
+          {{- if eq .Values.reloader.ignoreConfigMaps true }}
+          - "--resources-to-ignore=configMaps"
           {{- end }}
-          {{- if .Values.reloader.custom_annotations.auto }}
-          - "--auto-annotation"
-          - "{{ .Values.reloader.custom_annotations.auto }}"
+
+          {{- if .Values.reloader.custom_annotations }}
+            {{- if .Values.reloader.custom_annotations.configmap }}
+            - "--configmap-annotation"
+            - "{{ .Values.reloader.custom_annotations.configmap }}"
+            {{- end }}
+            {{- if .Values.reloader.custom_annotations.secret }}
+            - "--secret-annotation"
+            - "{{ .Values.reloader.custom_annotations.secret }}"
+            {{- end }}
+            {{- if .Values.reloader.custom_annotations.auto }}
+            - "--auto-annotation"
+            - "{{ .Values.reloader.custom_annotations.auto }}"
+            {{- end }}
           {{- end }}
-      {{- end }}
+
       {{- if .Values.reloader.deployment.resources }}
         resources:
 {{ toYaml .Values.reloader.deployment.resources | indent 10 }}

deployments/kubernetes/chart/reloader/templates/role.yaml

@@ -16,12 +16,28 @@ rules:
   - apiGroups:
       - ""
     resources:
+{{- if .Values.reloader.ignoreSecrets }}{{- else }}
       - secrets
+{{- end }}
+{{- if .Values.reloader.ignoreConfigMaps }}{{- else }}
       - configmaps
+{{- end }}
     verbs:
       - list
       - get
       - watch
+{{- if or (.Capabilities.APIVersions.Has "apps.openshift.io/v1") (.Values.isOpenshift) }}
+  - apiGroups:
+      - "apps.openshift.io"
+      - ""
+    resources:
+      - deploymentconfigs
+    verbs:
+      - list
+      - get
+      - update
+      - patch
+{{- end }}
   - apiGroups:
       - "apps"
     resources:

deployments/kubernetes/chart/reloader/values.yaml

@@ -4,6 +4,9 @@ kubernetes:
   host: https://kubernetes.default
 
 reloader:
+  isOpenshift: false
+  ignoreSecrets: false
+  ignoreConfigMaps: false
   watchGlobally: true
   # Set to true if you have a pod security policy that enforces readOnlyRootFilesystem
   readOnlyRootFileSystem: false
@@ -35,10 +38,10 @@ reloader:
     labels:
       provider: stakater
       group: com.stakater.platform
-      version: v0.0.32
+      version: v0.0.38
     image:
       name: stakater/reloader
-      tag: "v0.0.32"
+      tag: "v0.0.38"
       pullPolicy: IfNotPresent
     # Support for extra environment variables.
     env:

deployments/kubernetes/kustomization.yaml

@@ -0,0 +1,10 @@
+apiVersion: kustomize.config.k8s.io/v1beta1
+kind: Kustomization
+
+resources:
+  - manifests/clusterrole.yaml
+  - manifests/clusterrolebinding.yaml
+  - manifests/role.yaml
+  - manifests/rolebinding.yaml
+  - manifests/serviceaccount.yaml
+  - manifests/deployment.yaml

deployments/kubernetes/manifests/clusterrole.yaml

@@ -6,7 +6,7 @@ kind: ClusterRole
 metadata:
   labels:
     app: reloader
-    chart: "reloader-v0.0.32"
+    chart: "reloader-v0.0.38"
     release: "RELEASE-NAME"
     heritage: "Tiller"
   name: reloader-role

deployments/kubernetes/manifests/clusterrolebinding.yaml

@@ -6,7 +6,7 @@ kind: ClusterRoleBinding
 metadata:
   labels:
     app: reloader
-    chart: "reloader-v0.0.32"
+    chart: "reloader-v0.0.38"
     release: "RELEASE-NAME"
     heritage: "Tiller"
   name: reloader-role-binding

deployments/kubernetes/manifests/deployment.yaml

@@ -5,12 +5,12 @@ kind: Deployment
 metadata:
   labels:
     app: reloader
-    chart: "reloader-v0.0.32"
+    chart: "reloader-v0.0.38"
     release: "RELEASE-NAME"
     heritage: "Tiller"
     group: com.stakater.platform
     provider: stakater
-    version: v0.0.32
+    version: v0.0.38
     
   name: reloader
 spec:
@@ -24,18 +24,19 @@ spec:
     metadata:
       labels:
         app: reloader
-        chart: "reloader-v0.0.32"
+        chart: "reloader-v0.0.38"
         release: "RELEASE-NAME"
         heritage: "Tiller"
         group: com.stakater.platform
         provider: stakater
-        version: v0.0.32
+        version: v0.0.38
         
     spec:
       containers:
       - env:
-        image: "stakater/reloader:v0.0.32"
+        image: "stakater/reloader:v0.0.38"
         imagePullPolicy: IfNotPresent
         name: reloader
+        args:
       serviceAccountName: reloader
 

deployments/kubernetes/manifests/serviceaccount.yaml

@@ -6,7 +6,7 @@ kind: ServiceAccount
 metadata:
   labels:
     app: reloader
-    chart: "reloader-v0.0.32"
+    chart: "reloader-v0.0.38"
     release: "RELEASE-NAME"
     heritage: "Tiller"
   name: reloader

deployments/kubernetes/reloader.yaml

@@ -9,12 +9,12 @@ kind: Deployment
 metadata:
   labels:
     app: reloader
-    chart: "reloader-v0.0.32"
+    chart: "reloader-v0.0.38"
     release: "RELEASE-NAME"
     heritage: "Tiller"
     group: com.stakater.platform
     provider: stakater
-    version: v0.0.32
+    version: v0.0.38
     
   name: reloader
 spec:
@@ -28,19 +28,20 @@ spec:
     metadata:
       labels:
         app: reloader
-        chart: "reloader-v0.0.32"
+        chart: "reloader-v0.0.38"
         release: "RELEASE-NAME"
         heritage: "Tiller"
         group: com.stakater.platform
         provider: stakater
-        version: v0.0.32
+        version: v0.0.38
         
     spec:
       containers:
       - env:
-        image: "stakater/reloader:v0.0.32"
+        image: "stakater/reloader:v0.0.38"
         imagePullPolicy: IfNotPresent
         name: reloader
+        args:
       serviceAccountName: reloader
 
 ---
@@ -51,7 +52,7 @@ kind: ClusterRole
 metadata:
   labels:
     app: reloader
-    chart: "reloader-v0.0.32"
+    chart: "reloader-v0.0.38"
     release: "RELEASE-NAME"
     heritage: "Tiller"
   name: reloader-role
@@ -100,7 +101,7 @@ kind: ClusterRoleBinding
 metadata:
   labels:
     app: reloader
-    chart: "reloader-v0.0.32"
+    chart: "reloader-v0.0.38"
     release: "RELEASE-NAME"
     heritage: "Tiller"
   name: reloader-role-binding
@@ -122,7 +123,7 @@ kind: ServiceAccount
 metadata:
   labels:
     app: reloader
-    chart: "reloader-v0.0.32"
+    chart: "reloader-v0.0.38"
     release: "RELEASE-NAME"
     heritage: "Tiller"
   name: reloader

deployments/kubernetes/templates/chart/values.yaml.tmpl

@@ -4,6 +4,9 @@ kubernetes:
   host: https://kubernetes.default
 
 reloader:
+  isOpenshift: false
+  ignoreSecrets: false
+  ignoreConfigMaps: false
   watchGlobally: true
   # Set to true if you have a pod security policy that enforces readOnlyRootFilesystem
   readOnlyRootFileSystem: false

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: []

glide.yaml

@@ -1,14 +1,10 @@
 package: github.com/stakater/Reloader
 import:
-- package: k8s.io/api
-  version: kubernetes-1.8.0
-- package: k8s.io/apimachinery
-  version: kubernetes-1.8.0
-- package: k8s.io/client-go
-  version: 5.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

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
+}

internal/pkg/cmd/reloader.go

@@ -7,8 +7,9 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/stakater/Reloader/internal/pkg/controller"
 	"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
@@ -23,11 +24,15 @@ func NewReloaderCommand() *cobra.Command {
 	cmd.PersistentFlags().StringVar(&options.ConfigmapUpdateOnChangeAnnotation, "configmap-annotation", "configmap.reloader.stakater.com/reload", "annotation to detect changes in configmaps")
 	cmd.PersistentFlags().StringVar(&options.SecretUpdateOnChangeAnnotation, "secret-annotation", "secret.reloader.stakater.com/reload", "annotation to detect changes in secrets")
 	cmd.PersistentFlags().StringVar(&options.ReloaderAutoAnnotation, "auto-annotation", "reloader.stakater.com/auto", "annotation to detect changes in secrets")
+	cmd.PersistentFlags().StringSlice("resources-to-ignore", []string{}, "list of resources to ignore (valid options 'configMaps' or 'secrets')")
 
 	return cmd
 }
 
 func startReloader(cmd *cobra.Command, args []string) {
+	var ignoreList util.List
+	var err error
+
 	logrus.Info("Starting Reloader")
 	currentNamespace := os.Getenv("KUBERNETES_NAMESPACE")
 	if len(currentNamespace) == 0 {
@@ -36,12 +41,31 @@ func startReloader(cmd *cobra.Command, args []string) {
 	}
 
 	// create the clientset
-	clientset, err := kube.GetClient()
+	clientset, err := kube.GetKubernetesClient()
 	if err != nil {
 		logrus.Fatal(err)
 	}
 
+	ignoreList, err = cmd.Flags().GetStringSlice("resources-to-ignore")
+	if err != nil {
+		logrus.Fatal(err)
+	}
+
+	for _, v := range ignoreList {
+		if v != "configMaps" && v != "secrets" {
+			logrus.Fatalf("'resources-to-ignore' only accepts 'configMaps' or 'secrets', not '%s'", v)
+		}
+	}
+
+	if len(ignoreList) > 1 {
+		logrus.Fatal("'resources-to-ignore' only accepts 'configMaps' or 'secrets', not both")
+	}
+
 	for k := range kube.ResourceMap {
+		if ignoreList.Contains(k) {
+			continue
+		}
+
 		c, err := controller.NewController(clientset, k, currentNamespace)
 		if err != nil {
 			logrus.Fatalf("%s", err)

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)
 }

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

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

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)

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")
 	}

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

internal/pkg/util/util.go

@@ -46,3 +46,14 @@ func GetSHAfromSecret(data map[string][]byte) string {
 	sort.Strings(values)
 	return crypto.GenerateSHA(strings.Join(values, ";"))
 }
+
+type List []string
+
+func (l *List) Contains(s string) bool {
+	for _, v := range *l {
+		if v == s {
+			return true
+		}
+	}
+	return false
+}

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
 }

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"
 )