mjhjmtu

I have two functions in my shell scripts I run in background:

function foo 
 # do a bunch of things
 # print a lot of output


function bar 
 # do more things
 # print out more things


foo &
bar &
wait

The output is printed out as it comes out to stdout or stderr, so there's a lot of overlap:

[foo] output line 1
[bar] output line 1 
[foo] output line 2
[bar] output line 2

I'd like the output to be printed out sequentially (all of foo's output followed by all of bar's output) so that it's easier to read. Do I need to write the output to a file, then print out the file, or is there a way to do this without writing to files?

Every output is written to a file anyway, I don’t know of a way not to use files. I’d use tempfiles as needed, e.g.:

$ a=$(mktemp)
$ b=$(mktemp)
$ echo 1 >$a & echo 2 >$b & wait
$ cat $b
2
$ cat $a
1

mktemp creates two tempfiles a and b, the echo commands write to the tempfiles, you can then use cat to print from them at any time you need the output. If you want to redirect both stdout and stderr, use &> instead.

I would like to see a complete solution, that will be efficient on large number of records. Meanwhile if you have few hundred lines or lot of time (for few hundred thousands lines) you can try something like this:

#!/bin/bash

# Two functions that do number of things
foo() for i in 1..3; do echo "foo $i."; done; exit 0; 
bar() for i in 1..5; do echo "bar .$i"; done; exit 0; 

# The missing function :)
log_cat() wc -l)" && echo "[foo lines]: $FOO_LINES"
 BAR_LINES="$(cat "$BAR_LOG" 

# Define log files
FOO_LOG="/tmp/prefix_foo.tmp"
BAR_LOG="/tmp/prefix_bar.tmp"

# Execute the two functions and redirect their stdout to the log files
foo > "$FOO_LOG" &
bar > "$BAR_LOG" &
wait

# Concatenate the log files in the desired way
log_cat

Sample output:

$ ./rotate.sh 
[foo lines]: 3
[bar lines]: 5

[foo 1]: foo 1.
[bar 1]: bar .1

[foo 2]: foo 2.
[bar 2]: bar .2

[foo 3]: foo 3.
[bar 3]: bar .3

[foo 4]: 
[bar 4]: bar .4

[foo 5]: 
[bar 5]: bar .5

Well, the system is writing to files anyway to accomplish this; they're just temp files. However, you could have the foo process output to one file and rename it when complete. Have bar watch for the rename of said file, and when foo completes the rename, bar outputs the foo output then prints its own output, a la:

function foo 
 # do a bunch of things 
 # print a lot of output to /tmp/foo.work 
 # mv /tmp/foo.work /tmp/foo.done 
 

function bar 
 # do more things 
 # write more things to /tmp/bar.done 
 # if exist /tmp/foo.done print /tmp/foo.done else wait 1 and recheck 
 # rm /tmp/foo.done 
 # print /tmp/bar.done