Can an approach be found to do set -e/ERR subshell trapping immune to && and || restrictions?

Question

While the Bash man page states that:

The ERR trap is not executed if the failed command is ... part of a command executed in a && or || list ...

I hoped that code in a subshell would be in a different context and would not be subject to the above restriction. The code below shows that even subshells are not immune from this restriction:

#!/bin/bash

main()
{
   local Arg="$1"
   (
      set -e
      echo "In main: $Arg"
      trap MyTrap ERR
      $(exit 1)
      echo "Should not get here"
   )

   return 1
}

MyTrap()
{
   echo "In MyTrap"
}

main 1
[[ $? -eq 0 ]] || echo "failed"
echo
main 2 || echo "failed"

The above code has the following output:

In main: 1
In MyTrap
failed

In main: 2
Should not get here
failed

My present workaround is to use file persistence to save error states in MyTrap and then inspect return codes back in the caller. For example:

MyTrap()
{
   echo "_ERROR_=$?" > $HOME/.persist
   echo "In MyTrap"
}

main 1
[[ -f $HOME/.persist ]] && . $HOME/.persist || _ERROR_=0
[[ $_ERROR_ -eq 0 ]] || echo "failed"

The output of the above is now:

In main: 1
In MyTrap
failed

So, the question is: Can an approach be found to do set -e/ERR subshell trapping that is immune to && and || restrictions that is simpler than the workaround above?

Notes: This question applies to:

• Bash 4.2 and higher
• Red Hat 7, CentOS 7, and related distros (that is, not Debian, etc.)
• No third-party software should be used. Packages must be available, for example, via OS-provider packages in the [CentOS-7-x86_64-DVD-1611.iso][2] repository iso (and similarly for RHEL 7, Fedora 7, etc).

Answer 1

This code is NOT a solution. It is a modified version that you can test to give you some ideas.

#!/bin/bash

main()
{
   local Arg="$1"
   (
      echo "In main: $Arg"
      $(exit 1)
      echo "Should not get here"
   )

   return 1
}

MyTrap()
{
   echo "In MyTrap"
   exit 1
}

set -o errtrace
set -o functrace
trap MyTrap ERR

main 1
[[ $? -eq 0 ]] || echo "failed"
echo
main 2 || echo "failed"

It will not do what you would like it to do (I assume), because there is something important missing that is too involved to explain in a post, but there are a few key things.

If you want to handle errors uniformly in all your script, you will have to do the following.

• Set the trap at the top level, and do NOT use set -e
• Use the shell options that cause subshells and functions to inherit traps (shown in the example)
• Create a framework where you differentiate between "expected" errors (explicitely handled as some kind of exception, not as return codes), and "unexpected" exceptions (bugs), which will be trapped.
• Never use logical operators directly (except on test constructs or other simple statements you decide are safe enough)
• Perform logical tests after collecting exceptions, not as tests on the return codes.

Building that framework is very tricky, but doable (I have it working flawlessly on dozens of very complex scripts). Once you have done it, if you chose to blindly test a command (without explicitly handling exceptions), if it fails you have the option to crash your script in the trap (exit) instead of continuing execution with your script in an unstable state.

This probably incurs a slight performance penalty (at least the way I did it, using a special try function preceding every statement for which exception handling is used), and sure requires a LOT of discipline in coding, but in my case it makes me way more productive building complex scripts with the reasonable confidence the location of any bug (not that I have any of those...) will be much easier to pinpoint.