buckw

#!/usr/bin/env bash

#########################################################################
##
##  Buck wrapper script to invoke okbuck when needed, before running buck
##
#########################################################################

PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
    ls=`ls -ld "$PRG"`
    link=`expr "$ls" : ".*-> \(.*\)$"`
    if expr "$link" : "/.*" > /dev/null; then
        PRG="$link"
    else
        PRG=`dirname "$PRG"`"/$link"
    fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null
SCRIPT_DIR="`pwd -P`"
cd "$SAVED" >/dev/null

red=`tput setaf 1 2>/dev/null || true`
yellow=`tput setaf 3 2>/dev/null || true`
green=`tput setaf 2 2>/dev/null || true`
blue=`tput setaf 4 2>/dev/null || true`
reset=`tput sgr0 2>/dev/null || true`
bold=`tput bold 2>/dev/null || true`

die ( ) {
    echo
    echo "${bold}${red} $* ${reset}"
    echo
    exit 1
}

info ( ) {
    echo "${bold}${blue}$*${reset}"
}

warn ( ) {
    echo "${bold}${yellow}$*${reset}"
}

success ( ) {
    echo
    echo "${bold}${green}$*${reset}"
    echo
}

ensure ( ) {
    command -v $1 >/dev/null 2>&1 || die "ERROR: "$1" could be found in your PATH. Please install $1. $2"
}

jsonq() {
    python -c "import sys,json; obj=json.load(sys.stdin); print($1)"
}

ensure python "https://www.python.org"
INSTALLED_WATCHMAN=`command -v watchman`

OKBUCK_SUCCESS="$SCRIPT_DIR/build/okbuck.success"
OKBUCK_DIR="$SCRIPT_DIR/.okbuck"
MAX_DISPLAY_CHANGES=10
WATCHMAN_TIMEOUT=10
WATCHMAN_FAILED="WATCHMAN FAILED"
BUCK_BINARY_DIR="$OKBUCK_DIR/workspace/buck_binary"

export JAVA_OPTS="${JAVA_OPTS:-\"-Xmx1g\" \"-Xms1g\"}"

# Timeout a call and exit early. This can be called via timeout <time> <command>.
timeout( ) {
    perl -e "alarm shift; exec @ARGV" "$@";
}

ensureWatch ( ) {
    timeout $WATCHMAN_TIMEOUT watchman watch-project "$SCRIPT_DIR" >/dev/null 2>&1
}

removeWatch ( ) {
    timeout $WATCHMAN_TIMEOUT watchman watch-del "$SCRIPT_DIR" >/dev/null 2>&1
}

getChanges ( ) {
    ensureWatch
    WATCHMAN_ERROR_CODE=$?
    if [[ $WATCHMAN_ERROR_CODE -ne 0 ]]; then
        WATCHED_CHANGES=$WATCHMAN_FAILED
        echo "watch-project failed after $WATCHMAN_TIMEOUT seconds, error code: $WATCHMAN_ERROR_CODE"
        removeWatch
        WATCHDEL_ERROR_CODE=$?
        if [[ $WATCHDEL_ERROR_CODE -ne 0 ]]; then
            echo "watch-del failed after $WATCHMAN_TIMEOUT seconds, error code: $?"
            echo "Killing all watchman processes"
            killall watchman || true
        fi
    else
        WATCHED_CHANGES=`watchman --output-encoding=json --no-pretty -j 2>&1 <<-EOT
["query", "$SCRIPT_DIR", {
    "since": "n:okbuck_trig",
    "expression": ["allof",
        ["type", "f"],
        ["anyof",
            ["suffix", "sq"],
            ["suffix", "gradle"],
            ["name", ["gradle-wrapper.properties"]]
        ],
        ["not",
            ["dirname", ".okbuck"]
        ]
    ],
    "fields": ["name"]
}]
EOT`
    SOURCE_ROOTS=`watchman --output-encoding=json --no-pretty -j 2>&1 <<-EOT
["query", "$SCRIPT_DIR", {
    "since": "n:okbuck_source_roots",
    "expression": ["anyof",
        ["allof",
        ["type", "d"],
        ["anyof",
            ["match", "**/src/**/java", "wholename"],
            ["match", "**/src/**/res", "wholename"],
            ["match", "**/src/**/kotlin", "wholename"],
            ["match", "**/src/**/resources", "wholename"]
        ],
        ["not",
            ["dirname", ".okbuck"]
        ]
    ],
    ["allof",
        ["type", "f"],
        ["anyof", ["name", "AndroidManifest.xml"]],
        ["not", ["dirname", ".okbuck"]]
    ]
    ],
    "fields": ["new", "exists", "name"]
}]
EOT`
    fi
}

updateOkBuckSuccess ( ) {
    OKBUCK_SUCCESS_DIR=`dirname $OKBUCK_SUCCESS`
    mkdir -p $OKBUCK_SUCCESS_DIR
    touch "$OKBUCK_SUCCESS"
}

runOkBuck ( ) {
    info "RUNNING OKBUCK..."
    echo

    rm -f $OKBUCK_SUCCESS
    ( "$SCRIPT_DIR/gradlew" -p "$SCRIPT_DIR" okbuck -Dokbuck.wrapper=true $EXTRA_OKBUCK_ARGS &&
    updateOkBuckSuccess && success "PROCEEDING WITH BUCK" ) || die "OKBUCK FAILED"
}

watchmanWorkflow ( ) {
    # Get list of changed files since last time by querying watchman
    getChanges
    if [[ "$WATCHED_CHANGES" = "$WATCHMAN_FAILED" ]]; then
        runOkBuck
    else
        # Format list for simpler output
        CHANGES=$(echo $WATCHED_CHANGES | jsonq '" ".join(obj["files"])')
        NEW_OR_DELETED_SOURCE_ROOTS=$(echo $SOURCE_ROOTS | jsonq '" ".join([f["name"] for f in obj["files"] if (not f["exists"] or f["new"])])')
        NUM_CHANGES=$(echo $CHANGES $NEW_OR_DELETED_SOURCE_ROOTS | wc -w)

        if [[ $NUM_CHANGES -gt 0 ]]; then
            info "CHANGES DETECTED IN:"
            echo $CHANGES $NEW_OR_DELETED_SOURCE_ROOTS | tr " " "\n" | head -n $MAX_DISPLAY_CHANGES
            if [[ $NUM_CHANGES -gt $MAX_DISPLAY_CHANGES ]]; then
                DIFF=`expr $NUM_CHANGES - $MAX_DISPLAY_CHANGES`
                echo "...and $DIFF more"
            fi
            echo
            runOkBuck
        fi
    fi
}

setupBuckBinary ( ) {
    BUCK_BINARY=$(find "$BUCK_BINARY_DIR" -name buck*.pex)

    if [[ ! -x "$BUCK_BINARY" ]]; then
        chmod +x "$BUCK_BINARY"
    fi
}

# Run tasks before buck command
setupBuckRun ( ) {
    if [[ ! -z "$SKIP_OKBUCK" ]]; then
        :
    elif [[ ! -z "$FORCE_OKBUCK" ]]; then
        runOkBuck
    elif [[ ! -f "$OKBUCK_SUCCESS" ]] || [[ ! -d "$OKBUCK_DIR" ]]; then
        warn "NO PREVIOUS SUCCESSFUL OKBUCK RUN"
        if [[ ! -z "$INSTALLED_WATCHMAN" ]]; then
            getChanges # Prevent watchman from running after this run, since changes would already be accounted for
        fi
        runOkBuck
    elif [[ ! -z "$INSTALLED_WATCHMAN" ]]; then
        watchmanWorkflow
    else
        warn "ALWAYS RUNNING OKBUCK SINCE WATCHMAN IS NOT INSTALLED"
        warn "INSTALL WATCHMAN FOR FASTER BUILDS"
        warn "https://facebook.github.io/watchman"
        echo
        runOkBuck
    fi

    setupBuckBinary

    # Replace kotlin_home config with full path instead of source path
    local kotlin_home
    kotlin_home=$("$BUCK_BINARY" audit config kotlin.kotlin_home)

    if [[ "$kotlin_home" == *":kotlin_home"* ]]; then
        echo "changing kotlin home"
        local resolved_kotlin_home
        resolved_kotlin_home=$("$BUCK_BINARY" build //.okbuck/workspace/kotlin_home:kotlin_home --show-output | awk '{print $2}')
        sed -i.bak "s://.okbuck/workspace/kotlin_home\:kotlin_home:${resolved_kotlin_home}:g" .okbuck/config/okbuck.buckconfig
    fi
}

# Handle parameters and flags
handleParams ( ) {
   SKIP_FLAGS=""
   for arg in "$@"
   do
       case "$arg" in
       --help|-h|help|kill) export SKIP_OKBUCK=1 && SKIP_FLAGS=1 ;; # Go directly to the kill command, help command, or --help option. Do not run okbuck.
       --version) export SKIP_FLAGS=1;;
       esac;
   done
}

handleParams "$@"
setupBuckRun

# Invoke buck binary with arguments
exec "$BUCK_BINARY" "$@" $EXTRA_BUCK_CONFIG