679 lines
20 KiB
Bash
Executable File
679 lines
20 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
set -euo pipefail
|
|
|
|
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
|
|
cd "$SCRIPT_DIR"
|
|
|
|
ENV_FILE="$SCRIPT_DIR/.docker-build.env"
|
|
APP_IMAGE_REPO="git.invario-software.eu/invario/inventarsystem"
|
|
DIST_DIR="$SCRIPT_DIR/dist"
|
|
RUNTIME_COMPOSE_OVERRIDE_FILE="$SCRIPT_DIR/.docker-compose.runtime.override.yml"
|
|
|
|
SUDO=""
|
|
if [ "$(id -u)" -ne 0 ] && command -v sudo >/dev/null 2>&1; then
|
|
SUDO="sudo"
|
|
fi
|
|
|
|
IS_ROOT="false"
|
|
if [ "$(id -u)" -eq 0 ]; then
|
|
IS_ROOT="true"
|
|
fi
|
|
|
|
NUITKA_BUILD_VALUE="0"
|
|
HTTP_PORT_VALUE="10000"
|
|
HTTP_PORTS_VALUE=""
|
|
DEFAULT_TENANT_PORT_START="${INVENTAR_TENANT_PORT_START:-10000}"
|
|
CRON_SETUP_VALUE="${INVENTAR_SETUP_CRON:-1}"
|
|
APP_IMAGE_VALUE="${INVENTAR_APP_IMAGE:-$APP_IMAGE_REPO:latest}"
|
|
COMPOSE_FILE="docker-compose-multitenant.yml"
|
|
COMPOSE_PROFILES_VALUE=""
|
|
MIN_DOCKER_FREE_MB="${INVENTAR_MIN_DOCKER_FREE_MB:-1024}"
|
|
|
|
usage() {
|
|
cat <<EOF
|
|
Usage: $0 [options]
|
|
|
|
Options:
|
|
--no-cron Do not create or update cron jobs
|
|
--with-cron Create/update cron jobs (default)
|
|
--multitenant Use the multi-tenant architecture deployment
|
|
-h, --help Show this help message
|
|
EOF
|
|
}
|
|
|
|
parse_args() {
|
|
while [[ $# -gt 0 ]]; do
|
|
case "$1" in
|
|
--no-cron)
|
|
CRON_SETUP_VALUE="0"
|
|
shift
|
|
;;
|
|
--with-cron)
|
|
CRON_SETUP_VALUE="1"
|
|
shift
|
|
;;
|
|
--multitenant)
|
|
COMPOSE_FILE="docker-compose-multitenant.yml"
|
|
shift
|
|
;;
|
|
-h|--help)
|
|
usage
|
|
exit 0
|
|
;;
|
|
*)
|
|
echo "Error: unknown option '$1'"
|
|
usage
|
|
exit 2
|
|
;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
cron_setup_enabled() {
|
|
case "${CRON_SETUP_VALUE,,}" in
|
|
0|false|no|off)
|
|
return 1
|
|
;;
|
|
*)
|
|
return 0
|
|
;;
|
|
esac
|
|
}
|
|
|
|
apt_install() {
|
|
$SUDO apt-get update -y
|
|
$SUDO env DEBIAN_FRONTEND=noninteractive apt-get install -y "$@"
|
|
}
|
|
|
|
install_docker_engine() {
|
|
if command -v docker >/dev/null 2>&1; then
|
|
return 0
|
|
fi
|
|
|
|
echo "Docker not found. Trying distro package docker.io..."
|
|
if apt_install docker.io; then
|
|
return 0
|
|
fi
|
|
|
|
echo "docker.io install failed. Trying Docker CE package docker-ce..."
|
|
apt_install ca-certificates curl gnupg lsb-release
|
|
|
|
$SUDO install -m 0755 -d /etc/apt/keyrings
|
|
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | $SUDO gpg --dearmor -o /etc/apt/keyrings/docker.gpg
|
|
$SUDO chmod a+r /etc/apt/keyrings/docker.gpg
|
|
|
|
echo \
|
|
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
|
|
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
|
|
$SUDO tee /etc/apt/sources.list.d/docker.list >/dev/null
|
|
|
|
$SUDO apt-get update -y
|
|
$SUDO env DEBIAN_FRONTEND=noninteractive apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
|
|
}
|
|
|
|
ensure_runtime_dependencies() {
|
|
local missing=()
|
|
|
|
if ! command -v docker >/dev/null 2>&1; then
|
|
if [ "$IS_ROOT" = "true" ]; then
|
|
install_docker_engine
|
|
else
|
|
missing+=(docker)
|
|
fi
|
|
fi
|
|
|
|
if ! docker compose version >/dev/null 2>&1; then
|
|
missing+=(docker-compose-v2)
|
|
fi
|
|
|
|
if ! command -v openssl >/dev/null 2>&1; then
|
|
missing+=(openssl)
|
|
fi
|
|
|
|
if ! command -v curl >/dev/null 2>&1; then
|
|
missing+=(curl)
|
|
fi
|
|
|
|
if ! command -v python3 >/dev/null 2>&1; then
|
|
missing+=(python3)
|
|
fi
|
|
|
|
if cron_setup_enabled && ! command -v crontab >/dev/null 2>&1; then
|
|
missing+=(cron)
|
|
fi
|
|
|
|
if [ "${#missing[@]}" -gt 0 ]; then
|
|
if [ "$IS_ROOT" = "true" ]; then
|
|
echo "Installing missing dependencies: ${missing[*]}"
|
|
apt_install "${missing[@]}"
|
|
else
|
|
echo "ERROR: Missing dependencies: ${missing[*]}"
|
|
echo "Please install the missing tools or run this script as root."
|
|
exit 1
|
|
fi
|
|
fi
|
|
|
|
if [ "$IS_ROOT" = "true" ] && command -v systemctl >/dev/null 2>&1; then
|
|
systemctl enable --now docker >/dev/null 2>&1 || true
|
|
if cron_setup_enabled; then
|
|
systemctl enable --now cron >/dev/null 2>&1 || true
|
|
fi
|
|
fi
|
|
}
|
|
|
|
setup_boot_autostart_service() {
|
|
local service_path
|
|
local service_name="inventarsystem-docker.service"
|
|
|
|
if [ "${INVENTAR_SKIP_AUTOSTART_SETUP:-0}" = "1" ]; then
|
|
return 0
|
|
fi
|
|
|
|
if [ "$IS_ROOT" != "true" ]; then
|
|
echo "Skipping systemd autostart setup when not running as root."
|
|
return 0
|
|
fi
|
|
|
|
if ! command -v systemctl >/dev/null 2>&1; then
|
|
return 0
|
|
fi
|
|
|
|
service_path="/etc/systemd/system/$service_name"
|
|
|
|
if [ ! -f "$service_path" ] || ! grep -Fq "$SCRIPT_DIR/start.sh --no-cron" "$service_path"; then
|
|
$SUDO tee "$service_path" >/dev/null <<EOF
|
|
[Unit]
|
|
Description=Inventarsystem Docker Stack Autostart
|
|
Requires=docker.service
|
|
After=docker.service network-online.target
|
|
Wants=network-online.target
|
|
RequiresMountsFor=$SCRIPT_DIR
|
|
|
|
[Service]
|
|
Type=oneshot
|
|
RemainAfterExit=yes
|
|
WorkingDirectory=$SCRIPT_DIR
|
|
Environment=INVENTAR_SKIP_AUTOSTART_SETUP=1
|
|
Environment=INVENTAR_SETUP_CRON=0
|
|
ExecStart=/bin/bash "$SCRIPT_DIR/start.sh" --no-cron
|
|
ExecStop=/bin/bash "$SCRIPT_DIR/stop.sh"
|
|
TimeoutStartSec=0
|
|
|
|
[Install]
|
|
WantedBy=multi-user.target
|
|
EOF
|
|
|
|
$SUDO systemctl daemon-reload
|
|
fi
|
|
|
|
$SUDO systemctl enable "$service_name" >/dev/null 2>&1 || true
|
|
}
|
|
|
|
setup_scheduled_jobs() {
|
|
if ! cron_setup_enabled; then
|
|
echo "Cron job setup disabled (INVENTAR_SETUP_CRON=$CRON_SETUP_VALUE)"
|
|
return 0
|
|
fi
|
|
|
|
if [ "$IS_ROOT" != "true" ]; then
|
|
echo "Skipping cron job setup when not running as root."
|
|
return 0
|
|
fi
|
|
|
|
if ! command -v crontab >/dev/null 2>&1; then
|
|
echo "Warning: crontab not available, skipping nightly update setup"
|
|
return 0
|
|
fi
|
|
|
|
local update_line backup_line
|
|
update_line="0 3 * * * cd $SCRIPT_DIR && ./update.sh >> $SCRIPT_DIR/logs/update.log 2>&1"
|
|
backup_line="30 2 * * * cd $SCRIPT_DIR && ./backup.sh --mode auto >> $SCRIPT_DIR/logs/backup.log 2>&1"
|
|
|
|
local existing_cron
|
|
existing_cron="$(crontab -l 2>/dev/null || true)"
|
|
{
|
|
printf '%s\n' "$existing_cron" | grep -vF "$SCRIPT_DIR/update.sh" | grep -vF "$SCRIPT_DIR/backup-docker.sh" | grep -vF "$SCRIPT_DIR/backup.sh" || true
|
|
echo "$backup_line"
|
|
echo "$update_line"
|
|
} | crontab -
|
|
|
|
echo "Nightly backup scheduled at 02:30"
|
|
echo "Nightly auto-update scheduled at 03:00"
|
|
}
|
|
|
|
ensure_runtime_config_json() {
|
|
local config_path backup_path
|
|
config_path="$SCRIPT_DIR/config.json"
|
|
|
|
if [ -d "$config_path" ]; then
|
|
backup_path="${config_path}.dir.$(date +%Y%m%d-%H%M%S).bak"
|
|
mv "$config_path" "$backup_path"
|
|
echo "Warning: moved unexpected directory $config_path to $backup_path"
|
|
fi
|
|
|
|
if [ ! -f "$config_path" ]; then
|
|
cat > "$config_path" <<'EOF'
|
|
{
|
|
"ver": "2.6.5",
|
|
"dbg": false,
|
|
"host": "0.0.0.0",
|
|
"port": 8000,
|
|
"mongodb": {
|
|
"host": "mongodb",
|
|
"port": 27017,
|
|
"db": "Inventarsystem"
|
|
},
|
|
"modules": {
|
|
"library": {
|
|
"enabled": false
|
|
},
|
|
"student_cards": {
|
|
"enabled": false,
|
|
"default_borrow_days": 14,
|
|
"max_borrow_days": 365
|
|
}
|
|
}
|
|
}
|
|
EOF
|
|
echo "Created default runtime config at $config_path"
|
|
fi
|
|
}
|
|
|
|
ensure_app_image_loaded() {
|
|
if docker image inspect "$APP_IMAGE_VALUE" >/dev/null 2>&1; then
|
|
return 0
|
|
fi
|
|
|
|
local image_archive
|
|
image_archive="$(find_local_dist_image_archive || true)"
|
|
if [ -n "$image_archive" ]; then
|
|
echo "Loading app image from local dist artifact: $image_archive"
|
|
if docker load -i "$image_archive" >/dev/null 2>&1 && docker image inspect "$APP_IMAGE_VALUE" >/dev/null 2>&1; then
|
|
return 0
|
|
fi
|
|
echo "Warning: failed to load expected app image from $image_archive"
|
|
fi
|
|
|
|
echo "Error: local app image not found: $APP_IMAGE_VALUE"
|
|
echo "Run ./update.sh so the nightly updater loads the release image first."
|
|
exit 1
|
|
}
|
|
|
|
find_local_dist_image_archive() {
|
|
local tag archive
|
|
|
|
if [ ! -d "$DIST_DIR" ]; then
|
|
return 1
|
|
fi
|
|
|
|
tag="${APP_IMAGE_VALUE##*:}"
|
|
for archive in \
|
|
"$DIST_DIR/inventarsystem-image-$tag.tar.gz" \
|
|
"$DIST_DIR/inventarsystem-image-$tag.tar" \
|
|
"$DIST_DIR/inventarsystem-image.tar.gz" \
|
|
"$DIST_DIR/inventarsystem-image.tar"; do
|
|
if [ -f "$archive" ]; then
|
|
echo "$archive"
|
|
return 0
|
|
fi
|
|
done
|
|
|
|
archive="$(find "$DIST_DIR" -maxdepth 1 -type f \( -name 'inventarsystem-image-*.tar.gz' -o -name 'inventarsystem-image-*.tar' \) | sort | tail -n1)"
|
|
if [ -n "$archive" ]; then
|
|
echo "$archive"
|
|
return 0
|
|
fi
|
|
|
|
return 1
|
|
}
|
|
|
|
configure_nuitka_mode() {
|
|
local nuitka_mode
|
|
|
|
if [ "${NUITKA_SERVICE:-false}" = "true" ]; then
|
|
nuitka_mode="1"
|
|
else
|
|
nuitka_mode="0"
|
|
fi
|
|
|
|
if [ -f "$ENV_FILE" ] && [ -z "${NUITKA_SERVICE+x}" ]; then
|
|
nuitka_mode="$(awk -F= '/^NUITKA_BUILD=/{print $2}' "$ENV_FILE" | tr -d ' ' || true)"
|
|
if [ -z "$nuitka_mode" ]; then
|
|
nuitka_mode="0"
|
|
fi
|
|
fi
|
|
|
|
NUITKA_BUILD_VALUE="$nuitka_mode"
|
|
|
|
if [ "$nuitka_mode" = "1" ]; then
|
|
echo "Nuitka service mode: enabled (compiled app module)"
|
|
else
|
|
echo "Nuitka service mode: disabled (standard Python app module)"
|
|
fi
|
|
}
|
|
|
|
resolve_app_image() {
|
|
local env_image="" release_tag="" default_latest
|
|
default_latest="$APP_IMAGE_REPO:latest"
|
|
|
|
if [ -f "$ENV_FILE" ]; then
|
|
env_image="$(awk -F= '/^INVENTAR_APP_IMAGE=/{print $2}' "$ENV_FILE" | tail -n1 | tr -d ' ' || true)"
|
|
if [ -n "$env_image" ] && [ "$env_image" != "$default_latest" ]; then
|
|
APP_IMAGE_VALUE="$env_image"
|
|
return 0
|
|
fi
|
|
fi
|
|
|
|
if [ -f "$SCRIPT_DIR/.release-version" ]; then
|
|
release_tag="$(tr -d '[:space:]' < "$SCRIPT_DIR/.release-version")"
|
|
fi
|
|
|
|
if [ -n "$release_tag" ]; then
|
|
APP_IMAGE_VALUE="$APP_IMAGE_REPO:$release_tag"
|
|
return 0
|
|
fi
|
|
|
|
if [ -n "$env_image" ]; then
|
|
APP_IMAGE_VALUE="$env_image"
|
|
fi
|
|
}
|
|
|
|
port_in_use() {
|
|
local port="$1"
|
|
|
|
if ! command -v ss >/dev/null 2>&1; then
|
|
return 1
|
|
fi
|
|
|
|
ss -ltn "( sport = :$port )" 2>/dev/null | awk 'NR>1 {print $4}' | grep -q .
|
|
}
|
|
|
|
find_free_port() {
|
|
local port="$1"
|
|
while port_in_use "$port"; do
|
|
port=$((port + 1))
|
|
done
|
|
echo "$port"
|
|
}
|
|
|
|
parse_port_list() {
|
|
local raw="$1"
|
|
local port
|
|
local ports=()
|
|
raw="${raw//,/ }"
|
|
for port in $raw; do
|
|
port="${port//[[:space:]]/}"
|
|
if [ -n "$port" ] && printf '%s\n' "$port" | grep -qE '^[0-9]+$'; then
|
|
ports+=("$port")
|
|
fi
|
|
done
|
|
printf '%s\n' "${ports[@]}"
|
|
}
|
|
|
|
configure_host_ports() {
|
|
local requested_http
|
|
local requested_ports
|
|
local ports=()
|
|
local occupied_ports=()
|
|
|
|
requested_http=""
|
|
requested_ports=""
|
|
if [ -f "$ENV_FILE" ]; then
|
|
requested_http="$(awk -F= '/^INVENTAR_HTTP_PORT=/{print $2}' "$ENV_FILE" | tr -d ' ' || true)"
|
|
requested_ports="$(awk -F= '/^INVENTAR_HTTP_PORTS=/{print $2}' "$ENV_FILE" | tr -d ' ' || true)"
|
|
fi
|
|
|
|
if [ -n "${INVENTAR_HTTP_PORTS:-}" ]; then
|
|
requested_ports="$INVENTAR_HTTP_PORTS"
|
|
fi
|
|
|
|
if [ -n "${INVENTAR_HTTP_PORT:-}" ] && [ -z "$requested_ports" ]; then
|
|
requested_ports="$INVENTAR_HTTP_PORT"
|
|
fi
|
|
|
|
if [ -n "$requested_ports" ]; then
|
|
mapfile -t ports < <(parse_port_list "$requested_ports")
|
|
fi
|
|
|
|
if [ ${#ports[@]} -gt 0 ]; then
|
|
HTTP_PORTS_VALUE="${ports[*]}"
|
|
HTTP_PORT_VALUE="${ports[0]}"
|
|
|
|
for port in "${ports[@]}"; do
|
|
if port_in_use "$port"; then
|
|
occupied_ports+=("$port")
|
|
fi
|
|
done
|
|
|
|
if [ ${#occupied_ports[@]} -gt 0 ]; then
|
|
if [ ${#ports[@]} -eq 1 ]; then
|
|
HTTP_PORT_VALUE="$(find_free_port "$DEFAULT_TENANT_PORT_START")"
|
|
echo "Host port ${ports[0]} is already occupied. Assigned new tenant port: $HTTP_PORT_VALUE"
|
|
HTTP_PORTS_VALUE="$HTTP_PORT_VALUE"
|
|
else
|
|
echo "Error: requested host port(s) already in use: ${occupied_ports[*]}"
|
|
echo "Remove the occupied port(s) from INVENTAR_HTTP_PORTS or stop the conflicting service."
|
|
exit 1
|
|
fi
|
|
fi
|
|
else
|
|
HTTP_PORT_VALUE="$DEFAULT_TENANT_PORT_START"
|
|
HTTP_PORTS_VALUE="$HTTP_PORT_VALUE"
|
|
|
|
if port_in_use "$HTTP_PORT_VALUE"; then
|
|
HTTP_PORT_VALUE="$(find_free_port "$DEFAULT_TENANT_PORT_START")"
|
|
echo "Host port $DEFAULT_TENANT_PORT_START is already occupied. Assigned new tenant port: $HTTP_PORT_VALUE"
|
|
HTTP_PORTS_VALUE="$HTTP_PORT_VALUE"
|
|
fi
|
|
fi
|
|
}
|
|
|
|
ensure_min_docker_disk_space() {
|
|
local docker_root available_kb available_mb
|
|
|
|
if ! command -v df >/dev/null 2>&1; then
|
|
return 0
|
|
fi
|
|
|
|
docker_root="$(docker info --format '{{.DockerRootDir}}' 2>/dev/null || true)"
|
|
if [ -z "$docker_root" ]; then
|
|
docker_root="/var/lib/docker"
|
|
fi
|
|
|
|
if [ ! -d "$docker_root" ]; then
|
|
return 0
|
|
fi
|
|
|
|
available_kb="$(df -Pk "$docker_root" 2>/dev/null | awk 'NR==2 {print $4}' || true)"
|
|
if [ -z "$available_kb" ]; then
|
|
return 0
|
|
fi
|
|
|
|
available_mb=$((available_kb / 1024))
|
|
|
|
if [ "$available_mb" -lt "$MIN_DOCKER_FREE_MB" ]; then
|
|
echo "Error: low disk space in Docker data root ($docker_root)."
|
|
echo "Available: ${available_mb} MB; required minimum: ${MIN_DOCKER_FREE_MB} MB"
|
|
echo "MongoDB may fail with 'No space left on device'. Free space and retry."
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
detect_server_capacity() {
|
|
local cpus mem_kb mem_gb app_workers app_cpus app_mem app_mem_swap
|
|
|
|
cpus="$(nproc 2>/dev/null || echo 1)"
|
|
mem_kb="$(awk '/MemAvailable:/ {print $2; exit}' /proc/meminfo 2>/dev/null || awk '/MemTotal:/ {print $2; exit}' /proc/meminfo || echo 0)"
|
|
mem_gb=$(( (mem_kb + 1024*1024 - 1) / (1024*1024) ))
|
|
|
|
if [ "$cpus" -ge 8 ] && [ "$mem_gb" -ge 16 ]; then
|
|
app_workers=8
|
|
app_cpus="2.0"
|
|
app_mem="512m"
|
|
app_mem_swap="1024m"
|
|
elif [ "$cpus" -ge 4 ] && [ "$mem_gb" -ge 8 ]; then
|
|
app_workers=4
|
|
app_cpus="1.0"
|
|
app_mem="384m"
|
|
app_mem_swap="768m"
|
|
elif [ "$cpus" -ge 2 ] && [ "$mem_gb" -ge 4 ]; then
|
|
app_workers=2
|
|
app_cpus="0.75"
|
|
app_mem="320m"
|
|
app_mem_swap="640m"
|
|
else
|
|
app_workers=1
|
|
app_cpus="0.5"
|
|
app_mem="256m"
|
|
app_mem_swap="512m"
|
|
fi
|
|
|
|
if [ -f "$ENV_FILE" ]; then
|
|
local env_app_cpus env_app_mem env_app_mem_swap env_workers
|
|
env_app_cpus="$(awk -F= '/^INVENTAR_APP_CPUS=/{print $2; exit}' "$ENV_FILE" | tr -d ' ' || true)"
|
|
env_app_mem="$(awk -F= '/^INVENTAR_APP_MEM_LIMIT=/{print $2; exit}' "$ENV_FILE" | tr -d ' ' || true)"
|
|
env_app_mem_swap="$(awk -F= '/^INVENTAR_APP_MEM_SWAP_LIMIT=/{print $2; exit}' "$ENV_FILE" | tr -d ' ' || true)"
|
|
env_workers="$(awk -F= '/^INVENTAR_WORKERS=/{print $2; exit}' "$ENV_FILE" | tr -d ' ' || true)"
|
|
|
|
[ -n "$env_app_cpus" ] && app_cpus="$env_app_cpus"
|
|
[ -n "$env_app_mem" ] && app_mem="$env_app_mem"
|
|
[ -n "$env_app_mem_swap" ] && app_mem_swap="$env_app_mem_swap"
|
|
[ -n "$env_workers" ] && app_workers="$env_workers"
|
|
fi
|
|
|
|
INVENTAR_APP_CPUS="${INVENTAR_APP_CPUS:-$app_cpus}"
|
|
INVENTAR_APP_MEM_LIMIT="${INVENTAR_APP_MEM_LIMIT:-$app_mem}"
|
|
INVENTAR_APP_MEM_SWAP_LIMIT="${INVENTAR_APP_MEM_SWAP_LIMIT:-$app_mem_swap}"
|
|
INVENTAR_WORKERS="${INVENTAR_WORKERS:-$app_workers}"
|
|
INVENTAR_THREADS="${INVENTAR_THREADS:-2}"
|
|
|
|
echo "Detected host capacity: CPUs=$cpus, RAM=${mem_gb}GB"
|
|
echo "Configured app runtime: INVENTAR_WORKERS=$INVENTAR_WORKERS, INVENTAR_APP_CPUS=$INVENTAR_APP_CPUS, INVENTAR_APP_MEM_LIMIT=$INVENTAR_APP_MEM_LIMIT"
|
|
}
|
|
|
|
write_env_file() {
|
|
cat > "$ENV_FILE" <<EOF
|
|
NUITKA_BUILD=$NUITKA_BUILD_VALUE
|
|
INVENTAR_HTTP_PORT=$HTTP_PORT_VALUE
|
|
INVENTAR_HTTP_PORTS=${HTTP_PORTS_VALUE// /,}
|
|
INVENTAR_APP_IMAGE=$APP_IMAGE_VALUE
|
|
INVENTAR_APP_CPUS=$INVENTAR_APP_CPUS
|
|
INVENTAR_APP_MEM_LIMIT=$INVENTAR_APP_MEM_LIMIT
|
|
INVENTAR_APP_MEM_SWAP_LIMIT=$INVENTAR_APP_MEM_SWAP_LIMIT
|
|
INVENTAR_WORKERS=$INVENTAR_WORKERS
|
|
INVENTAR_THREADS=$INVENTAR_THREADS
|
|
INVENTAR_WORKER_TIMEOUT=${INVENTAR_WORKER_TIMEOUT:-30}
|
|
INVENTAR_WORKER_CONNECTIONS=${INVENTAR_WORKER_CONNECTIONS:-100}
|
|
EOF
|
|
}
|
|
|
|
write_runtime_compose_override() {
|
|
cat > "$RUNTIME_COMPOSE_OVERRIDE_FILE" <<EOF
|
|
services:
|
|
app:
|
|
working_dir: /app/Web
|
|
command: ["gunicorn", "app:app", "--bind", "0.0.0.0:8000", "--workers", "${INVENTAR_WORKERS:-2}", "--threads", "${INVENTAR_THREADS:-2}", "--timeout", "${INVENTAR_WORKER_TIMEOUT:-30}", "--graceful-timeout", "20", "--worker-connections", "${INVENTAR_WORKER_CONNECTIONS:-100}", "--max-requests", "1000", "--max-requests-jitter", "100", "--log-level", "info", "--access-logfile", "-", "--error-logfile", "-"]
|
|
image: ${APP_IMAGE_VALUE}
|
|
build: null
|
|
EOF
|
|
|
|
if [ -n "$HTTP_PORTS_VALUE" ]; then
|
|
local ports_array
|
|
local ports_list
|
|
ports_list="${HTTP_PORTS_VALUE//,/ }"
|
|
read -r -a ports_array <<<"$ports_list"
|
|
if [ "${#ports_array[@]}" -gt 0 ]; then
|
|
cat >> "$RUNTIME_COMPOSE_OVERRIDE_FILE" <<EOF
|
|
ports:
|
|
EOF
|
|
for port in "${ports_array[@]}"; do
|
|
if [ -n "$port" ]; then
|
|
cat >> "$RUNTIME_COMPOSE_OVERRIDE_FILE" <<EOF
|
|
- "$port:8000"
|
|
EOF
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
}
|
|
|
|
verify_stack_health() {
|
|
local compose_args running_services retry_count=0
|
|
compose_args=(-f "$COMPOSE_FILE")
|
|
if [ -f "$RUNTIME_COMPOSE_OVERRIDE_FILE" ]; then
|
|
compose_args+=(-f "$RUNTIME_COMPOSE_OVERRIDE_FILE")
|
|
fi
|
|
compose_args+=(--env-file "$ENV_FILE")
|
|
|
|
# Try health check with optional restart on first failure
|
|
while [[ $retry_count -lt 2 ]]; do
|
|
echo "Waiting for containers to become healthy... (attempt $((retry_count + 1))/2)"
|
|
for _ in $(seq 1 60); do
|
|
running_services="$(docker compose "${compose_args[@]}" ps --status running --services 2>/dev/null || true)"
|
|
if printf '%s\n' "$running_services" | grep -Fxq app && \
|
|
printf '%s\n' "$running_services" | grep -Fxq redis && \
|
|
printf '%s\n' "$running_services" | grep -Fxq mongodb; then
|
|
if docker compose "${compose_args[@]}" exec -T app python3 -c "import flask, pymongo" >/dev/null 2>&1; then
|
|
if curl -fsS "http://127.0.0.1:$HTTP_PORT_VALUE/health" >/dev/null 2>&1; then
|
|
echo "Health check passed."
|
|
return 0
|
|
fi
|
|
fi
|
|
fi
|
|
sleep 2
|
|
done
|
|
|
|
# First failure: attempt recovery by restarting containers
|
|
if [[ $retry_count -eq 0 ]]; then
|
|
echo "Health check failed. Attempting to restart containers..."
|
|
docker compose "${compose_args[@]}" ps || true
|
|
docker compose "${compose_args[@]}" logs --tail=120 app redis mongodb || true
|
|
docker compose "${compose_args[@]}" restart app redis mongodb
|
|
sleep 3
|
|
((retry_count++))
|
|
else
|
|
break
|
|
fi
|
|
done
|
|
|
|
# Final failure
|
|
echo "Error: stack health check failed after restart attempt."
|
|
docker compose "${compose_args[@]}" ps || true
|
|
docker compose "${compose_args[@]}" logs --tail=120 app redis mongodb || true
|
|
return 1
|
|
}
|
|
|
|
parse_args "$@"
|
|
|
|
ensure_runtime_dependencies
|
|
setup_boot_autostart_service
|
|
ensure_runtime_config_json
|
|
setup_scheduled_jobs
|
|
configure_nuitka_mode
|
|
resolve_app_image
|
|
configure_host_ports
|
|
ensure_min_docker_disk_space
|
|
detect_server_capacity
|
|
ensure_app_image_loaded
|
|
write_env_file
|
|
write_runtime_compose_override
|
|
|
|
echo "Starting Inventarsystem Docker stack (app + mongodb)..."
|
|
compose_up_args=(-f "$COMPOSE_FILE")
|
|
if [ -f "$RUNTIME_COMPOSE_OVERRIDE_FILE" ]; then
|
|
compose_up_args+=(-f "$RUNTIME_COMPOSE_OVERRIDE_FILE")
|
|
fi
|
|
compose_up_args+=(--env-file "$ENV_FILE")
|
|
if [ -n "$COMPOSE_PROFILES_VALUE" ]; then
|
|
export COMPOSE_PROFILES="$COMPOSE_PROFILES_VALUE"
|
|
fi
|
|
if ! docker compose "${compose_up_args[@]}" up -d --remove-orphans; then
|
|
echo "Docker Compose startup failed once. Waiting briefly and retrying..."
|
|
sleep 5
|
|
docker compose "${compose_up_args[@]}" up -d --remove-orphans
|
|
fi
|
|
|
|
verify_stack_health
|
|
|
|
echo "Stack started."
|
|
echo "Open: http://<server-ip>:$HTTP_PORT_VALUE" |