server.sh

#!/usr/bin/env bash
# ============================================================
# Resume Tailor — Server Management Script
# ============================================================
# Clean start / stop / status / restart for the Gradio server.
#
# The listening port is the source of truth (not PID files alone).
# The script always verifies that a process is actually running.
#
# Usage:
#   ./server.sh start     Start the server in the background
#   ./server.sh stop      Stop the server (SIGTERM, then SIGKILL)
#   ./server.sh status    Show whether the server is running
#   ./server.sh restart   Stop, then start again
# ============================================================

set -euo pipefail

# Absolute project root — works no matter which directory this is run from.
PROJECT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Port the Gradio app listens on (overridable via GRADIO_SERVER_PORT).
PORT="${GRADIO_SERVER_PORT:-7860}"

VENV_DIR="$PROJECT_DIR/venv"
VENV_PYTHON="$VENV_DIR/bin/python"
PIDFILE="$PROJECT_DIR/.server.pid"
LOG_FILE="$PROJECT_DIR/server.log"

# ------------------------------------------------------------
# Port helpers
# ------------------------------------------------------------

# Print the PID(s) of every process listening on $PORT.
port_pids() {
    # Primary method: lsof (returns bare PIDs).
    if command -v lsof >/dev/null 2>&1; then
        lsof -ti tcp:"$PORT" 2>/dev/null || true
        return 0
    fi

    # Fallback 1: fuser.
    if command -v fuser >/dev/null 2>&1; then
        fuser "$PORT/tcp" 2>/dev/null | tr -s ' ' '\n' | grep -E '^[0-9]+$' || true
        return 0
    fi

    # Fallback 2: parse /proc (usable even without lsof/fuser/ss).
    if [ -x "$VENV_PYTHON" ]; then
        "$VENV_PYTHON" - "$PORT" <<'PY' 2>/dev/null || true
import os
import socket
import sys

def main():
    try:
        port = int(sys.argv[1])
    except (ValueError, IndexError):
        return

    # Nothing is listening on the port -> report nothing.
    s = socket.socket()
    s.settimeout(1)
    try:
        s.connect(("127.0.0.1", port))
        s.close()
    except OSError:
        return

    hex_port = format(port, "04X")
    inodes = set()
    for path in ("/proc/net/tcp", "/proc/net/tcp6"):
        try:
            with open(path) as f:
                lines = f.read().splitlines()[1:]
        except OSError:
            continue
        for line in lines:
            fields = line.split()
            if len(fields) < 10 or fields[3] != "0A":  # 0A = TCP_LISTEN
                continue
            local_port = fields[1].rsplit(":", 1)[-1]
            if local_port.upper() != hex_port:
                continue
            inodes.add(fields[9])

    if not inodes:
        return

    # Map socket inode -> PID by scanning /proc/<pid>/fd.
    seen = set()
    for pid_dir in os.listdir("/proc"):
        if not pid_dir.isdigit():
            continue
        fd_dir = "/proc/%s/fd" % pid_dir
        try:
            fds = os.listdir(fd_dir)
        except OSError:
            continue
        try:
            for fd in fds:
                target = os.readlink(os.path.join(fd_dir, fd))
                if target.startswith("socket:[") and target[8:-1] in inodes:
                    pid = int(pid_dir)
                    if pid not in seen:
                        seen.add(pid)
                        print(pid)
        except OSError:
            continue

main()
PY
        return 0
    fi

    return 0
}

# True (exit 0) if a process is actually listening on $PORT.
is_server_running() {
    local pids
    pids="$(port_pids | sort -u 2>/dev/null || true)"
    [ -n "$pids" ]
}

# True (exit 0) if the kernel has a LISTEN socket bound to $PORT, even when no
# live process owns it. Such an "orphaned" listener can be left behind by a
# server that was hard-killed; lsof/ss/fuser only report sockets owned by a
# running process, so they miss it — yet it still blocks the port from being
# bound. Reading /proc/net/tcp directly catches it.
kernel_has_listener() {
    local hex_port
    hex_port="$(printf '%04X' "$PORT")"
    awk -v hp="$hex_port" '
        NR > 1 {
            if ($4 != "0A") next            # 0A = TCP_LISTEN
            split($2, a, ":")
            if (toupper(a[2]) == hp) { found = 1; exit }
        }
        END { exit found ? 0 : 1 }
    ' "/proc/net/tcp" "/proc/net/tcp6" 2>/dev/null
}

# Print a human-readable explanation of the orphaned-listener state.
orphaned_listener_hint() {
    echo "Port $PORT is bound by a LISTEN socket that no running process owns" >&2
    echo "  (an orphaned/stale listener left over from a killed server)." >&2
    echo "  It is invisible to lsof/ss, so it cannot be killed normally. Options:" >&2
    echo "    - Run on another port:     GRADIO_SERVER_PORT=$((PORT + 1)) $0 start" >&2
    echo "    - Force-close it (root):   sudo ss -K listen $PORT" >&2
    echo "    - Reboot to clear it." >&2
}

# ------------------------------------------------------------
# IP address (for display messages)
# ------------------------------------------------------------

get_ip_address() {
    local ip=""
    if command -v hostname >/dev/null 2>&1; then
        ip="$(hostname -I 2>/dev/null | awk '{print $1}')"
    fi
    case "$ip" in
        ""|"127.0.0.1"|"::1")
            if [ -x "$VENV_PYTHON" ]; then
                ip="$("$VENV_PYTHON" - <<'PY' 2>/dev/null || true
import socket
try:
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    s.connect(("8.8.8.8", 80))
    print(s.getsockname()[0], end="")
    s.close()
except Exception:
    print("127.0.0.1", end="")
PY
)"
            fi
            ;;
    esac
    [ -n "$ip" ] || ip="127.0.0.1"
    echo "$ip"
}

# ------------------------------------------------------------
# start
# ------------------------------------------------------------

start_server() {
    if is_server_running; then
        local existing
        existing="$(port_pids | sort -u 2>/dev/null | head -n 1)"
        echo "Server already running on port $PORT (PID: $existing)"
        exit 1
    fi

    # A port bound by an orphaned listener is not "running", but it still blocks
    # the port. Detect it before launching so the failure is explained instead
    # of surfacing as Gradio's cryptic "Cannot find empty port" traceback.
    if kernel_has_listener; then
        orphaned_listener_hint
        exit 1
    fi

    if [ ! -x "$VENV_PYTHON" ]; then
        echo "Virtual environment not found: $VENV_DIR/bin/python" >&2
        exit 1
    fi

    # Activate the virtual environment.
    set +u
    # shellcheck disable=SC1091
    . "$VENV_DIR/bin/activate"
    set -u

    cd "$PROJECT_DIR"

    # Launch in the background, detached from the current terminal (nohup),
    # so the server keeps running after the terminal is closed.
    GRADIO_SERVER_PORT="$PORT" nohup python -m src.gui >> "$LOG_FILE" 2>&1 &
    local pid=$!
    echo "$pid" > "$PIDFILE"

    # Wait until the port actually answers (or the process dies).
    local attempts=0
    while [ "$attempts" -lt 30 ]; do
        if ! kill -0 "$pid" 2>/dev/null; then
            echo "Server failed to start. Last log lines:" >&2
            tail -n 20 "$LOG_FILE" 2>/dev/null >&2 || true
            rm -f "$PIDFILE"
            exit 1
        fi
        if is_server_running; then
            echo "Server started at http://$(get_ip_address):$PORT (PID: $pid)"
            echo "   Log file: $LOG_FILE"
            return 0
        fi
        sleep 1
        attempts=$((attempts + 1))
    done

    echo "Timed out waiting for the server to start. Last log lines:" >&2
    tail -n 20 "$LOG_FILE" 2>/dev/null >&2 || true
    kill -TERM "$pid" 2>/dev/null || true
    rm -f "$PIDFILE"
    exit 1
}

# ------------------------------------------------------------
# stop
# ------------------------------------------------------------

stop_server() {
    local pids
    pids="$(port_pids | sort -u 2>/dev/null || true)"

    # Secondary hint: trust a PID file entry only if that process exists.
    if [ -z "$pids" ] && [ -f "$PIDFILE" ]; then
        local oldpid
        oldpid="$(cat "$PIDFILE" 2>/dev/null || true)"
        if [ -n "$oldpid" ] && kill -0 "$oldpid" 2>/dev/null; then
            pids="$oldpid"
        fi
    fi

    if [ -z "$pids" ]; then
        rm -f "$PIDFILE"
        echo "No server was running"
        return 0
    fi

    # Graceful stop: SIGTERM first.
    for pid in $pids; do
        kill -TERM "$pid" 2>/dev/null || true
    done

    # Give the server a few seconds to exit cleanly and free the port.
    local attempts=0
    while [ "$attempts" -lt 5 ]; do
        is_server_running || break
        sleep 1
        attempts=$((attempts + 1))
    done

    # Force stop: SIGKILL anything still holding the port.
    local remaining
    remaining="$(port_pids | sort -u 2>/dev/null || true)"
    if [ -n "$remaining" ]; then
        echo "   Did not stop in time — sending SIGKILL."
        for pid in $remaining; do
            kill -KILL "$pid" 2>/dev/null || true
        done
        sleep 1
    fi

    rm -f "$PIDFILE"
    echo "Server stopped"
}

# ------------------------------------------------------------
# status
# ------------------------------------------------------------

status_server() {
    local pids
    pids="$(port_pids | sort -u 2>/dev/null || true)"
    if [ -n "$pids" ]; then
        local first
        first="$(echo "$pids" | head -n 1)"
        echo "Server is running on http://$(get_ip_address):$PORT (PID: $first)"
        return 0
    fi
    if [ -f "$PIDFILE" ]; then
        # Stale PID file from a previous run — clean it up.
        rm -f "$PIDFILE"
    fi
    if kernel_has_listener; then
        echo "Server is not running, but port $PORT is blocked by an orphaned LISTEN socket" >&2
        return 1
    fi
    echo "Server is not running"
}

# ------------------------------------------------------------
# restart
# ------------------------------------------------------------

restart_server() {
    stop_server
    echo ""
    start_server
}

# ------------------------------------------------------------
# dispatch
# ------------------------------------------------------------

usage() {
    echo "Usage: $0 {start|stop|status|restart|help}"
    echo ""
    echo "  start     Start the Gradio server in the background"
    echo "  stop      Stop the server (SIGTERM, then SIGKILL)"
    echo "  status    Show whether the server is running"
    echo "  restart   Stop, then start again"
    echo "  help      Show this help"
    echo ""
    echo "The port can be overridden with GRADIO_SERVER_PORT (default: 7860)."
}

case "${1:-}" in
    start)     start_server ;;
    stop)      stop_server ;;
    status)    status_server ;;
    restart)   restart_server ;;
    help|-h|--help) usage ;;
    *)
        echo "Unknown command: '${1:-}'" >&2
        usage >&2
        exit 1
        ;;
esac