Files
qt-migration-legatus/qt6-after/qt6-migrated-legatus/db-manage.sh
T

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 "$@"