Kill last program in pipe if any previous command fails

Question

I have a backup script that is essentially:

acquire_data | gzip -9 | gpg --batch -e -r me@example.com | upload-to-cloud

The problem is if acquire_data, or gpg fails, then upload-to-cloud will see the EOF and happily upload an incomplete backup. As an example gpg will fail if the filesystem with the user's home directory is, is full.

I want to pipe it, not store to a temporary file, because it's a lot of data that may not fit in the local server's free space.

I might be able to do something like:

set -o pipefail
mkfifo fifo
upload-to-cloud < fifo &
UPLOADER=$!
((acquire_data | gzip -9 | gpg […]) || kill $UPLOADER) > fifo
wait $UPLOADER  # since I need the exit status

But I think that has a race condition. It's not guaranteed that the upload-to-cloud program will receive the signal before it reads an EOF. And adding a sleep seems wrong. Really stdin of upload-to-cloud need never be closed.

I want upload-to-cloud to die before it handles the EOF because then it won't finalize the upload, and the partial upload will be correctly discarded.

There's this similar question, except it talks about killing an earlier part if a later part fails, which is safer since it doesn't have a problem of the race condition.

What's the best way to do this?

Answer 1

Instead of running this all as one pipeline, split off upload-to-cloud into a separate process substitution which can be independently signaled, and for which your parent shell script holds a descriptor (and thus can control the timing of reaching EOF on its stdin).

Note that upload-to-cloud needs to be written to delete content it already uploaded in the event of an unclean exit for this to work as you intend.

Assuming you have a suitably recent version of bash:

#!/usr/bin/env bash

# dynamically allocate a file descriptor; assign it to a process substitution
# store the PID of that process substitution in upload_pid
exec {upload_fd}> >(exec upload-to-cloud); upload_pid=$!

# make sure we recorded an upload_pid that refers to a process that is actually running
if ! kill -0 "$upload_pid"; then
  # if this happens without any other obvious error message, check that we're bash 4.4
  echo "ERROR: upload-to-cloud not started, or PID not stored" >&2
fi

shopt -s pipefail
if acquire_data | gzip -9 | gpg --batch -e -r me@example.com >&"$upload_fd"; then
  exec {upload_fd}>&-  # close the pipeline writing up upload-to-cloud gracefully...
  wait "$upload_pid"   # ...and wait for it to exit
  exit                 # ...then ourselves exiting with the exit status of upload-to-cloud
                       # (which was returned by wait, became $?, thus exit's default).
else
  retval=$?            # store the exit status of the failed pipeline component
  kill "$upload_pid"   # kill the backgrounded process of upload-to-cloud
  wait "$upload_pid"   # let it handle that SIGTERM...
  exit "$retval"       # ...and exit the script with the exit status we stored earlier.
fi

---

Without a new enough bash to be able to store the PID for a process substitution, the line establishing the process substitution might change to:

mkfifo upload_to_cloud.fifo
upload-to-cloud <upload_to_cloud.fifo & upload_pid=$!
exec {upload_fd}>upload_to_cloud.fifo
rm -f upload_to_cloud.fifo

...after which the rest of the script should work unmodified.