apollo

#!/bin/bash

function usage(){
    echo "";
    echo "Usage: apollo <command>";
    echo "";
    echo "Production Commands:";
    echo "";
    echo "deploy:           Builds Unoptimized war file (no processing of javascript) into the target directory.";
    echo "release:          Builds in release mode (minimized javascript). (beta)";
    echo "run-local <port>: Runs from current directory, but not in dev-mode. ";
    echo "help:             This message.";
    echo "";
    echo "Development Commands:";
    echo "devmode:          Runs from current directory debug mode (non-minimized javascript).";
    echo "run-app   <port>: Runs from current directory, but does not compile annotator panel (you have to run run-local once first).";
    echo "test:             Runs test-suite.";
    echo "debug:            Runs from current directory in debug mode (non-minimized javascript).";
    echo "watchman:         Creates watchman daemon to autocopy plugin files (non-minimized javascript).";
    echo "compile:          Compiled the build.";
    echo "clean:            Removes class files.";
    echo "clean-all:        Removes class files and jbrowse files.";
    echo "create-rest-doc:  Recreates REST documentation.";
};


grails_executable=""
gradle_executable=""

if [[ $# == 0 || $1 == help || $1 == --help ]]; then
    usage
    exit 1;
fi

function deploy_message(){
   echo "***************************************"
   echo "NOTE: Please set the memory for your servlet container (tomcat, jetty, etc.) or Apollo may not start correctly: http://genomearchitect.readthedocs.io/en/latest/Troubleshooting.html#suggested-tomcat-memory-settings"
   echo "***************************************"
}

function check_rest_api(){
	if [ ! -f web-app/js/restapidoc/restapidoc.json ]; then 
		$grails_executable rest-api-doc 
	fi
}

function check_java(){
    javac_version=`javac -version 2>&1`
    echo "$javac_version found";
    if [[ $javac_version == javac*  ]]; then
        echo "javac installed";
        minor_version=`echo $javac_version  | cut -d\. -f2 `
        if [[ "$minor_version" != '8' ]] ; then
            echo "You must install JDK 1.8"
            exit 1 ;
        else
            echo "JDK 1.8 found: $javac_version"
        fi
    else
       echo "javac not installed.  Please install JDK 1.8."
       exit 1 ;
    fi
}

function check_node(){
    node_executable=$(which node)
    if ! [ -x "$node_executable" ] ; then
        nodejs_executable=$(which nodejs)
        if ! [ -x "$nodejs_executable" ] ; then
            echo "You must install 'Node JS' to do a release of Apollo."
            exit 1 ;
        else
            echo "STOPPING BUILD: You need to create a symlink from 'node' to 'nodejs'"
            echo "e.g., sudo ln -s $nodejs_executable /usr/bin/node"
            exit 0
        fi
    fi
    npm_executable=$(which npm)
    NPM_VERSION=`$npm_executable -v | cut -d\. -f1`
    if [ $NPM_VERSION -lt 2 ]; then
        echo "npm version 2 or better must be installed.  Please install an updated version of node.js by following the instructions appropriate for your system https://nodejs.org/en/download/package-manager/";
        exit 1
    fi
}

function check_bower(){
    bower_executable=$(which bower)
    if ! [ -x "$bower_executable" ] ; then
        $npm_executable install -g bower
        if ! [ -x "$bower_executable" ] ; then
            echo "You must install 'Bower' to do a release of Apollo.  sudo ${npm_executable} install -g bower"
            exit 1 ;
        fi
    fi
}

function check_perldependencies(){
    perl -e 'use Text::Markdown'
    if [ $? != 0 ] ; then
        echo "Perl package 'Text::Markdown' is required in order to do a release of Apollo."
        exit 1 ;
    fi
    perl -e 'use DateTime'
    if [ $? != 0 ] ; then
        echo "Perl package 'DateTime' is required in order to do a release of Apollo."
        exit 1 ;
    fi
}

function check_configs_for_release(){
    check_perldependencies
}


function check_configs(){
    grails_executable=$(which grails)
    gradle_executable=$(which gradle)
    git_executable=$(which git)
    if ! [ -x "$grails_executable" ] ; then
        if [ -f 'grailsw' ]; then
            echo "Grails not found using grailsw";
            grails_executable="./grailsw"
        else
           echo "You must install 'grails' to install Apollo."
           exit 1 ;
        fi
    fi
    if ! [ -x "$gradle_executable" ] ; then
       if [ -f 'gradlew' ]; then
           echo "Gradle not found using gradlew";
           gradle_executable="./gradlew"
       else
           echo "You must install 'gradle' to install Apollo."
           exit 1 ;
        fi
    fi
    if ! [ -x "$git_executable" ] ; then
       echo "You must install 'git' to install Apollo."
       exit 1 ;
    fi

    check_node
    check_bower
    check_java
}

function copy_configs(){
    rm -f src/java/apollo-config.groovy
    cp apollo-config.groovy src/java/apollo-config.groovy
}

function clean_code(){
    $grails_executable clean
    $gradle_executable cleanAll
}

function clean_all(){
    check_configs
    rm -rf bin
    rm -rf jbrowse-download
    rm -rf JBrowse-dev
    rm -rf web-app/jbrowse
    rm -f *.zip
    clean_code
}


if [[ $1 == "devmode" ]];then
    check_configs
    $gradle_executable handleJBrowse copyResourcesDev devmode &
    $grails_executable -reloading run-app
elif [[ $1 == "run-local" ]];then
    check_configs
    if [[ $# == 2 ]]; then
        $gradle_executable handleJBrowse copy-resources copyResourcesDev gwtc && $grails_executable -Dserver.port=$2 run-app
    else
        $gradle_executable handleJBrowse copy-resources copyResourcesDev gwtc && $grails_executable run-app
    fi
elif [[ $1 == "watchman" ]]; then
    watchman_executable=$(which watchman)
    if ! [ -x "$watchman_executable" ] ; then
        echo "Watchman not found. Install watchman to automatically update the client side plugins for apollo development modes"
    fi
    if [ -x "$watchman_executable" ]; then $watchman_executable -- trigger $(PWD) jsfilescopy 'client/apollo/**/*.js' -- scripts/copy_client.sh; fi;
elif [[ $1 == "run-app" ]];then
    check_configs
    if [[ $# == 2 ]]; then
        $gradle_executable handleJBrowse copyResourcesDev && $grails_executable -Dserver.port=$2 run-app
    else
        $gradle_executable handleJBrowse copyResourcesDev && $grails_executable run-app
    fi
elif [[ $1 == "debug" ]];then
    # TODO: feel like there is a better way to do this
    OLD_MAVEN_OPTS=$MAVEN_OPTS
    check_configs
    copy_configs
    clean_all
    export MAVEN_OPTS=-agentlib:jdwp=transport=dt_socket,address=5005,server=y,suspend=n
    $gradle_executable handleJBrowse devmode &
    $grails_executable -reloading debug
    export MAVEN_OPTS=$OLD_MAVEN_OPTS
    unset OLD_MAVEN_OPTS
elif [[ $1 == "test" ]];then
    check_configs
    copy_configs
    $gradle_executable handleJBrowse 
    check_rest_api
	$grails_executable test-app 
elif [[ $1 == "test-unit" ]];then
    check_configs
    copy_configs
    $grails_executable handleJBrowse test-app :unit
elif [[ $1 == "deploy" ]];then
    check_configs
    copy_configs
    $gradle_executable handleJBrowse copy-resources gwtc &&  $grails_executable war
    deploy_message
elif [[ $1 == "release" ]];then
    check_configs
    check_configs_for_release
    copy_configs
    clean_all
    $gradle_executable handleJBrowse release gwtc && $grails_executable war
    deploy_message
elif [[ $1 == "compile" ]];then
    check_configs
    $gradle_executable gwtc && $grails_executable compile
elif [[ $1 == "create-rest-doc" ]];then
    check_configs
    $grails_executable compile && $grails_executable rest-api-doc && mv -f restapidoc.json web-app/js/restapidoc/
elif [[ $1 == "clean-all" ]];then
    clean_all
elif [[ $1 == "clean" ]];then
    check_configs
    $gradle_executable clean &&  $grails_executable clean
elif [[ $1 == "jbrowse" ]];then
    check_configs
    $gradle_executable handleJBrowse
else
    usage
fi