10.10.0-debian-9-r0 release
This commit is contained in:
Bitnami Bot
parent
760f843e8b
commit
852713d15f
|
|
@ -0,0 +1,30 @@
|
|||
FROM bitnami/minideb-extras-base:stretch-r376
|
||||
LABEL maintainer "Bitnami <containers@bitnami.com>"
|
||||
|
||||
ENV BITNAMI_PKG_CHMOD="-R g+rwX" \
|
||||
HOME="/" \
|
||||
OS_ARCH="amd64" \
|
||||
OS_FLAVOUR="debian-9" \
|
||||
OS_NAME="linux"
|
||||
|
||||
# Install required system packages and dependencies
|
||||
RUN install_packages libbsd0 libc6 libedit2 libgcc1 libicu57 liblzma5 libncurses5 libnss-wrapper libssl1.1 libstdc++6 libtinfo5 libuuid1 libxml2 libxslt1.1 locales zlib1g
|
||||
RUN . ./libcomponent.sh && component_unpack "postgresql-repmgr" "10.10.0-0" --checksum bd73d00b732b1f18d083b9d65316b625302d314d11c49495bf300c1073f88a70
|
||||
RUN echo 'en_GB.UTF-8 UTF-8' >> /etc/locale.gen && locale-gen
|
||||
RUN echo 'en_US.UTF-8 UTF-8' >> /etc/locale.gen && locale-gen
|
||||
|
||||
COPY rootfs /
|
||||
RUN /postunpack.sh
|
||||
ENV BITNAMI_APP_NAME="postgresql-repmgr" \
|
||||
BITNAMI_IMAGE_VERSION="10.10.0-debian-9-r0" \
|
||||
LANG="en_US.UTF-8" \
|
||||
LANGUAGE="en_US:en" \
|
||||
NAMI_PREFIX="/.nami" \
|
||||
NSS_WRAPPER_LIB="/usr/lib/libnss_wrapper.so" \
|
||||
PATH="/opt/bitnami/postgresql-repmgr/bin:/opt/bitnami/repmgr/bin:/opt/bitnami/postgresql/bin:$PATH"
|
||||
|
||||
EXPOSE 5432
|
||||
|
||||
USER 1001
|
||||
ENTRYPOINT [ "/entrypoint.sh" ]
|
||||
CMD [ "/run.sh" ]
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
version: '2'
|
||||
services:
|
||||
pg-0:
|
||||
image: bitnami/postgresql-repmgr:10
|
||||
ports:
|
||||
- 5432
|
||||
volumes:
|
||||
- pg_0_data:/bitnami/postgresql
|
||||
environment:
|
||||
- POSTGRESQL_POSTGRES_PASSWORD=adminpassword
|
||||
- POSTGRESQL_USERNAME=customuser
|
||||
- POSTGRESQL_PASSWORD=custompassword
|
||||
- POSTGRESQL_DATABASE=customdatabase
|
||||
- REPMGR_PASSWORD=repmgrpassword
|
||||
- REPMGR_PRIMARY_HOST=pg-0
|
||||
- REPMGR_PARTNER_NODES=pg-0,pg-1
|
||||
- REPMGR_NODE_NAME=pg-0
|
||||
- REPMGR_NODE_NETWORK_NAME=pg-0
|
||||
pg-1:
|
||||
image: bitnami/postgresql-repmgr:10
|
||||
ports:
|
||||
- 5432
|
||||
volumes:
|
||||
- pg_1_data:/bitnami/postgresql
|
||||
environment:
|
||||
- POSTGRESQL_POSTGRES_PASSWORD=adminpassword
|
||||
- POSTGRESQL_USERNAME=customuser
|
||||
- POSTGRESQL_PASSWORD=custompassword
|
||||
- POSTGRESQL_DATABASE=customdatabase
|
||||
- REPMGR_PASSWORD=repmgrpassword
|
||||
- REPMGR_PRIMARY_HOST=pg-0
|
||||
- REPMGR_PARTNER_NODES=pg-0,pg-1
|
||||
- REPMGR_NODE_NAME=pg-1
|
||||
- REPMGR_NODE_NETWORK_NAME=pg-1
|
||||
volumes:
|
||||
pg_0_data:
|
||||
driver: local
|
||||
pg_1_data:
|
||||
driver: local
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
#set -o xtrace
|
||||
|
||||
# shellcheck disable=SC1091
|
||||
|
||||
# Load libraries
|
||||
. /liblog.sh
|
||||
. /libbitnami.sh
|
||||
. /libpostgresql.sh
|
||||
. /librepmgr.sh
|
||||
|
||||
# Load PostgreSQL & repmgr environment variables
|
||||
eval "$(repmgr_env)"
|
||||
eval "$(postgresql_env)"
|
||||
export MODULE=postgresql-repmgr
|
||||
|
||||
print_welcome_page
|
||||
|
||||
# Enable the nss_wrapper settings
|
||||
postgresql_enable_nss_wrapper
|
||||
|
||||
if [[ "$*" = *"/run.sh"* ]]; then
|
||||
info "** Starting PostgreSQL with Replication Manager setup **"
|
||||
/setup.sh
|
||||
touch "$POSTGRESQL_TMP_DIR"/.initialized
|
||||
info "** PostgreSQL with Replication Manager setup finished! **"
|
||||
fi
|
||||
|
||||
echo ""
|
||||
exec "$@"
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
# set -o xtrace # Uncomment this line for debugging purpose
|
||||
|
||||
header="[REPMGR EVENT::$2]"
|
||||
export header
|
||||
echo "$header Node id: $1; Event type: $2; Success [1|0]: $3; Time: $4; Details: $5"
|
||||
|
||||
if [[ $3 -ne 1 ]];then
|
||||
echo "$header The event failed! No need to do anything."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [[ $1 -ne $(repmgr_get_node_id) ]]; then
|
||||
echo "$header The event did not happen on me! No need to do anything."
|
||||
exit 1
|
||||
fi
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
# set -o xtrace # Uncomment this line for debugging purpose
|
||||
# shellcheck disable=SC2154
|
||||
|
||||
echo "$header Locking primary..."
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
# set -o xtrace # Uncomment this line for debugging purpose
|
||||
|
||||
readonly query="SELECT upstream_node_id FROM repmgr.nodes WHERE node_id=$(repmgr_get_node_id)"
|
||||
readonly new_upstream_node_id="$(echo "$query" | BITNAMI_DEBUG=true postgresql_execute "$REPMGR_DATABASE" "$POSTGRESQL_REPLICATION_USER" "$POSTGRESQL_REPLICATION_PASSWORD" "" "" "-tA")"
|
||||
if [[ -n "$new_upstream_node_id" ]]; then
|
||||
# shellcheck disable=SC2154
|
||||
echo "$header Locking standby (new_upstream_node_id=$new_upstream_node_id)..."
|
||||
echo "$new_upstream_node_id" > "$REPMGR_STANDBY_ROLE_LOCK_FILE_NAME"
|
||||
fi
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
# set -o xtrace # Uncomment this line for debugging purpose
|
||||
# shellcheck disable=SC2154
|
||||
|
||||
echo "$header Unlocking primary..."
|
||||
rm -f "$REPMGR_PRIMARY_ROLE_LOCK_FILE_NAME"
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
# set -o xtrace # Uncomment this line for debugging purpose
|
||||
# shellcheck disable=SC2154
|
||||
|
||||
echo "$header Unlocking standby..."
|
||||
rm -f "$REPMGR_STANDBY_ROLE_LOCK_FILE_NAME"
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
# set -o xtrace # Uncomment this line for debugging purpose
|
||||
|
||||
. "$REPMGR_EVENTS_DIR/execs/includes/anotate_event_processing.sh"
|
||||
. "$REPMGR_EVENTS_DIR/execs/includes/lock_primary.sh"
|
||||
. "$REPMGR_EVENTS_DIR/execs/includes/unlock_standby.sh"
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
# set -o xtrace # Uncomment this line for debugging purpose
|
||||
# shellcheck disable=SC1090
|
||||
# shellcheck disable=SC1091
|
||||
|
||||
. "$REPMGR_EVENTS_DIR/execs/includes/anotate_event_processing.sh"
|
||||
. "$REPMGR_EVENTS_DIR/execs/includes/lock_standby.sh"
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
# set -o xtrace # Uncomment this line for debugging purpose
|
||||
# shellcheck disable=SC1090
|
||||
# shellcheck disable=SC1091
|
||||
|
||||
. "$REPMGR_EVENTS_DIR/execs/includes/anotate_event_processing.sh"
|
||||
. "$REPMGR_EVENTS_DIR/execs/includes/unlock_primary.sh"
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
# set -o xtrace # Uncomment this line for debugging purpose
|
||||
# shellcheck disable=SC1090
|
||||
# shellcheck disable=SC1091
|
||||
|
||||
. "$REPMGR_EVENTS_DIR/execs/includes/anotate_event_processing.sh"
|
||||
. "$REPMGR_EVENTS_DIR/execs/includes/lock_primary.sh"
|
||||
. "$REPMGR_EVENTS_DIR/execs/includes/unlock_standby.sh"
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
# set -o xtrace # Uncomment this line for debugging purpose
|
||||
# shellcheck disable=SC1090
|
||||
# shellcheck disable=SC1091
|
||||
|
||||
# Load libraries
|
||||
. /librepmgr.sh
|
||||
. /libpostgresql.sh
|
||||
|
||||
eval "$(repmgr_env)"
|
||||
eval "$(postgresql_env)"
|
||||
|
||||
echo "[REPMGR EVENT] Node id: $1; Event type: $2; Success [1|0]: $3; Time: $4; Details: $5"
|
||||
event_script="$REPMGR_EVENTS_DIR/execs/$2.sh"
|
||||
echo "Looking for the script: $event_script"
|
||||
if [[ -f "$event_script" ]]; then
|
||||
echo "[REPMGR EVENT] will execute script '$event_script' for the event"
|
||||
. "$event_script"
|
||||
else
|
||||
echo "[REPMGR EVENT] no script '$event_script' found. Skipping..."
|
||||
fi
|
||||
|
|
@ -0,0 +1,808 @@
|
|||
#!/bin/bash
|
||||
#
|
||||
# Bitnami PostgreSQL library
|
||||
|
||||
# shellcheck disable=SC1090
|
||||
# shellcheck disable=SC1091
|
||||
|
||||
# Load Generic Libraries
|
||||
. /libfile.sh
|
||||
. /liblog.sh
|
||||
. /libservice.sh
|
||||
. /libvalidations.sh
|
||||
|
||||
|
||||
########################
|
||||
# Overwrite info, debug, warn and error functions (liblog.sh)
|
||||
########################
|
||||
postgresql_info() {
|
||||
MODULE=postgresql info "${*}"
|
||||
}
|
||||
postgresql_debug() {
|
||||
MODULE=postgresql debug "${*}"
|
||||
}
|
||||
postgresql_warn() {
|
||||
MODULE=postgresql warn "${*}"
|
||||
}
|
||||
postgresql_error() {
|
||||
MODULE=postgresql error "${*}"
|
||||
}
|
||||
|
||||
########################
|
||||
# Configure libnss_wrapper so PostgreSQL commands work with a random user.
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_enable_nss_wrapper() {
|
||||
if ! getent passwd "$(id -u)" &> /dev/null && [ -e "$NSS_WRAPPER_LIB" ]; then
|
||||
postgresql_debug "Configuring libnss_wrapper..."
|
||||
export LD_PRELOAD="$NSS_WRAPPER_LIB"
|
||||
# shellcheck disable=SC2155
|
||||
export NSS_WRAPPER_PASSWD="$(mktemp)"
|
||||
# shellcheck disable=SC2155
|
||||
export NSS_WRAPPER_GROUP="$(mktemp)"
|
||||
echo "postgres:x:$(id -u):$(id -g):PostgreSQL:$POSTGRESQL_DATA_DIR:/bin/false" > "$NSS_WRAPPER_PASSWD"
|
||||
echo "postgres:x:$(id -g):" > "$NSS_WRAPPER_GROUP"
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Load global variables used on PostgreSQL configuration.
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# Series of exports to be used as 'eval' arguments
|
||||
#########################
|
||||
postgresql_env() {
|
||||
declare_env_alias() {
|
||||
local -r alias="${1:?missing environment variable alias}"
|
||||
local -r original="${2:?missing original environment variable}"
|
||||
|
||||
if printenv "${original}" > /dev/null; then
|
||||
cat << EOF
|
||||
export $alias="${!original}"
|
||||
EOF
|
||||
fi
|
||||
}
|
||||
|
||||
# Alias created for official PostgreSQL image compatibility
|
||||
[[ -z "${POSTGRESQL_DATABASE:-}" ]] && declare_env_alias POSTGRESQL_DATABASE POSTGRES_DB
|
||||
[[ -z "${POSTGRESQL_USERNAME:-}" ]] && declare_env_alias POSTGRESQL_USERNAME POSTGRES_USER
|
||||
[[ -z "${POSTGRESQL_DATA_DIR:-}" ]] && declare_env_alias POSTGRESQL_DATA_DIR PGDATA
|
||||
|
||||
local -r suffixes=(
|
||||
"PASSWORD" "POSTGRES_PASSWORD" "INITDB_WAL_DIR" "INITDB_ARGS" "CLUSTER_APP_NAME"
|
||||
"MASTER_HOST" "MASTER_PORT_NUMBER" "NUM_SYNCHRONOUS_REPLICAS"
|
||||
"PORT_NUMBER" "REPLICATION_MODE" "REPLICATION_PASSWORD" "REPLICATION_USER" "FSYNC"
|
||||
"SYNCHRONOUS_COMMIT_MODE" "PASSWORD_FILE" "POSTGRES_PASSWORD_FILE"
|
||||
"REPLICATION_PASSWORD_FILE" "INIT_MAX_TIMEOUT"
|
||||
)
|
||||
for s in "${suffixes[@]}"; do
|
||||
declare_env_alias "POSTGRESQL_${s}" "POSTGRES_${s}"
|
||||
done
|
||||
|
||||
# Ensure the image is compatible with Helm chart 3.x.x series
|
||||
local -r postgresql_data="${POSTGRESQL_DATA_DIR:-${PGDATA:-}}"
|
||||
if [[ -n "${postgresql_data:-}" ]]; then
|
||||
if [[ -d "${postgresql_data}/data" ]] || [[ "${postgresql_data}" = "/bitnami/postgresql" ]]; then
|
||||
postgresql_warn "Data directory is set with a legacy value, adapting POSTGRESQL_DATA_DIR..."
|
||||
postgresql_warn "POSTGRESQL_DATA_DIR set to \"${postgresql_data}/data\"!!"
|
||||
cat << EOF
|
||||
export POSTGRESQL_DATA_DIR="${postgresql_data}/data"
|
||||
EOF
|
||||
fi
|
||||
fi
|
||||
|
||||
cat <<"EOF"
|
||||
# Paths
|
||||
export POSTGRESQL_VOLUME_DIR="${POSTGRESQL_VOLUME_DIR:-/bitnami/postgresql}"
|
||||
export POSTGRESQL_DATA_DIR="${POSTGRESQL_DATA_DIR:-$POSTGRESQL_VOLUME_DIR/data}"
|
||||
export POSTGRESQL_BASE_DIR="/opt/bitnami/postgresql"
|
||||
export POSTGRESQL_CONF_DIR="$POSTGRESQL_BASE_DIR/conf"
|
||||
export POSTGRESQL_MOUNTED_CONF_DIR="/bitnami/postgresql/conf"
|
||||
export POSTGRESQL_CONF_FILE="$POSTGRESQL_CONF_DIR/postgresql.conf"
|
||||
export POSTGRESQL_PGHBA_FILE="$POSTGRESQL_CONF_DIR/pg_hba.conf"
|
||||
export POSTGRESQL_RECOVERY_FILE="$POSTGRESQL_DATA_DIR/recovery.conf"
|
||||
export POSTGRESQL_LOG_DIR="$POSTGRESQL_BASE_DIR/logs"
|
||||
export POSTGRESQL_LOG_FILE="$POSTGRESQL_LOG_DIR/postgresql.log"
|
||||
export POSTGRESQL_TMP_DIR="$POSTGRESQL_BASE_DIR/tmp"
|
||||
export POSTGRESQL_PID_FILE="$POSTGRESQL_TMP_DIR/postgresql.pid"
|
||||
export POSTGRESQL_BIN_DIR="$POSTGRESQL_BASE_DIR/bin"
|
||||
export POSTGRESQL_INITSCRIPTS_DIR=/docker-entrypoint-initdb.d
|
||||
export POSTGRESQL_PREINITSCRIPTS_DIR=/docker-entrypoint-preinitdb.d
|
||||
export PATH="$POSTGRESQL_BIN_DIR:$PATH"
|
||||
|
||||
# Users
|
||||
export POSTGRESQL_DAEMON_USER="postgresql"
|
||||
export POSTGRESQL_DAEMON_GROUP="postgresql"
|
||||
|
||||
# Settings
|
||||
export POSTGRESQL_INIT_MAX_TIMEOUT=${POSTGRESQL_INIT_MAX_TIMEOUT:-60}
|
||||
export POSTGRESQL_CLUSTER_APP_NAME=${POSTGRESQL_CLUSTER_APP_NAME:-walreceiver}
|
||||
export POSTGRESQL_DATABASE="${POSTGRESQL_DATABASE:-postgres}"
|
||||
export POSTGRESQL_INITDB_ARGS="${POSTGRESQL_INITDB_ARGS:-}"
|
||||
export ALLOW_EMPTY_PASSWORD="${ALLOW_EMPTY_PASSWORD:-no}"
|
||||
export POSTGRESQL_INITDB_WAL_DIR="${POSTGRESQL_INITDB_WAL_DIR:-}"
|
||||
export POSTGRESQL_MASTER_HOST="${POSTGRESQL_MASTER_HOST:-}"
|
||||
export POSTGRESQL_MASTER_PORT_NUMBER="${POSTGRESQL_MASTER_PORT_NUMBER:-5432}"
|
||||
export POSTGRESQL_NUM_SYNCHRONOUS_REPLICAS="${POSTGRESQL_NUM_SYNCHRONOUS_REPLICAS:-0}"
|
||||
export POSTGRESQL_PORT_NUMBER="${POSTGRESQL_PORT_NUMBER:-5432}"
|
||||
export POSTGRESQL_REPLICATION_MODE="${POSTGRESQL_REPLICATION_MODE:-master}"
|
||||
export POSTGRESQL_REPLICATION_USER="${POSTGRESQL_REPLICATION_USER:-}"
|
||||
export POSTGRESQL_SYNCHRONOUS_COMMIT_MODE="${POSTGRESQL_SYNCHRONOUS_COMMIT_MODE:-on}"
|
||||
export POSTGRESQL_FSYNC="${POSTGRESQL_FSYNC:-on}"
|
||||
export POSTGRESQL_USERNAME="${POSTGRESQL_USERNAME:-postgres}"
|
||||
EOF
|
||||
if [[ -f "${POSTGRESQL_PASSWORD_FILE:-}" ]]; then
|
||||
cat <<"EOF"
|
||||
export POSTGRESQL_PASSWORD="$(< "${POSTGRESQL_PASSWORD_FILE}")"
|
||||
EOF
|
||||
else
|
||||
cat <<"EOF"
|
||||
export POSTGRESQL_PASSWORD="${POSTGRESQL_PASSWORD:-}"
|
||||
EOF
|
||||
fi
|
||||
if [[ -f "${POSTGRESQL_REPLICATION_PASSWORD_FILE:-}" ]]; then
|
||||
cat <<"EOF"
|
||||
export POSTGRESQL_REPLICATION_PASSWORD="$(< "${POSTGRESQL_REPLICATION_PASSWORD_FILE}")"
|
||||
EOF
|
||||
else
|
||||
cat <<"EOF"
|
||||
export POSTGRESQL_REPLICATION_PASSWORD="${POSTGRESQL_REPLICATION_PASSWORD:-}"
|
||||
EOF
|
||||
fi
|
||||
if [[ -f "${POSTGRESQL_POSTGRES_PASSWORD_FILE:-}" ]]; then
|
||||
cat <<"EOF"
|
||||
export POSTGRESQL_POSTGRES_PASSWORD="$(< "${POSTGRESQL_POSTGRES_PASSWORD_FILE}")"
|
||||
EOF
|
||||
else
|
||||
cat <<"EOF"
|
||||
export POSTGRESQL_POSTGRES_PASSWORD="${POSTGRESQL_POSTGRES_PASSWORD:-}"
|
||||
EOF
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Validate settings in POSTGRESQL_* environment variables
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_validate() {
|
||||
postgresql_info "Validating settings in POSTGRESQL_* env vars.."
|
||||
local error_code=0
|
||||
|
||||
# Auxiliary functions
|
||||
print_validation_error() {
|
||||
postgresql_error "$1"
|
||||
error_code=1
|
||||
}
|
||||
|
||||
empty_password_enabled_warn() {
|
||||
postgresql_warn "You set the environment variable ALLOW_EMPTY_PASSWORD=${ALLOW_EMPTY_PASSWORD}. For safety reasons, do not use this flag in a production environment."
|
||||
}
|
||||
empty_password_error() {
|
||||
print_validation_error "The $1 environment variable is empty or not set. Set the environment variable ALLOW_EMPTY_PASSWORD=yes to allow the container to be started with blank passwords. This is recommended only for development."
|
||||
}
|
||||
if is_boolean_yes "$ALLOW_EMPTY_PASSWORD"; then
|
||||
empty_password_enabled_warn
|
||||
else
|
||||
if [[ -z "$POSTGRESQL_PASSWORD" ]]; then
|
||||
empty_password_error "POSTGRESQL_PASSWORD"
|
||||
fi
|
||||
if (( ${#POSTGRESQL_PASSWORD} > 100 )); then
|
||||
print_validation_error "The password cannot be longer than 100 characters. Set the environment variable POSTGRESQL_PASSWORD with a shorter value"
|
||||
fi
|
||||
if [[ -n "$POSTGRESQL_USERNAME" ]] && [[ -z "$POSTGRESQL_PASSWORD" ]]; then
|
||||
empty_password_error "POSTGRESQL_PASSWORD"
|
||||
fi
|
||||
if [[ -n "$POSTGRESQL_USERNAME" ]] && [[ "$POSTGRESQL_USERNAME" != "postgres" ]] && [[ -n "$POSTGRESQL_PASSWORD" ]] && [[ -z "$POSTGRESQL_DATABASE" ]]; then
|
||||
print_validation_error "In order to use a custom PostgreSQL user you need to set the environment variable POSTGRESQL_DATABASE as well"
|
||||
fi
|
||||
fi
|
||||
if [[ -n "$POSTGRESQL_REPLICATION_MODE" ]]; then
|
||||
if [[ "$POSTGRESQL_REPLICATION_MODE" = "master" ]]; then
|
||||
if (( POSTGRESQL_NUM_SYNCHRONOUS_REPLICAS < 0 )); then
|
||||
print_validation_error "The number of synchronous replicas cannot be less than 0. Set the environment variable POSTGRESQL_NUM_SYNCHRONOUS_REPLICAS"
|
||||
fi
|
||||
elif [[ "$POSTGRESQL_REPLICATION_MODE" = "slave" ]]; then
|
||||
if [[ -z "$POSTGRESQL_MASTER_HOST" ]]; then
|
||||
print_validation_error "Slave replication mode chosen without setting the environment variable POSTGRESQL_MASTER_HOST. Use it to indicate where the Master node is running"
|
||||
fi
|
||||
if [[ -z "$POSTGRESQL_REPLICATION_USER" ]]; then
|
||||
print_validation_error "Slave replication mode chosen without setting the environment variable POSTGRESQL_REPLICATION_USER. Make sure that the master also has this parameter set"
|
||||
fi
|
||||
else
|
||||
print_validation_error "Invalid replication mode. Available options are 'master/slave'"
|
||||
fi
|
||||
# Common replication checks
|
||||
if [[ -n "$POSTGRESQL_REPLICATION_USER" ]] && [[ -z "$POSTGRESQL_REPLICATION_PASSWORD" ]]; then
|
||||
empty_password_error "POSTGRESQL_REPLICATION_PASSWORD"
|
||||
fi
|
||||
else
|
||||
if is_boolean_yes "$ALLOW_EMPTY_PASSWORD"; then
|
||||
empty_password_enabled_warn
|
||||
else
|
||||
if [[ -z "$POSTGRESQL_PASSWORD" ]]; then
|
||||
empty_password_error "POSTGRESQL_PASSWORD"
|
||||
fi
|
||||
if [[ -n "$POSTGRESQL_USERNAME" ]] && [[ -z "$POSTGRESQL_PASSWORD" ]]; then
|
||||
empty_password_error "POSTGRESQL_PASSWORD"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
[[ "$error_code" -eq 0 ]] || exit "$error_code"
|
||||
}
|
||||
|
||||
########################
|
||||
# Create basic postgresql.conf file using the example provided in the share/ folder
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_create_config() {
|
||||
postgresql_info "postgresql.conf file not detected. Generating it..."
|
||||
cp "$POSTGRESQL_BASE_DIR/share/postgresql.conf.sample" "$POSTGRESQL_CONF_FILE"
|
||||
# Update default value for 'include_dir' directive
|
||||
# ref: https://github.com/postgres/postgres/commit/fb9c475597c245562a28d1e916b575ac4ec5c19f#diff-f5544d9b6d218cc9677524b454b41c60
|
||||
if ! grep include_dir "$POSTGRESQL_CONF_FILE" > /dev/null; then
|
||||
postgresql_error "include_dir line is not present in $POSTGRESQL_CONF_FILE. This may be due to a changes in a new version of PostgreSQL. Please check"
|
||||
exit 1
|
||||
fi
|
||||
sed -i -E "/#include_dir/i include_dir = 'conf.d'" "$POSTGRESQL_CONF_FILE"
|
||||
}
|
||||
|
||||
########################
|
||||
# Create basic pg_hba.conf file
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_create_pghba() {
|
||||
postgresql_info "pg_hba.conf file not detected. Generating it..."
|
||||
cat << EOF > "$POSTGRESQL_PGHBA_FILE"
|
||||
host all all 0.0.0.0/0 trust
|
||||
host all all ::1/128 trust
|
||||
EOF
|
||||
}
|
||||
|
||||
########################
|
||||
# Change pg_hba.conf so it allows local UNIX socket-based connections
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_allow_local_connection() {
|
||||
cat << EOF >> "$POSTGRESQL_PGHBA_FILE"
|
||||
local all all trust
|
||||
EOF
|
||||
}
|
||||
|
||||
########################
|
||||
# Change pg_hba.conf so only password-based authentication is allowed
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_restrict_pghba() {
|
||||
if [[ -n "$POSTGRESQL_PASSWORD" ]]; then
|
||||
sed -i 's/trust/md5/g' "$POSTGRESQL_PGHBA_FILE"
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Change pg_hba.conf so it allows access from replication users
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_add_replication_to_pghba() {
|
||||
local replication_auth="trust"
|
||||
if [[ -n "$POSTGRESQL_REPLICATION_PASSWORD" ]]; then
|
||||
replication_auth="md5"
|
||||
fi
|
||||
cat << EOF >> "$POSTGRESQL_PGHBA_FILE"
|
||||
host replication all 0.0.0.0/0 ${replication_auth}
|
||||
EOF
|
||||
}
|
||||
|
||||
########################
|
||||
# Change a PostgreSQL configuration file by setting a property
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# $1 - property
|
||||
# $2 - value
|
||||
# $3 - Path to configuration file (default: $POSTGRESQL_CONF_FILE)
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_set_property() {
|
||||
local -r property="${1:?missing property}"
|
||||
local -r value="${2:?missing value}"
|
||||
local -r conf_file="${3:-$POSTGRESQL_CONF_FILE}"
|
||||
sed -i "s?^#*\s*${property}\s*=.*?${property} = '${value}'?g" "$conf_file"
|
||||
}
|
||||
|
||||
########################
|
||||
# Create a user for master-slave replication
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_create_replication_user() {
|
||||
local -r escaped_password="${POSTGRESQL_REPLICATION_PASSWORD//\'/\'\'}"
|
||||
postgresql_info "Creating replication user $POSTGRESQL_REPLICATION_USER"
|
||||
echo "CREATE ROLE \"$POSTGRESQL_REPLICATION_USER\" REPLICATION LOGIN ENCRYPTED PASSWORD '$escaped_password'" | postgresql_execute
|
||||
}
|
||||
|
||||
########################
|
||||
# Change postgresql.conf by setting replication parameters
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_configure_replication_parameters() {
|
||||
postgresql_info "Configuring replication parameters"
|
||||
postgresql_set_property "wal_level" "hot_standby"
|
||||
postgresql_set_property "max_wal_size" "400MB"
|
||||
postgresql_set_property "max_wal_senders" "16"
|
||||
postgresql_set_property "wal_keep_segments" "12"
|
||||
postgresql_set_property "hot_standby" "on"
|
||||
if (( POSTGRESQL_NUM_SYNCHRONOUS_REPLICAS > 0 )); then
|
||||
postgresql_set_property "synchronous_commit" "$POSTGRESQL_SYNCHRONOUS_COMMIT_MODE"
|
||||
postgresql_set_property "synchronous_standby_names" "${POSTGRESQL_NUM_SYNCHRONOUS_REPLICAS} (\"${POSTGRESQL_CLUSTER_APP_NAME}\")"
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Change postgresql.conf by setting fsync
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_configure_fsync() {
|
||||
postgresql_info "Configuring fsync"
|
||||
postgresql_set_property "fsync" "$POSTGRESQL_FSYNC"
|
||||
}
|
||||
|
||||
########################
|
||||
# Alter password of the postgres user
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# Password
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_alter_postgres_user() {
|
||||
local -r escaped_password="${1//\'/\'\'}"
|
||||
postgresql_info "Changing password of postgres"
|
||||
echo "ALTER ROLE postgres WITH PASSWORD '$escaped_password';" | postgresql_execute
|
||||
}
|
||||
|
||||
########################
|
||||
# Create an admin user with all privileges in POSTGRESQL_DATABASE
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_create_admin_user() {
|
||||
local -r escaped_password="${POSTGRESQL_PASSWORD//\'/\'\'}"
|
||||
postgresql_info "Creating user ${POSTGRESQL_USERNAME}"
|
||||
echo "CREATE ROLE \"${POSTGRESQL_USERNAME}\" WITH LOGIN CREATEDB PASSWORD '${escaped_password}';" | postgresql_execute
|
||||
postgresql_info "Grating access to \"${POSTGRESQL_USERNAME}\" to the database \"${POSTGRESQL_DATABASE}\""
|
||||
echo "GRANT ALL PRIVILEGES ON DATABASE \"${POSTGRESQL_DATABASE}\" TO \"${POSTGRESQL_USERNAME}\"\;" | postgresql_execute "" "postgres" "$POSTGRESQL_PASSWORD"
|
||||
}
|
||||
|
||||
########################
|
||||
# Create a database with name $POSTGRESQL_DATABASE
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_create_custom_database() {
|
||||
echo "CREATE DATABASE \"$POSTGRESQL_DATABASE\"" | postgresql_execute "" "postgres" "" "localhost"
|
||||
}
|
||||
|
||||
########################
|
||||
# Change postgresql.conf to listen in 0.0.0.0
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_enable_remote_connections() {
|
||||
postgresql_set_property "listen_addresses" "*"
|
||||
}
|
||||
|
||||
########################
|
||||
# Check if a given configuration file was mounted externally
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# $1 - Filename
|
||||
# Returns:
|
||||
# 1 if the file was mounted externally, 0 otherwise
|
||||
#########################
|
||||
postgresql_is_file_external() {
|
||||
local -r filename=$1
|
||||
if [[ -d "$POSTGRESQL_MOUNTED_CONF_DIR" ]] && [[ -f "$POSTGRESQL_MOUNTED_CONF_DIR"/"$filename" ]]; then
|
||||
return 0
|
||||
else
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Ensure PostgreSQL is initialized
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_initialize() {
|
||||
postgresql_info "Initializing PostgreSQL database..."
|
||||
|
||||
# This fixes an issue where the trap would kill the entrypoint.sh, if a PID was left over from a previous run
|
||||
# Exec replaces the process without creating a new one, and when the container is restarted it may have the same PID
|
||||
rm -f "$POSTGRESQL_PID_FILE"
|
||||
|
||||
# User injected custom configuration
|
||||
if [[ -d "$POSTGRESQL_MOUNTED_CONF_DIR" ]] && compgen -G "$POSTGRESQL_MOUNTED_CONF_DIR"/* > /dev/null; then
|
||||
postgresql_debug "Copying files from $POSTGRESQL_MOUNTED_CONF_DIR to $POSTGRESQL_CONF_DIR"
|
||||
cp -fr "$POSTGRESQL_MOUNTED_CONF_DIR"/. "$POSTGRESQL_CONF_DIR"
|
||||
fi
|
||||
local create_conf_file=yes
|
||||
local create_pghba_file=yes
|
||||
|
||||
if postgresql_is_file_external "postgresql.conf"; then
|
||||
postgresql_info "Custom configuration $POSTGRESQL_CONF_FILE detected"
|
||||
create_conf_file=no
|
||||
fi
|
||||
|
||||
if postgresql_is_file_external "pg_hba.conf"; then
|
||||
postgresql_info "Custom configuration $POSTGRESQL_PGHBA_FILE detected"
|
||||
create_pghba_file=no
|
||||
fi
|
||||
|
||||
postgresql_debug "Ensuring expected directories/files exist..."
|
||||
for dir in "$POSTGRESQL_TMP_DIR" "$POSTGRESQL_LOG_DIR"; do
|
||||
ensure_dir_exists "$dir"
|
||||
am_i_root && chown "$POSTGRESQL_DAEMON_USER:$POSTGRESQL_DAEMON_GROUP" "$dir"
|
||||
done
|
||||
is_boolean_yes "$create_conf_file" && postgresql_create_config
|
||||
is_boolean_yes "$create_pghba_file" && postgresql_create_pghba && postgresql_allow_local_connection
|
||||
|
||||
if ! is_dir_empty "$POSTGRESQL_DATA_DIR"; then
|
||||
postgresql_info "Deploying PostgreSQL with persisted data..."
|
||||
local -r postmaster_path="$POSTGRESQL_DATA_DIR"/postmaster.pid
|
||||
if [[ -f "$postmaster_path" ]]; then
|
||||
postgresql_info "Cleaning stale postmaster.pid file"
|
||||
rm "$postmaster_path"
|
||||
fi
|
||||
is_boolean_yes "$create_pghba_file" && postgresql_restrict_pghba
|
||||
is_boolean_yes "$create_conf_file" && postgresql_configure_replication_parameters
|
||||
is_boolean_yes "$create_conf_file" && postgresql_configure_fsync
|
||||
[[ "$POSTGRESQL_REPLICATION_MODE" = "master" ]] && [[ -n "$POSTGRESQL_REPLICATION_USER" ]] && is_boolean_yes "$create_pghba_file" && postgresql_add_replication_to_pghba
|
||||
else
|
||||
ensure_dir_exists "$POSTGRESQL_DATA_DIR"
|
||||
am_i_root && chown "$POSTGRESQL_DAEMON_USER:$POSTGRESQL_DAEMON_GROUP" "$POSTGRESQL_DATA_DIR"
|
||||
if [[ "$POSTGRESQL_REPLICATION_MODE" = "master" ]]; then
|
||||
postgresql_master_init_db
|
||||
postgresql_start_bg
|
||||
[[ -n "${POSTGRESQL_DATABASE}" ]] && [[ "$POSTGRESQL_DATABASE" != "postgres" ]] && postgresql_create_custom_database
|
||||
if [[ "$POSTGRESQL_USERNAME" = "postgres" ]]; then
|
||||
postgresql_alter_postgres_user "$POSTGRESQL_PASSWORD"
|
||||
else
|
||||
if [[ -n "$POSTGRESQL_POSTGRES_PASSWORD" ]]; then
|
||||
postgresql_alter_postgres_user "$POSTGRESQL_POSTGRES_PASSWORD"
|
||||
fi
|
||||
postgresql_create_admin_user
|
||||
fi
|
||||
is_boolean_yes "$create_pghba_file" && postgresql_restrict_pghba
|
||||
[[ -n "$POSTGRESQL_REPLICATION_USER" ]] && postgresql_create_replication_user
|
||||
is_boolean_yes "$create_conf_file" && postgresql_configure_replication_parameters
|
||||
is_boolean_yes "$create_conf_file" && postgresql_configure_fsync
|
||||
[[ -n "$POSTGRESQL_REPLICATION_USER" ]] && is_boolean_yes "$create_pghba_file" && postgresql_add_replication_to_pghba
|
||||
else
|
||||
postgresql_slave_init_db
|
||||
is_boolean_yes "$create_pghba_file" && postgresql_restrict_pghba
|
||||
is_boolean_yes "$create_conf_file" && postgresql_configure_replication_parameters
|
||||
is_boolean_yes "$create_conf_file" && postgresql_configure_fsync
|
||||
postgresql_configure_recovery
|
||||
fi
|
||||
fi
|
||||
|
||||
# Delete conf files generated on first run
|
||||
rm -f "$POSTGRESQL_DATA_DIR"/postgresql.conf "$POSTGRESQL_DATA_DIR"/pg_hba.conf
|
||||
}
|
||||
|
||||
########################
|
||||
# Run custom pre-initialization scripts
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_custom_pre_init_scripts() {
|
||||
info "Loading custom pre-init scripts..."
|
||||
if [[ -n $(find "$POSTGRESQL_PREINITSCRIPTS_DIR/" -type f -name "*.sh") ]]; then
|
||||
info "Loading user's custom files from $POSTGRESQL_PREINITSCRIPTS_DIR ...";
|
||||
find "$POSTGRESQL_PREINITSCRIPTS_DIR/" -type f -name "*.sh" | sort | while read -r f; do
|
||||
if [[ -x "$f" ]]; then
|
||||
debug "Executing $f"; "$f"
|
||||
else
|
||||
debug "Sourcing $f"; . "$f"
|
||||
fi
|
||||
done
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Run custom initialization scripts
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_custom_init_scripts() {
|
||||
postgresql_info "Loading custom scripts..."
|
||||
if [[ -n $(find "$POSTGRESQL_INITSCRIPTS_DIR/" -type f -regex ".*\.\(sh\|sql\|sql.gz\)") ]] && [[ ! -f "$POSTGRESQL_VOLUME_DIR/.user_scripts_initialized" ]] ; then
|
||||
postgresql_info "Loading user's custom files from $POSTGRESQL_INITSCRIPTS_DIR ...";
|
||||
postgresql_start_bg
|
||||
find "$POSTGRESQL_INITSCRIPTS_DIR/" -type f -regex ".*\.\(sh\|sql\|sql.gz\)" | sort | while read -r f; do
|
||||
case "$f" in
|
||||
*.sh)
|
||||
if [[ -x "$f" ]]; then
|
||||
postgresql_debug "Executing $f"; "$f"
|
||||
else
|
||||
postgresql_debug "Sourcing $f"; . "$f"
|
||||
fi
|
||||
;;
|
||||
*.sql) postgresql_debug "Executing $f"; postgresql_execute "$POSTGRESQL_DATABASE" "$POSTGRESQL_USERNAME" "$POSTGRESQL_PASSWORD" < "$f";;
|
||||
*.sql.gz) postgresql_debug "Executing $f"; gunzip -c "$f" | postgresql_execute "$POSTGRESQL_DATABASE" "$POSTGRESQL_USERNAME" "$POSTGRESQL_PASSWORD";;
|
||||
*) postgresql_debug "Ignoring $f" ;;
|
||||
esac
|
||||
done
|
||||
touch "$POSTGRESQL_VOLUME_DIR"/.user_scripts_initialized
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Stop PostgreSQL
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_stop() {
|
||||
postgresql_info "Stopping PostgreSQL..."
|
||||
stop_service_using_pid "$POSTGRESQL_PID_FILE"
|
||||
}
|
||||
|
||||
########################
|
||||
# Execute an arbitrary query/queries against the running PostgreSQL service
|
||||
# Stdin:
|
||||
# Query/queries to execute
|
||||
# Globals:
|
||||
# BITNAMI_DEBUG
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# $1 - Database where to run the queries
|
||||
# $2 - User to run queries
|
||||
# $3 - Password
|
||||
# $4 - Host
|
||||
# $5 - Port
|
||||
# $6 - Extra options (eg. -tA)
|
||||
# Returns:
|
||||
# None
|
||||
postgresql_execute() {
|
||||
local -r db="${1:-}"
|
||||
local -r user="${2:-postgres}"
|
||||
local -r pass="${3:-}"
|
||||
local -r host="${4:-localhost}"
|
||||
local -r port="${5:-5432}"
|
||||
local -r opts="${6:-}"
|
||||
|
||||
local args=( "-h" "$host" "-p" "$port" "-U" "$user" )
|
||||
local cmd=("$POSTGRESQL_BIN_DIR/psql")
|
||||
[[ -n "$db" ]] && args+=( "-d" "$db" )
|
||||
[[ -n "$opts" ]] && args+=( "$opts" )
|
||||
if [[ "${BITNAMI_DEBUG:-false}" = true ]]; then
|
||||
PGPASSWORD=$pass "${cmd[@]}" "${args[@]}"
|
||||
elif [[ "${NO_ERRORS:-false}" = true ]]; then
|
||||
PGPASSWORD=$pass "${cmd[@]}" "${args[@]}" 2>/dev/null
|
||||
else
|
||||
PGPASSWORD=$pass "${cmd[@]}" "${args[@]}" >/dev/null 2>&1
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Start PostgreSQL and wait until it is ready
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
postgresql_start_bg() {
|
||||
local -r pg_ctl_flags=("-w" "-D" "$POSTGRESQL_DATA_DIR" "-l" "$POSTGRESQL_LOG_FILE" "-o" "--config-file=$POSTGRESQL_CONF_FILE --external_pid_file=$POSTGRESQL_PID_FILE --hba_file=$POSTGRESQL_PGHBA_FILE")
|
||||
postgresql_info "Starting PostgreSQL in background..."
|
||||
is_postgresql_running && return
|
||||
if [[ "${BITNAMI_DEBUG:-false}" = true ]]; then
|
||||
"$POSTGRESQL_BIN_DIR"/pg_ctl "start" "${pg_ctl_flags[@]}"
|
||||
else
|
||||
"$POSTGRESQL_BIN_DIR"/pg_ctl "start" "${pg_ctl_flags[@]}" >/dev/null 2>&1
|
||||
fi
|
||||
local -r pg_isready_args=("-U" "postgres")
|
||||
local counter=$POSTGRESQL_INIT_MAX_TIMEOUT
|
||||
while ! "$POSTGRESQL_BIN_DIR"/pg_isready "${pg_isready_args[@]}" >/dev/null 2>&1; do
|
||||
sleep 1
|
||||
counter=$((counter - 1 ))
|
||||
if (( counter <= 0 )); then
|
||||
postgresql_error "PostgreSQL is not ready after $POSTGRESQL_INIT_MAX_TIMEOUT seconds"
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
}
|
||||
|
||||
########################
|
||||
# Check if PostgreSQL is running
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# Boolean
|
||||
#########################
|
||||
is_postgresql_running() {
|
||||
local pid
|
||||
pid="$(get_pid_from_file "$POSTGRESQL_PID_FILE")"
|
||||
|
||||
if [[ -z "$pid" ]]; then
|
||||
false
|
||||
else
|
||||
is_service_running "$pid"
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Initialize master node database by running initdb
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# Boolean
|
||||
#########################
|
||||
postgresql_master_init_db() {
|
||||
local initdb_args=()
|
||||
if [[ -n "${POSTGRESQL_INITDB_ARGS[*]}" ]]; then
|
||||
initdb_args+=("${POSTGRESQL_INITDB_ARGS[@]}")
|
||||
fi
|
||||
if [[ -n "$POSTGRESQL_INITDB_WAL_DIR" ]]; then
|
||||
ensure_dir_exists "$POSTGRESQL_INITDB_WAL_DIR"
|
||||
am_i_root && chown "$POSTGRESQL_DAEMON_USER:$POSTGRESQL_DAEMON_GROUP" "$POSTGRESQL_INITDB_WAL_DIR"
|
||||
initdb_args+=("--waldir" "$POSTGRESQL_INITDB_WAL_DIR")
|
||||
fi
|
||||
if [[ -n "${initdb_args[*]:-}" ]]; then
|
||||
postgresql_info "Initializing PostgreSQL with ${initdb_args[*]} extra initdb arguments"
|
||||
if [[ "${BITNAMI_DEBUG:-false}" = true ]]; then
|
||||
"$POSTGRESQL_BIN_DIR/initdb" -E UTF8 -D "$POSTGRESQL_DATA_DIR" -U "postgres" "${initdb_args[@]}"
|
||||
else
|
||||
"$POSTGRESQL_BIN_DIR/initdb" -E UTF8 -D "$POSTGRESQL_DATA_DIR" -U "postgres" "${initdb_args[@]}" >/dev/null 2>&1
|
||||
fi
|
||||
elif [[ "${BITNAMI_DEBUG:-false}" = true ]]; then
|
||||
"$POSTGRESQL_BIN_DIR/initdb" -E UTF8 -D "$POSTGRESQL_DATA_DIR" -U "postgres"
|
||||
else
|
||||
"$POSTGRESQL_BIN_DIR/initdb" -E UTF8 -D "$POSTGRESQL_DATA_DIR" -U "postgres" >/dev/null 2>&1
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Initialize slave node by running pg_basebackup
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# Boolean
|
||||
#########################
|
||||
postgresql_slave_init_db() {
|
||||
postgresql_info "Waiting for replication master to accept connections (${POSTGRESQL_INIT_MAX_TIMEOUT} timeout)..."
|
||||
local -r check_args=("-U" "$POSTGRESQL_REPLICATION_USER" "-h" "$POSTGRESQL_MASTER_HOST" "-p" "$POSTGRESQL_MASTER_PORT_NUMBER" "-d" "postgres")
|
||||
local -r check_cmd=("$POSTGRESQL_BIN_DIR"/pg_isready)
|
||||
local ready_counter=$POSTGRESQL_INIT_MAX_TIMEOUT
|
||||
|
||||
while ! PGPASSWORD=$POSTGRESQL_REPLICATION_PASSWORD "${check_cmd[@]}" "${check_args[@]}";do
|
||||
sleep 1
|
||||
ready_counter=$(( ready_counter - 1 ))
|
||||
if (( ready_counter <= 0 )); then
|
||||
postgresql_error "PostgreSQL master is not ready after $POSTGRESQL_INIT_MAX_TIMEOUT seconds"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
done
|
||||
postgresql_info "Replicating the initial database"
|
||||
local -r backup_args=("-D" "$POSTGRESQL_DATA_DIR" "-U" "$POSTGRESQL_REPLICATION_USER" "-h" "$POSTGRESQL_MASTER_HOST" "-p" "$POSTGRESQL_MASTER_PORT_NUMBER" "-X" "stream" "-w" "-v" "-P")
|
||||
local -r backup_cmd=("$POSTGRESQL_BIN_DIR"/pg_basebackup)
|
||||
local replication_counter=$POSTGRESQL_INIT_MAX_TIMEOUT
|
||||
while ! PGPASSWORD=$POSTGRESQL_REPLICATION_PASSWORD "${backup_cmd[@]}" "${backup_args[@]}";do
|
||||
postgresql_debug "Backup command failed. Sleeping and trying again"
|
||||
sleep 1
|
||||
replication_counter=$(( replication_counter - 1 ))
|
||||
if (( replication_counter <= 0 )); then
|
||||
postgresql_error "Slave replication failed after trying for $POSTGRESQL_INIT_MAX_TIMEOUT seconds"
|
||||
exit 1
|
||||
fi
|
||||
done
|
||||
chmod 0700 "$POSTGRESQL_DATA_DIR"
|
||||
}
|
||||
|
||||
########################
|
||||
# Create recovery.conf in slave node
|
||||
# Globals:
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# Boolean
|
||||
#########################
|
||||
postgresql_configure_recovery() {
|
||||
postgresql_info "Setting up streaming replication slave..."
|
||||
cp -f "$POSTGRESQL_BASE_DIR/share/recovery.conf.sample" "$POSTGRESQL_RECOVERY_FILE"
|
||||
chmod 600 "$POSTGRESQL_RECOVERY_FILE"
|
||||
postgresql_set_property "standby_mode" "on" "$POSTGRESQL_RECOVERY_FILE"
|
||||
postgresql_set_property "primary_conninfo" "host=${POSTGRESQL_MASTER_HOST} port=${POSTGRESQL_MASTER_PORT_NUMBER} user=${POSTGRESQL_REPLICATION_USER} password=${POSTGRESQL_REPLICATION_PASSWORD} application_name=${POSTGRESQL_CLUSTER_APP_NAME}" "$POSTGRESQL_RECOVERY_FILE"
|
||||
postgresql_set_property "trigger_file" "/tmp/postgresql.trigger.${POSTGRESQL_MASTER_PORT_NUMBER}" "$POSTGRESQL_RECOVERY_FILE"
|
||||
}
|
||||
|
|
@ -0,0 +1,614 @@
|
|||
#!/bin/bash
|
||||
#
|
||||
# Bitnami Postgresql Repmgr library
|
||||
|
||||
# shellcheck disable=SC1090
|
||||
# shellcheck disable=SC1091
|
||||
|
||||
# Load Generic Libraries
|
||||
. /liblog.sh
|
||||
. /libfs.sh
|
||||
. /libos.sh
|
||||
. /libvalidations.sh
|
||||
|
||||
########################
|
||||
# Overwrite info, debug, warn and error functions (liblog.sh)
|
||||
########################
|
||||
repmgr_info() {
|
||||
MODULE=repmgr info "${*}"
|
||||
}
|
||||
repmgr_debug() {
|
||||
MODULE=repmgr debug "${*}"
|
||||
}
|
||||
repmgr_warn() {
|
||||
MODULE=repmgr warn "${*}"
|
||||
}
|
||||
repmgr_error() {
|
||||
MODULE=repmgr error "${*}"
|
||||
}
|
||||
|
||||
########################
|
||||
# Loads global variables used on repmgr configuration.
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# Series of exports to be used as 'eval' arguments
|
||||
#########################
|
||||
repmgr_env() {
|
||||
cat <<"EOF"
|
||||
# Paths
|
||||
export REPMGR_BASE_DIR="/opt/bitnami/repmgr"
|
||||
export REPMGR_CONF_DIR="${REPMGR_BASE_DIR}/conf"
|
||||
export REPMGR_MOUNTED_CONF_DIR="${REPMGR_MOUNTED_CONF_DIR:-/bitnami/repmgr/conf}"
|
||||
export REPMGR_TMP_DIR="${REPMGR_BASE_DIR}/tmp"
|
||||
export REPMGR_EVENTS_DIR="${REPMGR_BASE_DIR}/events"
|
||||
export REPMGR_PRIMARY_ROLE_LOCK_FILE_NAME="${REPMGR_TMP_DIR}/master.lock"
|
||||
export REPMGR_STANDBY_ROLE_LOCK_FILE_NAME="${REPMGR_TMP_DIR}/standby.lock"
|
||||
export REPMGR_BIN_DIR="${REPMGR_BASE_DIR}/bin"
|
||||
export REPMGR_CONF_FILE="${REPMGR_CONF_DIR}/repmgr.conf"
|
||||
export REPMGR_PID_FILE="${REPMGR_TMP_DIR}/repmgr.pid"
|
||||
export PATH="${REPMGR_BIN_DIR}:$PATH"
|
||||
|
||||
# Settings
|
||||
export REPMGR_NODE_ID="${REPMGR_NODE_ID:-}"
|
||||
export REPMGR_NODE_NAME="${REPMGR_NODE_NAME:-$(hostname)}"
|
||||
export REPMGR_NODE_NETWORK_NAME="${REPMGR_NODE_NETWORK_NAME:-}"
|
||||
export REPMGR_NODE_PRIORITY="${REPMGR_NODE_PRIORITY:-100}"
|
||||
|
||||
export REPMGR_PORT_NUMBER="${REPMGR_PORT_NUMBER:-5432}"
|
||||
export REPMGR_LOG_LEVEL="${REPMGR_LOG_LEVEL:-NOTICE}"
|
||||
|
||||
export REPMGR_START_OPTIONS="${REPMGR_START_OPTIONS:-}"
|
||||
export REPMGR_CONNECT_TIMEOUT="${REPMGR_CONNECT_TIMEOUT:-5}"
|
||||
export REPMGR_RECONNECT_ATTEMPTS="${REPMGR_RECONNECT_ATTEMPTS:-3}"
|
||||
export REPMGR_RECONNECT_INTERVAL="${REPMGR_RECONNECT_INTERVAL:-5}"
|
||||
|
||||
export REPMGR_PARTNER_NODES="${REPMGR_PARTNER_NODES:-}"
|
||||
export REPMGR_PRIMARY_HOST="${REPMGR_PRIMARY_HOST:-}"
|
||||
export REPMGR_PRIMARY_PORT="${REPMGR_PRIMARY_PORT:-5432}"
|
||||
|
||||
export REPMGR_USE_REPLICATION_SLOTS="${REPMGR_USE_REPLICATION_SLOTS:-1}"
|
||||
export REPMGR_STANDBY_ROLE_LOCK_FILE_NAME="${REPMGR_TMP_DIR}/standby.lock"
|
||||
export REPMGR_MASTER_RESPONSE_TIMEOUT="${REPMGR_MASTER_RESPONSE_TIMEOUT:-20}"
|
||||
export REPMGR_DEGRADED_MONITORING_TIMEOUT="${REPMGR_DEGRADED_MONITORING_TIMEOUT:-5}"
|
||||
|
||||
# These are internal
|
||||
export REPMGR_SWITCH_ROLE="${REPMGR_SWITCH_ROLE:-no}"
|
||||
export REPMGR_CURRENT_PRIMARY_HOST=""
|
||||
|
||||
# Aliases to setup PostgreSQL environment variables
|
||||
export PGCONNECT_TIMEOUT="${PGCONNECT_TIMEOUT:-10}"
|
||||
|
||||
# Credentials
|
||||
export REPMGR_USERNAME="${REPMGR_USERNAME:-repmgr}"
|
||||
export REPMGR_DATABASE="${REPMGR_DATABASE:-repmgr}"
|
||||
EOF
|
||||
if [[ -f "${REPMGR_PASSWORD_FILE:-}" ]]; then
|
||||
cat <<"EOF"
|
||||
export REPMGR_PASSWORD="$(< "${REPMGR_PASSWORD_FILE}")"
|
||||
EOF
|
||||
else
|
||||
cat <<"EOF"
|
||||
export REPMGR_PASSWORD="${REPMGR_PASSWORD:-}"
|
||||
EOF
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Get repmgr node id
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# String
|
||||
#########################
|
||||
repmgr_get_node_id() {
|
||||
local num
|
||||
if [[ "$REPMGR_NODE_ID" != "" ]]; then
|
||||
echo "$REPMGR_NODE_ID"
|
||||
else
|
||||
num="${REPMGR_NODE_NAME##*-}"
|
||||
if [[ "$num" != "" ]]; then
|
||||
num=$((num+1000))
|
||||
echo "$num"
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Validate settings in REPMGR_* env. variables
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_validate() {
|
||||
repmgr_info "Validating settings in REPMGR_* env vars..."
|
||||
local error_code=0
|
||||
|
||||
# Auxiliary functions
|
||||
print_validation_error() {
|
||||
repmgr_error "$1"
|
||||
error_code=1
|
||||
}
|
||||
|
||||
if [[ -z "$REPMGR_PARTNER_NODES" ]]; then
|
||||
print_validation_error "The list of partner nodes cannot be empty. Set the environment variable REPMGR_PARTNER_NODES with a comma separated list of partner nodes."
|
||||
fi
|
||||
if [[ -z "$REPMGR_PRIMARY_HOST" ]]; then
|
||||
print_validation_error "The initial primary host is required. Set the environment variable REPMGR_PRIMARY_HOST with the initial primary host."
|
||||
fi
|
||||
if [[ -z "$REPMGR_NODE_NAME" ]]; then
|
||||
print_validation_error "The node name is required. Set the environment variable REPMGR_NODE_NAME with the node name."
|
||||
elif [[ ! "$REPMGR_NODE_NAME" =~ ^.*+-[0-9]+$ ]]; then
|
||||
print_validation_error "The node name does not follow the required format. Valid format: ^.*+-[0-9]+$"
|
||||
fi
|
||||
if [[ -z "$(repmgr_get_node_id)" ]]; then
|
||||
print_validation_error "The node id is required. Set the environment variable REPMGR_NODE_ID with the node id."
|
||||
fi
|
||||
if [[ -z "$REPMGR_NODE_NETWORK_NAME" ]]; then
|
||||
print_validation_error "The node network name is required. Set the environment variable REPMGR_NODE_NETWORK_NAME with the node network name."
|
||||
fi
|
||||
# Credentials validations
|
||||
if [[ -z "$REPMGR_USERNAME" ]] || [[ -z "$REPMGR_PASSWORD" ]]; then
|
||||
print_validation_error "The repmgr credentials are mandatory. Set the environment variables REPMGR_USERNAME and REPMGR_PASSWORD with the repmgr credentials."
|
||||
fi
|
||||
|
||||
[[ "$error_code" -eq 0 ]] || exit "$error_code"
|
||||
}
|
||||
|
||||
########################
|
||||
# Ask partner nodes which node is the primary
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# Non
|
||||
# Returns:
|
||||
# String
|
||||
#########################
|
||||
repmgr_get_upstream_node() {
|
||||
local primary_conninfo
|
||||
local pretending_primary=""
|
||||
|
||||
if [[ -n "$REPMGR_PARTNER_NODES" ]]; then
|
||||
repmgr_info "Querying all partner nodes for common upstream node..."
|
||||
read -r -a nodes <<< "$(tr ',;' ' ' <<< "${REPMGR_PARTNER_NODES}")"
|
||||
for node in "${nodes[@]}"; do
|
||||
repmgr_debug "Checking node $node..."
|
||||
local query="SELECT conninfo FROM repmgr.show_nodes WHERE (upstream_node_name IS NULL OR upstream_node_name = '') AND active=true"
|
||||
if ! primary_conninfo="$(echo "$query" | NO_ERRORS=true postgresql_execute "$REPMGR_DATABASE" "$REPMGR_USERNAME" "$REPMGR_PASSWORD" "$node" "$REPMGR_PRIMARY_PORT" "-tA")"; then
|
||||
repmgr_debug "Skipping: failed to get primary from the node $node!"
|
||||
continue
|
||||
elif [[ -z "$primary_conninfo" ]]; then
|
||||
repmgr_debug "Skipping: failed to get information about primary nodes!"
|
||||
continue
|
||||
elif [[ "$(echo "$primary_conninfo" | wc -l)" -eq 1 ]]; then
|
||||
local -r suggested_primary="$(echo "$primary_conninfo" | awk -F 'host=' '{print $2}' | awk '{print $1}')"
|
||||
repmgr_debug "Pretending primary role node - ${suggested_primary}"
|
||||
if [[ -n "$pretending_primary" ]]; then
|
||||
if [[ "${pretending_primary}" != "${suggested_primary}" ]]; then
|
||||
repmgr_warn "Conflict of pretending primary role nodes (previously: $pretending_primary, now: $suggested_primary)"
|
||||
pretending_primary="" && break
|
||||
fi
|
||||
else
|
||||
repmgr_debug "Pretending primary set to $suggested_primary!"
|
||||
pretending_primary="$suggested_primary"
|
||||
fi
|
||||
else
|
||||
repmgr_warn "There were more than one primary when getting primary from node $node"
|
||||
pretending_primary="" && break
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
echo "$pretending_primary"
|
||||
}
|
||||
|
||||
########################
|
||||
# Gets the node that is currently set as primary node
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# String
|
||||
#########################
|
||||
repmgr_get_primary_node() {
|
||||
local upstream_node
|
||||
local primary_node=""
|
||||
|
||||
upstream_node="$(repmgr_get_upstream_node)"
|
||||
[[ -n "$upstream_node" ]] && repmgr_info "Auto-detected primary node: '$upstream_node'"
|
||||
|
||||
if [[ -f "$REPMGR_PRIMARY_ROLE_LOCK_FILE_NAME" ]]; then
|
||||
repmgr_info "This node was acting as a primary before restart!"
|
||||
|
||||
if [[ -z "$upstream_node" ]] || [[ "$upstream_node" = "$REPMGR_NODE_NETWORK_NAME" ]]; then
|
||||
repmgr_info "Can not find new primary. Starting PostgreSQL normally..."
|
||||
else
|
||||
repmgr_info "Current master is $upstream_node. Cloning/rewinding it and acting as a standby node..."
|
||||
rm -f "$REPMGR_PRIMARY_ROLE_LOCK_FILE_NAME"
|
||||
export REPMGR_SWITCH_ROLE="yes"
|
||||
primary_node="$upstream_node"
|
||||
fi
|
||||
else
|
||||
if [[ -z "$upstream_node" ]]; then
|
||||
[[ "$REPMGR_PRIMARY_HOST" != "$REPMGR_NODE_NETWORK_NAME" ]] && primary_node="$REPMGR_PRIMARY_HOST"
|
||||
else
|
||||
primary_node="$upstream_node"
|
||||
fi
|
||||
fi
|
||||
|
||||
[[ -n "$primary_node" ]] && repmgr_debug "Primary node: $primary_node"
|
||||
echo "$primary_node"
|
||||
}
|
||||
|
||||
########################
|
||||
# Generates env vars for the node
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# Series of exports to be used as 'eval' arguments
|
||||
#########################
|
||||
repmgr_set_role() {
|
||||
local role="standby"
|
||||
local primary_node
|
||||
|
||||
primary_node="$(repmgr_get_primary_node)"
|
||||
if [[ -z "$primary_node" ]]; then
|
||||
repmgr_info "There are no nodes with primary role. Assuming the primary role..."
|
||||
role="primary"
|
||||
fi
|
||||
|
||||
cat <<EOF
|
||||
export REPMGR_ROLE="$role"
|
||||
export REPMGR_CURRENT_PRIMARY_HOST="$primary_node"
|
||||
EOF
|
||||
}
|
||||
|
||||
########################
|
||||
# Change a Repmgr configuration file by setting a property
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# $1 - property
|
||||
# $2 - value
|
||||
# $3 - Path to configuration file (default: $REPMGR_CONF_FILE)
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_set_property() {
|
||||
local -r property="${1:?missing property}"
|
||||
local -r value="${2:-}"
|
||||
local -r conf_file="${3:-$REPMGR_CONF_FILE}"
|
||||
sed -i "s?^#*\s*${property}\s*=.*?${property} = '${value}'?g" "$conf_file"
|
||||
}
|
||||
|
||||
|
||||
########################
|
||||
# Create the repmgr user (with )
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_create_repmgr_user() {
|
||||
local postgres_password="$POSTGRESQL_PASSWORD"
|
||||
local -r escaped_password="${REPMGR_PASSWORD//\'/\'\'}"
|
||||
repmgr_info "Creating repmgr user: $REPMGR_USERNAME"
|
||||
|
||||
[[ "$POSTGRESQL_USERNAME" != "postgres" ]] && [[ -n "$POSTGRESQL_POSTGRES_PASSWORD" ]] && postgres_password="$POSTGRESQL_POSTGRES_PASSWORD"
|
||||
# The repmgr user is created as superuser for simplicity (ref: https://repmgr.org/docs/4.3/quickstart-repmgr-user-database.html)
|
||||
echo "CREATE ROLE \"${REPMGR_USERNAME}\" WITH LOGIN CREATEDB PASSWORD '${escaped_password}';" | postgresql_execute "" "postgres" "$postgres_password"
|
||||
echo "ALTER USER ${REPMGR_USERNAME} WITH SUPERUSER;" | postgresql_execute "" "postgres" "$postgres_password"
|
||||
# set the repmgr user's search path to include the 'repmgr' schema name (ref: https://repmgr.org/docs/4.3/quickstart-repmgr-user-database.html)
|
||||
echo "ALTER USER ${REPMGR_USERNAME} SET search_path TO repmgr, \"\$user\", public;" | postgresql_execute "" "postgres" "$postgres_password"
|
||||
}
|
||||
|
||||
########################
|
||||
# Creates the repmgr database
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_create_repmgr_db() {
|
||||
local postgres_password="$POSTGRESQL_PASSWORD"
|
||||
repmgr_info "Creating repmgr database: $REPMGR_DATABASE"
|
||||
|
||||
[[ "$POSTGRESQL_USERNAME" != "postgres" ]] && [[ -n "$POSTGRESQL_POSTGRES_PASSWORD" ]] && postgres_password="$POSTGRESQL_POSTGRES_PASSWORD"
|
||||
echo "CREATE DATABASE $REPMGR_DATABASE;" | postgresql_execute "" "postgres" "$postgres_password"
|
||||
}
|
||||
|
||||
########################
|
||||
# Use a different PostgreSQL configuration file by pretending it's an injected custom configuration
|
||||
# Globals:
|
||||
# POSTGRESQL_MOUNTED_CONF_DIR
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_inject_postgresql_configuration() {
|
||||
repmgr_debug "Injecting a new postgresql.conf file..."
|
||||
postgresql_create_config
|
||||
# ref: https://repmgr.org/docs/4.3/quickstart-postgresql-configuration.html
|
||||
postgresql_set_property "shared_preload_libraries" "repmgr"
|
||||
postgresql_set_property "max_wal_senders" "10"
|
||||
postgresql_set_property "max_replication_slots" "10"
|
||||
postgresql_set_property "wal_level" "hot_standby"
|
||||
postgresql_set_property "archive_mode" "on"
|
||||
postgresql_set_property "hot_standby" "on"
|
||||
postgresql_set_property "archive_command" "/bin/true"
|
||||
# Redirect logs to POSTGRESQL_LOG_FILE
|
||||
postgresql_set_property "logging_collector" "on"
|
||||
postgresql_set_property "log_directory" "$POSTGRESQL_LOG_DIR"
|
||||
postgresql_set_property "log_filename" "postgresql.log"
|
||||
cp "$POSTGRESQL_CONF_FILE" "${POSTGRESQL_MOUNTED_CONF_DIR}/postgresql.conf"
|
||||
}
|
||||
|
||||
########################
|
||||
# Use a different pg_hba.conf file by pretending it's an injected custom configuration\
|
||||
# Globals:
|
||||
# POSTGRESQL_MOUNTED_CONF_DIR
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_inject_pghba_configuration() {
|
||||
repmgr_debug "Injecting a new pg_hba.conf file..."
|
||||
cat > "${POSTGRESQL_MOUNTED_CONF_DIR}/pg_hba.conf" << EOF
|
||||
host all $REPMGR_USERNAME 0.0.0.0/0 trust
|
||||
host $REPMGR_DATABASE $REPMGR_USERNAME 0.0.0.0/0 trust
|
||||
host replication $REPMGR_USERNAME 0.0.0.0/0 trust
|
||||
host all all 0.0.0.0/0 trust
|
||||
host all all ::1/128 trust
|
||||
local all all trust
|
||||
EOF
|
||||
}
|
||||
|
||||
########################
|
||||
# Prepare PostgreSQL default configuration
|
||||
# Globals:
|
||||
# POSTGRESQL_MOUNTED_CONF_DIR
|
||||
# REPMGR_MOUNTED_CONF_DIR
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_postgresql_configuration() {
|
||||
repmgr_info "Preparing PostgreSQL configuration..."
|
||||
# User injected custom configuration
|
||||
if [[ -d "$REPMGR_MOUNTED_CONF_DIR" ]] && compgen -G "$REPMGR_MOUNTED_CONF_DIR"/* > /dev/null; then
|
||||
repmgr_debug "User injected custom configuration detected!"
|
||||
fi
|
||||
ensure_dir_exists "$POSTGRESQL_MOUNTED_CONF_DIR"
|
||||
if [[ -f "${REPMGR_MOUNTED_CONF_DIR}/postgresql.conf" ]]; then
|
||||
cp "${REPMGR_MOUNTED_CONF_DIR}/postgresql.conf" "${POSTGRESQL_MOUNTED_CONF_DIR}/postgresql.conf"
|
||||
else
|
||||
repmgr_inject_postgresql_configuration
|
||||
fi
|
||||
if [[ -f "${REPMGR_MOUNTED_CONF_DIR}/pg_hba.conf" ]]; then
|
||||
cp "${REPMGR_MOUNTED_CONF_DIR}/pg_hba.conf" "${POSTGRESQL_MOUNTED_CONF_DIR}/pg_hba.conf"
|
||||
else
|
||||
repmgr_inject_pghba_configuration
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Generates repmgr config files
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_generate_repmgr_config() {
|
||||
repmgr_info "Preparing repmgr configuration..."
|
||||
|
||||
if [[ -f "${REPMGR_MOUNTED_CONF_DIR}/repmgr.conf" ]]; then
|
||||
repmgr_info "Custom repmgr.conf file detected"
|
||||
cp "${REPMGR_MOUNTED_CONF_DIR}/repmgr.conf" "$REPMGR_CONF_FILE"
|
||||
else
|
||||
cat << EOF >> "$REPMGR_CONF_FILE"
|
||||
event_notification_command='${REPMGR_EVENTS_DIR}/router.sh %n %e %s "%t" "%d"'
|
||||
ssh_options=-o \"StrictHostKeyChecking no\" -v
|
||||
use_replication_slots=$REPMGR_USE_REPLICATION_SLOTS
|
||||
pg_bindir=$POSTGRESQL_BIN_DIR
|
||||
|
||||
# FIXME: these 2 parameter should work
|
||||
node_id=$(repmgr_get_node_id)
|
||||
node_name=$REPMGR_NODE_NAME
|
||||
conninfo='user=$REPMGR_USERNAME password=$REPMGR_PASSWORD host=$REPMGR_NODE_NETWORK_NAME dbname=$REPMGR_DATABASE port=$REPMGR_PRIMARY_PORT connect_timeout=$REPMGR_CONNECT_TIMEOUT'
|
||||
failover=automatic
|
||||
promote_command='PGPASSWORD=$REPMGR_PASSWORD repmgr standby promote -f "$REPMGR_CONF_FILE" --log-level DEBUG --verbose'
|
||||
follow_command='PGPASSWORD=$REPMGR_PASSWORD repmgr standby follow -f "$REPMGR_CONF_FILE" -W --log-level DEBUG --verbose'
|
||||
reconnect_attempts=$REPMGR_RECONNECT_ATTEMPTS
|
||||
reconnect_interval=$REPMGR_RECONNECT_INTERVAL
|
||||
log_level=$REPMGR_LOG_LEVEL
|
||||
priority=$REPMGR_NODE_PRIORITY
|
||||
degraded_monitoring_timeout=$REPMGR_DEGRADED_MONITORING_TIMEOUT
|
||||
data_directory=$POSTGRESQL_DATA_DIR
|
||||
async_query_timeout=$REPMGR_MASTER_RESPONSE_TIMEOUT
|
||||
EOF
|
||||
fi
|
||||
}
|
||||
|
||||
########################
|
||||
# Waits until the primary node responds
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_wait_primary_node() {
|
||||
local return_value=1
|
||||
local -i timeout=60
|
||||
local -i step=10
|
||||
local -i max_tries=$(( timeout / step ))
|
||||
local schemata
|
||||
repmgr_info "Waiting for primary node..."
|
||||
repmgr_debug "Wait for schema $REPMGR_DATABASE.repmgr on $REPMGR_CURRENT_PRIMARY_HOST:$REPMGR_PRIMARY_PORT, will try $max_tries times with $step delay seconds (TIMEOUT=$timeout)"
|
||||
for ((i = 0 ; i <= timeout ; i+=step )); do
|
||||
local query="SELECT 1 FROM information_schema.schemata WHERE catalog_name='$REPMGR_DATABASE' AND schema_name='repmgr'"
|
||||
if ! schemata="$(echo "$query" | NO_ERRORS=true postgresql_execute "$REPMGR_DATABASE" "$REPMGR_USERNAME" "$REPMGR_PASSWORD" "$REPMGR_CURRENT_PRIMARY_HOST" "$REPMGR_PRIMARY_PORT" "-tA")"; then
|
||||
repmgr_debug "Host $REPMGR_CURRENT_PRIMARY_HOST:$REPMGR_PRIMARY_PORT is not accessible"
|
||||
else
|
||||
if [[ $schemata -ne 1 ]]; then
|
||||
repmgr_debug "Schema $REPMGR_DATABASE.repmgr is still not accessible"
|
||||
else
|
||||
repmgr_debug "Schema $REPMGR_DATABASE.repmgr exists!"
|
||||
return_value=0 && break
|
||||
fi
|
||||
fi
|
||||
sleep "$step"
|
||||
done
|
||||
return $return_value
|
||||
}
|
||||
|
||||
########################
|
||||
# Clones data from primary node
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# POSTGRESQL_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_clone_primary() {
|
||||
repmgr_info "Cloning data from primary node..."
|
||||
local -r flags=("-h" "$REPMGR_CURRENT_PRIMARY_HOST" "-p" "$REPMGR_PRIMARY_PORT" "-U" "$REPMGR_USERNAME" "-d" "$REPMGR_DATABASE" "-D" "$POSTGRESQL_DATA_DIR" "standby" "clone" "--fast-checkpoint" "--force")
|
||||
|
||||
PGPASSWORD="$REPMGR_PASSWORD" debug_execute "${REPMGR_BIN_DIR}/repmgr" "${flags[@]}"
|
||||
}
|
||||
|
||||
########################
|
||||
# Rejoin node
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_rewind() {
|
||||
repmgr_info "Rejoining node..."
|
||||
|
||||
repmgr_debug "Deleting old data..."
|
||||
rm -rf "$POSTGRESQL_DATA_DIR" && ensure_dir_exists "$POSTGRESQL_DATA_DIR"
|
||||
|
||||
repmgr_debug "Cloning data from primary node..."
|
||||
repmgr_clone_primary
|
||||
}
|
||||
|
||||
########################
|
||||
# Register a node as primary
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_register_primary() {
|
||||
repmgr_info "Registering Primary..."
|
||||
local -r flags=("-f" "$REPMGR_CONF_FILE" "master" "register" "--force")
|
||||
|
||||
debug_execute "${REPMGR_BIN_DIR}/repmgr" "${flags[@]}"
|
||||
}
|
||||
|
||||
########################
|
||||
# Unregister secondary node
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_unregister_standby() {
|
||||
repmgr_info "Unregistering secondary node..."
|
||||
|
||||
echo "DELETE FROM repmgr.nodes WHERE conninfo LIKE '%host=$REPMGR_NODE_NETWORK_NAME%'" | postgresql_execute "$REPMGR_DATABASE" "$REPMGR_USERNAME" "$REPMGR_PASSWORD" "$REPMGR_CURRENT_PRIMARY_HOST" "$REPMGR_PRIMARY_PORT"
|
||||
}
|
||||
|
||||
########################
|
||||
# Resgister a node as secondary
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_register_standby() {
|
||||
repmgr_info "Registering Standby node..."
|
||||
local -r flags=("-f" "$REPMGR_CONF_FILE" "standby" "register" "--force")
|
||||
|
||||
debug_execute "${REPMGR_BIN_DIR}/repmgr" "${flags[@]}"
|
||||
}
|
||||
|
||||
########################
|
||||
# Initialize repmgr service
|
||||
# Globals:
|
||||
# REPMGR_*
|
||||
# Arguments:
|
||||
# None
|
||||
# Returns:
|
||||
# None
|
||||
#########################
|
||||
repmgr_initialize() {
|
||||
repmgr_debug "Node ID: $(repmgr_get_node_id), Rol: $REPMGR_ROLE, Primary Node: $REPMGR_CURRENT_PRIMARY_HOST"
|
||||
repmgr_info "Initializing Repmgr..."
|
||||
|
||||
if [[ "$REPMGR_ROLE" = "standby" ]]; then
|
||||
repmgr_wait_primary_node || exit 1
|
||||
# TODO: better way to detect it's a 1st boot
|
||||
if [[ ! -f "$POSTGRESQL_CONF_FILE" ]] || ! is_boolean_yes "$REPMGR_SWITCH_ROLE"; then
|
||||
repmgr_clone_primary
|
||||
else
|
||||
repmgr_rewind
|
||||
fi
|
||||
fi
|
||||
postgresql_initialize
|
||||
# Allow remote connections, required to register primary and standby nodes
|
||||
postgresql_enable_remote_connections
|
||||
# Configure port and restrict access to PostgreSQL (MD5)
|
||||
postgresql_set_property "port" "$POSTGRESQL_PORT_NUMBER"
|
||||
postgresql_restrict_pghba
|
||||
if [[ "$REPMGR_ROLE" = "primary" ]]; then
|
||||
repmgr_create_repmgr_user
|
||||
repmgr_create_repmgr_db
|
||||
# Restart PostgreSQL
|
||||
postgresql_stop
|
||||
postgresql_start_bg
|
||||
repmgr_register_primary
|
||||
# Allow running custom initialization scripts
|
||||
postgresql_custom_init_scripts
|
||||
else
|
||||
postgresql_start_bg
|
||||
repmgr_unregister_standby
|
||||
repmgr_register_standby
|
||||
fi
|
||||
}
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
#!/bin/bash
|
||||
|
||||
# shellcheck disable=SC1091
|
||||
|
||||
# Load libraries
|
||||
. /libfs.sh
|
||||
. /libpostgresql.sh
|
||||
|
||||
. /librepmgr.sh
|
||||
|
||||
# Load PostgreSQL & repmgr environment variables
|
||||
eval "$(repmgr_env)"
|
||||
eval "$(postgresql_env)"
|
||||
|
||||
for dir in "$POSTGRESQL_INITSCRIPTS_DIR" "$POSTGRESQL_TMP_DIR" "$POSTGRESQL_LOG_DIR" "$POSTGRESQL_CONF_DIR" "${POSTGRESQL_CONF_DIR}/conf.d" "$POSTGRESQL_VOLUME_DIR" "$REPMGR_CONF_DIR" "$REPMGR_TMP_DIR"; do
|
||||
ensure_dir_exists "$dir"
|
||||
chmod -R g+rwX "$dir"
|
||||
done
|
||||
|
||||
# Copying events handlers
|
||||
mv /events "$REPMGR_EVENTS_DIR"
|
||||
chmod +x "$REPMGR_EVENTS_DIR"/router.sh "$REPMGR_EVENTS_DIR"/execs/*sh "$REPMGR_EVENTS_DIR"/execs/includes/*sh
|
||||
|
||||
# Redirect all logging to stdout
|
||||
ln -sf /dev/stdout "$POSTGRESQL_LOG_FILE"
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#!/bin/bash
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
# set -o xtrace # Uncomment this line for debugging purpose
|
||||
# shellcheck disable=SC1091
|
||||
|
||||
# Load libraries
|
||||
. /liblog.sh
|
||||
. /libpostgresql.sh
|
||||
. /librepmgr.sh
|
||||
|
||||
# Load PostgreSQL & repmgr environment variables
|
||||
eval "$(repmgr_env)"
|
||||
eval "$(postgresql_env)"
|
||||
|
||||
readonly repmgr_flags=("--pid-file=$REPMGR_PID_FILE" "-f" "$REPMGR_CONF_FILE" "--daemonize=false")
|
||||
readonly repmgr_cmd=$(command -v repmgrd)
|
||||
|
||||
postgresql_start_bg
|
||||
info "** Starting repmgrd **"
|
||||
# TODO: properly test running the container as root
|
||||
if am_i_root; then
|
||||
exec gosu "$POSTGRESQL_DAEMON_USER" "${repmgr_cmd}" "${repmgr_flags[@]}"
|
||||
else
|
||||
exec "${repmgr_cmd}" "${repmgr_flags[@]}"
|
||||
fi
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#!/bin/bash
|
||||
#
|
||||
# Bitnami PostgreSQL setup
|
||||
|
||||
set -o errexit
|
||||
set -o nounset
|
||||
set -o pipefail
|
||||
#set -o xtrace
|
||||
|
||||
# shellcheck disable=SC1090
|
||||
# shellcheck disable=SC1091
|
||||
|
||||
# Load Libraries
|
||||
. /libpostgresql.sh
|
||||
. /librepmgr.sh
|
||||
|
||||
# Load PostgreSQL & repmgr environment variables
|
||||
eval "$(repmgr_env)"
|
||||
eval "$(postgresql_env)"
|
||||
|
||||
# Ensure PostgreSQL & repmgr environment variables settings are valid
|
||||
repmgr_validate
|
||||
postgresql_validate
|
||||
|
||||
# Set the environment variables for the node's role
|
||||
eval "$(repmgr_set_role)"
|
||||
|
||||
# Ensure PostgreSQL is stopped when this script ends.
|
||||
trap "postgresql_stop" EXIT
|
||||
# Ensure 'daemon' user exists when running as 'root'
|
||||
am_i_root && ensure_user_exists "$POSTGRESQL_DAEMON_USER" "$POSTGRESQL_DAEMON_GROUP"
|
||||
# Prepare PostgreSQL default configuration
|
||||
repmgr_postgresql_configuration
|
||||
# Prepare repmgr configuration
|
||||
repmgr_generate_repmgr_config
|
||||
# Initialize PostgreSQL & repmgr
|
||||
repmgr_initialize
|
||||
|
|
@ -43,9 +43,15 @@ Bitnami containers can be used with [Kubeapps](https://kubeapps.com/) for deploy
|
|||
Learn more about the Bitnami tagging policy and the difference between rolling tags and immutable tags [in our documentation page](https://docs.bitnami.com/containers/how-to/understand-rolling-tags-containers/).
|
||||
|
||||
|
||||
* [`4-ol-7`, `4.0.3-ol-7-r40` (4/ol-7/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/4.0.3-ol-7-r40/4/ol-7/Dockerfile)
|
||||
* [`4-debian-9`, `4.0.3-debian-9-r40`, `4`, `4.0.3`, `4.0.3-r40`, `latest` (4/debian-9/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/4.0.3-debian-9-r40/4/debian-9/Dockerfile)
|
||||
* [`4-centos-7`, `4.0.3-centos-7-r42` (4/centos-7/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/4.0.3-centos-7-r42/4/centos-7/Dockerfile)
|
||||
* [`11-centos-7`, `11.5.0-centos-7-r0` (11/centos-7/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/11.5.0-centos-7-r0/11/centos-7/Dockerfile)
|
||||
* [`10-debian-9`, `10.10.0-debian-9-r0`, `10`, `10.10.0`, `10.10.0-r0` (10/debian-9/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/10.10.0-debian-9-r0/10/debian-9/Dockerfile)
|
||||
* [`9.6-debian-9`, `-debian-9-r0`, `9.6`, ``, `-r0` (9.6/debian-9/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/-debian-9-r0/9.6/debian-9/Dockerfile)
|
||||
* [`11-debian-9`, `-debian-9-r0`, `11`, ``, `-r0`, `latest` (11/debian-9/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/-debian-9-r0/11/debian-9/Dockerfile)
|
||||
* [`10-ol-7`, `-ol-7-r0` (10/ol-7/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/-ol-7-r0/10/ol-7/Dockerfile)
|
||||
* [`11-ol-7`, `-ol-7-r0` (11/ol-7/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/-ol-7-r0/11/ol-7/Dockerfile)
|
||||
* [`9.6-ol-7`, `-ol-7-r0` (9.6/ol-7/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/-ol-7-r0/9.6/ol-7/Dockerfile)
|
||||
* [`9.6-centos-7`, `-centos-7-r0` (9.6/centos-7/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/-centos-7-r0/9.6/centos-7/Dockerfile)
|
||||
* [`10-centos-7`, `-centos-7-r0` (10/centos-7/Dockerfile)](https://github.com/bitnami/bitnami-docker-postgresql-repmgr/blob/-centos-7-r0/10/centos-7/Dockerfile)
|
||||
|
||||
Subscribe to project updates by watching the [bitnami/postgresql-repmgr GitHub repo](https://github.com/bitnami/bitnami-docker-postgresql-repmgr).
|
||||
|
||||
|
|
@ -66,7 +72,7 @@ $ docker pull bitnami/postgresql-repmgr:[TAG]
|
|||
If you wish, you can also build the image yourself.
|
||||
|
||||
```bash
|
||||
$ docker build -t bitnami/postgresql-repmgr:latest 'https://github.com/bitnami/bitnami-docker-postgresql-repmgr.git#master:4/debian-9'
|
||||
$ docker build -t bitnami/postgresql-repmgr:latest 'https://github.com/bitnami/bitnami-docker-postgresql-repmgr.git#master:11/debian-9'
|
||||
```
|
||||
|
||||
# Persisting your application
|
||||
|
|
|
|||
Loading…
Reference in New Issue