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/spec/postgresql.go

@@ -1,394 +0,0 @@
-package spec
-
-import (
-	"encoding/json"
-	"fmt"
-	"github.com/mohae/deepcopy"
-	"regexp"
-	"strings"
-	"time"
-
-	"k8s.io/api/core/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/apimachinery/pkg/runtime"
-)
-
-// 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 time.Time // Start time
-	EndTime   time.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
-
-// possible values for PostgreSQL cluster statuses
-const (
-	ClusterStatusUnknown      PostgresStatus = ""
-	ClusterStatusCreating     PostgresStatus = "Creating"
-	ClusterStatusUpdating     PostgresStatus = "Updating"
-	ClusterStatusUpdateFailed PostgresStatus = "UpdateFailed"
-	ClusterStatusSyncFailed   PostgresStatus = "SyncFailed"
-	ClusterStatusAddFailed    PostgresStatus = "CreateFailed"
-	ClusterStatusRunning      PostgresStatus = "Running"
-	ClusterStatusInvalid      PostgresStatus = "Invalid"
-)
-
-const (
-	serviceNameMaxLength   = 63
-	clusterNameMaxLength   = serviceNameMaxLength - len("-repl")
-	serviceNameRegexString = `^[a-z]([-a-z0-9]*[a-z0-9])?$`
-)
-
-// Postgresql defines PostgreSQL Custom Resource Definition Object.
-type Postgresql struct {
-	metav1.TypeMeta   `json:",inline"`
-	metav1.ObjectMeta `json:"metadata"`
-
-	Spec   PostgresSpec   `json:"spec"`
-	Status PostgresStatus `json:"status,omitempty"`
-	Error  error          `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"`
-}
-
-// PostgresqlList defines a list of PostgreSQL clusters.
-type PostgresqlList struct {
-	metav1.TypeMeta `json:",inline"`
-	metav1.ListMeta `json:"metadata"`
-
-	Items []Postgresql `json:"items"`
-}
-
-var (
-	weekdays         = map[string]int{"Sun": 0, "Mon": 1, "Tue": 2, "Wed": 3, "Thu": 4, "Fri": 5, "Sat": 6}
-	serviceNameRegex = regexp.MustCompile(serviceNameRegexString)
-)
-
-// Clone makes a deepcopy of the Postgresql structure. The Error field is nulled-out,
-// as there is no guarantee that the actual implementation of the error interface
-// will not contain any private fields not-reachable to deepcopy. This should be ok,
-// since Error is never read from a Kubernetes object.
-func (p *Postgresql) Clone() *Postgresql {
-	if p == nil {
-		return nil
-	}
-	c := deepcopy.Copy(p).(*Postgresql)
-	c.Error = nil
-	return c
-}
-
-func (p *Postgresql) DeepCopyInto(out *Postgresql) {
-	if p != nil {
-		*out = deepcopy.Copy(*p).(Postgresql)
-	}
-}
-
-func (p *Postgresql) DeepCopy() *Postgresql {
-	if p == nil {
-		return nil
-	}
-	out := new(Postgresql)
-	p.DeepCopyInto(out)
-	return out
-}
-
-func (p *Postgresql) DeepCopyObject() runtime.Object {
-	if c := p.DeepCopy(); c != nil {
-		return c
-	}
-	return nil
-}
-
-func parseTime(s string) (time.Time, error) {
-	parts := strings.Split(s, ":")
-	if len(parts) != 2 {
-		return time.Time{}, fmt.Errorf("incorrect time format")
-	}
-	timeLayout := "15:04"
-
-	tp, err := time.Parse(timeLayout, s)
-	if err != nil {
-		return time.Time{}, err
-	}
-
-	return 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
-}
-
-// 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
-}
-
-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
-}
-
-type postgresqlListCopy PostgresqlList
-type postgresqlCopy Postgresql
-
-// 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
-		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
-		tmp2.Status = ClusterStatusInvalid
-	} else if err := validateCloneClusterDescription(&tmp2.Spec.Clone); err != nil {
-		tmp2.Error = err
-		tmp2.Status = ClusterStatusInvalid
-	} else {
-		tmp2.Spec.ClusterName = clusterName
-	}
-
-	*p = tmp2
-
-	return nil
-}
-
-// UnmarshalJSON converts a JSON into the PostgreSQL List object.
-func (pl *PostgresqlList) UnmarshalJSON(data []byte) error {
-	var tmp postgresqlListCopy
-
-	err := json.Unmarshal(data, &tmp)
-	if err != nil {
-		return err
-	}
-	tmp2 := PostgresqlList(tmp)
-	*pl = tmp2
-
-	return nil
-}
-
-func (pl *PostgresqlList) DeepCopy() *PostgresqlList {
-	if pl == nil {
-		return nil
-	}
-	out := new(PostgresqlList)
-	pl.DeepCopyInto(out)
-	return out
-}
-
-func (pl *PostgresqlList) DeepCopyInto(out *PostgresqlList) {
-	if pl != nil {
-		*out = deepcopy.Copy(*pl).(PostgresqlList)
-	}
-}
-
-func (pl *PostgresqlList) DeepCopyObject() runtime.Object {
-	if c := pl.DeepCopy(); c != nil {
-		return c
-	}
-	return nil
-}
-
-func (status PostgresStatus) Success() bool {
-	return status != ClusterStatusAddFailed &&
-		status != ClusterStatusUpdateFailed &&
-		status != ClusterStatusSyncFailed
-}
-
-func (status PostgresStatus) String() string {
-	return string(status)
-}

pkg/spec/postgresql_test.go

@@ -1,559 +0,0 @@
-package spec
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"reflect"
-	"testing"
-	"time"
-)
-
-var parseTimeTests = []struct {
-	in  string
-	out time.Time
-	err error
-}{
-	{"16:08", mustParseTime("16:08"), nil},
-	{"11:00", mustParseTime("11:00"), nil},
-	{"23:59", mustParseTime("23:59"), nil},
-
-	{"26:09", time.Now(), errors.New(`parsing time "26:09": hour out of range`)},
-	{"23:69", time.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",
-		},
-	},
-	[]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: nil,
-		},
-		[]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"),
-		},
-		[]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: nil,
-		},
-		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,
-			}},
-		},
-		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) time.Time {
-	v, err := time.Parse("15:04", s)
-	if err != nil {
-		panic(err)
-	}
-
-	return 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 TestUnmarshalPostgresList(t *testing.T) {
-	for _, tt := range postgresqlList {
-		var list PostgresqlList
-		err := list.UnmarshalJSON(tt.in)
-		if err != nil {
-			if tt.err == nil || err.Error() != tt.err.Error() {
-				t.Errorf("PostgresqlList 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(list, tt.out) {
-			t.Errorf("Postgresql list unmarshall expected: %#v, got: %#v", tt.out, list)
-		}
-	}
-}
-
-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 = nil
-		clone := cp.Clone()
-		if !reflect.DeepEqual(clone, cp) {
-			t.Errorf("TestPostgresqlClone expected: \n%#v\n, got \n%#v", cp, clone)
-		}
-
-	}
-}

pkg/spec/types.go

@@ -11,29 +11,14 @@ import (
 	"time"
 
 	"github.com/Sirupsen/logrus"
-	"k8s.io/api/apps/v1beta1"
-	"k8s.io/api/core/v1"
-	policyv1beta1 "k8s.io/api/policy/v1beta1"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/rest"
 )
 
-// EventType contains type of the events for the TPRs and Pods received from Kubernetes
-type EventType string
-
 // NamespacedName describes the namespace/name pairs used in Kubernetes names.
 type NamespacedName types.NamespacedName
 
-// Possible values for the EventType
-const (
-	EventAdd    EventType = "ADD"
-	EventUpdate EventType = "UPDATE"
-	EventDelete EventType = "DELETE"
-	EventSync   EventType = "SYNC"
-	EventRepair EventType = "REPAIR"
-
-	fileWithNamespace = "/var/run/secrets/kubernetes.io/serviceaccount/namespace"
-)
+const fileWithNamespace = "/var/run/secrets/kubernetes.io/serviceaccount/namespace"
 
 // RoleOrigin contains the code of the origin of a role
 type RoleOrigin int
@@ -47,16 +32,6 @@ const (
 	RoleOriginSystem
 )
 
-// ClusterEvent carries the payload of the Cluster TPR events.
-type ClusterEvent struct {
-	EventTime time.Time
-	UID       types.UID
-	EventType EventType
-	OldSpec   *Postgresql
-	NewSpec   *Postgresql
-	WorkerID  uint32
-}
-
 type syncUserOperation int
 
 // Possible values for the sync user operation (removal of users is not supported yet)
@@ -66,15 +41,6 @@ const (
 	PGSyncAlterSet // handle ALTER ROLE SET parameter = value
 )
 
-// PodEvent describes the event for a single Pod
-type PodEvent struct {
-	ResourceVersion string
-	PodName         NamespacedName
-	PrevPod         *v1.Pod
-	CurPod          *v1.Pod
-	EventType       EventType
-}
-
 // PgUser contains information about a single user.
 type PgUser struct {
 	Origin     RoleOrigin        `yaml:"-"`
@@ -109,36 +75,6 @@ type LogEntry struct {
 	Message     string
 }
 
-// Process describes process of the cluster
-type Process struct {
-	Name      string
-	StartTime time.Time
-}
-
-// ClusterStatus describes status of the cluster
-type ClusterStatus struct {
-	Team                string
-	Cluster             string
-	MasterService       *v1.Service
-	ReplicaService      *v1.Service
-	MasterEndpoint      *v1.Endpoints
-	ReplicaEndpoint     *v1.Endpoints
-	StatefulSet         *v1beta1.StatefulSet
-	PodDisruptionBudget *policyv1beta1.PodDisruptionBudget
-
-	CurrentProcess Process
-	Worker         uint32
-	Status         PostgresStatus
-	Spec           PostgresSpec
-	Error          error
-}
-
-// WorkerStatus describes status of the worker
-type WorkerStatus struct {
-	CurrentCluster NamespacedName
-	CurrentProcess Process
-}
-
 // Diff describes diff
 type Diff struct {
 	EventTime   time.Time
@@ -260,30 +196,3 @@ func GetOperatorNamespace() string {
 	}
 	return operatorNamespace
 }
-
-type Duration time.Duration
-
-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)
-	}
-}