PostgresHelper

#!/usr/bin/env bash
. "${BASH_SOURCE[0]%/*}/function.sh" script || exit

usage()
{
	ScriptUsage "$1" "\
Usage: $(ScriptName) dir|info|IsInstalled|IsRunning|patroni|run|service|vars
PostgreSQL datbase server functionality.

	-i,	 --instance=INSTANCE		the instance to use
	-v,	 --version=VERSION			the version to use

	-H,  --host=HOST						the database to use, defaults to localhost
	-db, --database=DATABASE		the database to use, defaults to postgres

	-u,	 --user=USER						the user to use, defaults to postgres
	-p,	 --password=VERSION			the password to use"
}

init()
{
	defaultCommand="run"
	confDirBase="/etc/postgresql"
	dataDirBase="/var/lib/postgresql"
	patroniConf="/etc/patroni/config.yml"
	patroniPortDefault="8008"
	patroniService="patroni"
	postgresPort="5432"
}

argStart()
{
	unset -v binDir confDir dataDir instance version password service;
	user="postgres" host="localhost" database="postgres"
}

opt()
{
	case "$1" in

		--instance|--instance=*|-i|-i=*) ScriptOptGet "instance" "$@";;
		--version|--version=*|-n|-n=*) ScriptOptGet "version" "$@";;

		--user|--user=*|-u|-u=*) ScriptOptGet "user" "$@";;
		--password|--password=*|-p|-p=*) ScriptOptGet "password" "$@";;

		--host|--host=*|-H|-H=*) ScriptOptGet "host" "$@";;
		--database|--database=*|-db|-db=*) ScriptOptGet "database" "$@";;

		*) return 1;;
	esac
}

argEnd()
{	
	export PGHOST="$host"
	export PGDATABASE="$database"
	export PGUSER="$user"
	export PGPASSWORD="$password"
}

#
# commands
#

dirCommand() { findPostgres && echo "$confDir"; }
isInstalledCommand() { [[ -d "$confDirBase" ]]; }
isRunningCommand() { IsAvailablePort localhost "$postgresPort"; }
varsCommand() { findPostgres && ScriptReturn version instance binDir confDir confDirBase dataDir dataDirBase service; }

#
# info command
#

infoUsage() { ScriptUsageEcho "Usage: $(ScriptName) info postgres|patroni"; }

infoCommand()
{	
	infoPostgresCommand || return
	patroniIsInstalled && { patroniInfoCommand || return; }
	return 0;
}

infoPostgresCommand()
{
	findPostgres || return
	local desc; isRunningCommand && desc=" (running)"
	header "PostgreSQL$desc"
	varsCommand || return
	serviceExistsCommand && echo "service=$(serviceStatusCommand)"
	return 0
}

infoPatroniCommand()
{
	patroniValidateInstall || return
	local desc; patroniIsRunningCommand && desc=" (running)"
	header "Patroni$desc"
	echo "patroniConf=$patroniConf"
	echo "port=$(getPatroniPort)"
	patroniServiceExistsCommand && echo "service=$(patroniServiceStatusCommand)"
	[[ $desc ]] && patroniCtrl "topology"
}

#
# run command
#

runArgs() { commandArg="$@"; shift+=$#; }

runCommand()
{
	local args=(); [[ $commandArg ]] && args=(--command "$commandArg")
	getPassword && psql "${args[@]}"
}

#
# patroni commands
#

patroniUsage() { ScriptUsageEcho "Usage: $(ScriptName) patroni ctl|info|start|stop|IsInstalled|IsRunning|service"; }
patroniCommand() { usage; }

patroniInfoCommand() { infoPatroniCommand; }

patroniIsInstalled() { InPath patroni; }
patroniIsRunningCommand() { patroniIsRunning; }
patroniIsRunning() { IsAvailablePort localhost "$(getPatroniPort)"; }

patroniStartCommand()
{
	patroniValidateInstall || return
	patroniIsRunning && { echo "Patroni is already running"; return; }
	( cd "/tmp"; sudoc -u postgres patroni "$patroniConf" )
}

patroniStopCommand()
{
	patroniValidateInstall || return
	! patroniIsRunning && { echo "Patroni is not running"; return; }
	echo "Stopping Patroni..."
	sudoc pkill "patroni"
}

#
# patroni ctl commands
#

patroniCtlArgStart() { patroniCtlArgs=(topology); }
patroniCtlArgEnd() { patroniValidateInstall; }
patroniCtlArgs() { [[ $@ ]] && patroniCtlArgs=( "$@" ); (( shift+=$# )); return 0; }
patroniCtlCommand() { patroniCtrl "${patroniCtlArgs[@]}" "${otherArgs[@]}"; }
patroniCtrl() { CONSUL_HTTP_ADDR= patronictl --config-file "$patroniConf" "$@"; }

#
# patroni service commands
#

patroniServiceUsage() { ScriptUsageEcho "Usage: $(ScriptName) service detail|exists|install|log|restart|running|start|status|stop"; }
patroniServiceCommand() { serviceStatusCommand; }
patroniServiceArgEnd() { patroniValidateInstall; }
patroniServiceDetailCommand() { service detail $patroniService; }
patroniServiceExistsCommand() { service exists $patroniService; }
patroniServiceLogCommand() {	service log $patroniService; }
patroniServiceRestartCommand() { service restart "$patroniService"; }
patroniServiceRunningCommand() { service running "$patroniService"; }
patroniServiceStartCommand() { service start "$patroniService"; }
patroniServiceStatusCommand() { service status "$patroniService"; }
patroniServiceStopCommand() { service stop "$patroniService"; }

#
# patroni helper
#

patroniValidateInstall() { isInstalledCommand && return; ScriptErr "Patroni is not installed"; return 1; }

#
# service commands
#

serviceUsage() { ScriptUsageEcho "Usage: $(ScriptName) service detail|exists|log|restart|running|start|status|stop"; }
serviceArgEnd() { findPostgres; }
serviceCommand() { serviceStatusCommand; }
serviceDetailCommand() { service detail $service; }
serviceExistsCommand() { service exists $service; }
serviceLogCommand() {	LogShow "/var/log/postgresql/postgresql-$version-$instance.log"; }
serviceRestartCommand() { service restart "$service"; }
serviceRunningCommand() { service running "$service"; }
serviceStartCommand() { service start "$service"; }
serviceStatusCommand() { service status "$service"; }
serviceStopCommand() { service stop "$service"; }

#
# helper
#

validateInstall() { isInstalledCommand && return; ScriptErr "PostgreSQL is not installed"; return 1; }

getPassword()
{
	[[ $password ]] && return
	password="$(credential get secure system)" || return
	export PGPASSWORD="$password"
}

getPatroniPort()
{
	[[ $patroniPort ]] && { echo "$patroniPort"; return; }
	[[ -f "$patroniConf" ]] && InPath yq && patroniPort="$(yq ".restapi.listen" "$patroniConf" |& GetUriPort)"
	echo "${patroniPort:-$patroniPortDefault}"
}

findPostgres()
{
	validateInstall || return
	[[ ! $force && $service ]] && return

	# version
	[[ ! $version ]] && version="$(command ls -1 "$confDirBase" | sort --reverse --numeric | head -1)"
	! IsNumeric "$version" && { ScriptErr "PostgreSQL version '$version' is not numeric"; return 1; }
	[[ ! -d "$confDirBase/$version" ]] && { ScriptErr "PostgreSQL version '$version' is not installed"; return 1; }

	# instance
	if [[ ! $instance ]]; then
		if [[ -d "$confDirBase/$version/main" ]]; then instance="main"
		else instance="$(command ls -1 "$confDirBase/$version" | sort | head -1)"
		fi
	fi
	confDir="$confDirBase/$version/$instance"
	[[ ! -d "$confDir" ]] && { ScriptErr "PostgreSQL instance '$instance' is not installed"; return; }

	binDir="/usr/lib/postgresql/$version/bin"
	dataDir="$dataDirBase/$version/$instance"
	service="postgresql@$version-$instance.service"
}

ScriptRun "$@"