v1

package
v0.8.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 26, 2024 License: MIT Imports: 14 Imported by: 1

Documentation

Index

Constants

View Source
const (
	ClusterStatusUnknown      = ""
	ClusterStatusCreating     = "Creating"
	ClusterStatusUpdating     = "Updating"
	ClusterStatusUpdateFailed = "UpdateFailed"
	ClusterStatusSyncFailed   = "SyncFailed"
	ClusterStatusAddFailed    = "CreateFailed"
	ClusterStatusRunning      = "Running"
	ClusterStatusInvalid      = "Invalid"
	ClusterStatusRestoring    = "Restoring"
)

ClusterStatusUnknown etc : status of a Postgres cluster known to the operator

View Source
const (
	PostgresCRDResourceKind   = "postgresql"
	PostgresCRDResourcePlural = "postgresqls"
	PostgresCRDResourceList   = PostgresCRDResourceKind + "List"
	PostgresCRDResouceName    = PostgresCRDResourcePlural + "." + acidzalando.GroupName
	PostgresCRDResourceShort  = "pg"

	OperatorConfigCRDResouceKind    = "OperatorConfiguration"
	OperatorConfigCRDResourcePlural = "operatorconfigurations"
	OperatorConfigCRDResourceList   = OperatorConfigCRDResouceKind + "List"
	OperatorConfigCRDResourceName   = OperatorConfigCRDResourcePlural + "." + acidzalando.GroupName
	OperatorConfigCRDResourceShort  = "opconfig"
)

CRDResource* define names necesssary for the k8s CRD API

View Source
const (
	APIVersion = "v1"
)

APIVersion of the `postgresql` and `operator` CRDs

Variables

View Source
var (

	// SchemeBuilder : An instance of runtime.SchemeBuilder, global for this package
	SchemeBuilder runtime.SchemeBuilder

	//AddToScheme is localSchemeBuilder.AddToScheme
	AddToScheme = localSchemeBuilder.AddToScheme
	//SchemeGroupVersion has GroupName and APIVersion
	SchemeGroupVersion = schema.GroupVersion{Group: acidzalando.GroupName, Version: APIVersion}
)
View Source
var OperatorConfigCRDResourceColumns = []apiextv1.CustomResourceColumnDefinition{
	{
		Name:        "Image",
		Type:        "string",
		Description: "Spilo image to be used for Pods",
		JSONPath:    ".configuration.docker_image",
	},
	{
		Name:        "Cluster-Label",
		Type:        "string",
		Description: "Label for K8s resources created by operator",
		JSONPath:    ".configuration.kubernetes.cluster_name_label",
	},
	{
		Name:        "Service-Account",
		Type:        "string",
		Description: "Name of service account to be used",
		JSONPath:    ".configuration.kubernetes.pod_service_account_name",
	},
	{
		Name:        "Min-Instances",
		Type:        "integer",
		Description: "Minimum number of instances per Postgres cluster",
		JSONPath:    ".configuration.min_instances",
	},
	{
		Name:     "Age",
		Type:     "date",
		JSONPath: ".metadata.creationTimestamp",
	},
}

OperatorConfigCRDResourceColumns definition of AdditionalPrinterColumns for OperatorConfiguration CRD

View Source
var OperatorConfigCRDResourceValidation = apiextv1.CustomResourceValidation{
	OpenAPIV3Schema: &apiextv1.JSONSchemaProps{
		Type:     "object",
		Required: []string{"kind", "apiVersion", "configuration"},
		Properties: map[string]apiextv1.JSONSchemaProps{
			"kind": {
				Type: "string",
				Enum: []apiextv1.JSON{
					{
						Raw: []byte(`"OperatorConfiguration"`),
					},
				},
			},
			"apiVersion": {
				Type: "string",
				Enum: []apiextv1.JSON{
					{
						Raw: []byte(`"cpo.opensource.cybertec.at/v1"`),
					},
				},
			},
			"configuration": {
				Type: "object",
				Properties: map[string]apiextv1.JSONSchemaProps{
					"crd_categories": {
						Type:     "array",
						Nullable: true,
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "string",
							},
						},
					},
					"docker_image": {
						Type: "string",
					},
					"enable_crd_registration": {
						Type: "boolean",
					},
					"enable_crd_validation": {
						Type:        "boolean",
						Description: "deprecated",
					},
					"enable_lazy_spilo_upgrade": {
						Type: "boolean",
					},
					"enable_shm_volume": {
						Type: "boolean",
					},
					"enable_spilo_wal_path_compat": {
						Type: "boolean",
					},
					"enable_team_id_clustername_prefix": {
						Type: "boolean",
					},
					"etcd_host": {
						Type: "string",
					},
					"ignore_instance_limits_annotation_key": {
						Type: "string",
					},
					"kubernetes_use_configmaps": {
						Type: "boolean",
					},
					"max_instances": {
						Type:        "integer",
						Description: "-1 = disabled",
						Minimum:     &minDisable,
					},
					"min_instances": {
						Type:        "integer",
						Description: "-1 = disabled",
						Minimum:     &minDisable,
					},
					"resync_period": {
						Type: "string",
					},
					"repair_period": {
						Type: "string",
					},
					"set_memory_request_to_limit": {
						Type: "boolean",
					},
					"sidecar_docker_images": {
						Type: "object",
						AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "string",
							},
						},
					},
					"sidecars": {
						Type:     "array",
						Nullable: true,
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type:                   "object",
								XPreserveUnknownFields: util.True(),
							},
						},
					},
					"workers": {
						Type:    "integer",
						Minimum: &min1,
					},
					"users": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"additional_owner_roles": {
								Type:     "array",
								Nullable: true,
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"enable_password_rotation": {
								Type: "boolean",
							},
							"password_rotation_interval": {
								Type: "integer",
							},
							"password_rotation_user_retention": {
								Type: "integer",
							},
							"replication_username": {
								Type: "string",
							},
							"super_username": {
								Type: "string",
							},
						},
					},
					"major_version_upgrade": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"major_version_upgrade_mode": {
								Type: "string",
							},
							"major_version_upgrade_team_allow_list": {
								Type: "array",
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"minimal_major_version": {
								Type: "string",
							},
							"target_major_version": {
								Type: "string",
							},
						},
					},
					"kubernetes": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"additional_pod_capabilities": {
								Type: "array",
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"cluster_domain": {
								Type: "string",
							},
							"cluster_labels": {
								Type: "object",
								AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"cluster_name_label": {
								Type: "string",
							},
							"custom_pod_annotations": {
								Type: "object",
								AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"delete_annotation_date_key": {
								Type: "string",
							},
							"delete_annotation_name_key": {
								Type: "string",
							},
							"downscaler_annotations": {
								Type: "array",
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"enable_cross_namespace_secret": {
								Type: "boolean",
							},
							"enable_init_containers": {
								Type: "boolean",
							},
							"enable_pod_antiaffinity": {
								Type: "boolean",
							},
							"enable_pod_disruption_budget": {
								Type: "boolean",
							},
							"enable_readiness_probe": {
								Type: "boolean",
							},
							"enable_sidecars": {
								Type: "boolean",
							},
							"ignored_annotations": {
								Type: "array",
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"infrastructure_roles_secret_name": {
								Type: "string",
							},
							"infrastructure_roles_secrets": {
								Type:     "array",
								Nullable: true,
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type:     "object",
										Required: []string{"secretname", "userkey", "passwordkey"},
										Properties: map[string]apiextv1.JSONSchemaProps{
											"secretname": {
												Type: "string",
											},
											"userkey": {
												Type: "string",
											},
											"passwordkey": {
												Type: "string",
											},
											"rolekey": {
												Type: "string",
											},
											"defaultuservalue": {
												Type: "string",
											},
											"defaultrolevalue": {
												Type: "string",
											},
											"details": {
												Type: "string",
											},
											"template": {
												Type: "boolean",
											},
										},
									},
								},
							},
							"inherited_annotations": {
								Type: "array",
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"inherited_labels": {
								Type: "array",
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"master_pod_move_timeout": {
								Type: "string",
							},
							"node_readiness_label": {
								Type: "object",
								AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"node_readiness_label_merge": {
								Type: "string",
								Enum: []apiextv1.JSON{
									{
										Raw: []byte(`"AND"`),
									},
									{
										Raw: []byte(`"OR"`),
									},
								},
							},
							"oauth_token_secret_name": {
								Type: "string",
							},
							"pdb_name_format": {
								Type: "string",
							},
							"persistent_volume_claim_retention_policy": {
								Type: "object",
								Properties: map[string]apiextv1.JSONSchemaProps{
									"when_deleted": {
										Type: "string",
										Enum: []apiextv1.JSON{
											{
												Raw: []byte(`"delete"`),
											},
											{
												Raw: []byte(`"retain"`),
											},
										},
									},
									"when_scaled": {
										Type: "string",
										Enum: []apiextv1.JSON{
											{
												Raw: []byte(`"delete"`),
											},
											{
												Raw: []byte(`"retain"`),
											},
										},
									},
								},
							},
							"pod_antiaffinity_preferred_during_scheduling": {
								Type: "boolean",
							},
							"pod_antiaffinity_topology_key": {
								Type: "string",
							},
							"pod_environment_configmap": {
								Type: "string",
							},
							"pod_environment_secret": {
								Type: "string",
							},
							"pod_management_policy": {
								Type: "string",
								Enum: []apiextv1.JSON{
									{
										Raw: []byte(`"ordered_ready"`),
									},
									{
										Raw: []byte(`"parallel"`),
									},
								},
							},
							"pod_priority_class_name": {
								Type: "string",
							},
							"pod_role_label": {
								Type: "string",
							},
							"pod_service_account_definition": {
								Type: "string",
							},
							"pod_service_account_name": {
								Type: "string",
							},
							"pod_service_account_role_binding_definition": {
								Type: "string",
							},
							"pod_terminate_grace_period": {
								Type: "string",
							},
							"secret_name_template": {
								Type: "string",
							},
							"share_pgsocket_with_sidecars": {
								Type: "boolean",
							},
							"spilo_runasuser": {
								Type: "integer",
							},
							"spilo_runasgroup": {
								Type: "integer",
							},
							"spilo_fsgroup": {
								Type: "integer",
							},
							"spilo_privileged": {
								Type: "boolean",
							},
							"spilo_allow_privilege_escalation": {
								Type: "boolean",
							},
							"storage_resize_mode": {
								Type: "string",
								Enum: []apiextv1.JSON{
									{
										Raw: []byte(`"ebs"`),
									},
									{
										Raw: []byte(`"mixed"`),
									},
									{
										Raw: []byte(`"pvc"`),
									},
									{
										Raw: []byte(`"off"`),
									},
								},
							},
							"toleration": {
								Type: "object",
								AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"watched_namespace": {
								Type: "string",
							},
						},
					},
					"patroni": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"enable_patroni_failsafe_mode": {
								Type: "boolean",
							},
						},
					},
					"postgres_pod_resources": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"default_cpu_limit": {
								Type:    "string",
								Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
							},
							"default_cpu_request": {
								Type:    "string",
								Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
							},
							"default_memory_limit": {
								Type:    "string",
								Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
							},
							"default_memory_request": {
								Type:    "string",
								Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
							},
							"max_cpu_request": {
								Type:    "string",
								Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
							},
							"max_memory_request": {
								Type:    "string",
								Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
							},
							"min_cpu_limit": {
								Type:    "string",
								Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
							},
							"min_memory_limit": {
								Type:    "string",
								Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
							},
						},
					},
					"timeouts": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"patroni_api_check_interval": {
								Type: "string",
							},
							"patroni_api_check_timeout": {
								Type: "string",
							},
							"pod_label_wait_timeout": {
								Type: "string",
							},
							"pod_deletion_wait_timeout": {
								Type: "string",
							},
							"ready_wait_interval": {
								Type: "string",
							},
							"ready_wait_timeout": {
								Type: "string",
							},
							"resource_check_interval": {
								Type: "string",
							},
							"resource_check_timeout": {
								Type: "string",
							},
						},
					},
					"load_balancer": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"custom_service_annotations": {
								Type: "object",
								AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"db_hosted_zone": {
								Type: "string",
							},
							"enable_master_load_balancer": {
								Type: "boolean",
							},
							"enable_master_pooler_load_balancer": {
								Type: "boolean",
							},
							"enable_replica_load_balancer": {
								Type: "boolean",
							},
							"enable_replica_pooler_load_balancer": {
								Type: "boolean",
							},
							"external_traffic_policy": {
								Type: "string",
								Enum: []apiextv1.JSON{
									{
										Raw: []byte(`"Cluster"`),
									},
									{
										Raw: []byte(`"Local"`),
									},
								},
							},
							"master_dns_name_format": {
								Type: "string",
							},
							"master_legacy_dns_name_format": {
								Type: "string",
							},
							"replica_dns_name_format": {
								Type: "string",
							},
							"replica_legacy_dns_name_format": {
								Type: "string",
							},
						},
					},
					"aws_or_gcp": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"additional_secret_mount": {
								Type: "string",
							},
							"additional_secret_mount_path": {
								Type: "string",
							},
							"aws_region": {
								Type: "string",
							},
							"enable_ebs_gp3_migration": {
								Type: "boolean",
							},
							"enable_ebs_gp3_migration_max_size": {
								Type: "integer",
							},
							"gcp_credentials": {
								Type: "string",
							},
							"kube_iam_role": {
								Type: "string",
							},
							"log_s3_bucket": {
								Type: "string",
							},
							"wal_s3_bucket": {
								Type: "string",
							},
						},
					},
					"logical_backup": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"logical_backup_azure_storage_account_name": {
								Type: "string",
							},
							"logical_backup_azure_storage_container": {
								Type: "string",
							},
							"logical_backup_azure_storage_account_key": {
								Type: "string",
							},
							"logical_backup_cpu_limit": {
								Type:    "string",
								Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
							},
							"logical_backup_cpu_request": {
								Type:    "string",
								Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
							},
							"logical_backup_docker_image": {
								Type: "string",
							},
							"logical_backup_google_application_credentials": {
								Type: "string",
							},
							"logical_backup_job_prefix": {
								Type: "string",
							},
							"logical_backup_memory_limit": {
								Type:    "string",
								Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
							},
							"logical_backup_memory_request": {
								Type:    "string",
								Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
							},
							"logical_backup_provider": {
								Type: "string",
								Enum: []apiextv1.JSON{
									{
										Raw: []byte(`"az"`),
									},
									{
										Raw: []byte(`"gcs"`),
									},
									{
										Raw: []byte(`"s3"`),
									},
								},
							},
							"logical_backup_s3_access_key_id": {
								Type: "string",
							},
							"logical_backup_s3_bucket": {
								Type: "string",
							},
							"logical_backup_s3_endpoint": {
								Type: "string",
							},
							"logical_backup_s3_region": {
								Type: "string",
							},
							"logical_backup_s3_secret_access_key": {
								Type: "string",
							},
							"logical_backup_s3_sse": {
								Type: "string",
							},
							"logical_backup_s3_retention_time": {
								Type: "string",
							},
							"logical_backup_schedule": {
								Type:    "string",
								Pattern: "^(\\d+|\\*)(/\\d+)?(\\s+(\\d+|\\*)(/\\d+)?){4}$",
							},
						},
					},
					"debug": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"debug_logging": {
								Type: "boolean",
							},
							"enable_database_access": {
								Type: "boolean",
							},
						},
					},
					"teams_api": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"enable_admin_role_for_users": {
								Type: "boolean",
							},
							"enable_postgres_team_crd": {
								Type: "boolean",
							},
							"enable_postgres_team_crd_superusers": {
								Type: "boolean",
							},
							"enable_team_member_deprecation": {
								Type: "boolean",
							},
							"enable_team_superuser": {
								Type: "boolean",
							},
							"enable_teams_api": {
								Type: "boolean",
							},
							"pam_configuration": {
								Type: "string",
							},
							"pam_role_name": {
								Type: "string",
							},
							"postgres_superuser_teams": {
								Type: "array",
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"protected_role_names": {
								Type: "array",
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"role_deletion_suffix": {
								Type: "string",
							},
							"team_admin_role": {
								Type: "string",
							},
							"team_api_role_configuration": {
								Type: "object",
								AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"teams_api_url": {
								Type: "string",
							},
						},
					},
					"logging_rest_api": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"api_port": {
								Type: "integer",
							},
							"cluster_history_entries": {
								Type: "integer",
							},
							"ring_log_lines": {
								Type: "integer",
							},
						},
					},
					"scalyr": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"scalyr_api_key": {
								Type: "string",
							},
							"scalyr_cpu_limit": {
								Type:    "string",
								Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
							},
							"scalyr_cpu_request": {
								Type:    "string",
								Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
							},
							"scalyr_image": {
								Type: "string",
							},
							"scalyr_memory_limit": {
								Type:    "string",
								Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
							},
							"scalyr_memory_request": {
								Type:    "string",
								Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
							},
							"scalyr_server_url": {
								Type: "string",
							},
						},
					},
					"connection_pooler": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"connection_pooler_default_cpu_limit": {
								Type:    "string",
								Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
							},
							"connection_pooler_default_cpu_request": {
								Type:    "string",
								Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
							},
							"connection_pooler_default_memory_limit": {
								Type:    "string",
								Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
							},
							"connection_pooler_default_memory_request": {
								Type:    "string",
								Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
							},
							"connection_pooler_image": {
								Type: "string",
							},
							"connection_pooler_max_db_connections": {
								Type: "integer",
							},
							"connection_pooler_mode": {
								Type: "string",
								Enum: []apiextv1.JSON{
									{
										Raw: []byte(`"session"`),
									},
									{
										Raw: []byte(`"transaction"`),
									},
								},
							},
							"connection_pooler_number_of_instances": {
								Type:    "integer",
								Minimum: &min1,
							},
							"connection_pooler_schema": {
								Type: "string",
							},
							"connection_pooler_user": {
								Type: "string",
							},
						},
					},
					"multisite": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"enable": {
								Type: "boolean",
							},
							"site": {
								Type: "string",
							},
							"etcd_host": {
								Type: "string",
							},
							"etcd_user": {
								Type: "string",
							},
							"etcd_password": {
								Type: "string",
							},
							"ttl": {
								Type: "integer",
							},
							"retry_timeout": {
								Type: "integer",
							},
						},
					},
				},
			},
			"status": {
				Type: "object",
				AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
					Schema: &apiextv1.JSONSchemaProps{
						Type: "string",
					},
				},
			},
		},
	},
}

OperatorConfigCRDResourceValidation to check applied manifest parameters

View Source
var PostgresCRDResourceColumns = []apiextv1.CustomResourceColumnDefinition{
	{
		Name:        "Team",
		Type:        "string",
		Description: "Team responsible for Postgres cluster",
		JSONPath:    ".spec.teamId",
	},
	{
		Name:        "Version",
		Type:        "string",
		Description: "PostgreSQL version",
		JSONPath:    ".spec.postgresql.version",
	},
	{
		Name:        "Pods",
		Type:        "integer",
		Description: "Number of Pods per Postgres cluster",
		JSONPath:    ".spec.numberOfInstances",
	},
	{
		Name:        "Volume",
		Type:        "string",
		Description: "Size of the bound volume",
		JSONPath:    ".spec.volume.size",
	},
	{
		Name:        "CPU-Request",
		Type:        "string",
		Description: "Requested CPU for Postgres containers",
		JSONPath:    ".spec.resources.requests.cpu",
	},
	{
		Name:        "Memory-Request",
		Type:        "string",
		Description: "Requested memory for Postgres containers",
		JSONPath:    ".spec.resources.requests.memory",
	},
	{
		Name:     "Age",
		Type:     "date",
		JSONPath: ".metadata.creationTimestamp",
	},
	{
		Name:        "Status",
		Type:        "string",
		Description: "Current sync status of postgresql resource",
		JSONPath:    ".status.PostgresClusterStatus",
	},
}

PostgresCRDResourceColumns definition of AdditionalPrinterColumns for postgresql CRD

View Source
var PostgresCRDResourceValidation = apiextv1.CustomResourceValidation{
	OpenAPIV3Schema: &apiextv1.JSONSchemaProps{
		Type:     "object",
		Required: []string{"kind", "apiVersion", "spec"},
		Properties: map[string]apiextv1.JSONSchemaProps{
			"kind": {
				Type: "string",
				Enum: []apiextv1.JSON{
					{
						Raw: []byte(`"postgresql"`),
					},
				},
			},
			"apiVersion": {
				Type: "string",
				Enum: []apiextv1.JSON{
					{
						Raw: []byte(`"cpo.opensource.cybertec.at/v1"`),
					},
				},
			},
			"spec": {
				Type:     "object",
				Required: []string{"numberOfInstances", "teamId", "postgresql", "volume"},
				Properties: map[string]apiextv1.JSONSchemaProps{
					"additionalVolumes": {
						Type: "array",
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type:     "object",
								Required: []string{"name", "mountPath", "volumeSource"},
								Properties: map[string]apiextv1.JSONSchemaProps{
									"name": {
										Type: "string",
									},
									"mountPath": {
										Type: "string",
									},
									"targetContainers": {
										Type:     "array",
										Nullable: true,
										Items: &apiextv1.JSONSchemaPropsOrArray{
											Schema: &apiextv1.JSONSchemaProps{
												Type: "string",
											},
										},
									},
									"volumeSource": {
										Type:                   "object",
										XPreserveUnknownFields: util.True(),
									},
									"subPath": {
										Type: "string",
									},
								},
							},
						},
					},
					"allowedSourceRanges": {
						Type:     "array",
						Nullable: true,
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type:    "string",
								Pattern: "^(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])\\.(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])\\.(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])\\.(\\d|[1-9]\\d|1\\d\\d|2[0-4]\\d|25[0-5])\\/(\\d|[1-2]\\d|3[0-2])$",
							},
						},
					},
					"clone": {
						Type:     "object",
						Required: []string{"cluster"},
						Properties: map[string]apiextv1.JSONSchemaProps{
							"cluster": {
								Type: "string",
							},
							"s3_endpoint": {
								Type: "string",
							},
							"s3_access_key_id": {
								Type: "string",
							},
							"s3_secret_access_key": {
								Type: "string",
							},
							"s3_force_path_style": {
								Type: "boolean",
							},
							"s3_wal_path": {
								Type: "string",
							},
							"timestamp": {
								Type:    "string",
								Pattern: "^([0-9]+)-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])[Tt]([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(\\.[0-9]+)?(([+-]([01][0-9]|2[0-3]):[0-5][0-9]))$",
							},
							"uid": {
								Type:   "string",
								Format: "uuid",
							},
						},
					},
					"connectionPooler": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"dockerImage": {
								Type: "string",
							},
							"maxDBConnections": {
								Type: "integer",
							},
							"mode": {
								Type: "string",
								Enum: []apiextv1.JSON{
									{
										Raw: []byte(`"session"`),
									},
									{
										Raw: []byte(`"transaction"`),
									},
								},
							},
							"numberOfInstances": {
								Type:    "integer",
								Minimum: &min1,
							},
							"resources": {
								Type: "object",
								Properties: map[string]apiextv1.JSONSchemaProps{
									"limits": {
										Type: "object",
										Properties: map[string]apiextv1.JSONSchemaProps{
											"cpu": {
												Type:    "string",
												Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
											},
											"memory": {
												Type:    "string",
												Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
											},
										},
									},
									"requests": {
										Type: "object",
										Properties: map[string]apiextv1.JSONSchemaProps{
											"cpu": {
												Type:    "string",
												Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
											},
											"memory": {
												Type:    "string",
												Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
											},
										},
									},
								},
							},
							"schema": {
								Type: "string",
							},
							"user": {
								Type: "string",
							},
						},
					},
					"databases": {
						Type: "object",
						AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "string",
							},
						},
					},
					"dockerImage": {
						Type: "string",
					},
					"enableConnectionPooler": {
						Type: "boolean",
					},
					"enableReplicaConnectionPooler": {
						Type: "boolean",
					},
					"enableLogicalBackup": {
						Type: "boolean",
					},
					"enableMasterLoadBalancer": {
						Type: "boolean",
					},
					"enableMasterPoolerLoadBalancer": {
						Type: "boolean",
					},
					"enableReplicaLoadBalancer": {
						Type: "boolean",
					},
					"enableReplicaPoolerLoadBalancer": {
						Type: "boolean",
					},
					"enableShmVolume": {
						Type: "boolean",
					},
					"env": {
						Type:     "array",
						Nullable: true,
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type:                   "object",
								XPreserveUnknownFields: util.True(),
							},
						},
					},
					"init_containers": {
						Type:        "array",
						Description: "deprecated",
						Nullable:    true,
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type:                   "object",
								XPreserveUnknownFields: util.True(),
							},
						},
					},
					"initContainers": {
						Type:     "array",
						Nullable: true,
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type:                   "object",
								XPreserveUnknownFields: util.True(),
							},
						},
					},

					"topologySpreadConstraints": {
						Type:     "array",
						Nullable: true,
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type:                   "object",
								XPreserveUnknownFields: util.True(),
							},
						},
					},
					"logicalBackupSchedule": {
						Type:    "string",
						Pattern: "^(\\d+|\\*)(/\\d+)?(\\s+(\\d+|\\*)(/\\d+)?){4}$",
					},
					"maintenanceWindows": {
						Type: "array",
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type:    "string",
								Pattern: "^\\ *((Mon|Tue|Wed|Thu|Fri|Sat|Sun):(2[0-3]|[01]?\\d):([0-5]?\\d)|(2[0-3]|[01]?\\d):([0-5]?\\d))-((Mon|Tue|Wed|Thu|Fri|Sat|Sun):(2[0-3]|[01]?\\d):([0-5]?\\d)|(2[0-3]|[01]?\\d):([0-5]?\\d))\\ *$",
							},
						},
					},
					"masterServiceAnnotations": {
						Type: "object",
						AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "string",
							},
						},
					},
					"nodeAffinity": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"preferredDuringSchedulingIgnoredDuringExecution": {
								Type: "array",
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type:     "object",
										Required: []string{"preference", "weight"},
										Properties: map[string]apiextv1.JSONSchemaProps{
											"preference": {
												Type: "object",
												Properties: map[string]apiextv1.JSONSchemaProps{
													"matchExpressions": {
														Type: "array",
														Items: &apiextv1.JSONSchemaPropsOrArray{
															Schema: &apiextv1.JSONSchemaProps{
																Type:     "object",
																Required: []string{"key", "operator"},
																Properties: map[string]apiextv1.JSONSchemaProps{
																	"key": {
																		Type: "string",
																	},
																	"operator": {
																		Type: "string",
																	},
																	"values": {
																		Type: "array",
																		Items: &apiextv1.JSONSchemaPropsOrArray{
																			Schema: &apiextv1.JSONSchemaProps{
																				Type: "string",
																			},
																		},
																	},
																},
															},
														},
													},
													"matchFields": {
														Type: "array",
														Items: &apiextv1.JSONSchemaPropsOrArray{
															Schema: &apiextv1.JSONSchemaProps{
																Type:     "object",
																Required: []string{"key", "operator"},
																Properties: map[string]apiextv1.JSONSchemaProps{
																	"key": {
																		Type: "string",
																	},
																	"operator": {
																		Type: "string",
																	},
																	"values": {
																		Type: "array",
																		Items: &apiextv1.JSONSchemaPropsOrArray{
																			Schema: &apiextv1.JSONSchemaProps{
																				Type: "string",
																			},
																		},
																	},
																},
															},
														},
													},
												},
											},
											"weight": {
												Type:   "integer",
												Format: "int32",
											},
										},
									},
								},
							},
							"requiredDuringSchedulingIgnoredDuringExecution": {
								Type:     "object",
								Required: []string{"nodeSelectorTerms"},
								Properties: map[string]apiextv1.JSONSchemaProps{
									"nodeSelectorTerms": {
										Type: "array",
										Items: &apiextv1.JSONSchemaPropsOrArray{
											Schema: &apiextv1.JSONSchemaProps{
												Type: "object",
												Properties: map[string]apiextv1.JSONSchemaProps{
													"matchExpressions": {
														Type: "array",
														Items: &apiextv1.JSONSchemaPropsOrArray{
															Schema: &apiextv1.JSONSchemaProps{
																Type:     "object",
																Required: []string{"key", "operator"},
																Properties: map[string]apiextv1.JSONSchemaProps{
																	"key": {
																		Type: "string",
																	},
																	"operator": {
																		Type: "string",
																	},
																	"values": {
																		Type: "array",
																		Items: &apiextv1.JSONSchemaPropsOrArray{
																			Schema: &apiextv1.JSONSchemaProps{
																				Type: "string",
																			},
																		},
																	},
																},
															},
														},
													},
													"matchFields": {
														Type: "array",
														Items: &apiextv1.JSONSchemaPropsOrArray{
															Schema: &apiextv1.JSONSchemaProps{
																Type:     "object",
																Required: []string{"key", "operator"},
																Properties: map[string]apiextv1.JSONSchemaProps{
																	"key": {
																		Type: "string",
																	},
																	"operator": {
																		Type: "string",
																	},
																	"values": {
																		Type: "array",
																		Items: &apiextv1.JSONSchemaPropsOrArray{
																			Schema: &apiextv1.JSONSchemaProps{
																				Type: "string",
																			},
																		},
																	},
																},
															},
														},
													},
												},
											},
										},
									},
								},
							},
						},
					},
					"numberOfInstances": {
						Type:    "integer",
						Minimum: &min0,
					},
					"patroni": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"failsafe_mode": {
								Type: "boolean",
							},
							"initdb": {
								Type: "object",
								AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"loop_wait": {
								Type: "integer",
							},
							"maximum_lag_on_failover": {
								Type: "integer",
							},
							"multisite": {
								Type: "object",
								Properties: map[string]apiextv1.JSONSchemaProps{
									"enable": {
										Type: "boolean",
									},
									"site": {
										Type: "string",
									},
									"etcd": {
										Type: "object",
										Properties: map[string]apiextv1.JSONSchemaProps{
											"hosts": {
												Type: "string",
											},
											"user": {
												Type: "string",
											},
											"password": {
												Type: "string",
											},
											"protocol": {
												Type: "string",
											},
										},
									},
									"ttl": {
										Type: "integer",
									},
									"retry_timeout": {
										Type: "integer",
									},
								},
							},
							"pg_hba": {
								Type: "array",
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
							"retry_timeout": {
								Type: "integer",
							},
							"slots": {
								Type: "object",
								AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "object",
										AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
											Schema: &apiextv1.JSONSchemaProps{
												Type: "string",
											},
										},
									},
								},
							},
							"synchronous_mode": {
								Type: "boolean",
							},
							"synchronous_mode_strict": {
								Type: "boolean",
							},
							"synchronous_node_count": {
								Type: "integer",
							},
							"ttl": {
								Type: "integer",
							},
						},
					},
					"podAnnotations": {
						Type: "object",
						AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "string",
							},
						},
					},
					"pod_priority_class_name": {
						Type:        "string",
						Description: "deprecated",
					},
					"podPriorityClassName": {
						Type: "string",
					},
					"postgresql": {
						Type:     "object",
						Required: []string{"version"},
						Properties: map[string]apiextv1.JSONSchemaProps{
							"version": {
								Type: "string",
								Enum: []apiextv1.JSON{
									{
										Raw: []byte(`"12"`),
									},
									{
										Raw: []byte(`"13"`),
									},
									{
										Raw: []byte(`"14"`),
									},
									{
										Raw: []byte(`"15"`),
									},
									{
										Raw: []byte(`"16"`),
									},
									{
										Raw: []byte(`"17"`),
									},
								},
							},
							"parameters": {
								Type: "object",
								AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
									},
								},
							},
						},
					},
					"preparedDatabases": {
						Type: "object",
						AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "object",
								Properties: map[string]apiextv1.JSONSchemaProps{
									"defaultUsers": {
										Type: "boolean",
									},
									"extensions": {
										Type: "object",
										AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
											Schema: &apiextv1.JSONSchemaProps{
												Type: "string",
											},
										},
									},
									"schemas": {
										Type: "object",
										AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
											Schema: &apiextv1.JSONSchemaProps{
												Type: "object",
												Properties: map[string]apiextv1.JSONSchemaProps{
													"defaultUsers": {
														Type: "boolean",
													},
													"defaultRoles": {
														Type: "boolean",
													},
												},
											},
										},
									},
									"secretNamespace": {
										Type: "string",
									},
								},
							},
						},
					},
					"replicaLoadBalancer": {
						Type:        "boolean",
						Description: "deprecated",
					},
					"replicaServiceAnnotations": {
						Type: "object",
						AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "string",
							},
						},
					},
					"resources": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"limits": {
								Type: "object",
								Properties: map[string]apiextv1.JSONSchemaProps{
									"cpu": {
										Type:    "string",
										Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
									},
									"memory": {
										Type:    "string",
										Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
									},
								},
							},
							"requests": {
								Type: "object",
								Properties: map[string]apiextv1.JSONSchemaProps{
									"cpu": {
										Type:    "string",
										Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
									},
									"memory": {
										Type:    "string",
										Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
									},
								},
							},
						},
					},
					"schedulerName": {
						Type: "string",
					},
					"serviceAnnotations": {
						Type: "object",
						AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "string",
							},
						},
					},
					"sidecars": {
						Type:     "array",
						Nullable: true,
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type:                   "object",
								XPreserveUnknownFields: util.True(),
							},
						},
					},
					"spiloRunAsUser": {
						Type: "integer",
					},
					"spiloRunAsGroup": {
						Type: "integer",
					},
					"spiloFSGroup": {
						Type: "integer",
					},
					"standby": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"s3_wal_path": {
								Type: "string",
							},
							"gs_wal_path": {
								Type: "string",
							},
							"standby_host": {
								Type: "string",
							},
							"standby_port": {
								Type: "string",
							},
						},
						OneOf: []apiextv1.JSONSchemaProps{
							apiextv1.JSONSchemaProps{Required: []string{"s3_wal_path"}},
							apiextv1.JSONSchemaProps{Required: []string{"gs_wal_path"}},
							apiextv1.JSONSchemaProps{Required: []string{"standby_host"}},
						},
					},
					"streams": {
						Type: "array",
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type:     "object",
								Required: []string{"applicationId", "database", "tables"},
								Properties: map[string]apiextv1.JSONSchemaProps{
									"applicationId": {
										Type: "string",
									},
									"batchSize": {
										Type: "integer",
									},
									"database": {
										Type: "string",
									},
									"enableRecovery": {
										Type: "boolean",
									},
									"filter": {
										Type: "object",
										AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
											Schema: &apiextv1.JSONSchemaProps{
												Type: "string",
											},
										},
									},
									"tables": {
										Type: "object",
										AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
											Schema: &apiextv1.JSONSchemaProps{
												Type:     "object",
												Required: []string{"eventType"},
												Properties: map[string]apiextv1.JSONSchemaProps{
													"eventType": {
														Type: "string",
													},
													"idColumn": {
														Type: "string",
													},
													"payloadColumn": {
														Type: "string",
													},
													"recoveryEventType": {
														Type: "string",
													},
												},
											},
										},
									},
								},
							},
						},
					},
					"teamId": {
						Type: "string",
					},
					"tls": {
						Type:     "object",
						Required: []string{"secretName"},
						Properties: map[string]apiextv1.JSONSchemaProps{
							"secretName": {
								Type: "string",
							},
							"certificateFile": {
								Type: "string",
							},
							"privateKeyFile": {
								Type: "string",
							},
							"caFile": {
								Type: "string",
							},
							"caSecretName": {
								Type: "string",
							},
						},
					},
					"tolerations": {
						Type: "array",
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "object",
								Properties: map[string]apiextv1.JSONSchemaProps{
									"key": {
										Type: "string",
									},
									"operator": {
										Type: "string",
										Enum: []apiextv1.JSON{
											{
												Raw: []byte(`"Equal"`),
											},
											{
												Raw: []byte(`"Exists"`),
											},
										},
									},
									"value": {
										Type: "string",
									},
									"effect": {
										Type: "string",
										Enum: []apiextv1.JSON{
											{
												Raw: []byte(`"NoExecute"`),
											},
											{
												Raw: []byte(`"NoSchedule"`),
											},
											{
												Raw: []byte(`"PreferNoSchedule"`),
											},
										},
									},
									"tolerationSeconds": {
										Type: "integer",
									},
								},
							},
						},
					},
					"useLoadBalancer": {
						Type:        "boolean",
						Description: "deprecated",
					},
					"users": {
						Type: "object",
						AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
							Schema: &apiextv1.JSONSchemaProps{
								Type:     "array",
								Nullable: true,
								Items: &apiextv1.JSONSchemaPropsOrArray{
									Schema: &apiextv1.JSONSchemaProps{
										Type: "string",
										Enum: []apiextv1.JSON{
											{
												Raw: []byte(`"bypassrls"`),
											},
											{
												Raw: []byte(`"BYPASSRLS"`),
											},
											{
												Raw: []byte(`"nobypassrls"`),
											},
											{
												Raw: []byte(`"NOBYPASSRLS"`),
											},
											{
												Raw: []byte(`"createdb"`),
											},
											{
												Raw: []byte(`"CREATEDB"`),
											},
											{
												Raw: []byte(`"nocreatedb"`),
											},
											{
												Raw: []byte(`"NOCREATEDB"`),
											},
											{
												Raw: []byte(`"createrole"`),
											},
											{
												Raw: []byte(`"CREATEROLE"`),
											},
											{
												Raw: []byte(`"nocreaterole"`),
											},
											{
												Raw: []byte(`"NOCREATEROLE"`),
											},
											{
												Raw: []byte(`"inherit"`),
											},
											{
												Raw: []byte(`"INHERIT"`),
											},
											{
												Raw: []byte(`"noinherit"`),
											},
											{
												Raw: []byte(`"NOINHERIT"`),
											},
											{
												Raw: []byte(`"login"`),
											},
											{
												Raw: []byte(`"LOGIN"`),
											},
											{
												Raw: []byte(`"nologin"`),
											},
											{
												Raw: []byte(`"NOLOGIN"`),
											},
											{
												Raw: []byte(`"replication"`),
											},
											{
												Raw: []byte(`"REPLICATION"`),
											},
											{
												Raw: []byte(`"noreplication"`),
											},
											{
												Raw: []byte(`"NOREPLICATION"`),
											},
											{
												Raw: []byte(`"superuser"`),
											},
											{
												Raw: []byte(`"SUPERUSER"`),
											},
											{
												Raw: []byte(`"nosuperuser"`),
											},
											{
												Raw: []byte(`"NOSUPERUSER"`),
											},
										},
									},
								},
							},
						},
					},
					"usersWithInPlaceSecretRotation": {
						Type:     "array",
						Nullable: true,
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "string",
							},
						},
					},
					"usersWithSecretRotation": {
						Type:     "array",
						Nullable: true,
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "string",
							},
						},
					},
					"volume": {
						Type:     "object",
						Required: []string{"size"},
						Properties: map[string]apiextv1.JSONSchemaProps{
							"iops": {
								Type: "integer",
							},
							"selector": {
								Type: "object",
								Properties: map[string]apiextv1.JSONSchemaProps{
									"matchExpressions": {
										Type: "array",
										Items: &apiextv1.JSONSchemaPropsOrArray{
											Schema: &apiextv1.JSONSchemaProps{
												Type:     "object",
												Required: []string{"key", "operator"},
												Properties: map[string]apiextv1.JSONSchemaProps{
													"key": {
														Type: "string",
													},
													"operator": {
														Type: "string",
														Enum: []apiextv1.JSON{
															{
																Raw: []byte(`"DoesNotExist"`),
															},
															{
																Raw: []byte(`"Exists"`),
															},
															{
																Raw: []byte(`"In"`),
															},
															{
																Raw: []byte(`"NotIn"`),
															},
														},
													},
													"values": {
														Type: "array",
														Items: &apiextv1.JSONSchemaPropsOrArray{
															Schema: &apiextv1.JSONSchemaProps{
																Type: "string",
															},
														},
													},
												},
											},
										},
									},
									"matchLabels": {
										Type:                   "object",
										XPreserveUnknownFields: util.True(),
									},
								},
							},
							"size": {
								Type:    "string",
								Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
							},
							"storageClass": {
								Type: "string",
							},
							"subPath": {
								Type: "string",
							},
							"throughput": {
								Type: "integer",
							},
						},
					},
					"backup": {
						Type: "object",
						Properties: map[string]apiextv1.JSONSchemaProps{
							"pgbackrest": {
								Type:     "object",
								Required: []string{"image", "repos"},
								Properties: map[string]apiextv1.JSONSchemaProps{
									"image": {
										Type: "string",
									},
									"configuration": {
										Type: "object",
										Properties: map[string]apiextv1.JSONSchemaProps{
											"secret": {
												Type: "string",
											},
											"protection": {
												Type: "object",
												Properties: map[string]apiextv1.JSONSchemaProps{
													"restore": {
														Type: "boolean",
													},
												},
											},
										},
									},
									"global": {
										Type: "object",
										AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
											Schema: &apiextv1.JSONSchemaProps{
												Type: "string",
											},
										},
									},
									"repos": {
										Type:         "array",
										Nullable:     true,
										MinItems:     &min1int64,
										XListType:    &mapString,
										XListMapKeys: []string{"name"},
										Items: &apiextv1.JSONSchemaPropsOrArray{
											Schema: &apiextv1.JSONSchemaProps{
												Type:     "object",
												Required: []string{"name", "storage"},
												Properties: map[string]apiextv1.JSONSchemaProps{
													"name": {
														Type:    "string",
														Pattern: "^repo[1-4]$",
													},
													"storage": {
														Type: "string",
														Enum: []apiextv1.JSON{
															{
																Raw: []byte(`"s3"`),
															},
															{
																Raw: []byte(`"gcs"`),
															},
															{
																Raw: []byte(`"azure"`),
															},
															{
																Raw: []byte(`"pvc"`),
															},
														},
													},
													"resource": {
														Type: "string",
													},
													"endpoint": {
														Type: "string",
													},
													"region": {
														Type: "string",
													},
													"account": {
														Type: "string",
													},
													"key": {
														Type: "string",
													},
													"keyType": {
														Type: "string",
													},
													"schedule": {
														Type: "object",
														Properties: map[string]apiextv1.JSONSchemaProps{
															"full": {
																Type: "string",
															},
															"incr": {
																Type: "string",
															},
															"diff": {
																Type: "string",
															},
														},
													},
													"volume": {
														Type:     "object",
														Required: []string{"size"},
														Properties: map[string]apiextv1.JSONSchemaProps{
															"iops": {
																Type: "integer",
															},
															"selector": {
																Type: "object",
																Properties: map[string]apiextv1.JSONSchemaProps{
																	"matchExpressions": {
																		Type: "array",
																		Items: &apiextv1.JSONSchemaPropsOrArray{
																			Schema: &apiextv1.JSONSchemaProps{
																				Type:     "object",
																				Required: []string{"key", "operator"},
																				Properties: map[string]apiextv1.JSONSchemaProps{
																					"key": {
																						Type: "string",
																					},
																					"operator": {
																						Type: "string",
																						Enum: []apiextv1.JSON{
																							{
																								Raw: []byte(`"DoesNotExist"`),
																							},
																							{
																								Raw: []byte(`"Exists"`),
																							},
																							{
																								Raw: []byte(`"In"`),
																							},
																							{
																								Raw: []byte(`"NotIn"`),
																							},
																						},
																					},
																					"values": {
																						Type: "array",
																						Items: &apiextv1.JSONSchemaPropsOrArray{
																							Schema: &apiextv1.JSONSchemaProps{
																								Type: "string",
																							},
																						},
																					},
																				},
																			},
																		},
																	},
																	"matchLabels": {
																		Type:                   "object",
																		XPreserveUnknownFields: util.True(),
																	},
																},
															},
															"size": {
																Type:    "string",
																Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
															},
															"storageClass": {
																Type: "string",
															},
															"subPath": {
																Type: "string",
															},
															"throughput": {
																Type: "integer",
															},
														},
													},
												},
											},
										},
									},
									"restore": {
										Type: "object",
										Properties: map[string]apiextv1.JSONSchemaProps{
											"id": {
												Type: "string",
											},
											"repo": {
												Type:    "string",
												Pattern: "^repo[1-4]$",
											},
											"options": {
												Type: "object",
												AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
													Schema: &apiextv1.JSONSchemaProps{
														Type: "string",
													},
												},
											},
										},
									},
									"resources": {
										Type: "object",
										Properties: map[string]apiextv1.JSONSchemaProps{
											"limits": {
												Type: "object",
												Properties: map[string]apiextv1.JSONSchemaProps{
													"cpu": {
														Type:    "string",
														Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
													},
													"memory": {
														Type:    "string",
														Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
													},
												},
											},
											"requests": {
												Type: "object",
												Properties: map[string]apiextv1.JSONSchemaProps{
													"cpu": {
														Type:    "string",
														Pattern: "^(\\d+m|\\d+(\\.\\d{1,3})?)$",
													},
													"memory": {
														Type:    "string",
														Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
													},
												},
											},
										},
									},
								},
							},
						},
					},
					"tde": {
						Type:     "object",
						Nullable: true,
						Properties: map[string]apiextv1.JSONSchemaProps{
							"enable": {
								Type: "boolean",
							},
						},
					},
					"monitor": {
						Type:     "object",
						Nullable: true,
						Properties: map[string]apiextv1.JSONSchemaProps{
							"image": {
								Type: "string",
							},
						},
					},
				},
			},
			"status": {
				Type: "object",
				AdditionalProperties: &apiextv1.JSONSchemaPropsOrBool{
					Schema: &apiextv1.JSONSchemaProps{
						Type: "string",
					},
				},
			},
		},
	},
}

PostgresCRDResourceValidation to check applied manifest parameters

Functions

func ConfigurationCRD

func ConfigurationCRD(crdCategories []string) *apiextv1.CustomResourceDefinition

ConfigurationCRD returns CustomResourceDefinition built from OperatorConfigCRDResource

func ExtractClusterName

func ExtractClusterName(clusterName string, teamName string) (string, error)

func PostgresCRD

func PostgresCRD(crdCategories []string) *apiextv1.CustomResourceDefinition

PostgresCRD returns CustomResourceDefinition built from PostgresCRDResource

func Resource

func Resource(resource string) schema.GroupResource

Resource takes an unqualified resource and returns a Group qualified GroupResource

Types

type AWSGCPConfiguration

type AWSGCPConfiguration struct {
	WALES3Bucket                 string `json:"wal_s3_bucket,omitempty"`
	AWSRegion                    string `json:"aws_region,omitempty"`
	WALGSBucket                  string `json:"wal_gs_bucket,omitempty"`
	GCPCredentials               string `json:"gcp_credentials,omitempty"`
	WALAZStorageAccount          string `json:"wal_az_storage_account,omitempty"`
	LogS3Bucket                  string `json:"log_s3_bucket,omitempty"`
	KubeIAMRole                  string `json:"kube_iam_role,omitempty"`
	AdditionalSecretMount        string `json:"additional_secret_mount,omitempty"`
	AdditionalSecretMountPath    string `json:"additional_secret_mount_path" default:"/meta/credentials"`
	EnableEBSGp3Migration        bool   `json:"enable_ebs_gp3_migration" default:"false"`
	EnableEBSGp3MigrationMaxSize int64  `json:"enable_ebs_gp3_migration_max_size" default:"1000"`
}

AWSGCPConfiguration defines the configuration for AWS TODO complete Google Cloud Platform (GCP) configuration

func (*AWSGCPConfiguration) DeepCopy

func (in *AWSGCPConfiguration) DeepCopy() *AWSGCPConfiguration

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AWSGCPConfiguration.

func (*AWSGCPConfiguration) DeepCopyInto

func (in *AWSGCPConfiguration) DeepCopyInto(out *AWSGCPConfiguration)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AdditionalVolume

type AdditionalVolume struct {
	Name             string          `json:"name"`
	MountPath        string          `json:"mountPath"`
	SubPath          string          `json:"subPath,omitempty"`
	TargetContainers []string        `json:"targetContainers"`
	VolumeSource     v1.VolumeSource `json:"volumeSource"`
}

AdditionalVolume specs additional optional volumes for statefulset

func (*AdditionalVolume) DeepCopy

func (in *AdditionalVolume) DeepCopy() *AdditionalVolume

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AdditionalVolume.

func (*AdditionalVolume) DeepCopyInto

func (in *AdditionalVolume) DeepCopyInto(out *AdditionalVolume)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Backup

type Backup struct {
	Pgbackrest *Pgbackrest `json:"pgbackrest"`
}

func (*Backup) DeepCopy

func (in *Backup) DeepCopy() *Backup

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Backup.

func (*Backup) DeepCopyInto

func (in *Backup) DeepCopyInto(out *Backup)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Backup) GetRestoreID

func (b *Backup) GetRestoreID() string

Returns currently specified restore ID or empty string if restore is not specified.

type CloneDescription

type CloneDescription struct {
	ClusterName       string `json:"cluster,omitempty"`
	UID               string `json:"uid,omitempty"`
	EndTimestamp      string `json:"timestamp,omitempty"`
	S3WalPath         string `json:"s3_wal_path,omitempty"`
	S3Endpoint        string `json:"s3_endpoint,omitempty"`
	S3AccessKeyId     string `json:"s3_access_key_id,omitempty"`
	S3SecretAccessKey string `json:"s3_secret_access_key,omitempty"`
	S3ForcePathStyle  *bool  `json:"s3_force_path_style,omitempty" defaults:"false"`
}

CloneDescription describes which cluster the new should clone and up to which point in time

func (*CloneDescription) DeepCopy

func (in *CloneDescription) DeepCopy() *CloneDescription

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CloneDescription.

func (*CloneDescription) DeepCopyInto

func (in *CloneDescription) DeepCopyInto(out *CloneDescription)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Configuration

type Configuration struct {
	Secret string `json:"secret"`
}

func (*Configuration) DeepCopy

func (in *Configuration) DeepCopy() *Configuration

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Configuration.

func (*Configuration) DeepCopyInto

func (in *Configuration) DeepCopyInto(out *Configuration)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ConnectionPooler

type ConnectionPooler struct {
	NumberOfInstances *int32 `json:"numberOfInstances,omitempty"`
	Schema            string `json:"schema,omitempty"`
	User              string `json:"user,omitempty"`
	Mode              string `json:"mode,omitempty"`
	DockerImage       string `json:"dockerImage,omitempty"`
	MaxDBConnections  *int32 `json:"maxDBConnections,omitempty"`

	*Resources `json:"resources,omitempty"`
}

ConnectionPooler Options for connection pooler

TODO: prepared snippets of configuration, one can choose via type, e.g. pgbouncer-large (with higher resources) or odyssey-small (with smaller resources) Type string `json:"type,omitempty"`

TODO: figure out what other important parameters of the connection pooler it makes sense to expose. E.g. pool size (min/max boundaries), max client connections etc.

func (*ConnectionPooler) DeepCopy

func (in *ConnectionPooler) DeepCopy() *ConnectionPooler

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ConnectionPooler.

func (*ConnectionPooler) DeepCopyInto

func (in *ConnectionPooler) DeepCopyInto(out *ConnectionPooler)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ConnectionPoolerConfiguration

type ConnectionPoolerConfiguration struct {
	NumberOfInstances    *int32 `json:"connection_pooler_number_of_instances,omitempty"`
	Schema               string `json:"connection_pooler_schema,omitempty"`
	User                 string `json:"connection_pooler_user,omitempty"`
	Image                string `json:"connection_pooler_image,omitempty"`
	Mode                 string `json:"connection_pooler_mode,omitempty"`
	MaxDBConnections     *int32 `json:"connection_pooler_max_db_connections,omitempty"`
	DefaultCPURequest    string `json:"connection_pooler_default_cpu_request,omitempty"`
	DefaultMemoryRequest string `json:"connection_pooler_default_memory_request,omitempty"`
	DefaultCPULimit      string `json:"connection_pooler_default_cpu_limit,omitempty"`
	DefaultMemoryLimit   string `json:"connection_pooler_default_memory_limit,omitempty"`
}

ConnectionPoolerConfiguration defines default configuration for connection pooler

func (*ConnectionPoolerConfiguration) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ConnectionPoolerConfiguration.

func (*ConnectionPoolerConfiguration) DeepCopyInto

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Duration

type Duration time.Duration

Duration shortens this frequently used name

func (*Duration) UnmarshalJSON

func (d *Duration) UnmarshalJSON(b []byte) error

UnmarshalJSON convert to Duration from byte slice of json

type EtcdConfig added in v0.8.0

type EtcdConfig struct {
	Hosts    *string `json:"hosts,omitempty"`
	User     *string `json:"user,omitempty"`
	Password *string `json:"password,omitempty"`
	Protocol *string `json:"protocol,omitempty"`
}

func (*EtcdConfig) DeepCopy added in v0.8.0

func (in *EtcdConfig) DeepCopy() *EtcdConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EtcdConfig.

func (*EtcdConfig) DeepCopyInto added in v0.8.0

func (in *EtcdConfig) DeepCopyInto(out *EtcdConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type KubernetesMetaConfiguration

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"`
	SpiloPrivileged                        bool                         `json:"spilo_privileged,omitempty"`
	SpiloAllowPrivilegeEscalation          *bool                        `json:"spilo_allow_privilege_escalation,omitempty"`
	SpiloRunAsUser                         *int64                       `json:"spilo_runasuser,omitempty"`
	SpiloRunAsGroup                        *int64                       `json:"spilo_runasgroup,omitempty"`
	SpiloFSGroup                           *int64                       `json:"spilo_fsgroup,omitempty"`
	AdditionalPodCapabilities              []string                     `json:"additional_pod_capabilities,omitempty"`
	WatchedNamespace                       string                       `json:"watched_namespace,omitempty"`
	PDBNameFormat                          config.StringTemplate        `json:"pdb_name_format,omitempty"`
	EnablePodDisruptionBudget              *bool                        `json:"enable_pod_disruption_budget,omitempty"`
	StorageResizeMode                      string                       `json:"storage_resize_mode,omitempty"`
	EnableInitContainers                   *bool                        `json:"enable_init_containers,omitempty"`
	EnableSidecars                         *bool                        `json:"enable_sidecars,omitempty"`
	SharePgSocketWithSidecars              *bool                        `json:"share_pgsocket_with_sidecars,omitempty"`
	SecretNameTemplate                     config.StringTemplate        `json:"secret_name_template,omitempty"`
	ClusterDomain                          string                       `json:"cluster_domain,omitempty"`
	OAuthTokenSecretName                   spec.NamespacedName          `json:"oauth_token_secret_name,omitempty"`
	InfrastructureRolesSecretName          spec.NamespacedName          `json:"infrastructure_roles_secret_name,omitempty"`
	InfrastructureRolesDefs                []*config.InfrastructureRole `json:"infrastructure_roles_secrets,omitempty"`
	PodRoleLabel                           string                       `json:"pod_role_label,omitempty"`
	ClusterLabels                          map[string]string            `json:"cluster_labels,omitempty"`
	InheritedLabels                        []string                     `json:"inherited_labels,omitempty"`
	InheritedAnnotations                   []string                     `json:"inherited_annotations,omitempty"`
	DownscalerAnnotations                  []string                     `json:"downscaler_annotations,omitempty"`
	IgnoredAnnotations                     []string                     `json:"ignored_annotations,omitempty"`
	ClusterNameLabel                       string                       `json:"cluster_name_label,omitempty"`
	DeleteAnnotationDateKey                string                       `json:"delete_annotation_date_key,omitempty"`
	DeleteAnnotationNameKey                string                       `json:"delete_annotation_name_key,omitempty"`
	NodeReadinessLabel                     map[string]string            `json:"node_readiness_label,omitempty"`
	NodeReadinessLabelMerge                string                       `json:"node_readiness_label_merge,omitempty"`
	CustomPodAnnotations                   map[string]string            `json:"custom_pod_annotations,omitempty"`
	// TODO: use a proper toleration structure?
	PodToleration                            map[string]string   `json:"toleration,omitempty"`
	PodEnvironmentConfigMap                  spec.NamespacedName `json:"pod_environment_configmap,omitempty"`
	PodEnvironmentSecret                     string              `json:"pod_environment_secret,omitempty"`
	PodPriorityClassName                     string              `json:"pod_priority_class_name,omitempty"`
	MasterPodMoveTimeout                     Duration            `json:"master_pod_move_timeout,omitempty"`
	EnablePodAntiAffinity                    bool                `json:"enable_pod_antiaffinity,omitempty"`
	PodAntiAffinityPreferredDuringScheduling bool                `json:"pod_antiaffinity_preferred_during_scheduling,omitempty"`
	PodAntiAffinityTopologyKey               string              `json:"pod_antiaffinity_topology_key,omitempty"`
	PodManagementPolicy                      string              `json:"pod_management_policy,omitempty"`
	PersistentVolumeClaimRetentionPolicy     map[string]string   `json:"persistent_volume_claim_retention_policy,omitempty"`
	EnableReadinessProbe                     bool                `json:"enable_readiness_probe,omitempty"`
	EnableCrossNamespaceSecret               bool                `json:"enable_cross_namespace_secret,omitempty"`
}

KubernetesMetaConfiguration defines k8s conf required for all Postgres clusters and the operator itself

func (*KubernetesMetaConfiguration) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new KubernetesMetaConfiguration.

func (*KubernetesMetaConfiguration) DeepCopyInto

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LoadBalancerConfiguration

type LoadBalancerConfiguration struct {
	DbHostedZone                    string                `json:"db_hosted_zone,omitempty"`
	EnableMasterLoadBalancer        bool                  `json:"enable_master_load_balancer,omitempty"`
	EnableMasterPoolerLoadBalancer  bool                  `json:"enable_master_pooler_load_balancer,omitempty"`
	EnableReplicaLoadBalancer       bool                  `json:"enable_replica_load_balancer,omitempty"`
	EnableReplicaPoolerLoadBalancer bool                  `json:"enable_replica_pooler_load_balancer,omitempty"`
	CustomServiceAnnotations        map[string]string     `json:"custom_service_annotations,omitempty"`
	MasterDNSNameFormat             config.StringTemplate `json:"master_dns_name_format,omitempty"`
	MasterLegacyDNSNameFormat       config.StringTemplate `json:"master_legacy_dns_name_format,omitempty"`
	ReplicaDNSNameFormat            config.StringTemplate `json:"replica_dns_name_format,omitempty"`
	ReplicaLegacyDNSNameFormat      config.StringTemplate `json:"replica_legacy_dns_name_format,omitempty"`
	ExternalTrafficPolicy           string                `json:"external_traffic_policy" default:"Cluster"`
}

LoadBalancerConfiguration defines the LB configuration

func (*LoadBalancerConfiguration) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoadBalancerConfiguration.

func (*LoadBalancerConfiguration) DeepCopyInto

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LoggingRESTAPIConfiguration

type LoggingRESTAPIConfiguration struct {
	APIPort               int `json:"api_port,omitempty"`
	RingLogLines          int `json:"ring_log_lines,omitempty"`
	ClusterHistoryEntries int `json:"cluster_history_entries,omitempty"`
}

LoggingRESTAPIConfiguration defines Logging API conf

func (*LoggingRESTAPIConfiguration) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LoggingRESTAPIConfiguration.

func (*LoggingRESTAPIConfiguration) DeepCopyInto

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MaintenanceWindow

type MaintenanceWindow struct {
	Everyday  bool         `json:"everyday,omitempty"`
	Weekday   time.Weekday `json:"weekday,omitempty"`
	StartTime metav1.Time  `json:"startTime,omitempty"`
	EndTime   metav1.Time  `json:"endTime,omitempty"`
}

MaintenanceWindow describes the time window when the operator is allowed to do maintenance on a cluster.

func (*MaintenanceWindow) DeepCopy

func (in *MaintenanceWindow) DeepCopy() *MaintenanceWindow

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MaintenanceWindow.

func (*MaintenanceWindow) DeepCopyInto

func (in *MaintenanceWindow) DeepCopyInto(out *MaintenanceWindow)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*MaintenanceWindow) MarshalJSON

func (m *MaintenanceWindow) MarshalJSON() ([]byte, error)

MarshalJSON converts a maintenance window definition to JSON.

func (*MaintenanceWindow) UnmarshalJSON

func (m *MaintenanceWindow) UnmarshalJSON(data []byte) error

UnmarshalJSON converts a JSON to the maintenance window definition.

type MajorVersionUpgradeConfiguration

type MajorVersionUpgradeConfiguration struct {
	MajorVersionUpgradeMode          string   `json:"major_version_upgrade_mode" default:"off"` // off - no actions, manual - manifest triggers action, full - manifest and minimal version violation trigger upgrade
	MajorVersionUpgradeTeamAllowList []string `json:"major_version_upgrade_team_allow_list,omitempty"`
	MinimalMajorVersion              string   `json:"minimal_major_version" default:"13"`
	TargetMajorVersion               string   `json:"target_major_version" default:"17"`
}

MajorVersionUpgradeConfiguration defines how to execute major version upgrades of Postgres.

func (*MajorVersionUpgradeConfiguration) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MajorVersionUpgradeConfiguration.

func (*MajorVersionUpgradeConfiguration) DeepCopyInto

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Monitoring

type Monitoring struct {
	Image string `json:"image,omitempty"`
}

Monitoring Sidecar defines a container to be run in the same pod as the Postgres container.

func (*Monitoring) DeepCopy

func (in *Monitoring) DeepCopy() *Monitoring

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Monitoring.

func (*Monitoring) DeepCopyInto

func (in *Monitoring) DeepCopyInto(out *Monitoring)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Multisite added in v0.8.0

type Multisite struct {
	Enable       *bool      `json:"enable,omitempty"`
	Site         *string    `json:"site,omitempty"`
	Etcd         EtcdConfig `json:"etcd"`
	TTL          *int32     `json:"ttl,omitempty"`
	RetryTimeout *int32     `json:"retry_timeout,omitempty"`
}

Multisite enables cross Kubernetes replication coordinated via etcd

func (*Multisite) DeepCopy added in v0.8.0

func (in *Multisite) DeepCopy() *Multisite

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Multisite.

func (*Multisite) DeepCopyInto added in v0.8.0

func (in *Multisite) DeepCopyInto(out *Multisite)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OperatorConfiguration

type OperatorConfiguration struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata"`

	Configuration OperatorConfigurationData `json:"configuration"`
}

OperatorConfiguration defines the specification for the OperatorConfiguration.

func (*OperatorConfiguration) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorConfiguration.

func (*OperatorConfiguration) DeepCopyInto

func (in *OperatorConfiguration) DeepCopyInto(out *OperatorConfiguration)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*OperatorConfiguration) DeepCopyObject

func (in *OperatorConfiguration) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type OperatorConfigurationData

type OperatorConfigurationData struct {
	EnableCRDRegistration         *bool                              `json:"enable_crd_registration,omitempty"`
	EnableCRDValidation           *bool                              `json:"enable_crd_validation,omitempty"`
	CRDCategories                 []string                           `json:"crd_categories,omitempty"`
	EnableLazySpiloUpgrade        bool                               `json:"enable_lazy_spilo_upgrade,omitempty"`
	EnablePgVersionEnvVar         bool                               `json:"enable_pgversion_env_var,omitempty"`
	EnableSpiloWalPathCompat      bool                               `json:"enable_spilo_wal_path_compat,omitempty"`
	EnableTeamIdClusternamePrefix bool                               `json:"enable_team_id_clustername_prefix,omitempty"`
	EtcdHost                      string                             `json:"etcd_host,omitempty"`
	KubernetesUseConfigMaps       bool                               `json:"kubernetes_use_configmaps,omitempty"`
	DockerImage                   string                             `json:"docker_image,omitempty"`
	Workers                       uint32                             `json:"workers,omitempty"`
	ResyncPeriod                  Duration                           `json:"resync_period,omitempty"`
	RepairPeriod                  Duration                           `json:"repair_period,omitempty"`
	SetMemoryRequestToLimit       bool                               `json:"set_memory_request_to_limit,omitempty"`
	ShmVolume                     *bool                              `json:"enable_shm_volume,omitempty"`
	SidecarImages                 map[string]string                  `json:"sidecar_docker_images,omitempty"` // deprecated in favour of SidecarContainers
	SidecarContainers             []v1.Container                     `json:"sidecars,omitempty"`
	PostgresUsersConfiguration    PostgresUsersConfiguration         `json:"users"`
	MajorVersionUpgrade           MajorVersionUpgradeConfiguration   `json:"major_version_upgrade"`
	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"`
	LogicalBackup                 OperatorLogicalBackupConfiguration `json:"logical_backup"`
	ConnectionPooler              ConnectionPoolerConfiguration      `json:"connection_pooler"`
	Multisite                     Multisite                          `json:"multisite"`
	Patroni                       PatroniConfiguration               `json:"patroni"`

	MinInstances                      int32  `json:"min_instances,omitempty"`
	MaxInstances                      int32  `json:"max_instances,omitempty"`
	IgnoreInstanceLimitsAnnotationKey string `json:"ignore_instance_limits_annotation_key,omitempty"`
}

OperatorConfigurationData defines the operation config

func (*OperatorConfigurationData) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorConfigurationData.

func (*OperatorConfigurationData) DeepCopyInto

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OperatorConfigurationList

type OperatorConfigurationList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`

	Items []OperatorConfiguration `json:"items"`
}

OperatorConfigurationList is used in the k8s API calls

func (*OperatorConfigurationList) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorConfigurationList.

func (*OperatorConfigurationList) DeepCopyInto

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*OperatorConfigurationList) DeepCopyObject

func (in *OperatorConfigurationList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type OperatorDebugConfiguration

type OperatorDebugConfiguration struct {
	DebugLogging   bool `json:"debug_logging,omitempty"`
	EnableDBAccess bool `json:"enable_database_access,omitempty"`
}

OperatorDebugConfiguration defines options for the debug mode

func (*OperatorDebugConfiguration) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorDebugConfiguration.

func (*OperatorDebugConfiguration) DeepCopyInto

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OperatorLogicalBackupConfiguration

type OperatorLogicalBackupConfiguration struct {
	Schedule                     string `json:"logical_backup_schedule,omitempty"`
	DockerImage                  string `json:"logical_backup_docker_image,omitempty"`
	BackupProvider               string `json:"logical_backup_provider,omitempty"`
	AzureStorageAccountName      string `json:"logical_backup_azure_storage_account_name,omitempty"`
	AzureStorageContainer        string `json:"logical_backup_azure_storage_container,omitempty"`
	AzureStorageAccountKey       string `json:"logical_backup_azure_storage_account_key,omitempty"`
	S3Bucket                     string `json:"logical_backup_s3_bucket,omitempty"`
	S3Region                     string `json:"logical_backup_s3_region,omitempty"`
	S3Endpoint                   string `json:"logical_backup_s3_endpoint,omitempty"`
	S3AccessKeyID                string `json:"logical_backup_s3_access_key_id,omitempty"`
	S3SecretAccessKey            string `json:"logical_backup_s3_secret_access_key,omitempty"`
	S3SSE                        string `json:"logical_backup_s3_sse,omitempty"`
	RetentionTime                string `json:"logical_backup_s3_retention_time,omitempty"`
	GoogleApplicationCredentials string `json:"logical_backup_google_application_credentials,omitempty"`
	JobPrefix                    string `json:"logical_backup_job_prefix,omitempty"`
	CPURequest                   string `json:"logical_backup_cpu_request,omitempty"`
	MemoryRequest                string `json:"logical_backup_memory_request,omitempty"`
	CPULimit                     string `json:"logical_backup_cpu_limit,omitempty"`
	MemoryLimit                  string `json:"logical_backup_memory_limit,omitempty"`
}

OperatorLogicalBackupConfiguration defines configuration for logical backup

func (*OperatorLogicalBackupConfiguration) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorLogicalBackupConfiguration.

func (*OperatorLogicalBackupConfiguration) DeepCopyInto

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OperatorTimeouts

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"`
	PatroniAPICheckInterval Duration `json:"patroni_api_check_interval,omitempty"`
	PatroniAPICheckTimeout  Duration `json:"patroni_api_check_timeout,omitempty"`
}

OperatorTimeouts defines the timeout of ResourceCheck, PodWait, ReadyWait

func (*OperatorTimeouts) DeepCopy

func (in *OperatorTimeouts) DeepCopy() *OperatorTimeouts

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OperatorTimeouts.

func (*OperatorTimeouts) DeepCopyInto

func (in *OperatorTimeouts) DeepCopyInto(out *OperatorTimeouts)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Patroni

type Patroni struct {
	InitDB                map[string]string            `json:"initdb,omitempty"`
	PgHba                 []string                     `json:"pg_hba,omitempty"`
	TTL                   uint32                       `json:"ttl,omitempty"`
	LoopWait              uint32                       `json:"loop_wait,omitempty"`
	RetryTimeout          uint32                       `json:"retry_timeout,omitempty"`
	MaximumLagOnFailover  float32                      `json:"maximum_lag_on_failover,omitempty"` // float32 because https://github.com/kubernetes/kubernetes/issues/30213
	Slots                 map[string]map[string]string `json:"slots,omitempty"`
	SynchronousMode       bool                         `json:"synchronous_mode,omitempty"`
	SynchronousModeStrict bool                         `json:"synchronous_mode_strict,omitempty"`
	SynchronousNodeCount  uint32                       `json:"synchronous_node_count,omitempty" defaults:"1"`
	Multisite             *Multisite                   `json:"multisite,omitempty"`
	FailsafeMode          *bool                        `json:"failsafe_mode,omitempty"`
}

Patroni contains Patroni-specific configuration

func (*Patroni) DeepCopy

func (in *Patroni) DeepCopy() *Patroni

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Patroni.

func (*Patroni) DeepCopyInto

func (in *Patroni) DeepCopyInto(out *Patroni)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PatroniConfiguration

type PatroniConfiguration struct {
	FailsafeMode *bool `json:"enable_patroni_failsafe_mode,omitempty"`
}

PatroniConfiguration defines configuration for Patroni

func (*PatroniConfiguration) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PatroniConfiguration.

func (*PatroniConfiguration) DeepCopyInto

func (in *PatroniConfiguration) DeepCopyInto(out *PatroniConfiguration)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Pgbackrest

type Pgbackrest struct {
	Image         string            `json:"image"`
	Global        map[string]string `json:"global"`
	Repos         []Repo            `json:"repos"`
	Restore       Restore           `json:"restore"`
	Configuration Configuration     `json:"configuration"`
	Resources     *Resources        `json:"resources,omitempty"`
}

func (*Pgbackrest) DeepCopy

func (in *Pgbackrest) DeepCopy() *Pgbackrest

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Pgbackrest.

func (*Pgbackrest) DeepCopyInto

func (in *Pgbackrest) DeepCopyInto(out *Pgbackrest)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PostgresPodResourcesDefaults

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"`
	MinCPULimit          string `json:"min_cpu_limit,omitempty"`
	MinMemoryLimit       string `json:"min_memory_limit,omitempty"`
	MaxCPURequest        string `json:"max_cpu_request,omitempty"`
	MaxMemoryRequest     string `json:"max_memory_request,omitempty"`
}

PostgresPodResourcesDefaults defines the spec of default resources

func (*PostgresPodResourcesDefaults) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresPodResourcesDefaults.

func (*PostgresPodResourcesDefaults) DeepCopyInto

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PostgresSpec

type PostgresSpec struct {
	PostgresqlParam `json:"postgresql"`
	Volume          `json:"volume,omitempty"`
	Patroni         `json:"patroni,omitempty"`
	*Resources      `json:"resources,omitempty"`

	EnableConnectionPooler        *bool             `json:"enableConnectionPooler,omitempty"`
	EnableReplicaConnectionPooler *bool             `json:"enableReplicaConnectionPooler,omitempty"`
	ConnectionPooler              *ConnectionPooler `json:"connectionPooler,omitempty"`

	TeamID      string `json:"teamId"`
	DockerImage string `json:"dockerImage,omitempty"`

	// deprecated field storing cluster name without teamId prefix
	ClusterName string `json:"-"`

	SpiloRunAsUser  *int64 `json:"spiloRunAsUser,omitempty"`
	SpiloRunAsGroup *int64 `json:"spiloRunAsGroup,omitempty"`
	SpiloFSGroup    *int64 `json:"spiloFSGroup,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"`
	EnableMasterPoolerLoadBalancer  *bool `json:"enableMasterPoolerLoadBalancer,omitempty"`
	EnableReplicaLoadBalancer       *bool `json:"enableReplicaLoadBalancer,omitempty"`
	EnableReplicaPoolerLoadBalancer *bool `json:"enableReplicaPoolerLoadBalancer,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"`

	Users                          map[string]UserFlags `json:"users,omitempty"`
	UsersWithSecretRotation        []string             `json:"usersWithSecretRotation,omitempty"`
	UsersWithInPlaceSecretRotation []string             `json:"usersWithInPlaceSecretRotation,omitempty"`

	NumberOfInstances         int32                         `json:"numberOfInstances"`
	MaintenanceWindows        []MaintenanceWindow           `json:"maintenanceWindows,omitempty"`
	Clone                     *CloneDescription             `json:"clone,omitempty"`
	Databases                 map[string]string             `json:"databases,omitempty"`
	PreparedDatabases         map[string]PreparedDatabase   `json:"preparedDatabases,omitempty"`
	SchedulerName             *string                       `json:"schedulerName,omitempty"`
	NodeAffinity              *v1.NodeAffinity              `json:"nodeAffinity,omitempty"`
	Tolerations               []v1.Toleration               `json:"tolerations,omitempty"`
	Sidecars                  []Sidecar                     `json:"sidecars,omitempty"`
	InitContainers            []v1.Container                `json:"initContainers,omitempty"`
	TopologySpreadConstraints []v1.TopologySpreadConstraint `` /* 147-byte string literal not displayed */
	PodPriorityClassName      string                        `json:"podPriorityClassName,omitempty"`
	ShmVolume                 *bool                         `json:"enableShmVolume,omitempty"`
	EnableLogicalBackup       bool                          `json:"enableLogicalBackup,omitempty"`
	LogicalBackupSchedule     string                        `json:"logicalBackupSchedule,omitempty"`
	StandbyCluster            *StandbyDescription           `json:"standby,omitempty"`
	PodAnnotations            map[string]string             `json:"podAnnotations,omitempty"`
	ServiceAnnotations        map[string]string             `json:"serviceAnnotations,omitempty"`
	// MasterServiceAnnotations takes precedence over ServiceAnnotations for master role if not empty
	MasterServiceAnnotations map[string]string `json:"masterServiceAnnotations,omitempty"`
	// ReplicaServiceAnnotations takes precedence over ServiceAnnotations for replica role if not empty
	ReplicaServiceAnnotations     map[string]string  `json:"replicaServiceAnnotations,omitempty"`
	ClusterPodsServiceAnnotations map[string]string  `json:"clusterPodsServiceAnnotations,omitempty"`
	TLS                           *TLSDescription    `json:"tls,omitempty"`
	AdditionalVolumes             []AdditionalVolume `json:"additionalVolumes,omitempty"`
	Streams                       []Stream           `json:"streams,omitempty"`
	Env                           []v1.EnvVar        `json:"env,omitempty"`

	// deprecated json tags
	InitContainersOld       []v1.Container `json:"init_containers,omitempty"`
	PodPriorityClassNameOld string         `json:"pod_priority_class_name,omitempty"`
	Backup                  *Backup        `json:"backup,omitempty"`
	TDE                     *TDE           `json:"tde,omitempty"`
	Monitoring              *Monitoring    `json:"monitor,omitempty"`
}

PostgresSpec defines the specification for the PostgreSQL TPR.

func (*PostgresSpec) DeepCopy

func (in *PostgresSpec) DeepCopy() *PostgresSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresSpec.

func (*PostgresSpec) DeepCopyInto

func (in *PostgresSpec) DeepCopyInto(out *PostgresSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*PostgresSpec) GetBackup

func (s *PostgresSpec) GetBackup() *Backup

type PostgresStatus

type PostgresStatus struct {
	PostgresClusterStatus string `json:"PostgresClusterStatus"`
	RestoreID             string `json:"RestoreID"`
}

PostgresStatus contains status of the PostgreSQL cluster (running, creation failed etc.)

func (PostgresStatus) Creating

func (postgresStatus PostgresStatus) Creating() bool

Creating status of cluster

func (*PostgresStatus) DeepCopy

func (in *PostgresStatus) DeepCopy() *PostgresStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresStatus.

func (*PostgresStatus) DeepCopyInto

func (in *PostgresStatus) DeepCopyInto(out *PostgresStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (PostgresStatus) Running

func (postgresStatus PostgresStatus) Running() bool

Running status of cluster

func (PostgresStatus) String

func (postgresStatus PostgresStatus) String() string

func (PostgresStatus) Success

func (postgresStatus PostgresStatus) Success() bool

Success of the current Status

func (*PostgresStatus) UnmarshalJSON

func (ps *PostgresStatus) UnmarshalJSON(data []byte) error

UnmarshalJSON converts a JSON to the status subresource definition.

type PostgresTeam

type PostgresTeam struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec PostgresTeamSpec `json:"spec"`
}

PostgresTeam defines Custom Resource Definition Object for team management.

func (*PostgresTeam) DeepCopy

func (in *PostgresTeam) DeepCopy() *PostgresTeam

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresTeam.

func (*PostgresTeam) DeepCopyInto

func (in *PostgresTeam) DeepCopyInto(out *PostgresTeam)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*PostgresTeam) DeepCopyObject

func (in *PostgresTeam) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PostgresTeamList

type PostgresTeamList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`

	Items []PostgresTeam `json:"items"`
}

PostgresTeamList defines a list of PostgresTeam definitions.

func (*PostgresTeamList) DeepCopy

func (in *PostgresTeamList) DeepCopy() *PostgresTeamList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresTeamList.

func (*PostgresTeamList) DeepCopyInto

func (in *PostgresTeamList) DeepCopyInto(out *PostgresTeamList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*PostgresTeamList) DeepCopyObject

func (in *PostgresTeamList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PostgresTeamSpec

type PostgresTeamSpec struct {
	AdditionalSuperuserTeams map[string][]string `json:"additionalSuperuserTeams,omitempty"`
	AdditionalTeams          map[string][]string `json:"additionalTeams,omitempty"`
	AdditionalMembers        map[string][]string `json:"additionalMembers,omitempty"`
}

PostgresTeamSpec defines the specification for the PostgresTeam TPR.

func (*PostgresTeamSpec) DeepCopy

func (in *PostgresTeamSpec) DeepCopy() *PostgresTeamSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresTeamSpec.

func (*PostgresTeamSpec) DeepCopyInto

func (in *PostgresTeamSpec) DeepCopyInto(out *PostgresTeamSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PostgresUsersConfiguration

type PostgresUsersConfiguration struct {
	SuperUsername                 string   `json:"super_username,omitempty"`
	ReplicationUsername           string   `json:"replication_username,omitempty"`
	AdditionalOwnerRoles          []string `json:"additional_owner_roles,omitempty"`
	EnablePasswordRotation        bool     `json:"enable_password_rotation,omitempty"`
	PasswordRotationInterval      uint32   `json:"password_rotation_interval,omitempty"`
	PasswordRotationUserRetention uint32   `json:"password_rotation_user_retention,omitempty"`
}

PostgresUsersConfiguration defines the system users of Postgres.

func (*PostgresUsersConfiguration) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresUsersConfiguration.

func (*PostgresUsersConfiguration) DeepCopyInto

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Postgresql

type Postgresql struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   PostgresSpec   `json:"spec"`
	Status PostgresStatus `json:"status"`
	Error  string         `json:"-"`
}

Postgresql defines PostgreSQL Custom Resource Definition Object.

func (*Postgresql) Clone

func (p *Postgresql) Clone() *Postgresql

Clone convenience wrapper around DeepCopy

func (*Postgresql) DeepCopy

func (in *Postgresql) DeepCopy() *Postgresql

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Postgresql.

func (*Postgresql) DeepCopyInto

func (in *Postgresql) DeepCopyInto(out *Postgresql)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*Postgresql) DeepCopyObject

func (in *Postgresql) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*Postgresql) UnmarshalJSON

func (p *Postgresql) UnmarshalJSON(data []byte) error

UnmarshalJSON converts a JSON into the PostgreSQL object.

type PostgresqlList

type PostgresqlList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata"`

	Items []Postgresql `json:"items"`
}

PostgresqlList defines a list of PostgreSQL clusters.

func (*PostgresqlList) DeepCopy

func (in *PostgresqlList) DeepCopy() *PostgresqlList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresqlList.

func (*PostgresqlList) DeepCopyInto

func (in *PostgresqlList) DeepCopyInto(out *PostgresqlList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*PostgresqlList) DeepCopyObject

func (in *PostgresqlList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type PostgresqlParam

type PostgresqlParam struct {
	PgVersion  string            `json:"version"`
	Parameters map[string]string `json:"parameters,omitempty"`
}

PostgresqlParam describes PostgreSQL version and pairs of configuration parameter name - values.

func (*PostgresqlParam) DeepCopy

func (in *PostgresqlParam) DeepCopy() *PostgresqlParam

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PostgresqlParam.

func (*PostgresqlParam) DeepCopyInto

func (in *PostgresqlParam) DeepCopyInto(out *PostgresqlParam)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PreparedDatabase

type PreparedDatabase struct {
	PreparedSchemas map[string]PreparedSchema `json:"schemas,omitempty"`
	DefaultUsers    bool                      `json:"defaultUsers,omitempty" defaults:"false"`
	Extensions      map[string]string         `json:"extensions,omitempty"`
	SecretNamespace string                    `json:"secretNamespace,omitempty"`
}

PreparedDatabase describes elements to be bootstrapped

func (*PreparedDatabase) DeepCopy

func (in *PreparedDatabase) DeepCopy() *PreparedDatabase

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PreparedDatabase.

func (*PreparedDatabase) DeepCopyInto

func (in *PreparedDatabase) DeepCopyInto(out *PreparedDatabase)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PreparedSchema

type PreparedSchema struct {
	DefaultRoles *bool `json:"defaultRoles,omitempty" defaults:"true"`
	DefaultUsers bool  `json:"defaultUsers,omitempty" defaults:"false"`
}

PreparedSchema describes elements to be bootstrapped per schema

func (*PreparedSchema) DeepCopy

func (in *PreparedSchema) DeepCopy() *PreparedSchema

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PreparedSchema.

func (*PreparedSchema) DeepCopyInto

func (in *PreparedSchema) DeepCopyInto(out *PreparedSchema)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Repo

type Repo struct {
	Name     string            `json:"name"`
	Storage  string            `json:"storage"`
	Resource string            `json:"resource"`
	Endpoint string            `json:"endpoint"`
	Region   string            `json:"region"`
	Account  string            `json:"account"`
	Key      string            `json:"key"`
	KeyType  string            `json:"keyType"`
	Schedule map[string]string `json:"schedule"`
	Volume   `json:"volume,omitempty"`
}

func (*Repo) DeepCopy

func (in *Repo) DeepCopy() *Repo

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Repo.

func (*Repo) DeepCopyInto

func (in *Repo) DeepCopyInto(out *Repo)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ResourceDescription

type ResourceDescription struct {
	CPU    string `json:"cpu"`
	Memory string `json:"memory"`
}

ResourceDescription describes CPU and memory resources defined for a cluster.

func (*ResourceDescription) DeepCopy

func (in *ResourceDescription) DeepCopy() *ResourceDescription

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ResourceDescription.

func (*ResourceDescription) DeepCopyInto

func (in *ResourceDescription) DeepCopyInto(out *ResourceDescription)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Resources

type Resources struct {
	ResourceRequests ResourceDescription `json:"requests,omitempty"`
	ResourceLimits   ResourceDescription `json:"limits,omitempty"`
}

Resources describes requests and limits for the cluster resouces.

func (*Resources) DeepCopy

func (in *Resources) DeepCopy() *Resources

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Resources.

func (*Resources) DeepCopyInto

func (in *Resources) DeepCopyInto(out *Resources)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Restore

type Restore struct {
	ID      string            `json:"id"`
	Repo    string            `json:"repo"`
	Options map[string]string `json:"options"`
}

func (*Restore) DeepCopy

func (in *Restore) DeepCopy() *Restore

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Restore.

func (*Restore) DeepCopyInto

func (in *Restore) DeepCopyInto(out *Restore)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ScalyrConfiguration

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

ScalyrConfiguration defines the configuration for ScalyrAPI

func (*ScalyrConfiguration) DeepCopy

func (in *ScalyrConfiguration) DeepCopy() *ScalyrConfiguration

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ScalyrConfiguration.

func (*ScalyrConfiguration) DeepCopyInto

func (in *ScalyrConfiguration) DeepCopyInto(out *ScalyrConfiguration)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Sidecar

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

Sidecar defines a container to be run in the same pod as the Postgres container.

func (*Sidecar) DeepCopy

func (in *Sidecar) DeepCopy() *Sidecar

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Sidecar.

func (*Sidecar) DeepCopyInto

func (in *Sidecar) DeepCopyInto(out *Sidecar)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type StandbyDescription

type StandbyDescription struct {
	S3WalPath   string `json:"s3_wal_path,omitempty"`
	GSWalPath   string `json:"gs_wal_path,omitempty"`
	StandbyHost string `json:"standby_host,omitempty"`
	StandbyPort string `json:"standby_port,omitempty"`
}

StandbyDescription contains remote primary config or s3/gs wal path

func (*StandbyDescription) DeepCopy

func (in *StandbyDescription) DeepCopy() *StandbyDescription

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StandbyDescription.

func (*StandbyDescription) DeepCopyInto

func (in *StandbyDescription) DeepCopyInto(out *StandbyDescription)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Stream

type Stream struct {
	ApplicationId  string                 `json:"applicationId"`
	Database       string                 `json:"database"`
	Tables         map[string]StreamTable `json:"tables"`
	Filter         map[string]*string     `json:"filter,omitempty"`
	BatchSize      *uint32                `json:"batchSize,omitempty"`
	EnableRecovery *bool                  `json:"enableRecovery,omitempty"`
}

Stream defines properties for creating FabricEventStream resources

func (*Stream) DeepCopy

func (in *Stream) DeepCopy() *Stream

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Stream.

func (*Stream) DeepCopyInto

func (in *Stream) DeepCopyInto(out *Stream)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type StreamTable

type StreamTable struct {
	EventType         string  `json:"eventType"`
	RecoveryEventType string  `json:"recoveryEventType"`
	IdColumn          *string `json:"idColumn,omitempty"`
	PayloadColumn     *string `json:"payloadColumn,omitempty"`
}

StreamTable defines properties of outbox tables for FabricEventStreams

func (*StreamTable) DeepCopy

func (in *StreamTable) DeepCopy() *StreamTable

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StreamTable.

func (*StreamTable) DeepCopyInto

func (in *StreamTable) DeepCopyInto(out *StreamTable)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TDE

type TDE struct {
	Enable bool `json:"enable"`
}

func (*TDE) DeepCopy

func (in *TDE) DeepCopy() *TDE

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TDE.

func (*TDE) DeepCopyInto

func (in *TDE) DeepCopyInto(out *TDE)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TLSDescription

type TLSDescription struct {
	SecretName      string `json:"secretName,omitempty"`
	CertificateFile string `json:"certificateFile,omitempty"`
	PrivateKeyFile  string `json:"privateKeyFile,omitempty"`
	CAFile          string `json:"caFile,omitempty"`
	CASecretName    string `json:"caSecretName,omitempty"`
}

TLSDescription specs TLS properties

func (*TLSDescription) DeepCopy

func (in *TLSDescription) DeepCopy() *TLSDescription

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TLSDescription.

func (*TLSDescription) DeepCopyInto

func (in *TLSDescription) DeepCopyInto(out *TLSDescription)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TeamsAPIConfiguration

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"`
	EnableAdminRoleForUsers         bool              `json:"enable_admin_role_for_users,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"`
	PostgresSuperuserTeams          []string          `json:"postgres_superuser_teams,omitempty"`
	EnablePostgresTeamCRD           bool              `json:"enable_postgres_team_crd,omitempty"`
	EnablePostgresTeamCRDSuperusers bool              `json:"enable_postgres_team_crd_superusers,omitempty"`
	EnableTeamMemberDeprecation     bool              `json:"enable_team_member_deprecation,omitempty"`
	RoleDeletionSuffix              string            `json:"role_deletion_suffix,omitempty"`
}

TeamsAPIConfiguration defines the configuration of TeamsAPI

func (*TeamsAPIConfiguration) DeepCopy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TeamsAPIConfiguration.

func (*TeamsAPIConfiguration) DeepCopyInto

func (in *TeamsAPIConfiguration) DeepCopyInto(out *TeamsAPIConfiguration)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type UserFlags

type UserFlags []string

UserFlags defines flags (such as superuser, nologin) that could be assigned to individual users

func (UserFlags) DeepCopy

func (in UserFlags) DeepCopy() UserFlags

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new UserFlags.

func (UserFlags) DeepCopyInto

func (in UserFlags) DeepCopyInto(out *UserFlags)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type Volume

type Volume struct {
	Selector     *metav1.LabelSelector `json:"selector,omitempty"`
	Size         string                `json:"size"`
	StorageClass string                `json:"storageClass,omitempty"`
	SubPath      string                `json:"subPath,omitempty"`
	Iops         *int64                `json:"iops,omitempty"`
	Throughput   *int64                `json:"throughput,omitempty"`
	VolumeType   string                `json:"type,omitempty"`
}

Volume describes a single volume in the manifest.

func (*Volume) DeepCopy

func (in *Volume) DeepCopy() *Volume

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Volume.

func (*Volume) DeepCopyInto

func (in *Volume) DeepCopyInto(out *Volume)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL