| #!/bin/bash |
| # Copyright 1999-2014 Gentoo Foundation |
| # Distributed under the terms of the GNU General Public License v2 |
| |
| source "${PORTAGE_BIN_PATH:-/usr/lib/portage/bin}/eapi.sh" |
| |
| # We need this next line for "die" and "assert". It expands |
| # It _must_ preceed all the calls to die and assert. |
| shopt -s expand_aliases |
| alias save_IFS='[ "${IFS:-unset}" != "unset" ] && old_IFS="${IFS}"' |
| alias restore_IFS='if [ "${old_IFS:-unset}" != "unset" ]; then IFS="${old_IFS}"; unset old_IFS; else unset IFS; fi' |
| |
| assert() { |
| local x pipestatus=${PIPESTATUS[*]} |
| for x in $pipestatus ; do |
| [[ $x -eq 0 ]] || die "$@" |
| done |
| } |
| |
| __assert_sigpipe_ok() { |
| # When extracting a tar file like this: |
| # |
| # bzip2 -dc foo.tar.bz2 | tar xof - |
| # |
| # For some tar files (see bug #309001), tar will |
| # close its stdin pipe when the decompressor still has |
| # remaining data to be written to its stdout pipe. This |
| # causes the decompressor to be killed by SIGPIPE. In |
| # this case, we want to ignore pipe writers killed by |
| # SIGPIPE, and trust the exit status of tar. We refer |
| # to the bash manual section "3.7.5 Exit Status" |
| # which says, "When a command terminates on a fatal |
| # signal whose number is N, Bash uses the value 128+N |
| # as the exit status." |
| |
| local x pipestatus=${PIPESTATUS[*]} |
| for x in $pipestatus ; do |
| # Allow SIGPIPE through (128 + 13) |
| [[ $x -ne 0 && $x -ne ${PORTAGE_SIGPIPE_STATUS:-141} ]] && die "$@" |
| done |
| |
| # Require normal success for the last process (tar). |
| [[ $x -eq 0 ]] || die "$@" |
| } |
| |
| shopt -s extdebug |
| |
| # __dump_trace([number of funcs on stack to skip], |
| # [whitespacing for filenames], |
| # [whitespacing for line numbers]) |
| __dump_trace() { |
| local funcname="" sourcefile="" lineno="" s="yes" n p |
| declare -i strip=${1:-1} |
| local filespacing=$2 linespacing=$3 |
| |
| # The __qa_call() function and anything before it are portage internals |
| # that the user will not be interested in. Therefore, the stack trace |
| # should only show calls that come after __qa_call(). |
| (( n = ${#FUNCNAME[@]} - 1 )) |
| (( p = ${#BASH_ARGV[@]} )) |
| while (( n > 0 )) ; do |
| [ "${FUNCNAME[${n}]}" == "__qa_call" ] && break |
| (( p -= ${BASH_ARGC[${n}]} )) |
| (( n-- )) |
| done |
| if (( n == 0 )) ; then |
| (( n = ${#FUNCNAME[@]} - 1 )) |
| (( p = ${#BASH_ARGV[@]} )) |
| fi |
| |
| eerror "Call stack:" |
| while (( n > ${strip} )) ; do |
| funcname=${FUNCNAME[${n} - 1]} |
| sourcefile=$(basename "${BASH_SOURCE[${n}]}") |
| lineno=${BASH_LINENO[${n} - 1]} |
| # Display function arguments |
| args= |
| if [[ -n "${BASH_ARGV[@]}" ]]; then |
| for (( j = 1 ; j <= ${BASH_ARGC[${n} - 1]} ; ++j )); do |
| newarg=${BASH_ARGV[$(( p - j - 1 ))]} |
| args="${args:+${args} }'${newarg}'" |
| done |
| (( p -= ${BASH_ARGC[${n} - 1]} )) |
| fi |
| eerror " $(printf "%${filespacing}s" "${sourcefile}"), line $(printf "%${linespacing}s" "${lineno}"): Called ${funcname}${args:+ ${args}}" |
| (( n-- )) |
| done |
| } |
| |
| nonfatal() { |
| if ! ___eapi_has_nonfatal; then |
| die "$FUNCNAME() not supported in this EAPI" |
| fi |
| if [[ $# -lt 1 ]]; then |
| die "$FUNCNAME(): Missing argument" |
| fi |
| |
| PORTAGE_NONFATAL=1 "$@" |
| } |
| |
| __bashpid() { |
| # The BASHPID variable is new to bash-4.0, so add a hack for older |
| # versions. This must be used like so: |
| # ${BASHPID:-$(__bashpid)} |
| sh -c 'echo ${PPID}' |
| } |
| |
| __helpers_die() { |
| if ___eapi_helpers_can_die; then |
| die "$@" |
| else |
| echo -e "$@" >&2 |
| fi |
| } |
| |
| die() { |
| local IFS=$' \t\n' |
| |
| if [[ $PORTAGE_NONFATAL -eq 1 ]]; then |
| echo -e " $WARN*$NORMAL ${FUNCNAME[1]}: WARNING: $@" >&2 |
| return 1 |
| fi |
| |
| set +e |
| if [ -n "${QA_INTERCEPTORS}" ] ; then |
| # die was called from inside inherit. We need to clean up |
| # QA_INTERCEPTORS since sed is called below. |
| unset -f ${QA_INTERCEPTORS} |
| unset QA_INTERCEPTORS |
| fi |
| local n filespacing=0 linespacing=0 |
| # setup spacing to make output easier to read |
| (( n = ${#FUNCNAME[@]} - 1 )) |
| while (( n > 0 )) ; do |
| [ "${FUNCNAME[${n}]}" == "__qa_call" ] && break |
| (( n-- )) |
| done |
| (( n == 0 )) && (( n = ${#FUNCNAME[@]} - 1 )) |
| while (( n > 0 )); do |
| sourcefile=${BASH_SOURCE[${n}]} sourcefile=${sourcefile##*/} |
| lineno=${BASH_LINENO[${n}]} |
| ((filespacing < ${#sourcefile})) && filespacing=${#sourcefile} |
| ((linespacing < ${#lineno})) && linespacing=${#lineno} |
| (( n-- )) |
| done |
| |
| # When a helper binary dies automatically in EAPI 4 and later, we don't |
| # get a stack trace, so at least report the phase that failed. |
| local phase_str= |
| [[ -n $EBUILD_PHASE ]] && phase_str=" ($EBUILD_PHASE phase)" |
| eerror "ERROR: ${CATEGORY}/${PF}::${PORTAGE_REPO_NAME} failed${phase_str}:" |
| eerror " ${*:-(no error message)}" |
| eerror |
| # __dump_trace is useless when the main script is a helper binary |
| local main_index |
| (( main_index = ${#BASH_SOURCE[@]} - 1 )) |
| if has ${BASH_SOURCE[$main_index]##*/} ebuild.sh misc-functions.sh ; then |
| __dump_trace 2 ${filespacing} ${linespacing} |
| eerror " $(printf "%${filespacing}s" "${BASH_SOURCE[1]##*/}"), line $(printf "%${linespacing}s" "${BASH_LINENO[0]}"): Called die" |
| eerror "The specific snippet of code:" |
| # This scans the file that called die and prints out the logic that |
| # ended in the call to die. This really only handles lines that end |
| # with '|| die' and any preceding lines with line continuations (\). |
| # This tends to be the most common usage though, so let's do it. |
| # Due to the usage of appending to the hold space (even when empty), |
| # we always end up with the first line being a blank (thus the 2nd sed). |
| sed -n \ |
| -e "# When we get to the line that failed, append it to the |
| # hold space, move the hold space to the pattern space, |
| # then print out the pattern space and quit immediately |
| ${BASH_LINENO[0]}{H;g;p;q}" \ |
| -e '# If this line ends with a line continuation, append it |
| # to the hold space |
| /\\$/H' \ |
| -e '# If this line does not end with a line continuation, |
| # erase the line and set the hold buffer to it (thus |
| # erasing the hold buffer in the process) |
| /[^\]$/{s:^.*$::;h}' \ |
| "${BASH_SOURCE[1]}" \ |
| | sed -e '1d' -e 's:^:RETAIN-LEADING-SPACE:' \ |
| | while read -r n ; do eerror " ${n#RETAIN-LEADING-SPACE}" ; done |
| eerror |
| fi |
| eerror "If you need support, post the output of \`emerge --info '=${CATEGORY}/${PF}::${PORTAGE_REPO_NAME}'\`," |
| eerror "the complete build log and the output of \`emerge -pqv '=${CATEGORY}/${PF}::${PORTAGE_REPO_NAME}'\`." |
| |
| # Only call die hooks here if we are executed via ebuild.sh or |
| # misc-functions.sh, since those are the only cases where the environment |
| # contains the hook functions. When necessary (like for __helpers_die), die |
| # hooks are automatically called later by a misc-functions.sh invocation. |
| if has ${BASH_SOURCE[$main_index]##*/} ebuild.sh misc-functions.sh && \ |
| [[ ${EBUILD_PHASE} != depend ]] ; then |
| local x |
| for x in $EBUILD_DEATH_HOOKS; do |
| ${x} "$@" >&2 1>&2 |
| done |
| > "$PORTAGE_BUILDDIR/.die_hooks" |
| fi |
| |
| if [[ -n ${PORTAGE_LOG_FILE} ]] ; then |
| eerror "The complete build log is located at '${PORTAGE_LOG_FILE}'." |
| if [[ ${PORTAGE_LOG_FILE} != ${T}/* ]] && \ |
| ! has fail-clean ${FEATURES} ; then |
| # Display path to symlink in ${T}, as requested in bug #412865. |
| local log_ext=log |
| [[ ${PORTAGE_LOG_FILE} != *.log ]] && log_ext+=.${PORTAGE_LOG_FILE##*.} |
| eerror "For convenience, a symlink to the build log is located at '${T}/build.${log_ext}'." |
| fi |
| fi |
| if [ -f "${T}/environment" ] ; then |
| eerror "The ebuild environment file is located at '${T}/environment'." |
| elif [ -d "${T}" ] ; then |
| { |
| set |
| export |
| } > "${T}/die.env" |
| eerror "The ebuild environment file is located at '${T}/die.env'." |
| fi |
| eerror "Working directory: '$(pwd)'" |
| eerror "S: '${S}'" |
| |
| [[ -n $PORTAGE_EBUILD_EXIT_FILE ]] && > "$PORTAGE_EBUILD_EXIT_FILE" |
| [[ -n $PORTAGE_IPC_DAEMON ]] && "$PORTAGE_BIN_PATH"/ebuild-ipc exit 1 |
| |
| # subshell die support |
| [[ ${BASHPID:-$(__bashpid)} == ${EBUILD_MASTER_PID} ]] || kill -s SIGTERM ${EBUILD_MASTER_PID} |
| exit 1 |
| } |
| |
| __quiet_mode() { |
| [[ ${PORTAGE_QUIET} -eq 1 ]] |
| } |
| |
| __vecho() { |
| __quiet_mode || echo "$@" |
| } |
| |
| # Internal logging function, don't use this in ebuilds |
| __elog_base() { |
| local messagetype |
| [ -z "${1}" -o -z "${T}" -o ! -d "${T}/logging" ] && return 1 |
| case "${1}" in |
| INFO|WARN|ERROR|LOG|QA) |
| messagetype="${1}" |
| shift |
| ;; |
| *) |
| __vecho -e " ${BAD}*${NORMAL} Invalid use of internal function __elog_base(), next message will not be logged" |
| return 1 |
| ;; |
| esac |
| echo -e "$@" | while read -r ; do |
| echo "$messagetype $REPLY" >> \ |
| "${T}/logging/${EBUILD_PHASE:-other}" |
| done |
| return 0 |
| } |
| |
| eqawarn() { |
| __elog_base QA "$*" |
| [[ ${RC_ENDCOL} != "yes" && ${LAST_E_CMD} == "ebegin" ]] && echo |
| echo -e "$@" | while read -r ; do |
| __vecho " $WARN*$NORMAL $REPLY" >&2 |
| done |
| LAST_E_CMD="eqawarn" |
| return 0 |
| } |
| |
| elog() { |
| __elog_base LOG "$*" |
| [[ ${RC_ENDCOL} != "yes" && ${LAST_E_CMD} == "ebegin" ]] && echo |
| echo -e "$@" | while read -r ; do |
| echo " $GOOD*$NORMAL $REPLY" |
| done |
| LAST_E_CMD="elog" |
| return 0 |
| } |
| |
| einfo() { |
| __elog_base INFO "$*" |
| [[ ${RC_ENDCOL} != "yes" && ${LAST_E_CMD} == "ebegin" ]] && echo |
| echo -e "$@" | while read -r ; do |
| echo " $GOOD*$NORMAL $REPLY" |
| done |
| LAST_E_CMD="einfo" |
| return 0 |
| } |
| |
| einfon() { |
| __elog_base INFO "$*" |
| [[ ${RC_ENDCOL} != "yes" && ${LAST_E_CMD} == "ebegin" ]] && echo |
| echo -ne " ${GOOD}*${NORMAL} $*" |
| LAST_E_CMD="einfon" |
| return 0 |
| } |
| |
| ewarn() { |
| __elog_base WARN "$*" |
| [[ ${RC_ENDCOL} != "yes" && ${LAST_E_CMD} == "ebegin" ]] && echo |
| echo -e "$@" | while read -r ; do |
| echo " $WARN*$NORMAL $RC_INDENTATION$REPLY" >&2 |
| done |
| LAST_E_CMD="ewarn" |
| return 0 |
| } |
| |
| eerror() { |
| __elog_base ERROR "$*" |
| [[ ${RC_ENDCOL} != "yes" && ${LAST_E_CMD} == "ebegin" ]] && echo |
| echo -e "$@" | while read -r ; do |
| echo " $BAD*$NORMAL $RC_INDENTATION$REPLY" >&2 |
| done |
| LAST_E_CMD="eerror" |
| return 0 |
| } |
| |
| ebegin() { |
| local msg="$*" dots spaces=${RC_DOT_PATTERN//?/ } |
| if [[ -n ${RC_DOT_PATTERN} ]] ; then |
| dots=$(printf "%$(( COLS - 3 - ${#RC_INDENTATION} - ${#msg} - 7 ))s" '') |
| dots=${dots//${spaces}/${RC_DOT_PATTERN}} |
| msg="${msg}${dots}" |
| else |
| msg="${msg} ..." |
| fi |
| einfon "${msg}" |
| [[ ${RC_ENDCOL} == "yes" ]] && echo |
| LAST_E_LEN=$(( 3 + ${#RC_INDENTATION} + ${#msg} )) |
| LAST_E_CMD="ebegin" |
| return 0 |
| } |
| |
| __eend() { |
| local retval=${1:-0} efunc=${2:-eerror} msg |
| shift 2 |
| |
| if [[ ${retval} == "0" ]] ; then |
| msg="${BRACKET}[ ${GOOD}ok${BRACKET} ]${NORMAL}" |
| else |
| if [[ -n $* ]] ; then |
| ${efunc} "$*" |
| fi |
| msg="${BRACKET}[ ${BAD}!!${BRACKET} ]${NORMAL}" |
| fi |
| |
| if [[ ${RC_ENDCOL} == "yes" ]] ; then |
| echo -e "${ENDCOL} ${msg}" |
| else |
| [[ ${LAST_E_CMD} == ebegin ]] || LAST_E_LEN=0 |
| printf "%$(( COLS - LAST_E_LEN - 7 ))s%b\n" '' "${msg}" |
| fi |
| |
| return ${retval} |
| } |
| |
| eend() { |
| local retval=${1:-0} |
| shift |
| |
| __eend ${retval} eerror "$*" |
| |
| LAST_E_CMD="eend" |
| return ${retval} |
| } |
| |
| __unset_colors() { |
| COLS=80 |
| ENDCOL= |
| |
| GOOD= |
| WARN= |
| BAD= |
| NORMAL= |
| HILITE= |
| BRACKET= |
| } |
| |
| __set_colors() { |
| COLS=${COLUMNS:-0} # bash's internal COLUMNS variable |
| # Avoid wasteful stty calls during the "depend" phases. |
| # If stdout is a pipe, the parent process can export COLUMNS |
| # if it's relevant. Use an extra subshell for stty calls, in |
| # order to redirect "/dev/tty: No such device or address" |
| # error from bash to /dev/null. |
| [[ $COLS == 0 && $EBUILD_PHASE != depend ]] && \ |
| COLS=$(set -- $( ( stty size </dev/tty ) 2>/dev/null || echo 24 80 ) ; echo $2) |
| (( COLS > 0 )) || (( COLS = 80 )) |
| |
| # Now, ${ENDCOL} will move us to the end of the |
| # column; irregardless of character width |
| ENDCOL=$'\e[A\e['$(( COLS - 8 ))'C' |
| if [ -n "${PORTAGE_COLORMAP}" ] ; then |
| eval ${PORTAGE_COLORMAP} |
| else |
| GOOD=$'\e[32;01m' |
| WARN=$'\e[33;01m' |
| BAD=$'\e[31;01m' |
| HILITE=$'\e[36;01m' |
| BRACKET=$'\e[34;01m' |
| NORMAL=$'\e[0m' |
| fi |
| } |
| |
| RC_ENDCOL="yes" |
| RC_INDENTATION='' |
| RC_DEFAULT_INDENT=2 |
| RC_DOT_PATTERN='' |
| |
| case "${NOCOLOR:-false}" in |
| yes|true) |
| __unset_colors |
| ;; |
| no|false) |
| __set_colors |
| ;; |
| esac |
| |
| if [[ -z ${USERLAND} ]] ; then |
| case $(uname -s) in |
| *BSD|DragonFly) |
| export USERLAND="BSD" |
| ;; |
| *) |
| export USERLAND="GNU" |
| ;; |
| esac |
| fi |
| |
| if [[ -z ${XARGS} ]] ; then |
| case ${USERLAND} in |
| BSD) |
| export XARGS="xargs" |
| ;; |
| *) |
| export XARGS="xargs -r" |
| ;; |
| esac |
| fi |
| |
| hasq() { |
| has $EBUILD_PHASE prerm postrm || eqawarn \ |
| "QA Notice: The 'hasq' function is deprecated (replaced by 'has')" |
| has "$@" |
| } |
| |
| hasv() { |
| if has "$@" ; then |
| echo "$1" |
| return 0 |
| fi |
| return 1 |
| } |
| |
| has() { |
| local needle=$1 |
| shift |
| |
| local x |
| for x in "$@"; do |
| [ "${x}" = "${needle}" ] && return 0 |
| done |
| return 1 |
| } |
| |
| __repo_attr() { |
| local appropriate_section=0 exit_status=1 line saved_extglob_shopt=$(shopt -p extglob) |
| shopt -s extglob |
| while read line; do |
| [[ ${appropriate_section} == 0 && ${line} == "[$1]" ]] && appropriate_section=1 && continue |
| [[ ${appropriate_section} == 1 && ${line} == "["*"]" ]] && appropriate_section=0 && continue |
| # If a conditional expression like [[ ${line} == $2*( )=* ]] is used |
| # then bash-3.2 produces an error like the following when the file is |
| # sourced: syntax error in conditional expression: unexpected token `(' |
| # Therefore, use a regular expression for compatibility. |
| if [[ ${appropriate_section} == 1 && ${line} =~ ^${2}[[:space:]]*= ]]; then |
| echo "${line##$2*( )=*( )}" |
| exit_status=0 |
| break |
| fi |
| done <<< "${PORTAGE_REPOSITORIES}" |
| eval "${saved_extglob_shopt}" |
| return ${exit_status} |
| } |
| |
| true |