/*

Copyright © contributors to CloudNativePG, established as

CloudNativePG a Series of LF Projects, LLC.

Licensed under the Apache License, Version 2.0 (the "License");

you may not use this file except in compliance with the License.

You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software

distributed under the License is distributed on an "AS IS" BASIS,

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

See the License for the specific language governing permissions and

limitations under the License.

SPDX-License-Identifier: Apache-2.0

*/

package v1

import (

machineryapi "github.com/cloudnative-pg/machinery/pkg/api"

monitoringv1 "github.com/prometheus-operator/prometheus-operator/pkg/apis/monitoring/v1"

corev1 "k8s.io/api/core/v1"

"k8s.io/apimachinery/pkg/api/resource"

metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

)

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"

// DefaultPostgresUID is the default UID which is used by PostgreSQL

DefaultPostgresUID = 26

// DefaultPostgresGID is the default GID which is used by PostgreSQL

DefaultPostgresGID = 26

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

// MetricsExporterUserName is the name of the dedicated role used by the

// metrics exporter to connect to PostgreSQL. This role has pg_monitor

// granted and is never a superuser, so session_user never escalates via

// RESET ROLE.

MetricsExporterUserName = "cnpg_metrics_exporter"

// MissingWALDiskSpaceExitCode is the exit code the instance manager

// will use to signal that there's no more WAL disk space

MissingWALDiskSpaceExitCode = 4

// MissingWALArchivePlugin is the exit code used by the instance manager

// to indicate that it started successfully, but the configured WAL

// archiving plugin is not available.

MissingWALArchivePlugin = 5

)

// SnapshotOwnerReference defines the reference type for the owner of the snapshot.

// This specifies which owner the processed resources should relate to.

type SnapshotOwnerReference string

// Constants to represent the allowed types for SnapshotOwnerReference.

const (

// SnapshotOwnerReferenceNone indicates that the snapshot does not have any owner reference.

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

)

// VolumeSnapshotConfiguration represents the configuration for the execution of snapshot backups.

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

}

// OnlineConfiguration contains the configuration parameters for the online volume snapshot

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

}

// ImageCatalogRef defines the reference to a major version in an ImageCatalog

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

// The major version of PostgreSQL we want to use from the ImageCatalog

Major int `json:"major"`

}

// +kubebuilder:validation:XValidation:rule="!(has(self.imageCatalogRef) && has(self.imageName))",message="imageName and imageCatalogRef are mutually exclusive"

// ClusterSpec defines the desired state of a PostgreSQL cluster managed by

// CloudNativePG.

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

// PodSelectorRefs defines named pod label selectors that can be referenced

// in pg_hba rules using the ${podselector:NAME} syntax in the address field.

// The operator resolves matching pod IPs and the instance manager expands

// pg_hba lines accordingly. Only pods in the Cluster's own namespace are considered.

// +optional

// +listType=map

// +listMapKey=name

PodSelectorRefs []PodSelectorRef `json:"podSelectorRefs,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"`

// Name of an existing ServiceAccount in the same namespace to use for the cluster.

// When specified, the operator will not create a new ServiceAccount

// but will use the provided one. This is useful for sharing a single

// ServiceAccount across multiple clusters (e.g., for cloud IAM configurations).

// If not specified, a ServiceAccount will be created with the cluster name.

// Mutually exclusive with ServiceAccountTemplate.

// +optional

// +kubebuilder:validation:XValidation:rule="self == oldSelf",message="serviceAccountName is immutable"

// +kubebuilder:validation:Pattern=`^[a-z0-9]([-a-z0-9]*[a-z0-9])?$`

// +kubebuilder:validation:MaxLength=253

ServiceAccountName string `json:"serviceAccountName,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`). Default is 180 seconds.

// +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 time in seconds that is allowed for a PostgreSQL instance to stop

// after an immediate shutdown request (used, for example, when a primary

// must step down and cannot wait for a graceful shutdown). Once this time

// has passed with PostgreSQL still running, the instance is considered

// unresponsive. Default value is 30 seconds.

// +kubebuilder:default:=30

// +optional

ImmediateShutdownTimeout int32 `json:"immediateShutdownTimeout,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).

// Note: when using `switchover`, the operator will reject updates that change both

// the image name and PostgreSQL configuration parameters simultaneously to avoid

// configuration mismatches during the switchover process.

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

// Override the PodSecurityContext applied to every Pod of the cluster.

// When set, this overrides the operator's default PodSecurityContext for the cluster.

// If omitted, the operator defaults are used.

// This field doesn't have any effect if SecurityContextConstraints are present.

// +optional

PodSecurityContext *corev1.PodSecurityContext `json:"podSecurityContext,omitempty"`

// Override the SecurityContext applied to every Container in the Pod of the cluster.

// When set, this overrides the operator's default Container SecurityContext.

// If omitted, the operator defaults are used.

// +optional

SecurityContext *corev1.SecurityContext `json:"securityContext,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"`

// Configuration of the Kubernetes `Lease` used to coordinate safe primary

// election within the cluster. When omitted, the operator applies built-in

// defaults; tune these values only if you understand the consequences for

// failover timing.

// +optional

PrimaryLease *PrimaryLeaseConfiguration `json:"primaryLease,omitempty"`

}

// PrimaryLeaseConfiguration configures the timings of the Kubernetes `Lease`

// that the primary instance holds and renews to coordinate a safe primary

// election. These values map directly onto the underlying Kubernetes

// leader-election parameters.

type PrimaryLeaseConfiguration struct {

// How long, in seconds, the primary lease is considered valid before it

// expires and another instance may acquire it. It must be greater than

// `renewDeadlineSeconds`.

// Defaults to 15.

// +kubebuilder:default:=15

// +kubebuilder:validation:Minimum=1

// +optional

LeaseDurationSeconds *int32 `json:"leaseDurationSeconds,omitempty"`

// How long, in seconds, the current primary keeps retrying to renew the

// lease before giving up and stopping. It must be smaller than

// `leaseDurationSeconds`.

// Defaults to 10.

// +kubebuilder:default:=10

// +kubebuilder:validation:Minimum=1

// +optional

RenewDeadlineSeconds *int32 `json:"renewDeadlineSeconds,omitempty"`

// How frequently, in seconds, a non-holder instance retries acquiring or

// renewing the lease.

// Defaults to 2.

// +kubebuilder:default:=2

// +kubebuilder:validation:Minimum=1

// +optional

RetryPeriodSeconds *int32 `json:"retryPeriodSeconds,omitempty"`

// The TTL, in seconds, written when the primary explicitly releases the

// lease on a clean shutdown, allowing a replica to promote without waiting

// for the full lease duration to expire.

// Defaults to 1.

// +kubebuilder:default:=1

// +kubebuilder:validation:Minimum=1

// +optional

ReleasedLeaseDurationSeconds *int32 `json:"releasedLeaseDurationSeconds,omitempty"`

}

// ProbesConfiguration represent the configuration for the probes

// to be injected in the PostgreSQL Pods

type ProbesConfiguration struct {

// The startup probe configuration

Startup *ProbeWithStrategy `json:"startup,omitempty"`

// The liveness probe configuration

Liveness *LivenessProbe `json:"liveness,omitempty"`

// The readiness probe configuration

Readiness *ProbeWithStrategy `json:"readiness,omitempty"`

}

// ProbeWithStrategy is the configuration of the startup probe

type ProbeWithStrategy struct {

// Probe is the standard probe configuration

Probe `json:",inline"`

// The probe strategy

// +kubebuilder:validation:Enum=pg_isready;streaming;query

// +optional

Type ProbeStrategyType `json:"type,omitempty"`

// Lag limit. Used only for `streaming` strategy

// +optional

MaximumLag *resource.Quantity `json:"maximumLag,omitempty"`

}

// ProbeStrategyType is the type of the strategy used to declare a PostgreSQL instance

// ready

type ProbeStrategyType string

const (

// ProbeStrategyPgIsReady means that the pg_isready tool is used to determine

// whether PostgreSQL is started up

ProbeStrategyPgIsReady ProbeStrategyType = "pg_isready"

// ProbeStrategyStreaming means that pg_isready is positive and the replica is

// connected via streaming replication to the current primary and the lag is, if specified,

// within the limit.

ProbeStrategyStreaming ProbeStrategyType = "streaming"

// ProbeStrategyQuery means that the server is able to connect to the superuser database

// and able to execute a simple query like "-- ping"

ProbeStrategyQuery ProbeStrategyType = "query"

)

// Probe describes a health check to be performed against a container to determine whether it is

// alive or ready to receive traffic.

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

}

// LivenessProbe is the configuration of the liveness probe

type LivenessProbe struct {

// Probe is the standard probe configuration

Probe `json:",inline"`

// Configure the primary isolation check, which stops a primary whose

// primary lease has gone past its renew deadline without a successful

// renewal, when at least one other instance is unreachable or names a

// different target primary, so that it stops accepting writes it can no

// longer safely serve. Its reaction time is set by the `primaryLease`

// timings and by `requestTimeout`, not by the liveness probe settings this

// stanza lives under. Enabled by default.

// +optional

IsolationCheck *IsolationCheckConfiguration `json:"isolationCheck,omitempty"`

}

// IsolationCheckConfiguration contains the configuration for the primary

// isolation check

type IsolationCheckConfiguration struct {

// Whether primary isolation checking is enabled. When disabled, an

// isolated primary is not stopped, but a primary that reaches a peer

// reporting a different target primary still is.

// +optional

// +kubebuilder:default:=true

Enabled *bool `json:"enabled,omitempty"`

// Timeout in milliseconds for requests during the primary isolation check

// +optional

// +kubebuilder:default:=1000

RequestTimeout int `json:"requestTimeout,omitempty"`

// Timeout in milliseconds for connections during the primary isolation check

// +optional

// +kubebuilder:default:=1000

ConnectionTimeout int `json:"connectionTimeout,omitempty"`

}

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"

// PhaseMajorUpgrade major version upgrade in process

PhaseMajorUpgrade = "Upgrading Postgres major version"

// PhaseUpgradeDelayed is set when a cluster needs 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"

// PhaseFailurePlugin is triggered when the cluster cannot proceed to reconciliation due to an interaction failure

PhaseFailurePlugin = "Cluster cannot proceed to reconciliation due to an error while interacting with plugins"

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

// PhaseDefinitionInvalid is set when the cluster definition is invalid

PhaseDefinitionInvalid = "Invalid cluster definition"

)

// EphemeralVolumesSizeLimitConfiguration contains the configuration of the ephemeral

// storage

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

}

// ServiceAccountTemplate contains the template needed to generate the service accounts

type ServiceAccountTemplate struct {

// Metadata are the metadata to be used for the generated

// service account

Metadata Metadata `json:"metadata"`

}

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

type PodTopologyLabels map[string]string

// PodName is the name of a Pod

type PodName string

// Topology contains the cluster 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"`

}

// RoleStatus represents the status of a managed role in the cluster

type RoleStatus string

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"

)

// PasswordState represents the state of the password of a managed RoleConfiguration

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

}

// ManagedRoles tracks the status of a cluster's managed roles

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, with an

// explanation of the cause. Failures may originate in PostgreSQL

// (e.g. dropping a role that owns objects) or in Kubernetes (e.g.

// the referenced password Secret cannot be fetched).

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

}

// TablespaceState represents the state of a tablespace in a cluster

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

}

// TablespaceStatus represents the status of a tablespace in the cluster

type TablespaceStatus string

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"

)

// AvailableArchitecture represents the state of a cluster's architecture

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

}

// ClusterStatus defines the observed state of a PostgreSQL cluster managed by

// CloudNativePG.

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

// Selector is the serialized form of the label selector that identifies

// the pods managed by this cluster. Populated by the operator and exposed

// through the scale sub-resource so an autoscaler (such as HPA or VPA)

// can discover the managed instance pods.

// +optional

Selector string `json:"selector,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"`

// PodSelectorRefs contains the resolved pod IPs for each named selector

// defined in spec.podSelectorRefs.

// +optional

// +listType=map

// +listMapKey=name

PodSelectorRefs []PodSelectorRefStatus `json:"podSelectorRefs,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)

//

// Deprecated: this field is not set anymore

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