v1

package
v1.22.4 Latest Latest
Warning

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

 Go to latest Published: Jun 12, 2024 License: Apache-2.0 Imports: 36 Imported by: 11

Documentation

Overview

Package v1 contains API Schema definitions for the postgresql v1 API group +kubebuilder:object:generate=true +groupName=postgresql.cnpg.io

Package v1 contains API Schema definitions for the postgresql v1 API group +kubebuilder:object:generate=true +groupName=postgresql.cnpg.io

Index

Constants

View Source 
const (
	// BackupPhasePending means that the backup is still waiting to be started
	BackupPhasePending = "pending"

	// BackupPhaseStarted means that the backup is now running
	BackupPhaseStarted = "started"

	// BackupPhaseRunning means that the backup is now running
	BackupPhaseRunning = "running"

	// BackupPhaseFinalizing means that a consistent backup have been
	// taken and the operator is waiting for it to be ready to be
	// used to restore a cluster.
	// This phase is used for VolumeSnapshot backups, when a
	// VolumeSnapshotContent have already been provisioned, but it is
	// still now waiting for the `readyToUse` flag to be true.
	BackupPhaseFinalizing = "finalizing"

	// BackupPhaseCompleted means that the backup is now completed
	BackupPhaseCompleted = "completed"

	// BackupPhaseFailed means that the backup is failed
	BackupPhaseFailed = "failed"

	// BackupPhaseWalArchivingFailing means wal archiving isn't properly working
	BackupPhaseWalArchivingFailing = "walArchivingFailing"
)
View Source 
const (
	// PrimaryPodDisruptionBudgetSuffix is the suffix appended to the cluster name
	// to get the name of the PDB used for the cluster primary
	PrimaryPodDisruptionBudgetSuffix = "-primary"

	// ReplicationSecretSuffix is the suffix appended to the cluster name to
	// get the name of the generated replication secret for PostgreSQL
	ReplicationSecretSuffix = "-replication" // #nosec

	// SuperUserSecretSuffix is the suffix appended to the cluster name to
	// get the name of the PostgreSQL superuser secret
	SuperUserSecretSuffix = "-superuser"

	// ApplicationUserSecretSuffix is the suffix appended to the cluster name to
	// get the name of the application user secret
	ApplicationUserSecretSuffix = "-app"

	// DefaultServerCaSecretSuffix is the suffix appended to the secret containing
	// the generated CA for the cluster
	DefaultServerCaSecretSuffix = "-ca"

	// ClientCaSecretSuffix is the suffix appended to the secret containing
	// the generated CA for the client certificates
	ClientCaSecretSuffix = "-ca"

	// ServerSecretSuffix is the suffix appended to the secret containing
	// the generated server secret for PostgreSQL
	ServerSecretSuffix = "-server"

	// ServiceAnySuffix is the suffix appended to the cluster name to get the
	// service name for every node (including non-ready ones)
	ServiceAnySuffix = "-any"

	// ServiceReadSuffix is the suffix appended to the cluster name to get the
	// service name for every ready node that you can use to read data (including the primary)
	ServiceReadSuffix = "-r"

	// ServiceReadOnlySuffix is the suffix appended to the cluster name to get the
	// service name for every ready node that you can use to read data (excluding the primary)
	ServiceReadOnlySuffix = "-ro"

	// ServiceReadWriteSuffix is the suffix appended to the cluster name to get
	// the se service name for every node that you can use to read and write
	// data
	ServiceReadWriteSuffix = "-rw"

	// ClusterSecretSuffix is the suffix appended to the cluster name to
	// get the name of the pull secret
	ClusterSecretSuffix = "-pull-secret"

	// WalArchiveVolumeSuffix is the suffix appended to the instance name to
	// get the name of the PVC dedicated to WAL files.
	WalArchiveVolumeSuffix = "-wal"

	// TablespaceVolumeInfix is the infix added between the instance name
	// and tablespace name to get the name of PVC for a certain tablespace
	TablespaceVolumeInfix = "-tbs-"

	// StreamingReplicationUser is the name of the user we'll use for
	// streaming replication purposes
	StreamingReplicationUser = "streaming_replica"

	// PodAntiAffinityTypeRequired is the label for required anti-affinity type
	PodAntiAffinityTypeRequired = "required"

	// PodAntiAffinityTypePreferred is the label for preferred anti-affinity type
	PodAntiAffinityTypePreferred = "preferred"

	// DefaultPgBouncerPoolerSecretSuffix is the suffix for the default pgbouncer Pooler secret
	DefaultPgBouncerPoolerSecretSuffix = "-pooler"

	// PendingFailoverMarker is used as target primary to signal that a failover is required
	PendingFailoverMarker = "pending"

	// PGBouncerPoolerUserName is the name of the role to be used for
	PGBouncerPoolerUserName = "cnpg_pooler_pgbouncer"
)
View Source 
const (
	// PhaseSwitchover when a cluster is changing the primary node
	PhaseSwitchover = "Switchover in progress"

	// PhaseFailOver in case a pod is missing and need to change primary
	PhaseFailOver = "Failing over"

	// PhaseFirstPrimary for an starting cluster
	PhaseFirstPrimary = "Setting up primary"

	// PhaseCreatingReplica everytime we add a new replica
	PhaseCreatingReplica = "Creating a new replica"

	// PhaseUpgrade upgrade in process
	PhaseUpgrade = "Upgrading cluster"

	// PhaseWaitingForUser set the status to wait for an action from the user
	PhaseWaitingForUser = "Waiting for user action"

	// PhaseInplacePrimaryRestart for a cluster restarting the primary instance in-place
	PhaseInplacePrimaryRestart = "Primary instance is being restarted in-place"

	// PhaseInplaceDeletePrimaryRestart for a cluster restarting the primary instance without a switchover
	PhaseInplaceDeletePrimaryRestart = "Primary instance is being restarted without a switchover"

	// PhaseHealthy for a cluster doing nothing
	PhaseHealthy = "Cluster in healthy state"

	// PhaseUnrecoverable for an unrecoverable cluster
	PhaseUnrecoverable = "Cluster is in an unrecoverable state, needs manual intervention"

	// PhaseArchitectureBinaryMissing is the error phase describing a missing architecture
	PhaseArchitectureBinaryMissing = "Cluster cannot execute instance online upgrade due to missing architecture binary"

	// PhaseWaitingForInstancesToBeActive is a waiting phase that is triggered when an instance pod is not active
	PhaseWaitingForInstancesToBeActive = "Waiting for the instances to become active"

	// PhaseOnlineUpgrading for when the instance manager is being upgraded in place
	PhaseOnlineUpgrading = "Online upgrade in progress"

	// PhaseApplyingConfiguration is set by the instance manager when a configuration
	// change is being detected
	PhaseApplyingConfiguration = "Applying configuration"
)
View Source 
const (
	// KubernetesUpgradeStrategyAllocateSpace means that the operator
	// should allocate more disk space to host data belonging to the
	// k8s node that is being updated
	KubernetesUpgradeStrategyAllocateSpace = "allocateSpace"

	// KubernetesUpgradeStrategyWaitForNode means that the operator
	// should just recreate stuff and wait for the upgraded node
	// to be ready
	KubernetesUpgradeStrategyWaitForNode = "waitForNode"
)
View Source 
const (
	// PrimaryUpdateStrategySupervised means that the operator need to wait for the
	// user to manually issue a switchover request before updating the primary
	// server (`supervised`)
	PrimaryUpdateStrategySupervised PrimaryUpdateStrategy = "supervised"

	// PrimaryUpdateStrategyUnsupervised means that the operator will proceed with the
	// selected PrimaryUpdateMethod to another updated replica and then automatically update
	// the primary server (`unsupervised`, default)
	PrimaryUpdateStrategyUnsupervised PrimaryUpdateStrategy = "unsupervised"

	// PrimaryUpdateMethodSwitchover means that the operator will switchover to another updated
	// replica when it needs to upgrade the primary instance
	PrimaryUpdateMethodSwitchover PrimaryUpdateMethod = "switchover"

	// PrimaryUpdateMethodRestart means that the operator will restart the primary instance in-place
	// when it needs to upgrade it
	PrimaryUpdateMethodRestart PrimaryUpdateMethod = "restart"

	// DefaultPgCtlTimeoutForPromotion is the default for the pg_ctl timeout when a promotion is performed.
	// It is greater than one year in seconds, big enough to simulate an infinite timeout
	DefaultPgCtlTimeoutForPromotion = 40000000

	// DefaultMaxSwitchoverDelay is the default for the pg_ctl timeout in seconds when a primary PostgreSQL instance
	// is gracefully shutdown during a switchover.
	DefaultMaxSwitchoverDelay = 3600

	// DefaultStartupDelay is the default value for startupDelay, startupDelay will be used to calculate the
	// FailureThreshold of startupProbe, the formula is `FailureThreshold = ceiling(startDelay / periodSeconds)`,
	// the minimum value is 1
	DefaultStartupDelay = 3600
)
View Source 
const (
	// BackupTargetPrimary means backups will be performed on the primary instance
	BackupTargetPrimary = BackupTarget("primary")

	// BackupTargetStandby means backups will be performed on a standby instance if available
	BackupTargetStandby = BackupTarget("prefer-standby")

	// DefaultBackupTarget is the default BackupTarget
	DefaultBackupTarget = BackupTargetStandby
)
View Source 
const (
	// CompressionTypeNone means no compression is performed
	CompressionTypeNone = CompressionType("")

	// CompressionTypeGzip means gzip compression is performed
	CompressionTypeGzip = CompressionType("gzip")

	// CompressionTypeBzip2 means bzip2 compression is performed
	CompressionTypeBzip2 = CompressionType("bzip2")

	// CompressionTypeSnappy means snappy compression is performed
	CompressionTypeSnappy = CompressionType("snappy")
)
View Source 
const (
	// EncryptionTypeNone means just use the bucket configuration
	EncryptionTypeNone = EncryptionType("")

	// EncryptionTypeAES256 means to use AES256 encryption
	EncryptionTypeAES256 = EncryptionType("AES256")

	// EncryptionTypeNoneAWSKMS means to use aws:kms encryption
	EncryptionTypeNoneAWSKMS = EncryptionType("aws:kms")
)
View Source 
const (
	// DefaultMonitoringKey is the key that should be used in the default metrics configmap to store the queries
	DefaultMonitoringKey = "queries"
	// DefaultMonitoringConfigMapName is the name of the target configmap with the default monitoring queries,
	// if configured
	DefaultMonitoringConfigMapName = "cnpg-default-monitoring"
	// DefaultMonitoringSecretName is the name of the target secret with the default monitoring queries,
	// if configured
	DefaultMonitoringSecretName = DefaultMonitoringConfigMapName
	// DefaultApplicationDatabaseName is the name of application database if not specified
	DefaultApplicationDatabaseName = "app"
	// DefaultApplicationUserName is the name of application database owner if not specified
	DefaultApplicationUserName = DefaultApplicationDatabaseName
)
View Source 
const (
	// PoolerTypeRW means that the pooler involves only the primary server
	PoolerTypeRW = PoolerType("rw")

	// PoolerTypeRO means that the pooler involves only the replicas
	PoolerTypeRO = PoolerType("ro")

	// DefaultPgBouncerPoolerAuthQuery is the default auth_query for PgBouncer
	DefaultPgBouncerPoolerAuthQuery = "SELECT usename, passwd FROM public.user_search($1)"
)
View Source 
const (
	// PgBouncerPoolModeSession the "session" mode
	PgBouncerPoolModeSession = PgBouncerPoolMode("session")

	// PgBouncerPoolModeTransaction the "transaction" mode
	PgBouncerPoolModeTransaction = PgBouncerPoolMode("transaction")
)
View Source 
const DefaultReplicationSlotsHASlotPrefix = "_cnpg_"

DefaultReplicationSlotsHASlotPrefix is the default prefix for names of replication slots used for HA.

View Source 
const DefaultReplicationSlotsUpdateInterval = 30

DefaultReplicationSlotsUpdateInterval is the default in seconds for the replication slots update interval

View Source 
const VolumeSnapshotKind = "VolumeSnapshot"

VolumeSnapshotKind this is a strongly typed reference to the kind used by the volumesnapshot package

Variables

View Source 
var (
	// BackupSucceededCondition is added to a backup
	// when it was completed correctly
	BackupSucceededCondition = &metav1.Condition{
		Type:    string(ConditionBackup),
		Status:  metav1.ConditionTrue,
		Reason:  string(ConditionReasonLastBackupSucceeded),
		Message: "Backup was successful",
	}

	// BackupStartingCondition is added to a backup
	// when it started
	BackupStartingCondition = &metav1.Condition{
		Type:    string(ConditionBackup),
		Status:  metav1.ConditionFalse,
		Reason:  string(ConditionBackupStarted),
		Message: "New Backup starting up",
	}

	// BuildClusterBackupFailedCondition builds
	// ConditionReasonLastBackupFailed condition
	BuildClusterBackupFailedCondition = func(err error) *metav1.Condition {
		return &metav1.Condition{
			Type:    string(ConditionBackup),
			Status:  metav1.ConditionFalse,
			Reason:  string(ConditionReasonLastBackupFailed),
			Message: err.Error(),
		}
	}
)

A Condition that can be used to communicate the Backup progress

View Source 
var (
	// GroupVersion is group version used to register these objects
	GroupVersion = schema.GroupVersion{Group: "postgresql.cnpg.io", Version: "v1"}

	// ClusterGVK is the triple to reach Cluster resources in k8s
	ClusterGVK = schema.GroupVersionResource{
		Group:    GroupVersion.Group,
		Version:  GroupVersion.Version,
		Resource: "clusters",
	}

	// PoolerGVK is the triple to reach Pooler resources in k8s
	PoolerGVK = schema.GroupVersionResource{
		Group:    GroupVersion.Group,
		Version:  GroupVersion.Version,
		Resource: "poolers",
	}

	// ClusterKind is the kind name of Clusters
	ClusterKind = "Cluster"

	// BackupKind is the kind name of Backups
	BackupKind = "Backup"

	// PoolerKind is the kind name of Poolers
	PoolerKind = "Pooler"

	// SchemeBuilder is used to add go types to the GroupVersionKind scheme
	SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion}

	// AddToScheme adds the types in this group-version to the given scheme.
	AddToScheme = SchemeBuilder.AddToScheme
)
View Source 
var (

	// AllowedPgbouncerGenericConfigurationParameters is the list of allowed parameters for PgBouncer
	AllowedPgbouncerGenericConfigurationParameters = stringset.From([]string{
		"application_name_add_host",
		"autodb_idle_timeout",
		"client_idle_timeout",
		"client_login_timeout",
		"default_pool_size",
		"disable_pqexec",
		"idle_transaction_timeout",
		"ignore_startup_parameters",
		"log_connections",
		"log_disconnections",
		"log_pooler_errors",
		"log_stats",
		"max_client_conn",
		"max_db_connections",
		"max_prepared_statements",
		"max_user_connections",
		"min_pool_size",
		"query_timeout",
		"query_wait_timeout",
		"reserve_pool_size",
		"reserve_pool_timeout",
		"server_check_delay",
		"server_check_query",
		"server_connect_timeout",
		"server_fast_close",
		"server_idle_timeout",
		"server_lifetime",
		"server_login_retry",
		"server_reset_query",
		"server_reset_query_always",
		"server_round_robin",
		"stats_period",
		"tcp_keepalive",
		"tcp_keepcnt",
		"tcp_keepidle",
		"tcp_keepintvl",
		"tcp_user_timeout",
		"verbose",
	})
)

Functions

func ConfigMapKeySelectorToCore 

func ConfigMapKeySelectorToCore(selector *ConfigMapKeySelector) *corev1.ConfigMapKeySelector

ConfigMapKeySelectorToCore transforms a ConfigMapKeySelector structure to the analogue one in the corev1 namespace

func SecretKeySelectorToCore 

func SecretKeySelectorToCore(selector *SecretKeySelector) *corev1.SecretKeySelector

SecretKeySelectorToCore transforms a SecretKeySelector structure to the analogue one in the corev1 namespace

Types

type AffinityConfiguration 

type AffinityConfiguration struct {
	// Activates anti-affinity for the pods. The operator will define pods
	// anti-affinity unless this field is explicitly set to false
	// +optional
	EnablePodAntiAffinity *bool `json:"enablePodAntiAffinity,omitempty"`

	// TopologyKey to use for anti-affinity configuration. See k8s documentation
	// for more info on that
	// +optional
	TopologyKey string `json:"topologyKey,omitempty"`

	// NodeSelector is map of key-value pairs used to define the nodes on which
	// the pods can run.
	// More info: https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
	// +optional
	NodeSelector map[string]string `json:"nodeSelector,omitempty"`

	// NodeAffinity describes node affinity scheduling rules for the pod.
	// More info: https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#node-affinity
	// +optional
	NodeAffinity *corev1.NodeAffinity `json:"nodeAffinity,omitempty"`

	// Tolerations is a list of Tolerations that should be set for all the pods, in order to allow them to run
	// on tainted nodes.
	// More info: https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/
	// +optional
	Tolerations []corev1.Toleration `json:"tolerations,omitempty"`

	// PodAntiAffinityType allows the user to decide whether pod anti-affinity between cluster instance has to be
	// considered a strong requirement during scheduling or not. Allowed values are: "preferred" (default if empty) or
	// "required". Setting it to "required", could lead to instances remaining pending until new kubernetes nodes are
	// added if all the existing nodes don't match the required pod anti-affinity rule.
	// More info:
	// https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/#inter-pod-affinity-and-anti-affinity
	// +optional
	PodAntiAffinityType string `json:"podAntiAffinityType,omitempty"`

	// AdditionalPodAntiAffinity allows to specify pod anti-affinity terms to be added to the ones generated
	// by the operator if EnablePodAntiAffinity is set to true (default) or to be used exclusively if set to false.
	// +optional
	AdditionalPodAntiAffinity *corev1.PodAntiAffinity `json:"additionalPodAntiAffinity,omitempty"`

	// AdditionalPodAffinity allows to specify pod affinity terms to be passed to all the cluster's pods.
	// +optional
	AdditionalPodAffinity *corev1.PodAffinity `json:"additionalPodAffinity,omitempty"`
}

AffinityConfiguration contains the info we need to create the affinity rules for Pods

func (*AffinityConfiguration) DeepCopy 

func (in *AffinityConfiguration) DeepCopy() *AffinityConfiguration

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

func (*AffinityConfiguration) DeepCopyInto 

func (in *AffinityConfiguration) DeepCopyInto(out *AffinityConfiguration)

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

type AvailableArchitecture added in v1.21.4 

type AvailableArchitecture struct {
	// GoArch is the name of the executable architecture
	GoArch string `json:"goArch"`

	// Hash is the hash of the executable
	Hash string `json:"hash"`
}

AvailableArchitecture represents the state of a cluster's architecture

func (*AvailableArchitecture) DeepCopy added in v1.21.4 

func (in *AvailableArchitecture) DeepCopy() *AvailableArchitecture

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

func (*AvailableArchitecture) DeepCopyInto added in v1.21.4 

func (in *AvailableArchitecture) DeepCopyInto(out *AvailableArchitecture)

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

type AzureCredentials 

type AzureCredentials struct {
	// The connection string to be used
	// +optional
	ConnectionString *SecretKeySelector `json:"connectionString,omitempty"`

	// The storage account where to upload data
	// +optional
	StorageAccount *SecretKeySelector `json:"storageAccount,omitempty"`

	// The storage account key to be used in conjunction
	// with the storage account name
	// +optional
	StorageKey *SecretKeySelector `json:"storageKey,omitempty"`

	// A shared-access-signature to be used in conjunction with
	// the storage account name
	// +optional
	StorageSasToken *SecretKeySelector `json:"storageSasToken,omitempty"`

	// Use the Azure AD based authentication without providing explicitly the keys.
	// +optional
	InheritFromAzureAD bool `json:"inheritFromAzureAD,omitempty"`
}

AzureCredentials is the type for the credentials to be used to upload files to Azure Blob Storage. The connection string contains every needed information. If the connection string is not specified, we'll need the storage account name and also one (and only one) of:

- storageKey - storageSasToken

- inheriting the credentials from the pod environment by setting inheritFromAzureAD to true

func (*AzureCredentials) DeepCopy 

func (in *AzureCredentials) DeepCopy() *AzureCredentials

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

func (*AzureCredentials) DeepCopyInto 

func (in *AzureCredentials) DeepCopyInto(out *AzureCredentials)

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

type Backup 

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

	// Specification of the desired behavior of the backup.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	Spec BackupSpec `json:"spec"`
	// Most recently observed status of the backup. This data may not be up to
	// date. Populated by the system. Read-only.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	// +optional
	Status BackupStatus `json:"status,omitempty"`
}

Backup is the Schema for the backups API

func (*Backup) DeepCopy 

func (in *Backup) DeepCopy() *Backup

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

func (*Backup) DeepCopyInto 

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

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

func (*Backup) DeepCopyObject 

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

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

func (*Backup) Default 

func (r *Backup) Default()

Default implements webhook.Defaulter so a webhook will be registered for the type

func (*Backup) GetAssignedInstance added in v1.21.0 

func (backup *Backup) GetAssignedInstance(ctx context.Context, cli client.Client) (*corev1.Pod, error)

GetAssignedInstance fetches the instance that was assigned to the backup execution

func (*Backup) GetMetadata 

func (backup *Backup) GetMetadata() *metav1.ObjectMeta

GetMetadata get the metadata

func (*Backup) GetName 

func (backup *Backup) GetName() string

GetName get the backup name

func (*Backup) GetNamespace 

func (backup *Backup) GetNamespace() string

GetNamespace get the backup namespace

func (*Backup) GetStatus 

func (backup *Backup) GetStatus() *BackupStatus

GetStatus gets the backup status

func (*Backup) GetVolumeSnapshotConfiguration added in v1.21.1 

func (backup *Backup) GetVolumeSnapshotConfiguration(
	clusterConfig VolumeSnapshotConfiguration,
) VolumeSnapshotConfiguration

GetVolumeSnapshotConfiguration overrides the configuration value with the ones specified in the backup, if present.

func (*Backup) IsCompletedVolumeSnapshot added in v1.21.0 

func (backup *Backup) IsCompletedVolumeSnapshot() bool

IsCompletedVolumeSnapshot checks if a backup is completed using the volume snapshot method. It returns true if the backup's method is BackupMethodVolumeSnapshot and its status phase is BackupPhaseCompleted. Otherwise, it returns false.

func (*Backup) SetupWebhookWithManager 

func (r *Backup) SetupWebhookWithManager(mgr ctrl.Manager) error

SetupWebhookWithManager setup the webhook inside the controller manager

func (*Backup) ValidateCreate 

func (r *Backup) ValidateCreate() (admission.Warnings, error)

ValidateCreate implements webhook.Validator so a webhook will be registered for the type

func (*Backup) ValidateDelete 

func (r *Backup) ValidateDelete() (admission.Warnings, error)

ValidateDelete implements webhook.Validator so a webhook will be registered for the type

func (*Backup) ValidateUpdate 

func (r *Backup) ValidateUpdate(_ runtime.Object) (admission.Warnings, error)

ValidateUpdate implements webhook.Validator so a webhook will be registered for the type

type BackupConfiguration 

type BackupConfiguration struct {
	// VolumeSnapshot provides the configuration for the execution of volume snapshot backups.
	// +optional
	VolumeSnapshot *VolumeSnapshotConfiguration `json:"volumeSnapshot,omitempty"`

	// The configuration for the barman-cloud tool suite
	// +optional
	BarmanObjectStore *BarmanObjectStoreConfiguration `json:"barmanObjectStore,omitempty"`

	// RetentionPolicy is the retention policy to be used for backups
	// and WALs (i.e. '60d'). The retention policy is expressed in the form
	// of `XXu` where `XX` is a positive integer and `u` is in `[dwm]` -
	// days, weeks, months.
	// It's currently only applicable when using the BarmanObjectStore method.
	// +kubebuilder:validation:Pattern=^[1-9][0-9]*[dwm]$
	// +optional
	RetentionPolicy string `json:"retentionPolicy,omitempty"`

	// The policy to decide which instance should perform backups. Available
	// options are empty string, which will default to `prefer-standby` policy,
	// `primary` to have backups run always on primary instances, `prefer-standby`
	// to have backups run preferably on the most updated standby, if available.
	// +kubebuilder:validation:Enum=primary;prefer-standby
	// +kubebuilder:default:=prefer-standby
	// +optional
	Target BackupTarget `json:"target,omitempty"`
}

BackupConfiguration defines how the backup of the cluster are taken. The supported backup methods are BarmanObjectStore and VolumeSnapshot. For details and examples refer to the Backup and Recovery section of the documentation

func (*BackupConfiguration) DeepCopy 

func (in *BackupConfiguration) DeepCopy() *BackupConfiguration

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

func (*BackupConfiguration) DeepCopyInto 

func (in *BackupConfiguration) DeepCopyInto(out *BackupConfiguration)

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

func (*BackupConfiguration) IsBarmanBackupConfigured added in v1.15.1 

func (backupConfiguration *BackupConfiguration) IsBarmanBackupConfigured() bool

IsBarmanBackupConfigured returns true if one of the possible backup destination is configured, false otherwise

func (*BackupConfiguration) IsBarmanEndpointCASet 

func (backupConfiguration *BackupConfiguration) IsBarmanEndpointCASet() bool

IsBarmanEndpointCASet returns true if we have a CA bundle for the endpoint false otherwise

type BackupList 

type BackupList struct {
	metav1.TypeMeta `json:",inline"`
	// Standard list metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	metav1.ListMeta `json:"metadata,omitempty"`
	// List of backups
	Items []Backup `json:"items"`
}

BackupList contains a list of Backup

func (*BackupList) CanExecuteBackup added in v1.21.0 

func (list *BackupList) CanExecuteBackup(backupName string) bool

CanExecuteBackup control if we can start a reconciliation loop for a certain backup.

A reconciliation loop can start if: - there's no backup running, and if the first of the sorted list of backups - the current backup is running and is the first running backup of the list

As a side effect, this function will sort the backup list

func (*BackupList) DeepCopy 

func (in *BackupList) DeepCopy() *BackupList

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

func (*BackupList) DeepCopyInto 

func (in *BackupList) DeepCopyInto(out *BackupList)

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

func (*BackupList) DeepCopyObject 

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

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

func (BackupList) GetPendingBackupNames added in v1.21.0 

func (list BackupList) GetPendingBackupNames() []string

GetPendingBackupNames returns the pending backup list

func (*BackupList) SortByName added in v1.21.0 

func (list *BackupList) SortByName()

SortByName sorts the backup items in alphabetical order

func (*BackupList) SortByReverseCreationTime added in v1.21.0 

func (list *BackupList) SortByReverseCreationTime()

SortByReverseCreationTime sorts the backup items in reverse creation time (starting from the latest one)

type BackupMethod added in v1.21.0 

type BackupMethod string

BackupMethod defines the way of executing the physical base backups of the selected PostgreSQL instance 

const (
	// BackupMethodVolumeSnapshot means using the volume snapshot
	// Kubernetes feature
	BackupMethodVolumeSnapshot BackupMethod = "volumeSnapshot"

	// BackupMethodBarmanObjectStore means using barman to backup the
	// PostgreSQL cluster
	BackupMethodBarmanObjectStore BackupMethod = "barmanObjectStore"
)

type BackupPhase 

type BackupPhase string

BackupPhase is the phase of the backup

type BackupSnapshotElementStatus added in v1.21.0 

type BackupSnapshotElementStatus struct {
	// Name is the snapshot resource name
	Name string `json:"name"`

	// Type is tho role of the snapshot in the cluster, such as PG_DATA, PG_WAL and PG_TABLESPACE
	Type string `json:"type"`

	// TablespaceName is the name of the snapshotted tablespace. Only set
	// when type is PG_TABLESPACE
	TablespaceName string `json:"tablespaceName,omitempty"`
}

BackupSnapshotElementStatus is a volume snapshot that is part of a volume snapshot method backup

func (*BackupSnapshotElementStatus) DeepCopy added in v1.21.0 

func (in *BackupSnapshotElementStatus) DeepCopy() *BackupSnapshotElementStatus

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

func (*BackupSnapshotElementStatus) DeepCopyInto added in v1.21.0 

func (in *BackupSnapshotElementStatus) DeepCopyInto(out *BackupSnapshotElementStatus)

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

type BackupSnapshotStatus added in v1.21.0 

type BackupSnapshotStatus struct {
	// The elements list, populated with the gathered volume snapshots
	// +optional
	Elements []BackupSnapshotElementStatus `json:"elements,omitempty"`
}

BackupSnapshotStatus the fields exclusive to the volumeSnapshot method backup

func (*BackupSnapshotStatus) DeepCopy added in v1.21.0 

func (in *BackupSnapshotStatus) DeepCopy() *BackupSnapshotStatus

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

func (*BackupSnapshotStatus) DeepCopyInto added in v1.21.0 

func (in *BackupSnapshotStatus) DeepCopyInto(out *BackupSnapshotStatus)

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

func (*BackupSnapshotStatus) SetSnapshotElements added in v1.21.0 

func (snapshotStatus *BackupSnapshotStatus) SetSnapshotElements(snapshots []volumesnapshot.VolumeSnapshot)

SetSnapshotElements sets the Snapshots field from a list of VolumeSnapshot

type BackupSource 

type BackupSource struct {
	LocalObjectReference `json:",inline"`
	// EndpointCA store the CA bundle of the barman endpoint.
	// Useful when using self-signed certificates to avoid
	// errors with certificate issuer and barman-cloud-wal-archive.
	// +optional
	EndpointCA *SecretKeySelector `json:"endpointCA,omitempty"`
}

BackupSource contains the backup we need to restore from, plus some information that could be needed to correctly restore it.

func (*BackupSource) DeepCopy 

func (in *BackupSource) DeepCopy() *BackupSource

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

func (*BackupSource) DeepCopyInto 

func (in *BackupSource) DeepCopyInto(out *BackupSource)

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

type BackupSpec 

type BackupSpec struct {
	// The cluster to backup
	Cluster LocalObjectReference `json:"cluster"`

	// The policy to decide which instance should perform this backup. If empty,
	// it defaults to `cluster.spec.backup.target`.
	// Available options are empty string, `primary` and `prefer-standby`.
	// `primary` to have backups run always on primary instances,
	// `prefer-standby` to have backups run preferably on the most updated
	// standby, if available.
	// +optional
	// +kubebuilder:validation:Enum=primary;prefer-standby
	Target BackupTarget `json:"target,omitempty"`

	// The backup method to be used, possible options are `barmanObjectStore`
	// and `volumeSnapshot`. Defaults to: `barmanObjectStore`.
	// +optional
	// +kubebuilder:validation:Enum=barmanObjectStore;volumeSnapshot
	// +kubebuilder:default:=barmanObjectStore
	Method BackupMethod `json:"method,omitempty"`

	// Whether the default type of backup with volume snapshots is
	// online/hot (`true`, default) or offline/cold (`false`)
	// Overrides the default setting specified in the cluster field '.spec.backup.volumeSnapshot.online'
	// +optional
	Online *bool `json:"online,omitempty"`

	// Configuration parameters to control the online/hot backup with volume snapshots
	// Overrides the default settings specified in the cluster '.backup.volumeSnapshot.onlineConfiguration' stanza
	// +optional
	OnlineConfiguration *OnlineConfiguration `json:"onlineConfiguration,omitempty"`
}

BackupSpec defines the desired state of Backup

func (*BackupSpec) DeepCopy 

func (in *BackupSpec) DeepCopy() *BackupSpec

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

func (*BackupSpec) DeepCopyInto 

func (in *BackupSpec) DeepCopyInto(out *BackupSpec)

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

type BackupStatus 

type BackupStatus struct {
	// The potential credentials for each cloud provider
	BarmanCredentials `json:",inline"`

	// EndpointCA store the CA bundle of the barman endpoint.
	// Useful when using self-signed certificates to avoid
	// errors with certificate issuer and barman-cloud-wal-archive.
	// +optional
	EndpointCA *SecretKeySelector `json:"endpointCA,omitempty"`

	// Endpoint to be used to upload data to the cloud,
	// overriding the automatic endpoint discovery
	// +optional
	EndpointURL string `json:"endpointURL,omitempty"`

	// The path where to store the backup (i.e. s3://bucket/path/to/folder)
	// this path, with different destination folders, will be used for WALs
	// and for data. This may not be populated in case of errors.
	// +optional
	DestinationPath string `json:"destinationPath,omitempty"`

	// The server name on S3, the cluster name is used if this
	// parameter is omitted
	// +optional
	ServerName string `json:"serverName,omitempty"`

	// Encryption method required to S3 API
	// +optional
	Encryption string `json:"encryption,omitempty"`

	// The ID of the Barman backup
	// +optional
	BackupID string `json:"backupId,omitempty"`

	// The Name of the Barman backup
	// +optional
	BackupName string `json:"backupName,omitempty"`

	// The last backup status
	// +optional
	Phase BackupPhase `json:"phase,omitempty"`

	// When the backup was started
	// +optional
	StartedAt *metav1.Time `json:"startedAt,omitempty"`

	// When the backup was terminated
	// +optional
	StoppedAt *metav1.Time `json:"stoppedAt,omitempty"`

	// The starting WAL
	// +optional
	BeginWal string `json:"beginWal,omitempty"`

	// The ending WAL
	// +optional
	EndWal string `json:"endWal,omitempty"`

	// The starting xlog
	// +optional
	BeginLSN string `json:"beginLSN,omitempty"`

	// The ending xlog
	// +optional
	EndLSN string `json:"endLSN,omitempty"`

	// The detected error
	// +optional
	Error string `json:"error,omitempty"`

	// Unused. Retained for compatibility with old versions.
	// +optional
	CommandOutput string `json:"commandOutput,omitempty"`

	// The backup command output in case of error
	// +optional
	CommandError string `json:"commandError,omitempty"`

	// Backup label file content as returned by Postgres in case of online (hot) backups
	// +optional
	BackupLabelFile []byte `json:"backupLabelFile,omitempty"`

	// Tablespace map file content as returned by Postgres in case of online (hot) backups
	// +optional
	TablespaceMapFile []byte `json:"tablespaceMapFile,omitempty"`

	// Information to identify the instance where the backup has been taken from
	// +optional
	InstanceID *InstanceID `json:"instanceID,omitempty"`

	// Status of the volumeSnapshot backup
	// +optional
	BackupSnapshotStatus BackupSnapshotStatus `json:"snapshotBackupStatus,omitempty"`

	// The backup method being used
	// +optional
	Method BackupMethod `json:"method,omitempty"`

	// Whether the backup was online/hot (`true`) or offline/cold (`false`)
	Online *bool `json:"online,omitempty"`
}

BackupStatus defines the observed state of Backup

func (*BackupStatus) DeepCopy 

func (in *BackupStatus) DeepCopy() *BackupStatus

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

func (*BackupStatus) DeepCopyInto 

func (in *BackupStatus) DeepCopyInto(out *BackupStatus)

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

func (*BackupStatus) GetOnline added in v1.21.1 

func (backupStatus *BackupStatus) GetOnline() bool

GetOnline tells whether this backup was taken while the database was up

func (*BackupStatus) IsDone 

func (backupStatus *BackupStatus) IsDone() bool

IsDone check if a backup is completed or still in progress

func (*BackupStatus) IsInProgress 

func (backupStatus *BackupStatus) IsInProgress() bool

IsInProgress check if a certain backup is in progress or not

func (*BackupStatus) SetAsCompleted 

func (backupStatus *BackupStatus) SetAsCompleted()

SetAsCompleted marks a certain backup as completed

func (*BackupStatus) SetAsFailed 

func (backupStatus *BackupStatus) SetAsFailed(
	err error,
)

SetAsFailed marks a certain backup as invalid

func (*BackupStatus) SetAsFinalizing added in v1.21.1 

func (backupStatus *BackupStatus) SetAsFinalizing()

SetAsFinalizing marks a certain backup as finalizing

func (*BackupStatus) SetAsStarted added in v1.21.0 

func (backupStatus *BackupStatus) SetAsStarted(podName, containerID string, method BackupMethod)

SetAsStarted marks a certain backup as started

type BackupTarget added in v1.19.0 

type BackupTarget string

BackupTarget describes the preferred targets for a backup

type BarmanCredentials added in v1.16.1 

type BarmanCredentials struct {
	// The credentials to use to upload data to Google Cloud Storage
	// +optional
	Google *GoogleCredentials `json:"googleCredentials,omitempty"`

	// The credentials to use to upload data to S3
	// +optional
	AWS *S3Credentials `json:"s3Credentials,omitempty"`

	// The credentials to use to upload data to Azure Blob Storage
	// +optional
	Azure *AzureCredentials `json:"azureCredentials,omitempty"`
}

BarmanCredentials an object containing the potential credentials for each cloud provider

func (BarmanCredentials) ArePopulated added in v1.16.1 

func (crendentials BarmanCredentials) ArePopulated() bool

ArePopulated checks if the passed set of credentials contains something

func (*BarmanCredentials) DeepCopy added in v1.16.1 

func (in *BarmanCredentials) DeepCopy() *BarmanCredentials

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

func (*BarmanCredentials) DeepCopyInto added in v1.16.1 

func (in *BarmanCredentials) DeepCopyInto(out *BarmanCredentials)

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

type BarmanObjectStoreConfiguration 

type BarmanObjectStoreConfiguration struct {
	// The potential credentials for each cloud provider
	BarmanCredentials `json:",inline"`

	// Endpoint to be used to upload data to the cloud,
	// overriding the automatic endpoint discovery
	// +optional
	EndpointURL string `json:"endpointURL,omitempty"`

	// EndpointCA store the CA bundle of the barman endpoint.
	// Useful when using self-signed certificates to avoid
	// errors with certificate issuer and barman-cloud-wal-archive
	// +optional
	EndpointCA *SecretKeySelector `json:"endpointCA,omitempty"`

	// The path where to store the backup (i.e. s3://bucket/path/to/folder)
	// this path, with different destination folders, will be used for WALs
	// and for data
	// +kubebuilder:validation:MinLength=1
	DestinationPath string `json:"destinationPath"`

	// The server name on S3, the cluster name is used if this
	// parameter is omitted
	// +optional
	ServerName string `json:"serverName,omitempty"`

	// The configuration for the backup of the WAL stream.
	// When not defined, WAL files will be stored uncompressed and may be
	// unencrypted in the object store, according to the bucket default policy.
	// +optional
	Wal *WalBackupConfiguration `json:"wal,omitempty"`

	// The configuration to be used to backup the data files
	// When not defined, base backups files will be stored uncompressed and may
	// be unencrypted in the object store, according to the bucket default
	// policy.
	// +optional
	Data *DataBackupConfiguration `json:"data,omitempty"`

	// Tags is a list of key value pairs that will be passed to the
	// Barman --tags option.
	// +optional
	Tags map[string]string `json:"tags,omitempty"`

	// HistoryTags is a list of key value pairs that will be passed to the
	// Barman --history-tags option.
	// +optional
	HistoryTags map[string]string `json:"historyTags,omitempty"`
}

BarmanObjectStoreConfiguration contains the backup configuration using Barman against an S3-compatible object storage

func (*BarmanObjectStoreConfiguration) AppendAdditionalCommandArgs added in v1.21.4 

func (cfg *BarmanObjectStoreConfiguration) AppendAdditionalCommandArgs(options []string) []string

AppendAdditionalCommandArgs adds custom arguments as barman cloud command-line options

func (*BarmanObjectStoreConfiguration) DeepCopy 

func (in *BarmanObjectStoreConfiguration) DeepCopy() *BarmanObjectStoreConfiguration

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

func (*BarmanObjectStoreConfiguration) DeepCopyInto 

func (in *BarmanObjectStoreConfiguration) DeepCopyInto(out *BarmanObjectStoreConfiguration)

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

type BootstrapConfiguration 

type BootstrapConfiguration struct {
	// Bootstrap the cluster via initdb
	// +optional
	InitDB *BootstrapInitDB `json:"initdb,omitempty"`

	// Bootstrap the cluster from a backup
	// +optional
	Recovery *BootstrapRecovery `json:"recovery,omitempty"`

	// Bootstrap the cluster taking a physical backup of another compatible
	// PostgreSQL instance
	// +optional
	PgBaseBackup *BootstrapPgBaseBackup `json:"pg_basebackup,omitempty"`
}

BootstrapConfiguration contains information about how to create the PostgreSQL cluster. Only a single bootstrap method can be defined among the supported ones. `initdb` will be used as the bootstrap method if left unspecified. Refer to the Bootstrap page of the documentation for more information.

func (*BootstrapConfiguration) DeepCopy 

func (in *BootstrapConfiguration) DeepCopy() *BootstrapConfiguration

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

func (*BootstrapConfiguration) DeepCopyInto 

func (in *BootstrapConfiguration) DeepCopyInto(out *BootstrapConfiguration)

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

type BootstrapInitDB 

type BootstrapInitDB struct {
	// Name of the database used by the application. Default: `app`.
	// +optional
	Database string `json:"database,omitempty"`

	// Name of the owner of the database in the instance to be used
	// by applications. Defaults to the value of the `database` key.
	// +optional
	Owner string `json:"owner,omitempty"`

	// Name of the secret containing the initial credentials for the
	// owner of the user database. If empty a new secret will be
	// created from scratch
	// +optional
	Secret *LocalObjectReference `json:"secret,omitempty"`

	// The list of options that must be passed to initdb when creating the cluster.
	// Deprecated: This could lead to inconsistent configurations,
	// please use the explicit provided parameters instead.
	// If defined, explicit values will be ignored.
	// +optional
	Options []string `json:"options,omitempty"`

	// Whether the `-k` option should be passed to initdb,
	// enabling checksums on data pages (default: `false`)
	// +optional
	DataChecksums *bool `json:"dataChecksums,omitempty"`

	// The value to be passed as option `--encoding` for initdb (default:`UTF8`)
	// +optional
	Encoding string `json:"encoding,omitempty"`

	// The value to be passed as option `--lc-collate` for initdb (default:`C`)
	// +optional
	LocaleCollate string `json:"localeCollate,omitempty"`

	// The value to be passed as option `--lc-ctype` for initdb (default:`C`)
	// +optional
	LocaleCType string `json:"localeCType,omitempty"`

	// The value in megabytes (1 to 1024) to be passed to the `--wal-segsize`
	// option for initdb (default: empty, resulting in PostgreSQL default: 16MB)
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=1024
	// +optional
	WalSegmentSize int `json:"walSegmentSize,omitempty"`

	// List of SQL queries to be executed as a superuser immediately
	// after the cluster has been created - to be used with extreme care
	// (by default empty)
	// +optional
	PostInitSQL []string `json:"postInitSQL,omitempty"`

	// List of SQL queries to be executed as a superuser in the application
	// database right after is created - to be used with extreme care
	// (by default empty)
	// +optional
	PostInitApplicationSQL []string `json:"postInitApplicationSQL,omitempty"`

	// List of SQL queries to be executed as a superuser in the `template1`
	// after the cluster has been created - to be used with extreme care
	// (by default empty)
	// +optional
	PostInitTemplateSQL []string `json:"postInitTemplateSQL,omitempty"`

	// Bootstraps the new cluster by importing data from an existing PostgreSQL
	// instance using logical backup (`pg_dump` and `pg_restore`)
	// +optional
	Import *Import `json:"import,omitempty"`

	// PostInitApplicationSQLRefs points references to ConfigMaps or Secrets which
	// contain SQL files, the general implementation order to these references is
	// from all Secrets to all ConfigMaps, and inside Secrets or ConfigMaps,
	// the implementation order is same as the order of each array
	// (by default empty)
	// +optional
	PostInitApplicationSQLRefs *PostInitApplicationSQLRefs `json:"postInitApplicationSQLRefs,omitempty"`
}

BootstrapInitDB is the configuration of the bootstrap process when initdb is used Refer to the Bootstrap page of the documentation for more information.

func (*BootstrapInitDB) DeepCopy 

func (in *BootstrapInitDB) DeepCopy() *BootstrapInitDB

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

func (*BootstrapInitDB) DeepCopyInto 

func (in *BootstrapInitDB) DeepCopyInto(out *BootstrapInitDB)

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

type BootstrapPgBaseBackup 

type BootstrapPgBaseBackup struct {
	// The name of the server of which we need to take a physical backup
	// +kubebuilder:validation:MinLength=1
	Source string `json:"source"`

	// Name of the database used by the application. Default: `app`.
	// +optional
	Database string `json:"database,omitempty"`

	// Name of the owner of the database in the instance to be used
	// by applications. Defaults to the value of the `database` key.
	// +optional
	Owner string `json:"owner,omitempty"`

	// Name of the secret containing the initial credentials for the
	// owner of the user database. If empty a new secret will be
	// created from scratch
	// +optional
	Secret *LocalObjectReference `json:"secret,omitempty"`
}

BootstrapPgBaseBackup contains the configuration required to take a physical backup of an existing PostgreSQL cluster

func (*BootstrapPgBaseBackup) DeepCopy 

func (in *BootstrapPgBaseBackup) DeepCopy() *BootstrapPgBaseBackup

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

func (*BootstrapPgBaseBackup) DeepCopyInto 

func (in *BootstrapPgBaseBackup) DeepCopyInto(out *BootstrapPgBaseBackup)

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

type BootstrapRecovery 

type BootstrapRecovery struct {
	// The backup object containing the physical base backup from which to
	// initiate the recovery procedure.
	// Mutually exclusive with `source` and `volumeSnapshots`.
	// +optional
	Backup *BackupSource `json:"backup,omitempty"`

	// The external cluster whose backup we will restore. This is also
	// used as the name of the folder under which the backup is stored,
	// so it must be set to the name of the source cluster
	// Mutually exclusive with `backup`.
	// +optional
	Source string `json:"source,omitempty"`

	// The static PVC data source(s) from which to initiate the
	// recovery procedure. Currently supporting `VolumeSnapshot`
	// and `PersistentVolumeClaim` resources that map an existing
	// PVC group, compatible with CloudNativePG, and taken with
	// a cold backup copy on a fenced Postgres instance (limitation
	// which will be removed in the future when online backup
	// will be implemented).
	// Mutually exclusive with `backup`.
	// +optional
	VolumeSnapshots *DataSource `json:"volumeSnapshots,omitempty"`

	// By default, the recovery process applies all the available
	// WAL files in the archive (full recovery). However, you can also
	// end the recovery as soon as a consistent state is reached or
	// recover to a point-in-time (PITR) by specifying a `RecoveryTarget` object,
	// as expected by PostgreSQL (i.e., timestamp, transaction Id, LSN, ...).
	// More info: https://www.postgresql.org/docs/current/runtime-config-wal.html#RUNTIME-CONFIG-WAL-RECOVERY-TARGET
	// +optional
	RecoveryTarget *RecoveryTarget `json:"recoveryTarget,omitempty"`

	// Name of the database used by the application. Default: `app`.
	// +optional
	Database string `json:"database,omitempty"`

	// Name of the owner of the database in the instance to be used
	// by applications. Defaults to the value of the `database` key.
	// +optional
	Owner string `json:"owner,omitempty"`

	// Name of the secret containing the initial credentials for the
	// owner of the user database. If empty a new secret will be
	// created from scratch
	// +optional
	Secret *LocalObjectReference `json:"secret,omitempty"`
}

BootstrapRecovery contains the configuration required to restore from an existing cluster using 3 methodologies: external cluster, volume snapshots or backup objects. Full recovery and Point-In-Time Recovery are supported. The method can be also be used to create clusters in continuous recovery (replica clusters), also supporting cascading replication when `instances` > 1. Once the cluster exits recovery, the password for the superuser will be changed through the provided secret. Refer to the Bootstrap page of the documentation for more information.

func (*BootstrapRecovery) DeepCopy 

func (in *BootstrapRecovery) DeepCopy() *BootstrapRecovery

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

func (*BootstrapRecovery) DeepCopyInto 

func (in *BootstrapRecovery) DeepCopyInto(out *BootstrapRecovery)

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

type CertificatesConfiguration 

type CertificatesConfiguration struct {
	// The secret containing the Server CA certificate. If not defined, a new secret will be created
	// with a self-signed CA and will be used to generate the TLS certificate ServerTLSSecret.<br />
	// <br />
	// Contains:<br />
	// <br />
	// - `ca.crt`: CA that should be used to validate the server certificate,
	// used as `sslrootcert` in client connection strings.<br />
	// - `ca.key`: key used to generate Server SSL certs, if ServerTLSSecret is provided,
	// this can be omitted.<br />
	// +optional
	ServerCASecret string `json:"serverCASecret,omitempty"`

	// The secret of type kubernetes.io/tls containing the server TLS certificate and key that will be set as
	// `ssl_cert_file` and `ssl_key_file` so that clients can connect to postgres securely.
	// If not defined, ServerCASecret must provide also `ca.key` and a new secret will be
	// created using the provided CA.
	// +optional
	ServerTLSSecret string `json:"serverTLSSecret,omitempty"`

	// The secret of type kubernetes.io/tls containing the client certificate to authenticate as
	// the `streaming_replica` user.
	// If not defined, ClientCASecret must provide also `ca.key`, and a new secret will be
	// created using the provided CA.
	// +optional
	ReplicationTLSSecret string `json:"replicationTLSSecret,omitempty"`

	// The secret containing the Client CA certificate. If not defined, a new secret will be created
	// with a self-signed CA and will be used to generate all the client certificates.<br />
	// <br />
	// Contains:<br />
	// <br />
	// - `ca.crt`: CA that should be used to validate the client certificates,
	// used as `ssl_ca_file` of all the instances.<br />
	// - `ca.key`: key used to generate client certificates, if ReplicationTLSSecret is provided,
	// this can be omitted.<br />
	// +optional
	ClientCASecret string `json:"clientCASecret,omitempty"`

	// The list of the server alternative DNS names to be added to the generated server TLS certificates, when required.
	// +optional
	ServerAltDNSNames []string `json:"serverAltDNSNames,omitempty"`
}

CertificatesConfiguration contains the needed configurations to handle server certificates.

func (*CertificatesConfiguration) DeepCopy 

func (in *CertificatesConfiguration) DeepCopy() *CertificatesConfiguration

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

func (*CertificatesConfiguration) DeepCopyInto 

func (in *CertificatesConfiguration) DeepCopyInto(out *CertificatesConfiguration)

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

type CertificatesStatus 

type CertificatesStatus struct {
	// Needed configurations to handle server certificates, initialized with default values, if needed.
	CertificatesConfiguration `json:",inline"`

	// Expiration dates for all certificates.
	// +optional
	Expirations map[string]string `json:"expirations,omitempty"`
}

CertificatesStatus contains configuration certificates and related expiration dates.

func (*CertificatesStatus) DeepCopy 

func (in *CertificatesStatus) DeepCopy() *CertificatesStatus

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

func (*CertificatesStatus) DeepCopyInto 

func (in *CertificatesStatus) DeepCopyInto(out *CertificatesStatus)

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

type Cluster 

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

	// Specification of the desired behavior of the cluster.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	Spec ClusterSpec `json:"spec"`
	// Most recently observed status of the cluster. This data may not be up
	// to date. Populated by the system. Read-only.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	// +optional
	Status ClusterStatus `json:"status,omitempty"`
}

Cluster is the Schema for the PostgreSQL API

func (*Cluster) ContainsManagedRolesConfiguration added in v1.20.0 

func (cluster *Cluster) ContainsManagedRolesConfiguration() bool

ContainsManagedRolesConfiguration returns true iff there are managed roles configured

func (*Cluster) ContainsTablespaces added in v1.22.0 

func (cluster *Cluster) ContainsTablespaces() bool

ContainsTablespaces returns true if for this cluster, we need to create tablespaces

func (*Cluster) DeepCopy 

func (in *Cluster) DeepCopy() *Cluster

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

func (*Cluster) DeepCopyInto 

func (in *Cluster) DeepCopyInto(out *Cluster)

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

func (*Cluster) DeepCopyObject 

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

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

func (*Cluster) Default 

func (r *Cluster) Default()

Default implements webhook.Defaulter so a webhook will be registered for the type

func (Cluster) ExternalCluster 

func (cluster Cluster) ExternalCluster(name string) (ExternalCluster, bool)

ExternalCluster gets the external server with a known name, returning true if the server was found and false otherwise

func (*Cluster) GetApplicationDatabaseName added in v1.16.0 

func (cluster *Cluster) GetApplicationDatabaseName() string

GetApplicationDatabaseName get the name of the application database for a specific bootstrap

func (*Cluster) GetApplicationDatabaseOwner added in v1.16.0 

func (cluster *Cluster) GetApplicationDatabaseOwner() string

GetApplicationDatabaseOwner get the owner user of the application database for a specific bootstrap

func (*Cluster) GetApplicationSecretName 

func (cluster *Cluster) GetApplicationSecretName() string

GetApplicationSecretName get the name of the application secret for any bootstrap type

func (Cluster) GetBarmanEndpointCAForReplicaCluster 

func (cluster Cluster) GetBarmanEndpointCAForReplicaCluster() *SecretKeySelector

GetBarmanEndpointCAForReplicaCluster checks if this is a replica cluster which needs barman endpoint CA

func (*Cluster) GetClientCASecretName 

func (cluster *Cluster) GetClientCASecretName() string

GetClientCASecretName get the name of the secret containing the CA of the cluster

func (*Cluster) GetClusterAltDNSNames 

func (cluster *Cluster) GetClusterAltDNSNames() []string

GetClusterAltDNSNames returns all the names needed to build a valid Server Certificate

func (*Cluster) GetCoredumpFilter added in v1.19.5 

func (cluster *Cluster) GetCoredumpFilter() string

GetCoredumpFilter get the coredump filter value from the cluster annotation

func (*Cluster) GetEnableLDAPAuth 

func (cluster *Cluster) GetEnableLDAPAuth() bool

GetEnableLDAPAuth return true if bind or bind+search method are configured in the cluster configuration

func (*Cluster) GetEnableSuperuserAccess 

func (cluster *Cluster) GetEnableSuperuserAccess() bool

GetEnableSuperuserAccess returns if the superuser access is enabled or not

func (*Cluster) GetExternalClusterSecrets added in v1.20.5 

func (cluster *Cluster) GetExternalClusterSecrets() *stringset.Data

GetExternalClusterSecrets returns the secrets used by external Clusters

func (*Cluster) GetFixedInheritedAnnotations 

func (cluster *Cluster) GetFixedInheritedAnnotations() map[string]string

GetFixedInheritedAnnotations gets the annotations that should be inherited by all resources according the cluster spec

func (*Cluster) GetFixedInheritedLabels 

func (cluster *Cluster) GetFixedInheritedLabels() map[string]string

GetFixedInheritedLabels gets the labels that should be inherited by all resources according the cluster spec

func (*Cluster) GetImageName 

func (cluster *Cluster) GetImageName() string

GetImageName get the name of the image that should be used to create the pods

func (*Cluster) GetImagePullSecret 

func (cluster *Cluster) GetImagePullSecret() string

GetImagePullSecret get the name of the pull secret to use to download the PostgreSQL image

func (*Cluster) GetLDAPSecretName 

func (cluster *Cluster) GetLDAPSecretName() string

GetLDAPSecretName gets the secret name containing the LDAP password

func (*Cluster) GetMaxStartDelay 

func (cluster *Cluster) GetMaxStartDelay() int32

GetMaxStartDelay get the amount of time of startDelay config option

func (*Cluster) GetMaxStopDelay 

func (cluster *Cluster) GetMaxStopDelay() int32

GetMaxStopDelay get the amount of time PostgreSQL has to stop

func (*Cluster) GetMaxSwitchoverDelay 

func (cluster *Cluster) GetMaxSwitchoverDelay() int32

GetMaxSwitchoverDelay get the amount of time PostgreSQL has to stop before switchover

func (*Cluster) GetPgCtlTimeoutForPromotion 

func (cluster *Cluster) GetPgCtlTimeoutForPromotion() int32

GetPgCtlTimeoutForPromotion returns the timeout that should be waited for an instance to be promoted to primary. As default, DefaultPgCtlTimeoutForPromotion is big enough to simulate an infinite timeout

func (Cluster) GetPostgresGID 

func (cluster Cluster) GetPostgresGID() int64

GetPostgresGID returns the GID that is being used for the "postgres" user

func (Cluster) GetPostgresUID 

func (cluster Cluster) GetPostgresUID() int64

GetPostgresUID returns the UID that is being used for the "postgres" user

func (*Cluster) GetPostgresqlVersion 

func (cluster *Cluster) GetPostgresqlVersion() (int, error)

GetPostgresqlVersion gets the PostgreSQL image version detecting it from the image name. Example:

ghcr.io/cloudnative-pg/postgresql:14.0 corresponds to version 140000 ghcr.io/cloudnative-pg/postgresql:13.2 corresponds to version 130002 ghcr.io/cloudnative-pg/postgresql:9.6.3 corresponds to version 90603

func (*Cluster) GetPrimaryUpdateMethod 

func (cluster *Cluster) GetPrimaryUpdateMethod() PrimaryUpdateMethod

GetPrimaryUpdateMethod get the cluster primary update method, defaulting to restart

func (*Cluster) GetPrimaryUpdateStrategy 

func (cluster *Cluster) GetPrimaryUpdateStrategy() PrimaryUpdateStrategy

GetPrimaryUpdateStrategy get the cluster primary update strategy, defaulting to unsupervised

func (*Cluster) GetReplicationSecretName 

func (cluster *Cluster) GetReplicationSecretName() string

GetReplicationSecretName get the name of the secret for the replication user

func (*Cluster) GetRestartTimeout added in v1.21.6 

func (cluster *Cluster) GetRestartTimeout() int32

GetRestartTimeout is used to have a timeout for operations that involve a restart of a PostgreSQL instance

func (*Cluster) GetSeccompProfile added in v1.18.4 

func (cluster *Cluster) GetSeccompProfile() *corev1.SeccompProfile

GetSeccompProfile return the proper SeccompProfile set in the cluster for Pods and Containers

func (*Cluster) GetServerCASecretName 

func (cluster *Cluster) GetServerCASecretName() string

GetServerCASecretName get the name of the secret containing the CA of the cluster

func (*Cluster) GetServerTLSSecretName 

func (cluster *Cluster) GetServerTLSSecretName() string

GetServerTLSSecretName get the name of the secret containing the certificate that is used for the PostgreSQL servers

func (*Cluster) GetServiceAnyName 

func (cluster *Cluster) GetServiceAnyName() string

GetServiceAnyName return the name of the service that is used as DNS domain for all the nodes, even if they are not ready

func (*Cluster) GetServiceReadName 

func (cluster *Cluster) GetServiceReadName() string

GetServiceReadName return the name of the service that is used for read transactions (including the primary)

func (*Cluster) GetServiceReadOnlyName 

func (cluster *Cluster) GetServiceReadOnlyName() string

GetServiceReadOnlyName return the name of the service that is used for read-only transactions (excluding the primary)

func (*Cluster) GetServiceReadWriteName 

func (cluster *Cluster) GetServiceReadWriteName() string

GetServiceReadWriteName return the name of the service that is used for read-write transactions

func (Cluster) GetSlotNameFromInstanceName added in v1.18.0 

func (cluster Cluster) GetSlotNameFromInstanceName(instanceName string) string

GetSlotNameFromInstanceName returns the slot name, given the instance name. It returns an empty string if High Availability Replication Slots are disabled

func (*Cluster) GetSmartShutdownTimeout added in v1.21.0 

func (cluster *Cluster) GetSmartShutdownTimeout() int32

GetSmartShutdownTimeout is used to ensure that smart shutdown timeout is a positive integer

func (*Cluster) GetSuperuserSecretName 

func (cluster *Cluster) GetSuperuserSecretName() string

GetSuperuserSecretName get the secret name of the PostgreSQL superuser

func (*Cluster) GetSyncReplicasData added in v1.16.0 

func (cluster *Cluster) GetSyncReplicasData() (syncReplicas int, electableSyncReplicas []string)

GetSyncReplicasData computes the actual number of required synchronous replicas and the names of the electable sync replicas given the requested min, max, the number of ready replicas in the cluster and the sync replicas constraints (if any)

func (*Cluster) GetTablespaceConfiguration added in v1.22.0 

func (cluster *Cluster) GetTablespaceConfiguration(name string) *TablespaceConfiguration

GetTablespaceConfiguration returns the tablespaceConfiguration for the given name otherwise return nil

func (*Cluster) IsInplaceRestartPhase added in v1.19.5 

func (cluster *Cluster) IsInplaceRestartPhase() bool

IsInplaceRestartPhase returns true if the cluster is in a phase that handles the Inplace restart

func (*Cluster) IsInstanceFenced 

func (cluster *Cluster) IsInstanceFenced(instance string) bool

IsInstanceFenced check if in a given instance should be fenced

func (*Cluster) IsNodeMaintenanceWindowInProgress 

func (cluster *Cluster) IsNodeMaintenanceWindowInProgress() bool

IsNodeMaintenanceWindowInProgress check if the upgrade mode is active or not

func (*Cluster) IsPodMonitorEnabled 

func (cluster *Cluster) IsPodMonitorEnabled() bool

IsPodMonitorEnabled checks if the PodMonitor object needs to be created

func (Cluster) IsReplica 

func (cluster Cluster) IsReplica() bool

IsReplica checks if this is a replica cluster or not

func (*Cluster) IsReusePVCEnabled 

func (cluster *Cluster) IsReusePVCEnabled() bool

IsReusePVCEnabled check if in a maintenance window we should reuse PVCs

func (*Cluster) LogTimestampsWithMessage added in v1.15.3 

func (cluster *Cluster) LogTimestampsWithMessage(ctx context.Context, logMessage string)

LogTimestampsWithMessage prints useful information about timestamps in stdout

func (*Cluster) SetDefaults 

func (r *Cluster) SetDefaults()

SetDefaults apply the defaults to undefined values in a Cluster

func (*Cluster) SetInheritedData added in v1.19.4 

func (cluster *Cluster) SetInheritedData(obj *metav1.ObjectMeta)

SetInheritedData sets all the needed annotations and labels

func (*Cluster) SetInheritedDataAndOwnership added in v1.17.4 

func (cluster *Cluster) SetInheritedDataAndOwnership(obj *metav1.ObjectMeta)

SetInheritedDataAndOwnership sets the cluster as owner of the passed object and then sets all the needed annotations and labels

func (*Cluster) SetupWebhookWithManager 

func (r *Cluster) SetupWebhookWithManager(mgr ctrl.Manager) error

SetupWebhookWithManager setup the webhook inside the controller manager

func (*Cluster) ShouldCreateApplicationDatabase 

func (cluster *Cluster) ShouldCreateApplicationDatabase() bool

ShouldCreateApplicationDatabase returns true if for this cluster, during the bootstrap phase, we need to create an application database

func (*Cluster) ShouldCreateApplicationSecret added in v1.16.0 

func (cluster *Cluster) ShouldCreateApplicationSecret() bool

ShouldCreateApplicationSecret returns true if for this cluster, during the bootstrap phase, we need to create a secret to store application credentials

func (*Cluster) ShouldCreateProjectedVolume added in v1.18.2 

func (cluster *Cluster) ShouldCreateProjectedVolume() bool

ShouldCreateProjectedVolume returns whether we should create the projected all in one volume

func (*Cluster) ShouldCreateWalArchiveVolume added in v1.17.0 

func (cluster *Cluster) ShouldCreateWalArchiveVolume() bool

ShouldCreateWalArchiveVolume returns whether we should create the wal archive volume

func (*Cluster) ShouldForceLegacyBackup added in v1.18.3 

func (cluster *Cluster) ShouldForceLegacyBackup() bool

ShouldForceLegacyBackup if present takes a backup without passing the name argument even on barman version 3.3.0+. This is needed to test both backup system in the E2E suite

func (*Cluster) ShouldInitDBCreateApplicationDatabase added in v1.16.0 

func (cluster *Cluster) ShouldInitDBCreateApplicationDatabase() bool

ShouldInitDBCreateApplicationDatabase returns true if the application database needs to be created during initdb job

func (*Cluster) ShouldInitDBCreateApplicationSecret added in v1.16.0 

func (cluster *Cluster) ShouldInitDBCreateApplicationSecret() bool

ShouldInitDBCreateApplicationSecret returns true if for this cluster, during the bootstrap phase using initDB, we need to create an new application secret

func (*Cluster) ShouldInitDBRunPostInitApplicationSQLRefs added in v1.17.0 

func (cluster *Cluster) ShouldInitDBRunPostInitApplicationSQLRefs() bool

ShouldInitDBRunPostInitApplicationSQLRefs returns true if for this cluster, during the bootstrap phase using initDB, we need to run post application SQL files from provided references.

func (*Cluster) ShouldPgBaseBackupCreateApplicationDatabase added in v1.16.0 

func (cluster *Cluster) ShouldPgBaseBackupCreateApplicationDatabase() bool

ShouldPgBaseBackupCreateApplicationDatabase returns true if the application database needs to be created during the pg_basebackup job

func (*Cluster) ShouldPgBaseBackupCreateApplicationSecret added in v1.16.0 

func (cluster *Cluster) ShouldPgBaseBackupCreateApplicationSecret() bool

ShouldPgBaseBackupCreateApplicationSecret returns true if for this cluster, during the bootstrap phase using pg_basebackup, we need to create an application secret

func (*Cluster) ShouldRecoveryCreateApplicationDatabase added in v1.16.0 

func (cluster *Cluster) ShouldRecoveryCreateApplicationDatabase() bool

ShouldRecoveryCreateApplicationDatabase returns true if the application database needs to be created during the recovery job

func (*Cluster) ShouldRecoveryCreateApplicationSecret added in v1.16.0 

func (cluster *Cluster) ShouldRecoveryCreateApplicationSecret() bool

ShouldRecoveryCreateApplicationSecret returns true if for this cluster, during the bootstrap phase using recovery, we need to create an application secret

func (*Cluster) ShouldResizeInUseVolumes 

func (cluster *Cluster) ShouldResizeInUseVolumes() bool

ShouldResizeInUseVolumes is true when we should resize PVC we already created

func (*Cluster) UpdateBackupTimes added in v1.21.2 

func (cluster *Cluster) UpdateBackupTimes(
	backupMethod BackupMethod,
	firstRecoverabilityPoint *time.Time,
	lastSuccessfulBackup *time.Time,
)

UpdateBackupTimes sets the firstRecoverabilityPoint and lastSuccessfulBackup for the provided method, as well as the overall firstRecoverabilityPoint and lastSuccessfulBackup for the cluster

func (*Cluster) UsesConfigMap 

func (cluster *Cluster) UsesConfigMap(config string) (ok bool)

UsesConfigMap checks whether a given secret is used by a Cluster

func (*Cluster) UsesSecret 

func (cluster *Cluster) UsesSecret(secret string) bool

UsesSecret checks whether a given secret is used by a Cluster.

This function is also used to discover the set of clusters that should be reconciled when a certain secret changes.

func (*Cluster) UsesSecretInManagedRoles added in v1.20.0 

func (cluster *Cluster) UsesSecretInManagedRoles(secretName string) bool

UsesSecretInManagedRoles checks if the given secret name is used in a managed role

func (*Cluster) Validate 

func (r *Cluster) Validate() (allErrs field.ErrorList)

Validate groups the validation logic for clusters returning a list of all encountered errors

func (*Cluster) ValidateChanges 

func (r *Cluster) ValidateChanges(old *Cluster) (allErrs field.ErrorList)

ValidateChanges groups the validation logic for cluster changes checking the differences between the previous version and the new one of the cluster, returning a list of all encountered errors

func (*Cluster) ValidateCreate 

func (r *Cluster) ValidateCreate() (admission.Warnings, error)

ValidateCreate implements webhook.Validator so a webhook will be registered for the type

func (*Cluster) ValidateDelete 

func (r *Cluster) ValidateDelete() (admission.Warnings, error)

ValidateDelete implements webhook.Validator so a webhook will be registered for the type

func (*Cluster) ValidateUpdate 

func (r *Cluster) ValidateUpdate(old runtime.Object) (admission.Warnings, error)

ValidateUpdate implements webhook.Validator so a webhook will be registered for the type

type ClusterConditionType 

type ClusterConditionType string

ClusterConditionType defines types of cluster conditions 

const (
	// ConditionContinuousArchiving represents whether WAL archiving is working
	ConditionContinuousArchiving ClusterConditionType = "ContinuousArchiving"
	// ConditionBackup represents the last backup's status
	ConditionBackup ClusterConditionType = "LastBackupSucceeded"
	// ConditionClusterReady represents whether a cluster is Ready
	ConditionClusterReady ClusterConditionType = "Ready"
)

These are valid conditions of a Cluster, some of the conditions could be owned by Instance Manager and some of them could be owned by reconciler.

type ClusterList 

type ClusterList struct {
	metav1.TypeMeta `json:",inline"`
	// Standard list metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	metav1.ListMeta `json:"metadata,omitempty"`
	// List of clusters
	Items []Cluster `json:"items"`
}

ClusterList contains a list of Cluster

func (*ClusterList) DeepCopy 

func (in *ClusterList) DeepCopy() *ClusterList

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

func (*ClusterList) DeepCopyInto 

func (in *ClusterList) DeepCopyInto(out *ClusterList)

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

func (*ClusterList) DeepCopyObject 

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

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

type ClusterSpec 

type ClusterSpec struct {
	// Description of this PostgreSQL cluster
	// +optional
	Description string `json:"description,omitempty"`

	// Metadata that will be inherited by all objects related to the Cluster
	// +optional
	InheritedMetadata *EmbeddedObjectMetadata `json:"inheritedMetadata,omitempty"`

	// Name of the container image, supporting both tags (`<image>:<tag>`)
	// and digests for deterministic and repeatable deployments
	// (`<image>:<tag>@sha256:<digestValue>`)
	// +optional
	ImageName string `json:"imageName,omitempty"`

	// Image pull policy.
	// One of `Always`, `Never` or `IfNotPresent`.
	// If not defined, it defaults to `IfNotPresent`.
	// Cannot be updated.
	// More info: https://kubernetes.io/docs/concepts/containers/images#updating-images
	// +optional
	ImagePullPolicy corev1.PullPolicy `json:"imagePullPolicy,omitempty"`

	// If specified, the pod will be dispatched by specified Kubernetes
	// scheduler. If not specified, the pod will be dispatched by the default
	// scheduler. More info:
	// https://kubernetes.io/docs/concepts/scheduling-eviction/kube-scheduler/
	// +optional
	SchedulerName string `json:"schedulerName,omitempty"`

	// The UID of the `postgres` user inside the image, defaults to `26`
	// +kubebuilder:default:=26
	// +optional
	PostgresUID int64 `json:"postgresUID,omitempty"`

	// The GID of the `postgres` user inside the image, defaults to `26`
	// +kubebuilder:default:=26
	// +optional
	PostgresGID int64 `json:"postgresGID,omitempty"`

	// Number of instances required in the cluster
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:default:=1
	Instances int `json:"instances"`

	// Minimum number of instances required in synchronous replication with the
	// primary. Undefined or 0 allow writes to complete when no standby is
	// available.
	// +kubebuilder:default:=0
	// +kubebuilder:validation:Minimum=0
	// +optional
	MinSyncReplicas int `json:"minSyncReplicas,omitempty"`

	// The target value for the synchronous replication quorum, that can be
	// decreased if the number of ready standbys is lower than this.
	// Undefined or 0 disable synchronous replication.
	// +kubebuilder:default:=0
	// +kubebuilder:validation:Minimum=0
	// +optional
	MaxSyncReplicas int `json:"maxSyncReplicas,omitempty"`

	// Configuration of the PostgreSQL server
	// +optional
	PostgresConfiguration PostgresConfiguration `json:"postgresql,omitempty"`

	// Replication slots management configuration
	// +kubebuilder:default:={"highAvailability":{"enabled":true}}
	// +optional
	ReplicationSlots *ReplicationSlotsConfiguration `json:"replicationSlots,omitempty"`

	// Instructions to bootstrap this cluster
	// +optional
	Bootstrap *BootstrapConfiguration `json:"bootstrap,omitempty"`

	// Replica cluster configuration
	// +optional
	ReplicaCluster *ReplicaClusterConfiguration `json:"replica,omitempty"`

	// The secret containing the superuser password. If not defined a new
	// secret will be created with a randomly generated password
	// +optional
	SuperuserSecret *LocalObjectReference `json:"superuserSecret,omitempty"`

	// When this option is enabled, the operator will use the `SuperuserSecret`
	// to update the `postgres` user password (if the secret is
	// not present, the operator will automatically create one). When this
	// option is disabled, the operator will ignore the `SuperuserSecret` content, delete
	// it when automatically created, and then blank the password of the `postgres`
	// user by setting it to `NULL`. Disabled by default.
	// +kubebuilder:default:=false
	// +optional
	EnableSuperuserAccess *bool `json:"enableSuperuserAccess,omitempty"`

	// The configuration for the CA and related certificates
	// +optional
	Certificates *CertificatesConfiguration `json:"certificates,omitempty"`

	// The list of pull secrets to be used to pull the images
	// +optional
	ImagePullSecrets []LocalObjectReference `json:"imagePullSecrets,omitempty"`

	// Configuration of the storage of the instances
	// +optional
	StorageConfiguration StorageConfiguration `json:"storage,omitempty"`

	// Configure the generation of the service account
	// +optional
	ServiceAccountTemplate *ServiceAccountTemplate `json:"serviceAccountTemplate,omitempty"`

	// Configuration of the storage for PostgreSQL WAL (Write-Ahead Log)
	// +optional
	WalStorage *StorageConfiguration `json:"walStorage,omitempty"`

	// EphemeralVolumeSource allows the user to configure the source of ephemeral volumes.
	// +optional
	EphemeralVolumeSource *corev1.EphemeralVolumeSource `json:"ephemeralVolumeSource,omitempty"`

	// The time in seconds that is allowed for a PostgreSQL instance to
	// successfully start up (default 3600).
	// The startup probe failure threshold is derived from this value using the formula:
	// ceiling(startDelay / 10).
	// +kubebuilder:default:=3600
	// +optional
	MaxStartDelay int32 `json:"startDelay,omitempty"`

	// The time in seconds that is allowed for a PostgreSQL instance to
	// gracefully shutdown (default 1800)
	// +kubebuilder:default:=1800
	// +optional
	MaxStopDelay int32 `json:"stopDelay,omitempty"`

	// The time in seconds that controls the window of time reserved for the smart shutdown of Postgres to complete.
	// Make sure you reserve enough time for the operator to request a fast shutdown of Postgres
	// (that is: `stopDelay` - `smartShutdownTimeout`).
	// +kubebuilder:default:=180
	// +optional
	SmartShutdownTimeout int32 `json:"smartShutdownTimeout,omitempty"`

	// The time in seconds that is allowed for a primary PostgreSQL instance
	// to gracefully shutdown during a switchover.
	// Default value is 3600 seconds (1 hour).
	// +kubebuilder:default:=3600
	// +optional
	MaxSwitchoverDelay int32 `json:"switchoverDelay,omitempty"`

	// The amount of time (in seconds) to wait before triggering a failover
	// after the primary PostgreSQL instance in the cluster was detected
	// to be unhealthy
	// +kubebuilder:default:=0
	// +optional
	FailoverDelay int32 `json:"failoverDelay,omitempty"`

	// LivenessProbeTimeout is the time (in seconds) that is allowed for a PostgreSQL instance
	// to successfully respond to the liveness probe (default 30).
	// The Liveness probe failure threshold is derived from this value using the formula:
	// ceiling(livenessProbe / 10).
	// +optional
	LivenessProbeTimeout *int32 `json:"livenessProbeTimeout,omitempty"`

	// Affinity/Anti-affinity rules for Pods
	// +optional
	Affinity AffinityConfiguration `json:"affinity,omitempty"`

	// TopologySpreadConstraints specifies how to spread matching pods among the given topology.
	// More info:
	// https://kubernetes.io/docs/concepts/scheduling-eviction/topology-spread-constraints/
	// +optional
	TopologySpreadConstraints []corev1.TopologySpreadConstraint `json:"topologySpreadConstraints,omitempty"`

	// Resources requirements of every generated Pod. Please refer to
	// https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
	// for more information.
	// +optional
	Resources corev1.ResourceRequirements `json:"resources,omitempty"`

	// EphemeralVolumesSizeLimit allows the user to set the limits for the ephemeral
	// volumes
	EphemeralVolumesSizeLimit *EphemeralVolumesSizeLimitConfiguration `json:"ephemeralVolumesSizeLimit,omitempty"`

	// Name of the priority class which will be used in every generated Pod, if the PriorityClass
	// specified does not exist, the pod will not be able to schedule.  Please refer to
	// https://kubernetes.io/docs/concepts/scheduling-eviction/pod-priority-preemption/#priorityclass
	// for more information
	// +optional
	PriorityClassName string `json:"priorityClassName,omitempty"`

	// Deployment strategy to follow to upgrade the primary server during a rolling
	// update procedure, after all replicas have been successfully updated:
	// it can be automated (`unsupervised` - default) or manual (`supervised`)
	// +kubebuilder:default:=unsupervised
	// +kubebuilder:validation:Enum:=unsupervised;supervised
	// +optional
	PrimaryUpdateStrategy PrimaryUpdateStrategy `json:"primaryUpdateStrategy,omitempty"`

	// Method to follow to upgrade the primary server during a rolling
	// update procedure, after all replicas have been successfully updated:
	// it can be with a switchover (`switchover`) or in-place (`restart` - default)
	// +kubebuilder:default:=restart
	// +kubebuilder:validation:Enum:=switchover;restart
	// +optional
	PrimaryUpdateMethod PrimaryUpdateMethod `json:"primaryUpdateMethod,omitempty"`

	// The configuration to be used for backups
	// +optional
	Backup *BackupConfiguration `json:"backup,omitempty"`

	// Define a maintenance window for the Kubernetes nodes
	// +optional
	NodeMaintenanceWindow *NodeMaintenanceWindow `json:"nodeMaintenanceWindow,omitempty"`

	// The configuration of the monitoring infrastructure of this cluster
	// +optional
	Monitoring *MonitoringConfiguration `json:"monitoring,omitempty"`

	// The list of external clusters which are used in the configuration
	// +optional
	ExternalClusters []ExternalCluster `json:"externalClusters,omitempty"`

	// The instances' log level, one of the following values: error, warning, info (default), debug, trace
	// +kubebuilder:default:=info
	// +kubebuilder:validation:Enum:=error;warning;info;debug;trace
	// +optional
	LogLevel string `json:"logLevel,omitempty"`

	// Template to be used to define projected volumes, projected volumes will be mounted
	// under `/projected` base folder
	// +optional
	ProjectedVolumeTemplate *corev1.ProjectedVolumeSource `json:"projectedVolumeTemplate,omitempty"`

	// Env follows the Env format to pass environment variables
	// to the pods created in the cluster
	// +optional
	// +patchMergeKey=name
	// +patchStrategy=merge
	Env []corev1.EnvVar `json:"env,omitempty"`

	// EnvFrom follows the EnvFrom format to pass environment variables
	// sources to the pods to be used by Env
	// +optional
	EnvFrom []corev1.EnvFromSource `json:"envFrom,omitempty"`

	// The configuration that is used by the portions of PostgreSQL that are managed by the instance manager
	// +optional
	Managed *ManagedConfiguration `json:"managed,omitempty"`

	// The SeccompProfile applied to every Pod and Container.
	// Defaults to: `RuntimeDefault`
	// +optional
	SeccompProfile *corev1.SeccompProfile `json:"seccompProfile,omitempty"`

	// The tablespaces configuration
	// +optional
	Tablespaces []TablespaceConfiguration `json:"tablespaces,omitempty"`
}

ClusterSpec defines the desired state of Cluster

func (*ClusterSpec) DeepCopy 

func (in *ClusterSpec) DeepCopy() *ClusterSpec

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

func (*ClusterSpec) DeepCopyInto 

func (in *ClusterSpec) DeepCopyInto(out *ClusterSpec)

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

type ClusterStatus 

type ClusterStatus struct {
	// The total number of PVC Groups detected in the cluster. It may differ from the number of existing instance pods.
	// +optional
	Instances int `json:"instances,omitempty"`

	// The total number of ready instances in the cluster. It is equal to the number of ready instance pods.
	// +optional
	ReadyInstances int `json:"readyInstances,omitempty"`

	// InstancesStatus indicates in which status the instances are
	// +optional
	InstancesStatus map[utils.PodStatus][]string `json:"instancesStatus,omitempty"`

	// The reported state of the instances during the last reconciliation loop
	// +optional
	InstancesReportedState map[PodName]InstanceReportedState `json:"instancesReportedState,omitempty"`

	// ManagedRolesStatus reports the state of the managed roles in the cluster
	// +optional
	ManagedRolesStatus ManagedRoles `json:"managedRolesStatus,omitempty"`

	// TablespacesStatus reports the state of the declarative tablespaces in the cluster
	// +optional
	TablespacesStatus []TablespaceState `json:"tablespacesStatus,omitempty"`

	// The timeline of the Postgres cluster
	// +optional
	TimelineID int `json:"timelineID,omitempty"`

	// Instances topology.
	// +optional
	Topology Topology `json:"topology,omitempty"`

	// ID of the latest generated node (used to avoid node name clashing)
	// +optional
	LatestGeneratedNode int `json:"latestGeneratedNode,omitempty"`

	// Current primary instance
	// +optional
	CurrentPrimary string `json:"currentPrimary,omitempty"`

	// Target primary instance, this is different from the previous one
	// during a switchover or a failover
	// +optional
	TargetPrimary string `json:"targetPrimary,omitempty"`

	// How many PVCs have been created by this cluster
	// +optional
	PVCCount int32 `json:"pvcCount,omitempty"`

	// How many Jobs have been created by this cluster
	// +optional
	JobCount int32 `json:"jobCount,omitempty"`

	// List of all the PVCs created by this cluster and still available
	// which are not attached to a Pod
	// +optional
	DanglingPVC []string `json:"danglingPVC,omitempty"`

	// List of all the PVCs that have ResizingPVC condition.
	// +optional
	ResizingPVC []string `json:"resizingPVC,omitempty"`

	// List of all the PVCs that are being initialized by this cluster
	// +optional
	InitializingPVC []string `json:"initializingPVC,omitempty"`

	// List of all the PVCs not dangling nor initializing
	// +optional
	HealthyPVC []string `json:"healthyPVC,omitempty"`

	// List of all the PVCs that are unusable because another PVC is missing
	// +optional
	UnusablePVC []string `json:"unusablePVC,omitempty"`

	// Current write pod
	// +optional
	WriteService string `json:"writeService,omitempty"`

	// Current list of read pods
	// +optional
	ReadService string `json:"readService,omitempty"`

	// Current phase of the cluster
	// +optional
	Phase string `json:"phase,omitempty"`

	// Reason for the current phase
	// +optional
	PhaseReason string `json:"phaseReason,omitempty"`

	// The list of resource versions of the secrets
	// managed by the operator. Every change here is done in the
	// interest of the instance manager, which will refresh the
	// secret data
	// +optional
	SecretsResourceVersion SecretsResourceVersion `json:"secretsResourceVersion,omitempty"`

	// The list of resource versions of the configmaps,
	// managed by the operator. Every change here is done in the
	// interest of the instance manager, which will refresh the
	// configmap data
	// +optional
	ConfigMapResourceVersion ConfigMapResourceVersion `json:"configMapResourceVersion,omitempty"`

	// The configuration for the CA and related certificates, initialized with defaults.
	// +optional
	Certificates CertificatesStatus `json:"certificates,omitempty"`

	// The first recoverability point, stored as a date in RFC3339 format.
	// This field is calculated from the content of FirstRecoverabilityPointByMethod
	// +optional
	FirstRecoverabilityPoint string `json:"firstRecoverabilityPoint,omitempty"`

	// The first recoverability point, stored as a date in RFC3339 format, per backup method type
	// +optional
	FirstRecoverabilityPointByMethod map[BackupMethod]metav1.Time `json:"firstRecoverabilityPointByMethod,omitempty"`

	// Last successful backup, stored as a date in RFC3339 format
	// This field is calculated from the content of LastSuccessfulBackupByMethod
	// +optional
	LastSuccessfulBackup string `json:"lastSuccessfulBackup,omitempty"`

	// Last successful backup, stored as a date in RFC3339 format, per backup method type
	// +optional
	LastSuccessfulBackupByMethod map[BackupMethod]metav1.Time `json:"lastSuccessfulBackupByMethod,omitempty"`

	// Stored as a date in RFC3339 format
	// +optional
	LastFailedBackup string `json:"lastFailedBackup,omitempty"`

	// The commit hash number of which this operator running
	// +optional
	CommitHash string `json:"cloudNativePGCommitHash,omitempty"`

	// The timestamp when the last actual promotion to primary has occurred
	// +optional
	CurrentPrimaryTimestamp string `json:"currentPrimaryTimestamp,omitempty"`

	// The timestamp when the primary was detected to be unhealthy
	// This field is reported when `.spec.failoverDelay` is populated or during online upgrades
	// +optional
	CurrentPrimaryFailingSinceTimestamp string `json:"currentPrimaryFailingSinceTimestamp,omitempty"`

	// The timestamp when the last request for a new primary has occurred
	// +optional
	TargetPrimaryTimestamp string `json:"targetPrimaryTimestamp,omitempty"`

	// The integration needed by poolers referencing the cluster
	// +optional
	PoolerIntegrations *PoolerIntegrations `json:"poolerIntegrations,omitempty"`

	// The hash of the binary of the operator
	// +optional
	OperatorHash string `json:"cloudNativePGOperatorHash,omitempty"`

	// AvailableArchitectures reports the available architectures of a cluster
	// +optional
	AvailableArchitectures []AvailableArchitecture `json:"availableArchitectures,omitempty"`

	// Conditions for cluster object
	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty"`

	// List of instance names in the cluster
	// +optional
	InstanceNames []string `json:"instanceNames,omitempty"`

	// OnlineUpdateEnabled shows if the online upgrade is enabled inside the cluster
	// +optional
	OnlineUpdateEnabled bool `json:"onlineUpdateEnabled,omitempty"`

	// AzurePVCUpdateEnabled shows if the PVC online upgrade is enabled for this cluster
	// +optional
	AzurePVCUpdateEnabled bool `json:"azurePVCUpdateEnabled,omitempty"`
}

ClusterStatus defines the observed state of Cluster

func (*ClusterStatus) DeepCopy 

func (in *ClusterStatus) DeepCopy() *ClusterStatus

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

func (*ClusterStatus) DeepCopyInto 

func (in *ClusterStatus) DeepCopyInto(out *ClusterStatus)

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

func (*ClusterStatus) GetAvailableArchitecture added in v1.21.4 

func (status *ClusterStatus) GetAvailableArchitecture(archName string) *AvailableArchitecture

GetAvailableArchitecture returns an AvailableArchitecture given it's name. It returns nil if it's not found.

type CompressionType 

type CompressionType string

CompressionType encapsulates the available types of compression

type ConditionReason added in v1.15.5 

type ConditionReason string

ConditionReason defines the reason why a certain condition changed 

const (
	// ConditionBackupStarted means that the condition changed because the debug
	// started
	ConditionBackupStarted ConditionReason = "BackupStarted"

	// ConditionReasonLastBackupSucceeded means that the condition changed because the last backup
	// has been taken successfully
	ConditionReasonLastBackupSucceeded ConditionReason = "LastBackupSucceeded"

	// ConditionReasonLastBackupFailed means that the condition changed because the last backup
	// failed
	ConditionReasonLastBackupFailed ConditionReason = "LastBackupFailed"

	// ConditionReasonContinuousArchivingSuccess means that the condition changed because the
	// WAL archiving was working correctly
	ConditionReasonContinuousArchivingSuccess ConditionReason = "ContinuousArchivingSuccess"

	// ConditionReasonContinuousArchivingFailing means that the condition has changed because
	// the WAL archiving is not working correctly
	ConditionReasonContinuousArchivingFailing ConditionReason = "ContinuousArchivingFailing"

	// ClusterReady means that the condition changed because the cluster is ready and working properly
	ClusterReady ConditionReason = "ClusterIsReady"

	// ClusterIsNotReady means that the condition changed because the cluster is not ready
	ClusterIsNotReady ConditionReason = "ClusterIsNotReady"

	// DetachedVolume is the reason that is set when we do a rolling upgrade to add a PVC volume to a cluster
	DetachedVolume ConditionReason = "DetachedVolume"
)

type ConditionStatus 

type ConditionStatus string

ConditionStatus defines conditions of resources 

const (
	ConditionTrue    ConditionStatus = "True"
	ConditionFalse   ConditionStatus = "False"
	ConditionUnknown ConditionStatus = "Unknown"
)

These are valid condition statuses. "ConditionTrue" means a resource is in the condition; "ConditionFalse" means a resource is not in the condition; "ConditionUnknown" means kubernetes can't decide if a resource is in the condition or not. In the future, we could add other intermediate conditions, e.g. ConditionDegraded

type ConfigMapKeySelector 

type ConfigMapKeySelector struct {
	// The name of the secret in the pod's namespace to select from.
	LocalObjectReference `json:",inline"`
	// The key to select
	Key string `json:"key"`
}

ConfigMapKeySelector contains enough information to let you locate the key of a ConfigMap

func (*ConfigMapKeySelector) DeepCopy 

func (in *ConfigMapKeySelector) DeepCopy() *ConfigMapKeySelector

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

func (*ConfigMapKeySelector) DeepCopyInto 

func (in *ConfigMapKeySelector) DeepCopyInto(out *ConfigMapKeySelector)

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

type ConfigMapResourceVersion 

type ConfigMapResourceVersion struct {
	// A map with the versions of all the config maps used to pass metrics.
	// Map keys are the config map names, map values are the versions
	// +optional
	Metrics map[string]string `json:"metrics,omitempty"`
}

ConfigMapResourceVersion is the resource versions of the secrets managed by the operator

func (*ConfigMapResourceVersion) DeepCopy 

func (in *ConfigMapResourceVersion) DeepCopy() *ConfigMapResourceVersion

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

func (*ConfigMapResourceVersion) DeepCopyInto 

func (in *ConfigMapResourceVersion) DeepCopyInto(out *ConfigMapResourceVersion)

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

type DataBackupConfiguration 

type DataBackupConfiguration struct {
	// Compress a backup file (a tar file per tablespace) while streaming it
	// to the object store. Available options are empty string (no
	// compression, default), `gzip`, `bzip2` or `snappy`.
	// +kubebuilder:validation:Enum=gzip;bzip2;snappy
	// +optional
	Compression CompressionType `json:"compression,omitempty"`

	// Whenever to force the encryption of files (if the bucket is
	// not already configured for that).
	// Allowed options are empty string (use the bucket policy, default),
	// `AES256` and `aws:kms`
	// +kubebuilder:validation:Enum=AES256;"aws:kms"
	// +optional
	Encryption EncryptionType `json:"encryption,omitempty"`

	// The number of parallel jobs to be used to upload the backup, defaults
	// to 2
	// +kubebuilder:validation:Minimum=1
	// +optional
	Jobs *int32 `json:"jobs,omitempty"`

	// Control whether the I/O workload for the backup initial checkpoint will
	// be limited, according to the `checkpoint_completion_target` setting on
	// the PostgreSQL server. If set to true, an immediate checkpoint will be
	// used, meaning PostgreSQL will complete the checkpoint as soon as
	// possible. `false` by default.
	// +optional
	ImmediateCheckpoint bool `json:"immediateCheckpoint,omitempty"`

	// AdditionalCommandArgs represents additional arguments that can be appended
	// to the 'barman-cloud-backup' command-line invocation. These arguments
	// provide flexibility to customize the backup process further according to
	// specific requirements or configurations.
	//
	// Example:
	// In a scenario where specialized backup options are required, such as setting
	// a specific timeout or defining custom behavior, users can use this field
	// to specify additional command arguments.
	//
	// Note:
	// It's essential to ensure that the provided arguments are valid and supported
	// by the 'barman-cloud-backup' command, to avoid potential errors or unintended
	// behavior during execution.
	AdditionalCommandArgs []string `json:"additionalCommandArgs,omitempty"`
}

DataBackupConfiguration is the configuration of the backup of the data directory

func (*DataBackupConfiguration) DeepCopy 

func (in *DataBackupConfiguration) DeepCopy() *DataBackupConfiguration

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

func (*DataBackupConfiguration) DeepCopyInto 

func (in *DataBackupConfiguration) DeepCopyInto(out *DataBackupConfiguration)

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

type DataSource added in v1.18.5 

type DataSource struct {
	// Configuration of the storage of the instances
	Storage corev1.TypedLocalObjectReference `json:"storage"`

	// Configuration of the storage for PostgreSQL WAL (Write-Ahead Log)
	// +optional
	WalStorage *corev1.TypedLocalObjectReference `json:"walStorage,omitempty"`

	// Configuration of the storage for PostgreSQL tablespaces
	// +optional
	TablespaceStorage map[string]corev1.TypedLocalObjectReference `json:"tablespaceStorage,omitempty"`
}

DataSource contains the configuration required to bootstrap a PostgreSQL cluster from an existing storage

func (*DataSource) DeepCopy added in v1.18.5 

func (in *DataSource) DeepCopy() *DataSource

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

func (*DataSource) DeepCopyInto added in v1.18.5 

func (in *DataSource) DeepCopyInto(out *DataSource)

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

type DatabaseRoleRef added in v1.22.0 

type DatabaseRoleRef struct {
	// +optional
	Name string `json:"name,omitempty"`
}

DatabaseRoleRef is a reference an a role available inside PostgreSQL

func (*DatabaseRoleRef) DeepCopy added in v1.22.0 

func (in *DatabaseRoleRef) DeepCopy() *DatabaseRoleRef

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

func (*DatabaseRoleRef) DeepCopyInto added in v1.22.0 

func (in *DatabaseRoleRef) DeepCopyInto(out *DatabaseRoleRef)

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

type EmbeddedObjectMetadata 

type EmbeddedObjectMetadata struct {
	// +optional
	Labels map[string]string `json:"labels,omitempty"`

	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`
}

EmbeddedObjectMetadata contains metadata to be inherited by all resources related to a Cluster

func (*EmbeddedObjectMetadata) DeepCopy 

func (in *EmbeddedObjectMetadata) DeepCopy() *EmbeddedObjectMetadata

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

func (*EmbeddedObjectMetadata) DeepCopyInto 

func (in *EmbeddedObjectMetadata) DeepCopyInto(out *EmbeddedObjectMetadata)

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

type EncryptionType 

type EncryptionType string

EncryptionType encapsulated the available types of encryption

type EnsureOption added in v1.20.0 

type EnsureOption string

EnsureOption represents whether we should enforce the presence or absence of a Role in a PostgreSQL instance 

const (
	EnsurePresent EnsureOption = "present"
	EnsureAbsent  EnsureOption = "absent"
)

values taken by EnsureOption

type EphemeralVolumesSizeLimitConfiguration added in v1.19.5 

type EphemeralVolumesSizeLimitConfiguration struct {
	// Shm is the size limit of the shared memory volume
	Shm *resource.Quantity `json:"shm,omitempty"`

	// TemporaryData is the size limit of the temporary data volume
	TemporaryData *resource.Quantity `json:"temporaryData,omitempty"`
}

EphemeralVolumesSizeLimitConfiguration contains the configuration of the ephemeral storage

func (*EphemeralVolumesSizeLimitConfiguration) DeepCopy added in v1.19.5 

func (in *EphemeralVolumesSizeLimitConfiguration) DeepCopy() *EphemeralVolumesSizeLimitConfiguration

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

func (*EphemeralVolumesSizeLimitConfiguration) DeepCopyInto added in v1.19.5 

func (in *EphemeralVolumesSizeLimitConfiguration) DeepCopyInto(out *EphemeralVolumesSizeLimitConfiguration)

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

func (*EphemeralVolumesSizeLimitConfiguration) GetShmLimit added in v1.19.5 

func (e *EphemeralVolumesSizeLimitConfiguration) GetShmLimit() *resource.Quantity

GetShmLimit gets the `/dev/shm` memory size limit

func (*EphemeralVolumesSizeLimitConfiguration) GetTemporaryDataLimit added in v1.19.5 

func (e *EphemeralVolumesSizeLimitConfiguration) GetTemporaryDataLimit() *resource.Quantity

GetTemporaryDataLimit gets the temporary storage size limit

type ExternalCluster 

type ExternalCluster struct {
	// The server name, required
	Name string `json:"name"`

	// The list of connection parameters, such as dbname, host, username, etc
	// +optional
	ConnectionParameters map[string]string `json:"connectionParameters,omitempty"`

	// The reference to an SSL certificate to be used to connect to this
	// instance
	// +optional
	SSLCert *corev1.SecretKeySelector `json:"sslCert,omitempty"`

	// The reference to an SSL private key to be used to connect to this
	// instance
	// +optional
	SSLKey *corev1.SecretKeySelector `json:"sslKey,omitempty"`

	// The reference to an SSL CA public key to be used to connect to this
	// instance
	// +optional
	SSLRootCert *corev1.SecretKeySelector `json:"sslRootCert,omitempty"`

	// The reference to the password to be used to connect to the server.
	// If a password is provided, CloudNativePG creates a PostgreSQL
	// passfile at `/controller/external/NAME/pass` (where "NAME" is the
	// cluster's name). This passfile is automatically referenced in the
	// connection string when establishing a connection to the remote
	// PostgreSQL server from the current PostgreSQL `Cluster`. This ensures
	// secure and efficient password management for external clusters.
	// +optional
	Password *corev1.SecretKeySelector `json:"password,omitempty"`

	// The configuration for the barman-cloud tool suite
	// +optional
	BarmanObjectStore *BarmanObjectStoreConfiguration `json:"barmanObjectStore,omitempty"`
}

ExternalCluster represents the connection parameters to an external cluster which is used in the other sections of the configuration

func (*ExternalCluster) DeepCopy 

func (in *ExternalCluster) DeepCopy() *ExternalCluster

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

func (*ExternalCluster) DeepCopyInto 

func (in *ExternalCluster) DeepCopyInto(out *ExternalCluster)

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

func (ExternalCluster) GetServerName 

func (in ExternalCluster) GetServerName() string

GetServerName returns the server name, defaulting to the name of the external cluster or using the one specified in the BarmanObjectStore

type GoogleCredentials 

type GoogleCredentials struct {
	// The secret containing the Google Cloud Storage JSON file with the credentials
	// +optional
	ApplicationCredentials *SecretKeySelector `json:"applicationCredentials,omitempty"`

	// If set to true, will presume that it's running inside a GKE environment,
	// default to false.
	// +optional
	GKEEnvironment bool `json:"gkeEnvironment,omitempty"`
}

GoogleCredentials is the type for the Google Cloud Storage credentials. This needs to be specified even if we run inside a GKE environment.

func (*GoogleCredentials) DeepCopy 

func (in *GoogleCredentials) DeepCopy() *GoogleCredentials

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

func (*GoogleCredentials) DeepCopyInto 

func (in *GoogleCredentials) DeepCopyInto(out *GoogleCredentials)

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

type Import added in v1.16.0 

type Import struct {
	// The source of the import
	Source ImportSource `json:"source"`

	// The import type. Can be `microservice` or `monolith`.
	// +kubebuilder:validation:Enum=microservice;monolith
	Type SnapshotType `json:"type"`

	// The databases to import
	Databases []string `json:"databases"`

	// The roles to import
	// +optional
	Roles []string `json:"roles,omitempty"`

	// List of SQL queries to be executed as a superuser in the application
	// database right after is imported - to be used with extreme care
	// (by default empty). Only available in microservice type.
	// +optional
	PostImportApplicationSQL []string `json:"postImportApplicationSQL,omitempty"`

	// When set to true, only the `pre-data` and `post-data` sections of
	// `pg_restore` are invoked, avoiding data import. Default: `false`.
	// +optional
	SchemaOnly bool `json:"schemaOnly,omitempty"`
}

Import contains the configuration to init a database from a logic snapshot of an externalCluster

func (*Import) DeepCopy added in v1.16.0 

func (in *Import) DeepCopy() *Import

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

func (*Import) DeepCopyInto added in v1.16.0 

func (in *Import) DeepCopyInto(out *Import)

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

type ImportSource added in v1.16.0 

type ImportSource struct {
	// The name of the externalCluster used for import
	ExternalCluster string `json:"externalCluster"`
}

ImportSource describes the source for the logical snapshot

func (*ImportSource) DeepCopy added in v1.16.0 

func (in *ImportSource) DeepCopy() *ImportSource

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

func (*ImportSource) DeepCopyInto added in v1.16.0 

func (in *ImportSource) DeepCopyInto(out *ImportSource)

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

type InstanceID 

type InstanceID struct {
	// The pod name
	// +optional
	PodName string `json:"podName,omitempty"`
	// The container ID
	// +optional
	ContainerID string `json:"ContainerID,omitempty"`
}

InstanceID contains the information to identify an instance

func (*InstanceID) DeepCopy 

func (in *InstanceID) DeepCopy() *InstanceID

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

func (*InstanceID) DeepCopyInto 

func (in *InstanceID) DeepCopyInto(out *InstanceID)

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

type InstanceReportedState added in v1.16.1 

type InstanceReportedState struct {
	// indicates if an instance is the primary one
	IsPrimary bool `json:"isPrimary"`
	// indicates on which TimelineId the instance is
	// +optional
	TimeLineID int `json:"timeLineID,omitempty"`
}

InstanceReportedState describes the last reported state of an instance during a reconciliation loop

func (*InstanceReportedState) DeepCopy added in v1.16.1 

func (in *InstanceReportedState) DeepCopy() *InstanceReportedState

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

func (*InstanceReportedState) DeepCopyInto added in v1.16.1 

func (in *InstanceReportedState) DeepCopyInto(out *InstanceReportedState)

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

type KubernetesUpgradeStrategy 

type KubernetesUpgradeStrategy string

KubernetesUpgradeStrategy tells the operator if the user want to allocate more space while upgrading a k8s node which is hosting the PostgreSQL Pods or just wait for the node to come up

type LDAPBindAsAuth 

type LDAPBindAsAuth struct {
	// Prefix for the bind authentication option
	// +optional
	Prefix string `json:"prefix,omitempty"`
	// Suffix for the bind authentication option
	// +optional
	Suffix string `json:"suffix,omitempty"`
}

LDAPBindAsAuth provides the required fields to use the bind authentication for LDAP

func (*LDAPBindAsAuth) DeepCopy 

func (in *LDAPBindAsAuth) DeepCopy() *LDAPBindAsAuth

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

func (*LDAPBindAsAuth) DeepCopyInto 

func (in *LDAPBindAsAuth) DeepCopyInto(out *LDAPBindAsAuth)

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

type LDAPBindSearchAuth 

type LDAPBindSearchAuth struct {
	// Root DN to begin the user search
	// +optional
	BaseDN string `json:"baseDN,omitempty"`
	// DN of the user to bind to the directory
	// +optional
	BindDN string `json:"bindDN,omitempty"`
	// Secret with the password for the user to bind to the directory
	// +optional
	BindPassword *corev1.SecretKeySelector `json:"bindPassword,omitempty"`

	// Attribute to match against the username
	// +optional
	SearchAttribute string `json:"searchAttribute,omitempty"`
	// Search filter to use when doing the search+bind authentication
	// +optional
	SearchFilter string `json:"searchFilter,omitempty"`
}

LDAPBindSearchAuth provides the required fields to use the bind+search LDAP authentication process

func (*LDAPBindSearchAuth) DeepCopy 

func (in *LDAPBindSearchAuth) DeepCopy() *LDAPBindSearchAuth

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

func (*LDAPBindSearchAuth) DeepCopyInto 

func (in *LDAPBindSearchAuth) DeepCopyInto(out *LDAPBindSearchAuth)

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

type LDAPConfig 

type LDAPConfig struct {
	// LDAP hostname or IP address
	// +optional
	Server string `json:"server,omitempty"`
	// LDAP server port
	// +optional
	Port int `json:"port,omitempty"`

	// LDAP schema to be used, possible options are `ldap` and `ldaps`
	// +kubebuilder:validation:Enum=ldap;ldaps
	// +optional
	Scheme LDAPScheme `json:"scheme,omitempty"`

	// Bind as authentication configuration
	// +optional
	BindAsAuth *LDAPBindAsAuth `json:"bindAsAuth,omitempty"`

	// Bind+Search authentication configuration
	// +optional
	BindSearchAuth *LDAPBindSearchAuth `json:"bindSearchAuth,omitempty"`

	// Set to 'true' to enable LDAP over TLS. 'false' is default
	// +optional
	TLS bool `json:"tls,omitempty"`
}

LDAPConfig contains the parameters needed for LDAP authentication

func (*LDAPConfig) DeepCopy 

func (in *LDAPConfig) DeepCopy() *LDAPConfig

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

func (*LDAPConfig) DeepCopyInto 

func (in *LDAPConfig) DeepCopyInto(out *LDAPConfig)

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

type LDAPScheme 

type LDAPScheme string

LDAPScheme defines the possible schemes for LDAP 

const (
	LDAPSchemeLDAP  LDAPScheme = "ldap"
	LDAPSchemeLDAPS LDAPScheme = "ldaps"
)

These are the valid LDAP schemes

type LocalObjectReference 

type LocalObjectReference struct {
	// Name of the referent.
	Name string `json:"name"`
}

LocalObjectReference contains enough information to let you locate a local object with a known type inside the same namespace

func (*LocalObjectReference) DeepCopy 

func (in *LocalObjectReference) DeepCopy() *LocalObjectReference

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

func (*LocalObjectReference) DeepCopyInto 

func (in *LocalObjectReference) DeepCopyInto(out *LocalObjectReference)

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

type ManagedConfiguration added in v1.20.0 

type ManagedConfiguration struct {
	// Database roles managed by the `Cluster`
	// +optional
	Roles []RoleConfiguration `json:"roles,omitempty"`
}

ManagedConfiguration represents the portions of PostgreSQL that are managed by the instance manager

func (*ManagedConfiguration) DeepCopy added in v1.20.0 

func (in *ManagedConfiguration) DeepCopy() *ManagedConfiguration

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

func (*ManagedConfiguration) DeepCopyInto added in v1.20.0 

func (in *ManagedConfiguration) DeepCopyInto(out *ManagedConfiguration)

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

type ManagedRoles added in v1.20.0 

type ManagedRoles struct {
	// ByStatus gives the list of roles in each state
	// +optional
	ByStatus map[RoleStatus][]string `json:"byStatus,omitempty"`

	// CannotReconcile lists roles that cannot be reconciled in PostgreSQL,
	// with an explanation of the cause
	// +optional
	CannotReconcile map[string][]string `json:"cannotReconcile,omitempty"`

	// PasswordStatus gives the last transaction id and password secret version for each managed role
	// +optional
	PasswordStatus map[string]PasswordState `json:"passwordStatus,omitempty"`
}

ManagedRoles tracks the status of a cluster's managed roles

func (*ManagedRoles) DeepCopy added in v1.20.0 

func (in *ManagedRoles) DeepCopy() *ManagedRoles

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

func (*ManagedRoles) DeepCopyInto added in v1.20.0 

func (in *ManagedRoles) DeepCopyInto(out *ManagedRoles)

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

type Metadata added in v1.18.1 

type Metadata struct {
	// Map of string keys and values that can be used to organize and categorize
	// (scope and select) objects. May match selectors of replication controllers
	// and services.
	// More info: http://kubernetes.io/docs/user-guide/labels
	// +optional
	Labels map[string]string `json:"labels,omitempty"`

	// Annotations is an unstructured key value map stored with a resource that may be
	// set by external tools to store and retrieve arbitrary metadata. They are not
	// queryable and should be preserved when modifying objects.
	// More info: http://kubernetes.io/docs/user-guide/annotations
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`
}

Metadata is a structure similar to the metav1.ObjectMeta, but still parseable by controller-gen to create a suitable CRD for the user. The comment of PodTemplateSpec has an explanation of why we are not using the core data types.

func (*Metadata) DeepCopy added in v1.18.1 

func (in *Metadata) DeepCopy() *Metadata

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

func (*Metadata) DeepCopyInto added in v1.18.1 

func (in *Metadata) DeepCopyInto(out *Metadata)

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

type MonitoringConfiguration 

type MonitoringConfiguration struct {
	// Whether the default queries should be injected.
	// Set it to `true` if you don't want to inject default queries into the cluster.
	// Default: false.
	// +kubebuilder:default:=false
	// +optional
	DisableDefaultQueries *bool `json:"disableDefaultQueries,omitempty"`

	// The list of config maps containing the custom queries
	// +optional
	CustomQueriesConfigMap []ConfigMapKeySelector `json:"customQueriesConfigMap,omitempty"`

	// The list of secrets containing the custom queries
	// +optional
	CustomQueriesSecret []SecretKeySelector `json:"customQueriesSecret,omitempty"`

	// Enable or disable the `PodMonitor`
	// +kubebuilder:default:=false
	// +optional
	EnablePodMonitor bool `json:"enablePodMonitor,omitempty"`

	// The list of metric relabelings for the `PodMonitor`. Applied to samples before ingestion.
	// +optional
	PodMonitorMetricRelabelConfigs []monitoringv1.RelabelConfig `json:"podMonitorMetricRelabelings,omitempty"`

	// The list of relabelings for the `PodMonitor`. Applied to samples before scraping.
	// +optional
	PodMonitorRelabelConfigs []monitoringv1.RelabelConfig `json:"podMonitorRelabelings,omitempty"`
}

MonitoringConfiguration is the type containing all the monitoring configuration for a certain cluster

func (*MonitoringConfiguration) AreDefaultQueriesDisabled 

func (m *MonitoringConfiguration) AreDefaultQueriesDisabled() bool

AreDefaultQueriesDisabled checks whether default monitoring queries should be disabled

func (*MonitoringConfiguration) DeepCopy 

func (in *MonitoringConfiguration) DeepCopy() *MonitoringConfiguration

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

func (*MonitoringConfiguration) DeepCopyInto 

func (in *MonitoringConfiguration) DeepCopyInto(out *MonitoringConfiguration)

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

type NodeMaintenanceWindow 

type NodeMaintenanceWindow struct {
	// Reuse the existing PVC (wait for the node to come
	// up again) or not (recreate it elsewhere - when `instances` >1)
	// +optional
	// +kubebuilder:default:=true
	ReusePVC *bool `json:"reusePVC,omitempty"`

	// Is there a node maintenance activity in progress?
	// +optional
	// +kubebuilder:default:=false
	InProgress bool `json:"inProgress,omitempty"`
}

NodeMaintenanceWindow contains information that the operator will use while upgrading the underlying node.

This option is only useful when the chosen storage prevents the Pods from being freely moved across nodes.

func (*NodeMaintenanceWindow) DeepCopy 

func (in *NodeMaintenanceWindow) DeepCopy() *NodeMaintenanceWindow

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

func (*NodeMaintenanceWindow) DeepCopyInto 

func (in *NodeMaintenanceWindow) DeepCopyInto(out *NodeMaintenanceWindow)

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

type OnlineConfiguration added in v1.21.1 

type OnlineConfiguration struct {
	// If false, the function will return immediately after the backup is completed,
	// without waiting for WAL to be archived.
	// This behavior is only useful with backup software that independently monitors WAL archiving.
	// Otherwise, WAL required to make the backup consistent might be missing and make the backup useless.
	// By default, or when this parameter is true, pg_backup_stop will wait for WAL to be archived when archiving is
	// enabled.
	// On a standby, this means that it will wait only when archive_mode = always.
	// If write activity on the primary is low, it may be useful to run pg_switch_wal on the primary in order to trigger
	// an immediate segment switch.
	// +kubebuilder:default:=true
	// +optional
	WaitForArchive *bool `json:"waitForArchive,omitempty"`

	// Control whether the I/O workload for the backup initial checkpoint will
	// be limited, according to the `checkpoint_completion_target` setting on
	// the PostgreSQL server. If set to true, an immediate checkpoint will be
	// used, meaning PostgreSQL will complete the checkpoint as soon as
	// possible. `false` by default.
	// +optional
	ImmediateCheckpoint *bool `json:"immediateCheckpoint,omitempty"`
}

OnlineConfiguration contains the configuration parameters for the online volume snapshot

func (*OnlineConfiguration) DeepCopy added in v1.21.1 

func (in *OnlineConfiguration) DeepCopy() *OnlineConfiguration

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

func (*OnlineConfiguration) DeepCopyInto added in v1.21.1 

func (in *OnlineConfiguration) DeepCopyInto(out *OnlineConfiguration)

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

func (OnlineConfiguration) GetImmediateCheckpoint added in v1.21.1 

func (o OnlineConfiguration) GetImmediateCheckpoint() bool

GetImmediateCheckpoint tells whether to execute an immediate checkpoint

func (OnlineConfiguration) GetWaitForArchive added in v1.21.1 

func (o OnlineConfiguration) GetWaitForArchive() bool

GetWaitForArchive tells whether to wait for archive or not

type PasswordState added in v1.20.0 

type PasswordState struct {
	// the last transaction ID to affect the role definition in PostgreSQL
	// +optional
	TransactionID int64 `json:"transactionID,omitempty"`
	// the resource version of the password secret
	// +optional
	SecretResourceVersion string `json:"resourceVersion,omitempty"`
}

PasswordState represents the state of the password of a managed RoleConfiguration

func (*PasswordState) DeepCopy added in v1.20.0 

func (in *PasswordState) DeepCopy() *PasswordState

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

func (*PasswordState) DeepCopyInto added in v1.20.0 

func (in *PasswordState) DeepCopyInto(out *PasswordState)

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

type PgBouncerIntegrationStatus 

type PgBouncerIntegrationStatus struct {
	// +optional
	Secrets []string `json:"secrets,omitempty"`
}

PgBouncerIntegrationStatus encapsulates the needed integration for the pgbouncer poolers referencing the cluster

func (*PgBouncerIntegrationStatus) DeepCopy 

func (in *PgBouncerIntegrationStatus) DeepCopy() *PgBouncerIntegrationStatus

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

func (*PgBouncerIntegrationStatus) DeepCopyInto 

func (in *PgBouncerIntegrationStatus) DeepCopyInto(out *PgBouncerIntegrationStatus)

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

type PgBouncerPoolMode 

type PgBouncerPoolMode string

PgBouncerPoolMode is the mode of PgBouncer +kubebuilder:validation:Enum=session;transaction

type PgBouncerSecrets 

type PgBouncerSecrets struct {
	// The auth query secret version
	// +optional
	AuthQuery SecretVersion `json:"authQuery,omitempty"`
}

PgBouncerSecrets contains the versions of the secrets used by pgbouncer

func (*PgBouncerSecrets) DeepCopy 

func (in *PgBouncerSecrets) DeepCopy() *PgBouncerSecrets

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

func (*PgBouncerSecrets) DeepCopyInto 

func (in *PgBouncerSecrets) DeepCopyInto(out *PgBouncerSecrets)

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

type PgBouncerSpec 

type PgBouncerSpec struct {
	// The pool mode. Default: `session`.
	// +kubebuilder:default:=session
	// +optional
	PoolMode PgBouncerPoolMode `json:"poolMode,omitempty"`

	// The credentials of the user that need to be used for the authentication
	// query. In case it is specified, also an AuthQuery
	// (e.g. "SELECT usename, passwd FROM pg_catalog.pg_shadow WHERE usename=$1")
	// has to be specified and no automatic CNPG Cluster integration will be triggered.
	// +optional
	AuthQuerySecret *LocalObjectReference `json:"authQuerySecret,omitempty"`

	// The query that will be used to download the hash of the password
	// of a certain user. Default: "SELECT usename, passwd FROM public.user_search($1)".
	// In case it is specified, also an AuthQuerySecret has to be specified and
	// no automatic CNPG Cluster integration will be triggered.
	// +optional
	AuthQuery string `json:"authQuery,omitempty"`

	// Additional parameters to be passed to PgBouncer - please check
	// the CNPG documentation for a list of options you can configure
	// +optional
	Parameters map[string]string `json:"parameters,omitempty"`

	// PostgreSQL Host Based Authentication rules (lines to be appended
	// to the pg_hba.conf file)
	// +optional
	PgHBA []string `json:"pg_hba,omitempty"`

	// When set to `true`, PgBouncer will disconnect from the PostgreSQL
	// server, first waiting for all queries to complete, and pause all new
	// client connections until this value is set to `false` (default). Internally,
	// the operator calls PgBouncer's `PAUSE` and `RESUME` commands.
	// +kubebuilder:default:=false
	// +optional
	Paused *bool `json:"paused,omitempty"`
}

PgBouncerSpec defines how to configure PgBouncer

func (*PgBouncerSpec) DeepCopy 

func (in *PgBouncerSpec) DeepCopy() *PgBouncerSpec

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

func (*PgBouncerSpec) DeepCopyInto 

func (in *PgBouncerSpec) DeepCopyInto(out *PgBouncerSpec)

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

func (PgBouncerSpec) IsPaused 

func (in PgBouncerSpec) IsPaused() bool

IsPaused returns whether all database should be paused or not.

type PodName added in v1.16.0 

type PodName string

PodName is the name of a Pod

type PodTemplateSpec 

type PodTemplateSpec struct {
	// Standard object's metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
	// +optional
	ObjectMeta Metadata `json:"metadata,omitempty"`

	// Specification of the desired behavior of the pod.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	// +optional
	Spec corev1.PodSpec `json:"spec,omitempty"`
}

PodTemplateSpec is a structure allowing the user to set a template for Pod generation.

Unfortunately we can't use the corev1.PodTemplateSpec type because the generated CRD won't have the field for the metadata section.

References: https://github.com/kubernetes-sigs/controller-tools/issues/385 https://github.com/kubernetes-sigs/controller-tools/issues/448 https://github.com/prometheus-operator/prometheus-operator/issues/3041

func (*PodTemplateSpec) DeepCopy 

func (in *PodTemplateSpec) DeepCopy() *PodTemplateSpec

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

func (*PodTemplateSpec) DeepCopyInto 

func (in *PodTemplateSpec) DeepCopyInto(out *PodTemplateSpec)

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

type PodTopologyLabels added in v1.16.0 

type PodTopologyLabels map[string]string

PodTopologyLabels represent the topology of a Pod. map[labelName]labelValue

func (PodTopologyLabels) DeepCopy added in v1.16.0 

func (in PodTopologyLabels) DeepCopy() PodTopologyLabels

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

func (PodTopologyLabels) DeepCopyInto added in v1.16.0 

func (in PodTopologyLabels) DeepCopyInto(out *PodTopologyLabels)

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

type Pooler 

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

	// Specification of the desired behavior of the Pooler.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	Spec PoolerSpec `json:"spec"`
	// Most recently observed status of the Pooler. This data may not be up to
	// date. Populated by the system. Read-only.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	// +optional
	Status PoolerStatus `json:"status,omitempty"`
}

Pooler is the Schema for the poolers API

func (*Pooler) DeepCopy 

func (in *Pooler) DeepCopy() *Pooler

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

func (*Pooler) DeepCopyInto 

func (in *Pooler) DeepCopyInto(out *Pooler)

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

func (*Pooler) DeepCopyObject 

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

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

func (*Pooler) GetAuthQuery 

func (in *Pooler) GetAuthQuery() string

GetAuthQuery returns the specified AuthQuery name for PgBouncer if provided or the default name otherwise.

func (*Pooler) GetAuthQuerySecretName 

func (in *Pooler) GetAuthQuerySecretName() string

GetAuthQuerySecretName returns the specified AuthQuerySecret name for PgBouncer if provided or the default name otherwise.

func (*Pooler) IsAutomatedIntegration added in v1.20.6 

func (in *Pooler) IsAutomatedIntegration() bool

IsAutomatedIntegration returns whether the Pooler integration with the Cluster is automated or not.

func (*Pooler) SetupWebhookWithManager 

func (r *Pooler) SetupWebhookWithManager(mgr ctrl.Manager) error

SetupWebhookWithManager setup the webhook inside the controller manager

func (*Pooler) Validate 

func (r *Pooler) Validate() (allErrs field.ErrorList)

Validate validates the configuration of a Pooler, returning a list of errors

func (*Pooler) ValidateCreate 

func (r *Pooler) ValidateCreate() (warns admission.Warnings, err error)

ValidateCreate implements webhook.Validator so a webhook will be registered for the type

func (*Pooler) ValidateDelete 

func (r *Pooler) ValidateDelete() (admission.Warnings, error)

ValidateDelete implements webhook.Validator so a webhook will be registered for the type

func (*Pooler) ValidateUpdate 

func (r *Pooler) ValidateUpdate(old runtime.Object) (warns admission.Warnings, err error)

ValidateUpdate implements webhook.Validator so a webhook will be registered for the type

type PoolerIntegrations 

type PoolerIntegrations struct {
	// +optional
	PgBouncerIntegration PgBouncerIntegrationStatus `json:"pgBouncerIntegration,omitempty"`
}

PoolerIntegrations encapsulates the needed integration for the poolers referencing the cluster

func (*PoolerIntegrations) DeepCopy 

func (in *PoolerIntegrations) DeepCopy() *PoolerIntegrations

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

func (*PoolerIntegrations) DeepCopyInto 

func (in *PoolerIntegrations) DeepCopyInto(out *PoolerIntegrations)

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

type PoolerList 

type PoolerList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []Pooler `json:"items"`
}

PoolerList contains a list of Pooler

func (*PoolerList) DeepCopy 

func (in *PoolerList) DeepCopy() *PoolerList

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

func (*PoolerList) DeepCopyInto 

func (in *PoolerList) DeepCopyInto(out *PoolerList)

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

func (*PoolerList) DeepCopyObject 

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

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

type PoolerMonitoringConfiguration added in v1.18.5 

type PoolerMonitoringConfiguration struct {
	// Enable or disable the `PodMonitor`
	// +kubebuilder:default:=false
	// +optional
	EnablePodMonitor bool `json:"enablePodMonitor,omitempty"`

	// The list of metric relabelings for the `PodMonitor`. Applied to samples before ingestion.
	// +optional
	PodMonitorMetricRelabelConfigs []monitoringv1.RelabelConfig `json:"podMonitorMetricRelabelings,omitempty"`

	// The list of relabelings for the `PodMonitor`. Applied to samples before scraping.
	// +optional
	PodMonitorRelabelConfigs []monitoringv1.RelabelConfig `json:"podMonitorRelabelings,omitempty"`
}

PoolerMonitoringConfiguration is the type containing all the monitoring configuration for a certain Pooler.

Mirrors the Cluster's MonitoringConfiguration but without the custom queries part for now.

func (*PoolerMonitoringConfiguration) DeepCopy added in v1.18.5 

func (in *PoolerMonitoringConfiguration) DeepCopy() *PoolerMonitoringConfiguration

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

func (*PoolerMonitoringConfiguration) DeepCopyInto added in v1.18.5 

func (in *PoolerMonitoringConfiguration) DeepCopyInto(out *PoolerMonitoringConfiguration)

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

type PoolerSecrets 

type PoolerSecrets struct {
	// The server TLS secret version
	// +optional
	ServerTLS SecretVersion `json:"serverTLS,omitempty"`

	// The server CA secret version
	// +optional
	ServerCA SecretVersion `json:"serverCA,omitempty"`

	// The client CA secret version
	// +optional
	ClientCA SecretVersion `json:"clientCA,omitempty"`

	// The version of the secrets used by PgBouncer
	// +optional
	PgBouncerSecrets *PgBouncerSecrets `json:"pgBouncerSecrets,omitempty"`
}

PoolerSecrets contains the versions of all the secrets used

func (*PoolerSecrets) DeepCopy 

func (in *PoolerSecrets) DeepCopy() *PoolerSecrets

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

func (*PoolerSecrets) DeepCopyInto 

func (in *PoolerSecrets) DeepCopyInto(out *PoolerSecrets)

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

type PoolerSpec 

type PoolerSpec struct {
	// This is the cluster reference on which the Pooler will work.
	// Pooler name should never match with any cluster name within the same namespace.
	Cluster LocalObjectReference `json:"cluster"`

	// Type of service to forward traffic to. Default: `rw`.
	// +kubebuilder:default:=rw
	// +optional
	Type PoolerType `json:"type,omitempty"`

	// The number of replicas we want. Default: 1.
	// +kubebuilder:default:=1
	// +optional
	Instances *int32 `json:"instances,omitempty"`

	// The template of the Pod to be created
	// +optional
	Template *PodTemplateSpec `json:"template,omitempty"`

	// The PgBouncer configuration
	PgBouncer *PgBouncerSpec `json:"pgbouncer"`

	// The deployment strategy to use for pgbouncer to replace existing pods with new ones
	// +optional
	DeploymentStrategy *appsv1.DeploymentStrategy `json:"deploymentStrategy,omitempty"`

	// The configuration of the monitoring infrastructure of this pooler.
	// +optional
	Monitoring *PoolerMonitoringConfiguration `json:"monitoring,omitempty"`
}

PoolerSpec defines the desired state of Pooler

func (*PoolerSpec) DeepCopy 

func (in *PoolerSpec) DeepCopy() *PoolerSpec

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

func (*PoolerSpec) DeepCopyInto 

func (in *PoolerSpec) DeepCopyInto(out *PoolerSpec)

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

type PoolerStatus 

type PoolerStatus struct {
	// The resource version of the config object
	// +optional
	Secrets *PoolerSecrets `json:"secrets,omitempty"`
	// The number of pods trying to be scheduled
	// +optional
	Instances int32 `json:"instances,omitempty"`
}

PoolerStatus defines the observed state of Pooler

func (*PoolerStatus) DeepCopy 

func (in *PoolerStatus) DeepCopy() *PoolerStatus

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

func (*PoolerStatus) DeepCopyInto 

func (in *PoolerStatus) DeepCopyInto(out *PoolerStatus)

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

type PoolerType 

type PoolerType string

PoolerType is the type of the connection pool, meaning the service we are targeting. Allowed values are `rw` and `ro`. +kubebuilder:validation:Enum=rw;ro

type PostInitApplicationSQLRefs added in v1.17.0 

type PostInitApplicationSQLRefs struct {
	// SecretRefs holds a list of references to Secrets
	// +optional
	SecretRefs []SecretKeySelector `json:"secretRefs,omitempty"`

	// ConfigMapRefs holds a list of references to ConfigMaps
	// +optional
	ConfigMapRefs []ConfigMapKeySelector `json:"configMapRefs,omitempty"`
}

PostInitApplicationSQLRefs points references to ConfigMaps or Secrets which contain SQL files, the general implementation order to these references is from all Secrets to all ConfigMaps, and inside Secrets or ConfigMaps, the implementation order is same as the order of each array

func (*PostInitApplicationSQLRefs) DeepCopy added in v1.17.0 

func (in *PostInitApplicationSQLRefs) DeepCopy() *PostInitApplicationSQLRefs

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

func (*PostInitApplicationSQLRefs) DeepCopyInto added in v1.17.0 

func (in *PostInitApplicationSQLRefs) DeepCopyInto(out *PostInitApplicationSQLRefs)

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

type PostgresConfiguration 

type PostgresConfiguration struct {
	// PostgreSQL configuration options (postgresql.conf)
	// +optional
	Parameters map[string]string `json:"parameters,omitempty"`

	// PostgreSQL Host Based Authentication rules (lines to be appended
	// to the pg_hba.conf file)
	// +optional
	PgHBA []string `json:"pg_hba,omitempty"`

	// PostgreSQL User Name Maps rules (lines to be appended
	// to the pg_ident.conf file)
	// +optional
	PgIdent []string `json:"pg_ident,omitempty"`

	// Requirements to be met by sync replicas. This will affect how the "synchronous_standby_names" parameter will be
	// set up.
	// +optional
	SyncReplicaElectionConstraint SyncReplicaElectionConstraints `json:"syncReplicaElectionConstraint,omitempty"`

	// Lists of shared preload libraries to add to the default ones
	// +optional
	AdditionalLibraries []string `json:"shared_preload_libraries,omitempty"`

	// Options to specify LDAP configuration
	// +optional
	LDAP *LDAPConfig `json:"ldap,omitempty"`

	// Specifies the maximum number of seconds to wait when promoting an instance to primary.
	// Default value is 40000000, greater than one year in seconds,
	// big enough to simulate an infinite timeout
	// +optional
	PgCtlTimeoutForPromotion int32 `json:"promotionTimeout,omitempty"`

	// If this parameter is true, the user will be able to invoke `ALTER SYSTEM`
	// on this CloudNativePG Cluster.
	// This should only be used for debugging and troubleshooting.
	// Defaults to false.
	// +optional
	EnableAlterSystem bool `json:"enableAlterSystem,omitempty"`
}

PostgresConfiguration defines the PostgreSQL configuration

func (*PostgresConfiguration) DeepCopy 

func (in *PostgresConfiguration) DeepCopy() *PostgresConfiguration

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

func (*PostgresConfiguration) DeepCopyInto 

func (in *PostgresConfiguration) DeepCopyInto(out *PostgresConfiguration)

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

type PrimaryUpdateMethod 

type PrimaryUpdateMethod string

PrimaryUpdateMethod contains the method to use when upgrading the primary server of the cluster as part of rolling updates

type PrimaryUpdateStrategy 

type PrimaryUpdateStrategy string

PrimaryUpdateStrategy contains the strategy to follow when upgrading the primary server of the cluster as part of rolling updates

type RecoveryTarget 

type RecoveryTarget struct {
	// The ID of the backup from which to start the recovery process.
	// If empty (default) the operator will automatically detect the backup
	// based on targetTime or targetLSN if specified. Otherwise use the
	// latest available backup in chronological order.
	// +optional
	BackupID string `json:"backupID,omitempty"`

	// The target timeline ("latest" or a positive integer)
	// +optional
	TargetTLI string `json:"targetTLI,omitempty"`

	// The target transaction ID
	// +optional
	TargetXID string `json:"targetXID,omitempty"`

	// The target name (to be previously created
	// with `pg_create_restore_point`)
	// +optional
	TargetName string `json:"targetName,omitempty"`

	// The target LSN (Log Sequence Number)
	// +optional
	TargetLSN string `json:"targetLSN,omitempty"`

	// The target time as a timestamp in the RFC3339 standard
	// +optional
	TargetTime string `json:"targetTime,omitempty"`

	// End recovery as soon as a consistent state is reached
	// +optional
	TargetImmediate *bool `json:"targetImmediate,omitempty"`

	// Set the target to be exclusive. If omitted, defaults to false, so that
	// in Postgres, `recovery_target_inclusive` will be true
	// +optional
	Exclusive *bool `json:"exclusive,omitempty"`
}

RecoveryTarget allows to configure the moment where the recovery process will stop. All the target options except TargetTLI are mutually exclusive.

func (*RecoveryTarget) BuildPostgresOptions 

func (target *RecoveryTarget) BuildPostgresOptions() string

BuildPostgresOptions create the list of options that should be added to the PostgreSQL configuration to recover given a certain target

func (*RecoveryTarget) DeepCopy 

func (in *RecoveryTarget) DeepCopy() *RecoveryTarget

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

func (*RecoveryTarget) DeepCopyInto 

func (in *RecoveryTarget) DeepCopyInto(out *RecoveryTarget)

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

type ReplicaClusterConfiguration 

type ReplicaClusterConfiguration struct {
	// The name of the external cluster which is the replication origin
	// +kubebuilder:validation:MinLength=1
	Source string `json:"source"`

	// If replica mode is enabled, this cluster will be a replica of an
	// existing cluster. Replica cluster can be created from a recovery
	// object store or via streaming through pg_basebackup.
	// Refer to the Replica clusters page of the documentation for more information.
	Enabled bool `json:"enabled"`
}

ReplicaClusterConfiguration encapsulates the configuration of a replica cluster

func (*ReplicaClusterConfiguration) DeepCopy 

func (in *ReplicaClusterConfiguration) DeepCopy() *ReplicaClusterConfiguration

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

func (*ReplicaClusterConfiguration) DeepCopyInto 

func (in *ReplicaClusterConfiguration) DeepCopyInto(out *ReplicaClusterConfiguration)

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

type ReplicationSlotsConfiguration added in v1.18.0 

type ReplicationSlotsConfiguration struct {
	// Replication slots for high availability configuration
	// +kubebuilder:default:={"enabled": true}
	// +optional
	HighAvailability *ReplicationSlotsHAConfiguration `json:"highAvailability,omitempty"`

	// Standby will update the status of the local replication slots
	// every `updateInterval` seconds (default 30).
	// +kubebuilder:default:=30
	// +kubebuilder:validation:Minimum=1
	// +optional
	UpdateInterval int `json:"updateInterval,omitempty"`
}

ReplicationSlotsConfiguration encapsulates the configuration of replication slots

func (*ReplicationSlotsConfiguration) DeepCopy added in v1.18.0 

func (in *ReplicationSlotsConfiguration) DeepCopy() *ReplicationSlotsConfiguration

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

func (*ReplicationSlotsConfiguration) DeepCopyInto added in v1.18.0 

func (in *ReplicationSlotsConfiguration) DeepCopyInto(out *ReplicationSlotsConfiguration)

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

func (*ReplicationSlotsConfiguration) GetUpdateInterval added in v1.18.0 

func (r *ReplicationSlotsConfiguration) GetUpdateInterval() time.Duration

GetUpdateInterval returns the update interval, defaulting to DefaultReplicationSlotsUpdateInterval if empty

type ReplicationSlotsHAConfiguration added in v1.18.0 

type ReplicationSlotsHAConfiguration struct {
	// If enabled (default), the operator will automatically manage replication slots
	// on the primary instance and use them in streaming replication
	// connections with all the standby instances that are part of the HA
	// cluster. If disabled, the operator will not take advantage
	// of replication slots in streaming connections with the replicas.
	// This feature also controls replication slots in replica cluster,
	// from the designated primary to its cascading replicas.
	// +optional
	// +kubebuilder:default:=true
	Enabled *bool `json:"enabled,omitempty"`

	// Prefix for replication slots managed by the operator for HA.
	// It may only contain lower case letters, numbers, and the underscore character.
	// This can only be set at creation time. By default set to `_cnpg_`.
	// +kubebuilder:default:=_cnpg_
	// +kubebuilder:validation:Pattern=^[0-9a-z_]*$
	// +optional
	SlotPrefix string `json:"slotPrefix,omitempty"`
}

ReplicationSlotsHAConfiguration encapsulates the configuration of the replication slots that are automatically managed by the operator to control the streaming replication connections with the standby instances for high availability (HA) purposes. Replication slots are a PostgreSQL feature that makes sure that PostgreSQL automatically keeps WAL files in the primary when a streaming client (in this specific case a replica that is part of the HA cluster) gets disconnected.

func (*ReplicationSlotsHAConfiguration) DeepCopy added in v1.18.0 

func (in *ReplicationSlotsHAConfiguration) DeepCopy() *ReplicationSlotsHAConfiguration

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

func (*ReplicationSlotsHAConfiguration) DeepCopyInto added in v1.18.0 

func (in *ReplicationSlotsHAConfiguration) DeepCopyInto(out *ReplicationSlotsHAConfiguration)

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

func (*ReplicationSlotsHAConfiguration) GetEnabled added in v1.18.4 

func (r *ReplicationSlotsHAConfiguration) GetEnabled() bool

GetEnabled returns false if replication slots are disabled, default is true

func (*ReplicationSlotsHAConfiguration) GetSlotNameFromInstanceName added in v1.18.0 

func (r *ReplicationSlotsHAConfiguration) GetSlotNameFromInstanceName(instanceName string) string

GetSlotNameFromInstanceName returns the slot name, given the instance name. It returns an empty string if High Availability Replication Slots are disabled

func (*ReplicationSlotsHAConfiguration) GetSlotPrefix added in v1.18.0 

func (r *ReplicationSlotsHAConfiguration) GetSlotPrefix() string

GetSlotPrefix returns the HA slot prefix, defaulting to DefaultReplicationSlotsHASlotPrefix if empty

type RoleConfiguration added in v1.20.0 

type RoleConfiguration struct {
	// Name of the role
	Name string `json:"name"`
	// Description of the role
	// +optional
	Comment string `json:"comment,omitempty"`

	// Ensure the role is `present` or `absent` - defaults to "present"
	// +kubebuilder:default:="present"
	// +kubebuilder:validation:Enum=present;absent
	// +optional
	Ensure EnsureOption `json:"ensure,omitempty"`

	// Secret containing the password of the role (if present)
	// If null, the password will be ignored unless DisablePassword is set
	// +optional
	PasswordSecret *LocalObjectReference `json:"passwordSecret,omitempty"`

	// If the role can log in, this specifies how many concurrent
	// connections the role can make. `-1` (the default) means no limit.
	// +kubebuilder:default:=-1
	// +optional
	ConnectionLimit int64 `json:"connectionLimit,omitempty"`

	// Date and time after which the role's password is no longer valid.
	// When omitted, the password will never expire (default).
	// +optional
	ValidUntil *metav1.Time `json:"validUntil,omitempty"`

	// List of one or more existing roles to which this role will be
	// immediately added as a new member. Default empty.
	// +optional
	InRoles []string `json:"inRoles,omitempty"`

	// Whether a role "inherits" the privileges of roles it is a member of.
	// Defaults is `true`.
	// +kubebuilder:default:=true
	// +optional
	Inherit *bool `json:"inherit,omitempty"` // IMPORTANT default is INHERIT

	// DisablePassword indicates that a role's password should be set to NULL in Postgres
	// +optional
	DisablePassword bool `json:"disablePassword,omitempty"`

	// Whether the role is a `superuser` who can override all access
	// restrictions within the database - superuser status is dangerous and
	// should be used only when really needed. You must yourself be a
	// superuser to create a new superuser. Defaults is `false`.
	// +optional
	Superuser bool `json:"superuser,omitempty"`

	// When set to `true`, the role being defined will be allowed to create
	// new databases. Specifying `false` (default) will deny a role the
	// ability to create databases.
	// +optional
	CreateDB bool `json:"createdb,omitempty"`

	// Whether the role will be permitted to create, alter, drop, comment
	// on, change the security label for, and grant or revoke membership in
	// other roles. Default is `false`.
	// +optional
	CreateRole bool `json:"createrole,omitempty"`

	// Whether the role is allowed to log in. A role having the `login`
	// attribute can be thought of as a user. Roles without this attribute
	// are useful for managing database privileges, but are not users in
	// the usual sense of the word. Default is `false`.
	// +optional
	Login bool `json:"login,omitempty"`

	// Whether a role is a replication role. A role must have this
	// attribute (or be a superuser) in order to be able to connect to the
	// server in replication mode (physical or logical replication) and in
	// order to be able to create or drop replication slots. A role having
	// the `replication` attribute is a very highly privileged role, and
	// should only be used on roles actually used for replication. Default
	// is `false`.
	// +optional
	Replication bool `json:"replication,omitempty"`

	// Whether a role bypasses every row-level security (RLS) policy.
	// Default is `false`.
	// +optional
	BypassRLS bool `json:"bypassrls,omitempty"` // Row-Level Security
}

RoleConfiguration is the representation, in Kubernetes, of a PostgreSQL role with the additional field Ensure specifying whether to ensure the presence or absence of the role in the database

The defaults of the CREATE ROLE command are applied Reference: https://www.postgresql.org/docs/current/sql-createrole.html

func (*RoleConfiguration) DeepCopy added in v1.20.0 

func (in *RoleConfiguration) DeepCopy() *RoleConfiguration

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

func (*RoleConfiguration) DeepCopyInto added in v1.20.0 

func (in *RoleConfiguration) DeepCopyInto(out *RoleConfiguration)

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

func (*RoleConfiguration) GetRoleInherit added in v1.20.0 

func (roleConfiguration *RoleConfiguration) GetRoleInherit() bool

GetRoleInherit return the inherit attribute of a roleConfiguration

func (*RoleConfiguration) GetRoleSecretsName added in v1.20.0 

func (roleConfiguration *RoleConfiguration) GetRoleSecretsName() string

GetRoleSecretsName gets the name of the secret which is used to store the role's password

type RoleStatus added in v1.20.0 

type RoleStatus string

RoleStatus represents the status of a managed role in the cluster 

const (
	// RoleStatusReconciled indicates the role in DB matches the Spec
	RoleStatusReconciled RoleStatus = "reconciled"
	// RoleStatusNotManaged indicates the role is not in the Spec, therefore not managed
	RoleStatusNotManaged RoleStatus = "not-managed"
	// RoleStatusPendingReconciliation indicates the role in Spec requires updated/creation in DB
	RoleStatusPendingReconciliation RoleStatus = "pending-reconciliation"
	// RoleStatusReserved indicates this is one of the roles reserved by the operator. E.g. `postgres`
	RoleStatusReserved RoleStatus = "reserved"
)

type RollingUpdateStatus 

type RollingUpdateStatus struct {
	// The image which we put into the Pod
	ImageName string `json:"imageName"`

	// When the update has been started
	// +optional
	StartedAt metav1.Time `json:"startedAt,omitempty"`
}

RollingUpdateStatus contains the information about an instance which is being updated

func (*RollingUpdateStatus) DeepCopy 

func (in *RollingUpdateStatus) DeepCopy() *RollingUpdateStatus

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

func (*RollingUpdateStatus) DeepCopyInto 

func (in *RollingUpdateStatus) DeepCopyInto(out *RollingUpdateStatus)

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

type S3Credentials 

type S3Credentials struct {
	// The reference to the access key id
	// +optional
	AccessKeyIDReference *SecretKeySelector `json:"accessKeyId,omitempty"`

	// The reference to the secret access key
	// +optional
	SecretAccessKeyReference *SecretKeySelector `json:"secretAccessKey,omitempty"`

	// The reference to the secret containing the region name
	// +optional
	RegionReference *SecretKeySelector `json:"region,omitempty"`

	// The references to the session key
	// +optional
	SessionToken *SecretKeySelector `json:"sessionToken,omitempty"`

	// Use the role based authentication without providing explicitly the keys.
	// +optional
	InheritFromIAMRole bool `json:"inheritFromIAMRole,omitempty"`
}

S3Credentials is the type for the credentials to be used to upload files to S3. It can be provided in two alternative ways:

- explicitly passing accessKeyId and secretAccessKey

- inheriting the role from the pod environment by setting inheritFromIAMRole to true

func (*S3Credentials) DeepCopy 

func (in *S3Credentials) DeepCopy() *S3Credentials

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

func (*S3Credentials) DeepCopyInto 

func (in *S3Credentials) DeepCopyInto(out *S3Credentials)

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

type ScheduledBackup 

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

	// Specification of the desired behavior of the ScheduledBackup.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	Spec ScheduledBackupSpec `json:"spec"`
	// Most recently observed status of the ScheduledBackup. This data may not be up
	// to date. Populated by the system. Read-only.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	// +optional
	Status ScheduledBackupStatus `json:"status,omitempty"`
}

ScheduledBackup is the Schema for the scheduledbackups API

func (*ScheduledBackup) CreateBackup 

func (scheduledBackup *ScheduledBackup) CreateBackup(name string) *Backup

CreateBackup creates a backup from this scheduled backup

func (*ScheduledBackup) DeepCopy 

func (in *ScheduledBackup) DeepCopy() *ScheduledBackup

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

func (*ScheduledBackup) DeepCopyInto 

func (in *ScheduledBackup) DeepCopyInto(out *ScheduledBackup)

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

func (*ScheduledBackup) DeepCopyObject 

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

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

func (*ScheduledBackup) Default 

func (r *ScheduledBackup) Default()

Default implements webhook.Defaulter so a webhook will be registered for the type

func (*ScheduledBackup) GetName 

func (scheduledBackup *ScheduledBackup) GetName() string

GetName gets the scheduled backup name

func (*ScheduledBackup) GetNamespace 

func (scheduledBackup *ScheduledBackup) GetNamespace() string

GetNamespace gets the scheduled backup name

func (*ScheduledBackup) GetSchedule 

func (scheduledBackup *ScheduledBackup) GetSchedule() string

GetSchedule get the cron-like schedule of this scheduled backup

func (*ScheduledBackup) GetStatus 

func (scheduledBackup *ScheduledBackup) GetStatus() *ScheduledBackupStatus

GetStatus gets the status that the caller may update

func (ScheduledBackup) IsImmediate 

func (scheduledBackup ScheduledBackup) IsImmediate() bool

IsImmediate check if a backup has to be issued immediately upon creation or not

func (ScheduledBackup) IsSuspended 

func (scheduledBackup ScheduledBackup) IsSuspended() bool

IsSuspended check if a scheduled backup has been suspended or not

func (*ScheduledBackup) SetupWebhookWithManager 

func (r *ScheduledBackup) SetupWebhookWithManager(mgr ctrl.Manager) error

SetupWebhookWithManager setup the webhook inside the controller manager

func (*ScheduledBackup) ValidateCreate 

func (r *ScheduledBackup) ValidateCreate() (admission.Warnings, error)

ValidateCreate implements webhook.Validator so a webhook will be registered for the type

func (*ScheduledBackup) ValidateDelete 

func (r *ScheduledBackup) ValidateDelete() (admission.Warnings, error)

ValidateDelete implements webhook.Validator so a webhook will be registered for the type

func (*ScheduledBackup) ValidateUpdate 

func (r *ScheduledBackup) ValidateUpdate(_ runtime.Object) (admission.Warnings, error)

ValidateUpdate implements webhook.Validator so a webhook will be registered for the type

type ScheduledBackupList 

type ScheduledBackupList struct {
	metav1.TypeMeta `json:",inline"`
	// Standard list metadata.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
	metav1.ListMeta `json:"metadata,omitempty"`
	// List of clusters
	Items []ScheduledBackup `json:"items"`
}

ScheduledBackupList contains a list of ScheduledBackup

func (*ScheduledBackupList) DeepCopy 

func (in *ScheduledBackupList) DeepCopy() *ScheduledBackupList

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

func (*ScheduledBackupList) DeepCopyInto 

func (in *ScheduledBackupList) DeepCopyInto(out *ScheduledBackupList)

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

func (*ScheduledBackupList) DeepCopyObject 

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

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

type ScheduledBackupSpec 

type ScheduledBackupSpec struct {
	// If this backup is suspended or not
	// +optional
	Suspend *bool `json:"suspend,omitempty"`

	// If the first backup has to be immediately start after creation or not
	// +optional
	Immediate *bool `json:"immediate,omitempty"`

	// The schedule does not follow the same format used in Kubernetes CronJobs
	// as it includes an additional seconds specifier,
	// see https://pkg.go.dev/github.com/robfig/cron#hdr-CRON_Expression_Format
	Schedule string `json:"schedule"`

	// The cluster to backup
	Cluster LocalObjectReference `json:"cluster"`

	// Indicates which ownerReference should be put inside the created backup resources.<br />
	// - none: no owner reference for created backup objects (same behavior as before the field was introduced)<br />
	// - self: sets the Scheduled backup object as owner of the backup<br />
	// - cluster: set the cluster as owner of the backup<br />
	// +kubebuilder:validation:Enum=none;self;cluster
	// +kubebuilder:default:=none
	// +optional
	BackupOwnerReference string `json:"backupOwnerReference,omitempty"`

	// The policy to decide which instance should perform this backup. If empty,
	// it defaults to `cluster.spec.backup.target`.
	// Available options are empty string, `primary` and `prefer-standby`.
	// `primary` to have backups run always on primary instances,
	// `prefer-standby` to have backups run preferably on the most updated
	// standby, if available.
	// +kubebuilder:validation:Enum=primary;prefer-standby
	// +optional
	Target BackupTarget `json:"target,omitempty"`

	// The backup method to be used, possible options are `barmanObjectStore`
	// and `volumeSnapshot`. Defaults to: `barmanObjectStore`.
	// +optional
	// +kubebuilder:validation:Enum=barmanObjectStore;volumeSnapshot
	// +kubebuilder:default:=barmanObjectStore
	Method BackupMethod `json:"method,omitempty"`

	// Whether the default type of backup with volume snapshots is
	// online/hot (`true`, default) or offline/cold (`false`)
	// Overrides the default setting specified in the cluster field '.spec.backup.volumeSnapshot.online'
	// +optional
	Online *bool `json:"online,omitempty"`

	// Configuration parameters to control the online/hot backup with volume snapshots
	// Overrides the default settings specified in the cluster '.backup.volumeSnapshot.onlineConfiguration' stanza
	// +optional
	OnlineConfiguration *OnlineConfiguration `json:"onlineConfiguration,omitempty"`
}

ScheduledBackupSpec defines the desired state of ScheduledBackup

func (*ScheduledBackupSpec) DeepCopy 

func (in *ScheduledBackupSpec) DeepCopy() *ScheduledBackupSpec

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

func (*ScheduledBackupSpec) DeepCopyInto 

func (in *ScheduledBackupSpec) DeepCopyInto(out *ScheduledBackupSpec)

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

type ScheduledBackupStatus 

type ScheduledBackupStatus struct {
	// The latest time the schedule
	// +optional
	LastCheckTime *metav1.Time `json:"lastCheckTime,omitempty"`

	// Information when was the last time that backup was successfully scheduled.
	// +optional
	LastScheduleTime *metav1.Time `json:"lastScheduleTime,omitempty"`

	// Next time we will run a backup
	// +optional
	NextScheduleTime *metav1.Time `json:"nextScheduleTime,omitempty"`
}

ScheduledBackupStatus defines the observed state of ScheduledBackup

func (*ScheduledBackupStatus) DeepCopy 

func (in *ScheduledBackupStatus) DeepCopy() *ScheduledBackupStatus

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

func (*ScheduledBackupStatus) DeepCopyInto 

func (in *ScheduledBackupStatus) DeepCopyInto(out *ScheduledBackupStatus)

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

type SecretKeySelector 

type SecretKeySelector struct {
	// The name of the secret in the pod's namespace to select from.
	LocalObjectReference `json:",inline"`
	// The key to select
	Key string `json:"key"`
}

SecretKeySelector contains enough information to let you locate the key of a Secret

func (*SecretKeySelector) DeepCopy 

func (in *SecretKeySelector) DeepCopy() *SecretKeySelector

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

func (*SecretKeySelector) DeepCopyInto 

func (in *SecretKeySelector) DeepCopyInto(out *SecretKeySelector)

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

type SecretVersion 

type SecretVersion struct {
	// The name of the secret
	// +optional
	Name string `json:"name,omitempty"`

	// The ResourceVersion of the secret
	// +optional
	Version string `json:"version,omitempty"`
}

SecretVersion contains a secret name and its ResourceVersion

func (*SecretVersion) DeepCopy 

func (in *SecretVersion) DeepCopy() *SecretVersion

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

func (*SecretVersion) DeepCopyInto 

func (in *SecretVersion) DeepCopyInto(out *SecretVersion)

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

type SecretsResourceVersion 

type SecretsResourceVersion struct {
	// The resource version of the "postgres" user secret
	// +optional
	SuperuserSecretVersion string `json:"superuserSecretVersion,omitempty"`

	// The resource version of the "streaming_replica" user secret
	// +optional
	ReplicationSecretVersion string `json:"replicationSecretVersion,omitempty"`

	// The resource version of the "app" user secret
	// +optional
	ApplicationSecretVersion string `json:"applicationSecretVersion,omitempty"`

	// The resource versions of the managed roles secrets
	// +optional
	ManagedRoleSecretVersions map[string]string `json:"managedRoleSecretVersion,omitempty"`

	// Unused. Retained for compatibility with old versions.
	// +optional
	CASecretVersion string `json:"caSecretVersion,omitempty"`

	// The resource version of the PostgreSQL client-side CA secret version
	// +optional
	ClientCASecretVersion string `json:"clientCaSecretVersion,omitempty"`

	// The resource version of the PostgreSQL server-side CA secret version
	// +optional
	ServerCASecretVersion string `json:"serverCaSecretVersion,omitempty"`

	// The resource version of the PostgreSQL server-side secret version
	// +optional
	ServerSecretVersion string `json:"serverSecretVersion,omitempty"`

	// The resource version of the Barman Endpoint CA if provided
	// +optional
	BarmanEndpointCA string `json:"barmanEndpointCA,omitempty"`

	// The resource versions of the external cluster secrets
	// +optional
	ExternalClusterSecretVersions map[string]string `json:"externalClusterSecretVersion,omitempty"`

	// A map with the versions of all the secrets used to pass metrics.
	// Map keys are the secret names, map values are the versions
	// +optional
	Metrics map[string]string `json:"metrics,omitempty"`
}

SecretsResourceVersion is the resource versions of the secrets managed by the operator

func (*SecretsResourceVersion) DeepCopy 

func (in *SecretsResourceVersion) DeepCopy() *SecretsResourceVersion

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

func (*SecretsResourceVersion) DeepCopyInto 

func (in *SecretsResourceVersion) DeepCopyInto(out *SecretsResourceVersion)

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

func (*SecretsResourceVersion) SetExternalClusterSecretVersion added in v1.20.5 

func (secretResourceVersion *SecretsResourceVersion) SetExternalClusterSecretVersion(
	secretName string,
	version *string,
)

SetExternalClusterSecretVersion Add or update or delete the resource version of the secret used in external clusters

func (*SecretsResourceVersion) SetManagedRoleSecretVersion added in v1.20.0 

func (secretResourceVersion *SecretsResourceVersion) SetManagedRoleSecretVersion(secret string, version *string)

SetManagedRoleSecretVersion Add or update or delete the resource version of the managed role secret

type ServiceAccountTemplate added in v1.18.1 

type ServiceAccountTemplate struct {
	// Metadata are the metadata to be used for the generated
	// service account
	Metadata Metadata `json:"metadata"`
}

ServiceAccountTemplate contains the template needed to generate the service accounts

func (*ServiceAccountTemplate) DeepCopy added in v1.18.1 

func (in *ServiceAccountTemplate) DeepCopy() *ServiceAccountTemplate

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

func (*ServiceAccountTemplate) DeepCopyInto added in v1.18.1 

func (in *ServiceAccountTemplate) DeepCopyInto(out *ServiceAccountTemplate)

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

func (*ServiceAccountTemplate) MergeMetadata added in v1.18.1 

func (st *ServiceAccountTemplate) MergeMetadata(sa *corev1.ServiceAccount)

MergeMetadata adds the passed custom annotations and labels in the service account.

type SnapshotOwnerReference added in v1.21.0 

type SnapshotOwnerReference string

SnapshotOwnerReference defines the reference type for the owner of the snapshot. This specifies which owner the processed resources should relate to. 

const (
	// ShapshotOwnerReferenceNone indicates that the snapshot does not have any owner reference.
	ShapshotOwnerReferenceNone SnapshotOwnerReference = "none"
	// SnapshotOwnerReferenceBackup indicates that the snapshot is owned by the backup resource.
	SnapshotOwnerReferenceBackup SnapshotOwnerReference = "backup"
	// SnapshotOwnerReferenceCluster indicates that the snapshot is owned by the cluster resource.
	SnapshotOwnerReferenceCluster SnapshotOwnerReference = "cluster"
)

Constants to represent the allowed types for SnapshotOwnerReference.

type SnapshotType added in v1.16.0 

type SnapshotType string

SnapshotType is a type of allowed import 

const (
	// MonolithSnapshotType indicates to execute the monolith clone typology
	MonolithSnapshotType SnapshotType = "monolith"

	// MicroserviceSnapshotType indicates to execute the microservice clone typology
	MicroserviceSnapshotType SnapshotType = "microservice"
)

type StorageConfiguration 

type StorageConfiguration struct {
	// StorageClass to use for PVCs. Applied after
	// evaluating the PVC template, if available.
	// If not specified, the generated PVCs will use the
	// default storage class
	// +optional
	StorageClass *string `json:"storageClass,omitempty"`

	// Size of the storage. Required if not already specified in the PVC template.
	// Changes to this field are automatically reapplied to the created PVCs.
	// Size cannot be decreased.
	// +optional
	Size string `json:"size,omitempty"`

	// Resize existent PVCs, defaults to true
	// +optional
	// +kubebuilder:default:=true
	ResizeInUseVolumes *bool `json:"resizeInUseVolumes,omitempty"`

	// Template to be used to generate the Persistent Volume Claim
	// +optional
	PersistentVolumeClaimTemplate *corev1.PersistentVolumeClaimSpec `json:"pvcTemplate,omitempty"`
}

StorageConfiguration is the configuration used to create and reconcile PVCs, usable for WAL volumes, PGDATA volumes, or tablespaces

func (*StorageConfiguration) DeepCopy 

func (in *StorageConfiguration) DeepCopy() *StorageConfiguration

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

func (*StorageConfiguration) DeepCopyInto 

func (in *StorageConfiguration) DeepCopyInto(out *StorageConfiguration)

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

func (*StorageConfiguration) GetSizeOrNil added in v1.17.4 

func (s *StorageConfiguration) GetSizeOrNil() *resource.Quantity

GetSizeOrNil returns the requests storage size

type SyncReplicaElectionConstraints added in v1.16.0 

type SyncReplicaElectionConstraints struct {
	// A list of node labels values to extract and compare to evaluate if the pods reside in the same topology or not
	// +optional
	NodeLabelsAntiAffinity []string `json:"nodeLabelsAntiAffinity,omitempty"`

	// This flag enables the constraints for sync replicas
	Enabled bool `json:"enabled"`
}

SyncReplicaElectionConstraints contains the constraints for sync replicas election.

For anti-affinity parameters two instances are considered in the same location if all the labels values match.

In future synchronous replica election restriction by name will be supported.

func (*SyncReplicaElectionConstraints) DeepCopy added in v1.16.0 

func (in *SyncReplicaElectionConstraints) DeepCopy() *SyncReplicaElectionConstraints

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

func (*SyncReplicaElectionConstraints) DeepCopyInto added in v1.16.0 

func (in *SyncReplicaElectionConstraints) DeepCopyInto(out *SyncReplicaElectionConstraints)

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

type TablespaceConfiguration added in v1.22.0 

type TablespaceConfiguration struct {
	// The name of the tablespace
	Name string `json:"name"`

	// The storage configuration for the tablespace
	Storage StorageConfiguration `json:"storage"`

	// Owner is the PostgreSQL user owning the tablespace
	// +optional
	Owner DatabaseRoleRef `json:"owner,omitempty"`

	// When set to true, the tablespace will be added as a `temp_tablespaces`
	// entry in PostgreSQL, and will be available to automatically house temp
	// database objects, or other temporary files. Please refer to PostgreSQL
	// documentation for more information on the `temp_tablespaces` GUC.
	// +optional
	// +kubebuilder:default:=false
	Temporary bool `json:"temporary,omitempty"`
}

TablespaceConfiguration is the configuration of a tablespace, and includes the storage specification for the tablespace

func (*TablespaceConfiguration) DeepCopy added in v1.22.0 

func (in *TablespaceConfiguration) DeepCopy() *TablespaceConfiguration

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

func (*TablespaceConfiguration) DeepCopyInto added in v1.22.0 

func (in *TablespaceConfiguration) DeepCopyInto(out *TablespaceConfiguration)

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

type TablespaceState added in v1.22.0 

type TablespaceState struct {
	// Name is the name of the tablespace
	Name string `json:"name"`

	// Owner is the PostgreSQL user owning the tablespace
	// +optional
	Owner string `json:"owner,omitempty"`

	// State is the latest reconciliation state
	State TablespaceStatus `json:"state"`

	// Error is the reconciliation error, if any
	// +optional
	Error string `json:"error,omitempty"`
}

TablespaceState represents the state of a tablespace in a cluster

func (*TablespaceState) DeepCopy added in v1.22.0 

func (in *TablespaceState) DeepCopy() *TablespaceState

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

func (*TablespaceState) DeepCopyInto added in v1.22.0 

func (in *TablespaceState) DeepCopyInto(out *TablespaceState)

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

type TablespaceStatus added in v1.22.0 

type TablespaceStatus string

TablespaceStatus represents the status of a tablespace in the cluster 

const (
	// TablespaceStatusReconciled indicates the tablespace in DB matches the Spec
	TablespaceStatusReconciled TablespaceStatus = "reconciled"

	// TablespaceStatusPendingReconciliation indicates the tablespace in Spec requires creation in the DB
	TablespaceStatusPendingReconciliation TablespaceStatus = "pending"
)

type Topology added in v1.16.0 

type Topology struct {
	// Instances contains the pod topology of the instances
	// +optional
	Instances map[PodName]PodTopologyLabels `json:"instances,omitempty"`

	// NodesUsed represents the count of distinct nodes accommodating the instances.
	// A value of '1' suggests that all instances are hosted on a single node,
	// implying the absence of High Availability (HA). Ideally, this value should
	// be the same as the number of instances in the Postgres HA cluster, implying
	// shared nothing architecture on the compute side.
	// +optional
	NodesUsed int32 `json:"nodesUsed,omitempty"`

	// SuccessfullyExtracted indicates if the topology data was extract. It is useful to enact fallback behaviors
	// in synchronous replica election in case of failures
	// +optional
	SuccessfullyExtracted bool `json:"successfullyExtracted,omitempty"`
}

Topology contains the cluster topology

func (*Topology) DeepCopy added in v1.16.0 

func (in *Topology) DeepCopy() *Topology

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

func (*Topology) DeepCopyInto added in v1.16.0 

func (in *Topology) DeepCopyInto(out *Topology)

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

type VolumeSnapshotConfiguration added in v1.21.0 

type VolumeSnapshotConfiguration struct {
	// Labels are key-value pairs that will be added to .metadata.labels snapshot resources.
	// +optional
	Labels map[string]string `json:"labels,omitempty"`
	// Annotations key-value pairs that will be added to .metadata.annotations snapshot resources.
	// +optional
	Annotations map[string]string `json:"annotations,omitempty"`
	// ClassName specifies the Snapshot Class to be used for PG_DATA PersistentVolumeClaim.
	// It is the default class for the other types if no specific class is present
	// +optional
	ClassName string `json:"className,omitempty"`
	// WalClassName specifies the Snapshot Class to be used for the PG_WAL PersistentVolumeClaim.
	// +optional
	WalClassName string `json:"walClassName,omitempty"`
	// TablespaceClassName specifies the Snapshot Class to be used for the tablespaces.
	// defaults to the PGDATA Snapshot Class, if set
	// +optional
	TablespaceClassName map[string]string `json:"tablespaceClassName,omitempty"`
	// SnapshotOwnerReference indicates the type of owner reference the snapshot should have
	// +optional
	// +kubebuilder:validation:Enum:=none;cluster;backup
	// +kubebuilder:default:=none
	SnapshotOwnerReference SnapshotOwnerReference `json:"snapshotOwnerReference,omitempty"`

	// Whether the default type of backup with volume snapshots is
	// online/hot (`true`, default) or offline/cold (`false`)
	// +optional
	// +kubebuilder:default:=true
	Online *bool `json:"online,omitempty"`

	// Configuration parameters to control the online/hot backup with volume snapshots
	// +kubebuilder:default:={waitForArchive:true,immediateCheckpoint:false}
	// +optional
	OnlineConfiguration OnlineConfiguration `json:"onlineConfiguration,omitempty"`
}

VolumeSnapshotConfiguration represents the configuration for the execution of snapshot backups.

func (*VolumeSnapshotConfiguration) DeepCopy added in v1.21.0 

func (in *VolumeSnapshotConfiguration) DeepCopy() *VolumeSnapshotConfiguration

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

func (*VolumeSnapshotConfiguration) DeepCopyInto added in v1.21.0 

func (in *VolumeSnapshotConfiguration) DeepCopyInto(out *VolumeSnapshotConfiguration)

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

func (*VolumeSnapshotConfiguration) GetOnline added in v1.21.1 

func (configuration *VolumeSnapshotConfiguration) GetOnline() bool

GetOnline tells whether this volume snapshot configuration allows online backups

type WalBackupConfiguration 

type WalBackupConfiguration struct {
	// Compress a WAL file before sending it to the object store. Available
	// options are empty string (no compression, default), `gzip`, `bzip2` or `snappy`.
	// +kubebuilder:validation:Enum=gzip;bzip2;snappy
	// +optional
	Compression CompressionType `json:"compression,omitempty"`

	// Whenever to force the encryption of files (if the bucket is
	// not already configured for that).
	// Allowed options are empty string (use the bucket policy, default),
	// `AES256` and `aws:kms`
	// +kubebuilder:validation:Enum=AES256;"aws:kms"
	// +optional
	Encryption EncryptionType `json:"encryption,omitempty"`

	// Number of WAL files to be either archived in parallel (when the
	// PostgreSQL instance is archiving to a backup object store) or
	// restored in parallel (when a PostgreSQL standby is fetching WAL
	// files from a recovery object store). If not specified, WAL files
	// will be processed one at a time. It accepts a positive integer as a
	// value - with 1 being the minimum accepted value.
	// +kubebuilder:validation:Minimum=1
	// +optional
	MaxParallel int `json:"maxParallel,omitempty"`
}

WalBackupConfiguration is the configuration of the backup of the WAL stream

func (*WalBackupConfiguration) DeepCopy 

func (in *WalBackupConfiguration) DeepCopy() *WalBackupConfiguration

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

func (*WalBackupConfiguration) DeepCopyInto 

func (in *WalBackupConfiguration) DeepCopyInto(out *WalBackupConfiguration)

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.