Bash. Using ccze without altering data for parsing - bash

I have a complex command on my bash script which prints a lot of info on stdout. This command is complex and takes some time to finish but is fully working. At the same time, I'm using a pipe with tee to write it into a file for a post-parsing task.
cmd="myComplexCommand | tee /dev/fd/5"
exec 5>&1
stored_output=$(eval "${cmd}")
Until here everything is working.
Now, I'm trying to implement ccze to colorize screen output. Usually to use it on any command is as simple as:
anyCommand | ccze -A
And everything is printed in a beauty colorized way. The problem is if I try to apply this to my particular case, after using the pipe to ccze on my myComplexCommand, the output on screen is colorized (nice!) but it alters the output stored on the file I want to parse on my post-parse task and it doesn't work.
Is there a Bash way to print a command using ccze in a beauty way on screen and at the same time store it in a file (without ccze modifications) to parse it later?

tee to file at a point in the pipeline before the colorization takes place:
myComplexCommand | tee filename | ccze -A
Incidentally, with bash 4.1 or later, if you want to send a lot of data both to a file and in colorized form to the TTY, you might put both those operations in a single process substitution:
exec {stdout_backup}>&1
exec {store_and_colorize}> >(tee filename | ccze -A | tee /dev/fd/"$stdout_backup")
and then reuse that process substitution as many times as you like:
result=$(something >&$store_and_colorize)
another_result=$(something_else >&$store_and_colorize)
That way you've got exactly one copy of ccze persisting across multiple uses.

Related

How to make tee in Linux provide screen output line by line, not at the end of execution? [duplicate]

Usually, stdout is line-buffered. In other words, as long as your printf argument ends with a newline, you can expect the line to be printed instantly. This does not appear to hold when using a pipe to redirect to tee.
I have a C++ program, a, that outputs strings, always \n-terminated, to stdout.
When it is run by itself (./a), everything prints correctly and at the right time, as expected. However, if I pipe it to tee (./a | tee output.txt), it doesn't print anything until it quits, which defeats the purpose of using tee.
I know that I could fix it by adding a fflush(stdout) after each printing operation in the C++ program. But is there a cleaner, easier way? Is there a command I can run, for example, that would force stdout to be line-buffered, even when using a pipe?
you can try stdbuf
$ stdbuf --output=L ./a | tee output.txt
(big) part of the man page:
-i, --input=MODE adjust standard input stream buffering
-o, --output=MODE adjust standard output stream buffering
-e, --error=MODE adjust standard error stream buffering
If MODE is 'L' the corresponding stream will be line buffered.
This option is invalid with standard input.
If MODE is '0' the corresponding stream will be unbuffered.
Otherwise MODE is a number which may be followed by one of the following:
KB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.
In this case the corresponding stream will be fully buffered with the buffer
size set to MODE bytes.
keep this in mind, though:
NOTE: If COMMAND adjusts the buffering of its standard streams ('tee' does
for e.g.) then that will override corresponding settings changed by 'stdbuf'.
Also some filters (like 'dd' and 'cat' etc.) dont use streams for I/O,
and are thus unaffected by 'stdbuf' settings.
you are not running stdbuf on tee, you're running it on a, so this shouldn't affect you, unless you set the buffering of a's streams in a's source.
Also, stdbuf is not POSIX, but part of GNU-coreutils.
Try unbuffer (man page) which is part of the expect package. You may already have it on your system.
In your case you would use it like this:
unbuffer ./a | tee output.txt
The -p option is for pipeline mode where unbuffer reads from stdin and passes it to the command in the rest of the arguments.
You can use setlinebuf from stdio.h.
setlinebuf(stdout);
This should change the buffering to "line buffered".
If you need more flexibility you can use setvbuf.
You may also try to execute your command in a pseudo-terminal using the script command (which should enforce line-buffered output to the pipe)!
script -q /dev/null ./a | tee output.txt # Mac OS X, FreeBSD
script -c "./a" /dev/null | tee output.txt # Linux
Be aware the script command does not propagate back the exit status of the wrapped command.
The unbuffer command from the expect package at the #Paused until further notice answer did not worked for me the way it was presented.
Instead of using:
./a | unbuffer -p tee output.txt
I had to use:
unbuffer -p ./a | tee output.txt
(-p is for pipeline mode where unbuffer reads from stdin and passes it to the command in the rest of the arguments)
The expect package can be installed on:
MSYS2 with pacman -S expect
Mac OS with brew install expect
Update
I recently had buffering problems with python inside a shell script (when trying to append timestamp to its output). The fix was to pass -u flag to python this way:
run.sh with python -u script.py
unbuffer -p /bin/bash run.sh 2>&1 | tee /dev/tty | ts '[%Y-%m-%d %H:%M:%S]' >> somefile.txt
This command will put a timestamp on the output and send it to a file and stdout at the same time.
The ts program (timestamp) can be installed with the moreutils package.
Update 2
Recently, also had problems with grep buffering the output, when I used the argument grep --line-buffered on grep to it stop buffering the output.
If you use the C++ stream classes instead, every std::endl is an implicit flush. Using C-style printing, I think the method you suggested (fflush()) is the only way.
The best answer IMO is grep's --line-buffer option as stated here:
https://unix.stackexchange.com/a/53445/40003

Avoid capturing input on a script that stores output of command and functions

I have a script that stores the output of commands, functions, and other scripts in a log file.
I want to avoid capturing user input.
The line that is in charge of storing the output of the commands to a logfile is this one:
$command 2>&1 | tee /dev/tty | ruby -pe 'print Time.now.strftime("[%s] ") if !$stdin.tty?' >> "$tempfile"
If the command is a function or a script that asks for user input and prints out those data, that input is stored in temporary file. I would like to avoid that since I don't want to capture sensible data.
I can't modify the commands, functions that I'm wrapping.
Your command only saves program output, not user input. The problem you're seeing is that the command has chosen to output whatever the user inputs, merging it into its own output that is then obviously logged.
There is no good way around this. Please fix your command.
Anyways. Here's a bad, fragile, hacky way around it:
tempfile=test.txt
command='read -ep Enter_some_input: '
$command 2>&1 |
tee /dev/tty |
python3 -c $'import os\nwhile s:=os.read(0, 1024):\n if len(s) > 3: os.write(1, s)' |
ruby -pe 'print Time.now.strftime("[%s] ") if !$stdin.tty?' >> "$tempfile"
The Python command drops all reads of 3 bytes or less. This aims to remove character by character echo as would happen in the most basic cases of a user typing into readline and similar, while hopefully not removing too much intentional output.

Get bash sub shell output immediately from named pipe

I have a few commands i run between brackets which i then redirect to a named pipe and tail the pipe however it looks like the redirection happens only after the block has finished executing as i don't see any output from the tail command for a while and it only shows the last command ouput when i do. Any ideas how view the output of the block in realtime?
Example Script
#!/usr/bin/env bash
mkfifo /tmp/why_you_no_out;
trap "rm /tmp/why_you_no_out" 0;
{
for ((i=1;i<=100;i++)); do
printf "$i";
done
sleep 10s;
printf "\n12356";
} >> /tmp/why_you_no_out &
printf "here";
tail -n 1 -f /tmp/why_you_no_out
Sounds like the issue is buffering. Most shells don't want to write data a byte at a time because it's wasteful. Instead, they wait until they have a sizable chunk of data before committing it unless the output is connected to your terminal.
If you're looking to unbuffer the output of an arbitrary command, you may find the "unbuffer" utility helpful or any of the solutions mentioned in this question: How to make output of any shell command unbuffered?
If you're dealing with specific applications, they may have options to reduce buffering. For example, GNU's grep includes the --line-buffered option.

Modifying "... | tee -a out.txt" to stream output live, rather than on completion?

I would need to output the output of a command on a file. Let's say my command is zip -r zip.zip directory , I would need to append/write (any of these options would be fine) to a file (let's say out.txt). I got zip zip.zip directory | tee -a out.txt so far, but it doesn't seem to work, it just writes the whole output when the command is over... How can I achieve this?
Thanks ;)
Background (ie. Why?)
Redirections are immediate -- when you run somecommand | tee -a out.txt, somecommand is set up with its stdout sent directly to a tee command, which is defined by its documentation to be unbuffered, and thus to write anything available on its input to its specified output sinks as quickly as possible. Similarly, somecommand >out.txt sets somecommand to be writing to out.txt literally before it's even started.
What's not immediate is flushing of buffered output.
That is to say: The standard C library, and most other tools/languages, buffer output on stdout, combining small writes into big ones. This is generally desirable, inasmuch as decreases the number of calls to and from kernel space ("context switches") in favor of doing a smaller number of more efficient, larger writes.
So your program isn't really waiting until it exits to write its output -- but it is waiting until its buffer (of maybe 32kb, or 64kb, or whatever) is full. If it never generates that much output at all, then it only gets flushed when closing the output stream.
Workarounds (How? -- GNU version)
If you're on a GNU platform, and your program is leaving its file descriptors the way it found them rather than trying to configure buffering explicitly, you can use the stdbuf command to configure buffering like so:
stdbuf -oL somecommand | tee -a out.txt
defines stdout (-o) to be line-buffered (L) when running somecommand.
Workarounds (How? -- Expect version)
Alternately, if you have expect installed, you can use the unbuffer helper it includes:
unbuffer somecommand | tee -a out.txt
...which will actually simulate a TTY (as expect does), getting the same non-buffered behavior you have when somecommand is connected directly to a console.
Did you try option command > out.log 2>&1 this log to file everything without displaying anything, everything will go straight to the file

Recording whole terminal screen using tee

I am trying to get help from someone, so I want to record my screen to be able to later review what happened. Formerly, I have used ssh with tee like ssh user#server | tee recfile and the recording works fine. Even when I use byobu on the server, everything is recorded using that simple pipe.
But when I pipe byobu itself to tee, the file will contain pretty nothing. I have used both byobu | tee recfile and byobu |& tee recfile. In both cases, byobu starts and works well, but the record file will only contain a few lines not related to the things happened in byobu session.
And byobu uses tmux. I have tried to pipe tmux to tee as well, and the output file only contained [exited].
My question is how tmux writes to the screen? It seems that it does not use standard output or standard error, as if it did, tee could work recording the screen. Is there a way to tell tmux to write to the standard output or standard error? Or is there another way to redirect the output to tee?
Edit: I checked that screen | tee recfile and screen |& tee recfile will produce an empty file. Also, bash | tee recfile will only redirect the output of executed commands to the file (user#name:~$'s and the input commands are not in there). bash |& tee recfile will do likewise, except that the prompt of the bash (user#name:~$) is not displayed at all.
As gniourf_gniourf pointed out, script solved my problem.
I also wrote a simple C++ code to playback the recorded file. Compile it with --std=c++11. (I use script -c byobu --timing=recfile.tim recfile to record and scriptout recfile recfile.tim 3 for playback.)
https://gist.github.com/Shayan-To/672c77fbf9811d769d453c8a9b43747e

Resources