v1

package
v1.13.0 Latest Latest
Warning

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

Go to latest
Published: Aug 22, 2024 License: MIT Imports: 14 Imported by: 47

Documentation

Index

Constants

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

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(`"acid.zalan.do/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_finalizers": {
								Type: "boolean",
							},
							"enable_init_containers": {
								Type: "boolean",
							},
							"enable_owner_references": {
								Type: "boolean",
							},
							"enable_persistent_volume_claim_deletion": {
								Type: "boolean",
							},
							"enable_pod_antiaffinity": {
								Type: "boolean",
							},
							"enable_pod_disruption_budget": {
								Type: "boolean",
							},
							"enable_readiness_probe": {
								Type: "boolean",
							},
							"enable_secrets_deletion": {
								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",
							},
							"pdb_master_label_selector": {
								Type: "boolean",
							},
							"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_bucket_prefix": {
								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}$",
							},
							"logical_backup_cronjob_environment_secret": {
								Type: "string",
							},
						},
					},
					"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",
							},
						},
					},
				},
			},
			"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(`"acid.zalan.do/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{
									"isSubPathExpr": {
										Type: "boolean",
									},
									"name": {
										Type: "string",
									},
									"mountPath": {
										Type: "string",
									},
									"subPath": {
										Type: "string",
									},
									"targetContainers": {
										Type:     "array",
										Nullable: true,
										Items: &apiextv1.JSONSchemaPropsOrArray{
											Schema: &apiextv1.JSONSchemaProps{
												Type: "string",
											},
										},
									},
									"volumeSource": {
										Type:                   "object",
										XPreserveUnknownFields: util.True(),
									},
								},
							},
						},
					},
					"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(),
							},
						},
					},
					"logicalBackupRetention": {
						Type: "string",
					},
					"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",
							},
							"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"`),
									},
								},
							},
							"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?)$",
									},
									"hugepages-2Mi": {
										Type:    "string",
										Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
									},
									"hugepages-1Gi": {
										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?)$",
									},
									"hugepages-2Mi": {
										Type:    "string",
										Pattern: "^(\\d+(e\\d+)?|\\d+(\\.\\d+)?(e\\d+)?[EPTGMK]i?)$",
									},
									"hugepages-1Gi": {
										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"`),
											},
										},
									},
								},
							},
						},
					},
					"usersIgnoringSecretRotation": {
						Type:     "array",
						Nullable: true,
						Items: &apiextv1.JSONSchemaPropsOrArray{
							Schema: &apiextv1.JSONSchemaProps{
								Type: "string",
							},
						},
					},
					"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{
							"isSubPathExpr": {
								Type: "boolean",
							},
							"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",
							},
						},
					},
				},
			},
			"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 added in v1.9.0

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,omitempty"`
	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 added in v1.5.0

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

AdditionalVolume specs additional optional volumes for statefulset

func (*AdditionalVolume) DeepCopy added in v1.5.0

func (in *AdditionalVolume) DeepCopy() *AdditionalVolume

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

func (*AdditionalVolume) DeepCopyInto added in v1.5.0

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

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

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 ConnectionPooler added in v1.5.0

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 added in v1.5.0

func (in *ConnectionPooler) DeepCopy() *ConnectionPooler

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

func (*ConnectionPooler) DeepCopyInto added in v1.5.0

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 added in v1.5.0

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 added in v1.5.0

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

func (*ConnectionPoolerConfiguration) DeepCopyInto added in v1.5.0

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 KubernetesMetaConfiguration

type KubernetesMetaConfiguration struct {
	EnableOwnerReferences *bool  `json:"enable_owner_references,omitempty"`
	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"`
	PDBMasterLabelSelector                 *bool                        `json:"pdb_master_label_selector,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"`
	EnableSecretsDeletion                    *bool               `json:"enable_secrets_deletion,omitempty"`
	EnablePersistentVolumeClaimDeletion      *bool               `json:"enable_persistent_volume_claim_deletion,omitempty"`
	EnableReadinessProbe                     bool                `json:"enable_readiness_probe,omitempty"`
	EnableCrossNamespaceSecret               bool                `json:"enable_cross_namespace_secret,omitempty"`
	EnableFinalizers                         *bool               `json:"enable_finalizers,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 added in v1.6.2

type MajorVersionUpgradeConfiguration struct {
	MajorVersionUpgradeMode          string   `json:"major_version_upgrade_mode" default:"manual"` // 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:"12"`
	TargetMajorVersion               string   `json:"target_major_version" default:"16"`
}

MajorVersionUpgradeConfiguration defines how to execute major version upgrades of Postgres.

func (*MajorVersionUpgradeConfiguration) DeepCopy added in v1.6.2

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

func (*MajorVersionUpgradeConfiguration) DeepCopyInto added in v1.6.2

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"`
	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 added in v1.2.0

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"`
	S3BucketPrefix               string `json:"logical_backup_s3_bucket_prefix,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"`
	CronjobEnvironmentSecret     string `json:"logical_backup_cronjob_environment_secret,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 added in v1.2.0

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

func (*OperatorLogicalBackupConfiguration) DeepCopyInto added in v1.2.0

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"`
	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 added in v1.9.0

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

PatroniConfiguration defines configuration for Patroni

func (*PatroniConfiguration) DeepCopy added in v1.9.0

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

func (*PatroniConfiguration) DeepCopyInto added in v1.9.0

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

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"`
	UsersIgnoringSecretRotation    []string             `json:"usersIgnoringSecretRotation,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"`
	PodPriorityClassName   string                      `json:"podPriorityClassName,omitempty"`
	ShmVolume              *bool                       `json:"enableShmVolume,omitempty"`
	EnableLogicalBackup    bool                        `json:"enableLogicalBackup,omitempty"`
	LogicalBackupRetention string                      `json:"logicalBackupRetention,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"`
	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"`
}

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.

type PostgresStatus

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

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

func (PostgresStatus) Creating added in v1.2.0

func (postgresStatus PostgresStatus) Creating() bool

Creating status of cluster

func (*PostgresStatus) DeepCopy added in v1.2.0

func (in *PostgresStatus) DeepCopy() *PostgresStatus

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

func (*PostgresStatus) DeepCopyInto added in v1.2.0

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 added in v1.2.0

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 added in v1.2.0

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

UnmarshalJSON converts a JSON to the status subresource definition.

type PostgresTeam added in v1.6.0

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 added in v1.6.0

func (in *PostgresTeam) DeepCopy() *PostgresTeam

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

func (*PostgresTeam) DeepCopyInto added in v1.6.0

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 added in v1.6.0

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

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

type PostgresTeamList added in v1.6.0

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 added in v1.6.0

func (in *PostgresTeamList) DeepCopy() *PostgresTeamList

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

func (*PostgresTeamList) DeepCopyInto added in v1.6.0

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 added in v1.6.0

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

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

type PostgresTeamSpec added in v1.6.0

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 added in v1.6.0

func (in *PostgresTeamSpec) DeepCopy() *PostgresTeamSpec

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

func (*PostgresTeamSpec) DeepCopyInto added in v1.6.0

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 added in v1.5.0

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 added in v1.5.0

func (in *PreparedDatabase) DeepCopy() *PreparedDatabase

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

func (*PreparedDatabase) DeepCopyInto added in v1.5.0

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 added in v1.5.0

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 added in v1.5.0

func (in *PreparedSchema) DeepCopy() *PreparedSchema

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

func (*PreparedSchema) DeepCopyInto added in v1.5.0

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

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,omitempty"`
	Memory       *string `json:"memory,omitempty"`
	HugePages2Mi *string `json:"hugepages-2Mi,omitempty"`
	HugePages1Gi *string `json:"hugepages-1Gi,omitempty"`
}

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 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 added in v1.2.0

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 added in v1.2.0

func (in *StandbyDescription) DeepCopy() *StandbyDescription

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

func (*StandbyDescription) DeepCopyInto added in v1.2.0

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 added in v1.8.0

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 added in v1.8.0

func (in *Stream) DeepCopy() *Stream

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

func (*Stream) DeepCopyInto added in v1.8.0

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 added in v1.8.0

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

StreamTable defines properties of outbox tables for FabricEventStreams

func (*StreamTable) DeepCopy added in v1.8.0

func (in *StreamTable) DeepCopy() *StreamTable

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

func (*StreamTable) DeepCopyInto added in v1.8.0

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

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

type TLSDescription added in v1.5.0

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 added in v1.5.0

func (in *TLSDescription) DeepCopy() *TLSDescription

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

func (*TLSDescription) DeepCopyInto added in v1.5.0

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"`
	IsSubPathExpr *bool                 `json:"isSubPathExpr,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