Retry commands on failure until success but with different flags

Question

So, I'm trying to retry failing or command-line with errors, BUT with different flags each time it retry...

I already know how to retry command on failure:

while ! "$@"
do
  :
  sleep 1
done

As an example, I'll use the function above on a failing command on purpose to illustrate:

retry ls test # here this will usually fail and thus retry infinitely

I'm aware this:

• Retry infinitely (until the retried command succeed or return an exit code that is interpreted by the shell as successful)
• Doesn't take into consideration any kind of errors/exit code other than failure whatsover

And all of the above is the wanted/expected effect.

Only thing I'm trying to add to that is support for additional flag when "retrying" N command (which I'll need to either supply as argument to the function or hardcode in the function depending on cases...)

Here what I tried:

bash
while ! "$(echo "$@" | sed "s/^pattern/pattern --otherflag/g")"
do
  :
  sleep 1
done

Usage:

retry ls pattern

Where the new command will become ls pattern --otherflag (which will obviously fail, but this is beside the point)

2nd Method:

while ! "${@/pattern/pattern --otherflag}"
do
  :
  sleep 1
done

Same usage as above...

Here it will give the same result as above.

Now this seems to work on first glance, but if the supplied/failing command contain any kind of quotes, which usually come unquoted, the output/retried command will then have the quotes removed/ignored...

So following above two method/example, a command such as ls pattern "file" will become ls pattern --otherflag file where file doesn't have any quotes (same happen with single quotes).

To fix this I tried this answer's quote function but didn't manage to get satisfying result. Furthermore, it also seems like it doesn't wait/use the added flag only on failure (eg: when the retry function kicks in) but instead run it before it even fail, with the additional flags.

I don't want to have to use a if block/condition if possible and prefer to stay as close as possible to the above snippet. Prefer bash or/and sh alternative. Any feedback/answer is welcome.

Answer 1

Assuming your script is called retry.sh, and its called from the shell with the command line retry.sh ls "foo bar", the positional parameters (arguments, i.e. $1, $2...) within the script will be ls and foo bar. Note that while quotes are a way to protect white space and other special characters on the shell command line, the quotes don't exist any more within the launched script. Instead, what you have is basically an array of strings.

Now, "$@" treats the distinct parameters properly: it expands each to a distinct word. But if you do "$(echo "$@" | sed "s/^pattern/pattern --otherflag/g")", the echo concatenates its arguments to one string, and the quotes around the whole command substitution keep it as one string, instead of having word splitting split it on white space. Not that splitting would help, since at this point the separation between the original arguments is lost, and the one argument foo bar would be the same as the two arguments foo and bar.

Also, "${@/pattern/pattern --otherflag}" will do the replacement within each positional parameter individually, so with the parameters ls and foo bar, "${@/ls/ls --otherflag}" would result in the two words ls --otherflag. This would look for a command literally called ls --otherflag, the same as if you were to run "ls --otherflag" on the shell command line.

---

What you want is ls, --otherflag, foo bar, i.e. to add the flag as an additional argument.

While you could take all the arguments from $@, escape them for shell processing and join them together to make a valid command line, then edit that command line, and feed it back to the shell with eval, it's safer to just deal with the list as a list.

Adding an argument to the end would be relatively easy:

#!/bin/sh
if ! "$@"; then
    echo "failed, retrying..."
    if ! "$@" --otherflag; then
        echo "nope, still failed"
    fi
fi

Adding one to the middle requires arrays or slicing $@. E.g. to add the flag to the second position:

#!/bin/bash
if ! "$@"; then
    echo "failed, retrying..."
    if ! "$1" --otherflag "${@:2}"; then
        echo "nope, still failed"
    fi
fi

"${@:n:m}" expands to the first m positional parameters starting at index n, or until the end of the list m is not given. So "$1" is the first argument (same as "${@:1:1}"), and "${@:2}" the rest.

Somewhat related: How can we run a command stored in a variable?