run

#!/bin/bash
#
# Copyright (c) 2020-2021, NVIDIA CORPORATION.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

init_globals() {
    if [ "$0" != "/bin/bash" ]; then
        RUN_SCRIPT_FILE="$(readlink -f "$0")"
        SCRIPT_DIR=$(dirname "${RUN_SCRIPT_FILE}")
        export RUN_SCRIPT_FILE
    else
        RUN_SCRIPT_FILE="$(readlink -f "${BASH_SOURCE[0]}")"
        export RUN_SCRIPT_FILE
    fi

    TOP=$(git rev-parse --show-toplevel || dirname "${RUN_SCRIPT_FILE}")
    export TOP
}

################################################################################
# Utility functions
################################################################################

#######################################
# Get list of available commands from a given input file.
#
# Available commands and command summary are extracted by checking a pattern
# "_desc() { echo '".
# Section title is extracted by checking a pattern "# Section: ".
# This command is used for listing available commands in CLI.
#
# e.g.)
#   "# Section: String/IO functions"
#     => "# String/IO functions"
#   "to_lower_desc() { echo 'Convert to lower case"
#     => "to_lower ----------------- Convert to lower case"
#
# Arguments:
#   $1 - input file that defines commands
# Returns:
#   Print list of available commands from $1
#######################################
get_list_of_available_commands() {
    if [ ! -e "$1" ]; then
        echo "$1 doesn't exist!"
    fi

    local line_str='--------------------------------'
    local IFS
    local cmd_lines
    cmd_lines="$(IFS= grep -E -e "^(([[:alpha:]_[:digit:]]+)_desc\(\)|# Section: )" "$1" | sed "s/_desc() *{ *echo '/ : /")"
    local line
    while IFS= read -r line; do
        local cmd
        local desc
        cmd=$(echo "$line" | cut -d":" -f1)
        desc=$(echo "$line" | cut -d":" -f2-)
        if [ "$cmd" = "# Section" ]; then
            c_echo B "${desc}"
        else
            # there is no substring operation in 'sh' so use 'cut'
            local dash_line
            dash_line="$(echo "${line_str}" | cut -c ${#cmd}-)"  #  = "${line_str:${#cmd}}"
             c_echo Y "   ${cmd}" w " ${dash_line} ${desc}"
        fi
        # use <<EOF, not '<<<"$cmd_lines"' to be executable in sh
    done <<EOF
$cmd_lines
EOF
}

my_cat_prefix() {
    local IFS
    local prefix="$1"
    local line
    while IFS= read -r line; do
        echo "${prefix}${line}" # -e option doesn't work in 'sh' so disallow escaped characters
    done <&0
}


c_str() {
    local old_color=39
    local old_attr=0
    local color=39
    local attr=0
    local text=""
    #local no_change=0
    for i in "$@"; do
        case "$i" in
            r|R)
                color=31
                ;;
            g|G)
                color=32
                ;;
            y|Y)
                color=33
                ;;
            b|B)
                color=34
                ;;
            p|P)
                color=35
                ;;
            c|C)
                color=36
                ;;
            w|W)
                color=37
                ;;

            z|Z)
                color=0
                ;;
        esac
        case "$i" in
            l|L|R|G|Y|B|P|C|W)
                attr=1
                ;;
            n|N|r|g|y|b|p|c|w)
                attr=0
                ;;
            z|Z)
                attr=0
                ;;
            *)
                text="${text}$i"
        esac
        if [ ${old_color} -ne ${color} ] || [ ${old_attr} -ne ${attr} ]; then
            text="${text}\033[${attr};${color}m"
            old_color=$color
            old_attr=$attr
        fi
    done
    /bin/echo -en "$text"
}

c_echo() {
    # shellcheck disable=SC2155
    local old_opt="$(shopt -op xtrace)" # save old xtrace option
    set +x # unset xtrace
    local text
    text="$(c_str "$@")"
    /bin/echo -e "$text\033[0m"
    eval "${old_opt}" # restore old xtrace option
}


echo_err() {
    >&2 echo "$@"
}

c_echo_err() {
    >&2 c_echo "$@"
}

printf_err() {
    >&2 printf '%s' "$@"
}

get_item_ranges() {
    local indexes="$1"
    local list="$2"
    echo -n "$(echo "${list}" | xargs | cut -d " " -f "${indexes}")"
}

get_unused_ports() {
    local num_of_ports=${1:-1}
    local start=${2:-49152}
    local end=${3:-61000}
    comm -23 \
    <(seq "${start}" "${end}" | sort) \
    <(ss -tan | awk '{print $4}' | while read -r line; do echo "${line##*\:}"; done | grep '[0-9]\{1,5\}' | sort -u) \
    | shuf | tail -n "${num_of_ports}" # use tail instead head to avoid broken pipe in VSCode terminal
}

newline() {
    echo
}

info() {
    c_echo W "$(date -u '+%Y-%m-%d %H:%M:%S') [INFO] " Z "$@"
}

error() {
    echo R "$(date -u '+%Y-%m-%d %H:%M:%S') [ERROR] " Z "$@"
}

fatal() {
    echo R "$(date -u '+%Y-%m-%d %H:%M:%S') [FATAL] " Z "$@"
    echo
    if [ -n "${SCRIPT_DIR}" ]; then
        exit 1
    fi
}

run_command() {
    local status=0
    local cmd="$*"

    c_echo B "$(date -u '+%Y-%m-%d %H:%M:%S') " W "\$ " G "${cmd}"

    [ "$(echo -n "$@")" = "" ] && return 1 # return 1 if there is no command available

    "$@"
    status=$?

    unset IFS

    return $status
}

retry() {
    local retries=$1
    shift

    local count=0
    until run_command "$@"; do
        exit=$?
        wait=$((2 ** count))
        count=$((count + 1))
        if [ $count -lt "$retries" ]; then
            info "Retry $count/$retries. Exit code=$exit, Retrying in $wait seconds..."
            sleep $wait
        else
            fatal "Retry $count/$retries. Exit code=$exit, no more retries left."
            return 1
        fi
    done
    return 0
}

get_arch() {
    local platform
    platform="$(uname -p)"
    local platform_str

    case "${platform}" in
        amd64|x86_64|x86|linux/amd64)
            platform_str="x86_64"
            ;;
        arm64|aarch64|arm|linux/arm64)
            platform_str="aarch64"
            ;;
    esac

    echo -n "${platform_str}"
}

is_aarch64() {
    get_arch | grep -q "aarch64" && return 0 || return 1
}

is_x86_64() {
    get_arch | grep -q "x86_64" && return 0 || return 1
}

#==================================================================================
# Section: Build
#==================================================================================

build_local_libcucim_() {
    local source_folder=${1:-${TOP}}
    local build_type=${2:-debug}
    local build_type_str=${3:-Debug}
    local prefix=${4:-}
    local build_folder=${source_folder}/build-${build_type}
    local CMAKE_CMD=${CMAKE_CMD:-cmake}

    pushd "${source_folder}" > /dev/null

    ${CMAKE_CMD} -S "${source_folder}" -B "${build_folder}" -G "Unix Makefiles" \
        -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE \
        -DCMAKE_PREFIX_PATH="${prefix}" \
        -DCMAKE_BUILD_TYPE="${build_type_str}" \
        -DCMAKE_INSTALL_PREFIX="${source_folder}/install"
    ${CMAKE_CMD} --build "${build_folder}" --config "${build_type_str}" --target cucim -- -j "$(nproc)"
    ${CMAKE_CMD} --build "${build_folder}" --config "${build_type_str}" --target install -- -j "$(nproc)"

    popd
}

build_local_cuslide_() {
    local source_folder=${1:-${TOP}/cpp/plugins/cucim.kit.cuslide}
    local build_type=${2:-debug}
    local build_type_str=${3:-Debug}
    local prefix=${4:-}
    local build_folder=${source_folder}/build-${build_type}
    local CMAKE_CMD=${CMAKE_CMD:-cmake}

    pushd "${source_folder}" > /dev/null

    ${CMAKE_CMD} -S "${source_folder}" -B "${build_folder}" -G "Unix Makefiles" \
        -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE \
        -DCMAKE_BUILD_TYPE="${build_type_str}" \
        -DCMAKE_PREFIX_PATH="${prefix}" \
        -DCMAKE_INSTALL_PREFIX="${source_folder}/install"
    ${CMAKE_CMD} --build "${build_folder}" --config "${build_type_str}" --target cucim.kit.cuslide -- -j "$(nproc)"
    ${CMAKE_CMD} --build "${build_folder}" --config "${build_type_str}" --target install -- -j "$(nproc)"

    popd
}

build_local_cuslide2_() {
    local source_folder=${1:-${TOP}/cpp/plugins/cucim.kit.cuslide2}
    local build_type=${2:-debug}
    local build_type_str=${3:-Debug}
    local prefix=${4:-}
    local build_folder=${source_folder}/build-${build_type}
    local CMAKE_CMD=${CMAKE_CMD:-cmake}

    pushd "${source_folder}" > /dev/null

    ${CMAKE_CMD} -S "${source_folder}" -B "${build_folder}" -G "Unix Makefiles" \
        -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE \
        -DCMAKE_BUILD_TYPE="${build_type_str}" \
        -DCMAKE_PREFIX_PATH="${prefix}" \
        -DCMAKE_INSTALL_PREFIX="${source_folder}/install"
    ${CMAKE_CMD} --build "${build_folder}" --config "${build_type_str}" --target cucim.kit.cuslide2 -- -j "$(nproc)"
    ${CMAKE_CMD} --build "${build_folder}" --config "${build_type_str}" --target install -- -j "$(nproc)"

    popd
}

build_local_cumed_() {
    local source_folder=${1:-${TOP}/cpp/plugins/cucim.kit.cumed}
    local build_type=${2:-debug}
    local build_type_str=${3:-Debug}
    local prefix=${4:-}
    local build_folder=${source_folder}/build-${build_type}
    local CMAKE_CMD=${CMAKE_CMD:-cmake}

    pushd "${source_folder}" > /dev/null

    ${CMAKE_CMD} -S "${source_folder}" -B "${build_folder}" -G "Unix Makefiles" \
        -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE \
        -DCMAKE_BUILD_TYPE="${build_type_str}" \
        -DCMAKE_PREFIX_PATH="${prefix}" \
        -DCMAKE_INSTALL_PREFIX="${source_folder}/install"
    ${CMAKE_CMD} --build "${build_folder}" --config "${build_type_str}" --target cucim.kit.cumed -- -j "$(nproc)"
    ${CMAKE_CMD} --build "${build_folder}" --config "${build_type_str}" --target install -- -j "$(nproc)"

    popd
}

build_local_cucim_() {
    local source_folder=${1:-${TOP}/python}
    local build_type=${2:-debug}
    local build_type_str=${3:-Debug}
    local prefix=${4:-}
    local build_folder=${source_folder}/build-${build_type}
    local CMAKE_CMD=${CMAKE_CMD:-cmake}

    pushd "${source_folder}" > /dev/null

    local python_library
    python_library=$(python3 -c "import sysconfig, os; print(os.path.join(sysconfig.get_config_var('LIBDIR'), sysconfig.get_config_var('LDLIBRARY')))")
    local python_include_dir
    python_include_dir=$(python3 -c "import sysconfig; print(sysconfig.get_path('include'))")

    ${CMAKE_CMD} -S "${source_folder}" -B "${build_folder}" -G "Unix Makefiles" \
        -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE \
        -DCMAKE_BUILD_TYPE="${build_type_str}" \
        -DCMAKE_PREFIX_PATH="${prefix}" \
        -DCMAKE_INSTALL_PREFIX="${source_folder}/install" \
        -DPYTHON_EXECUTABLE="$(which python3)" \
        -DPYTHON_LIBRARY="${python_library}" \
        -DPYTHON_INCLUDE_DIR="${python_include_dir}"
    ${CMAKE_CMD} --build "${build_folder}" --config "${build_type_str}" --target cucim -- -j "$(nproc)"
    ${CMAKE_CMD} --build "${build_folder}" --config "${build_type_str}" --target install -- -j "$(nproc)"

    popd
}

# shellcheck disable=SC2016
build_local_desc() { echo 'Build locally

Compile binaries locally

Arguments:
  $1 - subcommand [all|clean_cache|clean|libcucim|cuslide|cumed|cucim] (default: all)
  $2 - build type [debug|release|rel-debug] (default: debug)
'
}
build_local() {
    local subcommand="${1:-all}"
    local build_type="${2:-debug}"
    local build_type_str="Debug"
    local prefix=${3:-}

    local major_version
    major_version="$(cut -d. -f1 "${TOP}/VERSION")" # major version number

    [ "${build_type}" = "debug" ] && build_type_str="Debug"
    [ "${build_type}" = "release" ] && build_type_str="Release"
    [ "${build_type}" = "rel-debug" ] && build_type_str="RelWithDebInfo"

    local old_opt
    old_opt="$(shopt -op errexit);$(shopt -op nounset)" # save old shopts
    set -eu

    if [ "$subcommand" = "clean_cache" ]; then
        rm -f "${TOP}"/build-*/CMakeCache.txt
        rm -f "${TOP}"/cpp/plugins/cucim.kit.cuslide/build-*/CMakeCache.txt
        rm -f "${TOP}"/cpp/plugins/cucim.kit.cumed/build-*/CMakeCache.txt
        rm -f "${TOP}"/cpp/plugins/cucim.kit.cuslide2/build-*/CMakeCache.txt
        rm -f "${TOP}"/python/build-*/CMakeCache.txt
    fi

    if [ "$subcommand" = "clean" ]; then
        rm -rf "${TOP}"/build-*
        rm -rf "${TOP}"/install
        rm -rf "${TOP}"/cpp/plugins/cucim.kit.cuslide/build-*/
        rm -rf "${TOP}"/cpp/plugins/cucim.kit.cuslide/install
        rm -rf "${TOP}"/cpp/plugins/cucim.kit.cumed/build-*/
        rm -rf "${TOP}"/cpp/plugins/cucim.kit.cumed/install
        rm -rf "${TOP}"/cpp/plugins/cucim.kit.cuslide2/build-*/
        rm -rf "${TOP}"/cpp/plugins/cucim.kit.cuslide2/install
        rm -rf "${TOP}"/python/build-*
        rm -rf "${TOP}"/python/install
    fi

    if [ "$subcommand" = "all" ] || [ "$subcommand" = "libcucim" ]; then
        build_local_libcucim_ "${TOP}" "${build_type}" ${build_type_str} "${prefix}"
    fi

    if [ "$subcommand" = "all" ] || [ "$subcommand" = "cuslide" ]; then
        build_local_cuslide_ "${TOP}"/cpp/plugins/cucim.kit.cuslide "${build_type}" ${build_type_str} "${prefix}"
    fi

     if [ "$subcommand" = "all" ] || [ "$subcommand" = "cuslide2" ]; then
        build_local_cuslide2_ "${TOP}"/cpp/plugins/cucim.kit.cuslide2 "${build_type}" ${build_type_str} "${prefix}"
    fi

    if [ "$subcommand" = "all" ] || [ "$subcommand" = "cumed" ]; then
        build_local_cumed_ "${TOP}"/cpp/plugins/cucim.kit.cumed "${build_type}" ${build_type_str} "${prefix}"
    fi

    if [ "$subcommand" = "all" ] || [ "$subcommand" = "cucim" ]; then
        build_local_cucim_ "${TOP}"/python "${build_type}" ${build_type_str} "${prefix}"
    fi

    # Remove existing library files at python/cucim/src/cucim/clara
    rm -f "${TOP}"/python/cucim/src/cucim/clara/*.so*

    if [ "$subcommand" = "all" ] || [ "$subcommand" = "cucim" ]; then
        # We don't need to copy binary if executed by conda-build
        if [ "${CONDA_BUILD:-}" != "1" ]; then
            # Copy .so files from libcucim & cuslide/cumed's build folders to cuCIM's Python source folder
            # Since wheel file doesn't support symbolic link (https://github.com/pypa/wheel/issues/203),
            # we don't need to copy symbolic links. Instead copy only libcucim.so.${major_version} (without symbolic link)
            cp "${TOP}"/build-"${build_type}"/lib*/libcucim.so."${major_version}" "${TOP}"/python/cucim/src/cucim/clara/
            cp -P "${TOP}"/cpp/plugins/cucim.kit.cuslide/build-"${build_type}"/lib*/cucim* "${TOP}"/python/cucim/src/cucim/clara/
            cp -P "${TOP}"/cpp/plugins/cucim.kit.cumed/build-"${build_type}"/lib*/cucim* "${TOP}"/python/cucim/src/cucim/clara/
            # Only copy cuslide2 if it exists (infrastructure-only mode has no .so file)
            if ls "${TOP}"/cpp/plugins/cucim.kit.cuslide2/build-"${build_type}"/lib*/cucim* 1> /dev/null 2>&1; then
                cp -P "${TOP}"/cpp/plugins/cucim.kit.cuslide2/build-"${build_type}"/lib*/cucim* "${TOP}"/python/cucim/src/cucim/clara/
            fi
            # Copy .so files from pybind's build folder to cuCIM's Python source folder
            cp "${TOP}"/python/build-"${build_type}"/lib/cucim/_cucim.*.so "${TOP}"/python/cucim/src/cucim/clara/
        fi
    fi

    eval "${old_opt}" # restore old shopts
}

get_arch_name_() {
    architecture="unknown"
    case $(uname -m) in
        x86_64) architecture="x86_64" ;;
        arm|aarch64) lscpu | awk '/Architecture:/{print $2}' | grep -i -q "aarch64" && architecture="sbsa";;
    esac
    echo "${architecture}"
}

#==================================================================================
# Section: Test
#==================================================================================

# shellcheck disable=SC2016
test_desc() { echo 'Execute test cases

Arguments:
  $1 - subcommand [all|python|c++] (default: all)
  $2 - test_type [all|unit|integration|system|performance] (default: all)
  $3 - test_component [all|clara|skimage] (default: all)
'
}
test() {
    local subcommand="${1:-all}"
    local test_type="${2:-all}"
    shift;

    if [ "$subcommand" = "all" ] || [ "$subcommand" = "python" ]; then
        test_python "$@"
    fi
}

install_python_test_deps_() {
    if [ -n "${CONDA_PREFIX}" ]; then
        # Install test dependencies from pip because conda does not have all the dependencies (e.g., opencv-python).
        # (https://github.com/rapidsai/cucim/pull/433)
        run_command pip install -r "${TOP}"/python/cucim/requirements-test.txt
    else
        pushd "${TOP}/python/cucim"
        if [ -n "${VIRTUAL_ENV}" ]; then
            run_command pip3 install -e ".[test]"
        else
            run_command pip3 install --user -e ".[test]"
        fi
        popd
    fi
    hash -r
}

# shellcheck disable=SC2016
test_python_desc() { echo 'Execute Python test cases

Arguments:
  $1 - test_type [all|unit|integration|system|performance] (default: all)
  $2 - test_component [all|clara|skimage] (default: all)
'
}
test_python() {
    local test_type="${1:-all}"
    local test_component="${2:-all}"
    local result=0

    local testsuite=()
    local testsuite_unit_skimage="src"
    local testsuite_unit_clara="tests/unit"
    local testsuite_performance="tests/performance"

    install_python_test_deps_

    if [ "$test_type" = "all" ] || [ "$test_type" = "unit" ]; then
        if [ "$test_component" = "skimage" ]; then
            testsuite+=("${testsuite_unit_skimage}")
        elif [ "$test_component" = "clara" ]; then
            testsuite+=("${testsuite_unit_clara}")
        else
            testsuite+=("${testsuite_unit_skimage}" "${testsuite_unit_clara}")
        fi
    fi

    if [ "$test_type" = "all" ] || [ "$test_type" = "performance" ]; then
        testsuite+=("${testsuite_performance}")
    fi

    pushd "$TOP"/python/cucim
    # Set CUDA environment for CuPy JIT compilation
    if [ -n "${CONDA_PREFIX}" ]; then
        export CUDA_PATH="${CONDA_PREFIX}"
        export CUDA_HOME="${CONDA_PREFIX}"
        # CuPy NVRTC needs to find CUDA headers in targets subdirectory
        # Detect platform architecture for correct CUDA include path
        CUDA_ARCH=$(uname -m)
        if [ "${CUDA_ARCH}" = "aarch64" ]; then
            export CUDA_INCLUDE_PATH="${CONDA_PREFIX}/targets/sbsa-linux/include"
        else
            export CUDA_INCLUDE_PATH="${CONDA_PREFIX}/targets/x86_64-linux/include"
        fi
        echo "🔧 Set CUDA_HOME=${CUDA_HOME} CUDA_INCLUDE_PATH=${CUDA_INCLUDE_PATH}"
    fi
    run_command py.test --cache-clear -vv \
        --cov=cucim \
        --junitxml="$TOP/junit-cucim.xml" \
        --cov-config="$TOP/python/cucim/.coveragerc" \
        --cov-report=xml:"$TOP/cucim-coverage.xml" \
        --cov-report term \
        "${testsuite[@]}"
    result=$?
    popd

    return $result
}


#==================================================================================
# Section: Example
#==================================================================================

download_testdata_desc() { echo 'Download test data from Docker Hub
'
}
download_testdata() {
    c_echo W "Downloading test data..."
    run_command mkdir -p "${TOP}/notebooks/input"
    if [ ! -e "${TOP}/notebooks/input/image.tif" ]; then
        run_command rm -rf "${TOP}/notebooks/input"
        id=$(docker create gigony/svs-testdata:little-big)
        run_command docker cp "$id":/input "${TOP}/notebooks"
        run_command docker rm -v "$id"
        c_echo G "Test data is downloaded to '${TOP}/notebooks/input'!"
    else
        c_echo G "Test data already exists at '${TOP}/notebooks/input'!"
    fi
}

#==================================================================================
# Section: Release
#==================================================================================

update_version_desc() { echo 'Update version

Executes ci/release/update-version.sh which updates some version-related
files based on VERSION file.

Returns:
  Outputs executed by update-version.sh

  Exit code:
    exit code returned from update-version.sh
'
}
update_version() {
    local new_version=${1:-}
    local ret=0
    [ -z "${new_version}" ] && c_echo_err R "Please specify '[new version]' (e.g., '21.06.00')!" && return 1
    "$TOP"/ci/release/update-version.sh "$@"
    ret=$?

    return $ret
}

parse_args() {
    local OPTIND
    while getopts 'yh' option;
    do
        case "${option}" in
            h)
                print_usage
                exit 1
                ;;
            *)
                ;;
        esac
    done
    shift $((OPTIND-1))

    CMD="$1"
    shift

    ARGS=("$@")
}

print_usage() {
    set +x
    echo_err
    echo_err "USAGE: $0 [command] [arguments]..."
    echo_err ""
    c_echo_err W "Global Arguments"
    echo_err
    c_echo_err W "Command List"
    c_echo_err Y "    help  " w "----------------------------  Print detailed description for a given argument (command name)"
    echo_err "$(get_list_of_available_commands "${RUN_SCRIPT_FILE}" | my_cat_prefix " ")"
    echo_err
}

print_cmd_help_messages() {
    local cmd="$1"
    if [ -n "${cmd}" ]; then
        if type "${cmd}"_desc > /dev/null 2>&1; then
            "${cmd}"_desc
            exit 0
        else
            c_echo_err R "Command '${cmd}' doesn't exist!"
            exit 1
        fi
    fi
    print_usage
    return 0
}

main() {
    local ret=0
    parse_args "$@"

    case "$CMD" in
        help)
            print_cmd_help_messages "${ARGS[@]}"
            exit 0
            ;;
        ''|main)
            print_usage
            ;;
        *)
            if type "${CMD}" > /dev/null 2>&1; then
                "$CMD" "${ARGS[@]}"
            else
                print_usage
                exit 1
            fi
            ;;
    esac
    ret=$?
    if [ -n "${SCRIPT_DIR}" ]; then
        exit $ret
    fi
}

init_globals

if [ -n "${SCRIPT_DIR}" ]; then
    main "$@"
fi


# Description template

# Globals:
#   CS_OS
#   CS_TARGET
#   CS_USER (used if CS_OS is "l4t")
#   CS_HOST (used if CS_OS is "l4t")
#   CS_OBSCURA_MODE (used in Obscura server)
# Arguments:
#   Command line to execute
# Returns:
#   Outputs print messages during the execution (stdout->stdout, stderr->stderr).

#   Note:
#     This command removes "\r" characters from stdout.

#   Exit code:
#     exit code returned from executing a given command