.docker_aliases

#!/bin/bash
# Suppress single quote warning:
# shellcheck disable=SC2016

X11_OPTS=(
    --device /dev/dri
    -e DISPLAY
    -v /tmp/.X11-unix:/tmp/.X11-unix:ro
)

X11_COOKIE_OPTS=(
    "${X11_OPTS[@]}"
    -e "XCOOKIE=$(xauth list | grep unix | cut -f2 -d'/' | tr -cd '\11\12\15\40-\176' | sed -e 's/  / /g')"
)

SOUND_OPTS=(
    --device /dev/snd
    --group-add "$(getent group audio | cut -d: -f3)"
    -e "PULSE_SERVER=unix:${XDG_RUNTIME_DIR}/pulse/native"
    -v "${XDG_RUNTIME_DIR}/pulse/native:${XDG_RUNTIME_DIR}/pulse/native:ro"
)

DBUS_OPTS=(
    -v /run/dbus:/run/dbus:ro
    -v "${XDG_RUNTIME_DIR}/bus:${XDG_RUNTIME_DIR}/bus:ro"
    -e DBUS_SESSION_BUS_ADDRESS
)

XDG_OPEN_SERVER_OPTS=(
    -v "${XDG_RUNTIME_DIR}/xdg-open-server:${XDG_RUNTIME_DIR}/xdg-open-server:ro"
    -v /usr/lib/xdg-open-server/xdg-open:/usr/local/bin/xdg-open:ro
)

GTK_OPTS=(
    -v /usr/share/themes/:/usr/share/themes/
    -v "${HOME}/.gtkrc-2.0:/home/USER/.gtkrc-2.0"
)

function docker-cleanup {
    # Remove stopped containers
    docker ps -aq --no-trunc | xargs docker rm
    # Remove dangling/untagged images
    docker images -q --filter dangling=true | xargs docker rmi
}

function docker-ip {
    docker inspect --format '{{ .NetworkSettings.IPAddress }}' "${1}"
}

function docker-connect {
    dependencies "${1}"
    docker exec -it "${1}" "/bin/bash"
}

function docker-image-stop {
    containers="$(docker ps -a -q  --filter ancestor="${1}")"
    for c in $containers; do
        docker stop "${c}"
    done
}

function dependencies {
    for container in "$@"; do
        local state
        state=$(docker inspect --format "{{.State.Running}}" "$container" 2>/dev/null)

        if [[ "$state" == "false" ]] || [[ "$state" == "" ]]; then
            echo "$container is not running, starting it for you."
            $container
        fi
    done
}

function spotify {
    local OPTS=("$*")
    if [ "${OPTS[*]}" = "" ]; then
        OPTS=(--rm --detach)
    fi
    local name="spotify"
    echo -e "Launching spotify container"
    mkdir -p "${HOME}/.spotify/.config"
    mkdir -p "${HOME}/.spotify/.cache"
    set -x
    docker run "${OPTS[@]}" --name $name \
        -v /etc/localtime:/etc/localtime:ro \
        "${XDG_OPEN_SERVER_OPTS[@]}" \
        "${X11_COOKIE_OPTS[@]}" \
        "${SOUND_OPTS[@]}" \
        "${DBUS_OPTS[@]}" \
        -e DOCKER_SPOTIFY_FORCE_DEVICE_SCALE_FACTOR \
        -v "${HOME}/.spotify/.config:/home/spotify/.config" \
        -v "${HOME}/.spotify/.cache:/home/spotify/.cache" \
        --entrypoint "/bin/bash" \
        lizards/spotify \
        -c 'touch ~/.Xauthority && xauth add $XCOOKIE && spotify --force-device-scale-factor=$DOCKER_SPOTIFY_FORCE_DEVICE_SCALE_FACTOR'
    set +x
}

function slack {
    local OPTS=("$*")
    if [ "${OPTS[*]}" = "" ]; then
        OPTS=(--rm --detach)
    fi
    local name='slack'
    local user='slack'
    echo -e "Launching Slack container"
    mkdir -p "${HOME}/.slack/"
    set -x
    docker run "${OPTS[@]}" --name $name \
        -v /etc/localtime:/etc/localtime:ro \
        --ipc="host" \
        --shm-size="1024" \
        `# The below fixes: libudev: udev_has_devtmpfs: name_to_handle_at on /dev: Operation not permitted` \
        --security-opt seccomp=unconfined \
        "${XDG_OPEN_SERVER_OPTS[@]}" \
        "${X11_COOKIE_OPTS[@]}" \
        "${SOUND_OPTS[@]}" \
        "${DBUS_OPTS[@]}" \
        "${GTK_OPTS[@]//USER/$user}" \
        -v "${HOME}/.slack:/home/${user}/.config/Slack" \
        -v "${HOME}:/media:ro" \
        -e DOCKER_SLACK_FORCE_DEVICE_SCALE_FACTOR \
        --entrypoint "/bin/bash" \
        lizards/slack \
        -c 'touch ~/.Xauthority && xauth add $XCOOKIE && /usr/lib/slack/slack --force-device-scale-factor=$DOCKER_SLACK_FORCE_DEVICE_SCALE_FACTOR'
    set +x
}

function redis {
    # Usage:
    # One container: $ redis
    # A master and one slave: $ redis slave
    # A master and three slaves: $ redis slave 3
    # Stop all containers using this image: $ redis stop
    set -x
    local image="bitnami/redis:latest"
    local OPTS=("$*")
    if [ "${OPTS[*]}" = "" ] || [ "${1}" == "slave" ]; then
        OPTS=(--rm --detach)
    fi
    local name='redis-3.2.11'
    local slave_name="${name}-slave"

    if [ "${1}" == "stop" ]; then
        docker-image-stop $image
    else
        if [ "${1}" == "slave" ]; then
            slave_count=${2:-1}
            dependencies redis
            for i in $(seq 1 "${slave_count}"); do
                docker run "${OPTS[@]}" \
                    --name "${slave_name}-${i}" \
                    --link "${name}:master" \
                    -e "REDIS_REPLICATION_MODE=slave" \
                    -e "REDIS_MASTER_HOST=master" \
                    -e "REDIS_MASTER_PORT_NUMBER=6379" \
                    -e ALLOW_EMPTY_PASSWORD=yes \
                    $image
            done
        else
            docker run "${OPTS[@]}" \
                --name "${name}" \
                -e "REDIS_REPLICATION_MODE=master" \
                -e ALLOW_EMPTY_PASSWORD=yes \
                $image
        fi
    fi
    set +x
}

function redis-cluster {
    local name='redis-cluster-3.2.10'
    if [ "${1}" == "stop" ]; then
        docker stop $name
    else
        echo -e "Launching Redis Sharded Cluster container"
        docker run --rm --detach --name $name \
            -p 7000:7000 \
            -p 7001:7001 \
            -p 7002:7002 \
            -p 7003:7003 \
            -p 7004:7004 \
            -p 7005:7005 \
            -e CLUSTER_ONLY=true \
            grokzen/redis-cluster:3.2.10
    fi
}

function mysql-server {
    local name='mysql-server'
    if [ "${1}" == "stop" ]; then
        docker stop $name
    else
        echo -e "Launching MySQL container"
        docker run --rm --detach --name $name \
            -v "${HOME}/work/mysql-data:/var/lib/mysql" \
            -v "${HOME}/work/mysql-dumps:/mysql-dumps" \
            -e MYSQL_ROOT_PASSWORD=root \
            -e MYSQL_ROOT_HOST=172.17.0.1 \
            mysql/mysql-server:5.7.20
    fi
}

function mysql-workbench {
    dependencies mysql-server
    mkdir -p "${HOME}/.mysql-workbench/workbench"
    mkdir -p "${HOME}/.mysql-workbench/workspace"
    local name='mysql-workbench'
    local user='developer'
    echo -e "Launching MySQL workbench"
    docker run --rm --detach --name $name \
        "${X11_COOKIE_OPTS[@]}" \
        "${DBUS_OPTS[@]}" \
        -v "${HOME}/.mysql-workbench/workbench:/home/${user}/.mysql/workbench" \
        -v "${HOME}/.mysql-workbench/workspace:/home/${user}/workspace" \
        --link mysql-server \
        openkbs/mysql-workbench \
        /bin/bash -c "touch /home/${user}/.Xauthority && xauth add \$XCOOKIE && mysql-workbench"
}

function memcached {
    local name='memcached'
    if [ "${1}" == "stop" ]; then
        docker stop $name
    else
        echo -e "Launching Memcached"
        docker run --rm --detach --name $name \
        memcached:latest
    fi
}

function grpcui {
    local name="${3:-grpcui}"
    local grpc_service_host="${1:-localhost:8888}"
    local grpc_ui_port="${2:-8002}"
    echo -e "grpcui: connecting to ${grpc_service_host}"
    docker run --rm --detach --name "${name}" \
        --network host \
        -e GRPCUI_SERVER="${grpc_service_host}" \
        -e GRPCUI_PORT="${grpc_ui_port}" \
        wongnai/grpcui \
    && echo -e "grpcui: http://localhost:${grpc_ui_port}"
}

function vlc {
    local OPTS=("$*")
    if [ "${OPTS[*]}" = "" ]; then
        OPTS=(--rm --detach)
    fi
    local name="vlc"
    echo -e "Launching VLC container"
    mkdir -p "${HOME}/.vlc/.config"
    docker run "${OPTS[@]}" --name $name \
        -v /etc/localtime:/etc/localtime:ro \
        "${X11_COOKIE_OPTS[@]}" \
        "${SOUND_OPTS[@]}" \
        "${DBUS_OPTS[@]}" \
        -v "${HOME}/.vlc/.config:/home/vlc/.config" \
        -v "${HOME}:/media:ro" \
        --entrypoint "/bin/bash" \
        lizards/vlc \
        -c 'touch ~/.Xauthority && xauth add $XCOOKIE && vlc'
}

function vlc-screenshare {
    local OPTS=("$*")
    if [ "${OPTS[*]}" = "" ]; then
        OPTS=(--rm --detach)
    fi
    local name="vlc"
    echo -e "Launching VLC container"
    mkdir -p "${HOME}/.vlc/.config"
    docker run "${OPTS[@]}" --name $name \
        -v /etc/localtime:/etc/localtime:ro \
        "${X11_COOKIE_OPTS[@]}" \
        "${SOUND_OPTS[@]}" \
        "${DBUS_OPTS[@]}" \
        -v "${HOME}/.vlc/.config:/home/vlc/.config" \
        -v "${HOME}:/media:ro" \
        --entrypoint "/bin/bash" \
        lizards/vlc \
        -c 'touch ~/.Xauthority && xauth add $XCOOKIE && vlc vlc --no-video-deco  --no-embedded-video --screen-fps=5 --screen-top=0 --screen-left=3840 --screen-width=3840 --screen-height=2160 screen://'
}


function filezilla {
    local name='filezilla'
    local user='filezilla'
    local OPTS=("$*")
    if [ "${OPTS[*]}" = "" ]; then
        OPTS=(--rm --detach)
    fi
    echo -e "Launching Filezilla container"
    mkdir -p "${HOME}/.filezilla"
    docker run "${OPTS[@]}" --name $name \
        -v /etc/localtime:/etc/localtime:ro \
        --net=host \
        "${DBUS_OPTS[@]}" \
        "${X11_COOKIE_OPTS[@]}" \
        "${XDG_OPEN_SERVER_OPTS[@]}" \
        "${GTK_OPTS[@]//USER/$user}" \
        -v "${HOME}/.filezilla:/home/${user}/.config/filezilla" \
        -v "${HOME}:/host" \
        lizards/filezilla
}

function rutorrent {
    local name='rutorrent'
    local OPTS=("$*")
    if [ "${1}" = "stop" ]; then
        docker stop $name
    else
        if [ "${OPTS[*]}" = "" ]; then
            OPTS=(--rm --detach)
        fi
        echo -e "Launching ${name} container"
        mkdir -p "${HOME}/.rutorrent/config"
        mkdir -p "${HOME}/.rutorrent/downloads"
        docker run "${OPTS[@]}" --name=$name \
            -v "${HOME}/.rutorrent/config:/config" \
            -v "${HOME}/.rutorrent/downloads:/downloads" \
            -e PGID="$(id --group)" \
            -e PUID="$(id --user)" \
            -e TZ="$(timedatectl | grep "Time zone" | awk '{print $3}')" \
            -p 8080:80 \
            -p 5000:5000 \
            -p 51413:51413 \
            -p 6881:6881/udp \
            linuxserver/rutorrent
    fi
}

function shellcheck {
    for file in "$@"; do
        file=$(realpath $file)
        docker run --rm \
            -v "${file}:/${file}:ro" \
            koalaman/shellcheck \
            -x "${file}"
    done
}