Killing a process and diffing its result

Question

I've been trying to write a simple bash script, but I cannot get it to work.

I want to:

• Start a program, feeding it input from a text file (./prog < input1.txt)
• Wait a short amount of time and the kill it as if it was served a keyboard interrupt (& PID=$!; sleep 1; kill -INT $PID) source
• Find the differences between the program's output and a text file (| diff -y output1.txt -) source

Here's what I have now, putting the previous steps together:

./program < input1.txt & PID=$!; sleep 1; kill -INT $PID | diff -y output1.txt -

This version always reports that the first command has had no output, since the PID line is shadowing it. If I add even a file redirect after the program name, the kill command stops working since it is now pointing at the redirect.

Edit: I am on Ubuntu 16.04; the output of bash --version is GNU bash, version 4.3.48(1)-release (x86_64-pc-linux-gnu)

Answer 1

Indeed, in your code diff receives the output of kill instead of program. You can solve this by compounding the commands before the pipe in a subshell with ().

Another potential issue with your script is that kill is not designed to wait for termination of program; instead it just sends a signal to it. Therefore you may see a race condition where diff works without catching the whole output of program. I advice to programatically wait for termination of the backgound process with the wait bash builtin.

Here goes a sample of your code containing the above fixes:

#!/bin/bash
(
    ./program <input1.txt &
    PID=$!
    sleep 1
    kill -INT $PID
    wait
) | diff -y reference_output.txt -

Answer 2

You can use a process substitution[1]:

diff -y output1.txt <(your_program & sleep 1; kill $!)

If your_program is able to generate huge amounts of data in a second (as when testing with yes(1)), then diff will have a lot of trouble coping with, and unless you have some careful limits put in place, it may blow your memory and hang up your machine (and in the best case it will create the illusion that the command is "hanging" for a while). Instead of yes, try it with a slowyes script like while echo y; do sleep .01; done.

Notice that a <(...) process substitution runs in parallel, so diff will not wait for it to finish before starting to process its data.

I guess you will be better served by stopping your_program after it has generated a number of lines, instead of after a period of time:

diff -y output1.txt <(your_program | head -n 1000)

In this case, your_program should be killed by SIGPIPE, as usual with the left side of a pipeline. If your program is ignoring both SIGPIPE and write(2) errors, then please make another question about that, either how to fix it or how to work it around.

[1] if your shell does not support process substitutions (as the /bin/sh on debian, which is not bash), you can also use a pipeline, as in the other answer

{ your_program & sleep 1; kill $!; } | diff -y output1.txt -

the same caveats apply to this case, too.