commands

#!/bin/bash
set -e;

# Check if name is specified
if [[ $1 == postgresql:* ]]; then
    if [ -z $2 ] && [ $1 != postgresql:list ]; then
        echo "You must specify an app name"
        exit 1
    else
        APP="$2"
        # Check if app exists with the same name
        if [[ -d "$DOKKU_ROOT/$APP" ]]; then
            APP_EXISTS=true
        else
            APP_EXISTS=false
        fi
    fi
fi

# Create .postgresql diretory if not exists
if [[ ! -d $DOKKU_ROOT/.postgresql ]]; then
    mkdir -p $DOKKU_ROOT/.postgresql
    chown -R dokku: $DOKKU_ROOT/.postgresql
fi

function check_postgresql_container() {
    if [[ ! -f "$DOKKU_ROOT/.postgresql/pwd_$APP" ]]; then
        echo "Unknown (or too old) PostgreSQL container"
        exit 1
    fi
}

function check_postgresql_tool() {
    local tool_name="$1"
    if [[ $(whereis $tool_name | awk '{ print NF }') -eq 1 ]]; then
        echo "'${tool_name}' not found. Is the package 'postgresql-client' installed?" 1>&2
        exit 1
    fi
}

function get_postgresql_id() {
    ID=$(docker ps | grep postgresql/"$APP":latest | awk {'print $1'})
    echo $ID
}

function get_postgresql_ip() {
    ID=$(get_postgresql_id)
    IP=$(docker inspect --format '{{ .NetworkSettings.Gateway }}' $ID)
    echo $IP
}

function get_postgresql_port() {
    ID=$(get_postgresql_id)
    PORT=$(docker port "$ID" 5432 | sed 's/0.0.0.0://')
    echo $PORT
}


case "$1" in
  postgresql:create)
    DB_IMAGE=postgresql/$APP
    # Check if DB container is installed
    IMAGE=$(docker images | grep "netsyno/postgresql " |  awk '{print $3}')
    if [[ -z $IMAGE ]]; then
        echo "PostgreSQL image not found... Did you run 'dokku plugins-install' ?"
        exit 1
    fi
    # Check if an existing DB volume exists
    if [[ -f "$DOKKU_ROOT/.postgresql/volume_$APP" ]]; then
        VOLUME="`cat $DOKKU_ROOT/.postgresql/volume_$APP`:/opt/postgresql"
        echo
        echo "-----> Reusing postgresql/$APP database"
    else
        VOLUME="/mnt/$APP/postgresql:/opt/postgresql"
        # Generate a random password for DB user
        DB_PASSWORD=$(< /dev/urandom tr -dc A-Za-z0-9 | head -c 16)
        echo $DB_PASSWORD > "$DOKKU_ROOT/.postgresql/pwd_$APP"
        chown dokku: "$DOKKU_ROOT/.postgresql/pwd_$APP"
        chmod 700 "$DOKKU_ROOT/.postgresql/pwd_$APP"
    fi
    # Fork DB image
    ID=$(docker run -d netsyno/postgresql echo '')
    docker wait $ID > /dev/null
    IMAGE=$(docker commit $ID)
    docker tag $IMAGE $DB_IMAGE
    # Launch container
    ID=$(docker run -v $VOLUME -p 5432 -d $DB_IMAGE /usr/bin/start_pgsql.sh $DB_PASSWORD)
    sleep 4
    # Rename persistent volume
    if [[ ! -f "$DOKKU_ROOT/.postgresql/volume_$APP" ]]; then
        if [[ -z "$3" ]]; then
            VOLUME_PATH="/mnt/$APP/postgresql"
        else
            if [[ -d $3 ]]; then
                echo "$3 is a directory"
                VOLUME_PATH="$3"
            elif [[ -f $3 ]]; then
                echo "$3 is a file. directory required!"
                exit 1
            else
                echo "$3 is not a valid path. Choosing default"
                VOLUME_PATH="/mnt/$APP/postgresql"
            fi
        fi
        echo "Linking postgres data to $VOLUME_PATH"

        if [[ -z $VOLUME_PATH ]]; then
            echo "Your docker version is too old, please update it"
            exit 1
        fi
        echo $VOLUME_PATH > "$DOKKU_ROOT/.postgresql/volume_$APP"
    fi
    # Link to a potential existing app
    dokku postgresql:link $APP $APP
    echo
    echo "-----> PostgreSQL container created: $DB_IMAGE"
    sleep 1
    dokku postgresql:info $APP
    ;;

  postgresql:delete)
    DB_IMAGE=postgresql/$APP
    ID=$(get_postgresql_id)
    # Stop and remove the container
    if [[ ! -z $ID ]]; then
        docker kill $ID > /dev/null
        sleep 1
        docker rm -v $ID > /dev/null
        sleep 1
    fi
    # Remove image
    IMAGE=$(docker images | grep "$DB_IMAGE " |  awk '{print $1}')
    if [[ ! -z $IMAGE ]]; then
        docker rmi $IMAGE > /dev/null
    fi
    # Remove container root password
    if [[ -f "$DOKKU_ROOT/.postgresql/pwd_$APP" ]]; then
        rm -f "$DOKKU_ROOT/.postgresql/pwd_$APP"
    fi
    # Remove persistent volume
    if [[ -f "$DOKKU_ROOT/.postgresql/volume_$APP" ]]; then
        rm -f "$DOKKU_ROOT/.postgresql/volume_$APP"
    fi

    echo
    echo "-----> PostgreSQL container deleted: $DB_IMAGE"
    ;;

  postgresql:info)
    check_postgresql_container
    DB_PASSWORD=$(cat "$DOKKU_ROOT/.postgresql/pwd_$APP")
    IP=$(get_postgresql_ip)
    PORT=$(get_postgresql_port)

    echo
    echo "       Host: $IP"
    echo "       Port: $PORT"
    echo "       User: 'root'"
    echo "       Password: '$DB_PASSWORD'"
    echo "       Database: 'db'"
    echo
    echo "       Url: 'postgres://root:$DB_PASSWORD@$IP:$PORT/db'"
    echo
    ;;

  postgresql:link)
    if $APP_EXISTS; then
        # Check argument
        if [[ -z $3 ]]; then
            echo "You must specify a database name"
            exit 1
        fi
        DB_IMAGE="postgresql/$3"
        if [[ ! -f "$DOKKU_ROOT/.postgresql/pwd_$3" ]]; then
            echo "Database is not initialized correctly. Did you run 'dokku plugins-install'?"
            exit 1
        fi
        DB_PASSWORD=$(cat "$DOKKU_ROOT/.postgresql/pwd_$3")
        IP=$(get_postgresql_ip)
        PORT=$(get_postgresql_port)
        # Link database using dokku command
        dokku config:set $APP "DATABASE_URL=postgres://root:$DB_PASSWORD@$IP:$PORT/db"
        echo
        echo "-----> $APP linked to $DB_IMAGE database"
    fi
    ;;

  postgresql:logs)
    ID=$(get_postgresql_id)
    docker logs $ID | tail -n 100
    ;;

  postgresql:list)
    CONTAINERS=$(ls $DOKKU_ROOT/.postgresql/volume* 2> /dev/null | sed -e 's/_/ /' | awk '{print $2}')
    if [[ -z $CONTAINERS ]]; then
        echo "There are no PostgreSQL containers created."
    else
        echo "PostgreSQL containers:"
        for CONTAINER in $CONTAINERS; do
            echo "  - $CONTAINER"
        done
    fi
    ;;

  help)
    cat && cat<<EOF
    postgresql:create <db> [<localpath>]           Create a PostgreSQL container
    postgresql:delete <db>                         Delete specified PostgreSQL container
    postgresql:info <db>                           Display database informations
    postgresql:link <app> <db>                     Link an app to a PostgreSQL database
    postgresql:list                                Display list of PostgreSQL containers
    postgresql:logs <db>                           Display last logs from PostgreSQL container
EOF
    ;;

esac