ci-echo

#!/usr/bin/env bash
set -euo pipefail

YP_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." >/dev/null && pwd)"
source ${YP_DIR}/sh/common.inc.sh

#- ci-echo 1.0
## Usage: ci-echo [OPTION] -- STEP TEXT...
## Echo message with a STEP indicator for stdout or for TeamCity/Travis consumption.
##
##   --benchmark    Benchmark file to use for benchmarking groups (DO-DONE durations).
##   --external     Path to external logger.
##                  Defaults to ci-echo-external-honeycomb if
##                  both CI_ECHO_EXTERNAL_HONEYCOMB_API_KEY and
##                  and CI_ECHO_EXTERNAL_HONEYCOMB_DATASET are set.
##
##   -h, --help     Display this help and exit
##   -v, --version  Output version information and exit

BENCHMARK=/dev/null
EXTERNAL=

[[ "${CI:-}" != "true" ]] || \
    [[ -z "${YP_CI_ECHO_EXTERNAL_HONEYCOMB_API_KEY:-}" ]] || \
    [[ -z "${YP_CI_ECHO_EXTERNAL_HONEYCOMB_DATASET:-}" ]] || \
    EXTERNAL=${YP_DIR}/bin/ci-echo-external-honeycomb

if { getopt --test >/dev/null 2>&1 && false; } || [[ "$?" = "4" ]] || false; then
    ARGS=$(getopt -o hv -l help,version,benchmark:,external: -n $(basename ${BASH_SOURCE[0]}) -- "$@") || sh_script_usage
    eval set -- "${ARGS}"
fi

function timestamp_nano() {
    local TIMESTAMP_NANO=$(date +"%s%N")
    echo ${TIMESTAMP_NANO}
}
# if not GNU date, then do best effort
[[ $(date +"%N") != "N" ]] || {
    # shellcheck disable=SC1091
    YP_NANOSECONDS_VSN=$(source ${YP_DIR}/CONST.inc && echo "${YP_NANOSECONDS_VSN}")
    function timestamp_nano() {
        local TIMESTAMP_NANO
        # bypass the proxy executable for speed reasons
        # local NANOSECONDS_BINARY=${YP_DIR}/bin/nanoseconds
        local NANOSECONDS_BINARY=nanoseconds-${YP_NANOSECONDS_VSN}-${OS_SHORT}-${ARCH_NORMALIZED}
        NANOSECONDS_BINARY=${YP_DIR}/bin/nanoseconds-${YP_NANOSECONDS_VSN}/${NANOSECONDS_BINARY}
        if [[ -e "${NANOSECONDS_BINARY}" ]]; then
            TIMESTAMP_NANO=$(${NANOSECONDS_BINARY})
        else
            # seconds to nanoseconds
            TIMESTAMP_NANO=$(date +"%s")000000000
        fi
        echo ${TIMESTAMP_NANO}
    }
}

while [[ $# -gt 0 ]]; do
    case "$1" in
        --benchmark)
            BENCHMARK=$2
            shift 2
            [[ -e "${BENCHMARK}" ]] || {
                touch ${BENCHMARK}
                chmod a+rw ${BENCHMARK}
                echo "$(timestamp_nano) 0 benchmark" >> ${BENCHMARK}
            }
            ;;
        --external)
            EXTERNAL=$2
            shift 2
            ;;
        -h|--help)
            sh_script_usage
            ;;
        -v|--version)
            sh_script_version
            ;;
        --)
            shift
            break
            ;;
        -*)
            sh_script_usage
            ;;
        *)
            break
            ;;
    esac
done
# [[ $# -eq 0 ]] || sh_script_usage

[[ -z "${EXTERNAL}" ]] || {
    [[ -e "${EXTERNAL}" ]] || {
        >&2 echo "$(timestamp)" "[ERR ] External logger '${EXTERNAL}' doesn't exist."
        exit 1
    }
    [[ -x "${EXTERNAL}" ]] || {
        >&2 echo "$(timestamp)" "[ERR ] External logger '${EXTERNAL}' isn't executable."
        exit 1
    }
}

STOPWATCH_TIMESTAMP_NANO=$(cat ${BENCHMARK} | head -n1 | cut -d" " -f1 || true)

DATE_REF="--date=@"
# assume bsd/macos
date --date=@0 >/dev/null 2>&1 || DATE_REF="-r "

function timestamp() {
    local TIMESTAMP_NANO=$(timestamp_nano)
    local TIMESTAMP_MS="$(( ${TIMESTAMP_NANO} / 1000000000 ))"
    local TIMESTAMP=$(date "${DATE_REF}${TIMESTAMP_MS}" +%H:%M:%S)
    if [[ -z "${STOPWATCH_TIMESTAMP_NANO}" ]]; then
        echo "${TIMESTAMP}"
    else
        local STOPWATCH_TIMESTAMP_MS="$(( (${TIMESTAMP_NANO} - ${STOPWATCH_TIMESTAMP_NANO}) / 1000000000 ))"
        local STOPWATCH=$(date -u "${DATE_REF}${STOPWATCH_TIMESTAMP_MS}" +%H:%M:%S)
        echo "${TIMESTAMP} ${STOPWATCH}"
    fi
}

function fallback_echo() {
    case "$1" in
        "[DO  ]"|"[DONE]")
            local COLOR_DIM="\e[2m"
            local COLOR_RESET="\e[0m"

            [[ "${CI}" != "true" ]] || {
                COLOR_DIM=
                COLOR_RESET=
            }
            ;;
        *)
            ;;
    esac

    case $1 in
        "[DO  ]")
            >&2 echo
            >&2 echo -e "$(timestamp) $1 ${GROUP}"
            >&2 echo -e "              ${COLOR_DIM}> ${PWD_GROUP}${COLOR_RESET}"
            >&2 echo
            ;;
        "[DONE]")
            >&2 echo
            >&2 echo -e "              ${COLOR_DIM}< ${PWD_GROUP}${COLOR_RESET}"
            >&2 echo -e "$(timestamp) $1 ${GROUP}"
            >&2 echo -e "                in $(( ${GROUP_DURATION} / 1000000000 )) seconds"
            >&2 echo
            ;;
        ""|"      ")
            [[ -z "${GROUP}" ]] || >&2 echo "$(timestamp | sed "s/./ /g") $1 ${GROUP}"
            ;;
        *)
            >&2 echo "$(timestamp) $1 ${GROUP}"
            ;;
    esac
}

function basic_travis_echo() {
    # local ANSI_RED="\033[31;1m"
    # local ANSI_GREEN="\033[32;1m"
    # local ANSI_RESET="\033[0m"
    local ANSI_CLEAR_LINE="\033[0K"

    local XTRACE_STATE="$(set +o | grep xtrace)"
    set +x
    echo -en "$*\\r${ANSI_CLEAR_LINE}"
    eval "${XTRACE_STATE}"
}

function travis_echo() {
    case $1 in
        "[DO  ]")
            >&2 echo
            basic_travis_echo "travis_fold:start:${PWD_GROUP}"
            basic_travis_echo "travis_time:start:${PWD_GROUP}"
            >&2 echo "$(timestamp) $1 ${GROUP}"
            >&2 echo -e "              > ${PWD_GROUP}"
            >&2 echo
            ;;
        "[DONE]")
            >&2 echo
            >&2 echo -e "              < ${PWD_GROUP}"

            basic_travis_echo "travis_time:end:${PWD_GROUP}:start=${GROUP_START}000000000,finish=${GROUP_FINISH},duration=${GROUP_DURATION}"
            basic_travis_echo "travis_fold:end:${PWD_GROUP}"
            >&2 echo "$(timestamp) $1 ${GROUP}"
            >&2 echo "$(timestamp)        in $(( ${GROUP_DURATION} / 1000000000 )) seconds"
            >&2 echo
            ;;
        ""|"      ")
            [[ -z "${GROUP}" ]] || >&2 echo "$(timestamp | sed "s/./ /g") $1 ${GROUP}"
            ;;
        *)
            >&2 echo "$(timestamp) $1 ${GROUP}"
            ;;
    esac
}

function github_actions_echo() {
    case $1 in
        "[DO  ]")
            >&2 echo
            >&2 echo -e "$(timestamp) $1 ${GROUP}"

            # NOTE nesting doesn't work properly
            # see https://github.com/actions/runner/issues/802
            GITHUB_GROUP_MARKER=/tmp/ci-echo-github-group
            [[ -f "${GITHUB_GROUP_MARKER}" ]] || {
                echo -n "${PWD_GROUP}" > ${GITHUB_GROUP_MARKER}
                >&2 echo "::group::${PWD_GROUP}"
            }

            >&2 echo -e "              > ${PWD_GROUP}"
            >&2 echo
            ;;
        "[DONE]")
            >&2 echo
            >&2 echo -e "              < ${PWD_GROUP}"

            # NOTE nesting doesn't work properly
            # see https://github.com/actions/runner/issues/802
            GITHUB_GROUP_MARKER=/tmp/ci-echo-github-group
            [[ ! -f "${GITHUB_GROUP_MARKER}" ]] || {
                PWD_GROUP2="$(cat "${GITHUB_GROUP_MARKER}")"
                [[ "${PWD_GROUP2}" != "${PWD_GROUP}" ]] || {
                    rm -f "${GITHUB_GROUP_MARKER}"
                    >&2 echo "::endgroup::"
                }
            }

            >&2 echo -e "$(timestamp) $1 ${GROUP}"
            >&2 echo -e "                in $(( ${GROUP_DURATION} / 1000000000 )) seconds"
            >&2 echo
            ;;
        # "[WARN]")
        #     >&2 echo "$(timestamp) $1 ${GROUP}"
        #     echo "::warning::${GROUP}"
        #     ;;
        # "[ERR ]")
        #     >&2 echo "$(timestamp) $1 ${GROUP}"
        #     echo "::error::${GROUP}"
        #     ;;
        ""|"      ")
            [[ -z "${GROUP}" ]] || >&2 echo "$(timestamp | sed "s/./ /g") $1 ${GROUP}"
            ;;
        *)
            >&2 echo "$(timestamp) $1 ${GROUP}"
            ;;
    esac
}

function basic_teamcity_echo() {
    local XTRACE_STATE="$(set +o | grep xtrace)"
    set +x
    echo "##teamcity[$*]"
    eval "${XTRACE_STATE}"
}

function teamcity_echo() {
    local MESSAGE="$(echo "${GROUP}" | sed "s/'/|'/")"
    local STATUS=NORMAL

    case "$1" in
        "[DO  ]"|"[DONE]")
            local PWD_MESSAGE="${REL_PWD} ${MESSAGE}"
            ;;
        *)
            ;;
    esac

    case $1 in
        "[NEXT]")
            echo "##teamcity[progressMessage '${MESSAGE}']"
            return 0
            ;;
        "[DO  ]")
            TEAMCITY_BLOCK_MARKER=/tmp/ci_echo_teamcity_block_${RANDOM}
            echo -n "${PWD_MESSAGE}" > ${TEAMCITY_BLOCK_MARKER}
            basic_teamcity_echo "blockOpened name='${PWD_MESSAGE}'"
            return 0
            ;;
        "[DONE]")
            [[ -n "${MESSAGE}" ]] || {
                # shellcheck disable=SC2012
                TEAMCITY_BLOCK_MARKER=$(ls -t /tmp/ci_echo_teamcity_block_* 2>/dev/null | head -n1 || true)
                [[ ! -f "${TEAMCITY_BLOCK_MARKER}" ]] || {
                    PWD_MESSAGE="$(cat ${TEAMCITY_BLOCK_MARKER})"
                    rm -f ${TEAMCITY_BLOCK_MARKER}
                }
            }
            basic_teamcity_echo "blockClosed name='${PWD_MESSAGE}'"
            echo
            return 0
            ;;
        "[SKIP]")
            STATUS=WARNING
            ;;
        "[WARN]")
            STATUS=WARNING
            ;;
        "[ERR ]")
            STATUS=ERROR
            ;;
        "[INFO]"|*)
            ;;
    esac

    echo "##teamcity[message text='${MESSAGE}' status='${STATUS}']"
}

GROUP="${*:2}"

case "${1:-}" in
    "[DO  ]")
        GROUP_START=$(timestamp_nano)
        REL_PWD=$(${YP_DIR}/bin/relpath "$(pwd)" "${HOME}" 2>/dev/null || pwd)
        PWD_GROUP="$(echo "${REL_PWD} ${GROUP}" | tr "[:upper:]" "[:lower:]" | sed "s/[^a-z0-9]\{1,\}/-/g" | sed "s/^-//" | sed "s/-$//")"

        # shellcheck disable=SC2012
        # PARENT_GROUP_MARKER=$(ls -t /tmp/ci-echo-group-* 2>/dev/null | head -n1 || true)
        # PARENT_GROUP_MARKER_PWD_GROUP=
        # [[ -z "${PARENT_GROUP_MARKER}" ]] || \
        #     PARENT_GROUP_MARKER_PWD_GROUP="$(cat "${PARENT_GROUP_MARKER}" | sed -n "3,3 p")"

        # GROUP_MARKER=/tmp/ci-echo-group-${PWD_GROUP}-${GROUP_START}_${RANDOM}
        GROUP_MARKER=/tmp/ci-echo-group-${GROUP_START}-${RANDOM}
        echo -e "${GROUP_START}\n${GROUP}\n${PWD_GROUP}" > ${GROUP_MARKER}
        # [[ -z "${EXTERNAL}" ]] || ${EXTERNAL} \
        #     --group-parent "${PARENT_GROUP_MARKER_PWD_GROUP}" \
        #     --group "${PWD_GROUP}" \
        #     --group-start "${GROUP_START}" &
        ;;
    "[DONE]")
        REL_PWD=$(${YP_DIR}/bin/relpath "$(pwd)" "${HOME}" 2>/dev/null || pwd)
        # PWD_GROUP_PREFIX="$(echo "${REL_PWD}" | tr "A-Z" "a-z" | sed "s/[^a-z0-9]\{1,\}/-/g" | sed "s/^-//" | sed "s/-$//")"

        GROUP_FINISH=$(timestamp_nano)
        GROUP_START=${GROUP_FINISH}
        GROUP_DURATION=0

        [[ -n "${GROUP}" ]] || {
            # shellcheck disable=SC2012
            # GROUP_MARKER=$(ls -t /tmp/ci-echo-group-${PWD_GROUP_PREFIX}-* 2>/dev/null | head -n1 || true)
            GROUP_MARKER=$(ls -t /tmp/ci-echo-group-* 2>/dev/null | head -n1 || true)
            [[ ! -f "${GROUP_MARKER}" ]] || {
                GROUP_START=$(cat ${GROUP_MARKER} | sed -n "1,1 p")
                GROUP=$(cat ${GROUP_MARKER} | sed -n "2,2 p")
                PWD_GROUP=$(cat ${GROUP_MARKER} | sed -n "3,3 p")
                GROUP_DURATION=$(( ${GROUP_FINISH} - ${GROUP_START} ))
                rm -f ${GROUP_MARKER}

                # shellcheck disable=SC2012
                PARENT_GROUP_MARKER=$(ls -t /tmp/ci-echo-group-* 2>/dev/null | head -n1 || true)
                PARENT_GROUP_MARKER_PWD_GROUP=
                [[ -z "${PARENT_GROUP_MARKER}" ]] || \
                    PARENT_GROUP_MARKER_PWD_GROUP="$(cat "${PARENT_GROUP_MARKER}" | sed -n "3,3 p")"

                echo "${GROUP_START} ${GROUP_DURATION} ${PWD_GROUP}" >> ${BENCHMARK}
                [[ -z "${EXTERNAL}" ]] || ${EXTERNAL} \
                    --group-parent "${PARENT_GROUP_MARKER_PWD_GROUP}" \
                    --group "${PWD_GROUP}" \
                    --group-start "${GROUP_START}" \
                    --group-duration "${GROUP_DURATION}" &
            }
        }

        [[ -n "${PWD_GROUP:-}" ]] || {
            >&2 echo "$(timestamp)" "[ERR ] Looks like you've called 'ci-echo [DONE]' without calling 'ci-echo [DO  ]' first."
            exit 1
        }
        ;;
    *)
        ;;
esac

if [[ "${TRAVIS:-}" = "true" ]]; then
    travis_echo "${1:-}" "${GROUP}"
elif [[ -n "${GITHUB_ACTIONS:-}" ]]; then
    github_actions_echo "${1:-}" "${GROUP}"
elif [[ -n "${TEAMCITY_VERSION:-}" ]]; then
    teamcity_echo "${1:-}" "${GROUP}"
else
    fallback_echo "${1:-}" "${GROUP}"
fi