fej/fejctl

#!/usr/bin/env bash

image='chewingbever/fej'

# Creates the needed images
#
# $1: wether to build the debug or the release image (default debug)
function create_images() {
    # First, we build the builder
    DOCKER_BUILDKIT=1 docker build \
        -f docker/Dockerfile.builder \
        -t "$image-builder:latest" .

    if [[ "$1" = "rel" ]]; then
        DOCKER_BUILDKIT=1 docker build \
            -t "$image:latest" \
            -f docker/Dockerfile.rel .

    else
        # Then, we create the debug image
        DOCKER_BUILDKIT=1 docker build \
            -t "$image:dev" \
            -f docker/Dockerfile.dev .
    fi
}

# Execute the debug image (must be built first)
#
# $@: the arguments to pass to the image (passed as arguments to cargo)
function run_image() {
    docker volume create fej_build-cache
    docker volume create fej_registry-cache
    docker volume create fej_db-data

    # Run the database image
    docker run --rm \
        --detach \
        --name fej_db \
        --network fej \
        -p 5432:5432 \
        -e 'POSTGRES_DB=fej' \
        -e 'POSTGRES_USER=fej' \
        -e 'POSTGRES_PASSWORD=fej' \
        -v 'fej_db-data:/var/lib/postgresql/data' \
        postgres:13-alpine

    # Run the binary image
    docker run \
        --detach \
        --rm \
        --interactive \
        --tty \
        --publish 8000:8000 \
        --name fej \
        --env-file .env.container \
        --network fej \
        -v 'fej_build-cache:/usr/src/app/target' \
        -v 'fej_registry-cache:/root/.cargo/registry' \
        -v "$PWD/Rocket.toml:/usr/src/app/Rocket.toml:ro" \
        "$image:dev" "$@"
}

# Attach to the fej container
function logs() {
    docker logs -f fej
}

# Builds the given binary
#
# $1: the binary to build
function build() {
    create_images
    run_image build --bin "$1"
    logs
}

# Runs the given binary
#
# $1: the binary to run
function run() {
    create_images
    run_image run --bin "$1"
    logs
}

# Runs the tests
function tests() {
    create_images
    run_image test --no-fail-fast
    logs
}

# Stops both containers
function stop() {
    docker stop fej_db
    docker stop -t 0 fej
}

function run_release() {
    echo "Not implemented"
}

# Tags & pushes the release version to Docker Hub
function publish() {
    branch=`git rev-parse --abbrev-ref HEAD`

    if [[ "$branch" != master ]]; then
        >&2 echo "You can only publish from master."
        exit 2
    fi

    patch_version=`grep -Po '(?<=version = ").*(?=")' Cargo.toml | head -n1`
    major_version=`echo "$patch_version" | sed -E 's/([0-9]+)\.([0-9]+)\.([0-9]+)/\1/'`
    minor_version=`echo "$patch_version" | sed -E 's/([0-9]+).([0-9]+).([0-9]+)/\1.\2/'`
    tags=("latest" "$patch_version" "$minor_version" "$major_version")

    for tag in "${tags[@]}"; do
        # Create the tag
        docker tag "$image:$tags" "$image:$tag"

        # Push the tag
        docker push "$image:$tag"

        # Remove the tag again, if it's not the main tag
        [[ "$tag" != "$tags" ]] && docker rmi "$image:$tag"
    done

}

# Entrypoint to the script
#
# $1: action to perform, defaults to 'build'
# $2: binary to use, defaults to 'server'
function main() {
    # Default values
    cmd="${1:-build}"
    bin="${2:-server}"

    case $cmd in
        # Building
        b | build ) build "$bin" ;;
        br | build-release ) create_images rel ;;

        # Running
        r | run ) run "$bin" ;;
        rr | run-release ) run_release ;;
        s | stop ) stop ;;

        # Ease of life
        psql ) docker exec -it fej_db psql -U fej -d fej ;;
        sh ) docker exec -it fej sh ;;

        # Misc
        docs ) cargo doc --no-deps ;;
        format ) cargo fmt ;;
        l | logs ) logs ;;
        lint ) cargo fmt -- --check ;;
        p | push | publish ) publish ;;
        t | test ) tests ;;
        * ) >&2 echo "Invalid command."; exit 1 ;;
    esac
}

main "$@"