bash: error handling and functions

Question

I am trying to call a function in a loop and gracefully handle and continue when it throws.

If I omit the || handle_error it just stops the entire script as one would expect.

If I leave || handle_error there it will print foo is fine after the error and will not execute handle_error at all. This is also an expected behavior, it's just how it works.

#!/bin/bash

set -e

things=(foo bar)

function do_something {
  echo "param: $1"

  # just throw on first loop run
  # this statement is just a way to selectively throw
  # not part of a real use case scenario where the command(s)
  # may or may not throw
  if [[ $1 == "foo" ]]; then
    throw_error
  fi

  # this line should not be executed when $1 is "foo"
  echo "$1 is fine."
}

function handle_error {
  echo "$1 failed."
}

for thing in ${things[@]}; do
  do_something $thing || handle_error $thing
done

echo "done"

yields

param: foo
./test.sh: line 12: throw_error: command not found
foo is fine.
param: bar
bar is fine.
done

what I would like to have is

param: foo
./test.sh: line 12: throw_error: command not found
foo failed.
param: bar
bar is fine.
done

Edit:

do_something doesn't really have to return anything. It's just an example of a function that throws, I could potentially remove it from the example source code because I will have no control over its content nor I want to, and testing each command in it for failure is not viable.

Edit:

You are not allowed to touch do_something logic. I stated this before, it's just a function containing a set of instructions that may throw an error. It may be a typo, it may be make failing in a CI environment, it may be a network error.

Answer 1

The solution I found is to save the function in a separate file and execute it in a sub-shell. The downside is that we lose all locals.

do-something.sh

#!/bin/bash

set -e

echo "param: $1"

if [[ $1 == "foo" ]]; then
  throw_error
fi

echo "$1 is fine."

my-script.sh

#!/bin/bash

set -e

things=(foo bar)

function handle_error {
  echo "$1 failed."
}

for thing in "${things[@]}"; do
  ./do-something.sh "$thing" || handle_error "$thing"
done

echo "done"

yields

param: foo
./do-something.sh: line 8: throw_error: command not found
foo failed.
param: bar
bar is fine.
done

If there is a more elegant way I will mark that as correct answer. Will check again in 48h.

Edit

Thanks to @PeterCordes comment and this other answer I found another solution that doesn't require to have separate files.

#!/bin/bash

set -e

things=(foo bar)

function do_something {
  echo "param: $1"

  if [[ $1 == "foo" ]]; then
    throw_error
  fi

  echo "$1 is fine."
}

function handle_error {
  echo "$1 failed with code: $2"
}

for thing in "${things[@]}"; do
  set +e; (set -e; do_something "$thing"); error=$?; set -e
  ((error)) && handle_error "$thing" $error
done

echo "done"

correctly yields

param:  foo
./test.sh: line 11: throw_error: command not found
foo failed with code: 127
param:  bar
bar is fine.
done

Answer 2

#!/bin/bash

set -e

things=(foo bar)

function do_something() {
  echo "param: $1"
  ret_value=0

  if [[ $1 == "foo" ]]; then
    ret_value=1
  elif [[ $1 == "fred" ]]; then
    ret_value=2
  fi

  echo "$1 is fine."
  return $ret_value
}

function handle_error() {
  echo "$1 failed."
}

for thing in ${things[@]}; do
  do_something $thing || handle_error $thing
done

echo "done"

See my comment above for the explanation. You can't test for a return value without creating a return value, which should be somewhat obvious. And || tests for a return value, basically, one greater than 0. Like && tests for 0. I think that's more or less right. I believe the bash return value limit is 254? I want to say. Must be integer between 0 and 254. Can't be a string, a float, etc.

http://tldp.org/LDP/abs/html/complexfunct.html

Functions return a value, called an exit status. This is analogous to the exit status returned by a command. The exit status may be explicitly specified by a return statement, otherwise it is the exit status of the last command in the function (0 if successful, and a non-zero error code if not). This exit status may be used in the script by referencing it as $?. This mechanism effectively permits script functions to have a "return value" similar to C functions.

So actually, foo there would have returned a 127 command not found error. I think. I'd have to test to see for sure.

[updated} No, echo is the last command, as you can see from your output. And the outcome of the last echo is 0, so the function returns 0. So you want to dump this notion and go to something like trap, that's assuming you can't touch the internals of the function, which is odd.

echo fred; echo reval: $?
fred
reval: 0

What does set -e mean in a bash script?

-e  Exit immediately if a command exits with a non-zero status.

But it's not very reliable and considered as a bad practice, better use :

trap 'do_something' ERR

http://tldp.org/LDP/Bash-Beginners-Guide/html/sect_12_02.html see trap, that may do what you want. But not ||, unless you add returns.

Answer 3

try

if [[ "$1" == "foo" ]]; then
  foo
fi

I wonder if it was trying to execute the command foo within the condition test?

from bash reference:

-e Exit immediately if a pipeline (see Pipelines), which may consist of a single simple command (see Simple Commands), a list (see Lists), or a compound command (see Compound Commands) returns a non-zero status. The shell does not exit if the command that fails is part of the command list immediately following a while or until keyword, part of the test in an if statement, part of any command executed in a && or || list except the command following the final && or ||, any command in a pipeline but the last, or if the command’s return status is being inverted with !.

as you can see, if the error occurs within the test condition, then the script will continue oblivious and return 0.

--

Edit

So in response, I note that the docs continue:

If a compound command other than a subshell returns a non-zero status because a command failed while -e was being ignored, the shell does not exit.

Well because your for is succeeded by the echo, there's no reason for an error to be thrown!