Как сохранить стандартную ошибку в переменной

Допустим, у меня есть скрипт, подобный следующему:

useless.sh

echo "This Is Error" 1>&2
echo "This Is Output" 

И у меня есть другой сценарий оболочки:

alsoUseless.sh

./useless.sh | sed 's/Output/Useless/'

Я хочу записать «This Is Error» или любой другой stderr из useless.sh в переменную. Давайте назовем это ОШИБКА.

Обратите внимание, что я использую стандартный вывод для чего-то. Я хочу продолжать использовать stdout, поэтому перенаправление stderr в stdout в этом случае бесполезно.

Итак, в основном, я хочу сделать

./useless.sh 2> $ERROR | ...

но это, очевидно, не работает.

Я также знаю, что я мог сделать

./useless.sh 2> /tmp/Error
ERROR=`cat /tmp/Error`

но это безобразно и ненужно.

К сожалению, если здесь не будет ответов, это то, что я собираюсь сделать.

Я надеюсь, что есть другой способ.

У кого-нибудь есть идеи получше?

Было бы лучше записать файл ошибок так:

ERROR=$(</tmp/Error)

Оболочка распознает это и не должна запускать ' cat' для получения данных.

Большой вопрос сложен. Я не думаю, что есть простой способ сделать это. Вам придется встроить весь конвейер в под-оболочку, в конечном итоге отправив окончательный стандартный вывод в файл, чтобы вы могли перенаправить ошибки в стандартный вывод.

ERROR=$( { ./useless.sh | sed s/Output/Useless/ > outfile; } 2>&1 )

Обратите внимание, что точка с запятой необходима (в классических оболочках - Bourne, Korn - наверняка; вероятно, в Bash тоже). ' {}' Выполняет перенаправление ввода / вывода поверх вложенных команд. Как написано, это будет захватывать ошибки от sedслишком.

ВНИМАНИЕ: Формально непроверенный код - используйте на свой страх и риск.

alsoUseless.sh

Это позволит вам направить вывод вашего useless.shскрипта с помощью такой команды, как sedи сохранить stderrв переменной с именем error. Результат канала отправляется stdoutдля отображения или для передачи в другую команду.

Он устанавливает пару дополнительных файловых дескрипторов для управления перенаправлениями, необходимыми для этого.

#!/bin/bash

exec 3>&1 4>&2 #set up extra file descriptors

error=$( { ./useless.sh | sed 's/Output/Useless/' 2>&4 1>&3; } 2>&1 )

echo "The message is \"${error}.\""

exec 3>&- 4>&- # release the extra file descriptors

Перенаправить stderr в stdout, stdout в / dev / null, а затем использовать обратные клавиши или $()для захвата перенаправленного stderr:

ERROR=$(./useless.sh 2>&1 >/dev/null)

Для этого вопроса существует множество дубликатов, многие из которых имеют несколько более простой сценарий использования, когда вы не хотите захватывать stderr и stdout и код выхода одновременно.

if result=$(useless.sh 2>&1); then
    stdout=$result
else
    rc=$?
    stderr=$result
fi

работает для общего сценария, где вы ожидаете либо правильного вывода в случае успеха, либо диагностического сообщения на stderr в случае сбоя.

Обратите внимание, что управляющие операторы оболочки уже проверяются $?под капотом; так что-нибудь, что выглядит как

cmd
if [ $? -eq 0 ], then ...

это просто неуклюжий, однотипный способ сказать

if cmd; then ...

# command receives its input from stdin.
# command sends its output to stdout.
exec 3>&1
stderr="$(command </dev/stdin 2>&1 1>&3)"
exitcode="${?}"
echo "STDERR: $stderr"
exit ${exitcode}

Для удобства читателя этот рецепт здесь

• может быть повторно использован как oneliner для захвата stderr в переменную
• по-прежнему дает доступ к коду возврата команды
• Жертва временного файлового дескриптора 3 (который вы, конечно, можете изменить)
• И не выставляет эти временные файловые дескрипторы внутренней команде

Если вы хотите поймать stderrнекоторые commandв varвы можете сделать

{ var="$( { command; } 2>&1 1>&3 3>&- )"; } 3>&1;

После этого у вас есть все:

echo "command gives $? and stderr '$var'";

Если commandвсе просто (а не что-то вроде a | b), вы можете оставить внутреннее {}:

{ var="$(command 2>&1 1>&3 3>&-)"; } 3>&1;

Обернут в легкую функцию многократного использования bash(вероятно, для версии 3 и выше local -n):

: catch-stderr var cmd [args..]
catch-stderr() { local -n v="$1"; shift && { v="$("$@" 2>&1 1>&3 3>&-)"; } 3>&1; }

Разъяснение:

• local -nпсевдонимы "$ 1" (которая является переменной для catch-stderr)
• 3>&1 использует файловый дескриптор 3 для сохранения там стандартных точек
• { command; } (или "$ @") затем выполняет команду в захвате вывода $(..)
• Обратите внимание, что здесь важен точный порядок (неправильный способ неправильно перетасовывает дескрипторы файлов):
  • 2>&1перенаправляет stderrна выход захвата$(..)
  • 1>&3перенаправляет stdoutот захвата вывода $(..)обратно к «внешнему», stdoutкоторый был сохранен в файловом дескрипторе 3. Обратите внимание, что stderrвсе еще относится к тому месту, куда указывал FD 1: на захват вывода$(..)
  • 3>&-затем закрывает файловый дескриптор 3, так как он больше не нужен, так что commandвнезапно не появляется какой-то неизвестный открытый файловый дескриптор. Обратите внимание, что внешняя оболочка все еще имеет открытый FD 3, но commandне увидит его.
  • Последнее важно, потому что некоторые программы, например, lvmжалуются на неожиданные файловые дескрипторы. И lvmжалуется stderr- только то, что мы собираемся захватить!

Вы можете поймать любой другой дескриптор файла с этим рецептом, если вы адаптируетесь соответственно. Конечно, кроме файлового дескриптора 1 (здесь логика перенаправления будет неправильной, но для файлового дескриптора 1 вы можете просто использовать var=$(command)как обычно).

Обратите внимание, что это жертвует файловым дескриптором 3. Если вам понадобится этот файловый дескриптор, смело меняйте номер. Но имейте в виду, что некоторые оболочки (начиная с 1980-х годов) могут восприниматься 99>&1как аргумент, 9за которым следует 9>&1(это не проблема для bash).

Также обратите внимание, что не так легко сделать этот FD 3 настраиваемым через переменную. Это делает вещи очень нечитаемыми:

: catch-var-from-fd-by-fd variable fd-to-catch fd-to-sacrifice command [args..]
catch-var-from-fd-by-fd()
{
local -n v="$1";
local fd1="$2" fd2="$3";
shift 3 || return;

eval exec "$fd2>&1";
v="$(eval '"$@"' "$fd1>&1" "1>&$fd2" "$fd2>&-")";
eval exec "$fd2>&-";
}

Примечание по безопасности: первые 3 аргумента catch-var-from-fd-by-fdне должны приниматься сторонними организациями. Всегда дайте им явно "статичным" способом.

Так нет-нет-нет catch-var-from-fd-by-fd $var $fda $fdb $command, никогда не делай этого!

Если вам случится передать имя переменной, по крайней мере сделайте это следующим образом: local -n var="$var"; catch-var-from-fd-by-fd var 3 5 $command

Это по-прежнему не защитит вас от каждого эксплойта, но, по крайней мере, поможет обнаружить и избежать распространенных ошибок сценариев.

Ноты:

• catch-var-from-fd-by-fd var 2 3 cmd.. такой же как catch-stderr var cmd..
• shift || returnэто всего лишь способ предотвратить неприятные ошибки, если вы забудете указать правильное количество аргументов. Возможно, завершение оболочки будет другим способом (но это затрудняет тестирование из командной строки).
• Рутина была написана так, чтобы ее было легче понять. Можно переписать функцию так, что она не нужна exec, но тогда она становится действительно уродливой.
• Эта подпрограмма может быть переписана для не bashтак хорошо, что нет необходимости local -n. Однако тогда вы не можете использовать локальные переменные, и это становится ужасно!
• Также обратите внимание, что evalони используются безопасным образом. Обычно evalсчитается опасным. Однако в этом случае это не более зло, чем использование "$@"(для выполнения произвольных команд). Однако, пожалуйста, не забудьте использовать точное и правильное цитирование, как показано здесь (иначе это становится очень и очень опасным ).

Вот как я это сделал:

#
# $1 - name of the (global) variable where the contents of stderr will be stored
# $2 - command to be executed
#
captureStderr()
{
    local tmpFile=$(mktemp)

    $2 2> $tmpFile

    eval "$1=$(< $tmpFile)"

    rm $tmpFile
}

Пример использования:

captureStderr err "./useless.sh"

echo -$err-

Это делает использовать временный файл. Но, по крайней мере, уродливые вещи заключены в функцию.

Это интересная проблема, на которую я надеялся найти элегантное решение. К сожалению, я получаю решение, похожее на мистер Леффлер, но добавлю, что вы можете бесполезно вызывать функцию из Bash для улучшения читабельности:

#! / Bin / Баш

функция бесполезна {
    /tmp/useless.sh | sed 's / Output / Бесполезный /'
}

ERROR = $ (бесполезный)
echo $ ERROR

Все другие виды перенаправления вывода должны быть поддержаны временным файлом.

POSIX

STDERR может быть захвачен некоторой магией перенаправления:

$ { error=$( { { ls -ld /XXXX /bin | tr o Z ; } 1>&3 ; } 2>&1); } 3>&1
lrwxrwxrwx 1 rZZt rZZt 7 Aug 22 15:44 /bin -> usr/bin/

$ echo $error
ls: cannot access '/XXXX': No such file or directory

Обратите внимание, что передача STDOUT команды (здесь ls) выполняется внутри самой внутренней части { }. Если вы выполняете простую команду (например, не трубу), вы можете удалить эти внутренние скобки.

Вы не можете передавать по конвейеру за пределы команды, так как конвейер создает подоболочку в bashи zsh, и назначение переменной в подоболочке не будет доступно для текущей оболочки.

удар

Во- bashпервых, было бы лучше не предполагать, что файловый дескриптор 3 не используется:

{ error=$( { { ls -ld /XXXX /bin | tr o Z ; } 1>&$tmp ; } 2>&1); } {tmp}>&1; 
exec {tmp}>&-  # With this syntax the FD stays open

Обратите внимание, что это не работает в zsh.

Спасибо за этот ответ для общей идеи.

Этот пост помог мне придумать подобное решение для моих собственных целей:

MESSAGE=`{ echo $ERROR_MESSAGE | format_logs.py --level=ERROR; } 2>&1`

Тогда, пока наше СООБЩЕНИЕ не является пустой строкой, мы передаем его другим материалам. Это даст нам знать, если наш format_logs.py потерпел неудачу с каким-то исключением из Python.

Захват и печать stderr

ERROR=$( ./useless.sh 3>&1 1>&2 2>&3 | tee /dev/fd/2 )

Сломать

Вы можете использовать $()для захвата stdout, но вместо этого вы хотите захватить stderr. Таким образом, вы меняете stdout и stderr. Использование fd 3 в качестве временного хранилища в стандартном алгоритме подкачки.

Если вы хотите захватить И распечатать, используйте teeдля создания дубликата. В этом случае выходные данные teeбудут записываться, $()а не переходить на консоль, но stderr (of tee) будет по-прежнему идти на консоль, поэтому мы используем его в качестве второго вывода для teeспециального файла, /dev/fd/2поскольку teeожидается путь к файлу, а не fd число.

ПРИМЕЧАНИЕ. Это очень много перенаправлений в одну строку, и порядок имеет значение. $()захватывает стандартный вывод teeв конце конвейера, а сам конвейер направляет стандартный вывод ./useless.shв стандартный поток teeПОСЛЕ того, как мы поменялись стандартными и стандартными ./useless.sh.

Используя стандартный вывод ./useless.sh

ОП сказал, что он все еще хотел использовать (а не только печатать) стандартный вывод ./useless.sh | sed 's/Output/Useless/'.

Нет проблем, просто сделайте это ПЕРЕД обменом stdout и stderr. Я рекомендую переместить его в функцию или файл (также-useless.sh) и вызвать его вместо ./useless.sh в строке выше.

Однако, если вы хотите CAPTURE stdout AND stderr, то я думаю, что вам придется использовать временные файлы, потому что они $()будут делать только один файл за раз, и он создает подоболочку, из которой вы не сможете вернуть переменные.

Немного повторяя ответ Тома Хейла, я обнаружил, что можно превратить йогу перенаправления в функцию для более легкого повторного использования. Например:

#!/bin/sh

capture () {
    { captured=$( { { "$@" ; } 1>&3 ; } 2>&1); } 3>&1
}

# Example usage; capturing dialog's output without resorting to temp files
# was what motivated me to search for this particular SO question
capture dialog --menu "Pick one!" 0 0 0 \
        "FOO" "Foo" \
        "BAR" "Bar" \
        "BAZ" "Baz"
choice=$captured

clear; echo $choice

Почти наверняка возможно упростить это дальше. Особенно тщательно не тестировал, но, похоже, он работает как с bash, так и с ksh.

Если вы хотите обойти использование временного файла, вы можете использовать процесс подстановки. Я еще не совсем заставил его работать. Это была моя первая попытка:

$ .useless.sh 2> >( ERROR=$(<) )
-bash: command substitution: line 42: syntax error near unexpected token `)'
-bash: command substitution: line 42: `<)'

Потом я попробовал

$ ./useless.sh 2> >( ERROR=$( cat <() )  )
This Is Output
$ echo $ERROR   # $ERROR is empty

тем не мение

$ ./useless.sh 2> >( cat <() > asdf.txt )
This Is Output
$ cat asdf.txt
This Is Error

Таким образом, подстановка процесса обычно делает правильно ... к сожалению, всякий раз, когда я оборачиваю STDIN >( )чем-то внутри, $()пытаясь передать это переменной, я теряю содержимое $(). Я думаю, что это потому, что $()запускает подпроцесс, который больше не имеет доступа к файловому дескриптору в / dev / fd, который принадлежит родительскому процессу.

Подстановка процессов позволила мне работать с потоком данных, которого больше нет в STDERR, к сожалению, я, похоже, не могу управлять им так, как мне хочется.

$ b=$( ( a=$( (echo stdout;echo stderr >&2) ) ) 2>&1 )
$ echo "a=>$a b=>$b"
a=>stdout b=>stderr

В зш:

{ . ./useless.sh > /dev/tty } 2>&1 | read ERROR
$ echo $ERROR
( your message )

Для проверки ошибок ваших команд:

execute [INVOKING-FUNCTION] [COMMAND]

execute () {
    function="${1}"
    command="${2}"
    error=$(eval "${command}" 2>&1 >"/dev/null")

    if [ ${?} -ne 0 ]; then
        echo "${function}: ${error}"
        exit 1
    fi
}

Вдохновленный в Бережливом производстве:

• Сделайте ошибки невозможными
• Сделайте шаги наименьшими
• Завершить предметы по одному
• Сделайте это очевидным для всех

Простое решение

{ ERROR=$(./useless.sh 2>&1 1>&$out); } {out}>&1
echo "-"
echo $ERROR

Будет производить:

This Is Output
-
This Is Error

Улучшение в ответе YellowApple :

Это функция Bash для захвата stderr в любую переменную

stderr_capture_example.sh:

#!/usr/bin/env bash

# Capture stderr from a command to a variable while maintaining stdout
# @Args:
# $1: The variable name to store the stderr output
# $2: Vararg command and arguments
# @Return:
# The Command's Returnn-Code or 2 if missing arguments
function capture_stderr {
  [ $# -lt 2 ] && return 2
  local stderr="$1"
  shift
  {
    printf -v "$stderr" '%s' "$({ "$@" 1>&3; } 2>&1)"
  } 3>&1
}

# Testing with a call to erroring ls
LANG=C capture_stderr my_stderr ls "$0" ''

printf '\nmy_stderr contains:\n%s' "$my_stderr"

Тестирование:

bash stderr_capture_example.sh

Вывод:

 stderr_capture_example.sh

my_stderr contains:
ls: cannot access '': No such file or directory

Эта функция может быть использована для захвата возвращенного выбора dialogкоманды.