v1

package
v1.25.0 Latest Latest
Warning

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

 Go to latest Published: Dec 23, 2024 License: Apache-2.0 Imports: 11 Imported by: 4

Documentation

Overview

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 (
	// PodHealthy means that a Pod is active and ready
	PodHealthy = "healthy"

	// PodReplicating means that a Pod is still not ready but still active
	PodReplicating = "replicating"

	// PodFailed means that a Pod will not be scheduled again (deleted or evicted)
	PodFailed = "failed"
)
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"

	// MissingWALDiskSpaceExitCode is the exit code the instance manager
	// will use to signal that there's no more WAL disk space
	MissingWALDiskSpaceExitCode = 4
)
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"

	// PhaseUpgradeDelayed is set when a cluster need to be upgraded
	// but the operation is being delayed by the operator configuration
	PhaseUpgradeDelayed = "Cluster upgrade delayed"

	// 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"

	// PhaseUnknownPlugin is triggered when the required CNPG-i plugin have not been
	// loaded still
	PhaseUnknownPlugin = "Cluster cannot proceed to reconciliation due to an unknown plugin being required"

	// PhaseImageCatalogError is triggered when the cluster cannot select the image to
	// apply because of an invalid or incomplete catalog
	PhaseImageCatalogError = "Cluster has incomplete or invalid image catalog"

	// PhaseUnrecoverable for an unrecoverable cluster
	PhaseUnrecoverable = "Cluster is unrecoverable and 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"

	// PhaseReplicaClusterPromotion is the phase
	PhaseReplicaClusterPromotion = "Promoting to primary cluster"

	// PhaseCannotCreateClusterObjects is set by the operator when is unable to create cluster resources
	PhaseCannotCreateClusterObjects = "Unable to create required cluster objects"
)
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 (
	// SynchronousReplicaConfigurationMethodFirst means a priority list should be used
	SynchronousReplicaConfigurationMethodFirst = SynchronousReplicaConfigurationMethod("first")

	// SynchronousReplicaConfigurationMethodAny means that quorum based replication should be used
	SynchronousReplicaConfigurationMethodAny = SynchronousReplicaConfigurationMethod("any")
)
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 (
	// ServiceUpdateStrategyPatch applies a patch deriving from the differences of the actual service and the expect one
	ServiceUpdateStrategyPatch = "patch"
	// ServiceUpdateStrategyReplace deletes the existing service and recreates it when a difference is detected
	ServiceUpdateStrategyReplace = "replace"
)
View Source 
const (
	// 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"

	// ImageCatalogKind is the kind name of namespaced image catalogs
	ImageCatalogKind = "ImageCatalog"

	// ClusterImageCatalogKind is the kind name of the cluster-wide image catalogs
	ClusterImageCatalogKind = "ClusterImageCatalog"

	// PublicationKind is the kind name of publications
	PublicationKind = "Publication"

	// SubscriptionKind is the kind name of subscriptions
	SubscriptionKind = "Subscription"

	// DatabaseKind is the kind name of databases
	DatabaseKind = "Database"
)
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 (
	// GroupVersion is group version used to register these objects
	GroupVersion = schema.GroupVersion{Group: "postgresql.cnpg.io", Version: "v1"}

	// 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
)

Functions

This section is empty.

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 

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 

func (in *AvailableArchitecture) DeepCopy() *AvailableArchitecture

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

func (*AvailableArchitecture) DeepCopyInto 

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 = barmanApi.AzureCredentials

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 +kubebuilder:object:generate:=false

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.

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.

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
	// +optional
	metav1.ListMeta `json:"metadata,omitempty"`
	// List of backups
	Items []Backup `json:"items"`
}

BackupList contains a list of Backup

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.

type BackupMethod 

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"

	// BackupMethodPlugin means that this backup should be handled by
	// a plugin
	BackupMethodPlugin BackupMethod = "plugin"
)

type BackupPhase 

type BackupPhase string

BackupPhase is the phase of the backup

type BackupPluginConfiguration 

type BackupPluginConfiguration struct {
	// Name is the name of the plugin managing this backup
	Name string `json:"name"`

	// Parameters are the configuration parameters passed to the backup
	// plugin for this backup
	// +optional
	Parameters map[string]string `json:"parameters,omitempty"`
}

BackupPluginConfiguration contains the backup configuration used by the backup plugin

func (*BackupPluginConfiguration) DeepCopy 

func (in *BackupPluginConfiguration) DeepCopy() *BackupPluginConfiguration

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

func (*BackupPluginConfiguration) DeepCopyInto 

func (in *BackupPluginConfiguration) DeepCopyInto(out *BackupPluginConfiguration)

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

type BackupSnapshotElementStatus 

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
	// +optional
	TablespaceName string `json:"tablespaceName,omitempty"`
}

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

func (*BackupSnapshotElementStatus) DeepCopy 

func (in *BackupSnapshotElementStatus) DeepCopy() *BackupSnapshotElementStatus

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

func (*BackupSnapshotElementStatus) DeepCopyInto 

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 

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 

func (in *BackupSnapshotStatus) DeepCopy() *BackupSnapshotStatus

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

func (*BackupSnapshotStatus) DeepCopyInto 

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

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

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`,
	// `volumeSnapshot` or `plugin`. Defaults to: `barmanObjectStore`.
	// +optional
	// +kubebuilder:validation:Enum=barmanObjectStore;volumeSnapshot;plugin
	// +kubebuilder:default:=barmanObjectStore
	Method BackupMethod `json:"method,omitempty"`

	// Configuration parameters passed to the plugin managing this backup
	// +optional
	PluginConfiguration *BackupPluginConfiguration `json:"pluginConfiguration,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`)
	// +optional
	Online *bool `json:"online,omitempty"`

	// A map containing the plugin metadata
	// +optional
	PluginMetadata map[string]string `json:"pluginMetadata,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.

type BackupTarget 

type BackupTarget string

BackupTarget describes the preferred targets for a backup

type BarmanCredentials 

type BarmanCredentials = barmanApi.BarmanCredentials

BarmanCredentials an object containing the potential credentials for each cloud provider +kubebuilder:object:generate:=false

type BarmanObjectStoreConfiguration 

type BarmanObjectStoreConfiguration = barmanApi.BarmanObjectStoreConfiguration

BarmanObjectStoreConfiguration contains the backup configuration using Barman against an S3-compatible object storage +kubebuilder:object:generate:=false

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

	// Sets the default collation order and character classification in the new database.
	// +optional
	Locale string `json:"locale,omitempty"`

	// This option sets the locale provider for databases created in the new cluster.
	// Available from PostgreSQL 16.
	// +optional
	LocaleProvider string `json:"localeProvider,omitempty"`

	// Specifies the ICU locale when the ICU provider is used.
	// This option requires `localeProvider` to be set to `icu`.
	// Available from PostgreSQL 15.
	// +optional
	IcuLocale string `json:"icuLocale,omitempty"`

	// Specifies additional collation rules to customize the behavior of the default collation.
	// This option requires `localeProvider` to be set to `icu`.
	// Available from PostgreSQL 16.
	// +optional
	IcuRules string `json:"icuRules,omitempty"`

	// Specifies the locale name when the builtin provider is used.
	// This option requires `localeProvider` to be set to `builtin`.
	// Available from PostgreSQL 17.
	// +optional
	BuiltinLocale string `json:"builtinLocale,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 in the `postgres`
	// database right 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 the cluster has been 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`
	// database right 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"`

	// List of references to ConfigMaps or Secrets containing SQL files
	// to be executed as a superuser in the application database right after
	// the cluster has been created. The references are processed in a specific order:
	// first, all Secrets are processed, followed by all ConfigMaps.
	// Within each group, the processing order follows the sequence specified
	// in their respective arrays.
	// (by default empty)
	// +optional
	PostInitApplicationSQLRefs *SQLRefs `json:"postInitApplicationSQLRefs,omitempty"`

	// List of references to ConfigMaps or Secrets containing SQL files
	// to be executed as a superuser in the `template1` database right after
	// the cluster has been created. The references are processed in a specific order:
	// first, all Secrets are processed, followed by all ConfigMaps.
	// Within each group, the processing order follows the sequence specified
	// in their respective arrays.
	// (by default empty)
	// +optional
	PostInitTemplateSQLRefs *SQLRefs `json:"postInitTemplateSQLRefs,omitempty"`

	// List of references to ConfigMaps or Secrets containing SQL files
	// to be executed as a superuser in the `postgres` database right after
	// the cluster has been created. The references are processed in a specific order:
	// first, all Secrets are processed, followed by all ConfigMaps.
	// Within each group, the processing order follows the sequence specified
	// in their respective arrays.
	// (by default empty)
	// +optional
	PostInitSQLRefs *SQLRefs `json:"postInitSQLRefs,omitempty"`
}

BootstrapInitDB is the configuration of the bootstrap process when initdb is used Refer to the Bootstrap page of the documentation for more information. +kubebuilder:validation:XValidation:rule="!has(self.builtinLocale) || self.localeProvider == 'builtin'",message="builtinLocale is only available when localeProvider is set to `builtin`" +kubebuilder:validation:XValidation:rule="!has(self.icuLocale) || self.localeProvider == 'icu'",message="icuLocale is only available when localeProvider is set to `icu`" +kubebuilder:validation:XValidation:rule="!has(self.icuRules) || self.localeProvider == 'icu'",message="icuRules is only available when localeProvider is set to `icu`"

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 CatalogImage 

type CatalogImage struct {
	// The image reference
	Image string `json:"image"`
	// +kubebuilder:validation:Minimum=10
	// The PostgreSQL major version of the image. Must be unique within the catalog.
	Major int `json:"major"`
}

CatalogImage defines the image and major version

func (*CatalogImage) DeepCopy 

func (in *CatalogImage) DeepCopy() *CatalogImage

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

func (*CatalogImage) DeepCopyInto 

func (in *CatalogImage) DeepCopyInto(out *CatalogImage)

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) 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.

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 ClusterImageCatalog 

type ClusterImageCatalog struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata"`
	// Specification of the desired behavior of the ClusterImageCatalog.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	Spec ImageCatalogSpec `json:"spec"`
}

ClusterImageCatalog is the Schema for the clusterimagecatalogs API

func (*ClusterImageCatalog) DeepCopy 

func (in *ClusterImageCatalog) DeepCopy() *ClusterImageCatalog

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

func (*ClusterImageCatalog) DeepCopyInto 

func (in *ClusterImageCatalog) DeepCopyInto(out *ClusterImageCatalog)

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

func (*ClusterImageCatalog) DeepCopyObject 

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

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

type ClusterImageCatalogList 

type ClusterImageCatalogList 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"`
	// List of ClusterImageCatalogs
	Items []ClusterImageCatalog `json:"items"`
}

ClusterImageCatalogList contains a list of ClusterImageCatalog

func (*ClusterImageCatalogList) DeepCopy 

func (in *ClusterImageCatalogList) DeepCopy() *ClusterImageCatalogList

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

func (*ClusterImageCatalogList) DeepCopyInto 

func (in *ClusterImageCatalogList) DeepCopyInto(out *ClusterImageCatalogList)

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

func (*ClusterImageCatalogList) DeepCopyObject 

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

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

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
	// +optional
	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 ClusterMonitoringTLSConfiguration 

type ClusterMonitoringTLSConfiguration struct {
	// Enable TLS for the monitoring endpoint.
	// Changing this option will force a rollout of all instances.
	// +kubebuilder:default:=false
	// +optional
	Enabled bool `json:"enabled,omitempty"`
}

ClusterMonitoringTLSConfiguration is the type containing the TLS configuration for the cluster's monitoring

func (*ClusterMonitoringTLSConfiguration) DeepCopy 

func (in *ClusterMonitoringTLSConfiguration) DeepCopy() *ClusterMonitoringTLSConfiguration

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

func (*ClusterMonitoringTLSConfiguration) DeepCopyInto 

func (in *ClusterMonitoringTLSConfiguration) DeepCopyInto(out *ClusterMonitoringTLSConfiguration)

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

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

	// Defines the major PostgreSQL version we want to use within an ImageCatalog
	// +optional
	ImageCatalogRef *ImageCatalogRef `json:"imageCatalogRef,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
	// +optional
	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"`

	// Manage the `PodDisruptionBudget` resources within the cluster. When
	// configured as `true` (default setting), the pod disruption budgets
	// will safeguard the primary node from being terminated. Conversely,
	// setting it to `false` will result in the absence of any
	// `PodDisruptionBudget` resource, permitting the shutdown of all nodes
	// hosting the PostgreSQL cluster. This latter configuration is
	// advisable for any PostgreSQL cluster employed for
	// development/staging purposes.
	// +kubebuilder:default:=true
	// +optional
	EnablePDB *bool `json:"enablePDB,omitempty"`

	// The plugins configuration, containing
	// any plugin to be loaded with the corresponding configuration
	// +optional
	Plugins []PluginConfiguration `json:"plugins,omitempty"`

	// The configuration of the probes to be injected
	// in the PostgreSQL Pods.
	// +optional
	Probes *ProbesConfiguration `json:"probes,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[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"`

	// LastPromotionToken is the last verified promotion token that
	// was used to promote a replica cluster
	// +optional
	LastPromotionToken string `json:"lastPromotionToken,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"`

	// Image contains the image name used by the pods
	// +optional
	Image string `json:"image,omitempty"`

	// PluginStatus is the status of the loaded plugins
	// +optional
	PluginStatus []PluginStatus `json:"pluginStatus,omitempty"`

	// SwitchReplicaClusterStatus is the status of the switch to replica cluster
	// +optional
	SwitchReplicaClusterStatus SwitchReplicaClusterStatus `json:"switchReplicaClusterStatus,omitempty"`

	// DemotionToken is a JSON token containing the information
	// from pg_controldata such as Database system identifier, Latest checkpoint's
	// TimeLineID, Latest checkpoint's REDO location, Latest checkpoint's REDO
	// WAL file, and Time of latest checkpoint
	// +optional
	DemotionToken string `json:"demotionToken,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.

type ConditionReason 

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 = machineryapi.ConfigMapKeySelector

ConfigMapKeySelector contains enough information to let you locate the key of a ConfigMap +kubebuilder:object:generate:=false

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 = barmanApi.DataBackupConfiguration

DataBackupConfiguration is the configuration of the backup of the data directory +kubebuilder:object:generate:=false

type DataDurabilityLevel 

type DataDurabilityLevel string

DataDurabilityLevel specifies how strictly to enforce synchronous replication when cluster instances are unavailable. Options are `required` or `preferred`. 

const (
	// DataDurabilityLevelRequired means that data durability is strictly enforced
	DataDurabilityLevelRequired DataDurabilityLevel = "required"

	// DataDurabilityLevelPreferred means that data durability is enforced
	// only when healthy replicas are available
	DataDurabilityLevelPreferred DataDurabilityLevel = "preferred"
)

type DataSource 

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 

func (in *DataSource) DeepCopy() *DataSource

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

func (*DataSource) DeepCopyInto 

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

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

type Database 

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

	// Specification of the desired Database.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	Spec DatabaseSpec `json:"spec"`
	// Most recently observed status of the Database. 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 DatabaseStatus `json:"status,omitempty"`
}

Database is the Schema for the databases API

func (*Database) DeepCopy 

func (in *Database) DeepCopy() *Database

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

func (*Database) DeepCopyInto 

func (in *Database) DeepCopyInto(out *Database)

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

func (*Database) DeepCopyObject 

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

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

type DatabaseList 

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

DatabaseList contains a list of Database

func (*DatabaseList) DeepCopy 

func (in *DatabaseList) DeepCopy() *DatabaseList

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

func (*DatabaseList) DeepCopyInto 

func (in *DatabaseList) DeepCopyInto(out *DatabaseList)

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

func (*DatabaseList) DeepCopyObject 

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

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

type DatabaseReclaimPolicy 

type DatabaseReclaimPolicy string

DatabaseReclaimPolicy describes a policy for end-of-life maintenance of databases. +enum 

const (
	// DatabaseReclaimDelete means the database will be deleted from its PostgreSQL Cluster on release
	// from its claim.
	DatabaseReclaimDelete DatabaseReclaimPolicy = "delete"

	// DatabaseReclaimRetain means the database will be left in its current phase for manual
	// reclamation by the administrator. The default policy is Retain.
	DatabaseReclaimRetain DatabaseReclaimPolicy = "retain"
)

type DatabaseRoleRef 

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

DatabaseRoleRef is a reference an a role available inside PostgreSQL

func (*DatabaseRoleRef) DeepCopy 

func (in *DatabaseRoleRef) DeepCopy() *DatabaseRoleRef

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

func (*DatabaseRoleRef) DeepCopyInto 

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

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

type DatabaseSpec 

type DatabaseSpec struct {
	// The name of the PostgreSQL cluster hosting the database.
	ClusterRef corev1.LocalObjectReference `json:"cluster"`

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

	// The name of the database to create inside PostgreSQL. This setting cannot be changed.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="name is immutable"
	// +kubebuilder:validation:XValidation:rule="self != 'postgres'",message="the name postgres is reserved"
	// +kubebuilder:validation:XValidation:rule="self != 'template0'",message="the name template0 is reserved"
	// +kubebuilder:validation:XValidation:rule="self != 'template1'",message="the name template1 is reserved"
	Name string `json:"name"`

	// Maps to the `OWNER` parameter of `CREATE DATABASE`.
	// Maps to the `OWNER TO` command of `ALTER DATABASE`.
	// The role name of the user who owns the database inside PostgreSQL.
	Owner string `json:"owner"`

	// Maps to the `TEMPLATE` parameter of `CREATE DATABASE`. This setting
	// cannot be changed. The name of the template from which to create
	// this database.
	// +optional
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="template is immutable"
	Template string `json:"template,omitempty"`

	// Maps to the `ENCODING` parameter of `CREATE DATABASE`. This setting
	// cannot be changed. Character set encoding to use in the database.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="encoding is immutable"
	// +optional
	Encoding string `json:"encoding,omitempty"`

	// Maps to the `LOCALE` parameter of `CREATE DATABASE`. This setting
	// cannot be changed. Sets the default collation order and character
	// classification in the new database.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="locale is immutable"
	// +optional
	Locale string `json:"locale,omitempty"`

	// Maps to the `LOCALE_PROVIDER` parameter of `CREATE DATABASE`. This
	// setting cannot be changed. This option sets the locale provider for
	// databases created in the new cluster. Available from PostgreSQL 16.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="localeProvider is immutable"
	// +optional
	LocaleProvider string `json:"localeProvider,omitempty"`

	// Maps to the `LC_COLLATE` parameter of `CREATE DATABASE`. This
	// setting cannot be changed.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="localeCollate is immutable"
	// +optional
	LcCollate string `json:"localeCollate,omitempty"`

	// Maps to the `LC_CTYPE` parameter of `CREATE DATABASE`. This setting
	// cannot be changed.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="localeCType is immutable"
	// +optional
	LcCtype string `json:"localeCType,omitempty"`

	// Maps to the `ICU_LOCALE` parameter of `CREATE DATABASE`. This
	// setting cannot be changed. Specifies the ICU locale when the ICU
	// provider is used. This option requires `localeProvider` to be set to
	// `icu`. Available from PostgreSQL 15.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="icuLocale is immutable"
	// +optional
	IcuLocale string `json:"icuLocale,omitempty"`

	// Maps to the `ICU_RULES` parameter of `CREATE DATABASE`. This setting
	// cannot be changed. Specifies additional collation rules to customize
	// the behavior of the default collation. This option requires
	// `localeProvider` to be set to `icu`. Available from PostgreSQL 16.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="icuRules is immutable"
	// +optional
	IcuRules string `json:"icuRules,omitempty"`

	// Maps to the `BUILTIN_LOCALE` parameter of `CREATE DATABASE`. This
	// setting cannot be changed. Specifies the locale name when the
	// builtin provider is used. This option requires `localeProvider` to
	// be set to `builtin`. Available from PostgreSQL 17.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="builtinLocale is immutable"
	// +optional
	BuiltinLocale string `json:"builtinLocale,omitempty"`

	// Maps to the `COLLATION_VERSION` parameter of `CREATE DATABASE`. This
	// setting cannot be changed.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="collationVersion is immutable"
	// +optional
	CollationVersion string `json:"collationVersion,omitempty"`

	// Maps to the `IS_TEMPLATE` parameter of `CREATE DATABASE` and `ALTER
	// DATABASE`. If true, this database is considered a template and can
	// be cloned by any user with `CREATEDB` privileges.
	// +optional
	IsTemplate *bool `json:"isTemplate,omitempty"`

	// Maps to the `ALLOW_CONNECTIONS` parameter of `CREATE DATABASE` and
	// `ALTER DATABASE`. If false then no one can connect to this database.
	// +optional
	AllowConnections *bool `json:"allowConnections,omitempty"`

	// Maps to the `CONNECTION LIMIT` clause of `CREATE DATABASE` and
	// `ALTER DATABASE`. How many concurrent connections can be made to
	// this database. -1 (the default) means no limit.
	// +optional
	ConnectionLimit *int `json:"connectionLimit,omitempty"`

	// Maps to the `TABLESPACE` parameter of `CREATE DATABASE`.
	// Maps to the `SET TABLESPACE` command of `ALTER DATABASE`.
	// The name of the tablespace (in PostgreSQL) that will be associated
	// with the new database. This tablespace will be the default
	// tablespace used for objects created in this database.
	// +optional
	Tablespace string `json:"tablespace,omitempty"`

	// The policy for end-of-life maintenance of this database.
	// +kubebuilder:validation:Enum=delete;retain
	// +kubebuilder:default:=retain
	// +optional
	ReclaimPolicy DatabaseReclaimPolicy `json:"databaseReclaimPolicy,omitempty"`
}

DatabaseSpec is the specification of a Postgresql Database, built around the `CREATE DATABASE`, `ALTER DATABASE`, and `DROP DATABASE` SQL commands of PostgreSQL. +kubebuilder:validation:XValidation:rule="!has(self.builtinLocale) || self.localeProvider == 'builtin'",message="builtinLocale is only available when localeProvider is set to `builtin`" +kubebuilder:validation:XValidation:rule="!has(self.icuLocale) || self.localeProvider == 'icu'",message="icuLocale is only available when localeProvider is set to `icu`" +kubebuilder:validation:XValidation:rule="!has(self.icuRules) || self.localeProvider == 'icu'",message="icuRules is only available when localeProvider is set to `icu`"

func (*DatabaseSpec) DeepCopy 

func (in *DatabaseSpec) DeepCopy() *DatabaseSpec

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

func (*DatabaseSpec) DeepCopyInto 

func (in *DatabaseSpec) DeepCopyInto(out *DatabaseSpec)

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

type DatabaseStatus 

type DatabaseStatus struct {
	// A sequence number representing the latest
	// desired state that was synchronized
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// Applied is true if the database was reconciled correctly
	// +optional
	Applied *bool `json:"applied,omitempty"`

	// Message is the reconciliation output message
	// +optional
	Message string `json:"message,omitempty"`
}

DatabaseStatus defines the observed state of Database

func (*DatabaseStatus) DeepCopy 

func (in *DatabaseStatus) DeepCopy() *DatabaseStatus

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

func (*DatabaseStatus) DeepCopyInto 

func (in *DatabaseStatus) DeepCopyInto(out *DatabaseStatus)

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 EnsureOption 

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 

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

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

EphemeralVolumesSizeLimitConfiguration contains the configuration of the ephemeral storage

func (*EphemeralVolumesSizeLimitConfiguration) DeepCopy 

func (in *EphemeralVolumesSizeLimitConfiguration) DeepCopy() *EphemeralVolumesSizeLimitConfiguration

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

func (*EphemeralVolumesSizeLimitConfiguration) DeepCopyInto 

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

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

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

	// The configuration of the plugin that is taking care
	// of WAL archiving and backups for this external cluster
	PluginConfiguration *PluginConfiguration `json:"plugin,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.

type GoogleCredentials 

type GoogleCredentials = barmanApi.GoogleCredentials

GoogleCredentials is the type for the Google Cloud Storage credentials. This needs to be specified even if we run inside a GKE environment. +kubebuilder:object:generate:=false

type ImageCatalog 

type ImageCatalog struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata"`
	// Specification of the desired behavior of the ImageCatalog.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	Spec ImageCatalogSpec `json:"spec"`
}

ImageCatalog is the Schema for the imagecatalogs API

func (*ImageCatalog) DeepCopy 

func (in *ImageCatalog) DeepCopy() *ImageCatalog

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

func (*ImageCatalog) DeepCopyInto 

func (in *ImageCatalog) DeepCopyInto(out *ImageCatalog)

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

func (*ImageCatalog) DeepCopyObject 

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

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

type ImageCatalogList 

type ImageCatalogList 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"`
	// List of ImageCatalogs
	Items []ImageCatalog `json:"items"`
}

ImageCatalogList contains a list of ImageCatalog

func (*ImageCatalogList) DeepCopy 

func (in *ImageCatalogList) DeepCopy() *ImageCatalogList

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

func (*ImageCatalogList) DeepCopyInto 

func (in *ImageCatalogList) DeepCopyInto(out *ImageCatalogList)

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

func (*ImageCatalogList) DeepCopyObject 

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

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

type ImageCatalogRef 

type ImageCatalogRef struct {
	// +kubebuilder:validation:XValidation:rule="self.kind == 'ImageCatalog' || self.kind == 'ClusterImageCatalog'",message="Only image catalogs are supported"
	// +kubebuilder:validation:XValidation:rule="self.apiGroup == 'postgresql.cnpg.io'",message="Only image catalogs are supported"
	corev1.TypedLocalObjectReference `json:",inline"`
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="Major is immutable"
	// The major version of PostgreSQL we want to use from the ImageCatalog
	Major int `json:"major"`
}

ImageCatalogRef defines the reference to a major version in an ImageCatalog

func (*ImageCatalogRef) DeepCopy 

func (in *ImageCatalogRef) DeepCopy() *ImageCatalogRef

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

func (*ImageCatalogRef) DeepCopyInto 

func (in *ImageCatalogRef) DeepCopyInto(out *ImageCatalogRef)

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

type ImageCatalogSpec 

type ImageCatalogSpec struct {
	// List of CatalogImages available in the catalog
	// +kubebuilder:validation:MinItems=1
	// +kubebuilder:validation:MaxItems=8
	// +kubebuilder:validation:XValidation:rule="self.all(e, self.filter(f, f.major==e.major).size() == 1)",message=Images must have unique major versions
	Images []CatalogImage `json:"images"`
}

ImageCatalogSpec defines the desired ImageCatalog

func (*ImageCatalogSpec) DeepCopy 

func (in *ImageCatalogSpec) DeepCopy() *ImageCatalogSpec

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

func (*ImageCatalogSpec) DeepCopyInto 

func (in *ImageCatalogSpec) DeepCopyInto(out *ImageCatalogSpec)

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

type Import 

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

	// List of custom options to pass to the `pg_dump` command. IMPORTANT:
	// Use these options with caution and at your own risk, as the operator
	// does not validate their content. Be aware that certain options may
	// conflict with the operator's intended functionality or design.
	// +optional
	PgDumpExtraOptions []string `json:"pgDumpExtraOptions,omitempty"`

	// List of custom options to pass to the `pg_restore` command. IMPORTANT:
	// Use these options with caution and at your own risk, as the operator
	// does not validate their content. Be aware that certain options may
	// conflict with the operator's intended functionality or design.
	// +optional
	PgRestoreExtraOptions []string `json:"pgRestoreExtraOptions,omitempty"`
}

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

func (*Import) DeepCopy 

func (in *Import) DeepCopy() *Import

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

func (*Import) DeepCopyInto 

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 

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 

func (in *ImportSource) DeepCopy() *ImportSource

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

func (*ImportSource) DeepCopyInto 

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 

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 

func (in *InstanceReportedState) DeepCopy() *InstanceReportedState

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

func (*InstanceReportedState) DeepCopyInto 

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 = machineryapi.LocalObjectReference

LocalObjectReference contains enough information to let you locate a local object with a known type inside the same namespace +kubebuilder:object:generate:=false

type ManagedConfiguration 

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

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

func (*ManagedConfiguration) DeepCopy 

func (in *ManagedConfiguration) DeepCopy() *ManagedConfiguration

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

func (*ManagedConfiguration) DeepCopyInto 

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 

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 

func (in *ManagedRoles) DeepCopy() *ManagedRoles

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

func (*ManagedRoles) DeepCopyInto 

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

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

type ManagedService 

type ManagedService struct {
	// SelectorType specifies the type of selectors that the service will have.
	// Valid values are "rw", "r", and "ro", representing read-write, read, and read-only services.
	SelectorType ServiceSelectorType `json:"selectorType"`

	// UpdateStrategy describes how the service differences should be reconciled
	// +kubebuilder:default:="patch"
	// +optional
	UpdateStrategy ServiceUpdateStrategy `json:"updateStrategy,omitempty"`

	// ServiceTemplate is the template specification for the service.
	ServiceTemplate ServiceTemplateSpec `json:"serviceTemplate"`
}

ManagedService represents a specific service managed by the cluster. It includes the type of service and its associated template specification.

func (*ManagedService) DeepCopy 

func (in *ManagedService) DeepCopy() *ManagedService

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

func (*ManagedService) DeepCopyInto 

func (in *ManagedService) DeepCopyInto(out *ManagedService)

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

type ManagedServices 

type ManagedServices struct {
	// DisabledDefaultServices is a list of service types that are disabled by default.
	// Valid values are "r", and "ro", representing read, and read-only services.
	// +optional
	DisabledDefaultServices []ServiceSelectorType `json:"disabledDefaultServices,omitempty"`
	// Additional is a list of additional managed services specified by the user.
	// +optional
	Additional []ManagedService `json:"additional,omitempty"`
}

ManagedServices represents the services managed by the cluster.

func (*ManagedServices) DeepCopy 

func (in *ManagedServices) DeepCopy() *ManagedServices

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

func (*ManagedServices) DeepCopyInto 

func (in *ManagedServices) DeepCopyInto(out *ManagedServices)

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

type Metadata 

type Metadata struct {
	// The name of the resource. Only supported for certain types
	// +optional
	Name string `json:"name,omitempty"`

	// 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 

func (in *Metadata) DeepCopy() *Metadata

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

func (*Metadata) DeepCopyInto 

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

	// Configure TLS communication for the metrics endpoint.
	// Changing tls.enabled option will force a rollout of all instances.
	// +optional
	TLSConfig *ClusterMonitoringTLSConfiguration `json:"tls,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) 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 

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 

func (in *OnlineConfiguration) DeepCopy() *OnlineConfiguration

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

func (*OnlineConfiguration) DeepCopyInto 

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

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

type PasswordState 

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 

func (in *PasswordState) DeepCopy() *PasswordState

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

func (*PasswordState) DeepCopyInto 

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.

type PluginConfiguration 

type PluginConfiguration struct {
	// Name is the plugin name
	Name string `json:"name"`

	// Enabled is true if this plugin will be used
	// +kubebuilder:default:=true
	// +optional
	Enabled *bool `json:"enabled,omitempty"`

	// Parameters is the configuration of the plugin
	// +optional
	Parameters map[string]string `json:"parameters,omitempty"`
}

PluginConfiguration specifies a plugin that need to be loaded for this cluster to be reconciled

func (*PluginConfiguration) DeepCopy 

func (in *PluginConfiguration) DeepCopy() *PluginConfiguration

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

func (*PluginConfiguration) DeepCopyInto 

func (in *PluginConfiguration) DeepCopyInto(out *PluginConfiguration)

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

type PluginStatus 

type PluginStatus struct {
	// Name is the name of the plugin
	Name string `json:"name"`

	// Version is the version of the plugin loaded by the
	// latest reconciliation loop
	Version string `json:"version"`

	// Capabilities are the list of capabilities of the
	// plugin
	// +optional
	Capabilities []string `json:"capabilities,omitempty"`

	// OperatorCapabilities are the list of capabilities of the
	// plugin regarding the reconciler
	// +optional
	OperatorCapabilities []string `json:"operatorCapabilities,omitempty"`

	// WALCapabilities are the list of capabilities of the
	// plugin regarding the WAL management
	// +optional
	WALCapabilities []string `json:"walCapabilities,omitempty"`

	// BackupCapabilities are the list of capabilities of the
	// plugin regarding the Backup management
	// +optional
	BackupCapabilities []string `json:"backupCapabilities,omitempty"`

	// RestoreJobHookCapabilities are the list of capabilities of the
	// plugin regarding the RestoreJobHook management
	// +optional
	RestoreJobHookCapabilities []string `json:"restoreJobHookCapabilities,omitempty"`

	// Status contain the status reported by the plugin through the SetStatusInCluster interface
	// +optional
	Status string `json:"status,omitempty"`
}

PluginStatus is the status of a loaded plugin

func (*PluginStatus) DeepCopy 

func (in *PluginStatus) DeepCopy() *PluginStatus

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

func (*PluginStatus) DeepCopyInto 

func (in *PluginStatus) DeepCopyInto(out *PluginStatus)

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

type PodName 

type PodName string

PodName is the name of a Pod

type PodStatus 

type PodStatus string

PodStatus represent the possible status of pods

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 

type PodTopologyLabels map[string]string

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

func (PodTopologyLabels) DeepCopy 

func (in PodTopologyLabels) DeepCopy() PodTopologyLabels

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

func (PodTopologyLabels) DeepCopyInto 

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.

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"`
	// +optional
	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 

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 

func (in *PoolerMonitoringConfiguration) DeepCopy() *PoolerMonitoringConfiguration

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

func (*PoolerMonitoringConfiguration) DeepCopyInto 

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

	// Template for the Service to be created
	// +optional
	ServiceTemplate *ServiceTemplateSpec `json:"serviceTemplate,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 PostgresConfiguration 

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

	// Configuration of the PostgreSQL synchronous replication feature
	// +optional
	Synchronous *SynchronousReplicaConfiguration `json:"synchronous,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 Probe 

type Probe struct {
	// Number of seconds after the container has started before liveness probes are initiated.
	// More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
	// +optional
	InitialDelaySeconds int32 `json:"initialDelaySeconds,omitempty"`
	// Number of seconds after which the probe times out.
	// Defaults to 1 second. Minimum value is 1.
	// More info: https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
	// +optional
	TimeoutSeconds int32 `json:"timeoutSeconds,omitempty"`
	// How often (in seconds) to perform the probe.
	// Default to 10 seconds. Minimum value is 1.
	// +optional
	PeriodSeconds int32 `json:"periodSeconds,omitempty"`
	// Minimum consecutive successes for the probe to be considered successful after having failed.
	// Defaults to 1. Must be 1 for liveness and startup. Minimum value is 1.
	// +optional
	SuccessThreshold int32 `json:"successThreshold,omitempty"`
	// Minimum consecutive failures for the probe to be considered failed after having succeeded.
	// Defaults to 3. Minimum value is 1.
	// +optional
	FailureThreshold int32 `json:"failureThreshold,omitempty"`
	// Optional duration in seconds the pod needs to terminate gracefully upon probe failure.
	// The grace period is the duration in seconds after the processes running in the pod are sent
	// a termination signal and the time when the processes are forcibly halted with a kill signal.
	// Set this value longer than the expected cleanup time for your process.
	// If this value is nil, the pod's terminationGracePeriodSeconds will be used. Otherwise, this
	// value overrides the value provided by the pod spec.
	// Value must be non-negative integer. The value zero indicates stop immediately via
	// the kill signal (no opportunity to shut down).
	// This is a beta field and requires enabling ProbeTerminationGracePeriod feature gate.
	// Minimum value is 1. spec.terminationGracePeriodSeconds is used if unset.
	// +optional
	TerminationGracePeriodSeconds *int64 `json:"terminationGracePeriodSeconds,omitempty"`
}

Probe describes a health check to be performed against a container to determine whether it is alive or ready to receive traffic.

func (*Probe) DeepCopy 

func (in *Probe) DeepCopy() *Probe

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

func (*Probe) DeepCopyInto 

func (in *Probe) DeepCopyInto(out *Probe)

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

type ProbesConfiguration 

type ProbesConfiguration struct {
	// The startup probe configuration
	Startup *Probe `json:"startup,omitempty"`

	// The liveness probe configuration
	Liveness *Probe `json:"liveness,omitempty"`

	// The readiness probe configuration
	Readiness *Probe `json:"readiness,omitempty"`
}

ProbesConfiguration represent the configuration for the probes to be injected in the PostgreSQL Pods

func (*ProbesConfiguration) DeepCopy 

func (in *ProbesConfiguration) DeepCopy() *ProbesConfiguration

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

func (*ProbesConfiguration) DeepCopyInto 

func (in *ProbesConfiguration) DeepCopyInto(out *ProbesConfiguration)

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

type Publication 

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

	Spec   PublicationSpec   `json:"spec"`
	Status PublicationStatus `json:"status,omitempty"`
}

Publication is the Schema for the publications API

func (*Publication) DeepCopy 

func (in *Publication) DeepCopy() *Publication

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

func (*Publication) DeepCopyInto 

func (in *Publication) DeepCopyInto(out *Publication)

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

func (*Publication) DeepCopyObject 

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

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

type PublicationList 

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

PublicationList contains a list of Publication

func (*PublicationList) DeepCopy 

func (in *PublicationList) DeepCopy() *PublicationList

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

func (*PublicationList) DeepCopyInto 

func (in *PublicationList) DeepCopyInto(out *PublicationList)

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

func (*PublicationList) DeepCopyObject 

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

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

type PublicationReclaimPolicy 

type PublicationReclaimPolicy string

PublicationReclaimPolicy defines a policy for end-of-life maintenance of Publications. +enum 

const (
	// PublicationReclaimDelete means the publication will be deleted from Kubernetes on release
	// from its claim.
	PublicationReclaimDelete PublicationReclaimPolicy = "delete"

	// PublicationReclaimRetain means the publication will be left in its current phase for manual
	// reclamation by the administrator. The default policy is Retain.
	PublicationReclaimRetain PublicationReclaimPolicy = "retain"
)

type PublicationSpec 

type PublicationSpec struct {
	// The name of the PostgreSQL cluster that identifies the "publisher"
	ClusterRef corev1.LocalObjectReference `json:"cluster"`

	// The name of the publication inside PostgreSQL
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="name is immutable"
	Name string `json:"name"`

	// The name of the database where the publication will be installed in
	// the "publisher" cluster
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="dbname is immutable"
	DBName string `json:"dbname"`

	// Publication parameters part of the `WITH` clause as expected by
	// PostgreSQL `CREATE PUBLICATION` command
	// +optional
	Parameters map[string]string `json:"parameters,omitempty"`

	// Target of the publication as expected by PostgreSQL `CREATE PUBLICATION` command
	Target PublicationTarget `json:"target"`

	// The policy for end-of-life maintenance of this publication
	// +kubebuilder:validation:Enum=delete;retain
	// +kubebuilder:default:=retain
	// +optional
	ReclaimPolicy PublicationReclaimPolicy `json:"publicationReclaimPolicy,omitempty"`
}

PublicationSpec defines the desired state of Publication

func (*PublicationSpec) DeepCopy 

func (in *PublicationSpec) DeepCopy() *PublicationSpec

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

func (*PublicationSpec) DeepCopyInto 

func (in *PublicationSpec) DeepCopyInto(out *PublicationSpec)

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

type PublicationStatus 

type PublicationStatus struct {
	// A sequence number representing the latest
	// desired state that was synchronized
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// Applied is true if the publication was reconciled correctly
	// +optional
	Applied *bool `json:"applied,omitempty"`

	// Message is the reconciliation output message
	// +optional
	Message string `json:"message,omitempty"`
}

PublicationStatus defines the observed state of Publication

func (*PublicationStatus) DeepCopy 

func (in *PublicationStatus) DeepCopy() *PublicationStatus

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

func (*PublicationStatus) DeepCopyInto 

func (in *PublicationStatus) DeepCopyInto(out *PublicationStatus)

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

type PublicationTarget 

type PublicationTarget struct {
	// Marks the publication as one that replicates changes for all tables
	// in the database, including tables created in the future.
	// Corresponding to `FOR ALL TABLES` in PostgreSQL.
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="allTables is immutable"
	// +optional
	AllTables bool `json:"allTables,omitempty"`

	// Just the following schema objects
	// +kubebuilder:validation:XValidation:rule="!(self.exists(o, has(o.table) && has(o.table.columns)) && self.exists(o, has(o.tablesInSchema)))",message="specifying a column list when the publication also publishes tablesInSchema is not supported"
	// +kubebuilder:validation:MaxItems=100000
	// +optional
	Objects []PublicationTargetObject `json:"objects,omitempty"`
}

PublicationTarget is what this publication should publish +kubebuilder:validation:XValidation:rule="(has(self.allTables) && !has(self.objects)) || (!has(self.allTables) && has(self.objects))",message="allTables and objects are mutually exclusive"

func (*PublicationTarget) DeepCopy 

func (in *PublicationTarget) DeepCopy() *PublicationTarget

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

func (*PublicationTarget) DeepCopyInto 

func (in *PublicationTarget) DeepCopyInto(out *PublicationTarget)

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

type PublicationTargetObject 

type PublicationTargetObject struct {
	// Marks the publication as one that replicates changes for all tables
	// in the specified list of schemas, including tables created in the
	// future. Corresponding to `FOR TABLES IN SCHEMA` in PostgreSQL.
	// +optional
	TablesInSchema string `json:"tablesInSchema,omitempty"`

	// Specifies a list of tables to add to the publication. Corresponding
	// to `FOR TABLE` in PostgreSQL.
	// +optional
	Table *PublicationTargetTable `json:"table,omitempty"`
}

PublicationTargetObject is an object to publish +kubebuilder:validation:XValidation:rule="(has(self.tablesInSchema) && !has(self.table)) || (!has(self.tablesInSchema) && has(self.table))",message="tablesInSchema and table are mutually exclusive"

func (*PublicationTargetObject) DeepCopy 

func (in *PublicationTargetObject) DeepCopy() *PublicationTargetObject

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

func (*PublicationTargetObject) DeepCopyInto 

func (in *PublicationTargetObject) DeepCopyInto(out *PublicationTargetObject)

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

type PublicationTargetTable 

type PublicationTargetTable struct {
	// Whether to limit to the table only or include all its descendants
	// +optional
	Only bool `json:"only,omitempty"`

	// The table name
	Name string `json:"name"`

	// The schema name
	// +optional
	Schema string `json:"schema,omitempty"`

	// The columns to publish
	// +optional
	Columns []string `json:"columns,omitempty"`
}

PublicationTargetTable is a table to publish

func (*PublicationTargetTable) DeepCopy 

func (in *PublicationTargetTable) DeepCopy() *PublicationTargetTable

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

func (*PublicationTargetTable) DeepCopyInto 

func (in *PublicationTargetTable) DeepCopyInto(out *PublicationTargetTable)

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

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) 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 {
	// Self defines the name of this cluster. It is used to determine if this is a primary
	// or a replica cluster, comparing it with `primary`
	// +optional
	Self string `json:"self,omitempty"`

	// Primary defines which Cluster is defined to be the primary in the distributed PostgreSQL cluster, based on the
	// topology specified in externalClusters
	// +optional
	Primary string `json:"primary,omitempty"`

	// 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.
	// +optional
	Enabled *bool `json:"enabled,omitempty"`

	// A demotion token generated by an external cluster used to
	// check if the promotion requirements are met.
	// +optional
	PromotionToken string `json:"promotionToken,omitempty"`

	// When replica mode is enabled, this parameter allows you to replay
	// transactions only when the system time is at least the configured
	// time past the commit time. This provides an opportunity to correct
	// data loss errors. Note that when this parameter is set, a promotion
	// token cannot be used.
	// +optional
	MinApplyDelay *metav1.Duration `json:"minApplyDelay,omitempty"`
}

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 

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

	// Configures the synchronization of the user defined physical replication slots
	// +optional
	SynchronizeReplicas *SynchronizeReplicasConfiguration `json:"synchronizeReplicas,omitempty"`
}

ReplicationSlotsConfiguration encapsulates the configuration of replication slots

func (*ReplicationSlotsConfiguration) DeepCopy 

func (in *ReplicationSlotsConfiguration) DeepCopy() *ReplicationSlotsConfiguration

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

func (*ReplicationSlotsConfiguration) DeepCopyInto 

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

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

type ReplicationSlotsHAConfiguration 

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 

func (in *ReplicationSlotsHAConfiguration) DeepCopy() *ReplicationSlotsHAConfiguration

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

func (*ReplicationSlotsHAConfiguration) DeepCopyInto 

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

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

type RoleConfiguration 

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 

func (in *RoleConfiguration) DeepCopy() *RoleConfiguration

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

func (*RoleConfiguration) DeepCopyInto 

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

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

type RoleStatus 

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 = barmanApi.S3Credentials

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 +kubebuilder:object:generate:=false

type SQLRefs 

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

SQLRefs holds references to ConfigMaps or Secrets containing SQL files. The references are processed in a specific order: first, all Secrets are processed, followed by all ConfigMaps. Within each group, the processing order follows the sequence specified in their respective arrays.

func (*SQLRefs) DeepCopy 

func (in *SQLRefs) DeepCopy() *SQLRefs

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

func (*SQLRefs) DeepCopyInto 

func (in *SQLRefs) DeepCopyInto(out *SQLRefs)

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) 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.

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
	// +optional
	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`,
	// `volumeSnapshot` or `plugin`. Defaults to: `barmanObjectStore`.
	// +optional
	// +kubebuilder:validation:Enum=barmanObjectStore;volumeSnapshot;plugin
	// +kubebuilder:default:=barmanObjectStore
	Method BackupMethod `json:"method,omitempty"`

	// Configuration parameters passed to the plugin managing this backup
	// +optional
	PluginConfiguration *BackupPluginConfiguration `json:"pluginConfiguration,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 = machineryapi.SecretKeySelector

SecretKeySelector contains enough information to let you locate the key of a Secret +kubebuilder:object:generate:=false

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.

type ServiceAccountTemplate 

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 

func (in *ServiceAccountTemplate) DeepCopy() *ServiceAccountTemplate

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

func (*ServiceAccountTemplate) DeepCopyInto 

func (in *ServiceAccountTemplate) DeepCopyInto(out *ServiceAccountTemplate)

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

type ServiceSelectorType 

type ServiceSelectorType string

ServiceSelectorType describes a valid value for generating the service selectors. It indicates which type of service the selector applies to, such as read-write, read, or read-only +kubebuilder:validation:Enum=rw;r;ro 

const (
	// ServiceSelectorTypeRW selects the read-write service.
	ServiceSelectorTypeRW ServiceSelectorType = "rw"
	// ServiceSelectorTypeR selects the read service.
	ServiceSelectorTypeR ServiceSelectorType = "r"
	// ServiceSelectorTypeRO selects the read-only service.
	ServiceSelectorTypeRO ServiceSelectorType = "ro"
)

Constants representing the valid values for ServiceSelectorType.

type ServiceTemplateSpec 

type ServiceTemplateSpec 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 service.
	// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
	// +optional
	Spec corev1.ServiceSpec `json:"spec,omitempty"`
}

ServiceTemplateSpec is a structure allowing the user to set a template for Service generation.

func (*ServiceTemplateSpec) DeepCopy 

func (in *ServiceTemplateSpec) DeepCopy() *ServiceTemplateSpec

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

func (*ServiceTemplateSpec) DeepCopyInto 

func (in *ServiceTemplateSpec) DeepCopyInto(out *ServiceTemplateSpec)

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

type ServiceUpdateStrategy 

type ServiceUpdateStrategy string

ServiceUpdateStrategy describes how the changes to the managed service should be handled +kubebuilder:validation:Enum=patch;replace

type SnapshotOwnerReference 

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 

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.

type Subscription 

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

	Spec   SubscriptionSpec   `json:"spec"`
	Status SubscriptionStatus `json:"status,omitempty"`
}

Subscription is the Schema for the subscriptions API

func (*Subscription) DeepCopy 

func (in *Subscription) DeepCopy() *Subscription

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

func (*Subscription) DeepCopyInto 

func (in *Subscription) DeepCopyInto(out *Subscription)

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

func (*Subscription) DeepCopyObject 

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

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

type SubscriptionList 

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

SubscriptionList contains a list of Subscription

func (*SubscriptionList) DeepCopy 

func (in *SubscriptionList) DeepCopy() *SubscriptionList

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

func (*SubscriptionList) DeepCopyInto 

func (in *SubscriptionList) DeepCopyInto(out *SubscriptionList)

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

func (*SubscriptionList) DeepCopyObject 

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

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

type SubscriptionReclaimPolicy 

type SubscriptionReclaimPolicy string

SubscriptionReclaimPolicy describes a policy for end-of-life maintenance of Subscriptions. +enum 

const (
	// SubscriptionReclaimDelete means the subscription will be deleted from Kubernetes on release
	// from its claim.
	SubscriptionReclaimDelete SubscriptionReclaimPolicy = "delete"

	// SubscriptionReclaimRetain means the subscription will be left in its current phase for manual
	// reclamation by the administrator. The default policy is Retain.
	SubscriptionReclaimRetain SubscriptionReclaimPolicy = "retain"
)

type SubscriptionSpec 

type SubscriptionSpec struct {
	// The name of the PostgreSQL cluster that identifies the "subscriber"
	ClusterRef corev1.LocalObjectReference `json:"cluster"`

	// The name of the subscription inside PostgreSQL
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="name is immutable"
	Name string `json:"name"`

	// The name of the database where the publication will be installed in
	// the "subscriber" cluster
	// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="dbname is immutable"
	DBName string `json:"dbname"`

	// Subscription parameters part of the `WITH` clause as expected by
	// PostgreSQL `CREATE SUBSCRIPTION` command
	// +optional
	Parameters map[string]string `json:"parameters,omitempty"`

	// The name of the publication inside the PostgreSQL database in the
	// "publisher"
	PublicationName string `json:"publicationName"`

	// The name of the database containing the publication on the external
	// cluster. Defaults to the one in the external cluster definition.
	// +optional
	PublicationDBName string `json:"publicationDBName,omitempty"`

	// The name of the external cluster with the publication ("publisher")
	ExternalClusterName string `json:"externalClusterName"`

	// The policy for end-of-life maintenance of this subscription
	// +kubebuilder:validation:Enum=delete;retain
	// +kubebuilder:default:=retain
	// +optional
	ReclaimPolicy SubscriptionReclaimPolicy `json:"subscriptionReclaimPolicy,omitempty"`
}

SubscriptionSpec defines the desired state of Subscription

func (*SubscriptionSpec) DeepCopy 

func (in *SubscriptionSpec) DeepCopy() *SubscriptionSpec

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

func (*SubscriptionSpec) DeepCopyInto 

func (in *SubscriptionSpec) DeepCopyInto(out *SubscriptionSpec)

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

type SubscriptionStatus 

type SubscriptionStatus struct {
	// A sequence number representing the latest
	// desired state that was synchronized
	// +optional
	ObservedGeneration int64 `json:"observedGeneration,omitempty"`

	// Applied is true if the subscription was reconciled correctly
	// +optional
	Applied *bool `json:"applied,omitempty"`

	// Message is the reconciliation output message
	// +optional
	Message string `json:"message,omitempty"`
}

SubscriptionStatus defines the observed state of Subscription

func (*SubscriptionStatus) DeepCopy 

func (in *SubscriptionStatus) DeepCopy() *SubscriptionStatus

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

func (*SubscriptionStatus) DeepCopyInto 

func (in *SubscriptionStatus) DeepCopyInto(out *SubscriptionStatus)

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

type SwitchReplicaClusterStatus 

type SwitchReplicaClusterStatus struct {
	// InProgress indicates if there is an ongoing procedure of switching a cluster to a replica cluster.
	// +optional
	InProgress bool `json:"inProgress,omitempty"`
}

SwitchReplicaClusterStatus contains all the statuses regarding the switch of a cluster to a replica cluster

func (*SwitchReplicaClusterStatus) DeepCopy 

func (in *SwitchReplicaClusterStatus) DeepCopy() *SwitchReplicaClusterStatus

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

func (*SwitchReplicaClusterStatus) DeepCopyInto 

func (in *SwitchReplicaClusterStatus) DeepCopyInto(out *SwitchReplicaClusterStatus)

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

type SyncReplicaElectionConstraints 

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 

func (in *SyncReplicaElectionConstraints) DeepCopy() *SyncReplicaElectionConstraints

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

func (*SyncReplicaElectionConstraints) DeepCopyInto 

func (in *SyncReplicaElectionConstraints) DeepCopyInto(out *SyncReplicaElectionConstraints)

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

type SynchronizeReplicasConfiguration 

type SynchronizeReplicasConfiguration struct {
	// When set to true, every replication slot that is on the primary is synchronized on each standby
	// +kubebuilder:default:=true
	Enabled *bool `json:"enabled"`

	// List of regular expression patterns to match the names of replication slots to be excluded (by default empty)
	// +optional
	ExcludePatterns []string `json:"excludePatterns,omitempty"`
	// contains filtered or unexported fields
}

SynchronizeReplicasConfiguration contains the configuration for the synchronization of user defined physical replication slots

func (*SynchronizeReplicasConfiguration) DeepCopy 

func (in *SynchronizeReplicasConfiguration) DeepCopy() *SynchronizeReplicasConfiguration

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

func (*SynchronizeReplicasConfiguration) DeepCopyInto 

func (in *SynchronizeReplicasConfiguration) DeepCopyInto(out *SynchronizeReplicasConfiguration)

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

type SynchronousReplicaConfiguration 

type SynchronousReplicaConfiguration struct {
	// Method to select synchronous replication standbys from the listed
	// servers, accepting 'any' (quorum-based synchronous replication) or
	// 'first' (priority-based synchronous replication) as values.
	// +kubebuilder:validation:Enum=any;first
	Method SynchronousReplicaConfigurationMethod `json:"method"`

	// Specifies the number of synchronous standby servers that
	// transactions must wait for responses from.
	// +kubebuilder:validation:XValidation:rule="self > 0",message="The number of synchronous replicas should be greater than zero"
	Number int `json:"number"`

	// Specifies the maximum number of local cluster pods that can be
	// automatically included in the `synchronous_standby_names` option in
	// PostgreSQL.
	// +optional
	MaxStandbyNamesFromCluster *int `json:"maxStandbyNamesFromCluster,omitempty"`

	// A user-defined list of application names to be added to
	// `synchronous_standby_names` before local cluster pods (the order is
	// only useful for priority-based synchronous replication).
	// +optional
	StandbyNamesPre []string `json:"standbyNamesPre,omitempty"`

	// A user-defined list of application names to be added to
	// `synchronous_standby_names` after local cluster pods (the order is
	// only useful for priority-based synchronous replication).
	// +optional
	StandbyNamesPost []string `json:"standbyNamesPost,omitempty"`

	// If set to "required", data durability is strictly enforced. Write operations
	// with synchronous commit settings (`on`, `remote_write`, or `remote_apply`) will
	// block if there are insufficient healthy replicas, ensuring data persistence.
	// If set to "preferred", data durability is maintained when healthy replicas
	// are available, but the required number of instances will adjust dynamically
	// if replicas become unavailable. This setting relaxes strict durability enforcement
	// to allow for operational continuity. This setting is only applicable if both
	// `standbyNamesPre` and `standbyNamesPost` are unset (empty).
	// +kubebuilder:validation:Enum=required;preferred
	// +kubebuilder:default:=required
	// +optional
	DataDurability DataDurabilityLevel `json:"dataDurability,omitempty"`
}

SynchronousReplicaConfiguration contains the configuration of the PostgreSQL synchronous replication feature. Important: at this moment, also `.spec.minSyncReplicas` and `.spec.maxSyncReplicas` need to be considered. +kubebuilder:validation:XValidation:rule="self.dataDurability!='preferred' || ((!has(self.standbyNamesPre) || self.standbyNamesPre.size()==0) && (!has(self.standbyNamesPost) || self.standbyNamesPost.size()==0))",message="dataDurability set to 'preferred' requires empty 'standbyNamesPre' and empty 'standbyNamesPost'"

func (*SynchronousReplicaConfiguration) DeepCopy 

func (in *SynchronousReplicaConfiguration) DeepCopy() *SynchronousReplicaConfiguration

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

func (*SynchronousReplicaConfiguration) DeepCopyInto 

func (in *SynchronousReplicaConfiguration) DeepCopyInto(out *SynchronousReplicaConfiguration)

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

type SynchronousReplicaConfigurationMethod 

type SynchronousReplicaConfigurationMethod string

SynchronousReplicaConfigurationMethod configures whether to use quorum based replication or a priority list

type TablespaceConfiguration 

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 

func (in *TablespaceConfiguration) DeepCopy() *TablespaceConfiguration

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

func (*TablespaceConfiguration) DeepCopyInto 

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 

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 

func (in *TablespaceState) DeepCopy() *TablespaceState

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

func (*TablespaceState) DeepCopyInto 

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 

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 

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 

func (in *Topology) DeepCopy() *Topology

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

func (*Topology) DeepCopyInto 

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 

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 

func (in *VolumeSnapshotConfiguration) DeepCopy() *VolumeSnapshotConfiguration

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

func (*VolumeSnapshotConfiguration) DeepCopyInto 

func (in *VolumeSnapshotConfiguration) DeepCopyInto(out *VolumeSnapshotConfiguration)

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

type WalBackupConfiguration 

type WalBackupConfiguration = barmanApi.WalBackupConfiguration

WalBackupConfiguration is the configuration of the backup of the WAL stream +kubebuilder:object:generate:=false

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.