Use code-generation for CRD API and deepcopy methods (#369)

Client-go provides a https://github.com/kubernetes/code-generator package in order to provide the API to work with CRDs similar to the one available for built-in types, i.e. Pods, Statefulsets and so on.

Use this package to generate deepcopy methods (required for CRDs), instead of using an external deepcopy package; we also generate APIs used to manipulate both Postgres and OperatorConfiguration CRDs, as well as informers and listers for the Postgres CRD, instead of using generic informers and CRD REST API; by using generated code we can get rid of some custom and obscure CRD-related code and use a better API.

All generated code resides in /pkg/generated, with an exception of zz_deepcopy.go in apis/acid.zalan.do/v1

Rename postgres-operator-configuration CRD to OperatorConfiguration, since the former broke naming convention in the code-generator.

Moved Postgresql, PostgresqlList, OperatorConfiguration and OperatorConfigurationList and other types used by them into

Change the type of  the Error field in the Postgresql crd to a string, so that client-go could generate a deepcopy for it.

Use generated code to set status of CRD objects as well. Right now this is done with patch, however, Kubernetes 1.11 introduces the /status subresources, allowing us to set the status with
the special updateStatus call in the future. For now, we keep the code that is compatible with earlier versions of Kubernetes.

Rename postgresql.go to database.go and status.go to logs_and_api.go to reflect the purpose of each of those files.

Update client-go dependencies.

Minor reformatting and renaming.

pkg/apis/acid.zalan.do/register.go

@@ -0,0 +1,6 @@
+package acidzalando
+
+const (
+	// GroupName is the group name for the operator CRDs
+	GroupName = "acid.zalan.do"
+)

pkg/apis/acid.zalan.do/v1/const.go

@@ -0,0 +1,16 @@
+package v1
+
+const (
+	serviceNameMaxLength   = 63
+	clusterNameMaxLength   = serviceNameMaxLength - len("-repl")
+	serviceNameRegexString = `^[a-z]([-a-z0-9]*[a-z0-9])?$`
+
+	ClusterStatusUnknown      PostgresStatus = ""
+	ClusterStatusCreating     PostgresStatus = "Creating"
+	ClusterStatusUpdating     PostgresStatus = "Updating"
+	ClusterStatusUpdateFailed PostgresStatus = "UpdateFailed"
+	ClusterStatusSyncFailed   PostgresStatus = "SyncFailed"
+	ClusterStatusAddFailed    PostgresStatus = "CreateFailed"
+	ClusterStatusRunning      PostgresStatus = "Running"
+	ClusterStatusInvalid      PostgresStatus = "Invalid"
+)

pkg/apis/acid.zalan.do/v1/doc.go

@@ -0,0 +1,6 @@
+// +k8s:deepcopy-gen=package,register
+
+// Package v1 is the v1 version of the API.
+// +groupName=acid.zalan.do
+
+package v1

pkg/apis/acid.zalan.do/v1/marshal.go

@@ -0,0 +1,130 @@
+package v1
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+)
+
+type postgresqlCopy Postgresql
+
+// MarshalJSON converts a maintenance window definition to JSON.
+func (m *MaintenanceWindow) MarshalJSON() ([]byte, error) {
+	if m.Everyday {
+		return []byte(fmt.Sprintf("\"%s-%s\"",
+			m.StartTime.Format("15:04"),
+			m.EndTime.Format("15:04"))), nil
+	}
+
+	return []byte(fmt.Sprintf("\"%s:%s-%s\"",
+		m.Weekday.String()[:3],
+		m.StartTime.Format("15:04"),
+		m.EndTime.Format("15:04"))), nil
+}
+
+// UnmarshalJSON converts a JSON to the maintenance window definition.
+func (m *MaintenanceWindow) UnmarshalJSON(data []byte) error {
+	var (
+		got MaintenanceWindow
+		err error
+	)
+
+	parts := strings.Split(string(data[1:len(data)-1]), "-")
+	if len(parts) != 2 {
+		return fmt.Errorf("incorrect maintenance window format")
+	}
+
+	fromParts := strings.Split(parts[0], ":")
+	switch len(fromParts) {
+	case 3:
+		got.Everyday = false
+		got.Weekday, err = parseWeekday(fromParts[0])
+		if err != nil {
+			return fmt.Errorf("could not parse weekday: %v", err)
+		}
+
+		got.StartTime, err = parseTime(fromParts[1] + ":" + fromParts[2])
+	case 2:
+		got.Everyday = true
+		got.StartTime, err = parseTime(fromParts[0] + ":" + fromParts[1])
+	default:
+		return fmt.Errorf("incorrect maintenance window format")
+	}
+	if err != nil {
+		return fmt.Errorf("could not parse start time: %v", err)
+	}
+
+	got.EndTime, err = parseTime(parts[1])
+	if err != nil {
+		return fmt.Errorf("could not parse end time: %v", err)
+	}
+
+	if got.EndTime.Before(&got.StartTime) {
+		return fmt.Errorf("'From' time must be prior to the 'To' time")
+	}
+
+	*m = got
+
+	return nil
+}
+
+// UnmarshalJSON converts a JSON into the PostgreSQL object.
+func (p *Postgresql) UnmarshalJSON(data []byte) error {
+	var tmp postgresqlCopy
+
+	err := json.Unmarshal(data, &tmp)
+	if err != nil {
+		metaErr := json.Unmarshal(data, &tmp.ObjectMeta)
+		if metaErr != nil {
+			return err
+		}
+
+		tmp.Error = err.Error()
+		tmp.Status = ClusterStatusInvalid
+
+		*p = Postgresql(tmp)
+
+		return nil
+	}
+	tmp2 := Postgresql(tmp)
+
+	if clusterName, err := extractClusterName(tmp2.ObjectMeta.Name, tmp2.Spec.TeamID); err != nil {
+		tmp2.Error = err.Error()
+		tmp2.Status = ClusterStatusInvalid
+	} else if err := validateCloneClusterDescription(&tmp2.Spec.Clone); err != nil {
+		tmp2.Error = err.Error()
+		tmp2.Status = ClusterStatusInvalid
+	} else {
+		tmp2.Spec.ClusterName = clusterName
+	}
+
+	*p = tmp2
+
+	return nil
+}
+
+func (d *Duration) UnmarshalJSON(b []byte) error {
+	var (
+		v   interface{}
+		err error
+	)
+	if err = json.Unmarshal(b, &v); err != nil {
+		return err
+	}
+	switch val := v.(type) {
+	case string:
+		t, err := time.ParseDuration(val)
+		if err != nil {
+			return err
+		}
+		*d = Duration(t)
+		return nil
+	case float64:
+		t := time.Duration(val)
+		*d = Duration(t)
+		return nil
+	default:
+		return fmt.Errorf("could not recognize type %T as a valid type to unmarshal to Duration", val)
+	}
+}

pkg/apis/acid.zalan.do/v1/operator_configuration_type.go

@@ -0,0 +1,148 @@
+package v1
+
+import (
+	"github.com/zalando-incubator/postgres-operator/pkg/util/config"
+
+	"github.com/zalando-incubator/postgres-operator/pkg/spec"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"time"
+)
+
+// +genclient
+// +genclient:onlyVerbs=get
+// +genclient:noStatus
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+type OperatorConfiguration struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata"`
+
+	Configuration OperatorConfigurationData `json:"configuration"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+type OperatorConfigurationList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata"`
+
+	Items []OperatorConfiguration `json:"items"`
+}
+
+type PostgresUsersConfiguration struct {
+	SuperUsername       string `json:"super_username,omitempty"`
+	ReplicationUsername string `json:"replication_username,omitempty"`
+}
+
+type KubernetesMetaConfiguration struct {
+	PodServiceAccountName string `json:"pod_service_account_name,omitempty"`
+	// TODO: change it to the proper json
+	PodServiceAccountDefinition            string                `json:"pod_service_account_definition,omitempty"`
+	PodServiceAccountRoleBindingDefinition string                `json:"pod_service_account_role_binding_definition,omitempty"`
+	PodTerminateGracePeriod                Duration              `json:"pod_terminate_grace_period,omitempty"`
+	WatchedNamespace                       string                `json:"watched_namespace,omitempty"`
+	PDBNameFormat                          config.StringTemplate `json:"pdb_name_format,omitempty"`
+	SecretNameTemplate                     config.StringTemplate `json:"secret_name_template,omitempty"`
+	OAuthTokenSecretName                   spec.NamespacedName   `json:"oauth_token_secret_name,omitempty"`
+	InfrastructureRolesSecretName          spec.NamespacedName   `json:"infrastructure_roles_secret_name,omitempty"`
+	PodRoleLabel                           string                `json:"pod_role_label,omitempty"`
+	ClusterLabels                          map[string]string     `json:"cluster_labels,omitempty"`
+	ClusterNameLabel                       string                `json:"cluster_name_label,omitempty"`
+	NodeReadinessLabel                     map[string]string     `json:"node_readiness_label,omitempty"`
+	// TODO: use a proper toleration structure?
+	PodToleration map[string]string `json:"toleration,omitempty"`
+	// TODO: use namespacedname
+	PodEnvironmentConfigMap string `json:"pod_environment_configmap,omitempty"`
+	PodPriorityClassName    string `json:"pod_priority_class_name,omitempty"`
+}
+
+type PostgresPodResourcesDefaults struct {
+	DefaultCPURequest    string `json:"default_cpu_request,omitempty"`
+	DefaultMemoryRequest string `json:"default_memory_request,omitempty"`
+	DefaultCPULimit      string `json:"default_cpu_limit,omitempty"`
+	DefaultMemoryLimit   string `json:"default_memory_limit,omitempty"`
+}
+
+type OperatorTimeouts struct {
+	ResourceCheckInterval  Duration `json:"resource_check_interval,omitempty"`
+	ResourceCheckTimeout   Duration `json:"resource_check_timeout,omitempty"`
+	PodLabelWaitTimeout    Duration `json:"pod_label_wait_timeout,omitempty"`
+	PodDeletionWaitTimeout Duration `json:"pod_deletion_wait_timeout,omitempty"`
+	ReadyWaitInterval      Duration `json:"ready_wait_interval,omitempty"`
+	ReadyWaitTimeout       Duration `json:"ready_wait_timeout,omitempty"`
+}
+
+type LoadBalancerConfiguration struct {
+	DbHostedZone              string                `json:"db_hosted_zone,omitempty"`
+	EnableMasterLoadBalancer  bool                  `json:"enable_master_load_balancer,omitempty"`
+	EnableReplicaLoadBalancer bool                  `json:"enable_replica_load_balancer,omitempty"`
+	MasterDNSNameFormat       config.StringTemplate `json:"master_dns_name_format,omitempty"`
+	ReplicaDNSNameFormat      config.StringTemplate `json:"replica_dns_name_format,omitempty"`
+}
+
+type AWSGCPConfiguration struct {
+	WALES3Bucket string `json:"wal_s3_bucket,omitempty"`
+	AWSRegion    string `json:"aws_region,omitempty"`
+	LogS3Bucket  string `json:"log_s3_bucket,omitempty"`
+	KubeIAMRole  string `json:"kube_iam_role,omitempty"`
+}
+
+type OperatorDebugConfiguration struct {
+	DebugLogging   bool `json:"debug_logging,omitempty"`
+	EnableDBAccess bool `json:"enable_database_access,omitempty"`
+}
+
+type TeamsAPIConfiguration struct {
+	EnableTeamsAPI           bool              `json:"enable_teams_api,omitempty"`
+	TeamsAPIUrl              string            `json:"teams_api_url,omitempty"`
+	TeamAPIRoleConfiguration map[string]string `json:"team_api_role_configuration,omitempty"`
+	EnableTeamSuperuser      bool              `json:"enable_team_superuser,omitempty"`
+	TeamAdminRole            string            `json:"team_admin_role,omitempty"`
+	PamRoleName              string            `json:"pam_role_name,omitempty"`
+	PamConfiguration         string            `json:"pam_configuration,omitempty"`
+	ProtectedRoles           []string          `json:"protected_role_names,omitempty"`
+}
+
+type LoggingRESTAPIConfiguration struct {
+	APIPort               int `json:"api_port,omitempty"`
+	RingLogLines          int `json:"ring_log_lines,omitempty"`
+	ClusterHistoryEntries int `json:"cluster_history_entries,omitempty"`
+}
+
+type ScalyrConfiguration struct {
+	ScalyrAPIKey        string `json:"scalyr_api_key,omitempty"`
+	ScalyrImage         string `json:"scalyr_image,omitempty"`
+	ScalyrServerURL     string `json:"scalyr_server_url,omitempty"`
+	ScalyrCPURequest    string `json:"scalyr_cpu_request,omitempty"`
+	ScalyrMemoryRequest string `json:"scalyr_memory_request,omitempty"`
+	ScalyrCPULimit      string `json:"scalyr_cpu_limit,omitempty"`
+	ScalyrMemoryLimit   string `json:"scalyr_memory_limit,omitempty"`
+}
+
+type OperatorConfigurationData struct {
+	EtcdHost                   string                       `json:"etcd_host,omitempty"`
+	DockerImage                string                       `json:"docker_image,omitempty"`
+	Workers                    uint32                       `json:"workers,omitempty"`
+	MinInstances               int32                        `json:"min_instances,omitempty"`
+	MaxInstances               int32                        `json:"max_instances,omitempty"`
+	ResyncPeriod               Duration                     `json:"resync_period,omitempty"`
+	RepairPeriod               Duration                     `json:"repair_period,omitempty"`
+	Sidecars                   map[string]string            `json:"sidecar_docker_images,omitempty"`
+	PostgresUsersConfiguration PostgresUsersConfiguration   `json:"users"`
+	Kubernetes                 KubernetesMetaConfiguration  `json:"kubernetes"`
+	PostgresPodResources       PostgresPodResourcesDefaults `json:"postgres_pod_resources"`
+	Timeouts                   OperatorTimeouts             `json:"timeouts"`
+	LoadBalancer               LoadBalancerConfiguration    `json:"load_balancer"`
+	AWSGCP                     AWSGCPConfiguration          `json:"aws_or_gcp"`
+	OperatorDebug              OperatorDebugConfiguration   `json:"debug"`
+	TeamsAPI                   TeamsAPIConfiguration        `json:"teams_api"`
+	LoggingRESTAPI             LoggingRESTAPIConfiguration  `json:"logging_rest_api"`
+	Scalyr                     ScalyrConfiguration          `json:"scalyr"`
+}
+
+type OperatorConfigurationUsers struct {
+	SuperUserName            string            `json:"superuser_name,omitempty"`
+	Replication              string            `json:"replication_user_name,omitempty"`
+	ProtectedRoles           []string          `json:"protected_roles,omitempty"`
+	TeamAPIRoleConfiguration map[string]string `json:"team_api_role_configuration,omitempty"`
+}
+
+type Duration time.Duration

pkg/apis/acid.zalan.do/v1/postgresql_type.go

@@ -0,0 +1,127 @@
+package v1
+
+import (
+	"time"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// +genclient
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+//Postgresql defines PostgreSQL Custom Resource Definition Object.
+type Postgresql struct {
+	metav1.TypeMeta   `json:",inline"`
+	metav1.ObjectMeta `json:"metadata,omitempty"`
+
+	Spec   PostgresSpec   `json:"spec"`
+	Status PostgresStatus `json:"status,omitempty"`
+	Error  string         `json:"-"`
+}
+
+// PostgresSpec defines the specification for the PostgreSQL TPR.
+type PostgresSpec struct {
+	PostgresqlParam `json:"postgresql"`
+	Volume          `json:"volume,omitempty"`
+	Patroni         `json:"patroni,omitempty"`
+	Resources       `json:"resources,omitempty"`
+
+	TeamID      string `json:"teamId"`
+	DockerImage string `json:"dockerImage,omitempty"`
+
+	// vars that enable load balancers are pointers because it is important to know if any of them is omitted from the Postgres manifest
+	// in that case the var evaluates to nil and the value is taken from the operator config
+	EnableMasterLoadBalancer  *bool `json:"enableMasterLoadBalancer,omitempty"`
+	EnableReplicaLoadBalancer *bool `json:"enableReplicaLoadBalancer,omitempty"`
+
+	// deprecated load balancer settings maintained for backward compatibility
+	// see "Load balancers" operator docs
+	UseLoadBalancer     *bool `json:"useLoadBalancer,omitempty"`
+	ReplicaLoadBalancer *bool `json:"replicaLoadBalancer,omitempty"`
+
+	// load balancers' source ranges are the same for master and replica services
+	AllowedSourceRanges []string `json:"allowedSourceRanges"`
+
+	NumberOfInstances    int32                `json:"numberOfInstances"`
+	Users                map[string]UserFlags `json:"users"`
+	MaintenanceWindows   []MaintenanceWindow  `json:"maintenanceWindows,omitempty"`
+	Clone                CloneDescription     `json:"clone"`
+	ClusterName          string               `json:"-"`
+	Databases            map[string]string    `json:"databases,omitempty"`
+	Tolerations          []v1.Toleration      `json:"tolerations,omitempty"`
+	Sidecars             []Sidecar            `json:"sidecars,omitempty"`
+	PodPriorityClassName string               `json:"pod_priority_class_name,omitempty"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+// PostgresqlList defines a list of PostgreSQL clusters.
+type PostgresqlList struct {
+	metav1.TypeMeta `json:",inline"`
+	metav1.ListMeta `json:"metadata"`
+
+	Items []Postgresql `json:"items"`
+}
+
+// MaintenanceWindow describes the time window when the operator is allowed to do maintenance on a cluster.
+type MaintenanceWindow struct {
+	Everyday  bool
+	Weekday   time.Weekday
+	StartTime metav1.Time // Start time
+	EndTime   metav1.Time // End time
+}
+
+// Volume describes a single volume in the manifest.
+type Volume struct {
+	Size         string `json:"size"`
+	StorageClass string `json:"storageClass"`
+}
+
+// PostgresqlParam describes PostgreSQL version and pairs of configuration parameter name - values.
+type PostgresqlParam struct {
+	PgVersion  string            `json:"version"`
+	Parameters map[string]string `json:"parameters"`
+}
+
+// ResourceDescription describes CPU and memory resources defined for a cluster.
+type ResourceDescription struct {
+	CPU    string `json:"cpu"`
+	Memory string `json:"memory"`
+}
+
+// Resources describes requests and limits for the cluster resouces.
+type Resources struct {
+	ResourceRequest ResourceDescription `json:"requests,omitempty"`
+	ResourceLimits  ResourceDescription `json:"limits,omitempty"`
+}
+
+// Patroni contains Patroni-specific configuration
+type Patroni struct {
+	InitDB               map[string]string `json:"initdb"`
+	PgHba                []string          `json:"pg_hba"`
+	TTL                  uint32            `json:"ttl"`
+	LoopWait             uint32            `json:"loop_wait"`
+	RetryTimeout         uint32            `json:"retry_timeout"`
+	MaximumLagOnFailover float32           `json:"maximum_lag_on_failover"` // float32 because https://github.com/kubernetes/kubernetes/issues/30213
+}
+
+// CloneDescription describes which cluster the new should clone and up to which point in time
+type CloneDescription struct {
+	ClusterName  string `json:"cluster,omitempty"`
+	UID          string `json:"uid,omitempty"`
+	EndTimestamp string `json:"timestamp,omitempty"`
+}
+
+// Sidecar defines a container to be run in the same pod as the Postgres container.
+type Sidecar struct {
+	Resources   `json:"resources,omitempty"`
+	Name        string             `json:"name,omitempty"`
+	DockerImage string             `json:"image,omitempty"`
+	Ports       []v1.ContainerPort `json:"ports,omitempty"`
+	Env         []v1.EnvVar        `json:"env,omitempty"`
+}
+
+// UserFlags defines flags (such as superuser, nologin) that could be assigned to individual users
+type UserFlags []string
+
+// PostgresStatus contains status of the PostgreSQL cluster (running, creation failed etc.)
+type PostgresStatus string

pkg/apis/acid.zalan.do/v1/register.go

@@ -0,0 +1,58 @@
+package v1
+
+import (
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+
+	"github.com/zalando-incubator/postgres-operator/pkg/apis/acid.zalan.do"
+)
+
+const (
+	PostgresCRDResourceKind   = "postgresql"
+	PostgresCRDResourcePlural = "postgresqls"
+	PostgresCRDResouceName    = PostgresCRDResourcePlural + "." + acidzalando.GroupName
+	PostgresCRDResourceShort  = "pg"
+
+	OperatorConfigCRDResouceKind    = "OperatorConfiguration"
+	OperatorConfigCRDResourcePlural = "operatorconfigurations"
+	OperatorConfigCRDResourceName   = OperatorConfigCRDResourcePlural + "." + acidzalando.GroupName
+	OperatorConfigCRDResourceShort  = "opconfig"
+
+	APIVersion = "v1"
+)
+
+var (
+	// localSchemeBuilder and AddToScheme will stay in k8s.io/kubernetes.
+	SchemeBuilder      runtime.SchemeBuilder
+	localSchemeBuilder = &SchemeBuilder
+	AddToScheme        = localSchemeBuilder.AddToScheme
+	SchemeGroupVersion = schema.GroupVersion{Group: acidzalando.GroupName, Version: APIVersion}
+)
+
+func init() {
+	// We only register manually written functions here. The registration of the
+	// generated functions takes place in the generated files. The separation
+	// makes the code compile even when the generated files are missing.
+	localSchemeBuilder.Register(addKnownTypes)
+}
+
+// Resource takes an unqualified resource and returns a Group qualified GroupResource
+func Resource(resource string) schema.GroupResource {
+	return SchemeGroupVersion.WithResource(resource).GroupResource()
+}
+
+// Adds the list of known types to api.Scheme.
+func addKnownTypes(scheme *runtime.Scheme) error {
+	// AddKnownType assumes derives the type kind from the type name, which is always uppercase.
+	// For our CRDs we use lowercase names historically, therefore we have to supply the name separately.
+	// TODO: User uppercase CRDResourceKind of our types in the next major API version
+	scheme.AddKnownTypeWithName(SchemeGroupVersion.WithKind("postgresql"), &Postgresql{})
+	scheme.AddKnownTypeWithName(SchemeGroupVersion.WithKind("postgresqlList"), &PostgresqlList{})
+	scheme.AddKnownTypeWithName(SchemeGroupVersion.WithKind("OperatorConfiguration"),
+		&OperatorConfiguration{})
+	scheme.AddKnownTypeWithName(SchemeGroupVersion.WithKind("OperatorConfigurationList"),
+		&OperatorConfigurationList{})
+	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
+	return nil
+}

pkg/apis/acid.zalan.do/v1/util.go

@@ -0,0 +1,93 @@
+package v1
+
+import (
+	"fmt"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"regexp"
+	"strings"
+	"time"
+)
+
+var (
+	weekdays         = map[string]int{"Sun": 0, "Mon": 1, "Tue": 2, "Wed": 3, "Thu": 4, "Fri": 5, "Sat": 6}
+	serviceNameRegex = regexp.MustCompile(serviceNameRegexString)
+)
+
+func (p *Postgresql) Clone() *Postgresql {
+	if p == nil {
+		return nil
+	}
+	return p.DeepCopy()
+}
+
+func parseTime(s string) (metav1.Time, error) {
+	parts := strings.Split(s, ":")
+	if len(parts) != 2 {
+		return metav1.Time{}, fmt.Errorf("incorrect time format")
+	}
+	timeLayout := "15:04"
+
+	tp, err := time.Parse(timeLayout, s)
+	if err != nil {
+		return metav1.Time{}, err
+	}
+
+	return metav1.Time{Time: tp.UTC()}, nil
+}
+
+func parseWeekday(s string) (time.Weekday, error) {
+	weekday, ok := weekdays[s]
+	if !ok {
+		return time.Weekday(0), fmt.Errorf("incorrect weekday")
+	}
+
+	return time.Weekday(weekday), nil
+}
+
+func extractClusterName(clusterName string, teamName string) (string, error) {
+	teamNameLen := len(teamName)
+	if len(clusterName) < teamNameLen+2 {
+		return "", fmt.Errorf("name is too short")
+	}
+
+	if teamNameLen == 0 {
+		return "", fmt.Errorf("team name is empty")
+	}
+
+	if strings.ToLower(clusterName[:teamNameLen+1]) != strings.ToLower(teamName)+"-" {
+		return "", fmt.Errorf("name must match {TEAM}-{NAME} format")
+	}
+	if len(clusterName) > clusterNameMaxLength {
+		return "", fmt.Errorf("name cannot be longer than %d characters", clusterNameMaxLength)
+	}
+	if !serviceNameRegex.MatchString(clusterName) {
+		return "", fmt.Errorf("name must confirm to DNS-1035, regex used for validation is %q",
+			serviceNameRegexString)
+	}
+
+	return clusterName[teamNameLen+1:], nil
+}
+
+func validateCloneClusterDescription(clone *CloneDescription) error {
+	// when cloning from the basebackup (no end timestamp) check that the cluster name is a valid service name
+	if clone.ClusterName != "" && clone.EndTimestamp == "" {
+		if !serviceNameRegex.MatchString(clone.ClusterName) {
+			return fmt.Errorf("clone cluster name must confirm to DNS-1035, regex used for validation is %q",
+				serviceNameRegexString)
+		}
+		if len(clone.ClusterName) > serviceNameMaxLength {
+			return fmt.Errorf("clone cluster name must be no longer than %d characters", serviceNameMaxLength)
+		}
+	}
+	return nil
+}
+
+func (status PostgresStatus) Success() bool {
+	return status != ClusterStatusAddFailed &&
+		status != ClusterStatusUpdateFailed &&
+		status != ClusterStatusSyncFailed
+}
+
+func (status PostgresStatus) String() string {
+	return string(status)
+}

pkg/apis/acid.zalan.do/v1/util_test.go

@@ -0,0 +1,540 @@
+package v1
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"reflect"
+	"testing"
+	"time"
+)
+
+var parseTimeTests = []struct {
+	in  string
+	out metav1.Time
+	err error
+}{
+	{"16:08", mustParseTime("16:08"), nil},
+	{"11:00", mustParseTime("11:00"), nil},
+	{"23:59", mustParseTime("23:59"), nil},
+
+	{"26:09", metav1.Now(), errors.New(`parsing time "26:09": hour out of range`)},
+	{"23:69", metav1.Now(), errors.New(`parsing time "23:69": minute out of range`)},
+}
+
+var parseWeekdayTests = []struct {
+	in  string
+	out time.Weekday
+	err error
+}{
+	{"Wed", time.Wednesday, nil},
+	{"Sunday", time.Weekday(0), errors.New("incorrect weekday")},
+	{"", time.Weekday(0), errors.New("incorrect weekday")},
+}
+
+var clusterNames = []struct {
+	in          string
+	inTeam      string
+	clusterName string
+	err         error
+}{
+	{"acid-test", "acid", "test", nil},
+	{"test-my-name", "test", "my-name", nil},
+	{"my-team-another-test", "my-team", "another-test", nil},
+	{"------strange-team-cluster", "-----", "strange-team-cluster",
+		errors.New(`name must confirm to DNS-1035, regex used for validation is "^[a-z]([-a-z0-9]*[a-z0-9])?$"`)},
+	{"fooobar-fooobarfooobarfooobarfooobarfooobarfooobarfooobarfooobar", "fooobar", "",
+		errors.New("name cannot be longer than 58 characters")},
+	{"acid-test", "test", "", errors.New("name must match {TEAM}-{NAME} format")},
+	{"-test", "", "", errors.New("team name is empty")},
+	{"-test", "-", "", errors.New("name must match {TEAM}-{NAME} format")},
+	{"", "-", "", errors.New("name is too short")},
+	{"-", "-", "", errors.New("name is too short")},
+}
+
+var cloneClusterDescriptions = []struct {
+	in  *CloneDescription
+	err error
+}{
+	{&CloneDescription{"foo+bar", "", "NotEmpty"}, nil},
+	{&CloneDescription{"foo+bar", "", ""},
+		errors.New(`clone cluster name must confirm to DNS-1035, regex used for validation is "^[a-z]([-a-z0-9]*[a-z0-9])?$"`)},
+	{&CloneDescription{"foobar123456789012345678901234567890123456789012345678901234567890", "", ""},
+		errors.New("clone cluster name must be no longer than 63 characters")},
+	{&CloneDescription{"foobar", "", ""}, nil},
+}
+
+var maintenanceWindows = []struct {
+	in  []byte
+	out MaintenanceWindow
+	err error
+}{{[]byte(`"Tue:10:00-20:00"`),
+	MaintenanceWindow{
+		Everyday:  false,
+		Weekday:   time.Tuesday,
+		StartTime: mustParseTime("10:00"),
+		EndTime:   mustParseTime("20:00"),
+	}, nil},
+	{[]byte(`"Mon:10:00-10:00"`),
+		MaintenanceWindow{
+			Everyday:  false,
+			Weekday:   time.Monday,
+			StartTime: mustParseTime("10:00"),
+			EndTime:   mustParseTime("10:00"),
+		}, nil},
+	{[]byte(`"Sun:00:00-00:00"`),
+		MaintenanceWindow{
+			Everyday:  false,
+			Weekday:   time.Sunday,
+			StartTime: mustParseTime("00:00"),
+			EndTime:   mustParseTime("00:00"),
+		}, nil},
+	{[]byte(`"01:00-10:00"`),
+		MaintenanceWindow{
+			Everyday:  true,
+			Weekday:   time.Sunday,
+			StartTime: mustParseTime("01:00"),
+			EndTime:   mustParseTime("10:00"),
+		}, nil},
+	{[]byte(`"Mon:12:00-11:00"`), MaintenanceWindow{}, errors.New(`'From' time must be prior to the 'To' time`)},
+	{[]byte(`"Wed:33:00-00:00"`), MaintenanceWindow{}, errors.New(`could not parse start time: parsing time "33:00": hour out of range`)},
+	{[]byte(`"Wed:00:00-26:00"`), MaintenanceWindow{}, errors.New(`could not parse end time: parsing time "26:00": hour out of range`)},
+	{[]byte(`"Sunday:00:00-00:00"`), MaintenanceWindow{}, errors.New(`could not parse weekday: incorrect weekday`)},
+	{[]byte(`":00:00-10:00"`), MaintenanceWindow{}, errors.New(`could not parse weekday: incorrect weekday`)},
+	{[]byte(`"Mon:10:00-00:00"`), MaintenanceWindow{}, errors.New(`'From' time must be prior to the 'To' time`)},
+	{[]byte(`"Mon:00:00:00-10:00:00"`), MaintenanceWindow{}, errors.New(`incorrect maintenance window format`)},
+	{[]byte(`"Mon:00:00"`), MaintenanceWindow{}, errors.New("incorrect maintenance window format")},
+	{[]byte(`"Mon:00:00-00:00:00"`), MaintenanceWindow{}, errors.New("could not parse end time: incorrect time format")}}
+
+var unmarshalCluster = []struct {
+	in      []byte
+	out     Postgresql
+	marshal []byte
+	err     error
+}{{
+	[]byte(`{
+  "kind": "Postgresql","apiVersion": "acid.zalan.do/v1",
+  "metadata": {"name": "acid-testcluster1"}, "spec": {"teamId": 100}}`),
+	Postgresql{
+		TypeMeta: metav1.TypeMeta{
+			Kind:       "Postgresql",
+			APIVersion: "acid.zalan.do/v1",
+		},
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "acid-testcluster1",
+		},
+		Status: ClusterStatusInvalid,
+		Error: (&json.UnmarshalTypeError{
+			Value:  "number",
+			Type:   reflect.TypeOf(""),
+			Offset: 126,
+			Struct: "PostgresSpec",
+			Field:  "teamId",
+		}).Error(),
+	},
+	[]byte(`{"kind":"Postgresql","apiVersion":"acid.zalan.do/v1","metadata":{"name":"acid-testcluster1","creationTimestamp":null},"spec":{"postgresql":{"version":"","parameters":null},"volume":{"size":"","storageClass":""},"patroni":{"initdb":null,"pg_hba":null,"ttl":0,"loop_wait":0,"retry_timeout":0,"maximum_lag_on_failover":0},"resources":{"requests":{"cpu":"","memory":""},"limits":{"cpu":"","memory":""}},"teamId":"","allowedSourceRanges":null,"numberOfInstances":0,"users":null,"clone":{}},"status":"Invalid"}`), nil},
+	{[]byte(`{
+  "kind": "Postgresql",
+  "apiVersion": "acid.zalan.do/v1",
+  "metadata": {
+    "name": "acid-testcluster1"
+  },
+  "spec": {
+    "teamId": "ACID",
+    "volume": {
+      "size": "5Gi",
+      "storageClass": "SSD"
+    },
+    "numberOfInstances": 2,
+    "users": {
+      "zalando": [
+        "superuser",
+        "createdb"
+      ]
+    },
+    "allowedSourceRanges": [
+      "127.0.0.1/32"
+    ],
+    "postgresql": {
+      "version": "9.6",
+      "parameters": {
+        "shared_buffers": "32MB",
+        "max_connections": "10",
+        "log_statement": "all"
+      }
+    },
+    "resources": {
+      "requests": {
+        "cpu": "10m",
+        "memory": "50Mi"
+      },
+      "limits": {
+        "cpu": "300m",
+        "memory": "3000Mi"
+      }
+    },
+    "clone" : {
+     "cluster": "acid-batman"
+     },
+    "patroni": {
+      "initdb": {
+        "encoding": "UTF8",
+        "locale": "en_US.UTF-8",
+        "data-checksums": "true"
+      },
+      "pg_hba": [
+        "hostssl all all 0.0.0.0/0 md5",
+        "host    all all 0.0.0.0/0 md5"
+      ],
+      "ttl": 30,
+      "loop_wait": 10,
+      "retry_timeout": 10,
+      "maximum_lag_on_failover": 33554432
+    },
+    "maintenanceWindows": [
+      "Mon:01:00-06:00",
+      "Sat:00:00-04:00",
+      "05:00-05:15"
+    ]
+  }
+}`),
+		Postgresql{
+			TypeMeta: metav1.TypeMeta{
+				Kind:       "Postgresql",
+				APIVersion: "acid.zalan.do/v1",
+			},
+			ObjectMeta: metav1.ObjectMeta{
+				Name: "acid-testcluster1",
+			},
+			Spec: PostgresSpec{
+				PostgresqlParam: PostgresqlParam{
+					PgVersion: "9.6",
+					Parameters: map[string]string{
+						"shared_buffers":  "32MB",
+						"max_connections": "10",
+						"log_statement":   "all",
+					},
+				},
+				Volume: Volume{
+					Size:         "5Gi",
+					StorageClass: "SSD",
+				},
+				Patroni: Patroni{
+					InitDB: map[string]string{
+						"encoding":       "UTF8",
+						"locale":         "en_US.UTF-8",
+						"data-checksums": "true",
+					},
+					PgHba:                []string{"hostssl all all 0.0.0.0/0 md5", "host    all all 0.0.0.0/0 md5"},
+					TTL:                  30,
+					LoopWait:             10,
+					RetryTimeout:         10,
+					MaximumLagOnFailover: 33554432,
+				},
+				Resources: Resources{
+					ResourceRequest: ResourceDescription{CPU: "10m", Memory: "50Mi"},
+					ResourceLimits:  ResourceDescription{CPU: "300m", Memory: "3000Mi"},
+				},
+
+				TeamID:              "ACID",
+				AllowedSourceRanges: []string{"127.0.0.1/32"},
+				NumberOfInstances:   2,
+				Users:               map[string]UserFlags{"zalando": {"superuser", "createdb"}},
+				MaintenanceWindows: []MaintenanceWindow{{
+					Everyday:  false,
+					Weekday:   time.Monday,
+					StartTime: mustParseTime("01:00"),
+					EndTime:   mustParseTime("06:00"),
+				}, {
+					Everyday:  false,
+					Weekday:   time.Saturday,
+					StartTime: mustParseTime("00:00"),
+					EndTime:   mustParseTime("04:00"),
+				},
+					{
+						Everyday:  true,
+						Weekday:   time.Sunday,
+						StartTime: mustParseTime("05:00"),
+						EndTime:   mustParseTime("05:15"),
+					},
+				},
+				Clone: CloneDescription{
+					ClusterName: "acid-batman",
+				},
+				ClusterName: "testcluster1",
+			},
+			Error: "",
+		},
+		[]byte(`{"kind":"Postgresql","apiVersion":"acid.zalan.do/v1","metadata":{"name":"acid-testcluster1","creationTimestamp":null},"spec":{"postgresql":{"version":"9.6","parameters":{"log_statement":"all","max_connections":"10","shared_buffers":"32MB"}},"volume":{"size":"5Gi","storageClass":"SSD"},"patroni":{"initdb":{"data-checksums":"true","encoding":"UTF8","locale":"en_US.UTF-8"},"pg_hba":["hostssl all all 0.0.0.0/0 md5","host    all all 0.0.0.0/0 md5"],"ttl":30,"loop_wait":10,"retry_timeout":10,"maximum_lag_on_failover":33554432},"resources":{"requests":{"cpu":"10m","memory":"50Mi"},"limits":{"cpu":"300m","memory":"3000Mi"}},"teamId":"ACID","allowedSourceRanges":["127.0.0.1/32"],"numberOfInstances":2,"users":{"zalando":["superuser","createdb"]},"maintenanceWindows":["Mon:01:00-06:00","Sat:00:00-04:00","05:00-05:15"],"clone":{"cluster":"acid-batman"}}}`), nil},
+	{
+		[]byte(`{"kind": "Postgresql","apiVersion": "acid.zalan.do/v1","metadata": {"name": "teapot-testcluster1"}, "spec": {"teamId": "acid"}}`),
+		Postgresql{
+			TypeMeta: metav1.TypeMeta{
+				Kind:       "Postgresql",
+				APIVersion: "acid.zalan.do/v1",
+			},
+			ObjectMeta: metav1.ObjectMeta{
+				Name: "teapot-testcluster1",
+			},
+			Spec:   PostgresSpec{TeamID: "acid"},
+			Status: ClusterStatusInvalid,
+			Error:  errors.New("name must match {TEAM}-{NAME} format").Error(),
+		},
+		[]byte(`{"kind":"Postgresql","apiVersion":"acid.zalan.do/v1","metadata":{"name":"teapot-testcluster1","creationTimestamp":null},"spec":{"postgresql":{"version":"","parameters":null},"volume":{"size":"","storageClass":""},"patroni":{"initdb":null,"pg_hba":null,"ttl":0,"loop_wait":0,"retry_timeout":0,"maximum_lag_on_failover":0},"resources":{"requests":{"cpu":"","memory":""},"limits":{"cpu":"","memory":""}},"teamId":"acid","allowedSourceRanges":null,"numberOfInstances":0,"users":null,"clone":{}},"status":"Invalid"}`), nil},
+	{
+		in: []byte(`{"kind": "Postgresql","apiVersion": "acid.zalan.do/v1","metadata": {"name": "acid-testcluster1"}, "spec": {"teamId": "acid", "clone": {"cluster": "team-batman"}}}`),
+		out: Postgresql{
+			TypeMeta: metav1.TypeMeta{
+				Kind:       "Postgresql",
+				APIVersion: "acid.zalan.do/v1",
+			},
+			ObjectMeta: metav1.ObjectMeta{
+				Name: "acid-testcluster1",
+			},
+			Spec: PostgresSpec{
+				TeamID: "acid",
+				Clone: CloneDescription{
+					ClusterName: "team-batman",
+				},
+				ClusterName: "testcluster1",
+			},
+			Error: "",
+		},
+		marshal: []byte(`{"kind":"Postgresql","apiVersion":"acid.zalan.do/v1","metadata":{"name":"acid-testcluster1","creationTimestamp":null},"spec":{"postgresql":{"version":"","parameters":null},"volume":{"size":"","storageClass":""},"patroni":{"initdb":null,"pg_hba":null,"ttl":0,"loop_wait":0,"retry_timeout":0,"maximum_lag_on_failover":0},"resources":{"requests":{"cpu":"","memory":""},"limits":{"cpu":"","memory":""}},"teamId":"acid","allowedSourceRanges":null,"numberOfInstances":0,"users":null,"clone":{"cluster":"team-batman"}}}`), err: nil},
+	{[]byte(`{"kind": "Postgresql","apiVersion": "acid.zalan.do/v1"`),
+		Postgresql{},
+		[]byte{},
+		errors.New("unexpected end of JSON input")},
+	{[]byte(`{"kind":"Postgresql","apiVersion":"acid.zalan.do/v1","metadata":{"name":"acid-testcluster","creationTimestamp":qaz},"spec":{"postgresql":{"version":"","parameters":null},"volume":{"size":"","storageClass":""},"patroni":{"initdb":null,"pg_hba":null,"ttl":0,"loop_wait":0,"retry_timeout":0,"maximum_lag_on_failover":0},"resources":{"requests":{"cpu":"","memory":""},"limits":{"cpu":"","memory":""}},"teamId":"acid","allowedSourceRanges":null,"numberOfInstances":0,"users":null,"clone":{}},"status":"Invalid"}`),
+		Postgresql{},
+		[]byte{},
+		errors.New("invalid character 'q' looking for beginning of value")}}
+
+var postgresqlList = []struct {
+	in  []byte
+	out PostgresqlList
+	err error
+}{
+	{[]byte(`{"apiVersion":"v1","items":[{"apiVersion":"acid.zalan.do/v1","kind":"Postgresql","metadata":{"labels":{"team":"acid"},"name":"acid-testcluster42","namespace":"default","resourceVersion":"30446957","selfLink":"/apis/acid.zalan.do/v1/namespaces/default/postgresqls/acid-testcluster42","uid":"857cd208-33dc-11e7-b20a-0699041e4b03"},"spec":{"allowedSourceRanges":["185.85.220.0/22"],"numberOfInstances":1,"postgresql":{"version":"9.6"},"teamId":"acid","volume":{"size":"10Gi"}},"status":"Running"}],"kind":"List","metadata":{},"resourceVersion":"","selfLink":""}`),
+		PostgresqlList{
+			TypeMeta: metav1.TypeMeta{
+				Kind:       "List",
+				APIVersion: "v1",
+			},
+			Items: []Postgresql{{
+				TypeMeta: metav1.TypeMeta{
+					Kind:       "Postgresql",
+					APIVersion: "acid.zalan.do/v1",
+				},
+				ObjectMeta: metav1.ObjectMeta{
+					Name:            "acid-testcluster42",
+					Namespace:       "default",
+					Labels:          map[string]string{"team": "acid"},
+					ResourceVersion: "30446957",
+					SelfLink:        "/apis/acid.zalan.do/v1/namespaces/default/postgresqls/acid-testcluster42",
+					UID:             "857cd208-33dc-11e7-b20a-0699041e4b03",
+				},
+				Spec: PostgresSpec{
+					ClusterName:         "testcluster42",
+					PostgresqlParam:     PostgresqlParam{PgVersion: "9.6"},
+					Volume:              Volume{Size: "10Gi"},
+					TeamID:              "acid",
+					AllowedSourceRanges: []string{"185.85.220.0/22"},
+					NumberOfInstances:   1,
+				},
+				Status: ClusterStatusRunning,
+				Error:  "",
+			}},
+		},
+		nil},
+	{[]byte(`{"apiVersion":"v1","items":[{"apiVersion":"acid.zalan.do/v1","kind":"Postgresql","metadata":{"labels":{"team":"acid"},"name":"acid-testcluster42","namespace"`),
+		PostgresqlList{},
+		errors.New("unexpected end of JSON input")}}
+
+func mustParseTime(s string) metav1.Time {
+	v, err := time.Parse("15:04", s)
+	if err != nil {
+		panic(err)
+	}
+
+	return metav1.Time{Time: v.UTC()}
+}
+
+func TestParseTime(t *testing.T) {
+	for _, tt := range parseTimeTests {
+		aTime, err := parseTime(tt.in)
+		if err != nil {
+			if tt.err == nil || err.Error() != tt.err.Error() {
+				t.Errorf("ParseTime expected error: %v, got: %v", tt.err, err)
+			}
+			continue
+		} else if tt.err != nil {
+			t.Errorf("Expected error: %v", tt.err)
+		}
+
+		if aTime != tt.out {
+			t.Errorf("Expected time: %v, got: %v", tt.out, aTime)
+		}
+	}
+}
+
+func TestWeekdayTime(t *testing.T) {
+	for _, tt := range parseWeekdayTests {
+		aTime, err := parseWeekday(tt.in)
+		if err != nil {
+			if tt.err == nil || err.Error() != tt.err.Error() {
+				t.Errorf("ParseWeekday expected error: %v, got: %v", tt.err, err)
+			}
+			continue
+		} else if tt.err != nil {
+			t.Errorf("Expected error: %v", tt.err)
+		}
+
+		if aTime != tt.out {
+			t.Errorf("Expected weekday: %v, got: %v", tt.out, aTime)
+		}
+	}
+}
+
+func TestClusterName(t *testing.T) {
+	for _, tt := range clusterNames {
+		name, err := extractClusterName(tt.in, tt.inTeam)
+		if err != nil {
+			if tt.err == nil || err.Error() != tt.err.Error() {
+				t.Errorf("extractClusterName expected error: %v, got: %v", tt.err, err)
+			}
+			continue
+		} else if tt.err != nil {
+			t.Errorf("Expected error: %v", tt.err)
+		}
+		if name != tt.clusterName {
+			t.Errorf("Expected cluserName: %q, got: %q", tt.clusterName, name)
+		}
+	}
+}
+
+func TestCloneClusterDescription(t *testing.T) {
+	for _, tt := range cloneClusterDescriptions {
+		if err := validateCloneClusterDescription(tt.in); err != nil {
+			if tt.err == nil || err.Error() != tt.err.Error() {
+				t.Errorf("testCloneClusterDescription expected error: %v, got: %v", tt.err, err)
+			}
+		} else if tt.err != nil {
+			t.Errorf("Expected error: %v", tt.err)
+		}
+	}
+}
+
+func TestUnmarshalMaintenanceWindow(t *testing.T) {
+	for _, tt := range maintenanceWindows {
+		var m MaintenanceWindow
+		err := m.UnmarshalJSON(tt.in)
+		if err != nil {
+			if tt.err == nil || err.Error() != tt.err.Error() {
+				t.Errorf("MaintenanceWindow unmarshal expected error: %v, got %v", tt.err, err)
+			}
+			continue
+		} else if tt.err != nil {
+			t.Errorf("Expected error: %v", tt.err)
+		}
+
+		if !reflect.DeepEqual(m, tt.out) {
+			t.Errorf("Expected maintenance window: %#v, got: %#v", tt.out, m)
+		}
+	}
+}
+
+func TestMarshalMaintenanceWindow(t *testing.T) {
+	for _, tt := range maintenanceWindows {
+		if tt.err != nil {
+			continue
+		}
+
+		s, err := tt.out.MarshalJSON()
+		if err != nil {
+			t.Errorf("Marshal Error: %v", err)
+		}
+
+		if !bytes.Equal(s, tt.in) {
+			t.Errorf("Expected Marshal: %q, got: %q", string(tt.in), string(s))
+		}
+	}
+}
+
+func TestPostgresUnmarshal(t *testing.T) {
+	for _, tt := range unmarshalCluster {
+		var cluster Postgresql
+		err := cluster.UnmarshalJSON(tt.in)
+		if err != nil {
+			if tt.err == nil || err.Error() != tt.err.Error() {
+				t.Errorf("Unmarshal expected error: %v, got: %v", tt.err, err)
+			}
+			continue
+		} else if tt.err != nil {
+			t.Errorf("Expected error: %v", tt.err)
+		}
+
+		if !reflect.DeepEqual(cluster, tt.out) {
+			t.Errorf("Expected Postgresql: %#v, got %#v", tt.out, cluster)
+		}
+	}
+}
+
+func TestMarshal(t *testing.T) {
+	for _, tt := range unmarshalCluster {
+		if tt.err != nil {
+			continue
+		}
+
+		m, err := json.Marshal(tt.out)
+		if err != nil {
+			t.Errorf("Marshal error: %v", err)
+		}
+		if !bytes.Equal(m, tt.marshal) {
+			t.Errorf("Marshal Postgresql expected: %q, got: %q", string(tt.marshal), string(m))
+		}
+	}
+}
+
+func TestPostgresMeta(t *testing.T) {
+	for _, tt := range unmarshalCluster {
+		if a := tt.out.GetObjectKind(); a != &tt.out.TypeMeta {
+			t.Errorf("GetObjectKindMeta expected: %v, got: %v", tt.out.TypeMeta, a)
+		}
+
+		if a := tt.out.GetObjectMeta(); reflect.DeepEqual(a, tt.out.ObjectMeta) {
+			t.Errorf("GetObjectMeta expected: %v, got: %v", tt.out.ObjectMeta, a)
+		}
+	}
+}
+
+func TestPostgresListMeta(t *testing.T) {
+	for _, tt := range postgresqlList {
+		if tt.err != nil {
+			continue
+		}
+
+		if a := tt.out.GetObjectKind(); a != &tt.out.TypeMeta {
+			t.Errorf("GetObjectKindMeta expected: %v, got: %v", tt.out.TypeMeta, a)
+		}
+
+		if a := tt.out.GetListMeta(); reflect.DeepEqual(a, tt.out.ListMeta) {
+			t.Errorf("GetObjectMeta expected: %v, got: %v", tt.out.ListMeta, a)
+		}
+
+		return
+	}
+}
+
+func TestPostgresqlClone(t *testing.T) {
+	for _, tt := range unmarshalCluster {
+		cp := &tt.out
+		cp.Error = ""
+		clone := cp.Clone()
+		if !reflect.DeepEqual(clone, cp) {
+			t.Errorf("TestPostgresqlClone expected: \n%#v\n, got \n%#v", cp, clone)
+		}
+
+	}
+}

pkg/apis/acid.zalan.do/v1/zz_generated.deepcopy.go

@@ -0,0 +1,681 @@
+// +build !ignore_autogenerated
+
+/*
+Copyright 2018 Compose, Zalando SE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+// Code generated by deepcopy-gen. DO NOT EDIT.
+
+package v1
+
+import (
+	corev1 "k8s.io/api/core/v1"
+	runtime "k8s.io/apimachinery/pkg/runtime"
+)
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *AWSGCPConfiguration) DeepCopyInto(out *AWSGCPConfiguration) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AWSGCPConfiguration.
+func (in *AWSGCPConfiguration) DeepCopy() *AWSGCPConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(AWSGCPConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *CloneDescription) DeepCopyInto(out *CloneDescription) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloneDescription.
+func (in *CloneDescription) DeepCopy() *CloneDescription {
+	if in == nil {
+		return nil
+	}
+	out := new(CloneDescription)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *KubernetesMetaConfiguration) DeepCopyInto(out *KubernetesMetaConfiguration) {
+	*out = *in
+	out.OAuthTokenSecretName = in.OAuthTokenSecretName
+	out.InfrastructureRolesSecretName = in.InfrastructureRolesSecretName
+	if in.ClusterLabels != nil {
+		in, out := &in.ClusterLabels, &out.ClusterLabels
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	if in.NodeReadinessLabel != nil {
+		in, out := &in.NodeReadinessLabel, &out.NodeReadinessLabel
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	if in.PodToleration != nil {
+		in, out := &in.PodToleration, &out.PodToleration
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KubernetesMetaConfiguration.
+func (in *KubernetesMetaConfiguration) DeepCopy() *KubernetesMetaConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(KubernetesMetaConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *LoadBalancerConfiguration) DeepCopyInto(out *LoadBalancerConfiguration) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoadBalancerConfiguration.
+func (in *LoadBalancerConfiguration) DeepCopy() *LoadBalancerConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(LoadBalancerConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *LoggingRESTAPIConfiguration) DeepCopyInto(out *LoggingRESTAPIConfiguration) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoggingRESTAPIConfiguration.
+func (in *LoggingRESTAPIConfiguration) DeepCopy() *LoggingRESTAPIConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(LoggingRESTAPIConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *MaintenanceWindow) DeepCopyInto(out *MaintenanceWindow) {
+	*out = *in
+	in.StartTime.DeepCopyInto(&out.StartTime)
+	in.EndTime.DeepCopyInto(&out.EndTime)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MaintenanceWindow.
+func (in *MaintenanceWindow) DeepCopy() *MaintenanceWindow {
+	if in == nil {
+		return nil
+	}
+	out := new(MaintenanceWindow)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *OperatorConfiguration) DeepCopyInto(out *OperatorConfiguration) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Configuration.DeepCopyInto(&out.Configuration)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorConfiguration.
+func (in *OperatorConfiguration) DeepCopy() *OperatorConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(OperatorConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *OperatorConfiguration) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *OperatorConfigurationData) DeepCopyInto(out *OperatorConfigurationData) {
+	*out = *in
+	if in.Sidecars != nil {
+		in, out := &in.Sidecars, &out.Sidecars
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	out.PostgresUsersConfiguration = in.PostgresUsersConfiguration
+	in.Kubernetes.DeepCopyInto(&out.Kubernetes)
+	out.PostgresPodResources = in.PostgresPodResources
+	out.Timeouts = in.Timeouts
+	out.LoadBalancer = in.LoadBalancer
+	out.AWSGCP = in.AWSGCP
+	out.OperatorDebug = in.OperatorDebug
+	in.TeamsAPI.DeepCopyInto(&out.TeamsAPI)
+	out.LoggingRESTAPI = in.LoggingRESTAPI
+	out.Scalyr = in.Scalyr
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorConfigurationData.
+func (in *OperatorConfigurationData) DeepCopy() *OperatorConfigurationData {
+	if in == nil {
+		return nil
+	}
+	out := new(OperatorConfigurationData)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *OperatorConfigurationList) DeepCopyInto(out *OperatorConfigurationList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]OperatorConfiguration, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorConfigurationList.
+func (in *OperatorConfigurationList) DeepCopy() *OperatorConfigurationList {
+	if in == nil {
+		return nil
+	}
+	out := new(OperatorConfigurationList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *OperatorConfigurationList) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *OperatorConfigurationUsers) DeepCopyInto(out *OperatorConfigurationUsers) {
+	*out = *in
+	if in.ProtectedRoles != nil {
+		in, out := &in.ProtectedRoles, &out.ProtectedRoles
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	if in.TeamAPIRoleConfiguration != nil {
+		in, out := &in.TeamAPIRoleConfiguration, &out.TeamAPIRoleConfiguration
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorConfigurationUsers.
+func (in *OperatorConfigurationUsers) DeepCopy() *OperatorConfigurationUsers {
+	if in == nil {
+		return nil
+	}
+	out := new(OperatorConfigurationUsers)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *OperatorDebugConfiguration) DeepCopyInto(out *OperatorDebugConfiguration) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorDebugConfiguration.
+func (in *OperatorDebugConfiguration) DeepCopy() *OperatorDebugConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(OperatorDebugConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *OperatorTimeouts) DeepCopyInto(out *OperatorTimeouts) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorTimeouts.
+func (in *OperatorTimeouts) DeepCopy() *OperatorTimeouts {
+	if in == nil {
+		return nil
+	}
+	out := new(OperatorTimeouts)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Patroni) DeepCopyInto(out *Patroni) {
+	*out = *in
+	if in.InitDB != nil {
+		in, out := &in.InitDB, &out.InitDB
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	if in.PgHba != nil {
+		in, out := &in.PgHba, &out.PgHba
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Patroni.
+func (in *Patroni) DeepCopy() *Patroni {
+	if in == nil {
+		return nil
+	}
+	out := new(Patroni)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PostgresPodResourcesDefaults) DeepCopyInto(out *PostgresPodResourcesDefaults) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresPodResourcesDefaults.
+func (in *PostgresPodResourcesDefaults) DeepCopy() *PostgresPodResourcesDefaults {
+	if in == nil {
+		return nil
+	}
+	out := new(PostgresPodResourcesDefaults)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PostgresSpec) DeepCopyInto(out *PostgresSpec) {
+	*out = *in
+	in.PostgresqlParam.DeepCopyInto(&out.PostgresqlParam)
+	out.Volume = in.Volume
+	in.Patroni.DeepCopyInto(&out.Patroni)
+	out.Resources = in.Resources
+	if in.EnableMasterLoadBalancer != nil {
+		in, out := &in.EnableMasterLoadBalancer, &out.EnableMasterLoadBalancer
+		*out = new(bool)
+		**out = **in
+	}
+	if in.EnableReplicaLoadBalancer != nil {
+		in, out := &in.EnableReplicaLoadBalancer, &out.EnableReplicaLoadBalancer
+		*out = new(bool)
+		**out = **in
+	}
+	if in.UseLoadBalancer != nil {
+		in, out := &in.UseLoadBalancer, &out.UseLoadBalancer
+		*out = new(bool)
+		**out = **in
+	}
+	if in.ReplicaLoadBalancer != nil {
+		in, out := &in.ReplicaLoadBalancer, &out.ReplicaLoadBalancer
+		*out = new(bool)
+		**out = **in
+	}
+	if in.AllowedSourceRanges != nil {
+		in, out := &in.AllowedSourceRanges, &out.AllowedSourceRanges
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	if in.Users != nil {
+		in, out := &in.Users, &out.Users
+		*out = make(map[string]UserFlags, len(*in))
+		for key, val := range *in {
+			var outVal []string
+			if val == nil {
+				(*out)[key] = nil
+			} else {
+				in, out := &val, &outVal
+				*out = make(UserFlags, len(*in))
+				copy(*out, *in)
+			}
+			(*out)[key] = outVal
+		}
+	}
+	if in.MaintenanceWindows != nil {
+		in, out := &in.MaintenanceWindows, &out.MaintenanceWindows
+		*out = make([]MaintenanceWindow, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	out.Clone = in.Clone
+	if in.Databases != nil {
+		in, out := &in.Databases, &out.Databases
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	if in.Tolerations != nil {
+		in, out := &in.Tolerations, &out.Tolerations
+		*out = make([]corev1.Toleration, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	if in.Sidecars != nil {
+		in, out := &in.Sidecars, &out.Sidecars
+		*out = make([]Sidecar, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresSpec.
+func (in *PostgresSpec) DeepCopy() *PostgresSpec {
+	if in == nil {
+		return nil
+	}
+	out := new(PostgresSpec)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PostgresUsersConfiguration) DeepCopyInto(out *PostgresUsersConfiguration) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresUsersConfiguration.
+func (in *PostgresUsersConfiguration) DeepCopy() *PostgresUsersConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(PostgresUsersConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Postgresql) DeepCopyInto(out *Postgresql) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	in.ObjectMeta.DeepCopyInto(&out.ObjectMeta)
+	in.Spec.DeepCopyInto(&out.Spec)
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Postgresql.
+func (in *Postgresql) DeepCopy() *Postgresql {
+	if in == nil {
+		return nil
+	}
+	out := new(Postgresql)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *Postgresql) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PostgresqlList) DeepCopyInto(out *PostgresqlList) {
+	*out = *in
+	out.TypeMeta = in.TypeMeta
+	out.ListMeta = in.ListMeta
+	if in.Items != nil {
+		in, out := &in.Items, &out.Items
+		*out = make([]Postgresql, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresqlList.
+func (in *PostgresqlList) DeepCopy() *PostgresqlList {
+	if in == nil {
+		return nil
+	}
+	out := new(PostgresqlList)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.
+func (in *PostgresqlList) DeepCopyObject() runtime.Object {
+	if c := in.DeepCopy(); c != nil {
+		return c
+	}
+	return nil
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *PostgresqlParam) DeepCopyInto(out *PostgresqlParam) {
+	*out = *in
+	if in.Parameters != nil {
+		in, out := &in.Parameters, &out.Parameters
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresqlParam.
+func (in *PostgresqlParam) DeepCopy() *PostgresqlParam {
+	if in == nil {
+		return nil
+	}
+	out := new(PostgresqlParam)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ResourceDescription) DeepCopyInto(out *ResourceDescription) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceDescription.
+func (in *ResourceDescription) DeepCopy() *ResourceDescription {
+	if in == nil {
+		return nil
+	}
+	out := new(ResourceDescription)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Resources) DeepCopyInto(out *Resources) {
+	*out = *in
+	out.ResourceRequest = in.ResourceRequest
+	out.ResourceLimits = in.ResourceLimits
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Resources.
+func (in *Resources) DeepCopy() *Resources {
+	if in == nil {
+		return nil
+	}
+	out := new(Resources)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *ScalyrConfiguration) DeepCopyInto(out *ScalyrConfiguration) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScalyrConfiguration.
+func (in *ScalyrConfiguration) DeepCopy() *ScalyrConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(ScalyrConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Sidecar) DeepCopyInto(out *Sidecar) {
+	*out = *in
+	out.Resources = in.Resources
+	if in.Ports != nil {
+		in, out := &in.Ports, &out.Ports
+		*out = make([]corev1.ContainerPort, len(*in))
+		copy(*out, *in)
+	}
+	if in.Env != nil {
+		in, out := &in.Env, &out.Env
+		*out = make([]corev1.EnvVar, len(*in))
+		for i := range *in {
+			(*in)[i].DeepCopyInto(&(*out)[i])
+		}
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Sidecar.
+func (in *Sidecar) DeepCopy() *Sidecar {
+	if in == nil {
+		return nil
+	}
+	out := new(Sidecar)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *TeamsAPIConfiguration) DeepCopyInto(out *TeamsAPIConfiguration) {
+	*out = *in
+	if in.TeamAPIRoleConfiguration != nil {
+		in, out := &in.TeamAPIRoleConfiguration, &out.TeamAPIRoleConfiguration
+		*out = make(map[string]string, len(*in))
+		for key, val := range *in {
+			(*out)[key] = val
+		}
+	}
+	if in.ProtectedRoles != nil {
+		in, out := &in.ProtectedRoles, &out.ProtectedRoles
+		*out = make([]string, len(*in))
+		copy(*out, *in)
+	}
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TeamsAPIConfiguration.
+func (in *TeamsAPIConfiguration) DeepCopy() *TeamsAPIConfiguration {
+	if in == nil {
+		return nil
+	}
+	out := new(TeamsAPIConfiguration)
+	in.DeepCopyInto(out)
+	return out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in UserFlags) DeepCopyInto(out *UserFlags) {
+	{
+		in := &in
+		*out = make(UserFlags, len(*in))
+		copy(*out, *in)
+		return
+	}
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UserFlags.
+func (in UserFlags) DeepCopy() UserFlags {
+	if in == nil {
+		return nil
+	}
+	out := new(UserFlags)
+	in.DeepCopyInto(out)
+	return *out
+}
+
+// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
+func (in *Volume) DeepCopyInto(out *Volume) {
+	*out = *in
+	return
+}
+
+// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Volume.
+func (in *Volume) DeepCopy() *Volume {
+	if in == nil {
+		return nil
+	}
+	out := new(Volume)
+	in.DeepCopyInto(out)
+	return out
+}