merge with master

pkg/cluster/cluster.go

@@ -3,6 +3,7 @@ package cluster
 // Postgres CustomResourceDefinition object i.e. Spilo
 
 import (
+	"context"
 	"database/sql"
 	"encoding/json"
 	"fmt"
@@ -50,14 +51,14 @@ type Config struct {
 	PodServiceAccountRoleBinding *rbacv1.RoleBinding
 }
 
-// K8S objects that are belongs to a connection pool
-type ConnectionPoolObjects struct {
+// K8S objects that are belongs to a connection pooler
+type ConnectionPoolerObjects struct {
 	Deployment *appsv1.Deployment
 	Service    *v1.Service
 
-	// It could happen that a connection pool was enabled, but the operator was
-	// not able to properly process a corresponding event or was restarted. In
-	// this case we will miss missing/require situation and a lookup function
+	// It could happen that a connection pooler was enabled, but the operator
+	// was not able to properly process a corresponding event or was restarted.
+	// In this case we will miss missing/require situation and a lookup function
 	// will not be installed. To avoid synchronizing it all the time to prevent
 	// this, we can remember the result in memory at least until the next
 	// restart.
@@ -69,7 +70,7 @@ type kubeResources struct {
 	Endpoints           map[PostgresRole]*v1.Endpoints
 	Secrets             map[types.UID]*v1.Secret
 	Statefulset         *appsv1.StatefulSet
-	ConnectionPool      *ConnectionPoolObjects
+	ConnectionPooler    *ConnectionPoolerObjects
 	PodDisruptionBudget *policybeta1.PodDisruptionBudget
 	//Pods are treated separately
 	//PVCs are treated separately
@@ -89,7 +90,7 @@ type Cluster struct {
 	pgDb             *sql.DB
 	mu               sync.Mutex
 	userSyncStrategy spec.UserSyncer
-	deleteOptions    *metav1.DeleteOptions
+	deleteOptions    metav1.DeleteOptions
 	podEventsQueue   *cache.FIFO
 
 	teamsAPIClient   teams.Interface
@@ -132,7 +133,7 @@ func New(cfg Config, kubeClient k8sutil.KubernetesClient, pgSpec acidv1.Postgres
 			Services:  make(map[PostgresRole]*v1.Service),
 			Endpoints: make(map[PostgresRole]*v1.Endpoints)},
 		userSyncStrategy: users.DefaultUserSyncStrategy{},
-		deleteOptions:    &metav1.DeleteOptions{PropagationPolicy: &deletePropagationPolicy},
+		deleteOptions:    metav1.DeleteOptions{PropagationPolicy: &deletePropagationPolicy},
 		podEventsQueue:   podEventsQueue,
 		KubeClient:       kubeClient,
 	}
@@ -183,7 +184,8 @@ func (c *Cluster) setStatus(status string) {
 	// we cannot do a full scale update here without fetching the previous manifest (as the resourceVersion may differ),
 	// however, we could do patch without it. In the future, once /status subresource is there (starting Kubernetes 1.11)
 	// we should take advantage of it.
-	newspec, err := c.KubeClient.AcidV1ClientSet.AcidV1().Postgresqls(c.clusterNamespace()).Patch(c.Name, types.MergePatchType, patch, "status")
+	newspec, err := c.KubeClient.AcidV1ClientSet.AcidV1().Postgresqls(c.clusterNamespace()).Patch(
+		context.TODO(), c.Name, types.MergePatchType, patch, metav1.PatchOptions{}, "status")
 	if err != nil {
 		c.logger.Errorf("could not update status: %v", err)
 		// return as newspec is empty, see PR654
@@ -343,24 +345,24 @@ func (c *Cluster) Create() error {
 		c.logger.Errorf("could not list resources: %v", err)
 	}
 
-	// Create connection pool deployment and services if necessary. Since we
-	// need to peform some operations with the database itself (e.g. install
+	// Create connection pooler deployment and services if necessary. Since we
+	// need to perform some operations with the database itself (e.g. install
 	// lookup function), do it as the last step, when everything is available.
 	//
-	// Do not consider connection pool as a strict requirement, and if
+	// Do not consider connection pooler as a strict requirement, and if
 	// something fails, report warning
-	if c.needConnectionPool() {
-		if c.ConnectionPool != nil {
-			c.logger.Warning("Connection pool already exists in the cluster")
+	if c.needConnectionPooler() {
+		if c.ConnectionPooler != nil {
+			c.logger.Warning("Connection pooler already exists in the cluster")
 			return nil
 		}
-		connPool, err := c.createConnectionPool(c.installLookupFunction)
+		connectionPooler, err := c.createConnectionPooler(c.installLookupFunction)
 		if err != nil {
-			c.logger.Warningf("could not create connection pool: %v", err)
+			c.logger.Warningf("could not create connection pooler: %v", err)
 			return nil
 		}
-		c.logger.Infof("connection pool %q has been successfully created",
-			util.NameFromMeta(connPool.Deployment.ObjectMeta))
+		c.logger.Infof("connection pooler %q has been successfully created",
+			util.NameFromMeta(connectionPooler.Deployment.ObjectMeta))
 	}
 
 	return nil
@@ -618,11 +620,11 @@ func (c *Cluster) Update(oldSpec, newSpec *acidv1.Postgresql) error {
 		}
 	}
 
-	// connection pool needs one system user created, which is done in
+	// connection pooler needs one system user created, which is done in
 	// initUsers. Check if it needs to be called.
 	sameUsers := reflect.DeepEqual(oldSpec.Spec.Users, newSpec.Spec.Users)
-	needConnPool := c.needConnectionPoolWorker(&newSpec.Spec)
-	if !sameUsers || needConnPool {
+	needConnectionPooler := c.needConnectionPoolerWorker(&newSpec.Spec)
+	if !sameUsers || needConnectionPooler {
 		c.logger.Debugf("syncing secrets")
 		if err := c.initUsers(); err != nil {
 			c.logger.Errorf("could not init users: %v", err)
@@ -754,9 +756,9 @@ func (c *Cluster) Update(oldSpec, newSpec *acidv1.Postgresql) error {
 		}
 	}
 
-	// sync connection pool
-	if err := c.syncConnectionPool(oldSpec, newSpec, c.installLookupFunction); err != nil {
-		return fmt.Errorf("could not sync connection pool: %v", err)
+	// sync connection pooler
+	if err := c.syncConnectionPooler(oldSpec, newSpec, c.installLookupFunction); err != nil {
+		return fmt.Errorf("could not sync connection pooler: %v", err)
 	}
 
 	return nil
@@ -810,11 +812,11 @@ func (c *Cluster) Delete() {
 		c.logger.Warningf("could not remove leftover patroni objects; %v", err)
 	}
 
-	// Delete connection pool objects anyway, even if it's not mentioned in the
+	// Delete connection pooler objects anyway, even if it's not mentioned in the
 	// manifest, just to not keep orphaned components in case if something went
 	// wrong
-	if err := c.deleteConnectionPool(); err != nil {
-		c.logger.Warningf("could not remove connection pool: %v", err)
+	if err := c.deleteConnectionPooler(); err != nil {
+		c.logger.Warningf("could not remove connection pooler: %v", err)
 	}
 }
 
@@ -883,32 +885,32 @@ func (c *Cluster) initSystemUsers() {
 		Password: util.RandomPassword(constants.PasswordLength),
 	}
 
-	// Connection pool user is an exception, if requested it's going to be
+	// Connection pooler user is an exception, if requested it's going to be
 	// created by operator as a normal pgUser
-	if c.needConnectionPool() {
-		// initialize empty connection pool if not done yet
-		if c.Spec.ConnectionPool == nil {
-			c.Spec.ConnectionPool = &acidv1.ConnectionPool{}
+	if c.needConnectionPooler() {
+		// initialize empty connection pooler if not done yet
+		if c.Spec.ConnectionPooler == nil {
+			c.Spec.ConnectionPooler = &acidv1.ConnectionPooler{}
 		}
 
 		username := util.Coalesce(
-			c.Spec.ConnectionPool.User,
-			c.OpConfig.ConnectionPool.User)
+			c.Spec.ConnectionPooler.User,
+			c.OpConfig.ConnectionPooler.User)
 
 		// connection pooler application should be able to login with this role
-		connPoolUser := spec.PgUser{
-			Origin:   spec.RoleConnectionPool,
+		connectionPoolerUser := spec.PgUser{
+			Origin:   spec.RoleConnectionPooler,
 			Name:     username,
 			Flags:    []string{constants.RoleFlagLogin},
 			Password: util.RandomPassword(constants.PasswordLength),
 		}
 
 		if _, exists := c.pgUsers[username]; !exists {
-			c.pgUsers[username] = connPoolUser
+			c.pgUsers[username] = connectionPoolerUser
 		}
 
-		if _, exists := c.systemUsers[constants.ConnectionPoolUserKeyName]; !exists {
-			c.systemUsers[constants.ConnectionPoolUserKeyName] = connPoolUser
+		if _, exists := c.systemUsers[constants.ConnectionPoolerUserKeyName]; !exists {
+			c.systemUsers[constants.ConnectionPoolerUserKeyName] = connectionPoolerUser
 		}
 	}
 }
@@ -1297,12 +1299,12 @@ func (c *Cluster) deleteClusterObject(
 
 func (c *Cluster) deletePatroniClusterServices() error {
 	get := func(name string) (spec.NamespacedName, error) {
-		svc, err := c.KubeClient.Services(c.Namespace).Get(name, metav1.GetOptions{})
+		svc, err := c.KubeClient.Services(c.Namespace).Get(context.TODO(), name, metav1.GetOptions{})
 		return util.NameFromMeta(svc.ObjectMeta), err
 	}
 
 	deleteServiceFn := func(name string) error {
-		return c.KubeClient.Services(c.Namespace).Delete(name, c.deleteOptions)
+		return c.KubeClient.Services(c.Namespace).Delete(context.TODO(), name, c.deleteOptions)
 	}
 
 	return c.deleteClusterObject(get, deleteServiceFn, "service")
@@ -1310,12 +1312,12 @@ func (c *Cluster) deletePatroniClusterServices() error {
 
 func (c *Cluster) deletePatroniClusterEndpoints() error {
 	get := func(name string) (spec.NamespacedName, error) {
-		ep, err := c.KubeClient.Endpoints(c.Namespace).Get(name, metav1.GetOptions{})
+		ep, err := c.KubeClient.Endpoints(c.Namespace).Get(context.TODO(), name, metav1.GetOptions{})
 		return util.NameFromMeta(ep.ObjectMeta), err
 	}
 
 	deleteEndpointFn := func(name string) error {
-		return c.KubeClient.Endpoints(c.Namespace).Delete(name, c.deleteOptions)
+		return c.KubeClient.Endpoints(c.Namespace).Delete(context.TODO(), name, c.deleteOptions)
 	}
 
 	return c.deleteClusterObject(get, deleteEndpointFn, "endpoint")
@@ -1323,21 +1325,21 @@ func (c *Cluster) deletePatroniClusterEndpoints() error {
 
 func (c *Cluster) deletePatroniClusterConfigMaps() error {
 	get := func(name string) (spec.NamespacedName, error) {
-		cm, err := c.KubeClient.ConfigMaps(c.Namespace).Get(name, metav1.GetOptions{})
+		cm, err := c.KubeClient.ConfigMaps(c.Namespace).Get(context.TODO(), name, metav1.GetOptions{})
 		return util.NameFromMeta(cm.ObjectMeta), err
 	}
 
 	deleteConfigMapFn := func(name string) error {
-		return c.KubeClient.ConfigMaps(c.Namespace).Delete(name, c.deleteOptions)
+		return c.KubeClient.ConfigMaps(c.Namespace).Delete(context.TODO(), name, c.deleteOptions)
 	}
 
 	return c.deleteClusterObject(get, deleteConfigMapFn, "configmap")
 }
 
-// Test if two connection pool configuration needs to be synced. For simplicity
+// Test if two connection pooler configuration needs to be synced. For simplicity
 // compare not the actual K8S objects, but the configuration itself and request
 // sync if there is any difference.
-func (c *Cluster) needSyncConnPoolSpecs(oldSpec, newSpec *acidv1.ConnectionPool) (sync bool, reasons []string) {
+func (c *Cluster) needSyncConnectionPoolerSpecs(oldSpec, newSpec *acidv1.ConnectionPooler) (sync bool, reasons []string) {
 	reasons = []string{}
 	sync = false
 
@@ -1374,21 +1376,21 @@ func syncResources(a, b *v1.ResourceRequirements) bool {
 	return false
 }
 
-// Check if we need to synchronize connection pool deployment due to new
+// Check if we need to synchronize connection pooler deployment due to new
 // defaults, that are different from what we see in the DeploymentSpec
-func (c *Cluster) needSyncConnPoolDefaults(
-	spec *acidv1.ConnectionPool,
+func (c *Cluster) needSyncConnectionPoolerDefaults(
+	spec *acidv1.ConnectionPooler,
 	deployment *appsv1.Deployment) (sync bool, reasons []string) {
 
 	reasons = []string{}
 	sync = false
 
-	config := c.OpConfig.ConnectionPool
+	config := c.OpConfig.ConnectionPooler
 	podTemplate := deployment.Spec.Template
-	poolContainer := podTemplate.Spec.Containers[constants.ConnPoolContainer]
+	poolerContainer := podTemplate.Spec.Containers[constants.ConnectionPoolerContainer]
 
 	if spec == nil {
-		spec = &acidv1.ConnectionPool{}
+		spec = &acidv1.ConnectionPooler{}
 	}
 
 	if spec.NumberOfInstances == nil &&
@@ -1401,25 +1403,25 @@ func (c *Cluster) needSyncConnPoolDefaults(
 	}
 
 	if spec.DockerImage == "" &&
-		poolContainer.Image != config.Image {
+		poolerContainer.Image != config.Image {
 
 		sync = true
 		msg := fmt.Sprintf("DockerImage is different (having %s, required %s)",
-			poolContainer.Image, config.Image)
+			poolerContainer.Image, config.Image)
 		reasons = append(reasons, msg)
 	}
 
 	expectedResources, err := generateResourceRequirements(spec.Resources,
-		c.makeDefaultConnPoolResources())
+		c.makeDefaultConnectionPoolerResources())
 
 	// An error to generate expected resources means something is not quite
 	// right, but for the purpose of robustness do not panic here, just report
 	// and ignore resources comparison (in the worst case there will be no
 	// updates for new resource values).
-	if err == nil && syncResources(&poolContainer.Resources, expectedResources) {
+	if err == nil && syncResources(&poolerContainer.Resources, expectedResources) {
 		sync = true
 		msg := fmt.Sprintf("Resources are different (having %+v, required %+v)",
-			poolContainer.Resources, expectedResources)
+			poolerContainer.Resources, expectedResources)
 		reasons = append(reasons, msg)
 	}
 
@@ -1427,13 +1429,13 @@ func (c *Cluster) needSyncConnPoolDefaults(
 		c.logger.Warningf("Cannot generate expected resources, %v", err)
 	}
 
-	for _, env := range poolContainer.Env {
+	for _, env := range poolerContainer.Env {
 		if spec.User == "" && env.Name == "PGUSER" {
 			ref := env.ValueFrom.SecretKeyRef.LocalObjectReference
 
 			if ref.Name != c.credentialSecretName(config.User) {
 				sync = true
-				msg := fmt.Sprintf("Pool user is different (having %s, required %s)",
+				msg := fmt.Sprintf("pooler user is different (having %s, required %s)",
 					ref.Name, config.User)
 				reasons = append(reasons, msg)
 			}
@@ -1441,7 +1443,7 @@ func (c *Cluster) needSyncConnPoolDefaults(
 
 		if spec.Schema == "" && env.Name == "PGSCHEMA" && env.Value != config.Schema {
 			sync = true
-			msg := fmt.Sprintf("Pool schema is different (having %s, required %s)",
+			msg := fmt.Sprintf("pooler schema is different (having %s, required %s)",
 				env.Value, config.Schema)
 			reasons = append(reasons, msg)
 		}

pkg/cluster/cluster_test.go

@@ -709,16 +709,16 @@ func TestServiceAnnotations(t *testing.T) {
 func TestInitSystemUsers(t *testing.T) {
 	testName := "Test system users initialization"
 
-	// default cluster without connection pool
+	// default cluster without connection pooler
 	cl.initSystemUsers()
-	if _, exist := cl.systemUsers[constants.ConnectionPoolUserKeyName]; exist {
-		t.Errorf("%s, connection pool user is present", testName)
+	if _, exist := cl.systemUsers[constants.ConnectionPoolerUserKeyName]; exist {
+		t.Errorf("%s, connection pooler user is present", testName)
 	}
 
-	// cluster with connection pool
-	cl.Spec.EnableConnectionPool = boolToPointer(true)
+	// cluster with connection pooler
+	cl.Spec.EnableConnectionPooler = boolToPointer(true)
 	cl.initSystemUsers()
-	if _, exist := cl.systemUsers[constants.ConnectionPoolUserKeyName]; !exist {
-		t.Errorf("%s, connection pool user is not present", testName)
+	if _, exist := cl.systemUsers[constants.ConnectionPoolerUserKeyName]; !exist {
+		t.Errorf("%s, connection pooler user is not present", testName)
 	}
 }

pkg/cluster/database.go

@@ -56,10 +56,10 @@ const (
 			ALTER DEFAULT PRIVILEGES IN SCHEMA "%s" GRANT EXECUTE ON FUNCTIONS TO "%s","%s";
 			ALTER DEFAULT PRIVILEGES IN SCHEMA "%s" GRANT USAGE ON TYPES TO "%s","%s";`
 
-	connectionPoolLookup = `
-		CREATE SCHEMA IF NOT EXISTS {{.pool_schema}};
+	connectionPoolerLookup = `
+		CREATE SCHEMA IF NOT EXISTS {{.pooler_schema}};
 
-		CREATE OR REPLACE FUNCTION {{.pool_schema}}.user_lookup(
+		CREATE OR REPLACE FUNCTION {{.pooler_schema}}.user_lookup(
 			in i_username text, out uname text, out phash text)
 		RETURNS record AS $$
 		BEGIN
@@ -69,11 +69,12 @@ const (
 		END;
 		$$ LANGUAGE plpgsql SECURITY DEFINER;
 
-		REVOKE ALL ON FUNCTION {{.pool_schema}}.user_lookup(text)
-			FROM public, {{.pool_user}};
-		GRANT EXECUTE ON FUNCTION {{.pool_schema}}.user_lookup(text)
-			TO {{.pool_user}};
-		GRANT USAGE ON SCHEMA {{.pool_schema}} TO {{.pool_user}}`
+		REVOKE ALL ON FUNCTION {{.pooler_schema}}.user_lookup(text)
+			FROM public, {{.pooler_user}};
+		GRANT EXECUTE ON FUNCTION {{.pooler_schema}}.user_lookup(text)
+			TO {{.pooler_user}};
+		GRANT USAGE ON SCHEMA {{.pooler_schema}} TO {{.pooler_user}};
+	`
 )
 
 func (c *Cluster) pgConnectionString(dbname string) string {
@@ -462,7 +463,7 @@ func (c *Cluster) execCreateOrAlterExtension(extName, schemaName, statement, doi
 
 // Creates a connection pool credentials lookup function in every database to
 // perform remote authentification.
-func (c *Cluster) installLookupFunction(poolSchema, poolUser string) error {
+func (c *Cluster) installLookupFunction(poolerSchema, poolerUser string) error {
 	var stmtBytes bytes.Buffer
 	c.logger.Info("Installing lookup function")
 
@@ -481,11 +482,11 @@ func (c *Cluster) installLookupFunction(poolSchema, poolUser string) error {
 
 	currentDatabases, err := c.getDatabases()
 	if err != nil {
-		msg := "could not get databases to install pool lookup function: %v"
+		msg := "could not get databases to install pooler lookup function: %v"
 		return fmt.Errorf(msg, err)
 	}
 
-	templater := template.Must(template.New("sql").Parse(connectionPoolLookup))
+	templater := template.Must(template.New("sql").Parse(connectionPoolerLookup))
 
 	for dbname, _ := range currentDatabases {
 		if dbname == "template0" || dbname == "template1" {
@@ -496,11 +497,11 @@ func (c *Cluster) installLookupFunction(poolSchema, poolUser string) error {
 			return fmt.Errorf("could not init database connection to %s", dbname)
 		}
 
-		c.logger.Infof("Install pool lookup function into %s", dbname)
+		c.logger.Infof("Install pooler lookup function into %s", dbname)
 
 		params := TemplateParams{
-			"pool_schema": poolSchema,
-			"pool_user":   poolUser,
+			"pooler_schema": poolerSchema,
+			"pooler_user":   poolerUser,
 		}
 
 		if err := templater.Execute(&stmtBytes, params); err != nil {
@@ -535,12 +536,12 @@ func (c *Cluster) installLookupFunction(poolSchema, poolUser string) error {
 			continue
 		}
 
-		c.logger.Infof("Pool lookup function installed into %s", dbname)
+		c.logger.Infof("pooler lookup function installed into %s", dbname)
 		if err := c.closeDbConn(); err != nil {
 			c.logger.Errorf("could not close database connection: %v", err)
 		}
 	}
 
-	c.ConnectionPool.LookupFunction = true
+	c.ConnectionPooler.LookupFunction = true
 	return nil
 }

pkg/cluster/exec.go

@@ -2,10 +2,11 @@ package cluster
 
 import (
 	"bytes"
+	"context"
 	"fmt"
 	"strings"
 
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/client-go/kubernetes/scheme"
 	"k8s.io/client-go/tools/remotecommand"
@@ -23,7 +24,7 @@ func (c *Cluster) ExecCommand(podName *spec.NamespacedName, command ...string) (
 		execErr bytes.Buffer
 	)
 
-	pod, err := c.KubeClient.Pods(podName.Namespace).Get(podName.Name, metav1.GetOptions{})
+	pod, err := c.KubeClient.Pods(podName.Namespace).Get(context.TODO(), podName.Name, metav1.GetOptions{})
 	if err != nil {
 		return "", fmt.Errorf("could not get pod info: %v", err)
 	}

pkg/cluster/k8sres.go

@@ -1,6 +1,7 @@
 package cluster
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"path"
@@ -34,11 +35,8 @@ const (
 	patroniPGParametersParameterName = "parameters"
 	patroniPGHBAConfParameterName    = "pg_hba"
 	localHost                        = "127.0.0.1/32"
-	connectionPoolContainer          = "connection-pool"
+	connectionPoolerContainer        = "connection-pooler"
 	pgPort                           = 5432
-
-	// the gid of the postgres user in the default spilo image
-	spiloPostgresGID = 103
 )
 
 type pgUser struct {
@@ -74,7 +72,7 @@ func (c *Cluster) statefulSetName() string {
 	return c.Name
 }
 
-func (c *Cluster) connPoolName() string {
+func (c *Cluster) connectionPoolerName() string {
 	return c.Name + "-pooler"
 }
 
@@ -141,18 +139,18 @@ func (c *Cluster) makeDefaultResources() acidv1.Resources {
 	}
 }
 
-// Generate default resource section for connection pool deployment, to be used
-// if nothing custom is specified in the manifest
-func (c *Cluster) makeDefaultConnPoolResources() acidv1.Resources {
+// Generate default resource section for connection pooler deployment, to be
+// used if nothing custom is specified in the manifest
+func (c *Cluster) makeDefaultConnectionPoolerResources() acidv1.Resources {
 	config := c.OpConfig
 
 	defaultRequests := acidv1.ResourceDescription{
-		CPU:    config.ConnectionPool.ConnPoolDefaultCPURequest,
-		Memory: config.ConnectionPool.ConnPoolDefaultMemoryRequest,
+		CPU:    config.ConnectionPooler.ConnectionPoolerDefaultCPURequest,
+		Memory: config.ConnectionPooler.ConnectionPoolerDefaultMemoryRequest,
 	}
 	defaultLimits := acidv1.ResourceDescription{
-		CPU:    config.ConnectionPool.ConnPoolDefaultCPULimit,
-		Memory: config.ConnectionPool.ConnPoolDefaultMemoryLimit,
+		CPU:    config.ConnectionPooler.ConnectionPoolerDefaultCPULimit,
+		Memory: config.ConnectionPooler.ConnectionPoolerDefaultMemoryLimit,
 	}
 
 	return acidv1.Resources{
@@ -674,6 +672,10 @@ func (c *Cluster) generateSpiloPodEnvVars(uid types.UID, spiloConfiguration stri
 		envVars = append(envVars, v1.EnvVar{Name: "ETCD_HOST", Value: c.OpConfig.EtcdHost})
 	}
 
+	if c.patroniKubernetesUseConfigMaps() {
+		envVars = append(envVars, v1.EnvVar{Name: "KUBERNETES_USE_CONFIGMAPS", Value: "true"})
+	}
+
 	if cloneDescription.ClusterName != "" {
 		envVars = append(envVars, c.generateCloneEnvironment(cloneDescription)...)
 	}
@@ -914,11 +916,17 @@ func (c *Cluster) generateStatefulSet(spec *acidv1.PostgresSpec) (*appsv1.Statef
 
 	if c.OpConfig.PodEnvironmentConfigMap != (pkgspec.NamespacedName{}) {
 		var cm *v1.ConfigMap
-		cm, err = c.KubeClient.ConfigMaps(c.OpConfig.PodEnvironmentConfigMap.Namespace).Get(c.OpConfig.PodEnvironmentConfigMap.Name, metav1.GetOptions{})
+		cm, err = c.KubeClient.ConfigMaps(c.OpConfig.PodEnvironmentConfigMap.Namespace).Get(
+			context.TODO(),
+			c.OpConfig.PodEnvironmentConfigMap.Name,
+			metav1.GetOptions{})
 		if err != nil {
 			// if not found, try again using the cluster's namespace if it's different (old behavior)
 			if k8sutil.ResourceNotFound(err) && c.Namespace != c.OpConfig.PodEnvironmentConfigMap.Namespace {
-				cm, err = c.KubeClient.ConfigMaps(c.Namespace).Get(c.OpConfig.PodEnvironmentConfigMap.Name, metav1.GetOptions{})
+				cm, err = c.KubeClient.ConfigMaps(c.Namespace).Get(
+					context.TODO(),
+					c.OpConfig.PodEnvironmentConfigMap.Name,
+					metav1.GetOptions{})
 			}
 			if err != nil {
 				return nil, fmt.Errorf("could not read PodEnvironmentConfigMap: %v", err)
@@ -983,13 +991,8 @@ func (c *Cluster) generateStatefulSet(spec *acidv1.PostgresSpec) (*appsv1.Statef
 
 	// configure TLS with a custom secret volume
 	if spec.TLS != nil && spec.TLS.SecretName != "" {
-		if effectiveFSGroup == nil {
-			c.logger.Warnf("Setting the default FSGroup to satisfy the TLS configuration")
-			fsGroup := int64(spiloPostgresGID)
-			effectiveFSGroup = &fsGroup
-		}
-		// this is combined with the FSGroup above to give read access to the
-		// postgres user
+		// this is combined with the FSGroup in the section above
+		// to give read access to the postgres user
 		defaultMode := int32(0640)
 		volumes = append(volumes, v1.Volume{
 			Name: "tls-secret",
@@ -1414,7 +1417,7 @@ func (c *Cluster) generateService(role PostgresRole, spec *acidv1.PostgresSpec)
 		Type:  v1.ServiceTypeClusterIP,
 	}
 
-	if role == Replica {
+	if role == Replica || c.patroniKubernetesUseConfigMaps() {
 		serviceSpec.Selector = c.roleLabelsSet(false, role)
 	}
 
@@ -1859,33 +1862,33 @@ func (c *Cluster) getLogicalBackupJobName() (jobName string) {
 //
 // DEFAULT_SIZE is a pool size per db/user (having in mind the use case when
 // 	most of the queries coming through a connection pooler are from the same
-// 	user to the same db). In case if we want to spin up more connection pool
+// 	user to the same db). In case if we want to spin up more connection pooler
 // 	instances, take this into account and maintain the same number of
 // 	connections.
 //
-// MIN_SIZE is a pool minimal size, to prevent situation when sudden workload
+// MIN_SIZE is a pool's minimal size, to prevent situation when sudden workload
 // 	have to wait for spinning up a new connections.
 //
-// RESERVE_SIZE is how many additional connections to allow for a pool.
-func (c *Cluster) getConnPoolEnvVars(spec *acidv1.PostgresSpec) []v1.EnvVar {
+// RESERVE_SIZE is how many additional connections to allow for a pooler.
+func (c *Cluster) getConnectionPoolerEnvVars(spec *acidv1.PostgresSpec) []v1.EnvVar {
 	effectiveMode := util.Coalesce(
-		spec.ConnectionPool.Mode,
-		c.OpConfig.ConnectionPool.Mode)
+		spec.ConnectionPooler.Mode,
+		c.OpConfig.ConnectionPooler.Mode)
 
-	numberOfInstances := spec.ConnectionPool.NumberOfInstances
+	numberOfInstances := spec.ConnectionPooler.NumberOfInstances
 	if numberOfInstances == nil {
 		numberOfInstances = util.CoalesceInt32(
-			c.OpConfig.ConnectionPool.NumberOfInstances,
+			c.OpConfig.ConnectionPooler.NumberOfInstances,
 			k8sutil.Int32ToPointer(1))
 	}
 
 	effectiveMaxDBConn := util.CoalesceInt32(
-		spec.ConnectionPool.MaxDBConnections,
-		c.OpConfig.ConnectionPool.MaxDBConnections)
+		spec.ConnectionPooler.MaxDBConnections,
+		c.OpConfig.ConnectionPooler.MaxDBConnections)
 
 	if effectiveMaxDBConn == nil {
 		effectiveMaxDBConn = k8sutil.Int32ToPointer(
-			constants.ConnPoolMaxDBConnections)
+			constants.ConnectionPoolerMaxDBConnections)
 	}
 
 	maxDBConn := *effectiveMaxDBConn / *numberOfInstances
@@ -1896,51 +1899,51 @@ func (c *Cluster) getConnPoolEnvVars(spec *acidv1.PostgresSpec) []v1.EnvVar {
 
 	return []v1.EnvVar{
 		{
-			Name:  "CONNECTION_POOL_PORT",
+			Name:  "CONNECTION_POOLER_PORT",
 			Value: fmt.Sprint(pgPort),
 		},
 		{
-			Name:  "CONNECTION_POOL_MODE",
+			Name:  "CONNECTION_POOLER_MODE",
 			Value: effectiveMode,
 		},
 		{
-			Name:  "CONNECTION_POOL_DEFAULT_SIZE",
+			Name:  "CONNECTION_POOLER_DEFAULT_SIZE",
 			Value: fmt.Sprint(defaultSize),
 		},
 		{
-			Name:  "CONNECTION_POOL_MIN_SIZE",
+			Name:  "CONNECTION_POOLER_MIN_SIZE",
 			Value: fmt.Sprint(minSize),
 		},
 		{
-			Name:  "CONNECTION_POOL_RESERVE_SIZE",
+			Name:  "CONNECTION_POOLER_RESERVE_SIZE",
 			Value: fmt.Sprint(reserveSize),
 		},
 		{
-			Name:  "CONNECTION_POOL_MAX_CLIENT_CONN",
-			Value: fmt.Sprint(constants.ConnPoolMaxClientConnections),
+			Name:  "CONNECTION_POOLER_MAX_CLIENT_CONN",
+			Value: fmt.Sprint(constants.ConnectionPoolerMaxClientConnections),
 		},
 		{
-			Name:  "CONNECTION_POOL_MAX_DB_CONN",
+			Name:  "CONNECTION_POOLER_MAX_DB_CONN",
 			Value: fmt.Sprint(maxDBConn),
 		},
 	}
 }
 
-func (c *Cluster) generateConnPoolPodTemplate(spec *acidv1.PostgresSpec) (
+func (c *Cluster) generateConnectionPoolerPodTemplate(spec *acidv1.PostgresSpec) (
 	*v1.PodTemplateSpec, error) {
 
 	gracePeriod := int64(c.OpConfig.PodTerminateGracePeriod.Seconds())
 	resources, err := generateResourceRequirements(
-		spec.ConnectionPool.Resources,
-		c.makeDefaultConnPoolResources())
+		spec.ConnectionPooler.Resources,
+		c.makeDefaultConnectionPoolerResources())
 
 	effectiveDockerImage := util.Coalesce(
-		spec.ConnectionPool.DockerImage,
-		c.OpConfig.ConnectionPool.Image)
+		spec.ConnectionPooler.DockerImage,
+		c.OpConfig.ConnectionPooler.Image)
 
 	effectiveSchema := util.Coalesce(
-		spec.ConnectionPool.Schema,
-		c.OpConfig.ConnectionPool.Schema)
+		spec.ConnectionPooler.Schema,
+		c.OpConfig.ConnectionPooler.Schema)
 
 	if err != nil {
 		return nil, fmt.Errorf("could not generate resource requirements: %v", err)
@@ -1948,8 +1951,8 @@ func (c *Cluster) generateConnPoolPodTemplate(spec *acidv1.PostgresSpec) (
 
 	secretSelector := func(key string) *v1.SecretKeySelector {
 		effectiveUser := util.Coalesce(
-			spec.ConnectionPool.User,
-			c.OpConfig.ConnectionPool.User)
+			spec.ConnectionPooler.User,
+			c.OpConfig.ConnectionPooler.User)
 
 		return &v1.SecretKeySelector{
 			LocalObjectReference: v1.LocalObjectReference{
@@ -1975,7 +1978,7 @@ func (c *Cluster) generateConnPoolPodTemplate(spec *acidv1.PostgresSpec) (
 			},
 		},
 		// the convention is to use the same schema name as
-		// connection pool username
+		// connection pooler username
 		{
 			Name:  "PGSCHEMA",
 			Value: effectiveSchema,
@@ -1988,10 +1991,10 @@ func (c *Cluster) generateConnPoolPodTemplate(spec *acidv1.PostgresSpec) (
 		},
 	}
 
-	envVars = append(envVars, c.getConnPoolEnvVars(spec)...)
+	envVars = append(envVars, c.getConnectionPoolerEnvVars(spec)...)
 
 	poolerContainer := v1.Container{
-		Name:            connectionPoolContainer,
+		Name:            connectionPoolerContainer,
 		Image:           effectiveDockerImage,
 		ImagePullPolicy: v1.PullIfNotPresent,
 		Resources:       *resources,
@@ -2006,7 +2009,7 @@ func (c *Cluster) generateConnPoolPodTemplate(spec *acidv1.PostgresSpec) (
 
 	podTemplate := &v1.PodTemplateSpec{
 		ObjectMeta: metav1.ObjectMeta{
-			Labels:      c.connPoolLabelsSelector().MatchLabels,
+			Labels:      c.connectionPoolerLabelsSelector().MatchLabels,
 			Namespace:   c.Namespace,
 			Annotations: c.generatePodAnnotations(spec),
 		},
@@ -2048,32 +2051,32 @@ func (c *Cluster) ownerReferences() []metav1.OwnerReference {
 	}
 }
 
-func (c *Cluster) generateConnPoolDeployment(spec *acidv1.PostgresSpec) (
+func (c *Cluster) generateConnectionPoolerDeployment(spec *acidv1.PostgresSpec) (
 	*appsv1.Deployment, error) {
 
 	// there are two ways to enable connection pooler, either to specify a
-	// connectionPool section or enableConnectionPool. In the second case
-	// spec.connectionPool will be nil, so to make it easier to calculate
+	// connectionPooler section or enableConnectionPooler. In the second case
+	// spec.connectionPooler will be nil, so to make it easier to calculate
 	// default values, initialize it to an empty structure. It could be done
 	// anywhere, but here is the earliest common entry point between sync and
 	// create code, so init here.
-	if spec.ConnectionPool == nil {
-		spec.ConnectionPool = &acidv1.ConnectionPool{}
+	if spec.ConnectionPooler == nil {
+		spec.ConnectionPooler = &acidv1.ConnectionPooler{}
 	}
 
-	podTemplate, err := c.generateConnPoolPodTemplate(spec)
-	numberOfInstances := spec.ConnectionPool.NumberOfInstances
+	podTemplate, err := c.generateConnectionPoolerPodTemplate(spec)
+	numberOfInstances := spec.ConnectionPooler.NumberOfInstances
 	if numberOfInstances == nil {
 		numberOfInstances = util.CoalesceInt32(
-			c.OpConfig.ConnectionPool.NumberOfInstances,
+			c.OpConfig.ConnectionPooler.NumberOfInstances,
 			k8sutil.Int32ToPointer(1))
 	}
 
-	if *numberOfInstances < constants.ConnPoolMinInstances {
-		msg := "Adjusted number of connection pool instances from %d to %d"
-		c.logger.Warningf(msg, numberOfInstances, constants.ConnPoolMinInstances)
+	if *numberOfInstances < constants.ConnectionPoolerMinInstances {
+		msg := "Adjusted number of connection pooler instances from %d to %d"
+		c.logger.Warningf(msg, numberOfInstances, constants.ConnectionPoolerMinInstances)
 
-		*numberOfInstances = constants.ConnPoolMinInstances
+		*numberOfInstances = constants.ConnectionPoolerMinInstances
 	}
 
 	if err != nil {
@@ -2082,9 +2085,9 @@ func (c *Cluster) generateConnPoolDeployment(spec *acidv1.PostgresSpec) (
 
 	deployment := &appsv1.Deployment{
 		ObjectMeta: metav1.ObjectMeta{
-			Name:        c.connPoolName(),
+			Name:        c.connectionPoolerName(),
 			Namespace:   c.Namespace,
-			Labels:      c.connPoolLabelsSelector().MatchLabels,
+			Labels:      c.connectionPoolerLabelsSelector().MatchLabels,
 			Annotations: map[string]string{},
 			// make StatefulSet object its owner to represent the dependency.
 			// By itself StatefulSet is being deleted with "Orphaned"
@@ -2096,7 +2099,7 @@ func (c *Cluster) generateConnPoolDeployment(spec *acidv1.PostgresSpec) (
 		},
 		Spec: appsv1.DeploymentSpec{
 			Replicas: numberOfInstances,
-			Selector: c.connPoolLabelsSelector(),
+			Selector: c.connectionPoolerLabelsSelector(),
 			Template: *podTemplate,
 		},
 	}
@@ -2104,37 +2107,37 @@ func (c *Cluster) generateConnPoolDeployment(spec *acidv1.PostgresSpec) (
 	return deployment, nil
 }
 
-func (c *Cluster) generateConnPoolService(spec *acidv1.PostgresSpec) *v1.Service {
+func (c *Cluster) generateConnectionPoolerService(spec *acidv1.PostgresSpec) *v1.Service {
 
 	// there are two ways to enable connection pooler, either to specify a
-	// connectionPool section or enableConnectionPool. In the second case
-	// spec.connectionPool will be nil, so to make it easier to calculate
+	// connectionPooler section or enableConnectionPooler. In the second case
+	// spec.connectionPooler will be nil, so to make it easier to calculate
 	// default values, initialize it to an empty structure. It could be done
 	// anywhere, but here is the earliest common entry point between sync and
 	// create code, so init here.
-	if spec.ConnectionPool == nil {
-		spec.ConnectionPool = &acidv1.ConnectionPool{}
+	if spec.ConnectionPooler == nil {
+		spec.ConnectionPooler = &acidv1.ConnectionPooler{}
 	}
 
 	serviceSpec := v1.ServiceSpec{
 		Ports: []v1.ServicePort{
 			{
-				Name:       c.connPoolName(),
+				Name:       c.connectionPoolerName(),
 				Port:       pgPort,
 				TargetPort: intstr.IntOrString{StrVal: c.servicePort(Master)},
 			},
 		},
 		Type: v1.ServiceTypeClusterIP,
 		Selector: map[string]string{
-			"connection-pool": c.connPoolName(),
+			"connection-pooler": c.connectionPoolerName(),
 		},
 	}
 
 	service := &v1.Service{
 		ObjectMeta: metav1.ObjectMeta{
-			Name:        c.connPoolName(),
+			Name:        c.connectionPoolerName(),
 			Namespace:   c.Namespace,
-			Labels:      c.connPoolLabelsSelector().MatchLabels,
+			Labels:      c.connectionPoolerLabelsSelector().MatchLabels,
 			Annotations: map[string]string{},
 			// make StatefulSet object its owner to represent the dependency.
 			// By itself StatefulSet is being deleted with "Orphaned"

pkg/cluster/k8sres_test.go

@@ -587,38 +587,38 @@ func TestSecretVolume(t *testing.T) {
 
 func testResources(cluster *Cluster, podSpec *v1.PodTemplateSpec) error {
 	cpuReq := podSpec.Spec.Containers[0].Resources.Requests["cpu"]
-	if cpuReq.String() != cluster.OpConfig.ConnectionPool.ConnPoolDefaultCPURequest {
+	if cpuReq.String() != cluster.OpConfig.ConnectionPooler.ConnectionPoolerDefaultCPURequest {
 		return fmt.Errorf("CPU request doesn't match, got %s, expected %s",
-			cpuReq.String(), cluster.OpConfig.ConnectionPool.ConnPoolDefaultCPURequest)
+			cpuReq.String(), cluster.OpConfig.ConnectionPooler.ConnectionPoolerDefaultCPURequest)
 	}
 
 	memReq := podSpec.Spec.Containers[0].Resources.Requests["memory"]
-	if memReq.String() != cluster.OpConfig.ConnectionPool.ConnPoolDefaultMemoryRequest {
+	if memReq.String() != cluster.OpConfig.ConnectionPooler.ConnectionPoolerDefaultMemoryRequest {
 		return fmt.Errorf("Memory request doesn't match, got %s, expected %s",
-			memReq.String(), cluster.OpConfig.ConnectionPool.ConnPoolDefaultMemoryRequest)
+			memReq.String(), cluster.OpConfig.ConnectionPooler.ConnectionPoolerDefaultMemoryRequest)
 	}
 
 	cpuLim := podSpec.Spec.Containers[0].Resources.Limits["cpu"]
-	if cpuLim.String() != cluster.OpConfig.ConnectionPool.ConnPoolDefaultCPULimit {
+	if cpuLim.String() != cluster.OpConfig.ConnectionPooler.ConnectionPoolerDefaultCPULimit {
 		return fmt.Errorf("CPU limit doesn't match, got %s, expected %s",
-			cpuLim.String(), cluster.OpConfig.ConnectionPool.ConnPoolDefaultCPULimit)
+			cpuLim.String(), cluster.OpConfig.ConnectionPooler.ConnectionPoolerDefaultCPULimit)
 	}
 
 	memLim := podSpec.Spec.Containers[0].Resources.Limits["memory"]
-	if memLim.String() != cluster.OpConfig.ConnectionPool.ConnPoolDefaultMemoryLimit {
+	if memLim.String() != cluster.OpConfig.ConnectionPooler.ConnectionPoolerDefaultMemoryLimit {
 		return fmt.Errorf("Memory limit doesn't match, got %s, expected %s",
-			memLim.String(), cluster.OpConfig.ConnectionPool.ConnPoolDefaultMemoryLimit)
+			memLim.String(), cluster.OpConfig.ConnectionPooler.ConnectionPoolerDefaultMemoryLimit)
 	}
 
 	return nil
 }
 
 func testLabels(cluster *Cluster, podSpec *v1.PodTemplateSpec) error {
-	poolLabels := podSpec.ObjectMeta.Labels["connection-pool"]
+	poolerLabels := podSpec.ObjectMeta.Labels["connection-pooler"]
 
-	if poolLabels != cluster.connPoolLabelsSelector().MatchLabels["connection-pool"] {
+	if poolerLabels != cluster.connectionPoolerLabelsSelector().MatchLabels["connection-pooler"] {
 		return fmt.Errorf("Pod labels do not match, got %+v, expected %+v",
-			podSpec.ObjectMeta.Labels, cluster.connPoolLabelsSelector().MatchLabels)
+			podSpec.ObjectMeta.Labels, cluster.connectionPoolerLabelsSelector().MatchLabels)
 	}
 
 	return nil
@@ -626,13 +626,13 @@ func testLabels(cluster *Cluster, podSpec *v1.PodTemplateSpec) error {
 
 func testEnvs(cluster *Cluster, podSpec *v1.PodTemplateSpec) error {
 	required := map[string]bool{
-		"PGHOST":               false,
-		"PGPORT":               false,
-		"PGUSER":               false,
-		"PGSCHEMA":             false,
-		"PGPASSWORD":           false,
-		"CONNECTION_POOL_MODE": false,
-		"CONNECTION_POOL_PORT": false,
+		"PGHOST":                 false,
+		"PGPORT":                 false,
+		"PGUSER":                 false,
+		"PGSCHEMA":               false,
+		"PGPASSWORD":             false,
+		"CONNECTION_POOLER_MODE": false,
+		"CONNECTION_POOLER_PORT": false,
 	}
 
 	envs := podSpec.Spec.Containers[0].Env
@@ -658,8 +658,8 @@ func testCustomPodTemplate(cluster *Cluster, podSpec *v1.PodTemplateSpec) error
 	return nil
 }
 
-func TestConnPoolPodSpec(t *testing.T) {
-	testName := "Test connection pool pod template generation"
+func TestConnectionPoolerPodSpec(t *testing.T) {
+	testName := "Test connection pooler pod template generation"
 	var cluster = New(
 		Config{
 			OpConfig: config.Config{
@@ -668,12 +668,12 @@ func TestConnPoolPodSpec(t *testing.T) {
 					SuperUsername:       superUserName,
 					ReplicationUsername: replicationUserName,
 				},
-				ConnectionPool: config.ConnectionPool{
-					MaxDBConnections:             int32ToPointer(60),
-					ConnPoolDefaultCPURequest:    "100m",
-					ConnPoolDefaultCPULimit:      "100m",
-					ConnPoolDefaultMemoryRequest: "100Mi",
-					ConnPoolDefaultMemoryLimit:   "100Mi",
+				ConnectionPooler: config.ConnectionPooler{
+					MaxDBConnections:                     int32ToPointer(60),
+					ConnectionPoolerDefaultCPURequest:    "100m",
+					ConnectionPoolerDefaultCPULimit:      "100m",
+					ConnectionPoolerDefaultMemoryRequest: "100Mi",
+					ConnectionPoolerDefaultMemoryLimit:   "100Mi",
 				},
 			},
 		}, k8sutil.KubernetesClient{}, acidv1.Postgresql{}, logger)
@@ -686,7 +686,7 @@ func TestConnPoolPodSpec(t *testing.T) {
 					SuperUsername:       superUserName,
 					ReplicationUsername: replicationUserName,
 				},
-				ConnectionPool: config.ConnectionPool{},
+				ConnectionPooler: config.ConnectionPooler{},
 			},
 		}, k8sutil.KubernetesClient{}, acidv1.Postgresql{}, logger)
 
@@ -702,7 +702,7 @@ func TestConnPoolPodSpec(t *testing.T) {
 		{
 			subTest: "default configuration",
 			spec: &acidv1.PostgresSpec{
-				ConnectionPool: &acidv1.ConnectionPool{},
+				ConnectionPooler: &acidv1.ConnectionPooler{},
 			},
 			expected: nil,
 			cluster:  cluster,
@@ -711,7 +711,7 @@ func TestConnPoolPodSpec(t *testing.T) {
 		{
 			subTest: "no default resources",
 			spec: &acidv1.PostgresSpec{
-				ConnectionPool: &acidv1.ConnectionPool{},
+				ConnectionPooler: &acidv1.ConnectionPooler{},
 			},
 			expected: errors.New(`could not generate resource requirements: could not fill resource requests: could not parse default CPU quantity: quantities must match the regular expression '^([+-]?[0-9.]+)([eEinumkKMGTP]*[-+]?[0-9]*)$'`),
 			cluster:  clusterNoDefaultRes,
@@ -720,7 +720,7 @@ func TestConnPoolPodSpec(t *testing.T) {
 		{
 			subTest: "default resources are set",
 			spec: &acidv1.PostgresSpec{
-				ConnectionPool: &acidv1.ConnectionPool{},
+				ConnectionPooler: &acidv1.ConnectionPooler{},
 			},
 			expected: nil,
 			cluster:  cluster,
@@ -729,7 +729,7 @@ func TestConnPoolPodSpec(t *testing.T) {
 		{
 			subTest: "labels for service",
 			spec: &acidv1.PostgresSpec{
-				ConnectionPool: &acidv1.ConnectionPool{},
+				ConnectionPooler: &acidv1.ConnectionPooler{},
 			},
 			expected: nil,
 			cluster:  cluster,
@@ -738,7 +738,7 @@ func TestConnPoolPodSpec(t *testing.T) {
 		{
 			subTest: "required envs",
 			spec: &acidv1.PostgresSpec{
-				ConnectionPool: &acidv1.ConnectionPool{},
+				ConnectionPooler: &acidv1.ConnectionPooler{},
 			},
 			expected: nil,
 			cluster:  cluster,
@@ -746,7 +746,7 @@ func TestConnPoolPodSpec(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		podSpec, err := tt.cluster.generateConnPoolPodTemplate(tt.spec)
+		podSpec, err := tt.cluster.generateConnectionPoolerPodTemplate(tt.spec)
 
 		if err != tt.expected && err.Error() != tt.expected.Error() {
 			t.Errorf("%s [%s]: Could not generate pod template,\n %+v, expected\n %+v",
@@ -774,9 +774,9 @@ func testDeploymentOwnwerReference(cluster *Cluster, deployment *appsv1.Deployme
 
 func testSelector(cluster *Cluster, deployment *appsv1.Deployment) error {
 	labels := deployment.Spec.Selector.MatchLabels
-	expected := cluster.connPoolLabelsSelector().MatchLabels
+	expected := cluster.connectionPoolerLabelsSelector().MatchLabels
 
-	if labels["connection-pool"] != expected["connection-pool"] {
+	if labels["connection-pooler"] != expected["connection-pooler"] {
 		return fmt.Errorf("Labels are incorrect, got %+v, expected %+v",
 			labels, expected)
 	}
@@ -784,8 +784,8 @@ func testSelector(cluster *Cluster, deployment *appsv1.Deployment) error {
 	return nil
 }
 
-func TestConnPoolDeploymentSpec(t *testing.T) {
-	testName := "Test connection pool deployment spec generation"
+func TestConnectionPoolerDeploymentSpec(t *testing.T) {
+	testName := "Test connection pooler deployment spec generation"
 	var cluster = New(
 		Config{
 			OpConfig: config.Config{
@@ -794,11 +794,11 @@ func TestConnPoolDeploymentSpec(t *testing.T) {
 					SuperUsername:       superUserName,
 					ReplicationUsername: replicationUserName,
 				},
-				ConnectionPool: config.ConnectionPool{
-					ConnPoolDefaultCPURequest:    "100m",
-					ConnPoolDefaultCPULimit:      "100m",
-					ConnPoolDefaultMemoryRequest: "100Mi",
-					ConnPoolDefaultMemoryLimit:   "100Mi",
+				ConnectionPooler: config.ConnectionPooler{
+					ConnectionPoolerDefaultCPURequest:    "100m",
+					ConnectionPoolerDefaultCPULimit:      "100m",
+					ConnectionPoolerDefaultMemoryRequest: "100Mi",
+					ConnectionPoolerDefaultMemoryLimit:   "100Mi",
 				},
 			},
 		}, k8sutil.KubernetesClient{}, acidv1.Postgresql{}, logger)
@@ -822,7 +822,7 @@ func TestConnPoolDeploymentSpec(t *testing.T) {
 		{
 			subTest: "default configuration",
 			spec: &acidv1.PostgresSpec{
-				ConnectionPool: &acidv1.ConnectionPool{},
+				ConnectionPooler: &acidv1.ConnectionPooler{},
 			},
 			expected: nil,
 			cluster:  cluster,
@@ -831,7 +831,7 @@ func TestConnPoolDeploymentSpec(t *testing.T) {
 		{
 			subTest: "owner reference",
 			spec: &acidv1.PostgresSpec{
-				ConnectionPool: &acidv1.ConnectionPool{},
+				ConnectionPooler: &acidv1.ConnectionPooler{},
 			},
 			expected: nil,
 			cluster:  cluster,
@@ -840,7 +840,7 @@ func TestConnPoolDeploymentSpec(t *testing.T) {
 		{
 			subTest: "selector",
 			spec: &acidv1.PostgresSpec{
-				ConnectionPool: &acidv1.ConnectionPool{},
+				ConnectionPooler: &acidv1.ConnectionPooler{},
 			},
 			expected: nil,
 			cluster:  cluster,
@@ -848,7 +848,7 @@ func TestConnPoolDeploymentSpec(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		deployment, err := tt.cluster.generateConnPoolDeployment(tt.spec)
+		deployment, err := tt.cluster.generateConnectionPoolerDeployment(tt.spec)
 
 		if err != tt.expected && err.Error() != tt.expected.Error() {
 			t.Errorf("%s [%s]: Could not generate deployment spec,\n %+v, expected\n %+v",
@@ -877,16 +877,16 @@ func testServiceOwnwerReference(cluster *Cluster, service *v1.Service) error {
 func testServiceSelector(cluster *Cluster, service *v1.Service) error {
 	selector := service.Spec.Selector
 
-	if selector["connection-pool"] != cluster.connPoolName() {
+	if selector["connection-pooler"] != cluster.connectionPoolerName() {
 		return fmt.Errorf("Selector is incorrect, got %s, expected %s",
-			selector["connection-pool"], cluster.connPoolName())
+			selector["connection-pooler"], cluster.connectionPoolerName())
 	}
 
 	return nil
 }
 
-func TestConnPoolServiceSpec(t *testing.T) {
-	testName := "Test connection pool service spec generation"
+func TestConnectionPoolerServiceSpec(t *testing.T) {
+	testName := "Test connection pooler service spec generation"
 	var cluster = New(
 		Config{
 			OpConfig: config.Config{
@@ -895,11 +895,11 @@ func TestConnPoolServiceSpec(t *testing.T) {
 					SuperUsername:       superUserName,
 					ReplicationUsername: replicationUserName,
 				},
-				ConnectionPool: config.ConnectionPool{
-					ConnPoolDefaultCPURequest:    "100m",
-					ConnPoolDefaultCPULimit:      "100m",
-					ConnPoolDefaultMemoryRequest: "100Mi",
-					ConnPoolDefaultMemoryLimit:   "100Mi",
+				ConnectionPooler: config.ConnectionPooler{
+					ConnectionPoolerDefaultCPURequest:    "100m",
+					ConnectionPoolerDefaultCPULimit:      "100m",
+					ConnectionPoolerDefaultMemoryRequest: "100Mi",
+					ConnectionPoolerDefaultMemoryLimit:   "100Mi",
 				},
 			},
 		}, k8sutil.KubernetesClient{}, acidv1.Postgresql{}, logger)
@@ -922,7 +922,7 @@ func TestConnPoolServiceSpec(t *testing.T) {
 		{
 			subTest: "default configuration",
 			spec: &acidv1.PostgresSpec{
-				ConnectionPool: &acidv1.ConnectionPool{},
+				ConnectionPooler: &acidv1.ConnectionPooler{},
 			},
 			cluster: cluster,
 			check:   noCheck,
@@ -930,7 +930,7 @@ func TestConnPoolServiceSpec(t *testing.T) {
 		{
 			subTest: "owner reference",
 			spec: &acidv1.PostgresSpec{
-				ConnectionPool: &acidv1.ConnectionPool{},
+				ConnectionPooler: &acidv1.ConnectionPooler{},
 			},
 			cluster: cluster,
 			check:   testServiceOwnwerReference,
@@ -938,14 +938,14 @@ func TestConnPoolServiceSpec(t *testing.T) {
 		{
 			subTest: "selector",
 			spec: &acidv1.PostgresSpec{
-				ConnectionPool: &acidv1.ConnectionPool{},
+				ConnectionPooler: &acidv1.ConnectionPooler{},
 			},
 			cluster: cluster,
 			check:   testServiceSelector,
 		},
 	}
 	for _, tt := range tests {
-		service := tt.cluster.generateConnPoolService(tt.spec)
+		service := tt.cluster.generateConnectionPoolerService(tt.spec)
 
 		if err := tt.check(cluster, service); err != nil {
 			t.Errorf("%s [%s]: Service spec is incorrect, %+v",
@@ -958,6 +958,7 @@ func TestTLS(t *testing.T) {
 	var err error
 	var spec acidv1.PostgresSpec
 	var cluster *Cluster
+	var spiloFSGroup = int64(103)
 
 	makeSpec := func(tls acidv1.TLSDescription) acidv1.PostgresSpec {
 		return acidv1.PostgresSpec{
@@ -982,6 +983,9 @@ func TestTLS(t *testing.T) {
 					SuperUsername:       superUserName,
 					ReplicationUsername: replicationUserName,
 				},
+				Resources: config.Resources{
+					SpiloFSGroup: &spiloFSGroup,
+				},
 			},
 		}, k8sutil.KubernetesClient{}, acidv1.Postgresql{}, logger)
 	spec = makeSpec(acidv1.TLSDescription{SecretName: "my-secret", CAFile: "ca.crt"})

pkg/cluster/pod.go

@@ -1,6 +1,7 @@
 package cluster
 
 import (
+	"context"
 	"fmt"
 	"math/rand"
 
@@ -17,7 +18,7 @@ func (c *Cluster) listPods() ([]v1.Pod, error) {
 		LabelSelector: c.labelsSet(false).String(),
 	}
 
-	pods, err := c.KubeClient.Pods(c.Namespace).List(listOptions)
+	pods, err := c.KubeClient.Pods(c.Namespace).List(context.TODO(), listOptions)
 	if err != nil {
 		return nil, fmt.Errorf("could not get list of pods: %v", err)
 	}
@@ -30,7 +31,7 @@ func (c *Cluster) getRolePods(role PostgresRole) ([]v1.Pod, error) {
 		LabelSelector: c.roleLabelsSet(false, role).String(),
 	}
 
-	pods, err := c.KubeClient.Pods(c.Namespace).List(listOptions)
+	pods, err := c.KubeClient.Pods(c.Namespace).List(context.TODO(), listOptions)
 	if err != nil {
 		return nil, fmt.Errorf("could not get list of pods: %v", err)
 	}
@@ -73,7 +74,7 @@ func (c *Cluster) deletePod(podName spec.NamespacedName) error {
 	ch := c.registerPodSubscriber(podName)
 	defer c.unregisterPodSubscriber(podName)
 
-	if err := c.KubeClient.Pods(podName.Namespace).Delete(podName.Name, c.deleteOptions); err != nil {
+	if err := c.KubeClient.Pods(podName.Namespace).Delete(context.TODO(), podName.Name, c.deleteOptions); err != nil {
 		return err
 	}
 
@@ -183,7 +184,7 @@ func (c *Cluster) MigrateMasterPod(podName spec.NamespacedName) error {
 		eol                bool
 	)
 
-	oldMaster, err := c.KubeClient.Pods(podName.Namespace).Get(podName.Name, metav1.GetOptions{})
+	oldMaster, err := c.KubeClient.Pods(podName.Namespace).Get(context.TODO(), podName.Name, metav1.GetOptions{})
 
 	if err != nil {
 		return fmt.Errorf("could not get pod: %v", err)
@@ -206,7 +207,9 @@ func (c *Cluster) MigrateMasterPod(podName spec.NamespacedName) error {
 	// we must have a statefulset in the cluster for the migration to work
 	if c.Statefulset == nil {
 		var sset *appsv1.StatefulSet
-		if sset, err = c.KubeClient.StatefulSets(c.Namespace).Get(c.statefulSetName(),
+		if sset, err = c.KubeClient.StatefulSets(c.Namespace).Get(
+			context.TODO(),
+			c.statefulSetName(),
 			metav1.GetOptions{}); err != nil {
 			return fmt.Errorf("could not retrieve cluster statefulset: %v", err)
 		}
@@ -247,7 +250,7 @@ func (c *Cluster) MigrateMasterPod(podName spec.NamespacedName) error {
 
 // MigrateReplicaPod recreates pod on a new node
 func (c *Cluster) MigrateReplicaPod(podName spec.NamespacedName, fromNodeName string) error {
-	replicaPod, err := c.KubeClient.Pods(podName.Namespace).Get(podName.Name, metav1.GetOptions{})
+	replicaPod, err := c.KubeClient.Pods(podName.Namespace).Get(context.TODO(), podName.Name, metav1.GetOptions{})
 	if err != nil {
 		return fmt.Errorf("could not get pod: %v", err)
 	}
@@ -276,7 +279,7 @@ func (c *Cluster) recreatePod(podName spec.NamespacedName) (*v1.Pod, error) {
 	defer c.unregisterPodSubscriber(podName)
 	stopChan := make(chan struct{})
 
-	if err := c.KubeClient.Pods(podName.Namespace).Delete(podName.Name, c.deleteOptions); err != nil {
+	if err := c.KubeClient.Pods(podName.Namespace).Delete(context.TODO(), podName.Name, c.deleteOptions); err != nil {
 		return nil, fmt.Errorf("could not delete pod: %v", err)
 	}
 
@@ -300,7 +303,7 @@ func (c *Cluster) recreatePods() error {
 		LabelSelector: ls.String(),
 	}
 
-	pods, err := c.KubeClient.Pods(namespace).List(listOptions)
+	pods, err := c.KubeClient.Pods(namespace).List(context.TODO(), listOptions)
 	if err != nil {
 		return fmt.Errorf("could not get the list of pods: %v", err)
 	}
@@ -349,7 +352,7 @@ func (c *Cluster) recreatePods() error {
 }
 
 func (c *Cluster) podIsEndOfLife(pod *v1.Pod) (bool, error) {
-	node, err := c.KubeClient.Nodes().Get(pod.Spec.NodeName, metav1.GetOptions{})
+	node, err := c.KubeClient.Nodes().Get(context.TODO(), pod.Spec.NodeName, metav1.GetOptions{})
 	if err != nil {
 		return false, err
 	}

pkg/cluster/resources.go

@@ -1,6 +1,7 @@
 package cluster
 
 import (
+	"context"
 	"fmt"
 	"strconv"
 	"strings"
@@ -80,7 +81,10 @@ func (c *Cluster) createStatefulSet() (*appsv1.StatefulSet, error) {
 	if err != nil {
 		return nil, fmt.Errorf("could not generate statefulset: %v", err)
 	}
-	statefulSet, err := c.KubeClient.StatefulSets(statefulSetSpec.Namespace).Create(statefulSetSpec)
+	statefulSet, err := c.KubeClient.StatefulSets(statefulSetSpec.Namespace).Create(
+		context.TODO(),
+		statefulSetSpec,
+		metav1.CreateOptions{})
 	if err != nil {
 		return nil, err
 	}
@@ -90,37 +94,37 @@ func (c *Cluster) createStatefulSet() (*appsv1.StatefulSet, error) {
 	return statefulSet, nil
 }
 
-// Prepare the database for connection pool to be used, i.e. install lookup
+// Prepare the database for connection pooler to be used, i.e. install lookup
 // function (do it first, because it should be fast and if it didn't succeed,
 // it doesn't makes sense to create more K8S objects. At this moment we assume
-// that necessary connection pool user exists.
+// that necessary connection pooler user exists.
 //
-// After that create all the objects for connection pool, namely a deployment
+// After that create all the objects for connection pooler, namely a deployment
 // with a chosen pooler and a service to expose it.
-func (c *Cluster) createConnectionPool(lookup InstallFunction) (*ConnectionPoolObjects, error) {
+func (c *Cluster) createConnectionPooler(lookup InstallFunction) (*ConnectionPoolerObjects, error) {
 	var msg string
-	c.setProcessName("creating connection pool")
+	c.setProcessName("creating connection pooler")
 
-	schema := c.Spec.ConnectionPool.Schema
+	schema := c.Spec.ConnectionPooler.Schema
 	if schema == "" {
-		schema = c.OpConfig.ConnectionPool.Schema
+		schema = c.OpConfig.ConnectionPooler.Schema
 	}
 
-	user := c.Spec.ConnectionPool.User
+	user := c.Spec.ConnectionPooler.User
 	if user == "" {
-		user = c.OpConfig.ConnectionPool.User
+		user = c.OpConfig.ConnectionPooler.User
 	}
 
 	err := lookup(schema, user)
 
 	if err != nil {
-		msg = "could not prepare database for connection pool: %v"
+		msg = "could not prepare database for connection pooler: %v"
 		return nil, fmt.Errorf(msg, err)
 	}
 
-	deploymentSpec, err := c.generateConnPoolDeployment(&c.Spec)
+	deploymentSpec, err := c.generateConnectionPoolerDeployment(&c.Spec)
 	if err != nil {
-		msg = "could not generate deployment for connection pool: %v"
+		msg = "could not generate deployment for connection pooler: %v"
 		return nil, fmt.Errorf(msg, err)
 	}
 
@@ -129,46 +133,46 @@ func (c *Cluster) createConnectionPool(lookup InstallFunction) (*ConnectionPoolO
 	// should be good enough to not think about it here.
 	deployment, err := c.KubeClient.
 		Deployments(deploymentSpec.Namespace).
-		Create(deploymentSpec)
+		Create(context.TODO(), deploymentSpec, metav1.CreateOptions{})
 
 	if err != nil {
 		return nil, err
 	}
 
-	serviceSpec := c.generateConnPoolService(&c.Spec)
+	serviceSpec := c.generateConnectionPoolerService(&c.Spec)
 	service, err := c.KubeClient.
 		Services(serviceSpec.Namespace).
-		Create(serviceSpec)
+		Create(context.TODO(), serviceSpec, metav1.CreateOptions{})
 
 	if err != nil {
 		return nil, err
 	}
 
-	c.ConnectionPool = &ConnectionPoolObjects{
+	c.ConnectionPooler = &ConnectionPoolerObjects{
 		Deployment: deployment,
 		Service:    service,
 	}
-	c.logger.Debugf("created new connection pool %q, uid: %q",
+	c.logger.Debugf("created new connection pooler %q, uid: %q",
 		util.NameFromMeta(deployment.ObjectMeta), deployment.UID)
 
-	return c.ConnectionPool, nil
+	return c.ConnectionPooler, nil
 }
 
-func (c *Cluster) deleteConnectionPool() (err error) {
-	c.setProcessName("deleting connection pool")
-	c.logger.Debugln("deleting connection pool")
+func (c *Cluster) deleteConnectionPooler() (err error) {
+	c.setProcessName("deleting connection pooler")
+	c.logger.Debugln("deleting connection pooler")
 
 	// Lack of connection pooler objects is not a fatal error, just log it if
 	// it was present before in the manifest
-	if c.ConnectionPool == nil {
-		c.logger.Infof("No connection pool to delete")
+	if c.ConnectionPooler == nil {
+		c.logger.Infof("No connection pooler to delete")
 		return nil
 	}
 
 	// Clean up the deployment object. If deployment resource we've remembered
 	// is somehow empty, try to delete based on what would we generate
-	deploymentName := c.connPoolName()
-	deployment := c.ConnectionPool.Deployment
+	deploymentName := c.connectionPoolerName()
+	deployment := c.ConnectionPooler.Deployment
 
 	if deployment != nil {
 		deploymentName = deployment.Name
@@ -180,19 +184,19 @@ func (c *Cluster) deleteConnectionPool() (err error) {
 	options := metav1.DeleteOptions{PropagationPolicy: &policy}
 	err = c.KubeClient.
 		Deployments(c.Namespace).
-		Delete(deploymentName, &options)
+		Delete(context.TODO(), deploymentName, options)
 
 	if !k8sutil.ResourceNotFound(err) {
-		c.logger.Debugf("Connection pool deployment was already deleted")
+		c.logger.Debugf("Connection pooler deployment was already deleted")
 	} else if err != nil {
 		return fmt.Errorf("could not delete deployment: %v", err)
 	}
 
-	c.logger.Infof("Connection pool deployment %q has been deleted", deploymentName)
+	c.logger.Infof("Connection pooler deployment %q has been deleted", deploymentName)
 
 	// Repeat the same for the service object
-	service := c.ConnectionPool.Service
-	serviceName := c.connPoolName()
+	service := c.ConnectionPooler.Service
+	serviceName := c.connectionPoolerName()
 
 	if service != nil {
 		serviceName = service.Name
@@ -202,17 +206,17 @@ func (c *Cluster) deleteConnectionPool() (err error) {
 	// will be deleted.
 	err = c.KubeClient.
 		Services(c.Namespace).
-		Delete(serviceName, &options)
+		Delete(context.TODO(), serviceName, options)
 
 	if !k8sutil.ResourceNotFound(err) {
-		c.logger.Debugf("Connection pool service was already deleted")
+		c.logger.Debugf("Connection pooler service was already deleted")
 	} else if err != nil {
 		return fmt.Errorf("could not delete service: %v", err)
 	}
 
-	c.logger.Infof("Connection pool service %q has been deleted", serviceName)
+	c.logger.Infof("Connection pooler service %q has been deleted", serviceName)
 
-	c.ConnectionPool = nil
+	c.ConnectionPooler = nil
 	return nil
 }
 
@@ -251,7 +255,7 @@ func (c *Cluster) preScaleDown(newStatefulSet *appsv1.StatefulSet) error {
 	}
 
 	podName := fmt.Sprintf("%s-0", c.Statefulset.Name)
-	masterCandidatePod, err := c.KubeClient.Pods(c.clusterNamespace()).Get(podName, metav1.GetOptions{})
+	masterCandidatePod, err := c.KubeClient.Pods(c.clusterNamespace()).Get(context.TODO(), podName, metav1.GetOptions{})
 	if err != nil {
 		return fmt.Errorf("could not get master candidate pod: %v", err)
 	}
@@ -350,9 +354,12 @@ func (c *Cluster) updateStatefulSetAnnotations(annotations map[string]string) (*
 		return nil, fmt.Errorf("could not form patch for the statefulset metadata: %v", err)
 	}
 	result, err := c.KubeClient.StatefulSets(c.Statefulset.Namespace).Patch(
+		context.TODO(),
 		c.Statefulset.Name,
 		types.MergePatchType,
-		[]byte(patchData), "")
+		[]byte(patchData),
+		metav1.PatchOptions{},
+		"")
 	if err != nil {
 		return nil, fmt.Errorf("could not patch statefulset annotations %q: %v", patchData, err)
 	}
@@ -380,9 +387,12 @@ func (c *Cluster) updateStatefulSet(newStatefulSet *appsv1.StatefulSet) error {
 	}
 
 	statefulSet, err := c.KubeClient.StatefulSets(c.Statefulset.Namespace).Patch(
+		context.TODO(),
 		c.Statefulset.Name,
 		types.MergePatchType,
-		patchData, "")
+		patchData,
+		metav1.PatchOptions{},
+		"")
 	if err != nil {
 		return fmt.Errorf("could not patch statefulset spec %q: %v", statefulSetName, err)
 	}
@@ -414,7 +424,7 @@ func (c *Cluster) replaceStatefulSet(newStatefulSet *appsv1.StatefulSet) error {
 	oldStatefulset := c.Statefulset
 
 	options := metav1.DeleteOptions{PropagationPolicy: &deletePropagationPolicy}
-	err := c.KubeClient.StatefulSets(oldStatefulset.Namespace).Delete(oldStatefulset.Name, &options)
+	err := c.KubeClient.StatefulSets(oldStatefulset.Namespace).Delete(context.TODO(), oldStatefulset.Name, options)
 	if err != nil {
 		return fmt.Errorf("could not delete statefulset %q: %v", statefulSetName, err)
 	}
@@ -425,7 +435,7 @@ func (c *Cluster) replaceStatefulSet(newStatefulSet *appsv1.StatefulSet) error {
 
 	err = retryutil.Retry(c.OpConfig.ResourceCheckInterval, c.OpConfig.ResourceCheckTimeout,
 		func() (bool, error) {
-			_, err2 := c.KubeClient.StatefulSets(oldStatefulset.Namespace).Get(oldStatefulset.Name, metav1.GetOptions{})
+			_, err2 := c.KubeClient.StatefulSets(oldStatefulset.Namespace).Get(context.TODO(), oldStatefulset.Name, metav1.GetOptions{})
 			if err2 == nil {
 				return false, nil
 			}
@@ -439,7 +449,7 @@ func (c *Cluster) replaceStatefulSet(newStatefulSet *appsv1.StatefulSet) error {
 	}
 
 	// create the new statefulset with the desired spec. It would take over the remaining pods.
-	createdStatefulset, err := c.KubeClient.StatefulSets(newStatefulSet.Namespace).Create(newStatefulSet)
+	createdStatefulset, err := c.KubeClient.StatefulSets(newStatefulSet.Namespace).Create(context.TODO(), newStatefulSet, metav1.CreateOptions{})
 	if err != nil {
 		return fmt.Errorf("could not create statefulset %q: %v", statefulSetName, err)
 	}
@@ -460,7 +470,7 @@ func (c *Cluster) deleteStatefulSet() error {
 		return fmt.Errorf("there is no statefulset in the cluster")
 	}
 
-	err := c.KubeClient.StatefulSets(c.Statefulset.Namespace).Delete(c.Statefulset.Name, c.deleteOptions)
+	err := c.KubeClient.StatefulSets(c.Statefulset.Namespace).Delete(context.TODO(), c.Statefulset.Name, c.deleteOptions)
 	if err != nil {
 		return err
 	}
@@ -482,7 +492,7 @@ func (c *Cluster) createService(role PostgresRole) (*v1.Service, error) {
 	c.setProcessName("creating %v service", role)
 
 	serviceSpec := c.generateService(role, &c.Spec)
-	service, err := c.KubeClient.Services(serviceSpec.Namespace).Create(serviceSpec)
+	service, err := c.KubeClient.Services(serviceSpec.Namespace).Create(context.TODO(), serviceSpec, metav1.CreateOptions{})
 	if err != nil {
 		return nil, err
 	}
@@ -509,9 +519,12 @@ func (c *Cluster) updateService(role PostgresRole, newService *v1.Service) error
 	if len(newService.ObjectMeta.Annotations) > 0 {
 		if annotationsPatchData, err := metaAnnotationsPatch(newService.ObjectMeta.Annotations); err == nil {
 			_, err = c.KubeClient.Services(serviceName.Namespace).Patch(
+				context.TODO(),
 				serviceName.Name,
 				types.MergePatchType,
-				[]byte(annotationsPatchData), "")
+				[]byte(annotationsPatchData),
+				metav1.PatchOptions{},
+				"")
 
 			if err != nil {
 				return fmt.Errorf("could not replace annotations for the service %q: %v", serviceName, err)
@@ -528,7 +541,7 @@ func (c *Cluster) updateService(role PostgresRole, newService *v1.Service) error
 	if newServiceType == "ClusterIP" && newServiceType != oldServiceType {
 		newService.ResourceVersion = c.Services[role].ResourceVersion
 		newService.Spec.ClusterIP = c.Services[role].Spec.ClusterIP
-		svc, err = c.KubeClient.Services(serviceName.Namespace).Update(newService)
+		svc, err = c.KubeClient.Services(serviceName.Namespace).Update(context.TODO(), newService, metav1.UpdateOptions{})
 		if err != nil {
 			return fmt.Errorf("could not update service %q: %v", serviceName, err)
 		}
@@ -539,9 +552,7 @@ func (c *Cluster) updateService(role PostgresRole, newService *v1.Service) error
 		}
 
 		svc, err = c.KubeClient.Services(serviceName.Namespace).Patch(
-			serviceName.Name,
-			types.MergePatchType,
-			patchData, "")
+			context.TODO(), serviceName.Name, types.MergePatchType, patchData, metav1.PatchOptions{}, "")
 		if err != nil {
 			return fmt.Errorf("could not patch service %q: %v", serviceName, err)
 		}
@@ -560,7 +571,7 @@ func (c *Cluster) deleteService(role PostgresRole) error {
 		return nil
 	}
 
-	if err := c.KubeClient.Services(service.Namespace).Delete(service.Name, c.deleteOptions); err != nil {
+	if err := c.KubeClient.Services(service.Namespace).Delete(context.TODO(), service.Name, c.deleteOptions); err != nil {
 		return err
 	}
 
@@ -584,7 +595,7 @@ func (c *Cluster) createEndpoint(role PostgresRole) (*v1.Endpoints, error) {
 	}
 	endpointsSpec := c.generateEndpoint(role, subsets)
 
-	endpoints, err := c.KubeClient.Endpoints(endpointsSpec.Namespace).Create(endpointsSpec)
+	endpoints, err := c.KubeClient.Endpoints(endpointsSpec.Namespace).Create(context.TODO(), endpointsSpec, metav1.CreateOptions{})
 	if err != nil {
 		return nil, fmt.Errorf("could not create %s endpoint: %v", role, err)
 	}
@@ -626,7 +637,7 @@ func (c *Cluster) createPodDisruptionBudget() (*policybeta1.PodDisruptionBudget,
 	podDisruptionBudgetSpec := c.generatePodDisruptionBudget()
 	podDisruptionBudget, err := c.KubeClient.
 		PodDisruptionBudgets(podDisruptionBudgetSpec.Namespace).
-		Create(podDisruptionBudgetSpec)
+		Create(context.TODO(), podDisruptionBudgetSpec, metav1.CreateOptions{})
 
 	if err != nil {
 		return nil, err
@@ -647,7 +658,7 @@ func (c *Cluster) updatePodDisruptionBudget(pdb *policybeta1.PodDisruptionBudget
 
 	newPdb, err := c.KubeClient.
 		PodDisruptionBudgets(pdb.Namespace).
-		Create(pdb)
+		Create(context.TODO(), pdb, metav1.CreateOptions{})
 	if err != nil {
 		return fmt.Errorf("could not create pod disruption budget: %v", err)
 	}
@@ -665,7 +676,7 @@ func (c *Cluster) deletePodDisruptionBudget() error {
 	pdbName := util.NameFromMeta(c.PodDisruptionBudget.ObjectMeta)
 	err := c.KubeClient.
 		PodDisruptionBudgets(c.PodDisruptionBudget.Namespace).
-		Delete(c.PodDisruptionBudget.Name, c.deleteOptions)
+		Delete(context.TODO(), c.PodDisruptionBudget.Name, c.deleteOptions)
 	if err != nil {
 		return fmt.Errorf("could not delete pod disruption budget: %v", err)
 	}
@@ -674,7 +685,7 @@ func (c *Cluster) deletePodDisruptionBudget() error {
 
 	err = retryutil.Retry(c.OpConfig.ResourceCheckInterval, c.OpConfig.ResourceCheckTimeout,
 		func() (bool, error) {
-			_, err2 := c.KubeClient.PodDisruptionBudgets(pdbName.Namespace).Get(pdbName.Name, metav1.GetOptions{})
+			_, err2 := c.KubeClient.PodDisruptionBudgets(pdbName.Namespace).Get(context.TODO(), pdbName.Name, metav1.GetOptions{})
 			if err2 == nil {
 				return false, nil
 			}
@@ -697,7 +708,8 @@ func (c *Cluster) deleteEndpoint(role PostgresRole) error {
 		return fmt.Errorf("there is no %s endpoint in the cluster", role)
 	}
 
-	if err := c.KubeClient.Endpoints(c.Endpoints[role].Namespace).Delete(c.Endpoints[role].Name, c.deleteOptions); err != nil {
+	if err := c.KubeClient.Endpoints(c.Endpoints[role].Namespace).Delete(
+		context.TODO(), c.Endpoints[role].Name, c.deleteOptions); err != nil {
 		return fmt.Errorf("could not delete endpoint: %v", err)
 	}
 
@@ -711,7 +723,7 @@ func (c *Cluster) deleteEndpoint(role PostgresRole) error {
 func (c *Cluster) deleteSecret(secret *v1.Secret) error {
 	c.setProcessName("deleting secret %q", util.NameFromMeta(secret.ObjectMeta))
 	c.logger.Debugf("deleting secret %q", util.NameFromMeta(secret.ObjectMeta))
-	err := c.KubeClient.Secrets(secret.Namespace).Delete(secret.Name, c.deleteOptions)
+	err := c.KubeClient.Secrets(secret.Namespace).Delete(context.TODO(), secret.Name, c.deleteOptions)
 	if err != nil {
 		return err
 	}
@@ -736,7 +748,7 @@ func (c *Cluster) createLogicalBackupJob() (err error) {
 	}
 	c.logger.Debugf("Generated cronJobSpec: %v", logicalBackupJobSpec)
 
-	_, err = c.KubeClient.CronJobsGetter.CronJobs(c.Namespace).Create(logicalBackupJobSpec)
+	_, err = c.KubeClient.CronJobsGetter.CronJobs(c.Namespace).Create(context.TODO(), logicalBackupJobSpec, metav1.CreateOptions{})
 	if err != nil {
 		return fmt.Errorf("could not create k8s cron job: %v", err)
 	}
@@ -754,9 +766,12 @@ func (c *Cluster) patchLogicalBackupJob(newJob *batchv1beta1.CronJob) error {
 
 	// update the backup job spec
 	_, err = c.KubeClient.CronJobsGetter.CronJobs(c.Namespace).Patch(
+		context.TODO(),
 		c.getLogicalBackupJobName(),
 		types.MergePatchType,
-		patchData, "")
+		patchData,
+		metav1.PatchOptions{},
+		"")
 	if err != nil {
 		return fmt.Errorf("could not patch logical backup job: %v", err)
 	}
@@ -768,7 +783,7 @@ func (c *Cluster) deleteLogicalBackupJob() error {
 
 	c.logger.Info("removing the logical backup job")
 
-	return c.KubeClient.CronJobsGetter.CronJobs(c.Namespace).Delete(c.getLogicalBackupJobName(), c.deleteOptions)
+	return c.KubeClient.CronJobsGetter.CronJobs(c.Namespace).Delete(context.TODO(), c.getLogicalBackupJobName(), c.deleteOptions)
 }
 
 // GetServiceMaster returns cluster's kubernetes master Service
@@ -801,12 +816,12 @@ func (c *Cluster) GetPodDisruptionBudget() *policybeta1.PodDisruptionBudget {
 	return c.PodDisruptionBudget
 }
 
-// Perform actual patching of a connection pool deployment, assuming that all
+// Perform actual patching of a connection pooler deployment, assuming that all
 // the check were already done before.
-func (c *Cluster) updateConnPoolDeployment(oldDeploymentSpec, newDeployment *appsv1.Deployment) (*appsv1.Deployment, error) {
-	c.setProcessName("updating connection pool")
-	if c.ConnectionPool == nil || c.ConnectionPool.Deployment == nil {
-		return nil, fmt.Errorf("there is no connection pool in the cluster")
+func (c *Cluster) updateConnectionPoolerDeployment(oldDeploymentSpec, newDeployment *appsv1.Deployment) (*appsv1.Deployment, error) {
+	c.setProcessName("updating connection pooler")
+	if c.ConnectionPooler == nil || c.ConnectionPooler.Deployment == nil {
+		return nil, fmt.Errorf("there is no connection pooler in the cluster")
 	}
 
 	patchData, err := specPatch(newDeployment.Spec)
@@ -818,16 +833,18 @@ func (c *Cluster) updateConnPoolDeployment(oldDeploymentSpec, newDeployment *app
 	// worker at one time will try to update it chances of conflicts are
 	// minimal.
 	deployment, err := c.KubeClient.
-		Deployments(c.ConnectionPool.Deployment.Namespace).
-		Patch(
-			c.ConnectionPool.Deployment.Name,
-			types.MergePatchType,
-			patchData, "")
+		Deployments(c.ConnectionPooler.Deployment.Namespace).Patch(
+		context.TODO(),
+		c.ConnectionPooler.Deployment.Name,
+		types.MergePatchType,
+		patchData,
+		metav1.PatchOptions{},
+		"")
 	if err != nil {
 		return nil, fmt.Errorf("could not patch deployment: %v", err)
 	}
 
-	c.ConnectionPool.Deployment = deployment
+	c.ConnectionPooler.Deployment = deployment
 
 	return deployment, nil
 }

pkg/cluster/resources_test.go

@@ -19,8 +19,8 @@ func boolToPointer(value bool) *bool {
 	return &value
 }
 
-func TestConnPoolCreationAndDeletion(t *testing.T) {
-	testName := "Test connection pool creation"
+func TestConnectionPoolerCreationAndDeletion(t *testing.T) {
+	testName := "Test connection pooler creation"
 	var cluster = New(
 		Config{
 			OpConfig: config.Config{
@@ -29,11 +29,11 @@ func TestConnPoolCreationAndDeletion(t *testing.T) {
 					SuperUsername:       superUserName,
 					ReplicationUsername: replicationUserName,
 				},
-				ConnectionPool: config.ConnectionPool{
-					ConnPoolDefaultCPURequest:    "100m",
-					ConnPoolDefaultCPULimit:      "100m",
-					ConnPoolDefaultMemoryRequest: "100Mi",
-					ConnPoolDefaultMemoryLimit:   "100Mi",
+				ConnectionPooler: config.ConnectionPooler{
+					ConnectionPoolerDefaultCPURequest:    "100m",
+					ConnectionPoolerDefaultCPULimit:      "100m",
+					ConnectionPoolerDefaultMemoryRequest: "100Mi",
+					ConnectionPoolerDefaultMemoryLimit:   "100Mi",
 				},
 			},
 		}, k8sutil.NewMockKubernetesClient(), acidv1.Postgresql{}, logger)
@@ -45,31 +45,31 @@ func TestConnPoolCreationAndDeletion(t *testing.T) {
 	}
 
 	cluster.Spec = acidv1.PostgresSpec{
-		ConnectionPool: &acidv1.ConnectionPool{},
+		ConnectionPooler: &acidv1.ConnectionPooler{},
 	}
-	poolResources, err := cluster.createConnectionPool(mockInstallLookupFunction)
+	poolerResources, err := cluster.createConnectionPooler(mockInstallLookupFunction)
 
 	if err != nil {
-		t.Errorf("%s: Cannot create connection pool, %s, %+v",
-			testName, err, poolResources)
+		t.Errorf("%s: Cannot create connection pooler, %s, %+v",
+			testName, err, poolerResources)
 	}
 
-	if poolResources.Deployment == nil {
-		t.Errorf("%s: Connection pool deployment is empty", testName)
+	if poolerResources.Deployment == nil {
+		t.Errorf("%s: Connection pooler deployment is empty", testName)
 	}
 
-	if poolResources.Service == nil {
-		t.Errorf("%s: Connection pool service is empty", testName)
+	if poolerResources.Service == nil {
+		t.Errorf("%s: Connection pooler service is empty", testName)
 	}
 
-	err = cluster.deleteConnectionPool()
+	err = cluster.deleteConnectionPooler()
 	if err != nil {
-		t.Errorf("%s: Cannot delete connection pool, %s", testName, err)
+		t.Errorf("%s: Cannot delete connection pooler, %s", testName, err)
 	}
 }
 
-func TestNeedConnPool(t *testing.T) {
-	testName := "Test how connection pool can be enabled"
+func TestNeedConnectionPooler(t *testing.T) {
+	testName := "Test how connection pooler can be enabled"
 	var cluster = New(
 		Config{
 			OpConfig: config.Config{
@@ -78,50 +78,50 @@ func TestNeedConnPool(t *testing.T) {
 					SuperUsername:       superUserName,
 					ReplicationUsername: replicationUserName,
 				},
-				ConnectionPool: config.ConnectionPool{
-					ConnPoolDefaultCPURequest:    "100m",
-					ConnPoolDefaultCPULimit:      "100m",
-					ConnPoolDefaultMemoryRequest: "100Mi",
-					ConnPoolDefaultMemoryLimit:   "100Mi",
+				ConnectionPooler: config.ConnectionPooler{
+					ConnectionPoolerDefaultCPURequest:    "100m",
+					ConnectionPoolerDefaultCPULimit:      "100m",
+					ConnectionPoolerDefaultMemoryRequest: "100Mi",
+					ConnectionPoolerDefaultMemoryLimit:   "100Mi",
 				},
 			},
 		}, k8sutil.NewMockKubernetesClient(), acidv1.Postgresql{}, logger)
 
 	cluster.Spec = acidv1.PostgresSpec{
-		ConnectionPool: &acidv1.ConnectionPool{},
+		ConnectionPooler: &acidv1.ConnectionPooler{},
 	}
 
-	if !cluster.needConnectionPool() {
-		t.Errorf("%s: Connection pool is not enabled with full definition",
+	if !cluster.needConnectionPooler() {
+		t.Errorf("%s: Connection pooler is not enabled with full definition",
 			testName)
 	}
 
 	cluster.Spec = acidv1.PostgresSpec{
-		EnableConnectionPool: boolToPointer(true),
+		EnableConnectionPooler: boolToPointer(true),
 	}
 
-	if !cluster.needConnectionPool() {
-		t.Errorf("%s: Connection pool is not enabled with flag",
+	if !cluster.needConnectionPooler() {
+		t.Errorf("%s: Connection pooler is not enabled with flag",
 			testName)
 	}
 
 	cluster.Spec = acidv1.PostgresSpec{
-		EnableConnectionPool: boolToPointer(false),
-		ConnectionPool:       &acidv1.ConnectionPool{},
+		EnableConnectionPooler: boolToPointer(false),
+		ConnectionPooler:       &acidv1.ConnectionPooler{},
 	}
 
-	if cluster.needConnectionPool() {
-		t.Errorf("%s: Connection pool is still enabled with flag being false",
+	if cluster.needConnectionPooler() {
+		t.Errorf("%s: Connection pooler is still enabled with flag being false",
 			testName)
 	}
 
 	cluster.Spec = acidv1.PostgresSpec{
-		EnableConnectionPool: boolToPointer(true),
-		ConnectionPool:       &acidv1.ConnectionPool{},
+		EnableConnectionPooler: boolToPointer(true),
+		ConnectionPooler:       &acidv1.ConnectionPooler{},
 	}
 
-	if !cluster.needConnectionPool() {
-		t.Errorf("%s: Connection pool is not enabled with flag and full",
+	if !cluster.needConnectionPooler() {
+		t.Errorf("%s: Connection pooler is not enabled with flag and full",
 			testName)
 	}
 }

pkg/cluster/sync.go

@@ -1,6 +1,7 @@
 package cluster
 
 import (
+	"context"
 	"fmt"
 	"strings"
 
@@ -115,9 +116,9 @@ func (c *Cluster) Sync(newSpec *acidv1.Postgresql) error {
 		}
 	}
 
-	// sync connection pool
-	if err = c.syncConnectionPool(&oldSpec, newSpec, c.installLookupFunction); err != nil {
-		return fmt.Errorf("could not sync connection pool: %v", err)
+	// sync connection pooler
+	if err = c.syncConnectionPooler(&oldSpec, newSpec, c.installLookupFunction); err != nil {
+		return fmt.Errorf("could not sync connection pooler: %v", err)
 	}
 
 	return err
@@ -146,7 +147,7 @@ func (c *Cluster) syncService(role PostgresRole) error {
 	)
 	c.setProcessName("syncing %s service", role)
 
-	if svc, err = c.KubeClient.Services(c.Namespace).Get(c.serviceName(role), metav1.GetOptions{}); err == nil {
+	if svc, err = c.KubeClient.Services(c.Namespace).Get(context.TODO(), c.serviceName(role), metav1.GetOptions{}); err == nil {
 		c.Services[role] = svc
 		desiredSvc := c.generateService(role, &c.Spec)
 		if match, reason := k8sutil.SameService(svc, desiredSvc); !match {
@@ -172,7 +173,7 @@ func (c *Cluster) syncService(role PostgresRole) error {
 			return fmt.Errorf("could not create missing %s service: %v", role, err)
 		}
 		c.logger.Infof("%s service %q already exists", role, util.NameFromMeta(svc.ObjectMeta))
-		if svc, err = c.KubeClient.Services(c.Namespace).Get(c.serviceName(role), metav1.GetOptions{}); err != nil {
+		if svc, err = c.KubeClient.Services(c.Namespace).Get(context.TODO(), c.serviceName(role), metav1.GetOptions{}); err != nil {
 			return fmt.Errorf("could not fetch existing %s service: %v", role, err)
 		}
 	}
@@ -187,7 +188,7 @@ func (c *Cluster) syncEndpoint(role PostgresRole) error {
 	)
 	c.setProcessName("syncing %s endpoint", role)
 
-	if ep, err = c.KubeClient.Endpoints(c.Namespace).Get(c.endpointName(role), metav1.GetOptions{}); err == nil {
+	if ep, err = c.KubeClient.Endpoints(c.Namespace).Get(context.TODO(), c.endpointName(role), metav1.GetOptions{}); err == nil {
 		// TODO: No syncing of endpoints here, is this covered completely by updateService?
 		c.Endpoints[role] = ep
 		return nil
@@ -206,7 +207,7 @@ func (c *Cluster) syncEndpoint(role PostgresRole) error {
 			return fmt.Errorf("could not create missing %s endpoint: %v", role, err)
 		}
 		c.logger.Infof("%s endpoint %q already exists", role, util.NameFromMeta(ep.ObjectMeta))
-		if ep, err = c.KubeClient.Endpoints(c.Namespace).Get(c.endpointName(role), metav1.GetOptions{}); err != nil {
+		if ep, err = c.KubeClient.Endpoints(c.Namespace).Get(context.TODO(), c.endpointName(role), metav1.GetOptions{}); err != nil {
 			return fmt.Errorf("could not fetch existing %s endpoint: %v", role, err)
 		}
 	}
@@ -219,7 +220,7 @@ func (c *Cluster) syncPodDisruptionBudget(isUpdate bool) error {
 		pdb *policybeta1.PodDisruptionBudget
 		err error
 	)
-	if pdb, err = c.KubeClient.PodDisruptionBudgets(c.Namespace).Get(c.podDisruptionBudgetName(), metav1.GetOptions{}); err == nil {
+	if pdb, err = c.KubeClient.PodDisruptionBudgets(c.Namespace).Get(context.TODO(), c.podDisruptionBudgetName(), metav1.GetOptions{}); err == nil {
 		c.PodDisruptionBudget = pdb
 		newPDB := c.generatePodDisruptionBudget()
 		if match, reason := k8sutil.SamePDB(pdb, newPDB); !match {
@@ -245,7 +246,7 @@ func (c *Cluster) syncPodDisruptionBudget(isUpdate bool) error {
 			return fmt.Errorf("could not create pod disruption budget: %v", err)
 		}
 		c.logger.Infof("pod disruption budget %q already exists", util.NameFromMeta(pdb.ObjectMeta))
-		if pdb, err = c.KubeClient.PodDisruptionBudgets(c.Namespace).Get(c.podDisruptionBudgetName(), metav1.GetOptions{}); err != nil {
+		if pdb, err = c.KubeClient.PodDisruptionBudgets(c.Namespace).Get(context.TODO(), c.podDisruptionBudgetName(), metav1.GetOptions{}); err != nil {
 			return fmt.Errorf("could not fetch existing %q pod disruption budget", util.NameFromMeta(pdb.ObjectMeta))
 		}
 	}
@@ -261,7 +262,7 @@ func (c *Cluster) syncStatefulSet() error {
 		podsRollingUpdateRequired bool
 	)
 	// NB: Be careful to consider the codepath that acts on podsRollingUpdateRequired before returning early.
-	sset, err := c.KubeClient.StatefulSets(c.Namespace).Get(c.statefulSetName(), metav1.GetOptions{})
+	sset, err := c.KubeClient.StatefulSets(c.Namespace).Get(context.TODO(), c.statefulSetName(), metav1.GetOptions{})
 	if err != nil {
 		if !k8sutil.ResourceNotFound(err) {
 			return fmt.Errorf("could not get statefulset: %v", err)
@@ -410,14 +411,14 @@ func (c *Cluster) syncSecrets() error {
 	secrets := c.generateUserSecrets()
 
 	for secretUsername, secretSpec := range secrets {
-		if secret, err = c.KubeClient.Secrets(secretSpec.Namespace).Create(secretSpec); err == nil {
+		if secret, err = c.KubeClient.Secrets(secretSpec.Namespace).Create(context.TODO(), secretSpec, metav1.CreateOptions{}); err == nil {
 			c.Secrets[secret.UID] = secret
 			c.logger.Debugf("created new secret %q, uid: %q", util.NameFromMeta(secret.ObjectMeta), secret.UID)
 			continue
 		}
 		if k8sutil.ResourceAlreadyExists(err) {
 			var userMap map[string]spec.PgUser
-			if secret, err = c.KubeClient.Secrets(secretSpec.Namespace).Get(secretSpec.Name, metav1.GetOptions{}); err != nil {
+			if secret, err = c.KubeClient.Secrets(secretSpec.Namespace).Get(context.TODO(), secretSpec.Name, metav1.GetOptions{}); err != nil {
 				return fmt.Errorf("could not get current secret: %v", err)
 			}
 			if secretUsername != string(secret.Data["username"]) {
@@ -440,7 +441,7 @@ func (c *Cluster) syncSecrets() error {
 				pwdUser.Origin == spec.RoleOriginInfrastructure {
 
 				c.logger.Debugf("updating the secret %q from the infrastructure roles", secretSpec.Name)
-				if _, err = c.KubeClient.Secrets(secretSpec.Namespace).Update(secretSpec); err != nil {
+				if _, err = c.KubeClient.Secrets(secretSpec.Namespace).Update(context.TODO(), secretSpec, metav1.UpdateOptions{}); err != nil {
 					return fmt.Errorf("could not update infrastructure role secret for role %q: %v", secretUsername, err)
 				}
 			} else {
@@ -483,12 +484,12 @@ func (c *Cluster) syncRoles() (err error) {
 		userNames = append(userNames, u.Name)
 	}
 
-	if c.needConnectionPool() {
-		connPoolUser := c.systemUsers[constants.ConnectionPoolUserKeyName]
-		userNames = append(userNames, connPoolUser.Name)
+	if c.needConnectionPooler() {
+		connectionPoolerUser := c.systemUsers[constants.ConnectionPoolerUserKeyName]
+		userNames = append(userNames, connectionPoolerUser.Name)
 
-		if _, exists := c.pgUsers[connPoolUser.Name]; !exists {
-			c.pgUsers[connPoolUser.Name] = connPoolUser
+		if _, exists := c.pgUsers[connectionPoolerUser.Name]; !exists {
+			c.pgUsers[connectionPoolerUser.Name] = connectionPoolerUser
 		}
 	}
 
@@ -695,7 +696,7 @@ func (c *Cluster) syncLogicalBackupJob() error {
 	// sync the job if it exists
 
 	jobName := c.getLogicalBackupJobName()
-	if job, err = c.KubeClient.CronJobsGetter.CronJobs(c.Namespace).Get(jobName, metav1.GetOptions{}); err == nil {
+	if job, err = c.KubeClient.CronJobsGetter.CronJobs(c.Namespace).Get(context.TODO(), jobName, metav1.GetOptions{}); err == nil {
 
 		desiredJob, err = c.generateLogicalBackupJob()
 		if err != nil {
@@ -729,7 +730,7 @@ func (c *Cluster) syncLogicalBackupJob() error {
 			return fmt.Errorf("could not create missing logical backup job: %v", err)
 		}
 		c.logger.Infof("logical backup job %q already exists", jobName)
-		if _, err = c.KubeClient.CronJobsGetter.CronJobs(c.Namespace).Get(jobName, metav1.GetOptions{}); err != nil {
+		if _, err = c.KubeClient.CronJobsGetter.CronJobs(c.Namespace).Get(context.TODO(), jobName, metav1.GetOptions{}); err != nil {
 			return fmt.Errorf("could not fetch existing logical backup job: %v", err)
 		}
 	}
@@ -737,69 +738,69 @@ func (c *Cluster) syncLogicalBackupJob() error {
 	return nil
 }
 
-func (c *Cluster) syncConnectionPool(oldSpec, newSpec *acidv1.Postgresql, lookup InstallFunction) error {
-	if c.ConnectionPool == nil {
-		c.ConnectionPool = &ConnectionPoolObjects{}
+func (c *Cluster) syncConnectionPooler(oldSpec, newSpec *acidv1.Postgresql, lookup InstallFunction) error {
+	if c.ConnectionPooler == nil {
+		c.ConnectionPooler = &ConnectionPoolerObjects{}
 	}
 
-	newNeedConnPool := c.needConnectionPoolWorker(&newSpec.Spec)
-	oldNeedConnPool := c.needConnectionPoolWorker(&oldSpec.Spec)
+	newNeedConnectionPooler := c.needConnectionPoolerWorker(&newSpec.Spec)
+	oldNeedConnectionPooler := c.needConnectionPoolerWorker(&oldSpec.Spec)
 
-	if newNeedConnPool {
-		// Try to sync in any case. If we didn't needed connection pool before,
+	if newNeedConnectionPooler {
+		// Try to sync in any case. If we didn't needed connection pooler before,
 		// it means we want to create it. If it was already present, still sync
 		// since it could happen that there is no difference in specs, and all
-		// the resources are remembered, but the deployment was manualy deleted
+		// the resources are remembered, but the deployment was manually deleted
 		// in between
-		c.logger.Debug("syncing connection pool")
+		c.logger.Debug("syncing connection pooler")
 
 		// in this case also do not forget to install lookup function as for
 		// creating cluster
-		if !oldNeedConnPool || !c.ConnectionPool.LookupFunction {
-			newConnPool := newSpec.Spec.ConnectionPool
+		if !oldNeedConnectionPooler || !c.ConnectionPooler.LookupFunction {
+			newConnectionPooler := newSpec.Spec.ConnectionPooler
 
 			specSchema := ""
 			specUser := ""
 
-			if newConnPool != nil {
-				specSchema = newConnPool.Schema
-				specUser = newConnPool.User
+			if newConnectionPooler != nil {
+				specSchema = newConnectionPooler.Schema
+				specUser = newConnectionPooler.User
 			}
 
 			schema := util.Coalesce(
 				specSchema,
-				c.OpConfig.ConnectionPool.Schema)
+				c.OpConfig.ConnectionPooler.Schema)
 
 			user := util.Coalesce(
 				specUser,
-				c.OpConfig.ConnectionPool.User)
+				c.OpConfig.ConnectionPooler.User)
 
 			if err := lookup(schema, user); err != nil {
 				return err
 			}
 		}
 
-		if err := c.syncConnectionPoolWorker(oldSpec, newSpec); err != nil {
-			c.logger.Errorf("could not sync connection pool: %v", err)
+		if err := c.syncConnectionPoolerWorker(oldSpec, newSpec); err != nil {
+			c.logger.Errorf("could not sync connection pooler: %v", err)
 			return err
 		}
 	}
 
-	if oldNeedConnPool && !newNeedConnPool {
+	if oldNeedConnectionPooler && !newNeedConnectionPooler {
 		// delete and cleanup resources
-		if err := c.deleteConnectionPool(); err != nil {
-			c.logger.Warningf("could not remove connection pool: %v", err)
+		if err := c.deleteConnectionPooler(); err != nil {
+			c.logger.Warningf("could not remove connection pooler: %v", err)
 		}
 	}
 
-	if !oldNeedConnPool && !newNeedConnPool {
+	if !oldNeedConnectionPooler && !newNeedConnectionPooler {
 		// delete and cleanup resources if not empty
-		if c.ConnectionPool != nil &&
-			(c.ConnectionPool.Deployment != nil ||
-				c.ConnectionPool.Service != nil) {
+		if c.ConnectionPooler != nil &&
+			(c.ConnectionPooler.Deployment != nil ||
+				c.ConnectionPooler.Service != nil) {
 
-			if err := c.deleteConnectionPool(); err != nil {
-				c.logger.Warningf("could not remove connection pool: %v", err)
+			if err := c.deleteConnectionPooler(); err != nil {
+				c.logger.Warningf("could not remove connection pooler: %v", err)
 			}
 		}
 	}
@@ -807,58 +808,58 @@ func (c *Cluster) syncConnectionPool(oldSpec, newSpec *acidv1.Postgresql, lookup
 	return nil
 }
 
-// Synchronize connection pool resources. Effectively we're interested only in
+// Synchronize connection pooler resources. Effectively we're interested only in
 // synchronizing the corresponding deployment, but in case of deployment or
 // service is missing, create it. After checking, also remember an object for
 // the future references.
-func (c *Cluster) syncConnectionPoolWorker(oldSpec, newSpec *acidv1.Postgresql) error {
+func (c *Cluster) syncConnectionPoolerWorker(oldSpec, newSpec *acidv1.Postgresql) error {
 	deployment, err := c.KubeClient.
 		Deployments(c.Namespace).
-		Get(c.connPoolName(), metav1.GetOptions{})
+		Get(context.TODO(), c.connectionPoolerName(), metav1.GetOptions{})
 
 	if err != nil && k8sutil.ResourceNotFound(err) {
-		msg := "Deployment %s for connection pool synchronization is not found, create it"
-		c.logger.Warningf(msg, c.connPoolName())
+		msg := "Deployment %s for connection pooler synchronization is not found, create it"
+		c.logger.Warningf(msg, c.connectionPoolerName())
 
-		deploymentSpec, err := c.generateConnPoolDeployment(&newSpec.Spec)
+		deploymentSpec, err := c.generateConnectionPoolerDeployment(&newSpec.Spec)
 		if err != nil {
-			msg = "could not generate deployment for connection pool: %v"
+			msg = "could not generate deployment for connection pooler: %v"
 			return fmt.Errorf(msg, err)
 		}
 
 		deployment, err := c.KubeClient.
 			Deployments(deploymentSpec.Namespace).
-			Create(deploymentSpec)
+			Create(context.TODO(), deploymentSpec, metav1.CreateOptions{})
 
 		if err != nil {
 			return err
 		}
 
-		c.ConnectionPool.Deployment = deployment
+		c.ConnectionPooler.Deployment = deployment
 	} else if err != nil {
-		return fmt.Errorf("could not get connection pool deployment to sync: %v", err)
+		return fmt.Errorf("could not get connection pooler deployment to sync: %v", err)
 	} else {
-		c.ConnectionPool.Deployment = deployment
+		c.ConnectionPooler.Deployment = deployment
 
 		// actual synchronization
-		oldConnPool := oldSpec.Spec.ConnectionPool
-		newConnPool := newSpec.Spec.ConnectionPool
-		specSync, specReason := c.needSyncConnPoolSpecs(oldConnPool, newConnPool)
-		defaultsSync, defaultsReason := c.needSyncConnPoolDefaults(newConnPool, deployment)
+		oldConnectionPooler := oldSpec.Spec.ConnectionPooler
+		newConnectionPooler := newSpec.Spec.ConnectionPooler
+		specSync, specReason := c.needSyncConnectionPoolerSpecs(oldConnectionPooler, newConnectionPooler)
+		defaultsSync, defaultsReason := c.needSyncConnectionPoolerDefaults(newConnectionPooler, deployment)
 		reason := append(specReason, defaultsReason...)
 		if specSync || defaultsSync {
-			c.logger.Infof("Update connection pool deployment %s, reason: %+v",
-				c.connPoolName(), reason)
+			c.logger.Infof("Update connection pooler deployment %s, reason: %+v",
+				c.connectionPoolerName(), reason)
 
-			newDeploymentSpec, err := c.generateConnPoolDeployment(&newSpec.Spec)
+			newDeploymentSpec, err := c.generateConnectionPoolerDeployment(&newSpec.Spec)
 			if err != nil {
-				msg := "could not generate deployment for connection pool: %v"
+				msg := "could not generate deployment for connection pooler: %v"
 				return fmt.Errorf(msg, err)
 			}
 
-			oldDeploymentSpec := c.ConnectionPool.Deployment
+			oldDeploymentSpec := c.ConnectionPooler.Deployment
 
-			deployment, err := c.updateConnPoolDeployment(
+			deployment, err := c.updateConnectionPoolerDeployment(
 				oldDeploymentSpec,
 				newDeploymentSpec)
 
@@ -866,34 +867,34 @@ func (c *Cluster) syncConnectionPoolWorker(oldSpec, newSpec *acidv1.Postgresql)
 				return err
 			}
 
-			c.ConnectionPool.Deployment = deployment
+			c.ConnectionPooler.Deployment = deployment
 			return nil
 		}
 	}
 
 	service, err := c.KubeClient.
 		Services(c.Namespace).
-		Get(c.connPoolName(), metav1.GetOptions{})
+		Get(context.TODO(), c.connectionPoolerName(), metav1.GetOptions{})
 
 	if err != nil && k8sutil.ResourceNotFound(err) {
-		msg := "Service %s for connection pool synchronization is not found, create it"
-		c.logger.Warningf(msg, c.connPoolName())
+		msg := "Service %s for connection pooler synchronization is not found, create it"
+		c.logger.Warningf(msg, c.connectionPoolerName())
 
-		serviceSpec := c.generateConnPoolService(&newSpec.Spec)
+		serviceSpec := c.generateConnectionPoolerService(&newSpec.Spec)
 		service, err := c.KubeClient.
 			Services(serviceSpec.Namespace).
-			Create(serviceSpec)
+			Create(context.TODO(), serviceSpec, metav1.CreateOptions{})
 
 		if err != nil {
 			return err
 		}
 
-		c.ConnectionPool.Service = service
+		c.ConnectionPooler.Service = service
 	} else if err != nil {
-		return fmt.Errorf("could not get connection pool service to sync: %v", err)
+		return fmt.Errorf("could not get connection pooler service to sync: %v", err)
 	} else {
 		// Service updates are not supported and probably not that useful anyway
-		c.ConnectionPool.Service = service
+		c.ConnectionPooler.Service = service
 	}
 
 	return nil

pkg/cluster/sync_test.go

@@ -18,8 +18,8 @@ func int32ToPointer(value int32) *int32 {
 }
 
 func deploymentUpdated(cluster *Cluster, err error) error {
-	if cluster.ConnectionPool.Deployment.Spec.Replicas == nil ||
-		*cluster.ConnectionPool.Deployment.Spec.Replicas != 2 {
+	if cluster.ConnectionPooler.Deployment.Spec.Replicas == nil ||
+		*cluster.ConnectionPooler.Deployment.Spec.Replicas != 2 {
 		return fmt.Errorf("Wrong nubmer of instances")
 	}
 
@@ -27,15 +27,15 @@ func deploymentUpdated(cluster *Cluster, err error) error {
 }
 
 func objectsAreSaved(cluster *Cluster, err error) error {
-	if cluster.ConnectionPool == nil {
-		return fmt.Errorf("Connection pool resources are empty")
+	if cluster.ConnectionPooler == nil {
+		return fmt.Errorf("Connection pooler resources are empty")
 	}
 
-	if cluster.ConnectionPool.Deployment == nil {
+	if cluster.ConnectionPooler.Deployment == nil {
 		return fmt.Errorf("Deployment was not saved")
 	}
 
-	if cluster.ConnectionPool.Service == nil {
+	if cluster.ConnectionPooler.Service == nil {
 		return fmt.Errorf("Service was not saved")
 	}
 
@@ -43,15 +43,15 @@ func objectsAreSaved(cluster *Cluster, err error) error {
 }
 
 func objectsAreDeleted(cluster *Cluster, err error) error {
-	if cluster.ConnectionPool != nil {
-		return fmt.Errorf("Connection pool was not deleted")
+	if cluster.ConnectionPooler != nil {
+		return fmt.Errorf("Connection pooler was not deleted")
 	}
 
 	return nil
 }
 
-func TestConnPoolSynchronization(t *testing.T) {
-	testName := "Test connection pool synchronization"
+func TestConnectionPoolerSynchronization(t *testing.T) {
+	testName := "Test connection pooler synchronization"
 	var cluster = New(
 		Config{
 			OpConfig: config.Config{
@@ -60,12 +60,12 @@ func TestConnPoolSynchronization(t *testing.T) {
 					SuperUsername:       superUserName,
 					ReplicationUsername: replicationUserName,
 				},
-				ConnectionPool: config.ConnectionPool{
-					ConnPoolDefaultCPURequest:    "100m",
-					ConnPoolDefaultCPULimit:      "100m",
-					ConnPoolDefaultMemoryRequest: "100Mi",
-					ConnPoolDefaultMemoryLimit:   "100Mi",
-					NumberOfInstances:            int32ToPointer(1),
+				ConnectionPooler: config.ConnectionPooler{
+					ConnectionPoolerDefaultCPURequest:    "100m",
+					ConnectionPoolerDefaultCPULimit:      "100m",
+					ConnectionPoolerDefaultMemoryRequest: "100Mi",
+					ConnectionPoolerDefaultMemoryLimit:   "100Mi",
+					NumberOfInstances:                    int32ToPointer(1),
 				},
 			},
 		}, k8sutil.KubernetesClient{}, acidv1.Postgresql{}, logger)
@@ -84,15 +84,15 @@ func TestConnPoolSynchronization(t *testing.T) {
 
 	clusterDirtyMock := *cluster
 	clusterDirtyMock.KubeClient = k8sutil.NewMockKubernetesClient()
-	clusterDirtyMock.ConnectionPool = &ConnectionPoolObjects{
+	clusterDirtyMock.ConnectionPooler = &ConnectionPoolerObjects{
 		Deployment: &appsv1.Deployment{},
 		Service:    &v1.Service{},
 	}
 
 	clusterNewDefaultsMock := *cluster
 	clusterNewDefaultsMock.KubeClient = k8sutil.NewMockKubernetesClient()
-	cluster.OpConfig.ConnectionPool.Image = "pooler:2.0"
-	cluster.OpConfig.ConnectionPool.NumberOfInstances = int32ToPointer(2)
+	cluster.OpConfig.ConnectionPooler.Image = "pooler:2.0"
+	cluster.OpConfig.ConnectionPooler.NumberOfInstances = int32ToPointer(2)
 
 	tests := []struct {
 		subTest string
@@ -105,12 +105,12 @@ func TestConnPoolSynchronization(t *testing.T) {
 			subTest: "create if doesn't exist",
 			oldSpec: &acidv1.Postgresql{
 				Spec: acidv1.PostgresSpec{
-					ConnectionPool: &acidv1.ConnectionPool{},
+					ConnectionPooler: &acidv1.ConnectionPooler{},
 				},
 			},
 			newSpec: &acidv1.Postgresql{
 				Spec: acidv1.PostgresSpec{
-					ConnectionPool: &acidv1.ConnectionPool{},
+					ConnectionPooler: &acidv1.ConnectionPooler{},
 				},
 			},
 			cluster: &clusterMissingObjects,
@@ -123,7 +123,7 @@ func TestConnPoolSynchronization(t *testing.T) {
 			},
 			newSpec: &acidv1.Postgresql{
 				Spec: acidv1.PostgresSpec{
-					EnableConnectionPool: boolToPointer(true),
+					EnableConnectionPooler: boolToPointer(true),
 				},
 			},
 			cluster: &clusterMissingObjects,
@@ -136,7 +136,7 @@ func TestConnPoolSynchronization(t *testing.T) {
 			},
 			newSpec: &acidv1.Postgresql{
 				Spec: acidv1.PostgresSpec{
-					ConnectionPool: &acidv1.ConnectionPool{},
+					ConnectionPooler: &acidv1.ConnectionPooler{},
 				},
 			},
 			cluster: &clusterMissingObjects,
@@ -146,7 +146,7 @@ func TestConnPoolSynchronization(t *testing.T) {
 			subTest: "delete if not needed",
 			oldSpec: &acidv1.Postgresql{
 				Spec: acidv1.PostgresSpec{
-					ConnectionPool: &acidv1.ConnectionPool{},
+					ConnectionPooler: &acidv1.ConnectionPooler{},
 				},
 			},
 			newSpec: &acidv1.Postgresql{
@@ -170,14 +170,14 @@ func TestConnPoolSynchronization(t *testing.T) {
 			subTest: "update deployment",
 			oldSpec: &acidv1.Postgresql{
 				Spec: acidv1.PostgresSpec{
-					ConnectionPool: &acidv1.ConnectionPool{
+					ConnectionPooler: &acidv1.ConnectionPooler{
 						NumberOfInstances: int32ToPointer(1),
 					},
 				},
 			},
 			newSpec: &acidv1.Postgresql{
 				Spec: acidv1.PostgresSpec{
-					ConnectionPool: &acidv1.ConnectionPool{
+					ConnectionPooler: &acidv1.ConnectionPooler{
 						NumberOfInstances: int32ToPointer(2),
 					},
 				},
@@ -189,12 +189,12 @@ func TestConnPoolSynchronization(t *testing.T) {
 			subTest: "update image from changed defaults",
 			oldSpec: &acidv1.Postgresql{
 				Spec: acidv1.PostgresSpec{
-					ConnectionPool: &acidv1.ConnectionPool{},
+					ConnectionPooler: &acidv1.ConnectionPooler{},
 				},
 			},
 			newSpec: &acidv1.Postgresql{
 				Spec: acidv1.PostgresSpec{
-					ConnectionPool: &acidv1.ConnectionPool{},
+					ConnectionPooler: &acidv1.ConnectionPooler{},
 				},
 			},
 			cluster: &clusterNewDefaultsMock,
@@ -202,7 +202,7 @@ func TestConnPoolSynchronization(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		err := tt.cluster.syncConnectionPool(tt.oldSpec, tt.newSpec, mockInstallLookupFunction)
+		err := tt.cluster.syncConnectionPooler(tt.oldSpec, tt.newSpec, mockInstallLookupFunction)
 
 		if err := tt.check(tt.cluster, err); err != nil {
 			t.Errorf("%s [%s]: Could not synchronize, %+v",

pkg/cluster/util.go

@@ -2,6 +2,7 @@ package cluster
 
 import (
 	"bytes"
+	"context"
 	"encoding/gob"
 	"encoding/json"
 	"fmt"
@@ -47,7 +48,7 @@ func (g *SecretOauthTokenGetter) getOAuthToken() (string, error) {
 	// Temporary getting postgresql-operator secret from the NamespaceDefault
 	credentialsSecret, err := g.kubeClient.
 		Secrets(g.OAuthTokenSecretName.Namespace).
-		Get(g.OAuthTokenSecretName.Name, metav1.GetOptions{})
+		Get(context.TODO(), g.OAuthTokenSecretName.Name, metav1.GetOptions{})
 
 	if err != nil {
 		return "", fmt.Errorf("could not get credentials secret: %v", err)
@@ -278,7 +279,7 @@ func (c *Cluster) waitStatefulsetReady() error {
 			listOptions := metav1.ListOptions{
 				LabelSelector: c.labelsSet(false).String(),
 			}
-			ss, err := c.KubeClient.StatefulSets(c.Namespace).List(listOptions)
+			ss, err := c.KubeClient.StatefulSets(c.Namespace).List(context.TODO(), listOptions)
 			if err != nil {
 				return false, err
 			}
@@ -313,7 +314,7 @@ func (c *Cluster) _waitPodLabelsReady(anyReplica bool) error {
 	}
 	podsNumber = 1
 	if !anyReplica {
-		pods, err := c.KubeClient.Pods(namespace).List(listOptions)
+		pods, err := c.KubeClient.Pods(namespace).List(context.TODO(), listOptions)
 		if err != nil {
 			return err
 		}
@@ -327,7 +328,7 @@ func (c *Cluster) _waitPodLabelsReady(anyReplica bool) error {
 		func() (bool, error) {
 			masterCount := 0
 			if !anyReplica {
-				masterPods, err2 := c.KubeClient.Pods(namespace).List(masterListOption)
+				masterPods, err2 := c.KubeClient.Pods(namespace).List(context.TODO(), masterListOption)
 				if err2 != nil {
 					return false, err2
 				}
@@ -337,7 +338,7 @@ func (c *Cluster) _waitPodLabelsReady(anyReplica bool) error {
 				}
 				masterCount = len(masterPods.Items)
 			}
-			replicaPods, err2 := c.KubeClient.Pods(namespace).List(replicaListOption)
+			replicaPods, err2 := c.KubeClient.Pods(namespace).List(context.TODO(), replicaListOption)
 			if err2 != nil {
 				return false, err2
 			}
@@ -414,24 +415,24 @@ func (c *Cluster) labelsSelector() *metav1.LabelSelector {
 	}
 }
 
-// Return connection pool labels selector, which should from one point of view
+// Return connection pooler labels selector, which should from one point of view
 // inherit most of the labels from the cluster itself, but at the same time
 // have e.g. different `application` label, so that recreatePod operation will
 // not interfere with it (it lists all the pods via labels, and if there would
 // be no difference, it will recreate also pooler pods).
-func (c *Cluster) connPoolLabelsSelector() *metav1.LabelSelector {
-	connPoolLabels := labels.Set(map[string]string{})
+func (c *Cluster) connectionPoolerLabelsSelector() *metav1.LabelSelector {
+	connectionPoolerLabels := labels.Set(map[string]string{})
 
 	extraLabels := labels.Set(map[string]string{
-		"connection-pool": c.connPoolName(),
-		"application":     "db-connection-pool",
+		"connection-pooler": c.connectionPoolerName(),
+		"application":       "db-connection-pooler",
 	})
 
-	connPoolLabels = labels.Merge(connPoolLabels, c.labelsSet(false))
-	connPoolLabels = labels.Merge(connPoolLabels, extraLabels)
+	connectionPoolerLabels = labels.Merge(connectionPoolerLabels, c.labelsSet(false))
+	connectionPoolerLabels = labels.Merge(connectionPoolerLabels, extraLabels)
 
 	return &metav1.LabelSelector{
-		MatchLabels:      connPoolLabels,
+		MatchLabels:      connectionPoolerLabels,
 		MatchExpressions: nil,
 	}
 }
@@ -509,14 +510,23 @@ func (c *Cluster) patroniUsesKubernetes() bool {
 	return c.OpConfig.EtcdHost == ""
 }
 
-func (c *Cluster) needConnectionPoolWorker(spec *acidv1.PostgresSpec) bool {
-	if spec.EnableConnectionPool == nil {
-		return spec.ConnectionPool != nil
+func (c *Cluster) patroniKubernetesUseConfigMaps() bool {
+	if !c.patroniUsesKubernetes() {
+		return false
+	}
+
+	// otherwise, follow the operator configuration
+	return c.OpConfig.KubernetesUseConfigMaps
+}
+
+func (c *Cluster) needConnectionPoolerWorker(spec *acidv1.PostgresSpec) bool {
+	if spec.EnableConnectionPooler == nil {
+		return spec.ConnectionPooler != nil
 	} else {
-		return *spec.EnableConnectionPool
+		return *spec.EnableConnectionPooler
 	}
 }
 
-func (c *Cluster) needConnectionPool() bool {
-	return c.needConnectionPoolWorker(&c.Spec)
+func (c *Cluster) needConnectionPooler() bool {
+	return c.needConnectionPoolerWorker(&c.Spec)
 }

pkg/cluster/volumes.go

@@ -1,11 +1,12 @@
 package cluster
 
 import (
+	"context"
 	"fmt"
 	"strconv"
 	"strings"
 
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
@@ -23,7 +24,7 @@ func (c *Cluster) listPersistentVolumeClaims() ([]v1.PersistentVolumeClaim, erro
 		LabelSelector: c.labelsSet(false).String(),
 	}
 
-	pvcs, err := c.KubeClient.PersistentVolumeClaims(ns).List(listOptions)
+	pvcs, err := c.KubeClient.PersistentVolumeClaims(ns).List(context.TODO(), listOptions)
 	if err != nil {
 		return nil, fmt.Errorf("could not list of PersistentVolumeClaims: %v", err)
 	}
@@ -38,7 +39,7 @@ func (c *Cluster) deletePersistentVolumeClaims() error {
 	}
 	for _, pvc := range pvcs {
 		c.logger.Debugf("deleting PVC %q", util.NameFromMeta(pvc.ObjectMeta))
-		if err := c.KubeClient.PersistentVolumeClaims(pvc.Namespace).Delete(pvc.Name, c.deleteOptions); err != nil {
+		if err := c.KubeClient.PersistentVolumeClaims(pvc.Namespace).Delete(context.TODO(), pvc.Name, c.deleteOptions); err != nil {
 			c.logger.Warningf("could not delete PersistentVolumeClaim: %v", err)
 		}
 	}
@@ -78,7 +79,7 @@ func (c *Cluster) listPersistentVolumes() ([]*v1.PersistentVolume, error) {
 				continue
 			}
 		}
-		pv, err := c.KubeClient.PersistentVolumes().Get(pvc.Spec.VolumeName, metav1.GetOptions{})
+		pv, err := c.KubeClient.PersistentVolumes().Get(context.TODO(), pvc.Spec.VolumeName, metav1.GetOptions{})
 		if err != nil {
 			return nil, fmt.Errorf("could not get PersistentVolume: %v", err)
 		}
@@ -143,7 +144,7 @@ func (c *Cluster) resizeVolumes(newVolume acidv1.Volume, resizers []volumes.Volu
 			c.logger.Debugf("filesystem resize successful on volume %q", pv.Name)
 			pv.Spec.Capacity[v1.ResourceStorage] = newQuantity
 			c.logger.Debugf("updating persistent volume definition for volume %q", pv.Name)
-			if _, err := c.KubeClient.PersistentVolumes().Update(pv); err != nil {
+			if _, err := c.KubeClient.PersistentVolumes().Update(context.TODO(), pv, metav1.UpdateOptions{}); err != nil {
 				return fmt.Errorf("could not update persistent volume: %q", err)
 			}
 			c.logger.Debugf("successfully updated persistent volume %q", pv.Name)