otn

#!/bin/bash

RED='\033[0;31m'
YELLOW='\033[0;33m'
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m'

init () {
    if [ -f .env ]; then
        while true; do
            read -e -p "[$(printf "${YELLOW}WARNING${NC}")] Environment file already exists! Do you want overwrite file? This action may cause errors! (y/N) " yn

            case $yn in 
	            [yY])
                    break
                ;;
	            [nN])
                    echo Exit
		            exit
                ;;
                '')
                    echo Exit
		            exit
                ;;
	            *)
                    echo invalid response
                ;;
            esac
        done
    fi

# Get User Email Address
    printf "[${BLUE}INFO${NC}] Email address needed for LetsEncrypt SSL Certificates\n"
    while [[ ! $USER_EMAIL =~ ^.+@.+\..+$ ]] || [[ $USER_EMAIL == '' ]]; do
        read -e -p "Enter Your Email [$(printf "${RED}REQUIRED${NC}")]: " USER_EMAIL
        
        if ! [[ $USER_EMAIL =~ ^.+@.+\..+$ ]]; then 
            printf "[${RED}ERROR${NC}] Write a correct email address\n"
        fi
    done

# Get User Domain Name
    while [[ ! $USER_DOMAIN =~ ^.+\..+$ ]] || [[ $USER_DOMAIN == '' ]]; do
        read -e -p "Enter Your Domain [$(printf "${RED}REQUIRED${NC}")]: " USER_DOMAIN
        
        if ! [[ $USER_DOMAIN =~ ^.+\..+$ ]]; then 
            printf "[${RED}ERROR${NC}] Write a correct domain name\n"
        fi
    done

    read -e -p "Enter Outline Wiki Domain: " -i "wiki.$USER_DOMAIN" OUTLINE_DOMAIN
    read -e -p "Enter Keycloak Domain: " -i "kk.$USER_DOMAIN" KEYCLOAK_DOMAIN
    read -e -p "Enter MiniO Domain: " -i "minio.$USER_DOMAIN" MINIO_DOMAIN
    read -e -p "Enter MiniO Admin Console Domain: " -i "minio-admin.$USER_DOMAIN" MINIO_ADMIN_DOMAIN

    PUBLIC_IP_ADDRESS=$(dig +short myip.opendns.com @resolver1.opendns.com)
    local DOMAIN_ERRORS=false

    printf "Your public IP address: ${GREEN}${PUBLIC_IP_ADDRESS}${NC}\n"

    if [[ $(dig +short a $OUTLINE_DOMAIN) = $PUBLIC_IP_ADDRESS ]]; then
        printf "[${GREEN}SUCCESS${NC}] Check IP ${OUTLINE_DOMAIN}\n"
    else
        printf "[${RED}ERROR${NC}] Check IP ${OUTLINE_DOMAIN}\n"
        DOMAIN_ERRORS=true
    fi

    if [[ $(dig +short a $KEYCLOAK_DOMAIN) = $PUBLIC_IP_ADDRESS ]]; then
        printf "[${GREEN}SUCCESS${NC}] Check IP ${KEYCLOAK_DOMAIN}\n"
    else
        printf "[${RED}ERROR${NC}] Check IP ${KEYCLOAK_DOMAIN}\n"
        DOMAIN_ERRORS=true
    fi

    if [[ $(dig +short a $MINIO_DOMAIN) = $PUBLIC_IP_ADDRESS ]]; then
        printf "[${GREEN}SUCCESS${NC}] Check IP ${MINIO_DOMAIN}\n"
    else
        printf "[${RED}ERROR${NC}] Check IP ${MINIO_DOMAIN}\n"
        DOMAIN_ERRORS=true
    fi

    if [[ $(dig +short a $MINIO_ADMIN_DOMAIN) = $PUBLIC_IP_ADDRESS ]]; then
        printf "[${GREEN}SUCCESS${NC}] Check IP ${MINIO_ADMIN_DOMAIN}\n"
    else
        printf "[${RED}ERROR${NC}] Check IP ${MINIO_ADMIN_DOMAIN}\n"
        DOMAIN_ERRORS=true
    fi

    if [[ $DOMAIN_ERRORS = true ]]; then
        printf "[${YELLOW}WARNING${NC}] Some domains do not have an A record that leads to the current server.
          This is normal if you are using Cloudflare, or other DDos protection.
          However, if you do not have such protection installed, pay attention to it.\n"
    fi

    read -e -p "Enter Keycloak Admin Username: " -i "admin" KEYCLOAK_ADMIN_USERNAME
    read -e -p "Enter Keycloak Realm for Outline: " -i "outline" KEYCLOAK_REALM_NAME
    read -e -p "Enter Keycloak OIDC ClientID for Outline: " -i "outline_app" KEYCLOAK_CLIENT_ID
    KEYCLOAK_ADMIN_PASSWORD=$(pass_gen 16)
    KEYCLOAK_CLIENT_SECRET=$(pass_gen 32)

    read -e -p "Enter MiniO Root Username: " -i "admin" MINIO_ROOT_USERNAME
    MINIO_ROOT_PASSWORD=$(pass_gen 16)
    read -e -p "Enter MiniO Bucket for Outline Name: " -i "outline" MINIO_BUCKET_NAME
    read -e -p "Enter MiniO Bucket for Outline Username: " -i "outline" MINIO_BUCKET_USERNAME
    MINIO_BUCKET_PASSWORD=$(pass_gen 16)

    read -e -p "Enter Outline Database User: " -i "outline" POSTGRES_OUTLINE_USERNAME
    read -e -p "Enter Outline Database: " -i "outline" POSTGRES_OUTLINE_DB_NAME
    POSTGRES_OUTLINE_PASSWORD=$(pass_gen 16)

    OUTLINE_SECRET_KEY=$(hash_gen)
    OUTLINE_UTILS_SECRET=$(hash_gen)

    tee .env <<EOF  > /dev/null
# –––––––––––––––– NOT OUTLINE ENVS ––––––––––––––––
USER_DOMAIN=$USER_DOMAIN
USER_EMAIL=$USER_EMAIL
KEYCLOAK_DOMAIN=$KEYCLOAK_DOMAIN
MINIO_DOMAIN=$MINIO_DOMAIN
MINIO_ADMIN_DOMAIN=$MINIO_ADMIN_DOMAIN
OUTLINE_DOMAIN=$OUTLINE_DOMAIN

# POSTGRES
POSTGRES_OUTLINE_USERNAME=$POSTGRES_OUTLINE_USERNAME
POSTGRES_OUTLINE_DB_NAME=$POSTGRES_OUTLINE_DB_NAME
POSTGRES_OUTLINE_PASSWORD=$POSTGRES_OUTLINE_PASSWORD

# MINIO
MINIO_ROOT_USERNAME=$MINIO_ROOT_USERNAME
MINIO_ROOT_PASSWORD=$MINIO_ROOT_PASSWORD
MINIO_BUCKET_NAME=$MINIO_BUCKET_NAME
MINIO_BUCKET_USERNAME=$MINIO_BUCKET_USERNAME
MINIO_BUCKET_PASSWORD=$MINIO_BUCKET_PASSWORD

# KEYCLOAK
KEYCLOAK_REALM_NAME=$KEYCLOAK_REALM_NAME
KEYCLOAK_ADMIN_USERNAME=$KEYCLOAK_ADMIN_USERNAME
KEYCLOAK_ADMIN_PASSWORD=$KEYCLOAK_ADMIN_PASSWORD
KEYCLOAK_CLIENT_ID=$KEYCLOAK_CLIENT_ID
KEYCLOAK_CLIENT_SECRET=$KEYCLOAK_CLIENT_SECRET

# OUTLINE
OUTLINE_SECRET_KEY=$OUTLINE_SECRET_KEY
OUTLINE_UTILS_SECRET=$OUTLINE_UTILS_SECRET
EOF
}

deploy () {
if [ -f .deployed ]; then
        printf "[${RED}ERROR${NC}] Already deployed. Re-deploying may cause errors\n"
        exit
    fi

    if ! [ -f .env ]; then
        init
    fi

    export $(echo $(cat .env | sed 's/#.*//g'| xargs) | envsubst)

    if [[ $1 = true ]]; then
        docker-compose -f traefik/docker-compose.yml -f traefik/docker-compose.debug.yml up -d &> /dev/null
    else
        docker-compose -f traefik/docker-compose.yml up -d &> /dev/null
    fi

    printf '\n\tWaiting for keycloak starts  '

    docker-compose -f keycloak/docker-compose.yml up -d &> /dev/null

    while ! docker-compose -f keycloak/docker-compose.yml ps | grep keycloak | grep -q "(healthy)"; do for X in '-' '/' '|' '\'; do echo -en "\b$X"; sleep 1; done; done

    printf '\n'

    docker-compose -f keycloak/docker-compose.yml exec keycloak /opt/jboss/keycloak/bin/kcadm.sh config credentials --server http://localhost:8080/auth/ --realm master --user $KEYCLOAK_ADMIN_USERNAME --password $KEYCLOAK_ADMIN_PASSWORD
    docker-compose -f keycloak/docker-compose.yml exec keycloak /opt/jboss/keycloak/bin/kcadm.sh create realms -s realm=$KEYCLOAK_REALM_NAME -s enabled=true
    docker-compose -f keycloak/docker-compose.yml exec keycloak /opt/jboss/keycloak/bin/kcadm.sh create clients -r $KEYCLOAK_REALM_NAME -s enabled=true -s rootUrl="https://${OUTLINE_DOMAIN}" -s clientId="${KEYCLOAK_CLIENT_ID}" -s redirectUris="[\"https://${OUTLINE_DOMAIN}/*\"]" -s webOrigins="[\"https://${OUTLINE_DOMAIN}/\"]" -s adminUrl="https://${OUTLINE_DOMAIN}" -s secret="${KEYCLOAK_CLIENT_SECRET}"

    printf '\n\tWaiting for minio starts  '

    docker-compose -f minio/docker-compose.yml up -d &> /dev/null

    while ! docker-compose -f minio/docker-compose.yml ps | grep minio | grep -q "(healthy)"; do for X in '-' '/' '|' '\'; do echo -en "\b$X"; sleep 1; done; done

    docker-compose -f minio/docker-compose.yml exec minio mc alias set local http://localhost:9000 $MINIO_ROOT_USERNAME "$MINIO_ROOT_PASSWORD"
    docker-compose -f minio/docker-compose.yml exec minio mc admin user add local $MINIO_BUCKET_USERNAME "$MINIO_BUCKET_PASSWORD"
    docker-compose -f minio/docker-compose.yml exec minio mc admin policy attach local readwrite --user $MINIO_BUCKET_USERNAME
    docker-compose -f minio/docker-compose.yml exec minio mc mb local/$MINIO_BUCKET_NAME

    printf '\nWaiting for outline starts  \n'

    docker-compose -f outline/docker-compose.yml up -d &> /dev/null

    printf "\n${GREEN}DONE${NC}\n"

    touch .deployed
}

up () {
    export $(echo $(cat .env | sed 's/#.*//g'| xargs) | envsubst)

    if [[ $1 = true ]]; then
        docker-compose -f traefik/docker-compose.yml -f traefik/docker-compose.debug.yml up -d
    else
        docker-compose -f traefik/docker-compose.yml up -d
    fi

    docker-compose -f keycloak/docker-compose.yml up -d
    docker-compose -f minio/docker-compose.yml up -d
    docker-compose -f outline/docker-compose.yml up -d
}

start () {
    export $(echo $(cat .env | sed 's/#.*//g'| xargs) | envsubst)

    if [[ $1 = true ]]; then
        docker-compose -f traefik/docker-compose.yml -f traefik/docker-compose.debug.yml start
    else
        docker-compose -f traefik/docker-compose.yml start
    fi

    docker-compose -f keycloak/docker-compose.yml start
    docker-compose -f minio/docker-compose.yml start
    docker-compose -f outline/docker-compose.yml start
}

stop () {
    export $(echo $(cat .env | sed 's/#.*//g'| xargs) | envsubst)

    docker-compose -f outline/docker-compose.yml stop
    docker-compose -f minio/docker-compose.yml stop
    docker-compose -f keycloak/docker-compose.yml stop
    docker-compose -f traefik/docker-compose.yml stop
}

down () {
    export $(echo $(cat .env | sed 's/#.*//g'| xargs) | envsubst)

    docker-compose -f outline/docker-compose.yml down
    docker-compose -f minio/docker-compose.yml down
    docker-compose -f keycloak/docker-compose.yml down
    docker-compose -f traefik/docker-compose.yml down
}

pass_gen () {
    local len="${1:-32}"
    echo $(tr -dc A-Za-z0-9 </dev/urandom | head -c $len)
}

hash_gen () {
    local len="${1:-32}"
    echo $(openssl rand -hex $len)
}

help () {
    cat <<EOF
Outline Docker Deploy Script

    init    - Create .env file with required parameters.
    deploy  - Run deploy of application. (--debug key will add traefik dashboard on 8080 port)
    up      - Up application. (--debug key will add traefik dashboard on 8080 port)
    down    - Down application with removing containers.
    start   - Starts stopped application. (--debug key will add traefik dashboard on 8080 port)
    stop    - Stops application.
    help    - Shows this help text.

v.0.0.1

EOF
}

case "$1" in
    init)
        init
    ;;
    help)
        help
    ;;
    up)
        if [[ $2 == '--debug' ]]; then
            up true
        else
            up false
        fi
    ;;
    start)
        if [[ $2 == '--debug' ]]; then
            start true
        else
            start false
        fi
    ;;
    stop)
        stop
    ;;
    down)
        down
    ;;
    deploy)
        if [[ $2 == '--debug' ]]; then
            deploy true
        else
            deploy false
        fi
    ;;
    *)
        printf "[${RED}ERROR${NC}] Unknown command\n\n"
        help
    ;;
esac