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/cache/buck_binary"

# 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", "gradle"],
            ["suffix", "map"],
            ["suffix", "sq"],
            ["suffix", "pro"],
            ["name", ["lint.xml", "gradle-wrapper.properties"]],
            ["match", "**/src/**/AndroidManifest.xml", "wholename"]
        ],
        ["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": ["allof",
        ["type", "d"],
        ["anyof",
            ["match", "**/src/**/java", "wholename"],
            ["match", "**/src/**/res", "wholename"],
            ["match", "**/src/**/resources", "wholename"]
        ],
        ["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
}

killBuckDaemons ( ) {
    DAEMONS=$(ps -ef | grep "[c]om.facebook.buck.cli.Main\$DaemonBootstrap" | awk '{print $2}')
    if [ ! -z "$DAEMONS" ]; then
        echo "$DAEMONS" | xargs kill -9
    fi
}

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

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

    # No existing daemon or clean project root
    BUCKD_VERSION_FILE="$SCRIPT_DIR/.buckd/buckd.version"
    if [[ ! -f "$BUCKD_VERSION_FILE" ]]; then
        killBuckDaemons
    else
        BUCKD_VERSION=$(cat "$BUCKD_VERSION_FILE")
    fi

    # Unknown daemon state
    if [[ -z "$BUCKD_VERSION" ]]; then
        killBuckDaemons
    fi

    # Daemon version does not match
    BUCK_BINARY_VERSION=$(basename "$BUCK_BINARY" | cut -f 1 -d "." | cut -f 2 -d "-")
    if [[ "$BUCK_BINARY_VERSION" != "$BUCKD_VERSION" ]]; then
        killBuckDaemons
    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
}

# Handle parameters and flags
handleParams ( ) {
   # Go directly to the kill command, help command, or --help option. Do not run okbuck.
   if [[ "kill" == $1 || "help" == $1 || $@ == *"--help"* || $@ == *" -h "* ]]; then
      SKIP_OKBUCK=true
   fi
}

handleParams "$@"
setupBuckRun

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