Files
qt-migration-legatus/qt6-after/qt6-migrated-legatus/db-manage.sh
T
torsten 15f7add351 Migrate Lts/Tests module to Qt6 with Python 3 port
- Ported all Python scripts from Python 2 to Python 3
- Created db-manage.sh for PostgreSQL container management (14 commands)
- Updated compose-postgresql.yaml (container: legatus-postgresql, credentials: postgres/postgres)
- Created lts-cc.conf template for database configuration
- Added CMakeLists.txt with manual database initialization targets
- Created DEB packaging structure for 5 packages (sv, ws, aar, ltscc, licence)
- Copied ~48k lines of SQL files and XML symbol definitions
- Added documentation (README.md, README.python3.md, MIGRATION_REPORT)

Validation:
- PostgreSQL container starts successfully
- Database initialization tested (guez_pro created)
- Group 2 build: 97% tests passed (654/677)
2026-11-20 17:28:17 +01:00

517 lines
13 KiB
Bash
Executable File

#!/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}"
# Install Python3 in container temporarily and execute create_excon_db.py
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
log_info "Installing Python3 in container (temporary)..."
docker exec "${CONTAINER_NAME}" apt-get update -qq >/dev/null 2>&1 || true
docker exec "${CONTAINER_NAME}" apt-get install -y -qq python3 >/dev/null 2>&1 || {
log_warn "Could not install python3, using direct SQL execution instead"
# Fallback: execute SQL files directly
cmd_init_db_sql "${project}"
return $?
}
# 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}"
return 1
;;
esac
log_info "Executing create_excon_db.py ${db_args}..."
# Copy script to container
docker cp "${script_path}" "${CONTAINER_NAME}:/tmp/create_excon_db.py"
docker exec "${CONTAINER_NAME}" chmod +x /tmp/create_excon_db.py
# Copy lts-cc.conf if exists
local config_arg=""
if [ -f "${LTS_CC_CONF}" ]; then
docker cp "${LTS_CC_CONF}" "${CONTAINER_NAME}:/tmp/lts-cc.conf"
config_arg="-c /tmp/lts-cc.conf"
fi
# Copy SQL files to container
local sql_dir="${SCRIPT_DIR}/Lts/Tests/DatabaseInitialisation"
docker exec "${CONTAINER_NAME}" mkdir -p /tmp/sql
for f in "${sql_dir}"/*.sql; do
if [ -f "$f" ]; then
docker cp "$f" "${CONTAINER_NAME}:/tmp/sql/"
fi
done
# Execute create_excon_db.py in container
docker exec -w /tmp "${CONTAINER_NAME}" python3 /tmp/create_excon_db.py ${db_args} ${config_arg} -b /tmp
log_info "Database initialization completed for project: ${project}"
}
# Fallback: Initialize database by executing SQL files directly
cmd_init_db_sql() {
local project="${1:-}"
local sql_dir="${SCRIPT_DIR}/Lts/Tests/DatabaseInitialisation"
log_info "Executing SQL files directly for project: ${project}"
# List of base SQL files to execute
local base_files=(
"init_db_users_grants.sql"
"init_db_procedures.sql"
"init_db_schemas.sql"
)
# Project-specific files
local project_files=()
case "${project}" in
guez)
project_files=(
"guez_ppm_values_types.sql"
"guez_ppm_values_templates.sql"
"guez_pdm_values.sql"
"guez_pdm_values_translation.sql"
"guez_opm_values_initial.sql"
"guez_opm_values.sql"
"guez_flm_symbols.sql"
"guez_update_flm_used_by.sql"
)
;;
ahtc)
project_files=(
"ahtc_ppm_values_types.sql"
"ahtc_ppm_values_templates.sql"
"ahtc_pdm_values.sql"
"ahtc_opm_values.sql"
"ahtc_flm_symbols.sql"
)
;;
*)
log_warn "Direct SQL execution not fully implemented for ${project}"
return 1
;;
esac
# Execute base files
for f in "${base_files[@]}"; do
if [ -f "${sql_dir}/${f}" ]; then
log_info "Executing: ${f}"
docker exec -i "${CONTAINER_NAME}" psql -U postgres -d lts_ets_pro -f "/tmp/sql/${f}" 2>&1 | head -5
fi
done
# Execute project files
for f in "${project_files[@]}"; do
if [ -f "${sql_dir}/${f}" ]; then
log_info "Executing: ${f}"
docker exec -i "${CONTAINER_NAME}" psql -U postgres -d lts_ets_pro -f "/tmp/sql/${f}" 2>&1 | head -5
else
log_warn "SQL file not found: ${f}"
fi
done
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 "$@"