IronFox/scripts/run-docker.sh

#!/bin/bash

# IronFox - Docker build script

set -euo pipefail

script="$(realpath "$0")"
script_dir="$(dirname "${script}")"
root_dir="$(dirname "${script_dir}")"

# Configuration
IMAGE_NAME="ironfox-builder"
CONTAINER_NAME="ironfox-builder"
DOCKERFILE_PATH="${root_dir}/Dockerfile"
PROMPT='\[\033[1;36m\]🐳\[\033[0m\] \[\033[1;34m\]\u@ironfox\[\033[0m\]:\[\033[1;33m\]\w\[\033[0m\]\$ '

# Initialize variables
MOUNT_ARGS=()
COMMAND_ARGS=()
PARSE_COMMAND=false

usage() {
    cat << EOF
IronFox - Docker Build Script

USAGE:
    $0 [OPTIONS] [-- COMMAND [ARGS...]]

OPTIONS:
    -v HOST_PATH:CONTAINER_PATH    Mount a volume from host to container
    -h, --help                     Show this help message

EXAMPLES:
    $0                                    # Start interactive shell
    $0 -v /home/user/code:/workspace      # Mount volume and start shell
    $0 -- ls -la                          # Run 'ls -la' in container
    $0 -v ./data:/data -- python app.py   # Mount volume and run Python script

BEHAVIOR:
- Builds Docker image from '${DOCKERFILE_PATH}' if it doesn't exist
- Creates a persistent container if it doesn't exist
- Automatically mounts the IronFox directory to /app in container
- Starts the container if it's stopped
- Runs interactive shell if no command is provided after --
- Multiple -v options can be used to mount multiple volumes

CONFIGURATION:
- Image name: $IMAGE_NAME
- Container name: $CONTAINER_NAME
- Dockerfile path: $DOCKERFILE_PATH
EOF
}

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        -v)
            if [[ -z "$2" ]]; then
                echo "Error: -v requires a volume mapping argument (host_path:container_path)"
                exit 1
            fi
            MOUNT_ARGS+=("-v" "$2")
            shift 2
            ;;
        -h)
            usage
            exit 0
            ;;
        --)
            PARSE_COMMAND=true
            shift
            break
            ;;
        *)
            echo "Error: Unknown option $1"
            echo "Usage: $0 [-v host_path:container_path] [-- command args...]"
            exit 1
            ;;
    esac
done

if [[ "${PARSE_COMMAND}" == true ]]; then
    COMMAND_ARGS=("$@")
fi

image_exists() {
    docker image inspect "${IMAGE_NAME}" >/dev/null 2>&1
}

container_exists() {
    docker container inspect "${CONTAINER_NAME}" >/dev/null 2>&1
}

container_running() {
    [[ "$(docker container inspect -f '{{.State.Running}}' "${CONTAINER_NAME}" 2>/dev/null)" == "true" ]]
}

build_image() {
    echo "Building Docker image '${IMAGE_NAME}'..."
    if [[ ! -f "${DOCKERFILE_PATH}" ]]; then
        echo "Error: Dockerfile not found at ${DOCKERFILE_PATH}"
        exit 1
    fi
    docker build -t "${IMAGE_NAME}" -f "${DOCKERFILE_PATH}" .
    echo "Docker image '${IMAGE_NAME}' built successfully."
}

create_container() {
    echo "Creating container '${CONTAINER_NAME}'..."
    
    local docker_cmd=(
        "docker" "run" "-d" "-it"
        "--name" "${CONTAINER_NAME}"
        "-v" "${root_dir}:/app"
        "${MOUNT_ARGS[@]}"
        "${IMAGE_NAME}"
    )
    
    "${docker_cmd[@]}"
    echo "Container '${CONTAINER_NAME}' created successfully."
}

start_container() {
    if ! container_running; then
        echo "Starting container '${CONTAINER_NAME}'..."
        docker start "${CONTAINER_NAME}"
    fi
}

execute_in_container() {
    local cmd=("$@")
    
    if [[ ${#cmd[@]} -eq 0 ]]; then
        echo "Starting interactive shell in container '${CONTAINER_NAME}'..."
        docker exec -it "${CONTAINER_NAME}" /bin/bash -c "export PS1='${PROMPT}' && /bin/bash"
    else
        echo "Executing command in container '${CONTAINER_NAME}': ${cmd[*]}"
        docker exec -it "${CONTAINER_NAME}" "${cmd[@]}"
    fi
}

main() {
    echo "IronFox"
    echo "========================"
    
    if ! image_exists; then
        build_image
    else
        echo "Docker image '${IMAGE_NAME}' already exists."
    fi
    
    if ! container_exists; then
        create_container
    else
        echo "Container '${CONTAINER_NAME}' already exists."
    fi
    
    start_container
    execute_in_container "${COMMAND_ARGS[@]}"
}

main