455 lines
11 KiB
Bash
455 lines
11 KiB
Bash
#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
|
|
# -----------------------------------------------------------------------------
|
|
# db-manage.sh - PostgreSQL Container Management for Legatus Qt6 Migration
|
|
#
|
|
# Features:
|
|
# - Start/stop/restart PostgreSQL container via compose-postgresql.yaml
|
|
# - Database initialization via create_excon_db.py
|
|
# - Backup/restore functionality
|
|
# - Logs, status, prune commands
|
|
# -----------------------------------------------------------------------------
|
|
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
COMPOSE_FILE="$(cd "${SCRIPT_DIR}/../../../scripts" && pwd)/compose-postgresql.yaml"
|
|
LTS_CC_CONF="${SCRIPT_DIR}/lts-cc.conf"
|
|
DB_SCRIPTS_DIR="${SCRIPT_DIR}/db-scripts"
|
|
CONTAINER_NAME="legatus-postgresql"
|
|
|
|
# Default credentials
|
|
DB_USER="${DB_USER:-postgres}"
|
|
DB_PASSWORD="${DB_PASSWORD:-postgres}"
|
|
DB_NAME="${DB_NAME:-lts_ets_pro}"
|
|
DB_HOST="localhost"
|
|
DB_PORT="5432"
|
|
|
|
# Colors for output
|
|
RED='\033[0;31m'
|
|
GREEN='\033[0;32m'
|
|
YELLOW='\033[1;33m'
|
|
NC='\033[0m' # No Color
|
|
|
|
usage() {
|
|
cat <<EOF
|
|
Usage: $(basename "$0") <command> [options]
|
|
|
|
Commands:
|
|
start Start PostgreSQL container
|
|
stop Stop PostgreSQL container
|
|
restart Restart PostgreSQL container
|
|
status Show container status
|
|
logs Show Docker logs
|
|
prune Clean up old containers/volumes
|
|
show-config Display lts-cc.conf content
|
|
init-db <project> Initialize database (guez|ahtc|qatar|l400p2|demo|commaster|test-db)
|
|
list-dbs List available databases
|
|
drop-db <database> Drop specified database
|
|
psql <database> Open psql shell for specified database
|
|
backup <database> Create database backup
|
|
restore <database> <file> Restore database from backup file
|
|
|
|
Environment Variables:
|
|
DB_USER Database user (default: postgres)
|
|
DB_PASSWORD Database password (default: postgres)
|
|
DB_NAME Database name (default: lts_ets_pro)
|
|
|
|
Examples:
|
|
$(basename "$0") start
|
|
$(basename "$0") init-db guez
|
|
$(basename "$0") init-db test-db
|
|
$(basename "$0") psql guez
|
|
$(basename "$0") backup guez
|
|
$(basename "$0") restore guez /path/to/backup.sql
|
|
EOF
|
|
}
|
|
|
|
log_info() {
|
|
echo -e "${GREEN}[INFO]${NC} $1"
|
|
}
|
|
|
|
log_warn() {
|
|
echo -e "${YELLOW}[WARN]${NC} $1"
|
|
}
|
|
|
|
log_error() {
|
|
echo -e "${RED}[ERROR]${NC} $1"
|
|
}
|
|
|
|
# Check if container is running
|
|
is_container_running() {
|
|
docker inspect -f '{{.State.Running}}' "${CONTAINER_NAME}" 2>/dev/null | grep -q "true"
|
|
}
|
|
|
|
# Check if container exists
|
|
container_exists() {
|
|
docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"
|
|
}
|
|
|
|
# Start PostgreSQL container
|
|
cmd_start() {
|
|
log_info "Starting PostgreSQL container..."
|
|
|
|
if is_container_running; then
|
|
log_warn "Container ${CONTAINER_NAME} is already running"
|
|
return 0
|
|
fi
|
|
|
|
if container_exists; then
|
|
log_info "Starting existing container..."
|
|
docker start "${CONTAINER_NAME}"
|
|
else
|
|
log_info "Creating and starting new container..."
|
|
docker compose -f "${COMPOSE_FILE}" up -d
|
|
fi
|
|
|
|
# Wait for PostgreSQL to be ready
|
|
log_info "Waiting for PostgreSQL to be ready..."
|
|
local max_attempts=30
|
|
local attempt=0
|
|
while ! docker exec "${CONTAINER_NAME}" pg_isready -U "${DB_USER}" -d "${DB_NAME}" >/dev/null 2>&1; do
|
|
attempt=$((attempt + 1))
|
|
if [ $attempt -ge $max_attempts ]; then
|
|
log_error "PostgreSQL did not start within ${max_attempts} seconds"
|
|
return 1
|
|
fi
|
|
sleep 1
|
|
done
|
|
|
|
log_info "PostgreSQL container started successfully"
|
|
}
|
|
|
|
# Stop PostgreSQL container
|
|
cmd_stop() {
|
|
log_info "Stopping PostgreSQL container..."
|
|
|
|
if ! container_exists; then
|
|
log_warn "Container ${CONTAINER_NAME} does not exist"
|
|
return 0
|
|
fi
|
|
|
|
docker stop "${CONTAINER_NAME}"
|
|
log_info "PostgreSQL container stopped"
|
|
}
|
|
|
|
# Restart PostgreSQL container
|
|
cmd_restart() {
|
|
log_info "Restarting PostgreSQL container..."
|
|
cmd_stop
|
|
sleep 2
|
|
cmd_start
|
|
}
|
|
|
|
# Show container status
|
|
cmd_status() {
|
|
if ! container_exists; then
|
|
log_warn "Container ${CONTAINER_NAME} does not exist"
|
|
return 1
|
|
fi
|
|
|
|
echo "Container Status:"
|
|
docker ps -a --filter "name=${CONTAINER_NAME}" --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
|
|
|
|
echo ""
|
|
echo "PostgreSQL Connection:"
|
|
if is_container_running; then
|
|
if docker exec "${CONTAINER_NAME}" pg_isready -U "${DB_USER}" -d "${DB_NAME}" >/dev/null 2>&1; then
|
|
log_info "PostgreSQL is accepting connections"
|
|
else
|
|
log_warn "PostgreSQL is not accepting connections"
|
|
fi
|
|
else
|
|
log_warn "Container is not running"
|
|
fi
|
|
}
|
|
|
|
# Show Docker logs
|
|
cmd_logs() {
|
|
if ! container_exists; then
|
|
log_warn "Container ${CONTAINER_NAME} does not exist"
|
|
return 1
|
|
fi
|
|
|
|
docker logs "${CONTAINER_NAME}" "${@:-}"
|
|
}
|
|
|
|
# Prune old containers and volumes
|
|
cmd_prune() {
|
|
log_info "Cleaning up old containers and volumes..."
|
|
|
|
# Remove stopped containers
|
|
docker container prune -f
|
|
|
|
# Remove unused volumes (except pg18_data)
|
|
docker volume prune -f --filter "label!=com.docker.compose.volume=pg18_data"
|
|
|
|
log_info "Cleanup completed"
|
|
}
|
|
|
|
# Show lts-cc.conf content
|
|
cmd_show_config() {
|
|
if [ ! -f "${LTS_CC_CONF}" ]; then
|
|
log_error "lts-cc.conf not found at ${LTS_CC_CONF}"
|
|
return 1
|
|
fi
|
|
|
|
log_info "Content of lts-cc.conf:"
|
|
echo "---"
|
|
cat "${LTS_CC_CONF}"
|
|
echo "---"
|
|
}
|
|
|
|
# Initialize database
|
|
cmd_init_db() {
|
|
local project="${1:-}"
|
|
|
|
if [ -z "${project}" ]; then
|
|
log_error "Project name required (guez|ahtc|qatar|l400p2|demo|commaster|test-db)"
|
|
return 1
|
|
fi
|
|
|
|
if ! is_container_running; then
|
|
log_error "PostgreSQL container is not running. Run '$(basename "$0") start' first."
|
|
return 1
|
|
fi
|
|
|
|
log_info "Initializing database for project: ${project}"
|
|
|
|
# Determine create_excon_db.py arguments
|
|
local db_args=""
|
|
case "${project}" in
|
|
guez)
|
|
db_args="-p guez"
|
|
;;
|
|
ahtc)
|
|
db_args="-p ahtc"
|
|
;;
|
|
qatar)
|
|
db_args="-p qatar"
|
|
;;
|
|
l400p2)
|
|
db_args="-p l400p2"
|
|
;;
|
|
demo)
|
|
db_args="-p demo"
|
|
;;
|
|
commaster)
|
|
db_args="-p commaster"
|
|
;;
|
|
test-db)
|
|
db_args="-p guez -e"
|
|
;;
|
|
*)
|
|
log_error "Unknown project: ${project}"
|
|
log_info "Valid projects: guez, ahtc, qatar, l400p2, demo, commaster, test-db"
|
|
return 1
|
|
;;
|
|
esac
|
|
|
|
# Find create_excon_db.py script
|
|
local script_path="${SCRIPT_DIR}/Lts/Tests/DatabaseInitialisation/create_excon_db.py"
|
|
|
|
if [ ! -f "${script_path}" ]; then
|
|
log_error "create_excon_db.py not found at ${script_path}"
|
|
return 1
|
|
fi
|
|
|
|
# Copy script to container and execute
|
|
log_info "Executing create_excon_db.py ${db_args}..."
|
|
|
|
docker exec -i "${CONTAINER_NAME}" /bin/bash -c "cat > /tmp/create_excon_db.py && chmod +x /tmp/create_excon_db.py" < "${script_path}"
|
|
|
|
# Read lts-cc.conf for database configuration
|
|
if [ -f "${LTS_CC_CONF}" ]; then
|
|
local db_host db_name
|
|
db_host=$(grep -E "^DatabaseHostName=" "${LTS_CC_CONF}" | cut -d'=' -f2)
|
|
db_name=$(grep -E "^DatabaseName=" "${LTS_CC_CONF}" | cut -d'=' -f2)
|
|
|
|
# Execute with config file
|
|
docker exec -i "${CONTAINER_NAME}" /bin/bash -c "
|
|
cat > /tmp/lts-cc.conf
|
|
cat > /tmp/create_excon_db.py && chmod +x /tmp/create_excon_db.py
|
|
cd /tmp && python3 /tmp/create_excon_db.py ${db_args} -c /tmp/lts-cc.conf -b /tmp
|
|
" < "${LTS_CC_CONF}"
|
|
else
|
|
# Execute without config file (uses defaults)
|
|
docker exec "${CONTAINER_NAME}" python3 /tmp/create_excon_db.py ${db_args}
|
|
fi
|
|
|
|
log_info "Database initialization completed for project: ${project}"
|
|
}
|
|
|
|
# List databases
|
|
cmd_list_dbs() {
|
|
if ! is_container_running; then
|
|
log_error "PostgreSQL container is not running"
|
|
return 1
|
|
fi
|
|
|
|
log_info "Available databases:"
|
|
docker exec "${CONTAINER_NAME}" psql -U "${DB_USER}" -lqt 2>/dev/null | cut -d'|' -f1 | grep -v '^$' | sort
|
|
}
|
|
|
|
# Drop database
|
|
cmd_drop_db() {
|
|
local database="${1:-}"
|
|
|
|
if [ -z "${database}" ]; then
|
|
log_error "Database name required"
|
|
return 1
|
|
fi
|
|
|
|
if ! is_container_running; then
|
|
log_error "PostgreSQL container is not running"
|
|
return 1
|
|
fi
|
|
|
|
log_warn "Dropping database: ${database}"
|
|
read -p "Are you sure? (y/N): " confirm
|
|
if [[ ! "${confirm}" =~ ^[Yy]$ ]]; then
|
|
log_info "Aborted"
|
|
return 0
|
|
fi
|
|
|
|
docker exec "${CONTAINER_NAME}" psql -U "${DB_USER}" -d "${DB_NAME}" -c "DROP DATABASE IF EXISTS ${database};"
|
|
log_info "Database ${database} dropped"
|
|
}
|
|
|
|
# Open psql shell
|
|
cmd_psql() {
|
|
local database="${1:-${DB_NAME}}"
|
|
|
|
if ! is_container_running; then
|
|
log_error "PostgreSQL container is not running"
|
|
return 1
|
|
fi
|
|
|
|
log_info "Opening psql shell for database: ${database}"
|
|
docker exec -it "${CONTAINER_NAME}" psql -U "${DB_USER}" -d "${database}"
|
|
}
|
|
|
|
# Backup database
|
|
cmd_backup() {
|
|
local database="${1:-}"
|
|
|
|
if [ -z "${database}" ]; then
|
|
log_error "Database name required"
|
|
return 1
|
|
fi
|
|
|
|
if ! is_container_running; then
|
|
log_error "PostgreSQL container is not running"
|
|
return 1
|
|
fi
|
|
|
|
local backup_dir="${SCRIPT_DIR}/backups"
|
|
mkdir -p "${backup_dir}"
|
|
|
|
local timestamp
|
|
timestamp=$(date +"%Y%m%d_%H%M%S")
|
|
local backup_file="${backup_dir}/${database}_${timestamp}.sql"
|
|
|
|
log_info "Creating backup of database: ${database}"
|
|
docker exec "${CONTAINER_NAME}" pg_dump -U "${DB_USER}" -d "${database}" > "${backup_file}"
|
|
|
|
log_info "Backup created: ${backup_file}"
|
|
}
|
|
|
|
# Restore database
|
|
cmd_restore() {
|
|
local database="${1:-}"
|
|
local backup_file="${2:-}"
|
|
|
|
if [ -z "${database}" ]; then
|
|
log_error "Database name required"
|
|
return 1
|
|
fi
|
|
|
|
if [ -z "${backup_file}" ]; then
|
|
log_error "Backup file required"
|
|
return 1
|
|
fi
|
|
|
|
if [ ! -f "${backup_file}" ]; then
|
|
log_error "Backup file not found: ${backup_file}"
|
|
return 1
|
|
fi
|
|
|
|
if ! is_container_running; then
|
|
log_error "PostgreSQL container is not running"
|
|
return 1
|
|
fi
|
|
|
|
log_warn "Restoring database ${database} from ${backup_file}"
|
|
read -p "Are you sure? This will overwrite existing data. (y/N): " confirm
|
|
if [[ ! "${confirm}" =~ ^[Yy]$ ]]; then
|
|
log_info "Aborted"
|
|
return 0
|
|
fi
|
|
|
|
cat "${backup_file}" | docker exec -i "${CONTAINER_NAME}" psql -U "${DB_USER}" -d "${database}"
|
|
|
|
log_info "Database ${database} restored from ${backup_file}"
|
|
}
|
|
|
|
# Main command dispatcher
|
|
main() {
|
|
local command="${1:-}"
|
|
shift || true
|
|
|
|
case "${command}" in
|
|
start)
|
|
cmd_start
|
|
;;
|
|
stop)
|
|
cmd_stop
|
|
;;
|
|
restart)
|
|
cmd_restart
|
|
;;
|
|
status)
|
|
cmd_status
|
|
;;
|
|
logs)
|
|
cmd_logs "$@"
|
|
;;
|
|
prune)
|
|
cmd_prune
|
|
;;
|
|
show-config)
|
|
cmd_show_config
|
|
;;
|
|
init-db)
|
|
cmd_init_db "$@"
|
|
;;
|
|
list-dbs)
|
|
cmd_list_dbs
|
|
;;
|
|
drop-db)
|
|
cmd_drop_db "$@"
|
|
;;
|
|
psql)
|
|
cmd_psql "$@"
|
|
;;
|
|
backup)
|
|
cmd_backup "$@"
|
|
;;
|
|
restore)
|
|
cmd_restore "$@"
|
|
;;
|
|
-h|--help|help)
|
|
usage
|
|
;;
|
|
"")
|
|
usage
|
|
exit 1
|
|
;;
|
|
*)
|
|
log_error "Unknown command: ${command}"
|
|
usage
|
|
exit 1
|
|
;;
|
|
esac
|
|
}
|
|
|
|
main "$@" |