run

#!/usr/bin/env bash
#
# A script to make working with docker/compose to have
# less typing.
#
# For local development only.

UI_PATH="source/SIL.AppBuilder.Portal.Frontend"
API_PATH="source/OptimaJet.DWKit.StarterApplication"
COMPOSE="docker-compose -f deployment/development/docker-compose.yml --project-directory . -p appbuilder-portal"
COMPOSE_SERVICES="db adminer api ui"

CI_COMPOSE="docker-compose -f deployment/ci/docker-compose.yml --project-directory . -p appbuilder-portal-ci"

PSQL="PGPASSWORD=\$POSTGRES_PASSWORD psql -h localhost -U \$POSTGRES_USER"

function runstuff {
  # First arg
  given_command=$1
  # The rest of the args
  arguments=${@:2}

  case $given_command in
    # docker-compose proxy
    dc)       ${COMPOSE} $arguments;;
    up:build) ${COMPOSE} up --build $arguments ${COMPOSE_SERVICES} ;;
    up)       ${COMPOSE} up $arguments ${COMPOSE_SERVICES} ;;
    up:local:start)
      runstuff dc up -d db adminer

      echo "db and adminer have been started. please make sure you have /etc/hosts entries"
      echo ""
      echo "  127.0.0.1 db.docker"
      echo "  127.0.0.1 api"
      echo "  127.0.0.1 adminer"
      echo ""
      echo "if you need to connect to these services from locally run api and ui"
      echo ""
      echo "also make sure any environment variables present in docker-compose.yml"
      echo "for the non-running services are present when booting up the services"
      echo "on the host environment (use .env.dev files to make this simpler)"
      echo ""
      echo "why?"
      echo "because currently, docker-compose doesn't have a way to omit files / folders"
      echo "from volume mounts, so whenever dotnet watch would do a rebuild inside the"
      echo "docker environment, it would blow away all the host-dependencies that the"
      echo "editor was using for intellisense..."

      runstuff dc ps
      runstuff dc logs --follow --tail="2"
    ;;

    bash)     ${COMPOSE} run --rm $arguments bash;;
    restart)  ${COMPOSE} stop $arguments && ${COMPOSE} start $arguments;;

    api:ef)
      ${COMPOSE} exec api bash -c "\
        dotnet ef ${arguments} \
          --startup-project /app/OptimaJet.DWKit.StarterApplication/OptimaJet.DWKit.StarterApplication.csproj \
          --project /app/OptimaJet.DWKit.StarterApplication/OptimaJet.DWKit.StarterApplication.csproj \
          --msbuildprojectextensionspath /app/out/OptimaJet.DWKit.StarterApplication/obj/ \
        ";;

    db:update)     runstuff api:ef database update ${arguments};;
    db:migrations) runstuff api:ef migrations ${arguments};;

    bootstrap)
      set -e
      runstuff bootstrap:dwkit
      runstuff bootstrap:api
      runstuff bootstrap:sample
      runstuff bootstrap:dev
      runstuff bootstrap:ui-static
      set +e
    ;;

    bootstrap:alpha)
      set -e
      runstuff bootstrap:dwkit
      runstuff bootstrap:api
      runstuff bootstrap:orgs
      runstuff bootstrap:dev
      runstuff bootstrap:ui-static
      set +e
    ;;

    bootstrap:dwkit)
      echo "api must not be running in order to run the initial db scripts ..."
      runstuff dc stop api


      # Setup Database
      ${COMPOSE} exec db bash -c "\
        ${PSQL} -d postgres -tc \
          \"SELECT 1 FROM pg_database \
            WHERE datname = '\$POSTGRES_DB'\" \
        | grep -q 1 \
        && ${PSQL} -d postgres -c \"DROP DATABASE \$POSTGRES_DB\""

      ${COMPOSE} exec db bash -c "${PSQL} -d postgres -c \"CREATE DATABASE \$POSTGRES_DB WITH ENCODING 'UTF8'\""

      echo "Setting up DWKit..."
      ${COMPOSE} exec db bash -c "${PSQL} -d \$POSTGRES_DB -f /scripts/PostgreSQL/DWKitScript.sql" \
        && ${COMPOSE} exec db bash -c "${PSQL} -d \$POSTGRES_DB -f /scripts/PostgreSQL/Workflow_CreatePersistenceObjects.sql" \
        && ${COMPOSE} exec db bash -c "${PSQL} -d \$POSTGRES_DB -f /scripts/PostgreSQL/DWKitUpdate_2.6.sql" \
        && echo "DB setup with DWKit Scripts"
    ;;

    bootstrap:api)
      echo "api must be running in order to run the db migration scripts ..."
      runstuff dc start api

      echo "Running migrations..."

      runstuff db:update \
        && ${COMPOSE} exec db bash -c "${PSQL} -d \$POSTGRES_DB -f /scripts/bootstrap.sql" \
        && ${COMPOSE} exec db bash -c "${PSQL} -d \$POSTGRES_DB -f /scripts/default_workflow.sql" \
        && echo "DB setup for json:api"
    ;;

    bootstrap:workflow)
	${COMPOSE} exec db bash -c "${PSQL} -d \$POSTGRES_DB -f /scripts/default_workflow.sql"
    ;;

    bootstrap:sample)
      echo "Adding sample data..."

      ${COMPOSE} exec db bash -c "${PSQL} -d \$POSTGRES_DB -f /scripts/sample_data.sql" \
        && echo "DB setup with sample data"
    ;;

    bootstrap:ui-static)
      echo "Building Static Data for the UI"

      ( cd $UI_PATH && ./scripts/refresh-languages.sh )
    ;;

    bootstrap:orgs)
      echo "Adding sample data..."

      ${COMPOSE} exec db bash -c "${PSQL} -d \$POSTGRES_DB -f /scripts/default_organizations.sql" \
        && echo "DB setup with default organizations data"
    ;;

    bootstrap:dev)
      # add something like the following to scripts/DB/dev.sql
      # UPDATE "Users"
      # SET "PublishingKey" = 'ssh-rsa ...'
      # WHERE
      #   "Id" = X;
      ${COMPOSE} exec db bash -c "if [ -f /scripts/dev.sql ]; then ${PSQL} -d \$POSTGRES_DB -f /scripts/dev.sql; fi" \
        && echo "DB setup with dev data"
    ;;



    ##################
    # Testing
    ci:build)
      ${CI_COMPOSE} build
    ;;

    ci:ui)
      ${CI_COMPOSE} run --rm ui \
        bash -c "yarn && yarn lint && yarn test:ci"
    ;;

    ci:api)
      ${CI_COMPOSE} run --rm api \
        bash -c "dotnet test /app/SIL.AppBuilder.Portal.Backend.Tests/"
    ;;

    ci)
      ${CI_COMPOSE} $arguments
    ;;

    prod:nginx:run)
      runstuff dc start adminer
      runstuff dc start db
      runstuff dc start api
      # 1. Remove existing docker container with tag
      # 2. Rebuild
      # 3. Run

      CURRENT_VERSION=$(git rev-parse HEAD)

      # 1. Remove existing
      docker image rm nginx-$CURRENT_VERSION -f

      # 2. Rebuild
      docker build . -f Dockerfile.nginx \
        --tag "nginx-$CURRENT_VERSION" --target release

      # 3. Run
      docker run -it \
        -p 9091:80 \
        -e "API_URL=http://api.docker:7081" \
        -e "AUTH0_DOMAIN=sil-appbuilder.auth0.com" \
        -e "AUTH0_CLIENT_ID=n8IAE2O17FBrlQ667x5mydhpqelCBUWG" \
        -e "DWKIT_UI_HOST=172.18.0.1" \
        --network appbuilder-portal_default \
        --link appbuilder-portal_api_1:api.docker nginx-$CURRENT_VERSION
    ;;

    ################
    # Host-Machine Utils

    # frontend things
    yarn) ( cd $UI_PATH && yarn $arguments );;
    refresh-languages) ( cd $UI_PATH && ./scripts/refresh-languages.sh );;

    # backend / api things
    dotnet:api) ( cd $API_PATH && dotnet $arguments );;

    dotnet) ( cd source && dotnet ${arguments} );;
    dotnet:ef)
      runstuff dotnet ef \
        ${arguments} \
        --startup-project ./OptimaJet.DWKit.StarterApplication/OptimaJet.DWKit.StarterApplication.csproj \
        --project ./OptimaJet.DWKit.StarterApplication/OptimaJet.DWKit.StarterApplication.csproj \
        --msbuildprojectextensionspath ./out/OptimaJet.DWKit.StarterApplication/obj/
    ;;
    # dotnet:api)

    # Don't name any folders bin, obj, tmp, dist, or node_modules
    clean:all)
      echo "Cleaning..."
      runstuff clean:api
      runstuff clean:frontend
    ;;

    clean:api)
      shopt -s globstar
      rm -rf **/out/ &&
      # rm -rf source//bin && \
      rm -rf **/obj
    ;;

    clean:frontend)
      shopt -s globstar
      runstuff yarn cache clean && \
      rm -rf **/dist && \
      rm -rf **/node_modules && \
      rm -rf **/tmp
    ;;

    *) print_help;;
  esac
}

function print_help {

  echo ""
  echo "Available Commands:"
  echo ""
  echo "dc             : short for docker-compose"
  echo "up:build"
  echo "up"
  echo "up:local:start : starts non-essential services in docker, and the api and ui services natively on the host machine"
  echo ""
  echo "bash           : drop into a bash shell in a temporary docker-compose service"
  echo "restart        : restart a specific docker-compose service"
  echo ""
  echo "bootstrap      : runs initial scripts for project setup"
  echo "bootstrap:dwkit"
  echo "bootstrap:alpha"
  echo "bootstrap:orgs"
  echo "bootstrap:api"
  echo "bootstrap:sample"
  echo "db:migrations  : run Entity Framework migrations command"
  echo "db:update      : run Entity Framework database command"
  echo ""
  echo "yarn"
  echo ""
  echo "dotnet"
  echo ""
  echo "clean:all      : recursively removes dist, node_modules, and tmp directories"
  echo "clean:api"
  echo "clean:frontend"
}

if [ $1 ]; then
  runstuff $*
else
  print_help
fi