Merge pull request #74 from stakater/deploymentconfigs

Add support for DeploymentConfigs for openshift
2026-08-20 12:36:26 +00:00 · 2019-07-08 12:10:45 +02:00
parent 5fc34e885e cc65a1c039
commit da4ffc9432
20 changed files with 615 additions and 367 deletions
@@ -0,0 +1 @@
+vendor
@@ -1 +1 @@
-v0.0.36
+v0.1.0
@@ -20,7 +20,7 @@ LDFLAGS =
 default: build test

 install:
-	"$(GLIDECMD)" install
+	"$(GLIDECMD)" install --strip-vendor

 build:
 	"$(GOCMD)" build ${GOFLAGS} ${LDFLAGS} -o "${BINARY}"
@@ -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
@@ -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 /
@@ -26,6 +26,18 @@ rules:
      - list
      - get
      - watch
+{{- if .Capabilities.APIVersions.Has "apps.openshift.io/v1" }}
+  - apiGroups:
+      - "apps.openshift.io"
+      - ""
+    resources:
+      - deploymentconfigs
+    verbs:
+      - list
+      - get
+      - update
+      - patch
+{{- end }}
  - apiGroups:
      - "apps"
    resources:
@@ -26,6 +26,18 @@ rules:
      - list
      - get
      - watch
+{{- if .Capabilities.APIVersions.Has "apps.openshift.io/v1" }}
+  - apiGroups:
+      - "apps.openshift.io"
+      - ""
+    resources:
+      - deploymentconfigs
+    verbs:
+      - list
+      - get
+      - update
+      - patch
+{{- end }}
  - apiGroups:
      - "apps"
    resources:
@@ -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: []
@@ -1,14 +1,10 @@
 package: github.com/stakater/Reloader
 import:
- package: k8s.io/api
-  version: kubernetes-1.10.0
- package: k8s.io/apimachinery
-  version: kubernetes-1.10.0
- package: k8s.io/client-go
-  version: 6.0.0
+- package: github.com/openshift/client-go
+  version: release-3.11
 - package: github.com/spf13/cobra
-  version: 0.0.3
- package: github.com/spf13/pflag
-  version: 1.0.1
- package: github.com/sirupsen/logrus
-  version: 1.0.5
+  version: f62e98d28ab7ad31d707ba837a966378465c7b57
+- package: github.com/openshift/library-go
+  version: release-3.11
+- package: github.com/openshift/api
+  version: master
@@ -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
+}
@@ -9,7 +9,7 @@ import (
 	"github.com/stakater/Reloader/internal/pkg/options"
 	"github.com/stakater/Reloader/internal/pkg/util"
 	"github.com/stakater/Reloader/pkg/kube"
-	"k8s.io/apimachinery/pkg/apis/meta/v1"
+	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 )

 // NewReloaderCommand starts the reloader controller
@@ -41,7 +41,7 @@ func startReloader(cmd *cobra.Command, args []string) {
 	}

 	// create the clientset
-	clientset, err := kube.GetClient()
+	clientset, err := kube.GetKubernetesClient()
 	if err != nil {
 		logrus.Fatal(err)
 	}
@@ -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)
 }
@@ -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
@@ -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
@@ -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)
@@ -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")
 	}
@@ -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
@@ -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
 }
@@ -1,7 +1,7 @@
 package kube

 import (
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 )