Monitorar o diálogo de um programa e enviar um alerta

Você pode monitorar a atividade de

1. um fifo ou
2. um xtermarquivo de log , agora com um modo interativo

e deixá-lo iniciar uma zenitymensagem de informação , quando houver entrada do programa monitorado. Se desejar, você também pode instalar espeake deixá-lo enviar uma mensagem de áudio .

1. Inicie uma zenitymensagem informativa, quando houver entrada de um programa monitorado usando um fifo.

O shellscript a seguir pode monitorar o diálogo de saída de um programa e enviar um alerta.

• assumindo um ambiente de desktop gráfico
• inicie um shellscript wrapper em uma janela de terminal, que é usado como um 'console' parawrapper
• iniciando o programa a ser monitorado em uma xtermjanela
• executando o diálogo na xtermjanela (é onde você escreve sua entrada)
• usando um fifo para ter acesso à saída do programa a ser monitorado, /dev/stdoute dev/stderr.
• executando um whileloop
  • testando se o fifo foi modificado e nesse caso
    • iniciando uma zenityjanela de mensagem informativa.

Espera-se que você feche a zenityjanela (pode trabalhar com 'Enter') para voltar à xtermjanela, onde você escreve sua entrada.

#!/bin/bash

if [ $# -eq 0 ]
then
 echo "'$0' is a wrapper, that sends a notification, when the wrapped program
has written to standard input and standard error and may be waiting for input.
---
Usage:   $0 <program name> [parameters]
Example: $0 .program"
 exit
fi

message="'${1##*/} $2 ...' has written something, maybe asks for input"

tmpdir=$(mktemp -d)
tmpfifo=$(mktemp --tmpdir=$tmpdir)
rm "$tmpfifo"
mkfifo "$tmpfifo"
#ls -l "$tmpdir"
cnt1=$(stat --printf "%Y" "$tmpfifo")
sleep 1

xterm -title "${1##*/} $2 ..." -fa default -fs 11 -bg '#403600' \
 -e bash -c "$* 2>&1 | tee /dev/stderr 2>&1 > $tmpfifo" 2> /dev/null & pid=$!

#< "$tmpfifo" espeak &
< "$tmpfifo" cat &

cont=true
while $cont
do
 tmpstr=$(ps -Af |sed "s/grep $pid//"|grep "$pid")
# echo "$tmpstr"
 if [ "$tmpstr" != "" ]
 then
  cnt0=$cnt1
  cnt1=$(stat --printf "%Y" "$tmpfifo")
  if [ "$cnt1" != "$cnt0" ]
  then
#   zenity --notification --text="$message" 2> /dev/null
#   espeak "$message" &
   zenity --info --title="${0##*/} ${1##*/} $2 ..." \
    --text="$message" --width=500  2> /dev/null
  fi
  sleep 1
  else
  sleep .2
  # echo "process $pid has finished"
  cont=false
 fi
done

# clean up

rm -r "$tmpdir"

Você pode querer correr espeakperto zenitypara receber uma mensagem de áudio também. Nesse caso, você pode remover o #caractere no início dessa linha. (Pode haver muito texto do programa, então geralmente é uma má ideia redirecionar o fifo para espeak. É melhor redirecionar o fifo para cate imprimi-lo no 'console'.)

Demonstração

Você pode testar algumas linhas de comando com cp -ie mv -ie você pode testar com o seguinte pequeno shellscript program,

#!/bin/bash

while true
do
 read -p "Waiting for input. 'Stop' to Quit " string
 if [ "${string:0:4}" == "Stop" ]
 then
  printf "$string. Gotcha\n"
  break
 elif [ "$string" != "" ]
 then
  printf "$string\n"
  printf "Working for 10 seconds ...\n"
  sleep 10
 else 
  sleep 3
 fi
done

Texto de ajuda:

$ ./wrapper
'./wrapper' is a wrapper, that sends a notification, when the wrapped program
has written to standard input and standard error and may be waiting for input.
---
Usage:   ./wrapper <program name> [parameters]
Example: ./wrapper .program

Monitoramento program:

$ ./wrapper ./program

zenityjanela de mensagem de informação:

Diálogo na xtermjanela:

Waiting for input. 'Stop' to Quit Hello
Hello
Working for 10 seconds ...
Waiting for input. 'Stop' to Quit World
World
Working for 10 seconds ...
Waiting for input. 'Stop' to Quit Goodbye
Goodbye
Working for 10 seconds ...
Waiting for input. 'Stop' to Quit Stop

Saída 'Console' na janela do terminal original após terminar:

$ ./wrapper ./program
Waiting for input. 'Stop' to Quit Hello
Working for 10 seconds ...
Waiting for input. 'Stop' to Quit World
Working for 10 seconds ...
Waiting for input. 'Stop' to Quit Goodbye
Working for 10 seconds ...
Waiting for input. 'Stop' to Quit Stop. Gotcha

Monitoramento cp -ip:

$ LANG=C /path/wrapper cp -ip ubuntustudio-18.04-dvd-amd64.iso ubuntu-18.04.1-desktop-amd64.iso /tmp

zenityjanela de mensagem de informação:

Diálogo em xterm:

cp: overwrite '/tmp/ubuntustudio-18.04-dvd-amd64.iso'? y
cp: overwrite '/tmp/ubuntu-18.04.1-desktop-amd64.iso'? n

Monitoramento sudo parted /dev/sdc:

$ LANG=C ./wrapper sudo parted /dev/sdc

Diálogo em xterm:

[sudo] password for sudodus: 
GNU Parted 3.2
Using /dev/sdc
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) p                                                                
Model: SanDisk Extreme (scsi)
Disk /dev/sdc: 16,0GB
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Disk Flags: 

Number  Start   End     Size    Type      File system  Flags
 3      2097kB  258MB   256MB   primary   fat32        boot
 4      258MB   1366MB  1108MB  primary
 2      1366MB  12,4GB  11,0GB  extended               lba
 5      1367MB  6736MB  5369MB  logical   ext2
 6      6737MB  12,4GB  5615MB  logical   ext4
 1      12,4GB  16,0GB  3662MB  primary   ntfs

(parted) q

2. Iniciar uma zenitymensagem informativa, quando algo é escrito em uma xtermjanela (do programa monitorado ou do usuário).

O shellscript a seguir pode monitorar o diálogo com um programa e enviar um alerta.

• assumindo um ambiente de desktop gráfico
• inicie um shellscript wrapper em uma janela de terminal, que é usado como um 'console' parawrapper
• iniciando o programa a ser monitorado em uma xtermjanela
• executando o diálogo na xtermjanela (é onde você escreve sua entrada)
• usando um arquivo de log xtermpara obter acesso à saída e entrada do programa a ser monitorado
• executando um whileloop
  • testando se o arquivo de log foi modificado e nesse caso
    • iniciando uma zenityjanela de mensagem informativa.
    • pequenos atrasos são permitidos durante a digitação da entrada (8 segundos; você pode editar o arquivo de script para alterar o tempo de atraso).

Espera-se que você feche a zenityjanela (pode trabalhar com 'Enter') para voltar à xtermjanela, onde você escreve sua entrada.

Agora existe um modo interativo, onde você usa a xtermjanela da mesma forma que usa qualquer janela de terminal. Feche a xtermjanela para interromper o monitoramento.

#!/bin/bash

# date        editor   comment
# 2018-12-31  sudodus  version 1.0

version=1.0

name="${0##*/}"
if [ "$1" == "-h" ] || [ "$1" == "--help" ]
then
 echo "'$name' is a wrapper, that sends a notification, when the wrapped program
has written to standard input and standard error and may be waiting for input.
---
Usage:    $name [program name] [parameters]
Examples: $name          # to run program(s) interactively in an xterm window
          $name program
          $name -h       # to get help (this text)
          $name -v       # show version"
 exit
elif [ "$1" == "-v" ]
then
 echo "$name version $version"
 exit
fi
tstart=$(date '+%s')
echo "----- start $name at $(date '+%F %T') ----------------------------"
tmpstr="${1##*/}"
xtermlog=$(mktemp -u)

if [ $# -eq 0 ]
then
 mess_zenity="Check, if the monitored program asks for input"
 mess_espeak="${mess_zenity/program/, Program,}"
 xterm -title "monitored by ${0##*/}" -fa default -fs 11 -bg '#2c2b2a' \
 -l -lf "$xtermlog" -sb -rightbar 2> /dev/null & pid=$!
else
 mess_espeak="Check if '${tmpstr^} ${2##*/} ${3##*/} ...' asks for input"
 mess_zenity="Check if '$tmpstr $2 $3 ...' asks for input"
 xterm -title "${1##*/} $2 $3 ..." -fa default -fs 11 -bg '#2c2b2a' \
 -l -lf "$xtermlog" -e "$@" 2> /dev/null & pid=$!
fi
sleep 0.5
sync
cnt1=$(stat --printf "%Y" "$xtermlog")
tail -f "$xtermlog" & ptail=$!

cont=true
while $cont
do
 sleep 1
 cnt0=$cnt1
 tmpstr=$(ps -Af |sed "s/grep $pid//"|grep "$pid")
# echo "$tmpstr"
 if [ "$tmpstr" != "" ]
 then
  cnt1=$(stat --printf "%Y" "$xtermlog")
  if [ $cnt1 -gt $((cnt0 + 8)) ]
  then
#   zenity --notification --text="$message" 2> /dev/null
   espeak "$mess_espeak" &
   zenity --info --title="${0##*/} ${1##*/} $2 ..." \
    --text="$mess_zenity" --width=500  2> /dev/null
   touch "$xtermlog"
   cnt1=$(stat --printf "%Y" "$xtermlog")
  fi
  sleep 1
  else
  sleep .2
  # echo "process $pid has finished"
  cont=false
 fi
done

# clean up
tmpstr="$(tail -n1 "$xtermlog" | sed 's/.*exit.*/exit/')"
if [ "$tmpstr" != "exit" ]
then
 echo ""
fi
rm -r "$xtermlog"
kill $ptail
tend=$(date '+%s')
tuse=$((tend-tstart))
echo "------- end $name at $(date '+%F %T') --- used $tuse seconds"

Salve este bashcódigo em um arquivo e dê a ele [por exemplo] o nome vialog, torne-o executável e talvez mova-o para um diretório em seu caminho.

$ vialog
----- start vialog at 2018-12-31 14:37:41 ----------------------------

Você trabalha na xtermjanela e o diálogo ecoa na janela inicial também.

sudodus@bionic64 /media/multimed-2/test/test0/pomsky-wrap $ ./program
Waiting for input. 'Stop' to Quit Hello World
Hello World
Working for 10 seconds ...
Waiting for input. 'Stop' to Quit I am writing ...
I am writing ...
Working for 10 seconds ...
Waiting for input. 'Stop' to Quit Stop
Stop. Gotcha
sudodus@bionic64 /media/multimed-2/test/test0/pomsky-wrap $ scrot -sb
sudodus@bionic64 /media/multimed-2/test/test0/pomsky-wrap $ exit
exit
------- end vialog at 2018-12-31 14:39:02 --- used 81 seconds

Convite para feedback

Em vez de adicionar outro shellscript à minha resposta já existente, acho que é melhor com uma segunda resposta. Vou ouvir os comentários e focar no script/método preferido e tentar mesclar o que é preferido em uma resposta (a menos que haja motivos para mantê-los todos (para diferentes propósitos).

Monitorar o diálogo de um programa e enviar um alerta

Você pode monitorar a atividade de

1. um fifo ou
2. um xtermarquivo de registro

e deixá-lo iniciar uma zenitymensagem de informação , quando houver entrada do programa monitorado. Se desejar, você também pode instalar espeake deixá-lo enviar uma mensagem de áudio .

Esta resposta se concentra em uma segunda alternativa usando um fifo .

Start a zenity info message, when there is input from a monitored program using a fifo.

1.1 Using xterm, monitoring standard output and standard error via a fifo

This wrapper method has the

• advantage, that no direct input will trigger the alert. This works well with many programs, for example cp -i and sudo.
• disadvantage, that
  • some programs will be disabled, because they use not only standard output and standard error for writing its output. Example: sftp will lose the prompt, and the user cannot know, when the program is ready for a new task.
  • some programs echo the input (there is indirect input), and this will trigger the alert, which may cause a lot of alerts in a shellscript, that does not take that into account. Example: ssh.

1.2 Using the compiled program script and its log file via a fifo

The following shellscript can monitor the output dialogue from a program and send an alert. It needs espeak and script (script need not be installed in Ubuntu and Debian).

sudo apt update
sudo apt install espeak

• assuming a graphical desktop environment
• start a shellscript in a terminal window, let us call it viafifo.
• starting the program to be monitored 'in viafifo'
• running the dialogue in the terminal window (that is where you write your input)
• using a fifo to get access to the output of the program to be monitored, /dev/stdin, /dev/stdout and dev/stderr. The main task in the shellscript is the line with the program script, that is monitoring the activity in the terminal window and writing to the fifo.
• running a while loop
  • testing if the fifo has been modified and in that case
    • starting a zenity info message window and a correspoding spoken message with espeak.
    • short delays are allowed during typing the input (8 seconds; you can edit the script file to change the delay time).

You are expected to close the zenity window (can work with 'Enter') to get back to the xterm window, where you write your input.

Digite exitpara sair scripte viafifo. Depois disso, você pode obter um arquivo de log com todo o diálogo.

viafifoé testado com

• Ubuntu 18.04.1LTS . <---Você encontra ocódigo bashviafifo neste link .
• Debian 9.6.0, 'Esticar'. Veja as seguintes capturas de tela e impressão de time viafifoe viafifo.log.

Exemplo de demonstração

Capturas de tela

time viafifo

user@debian:~$ time viafifo
----- Start viafifo ------------------------------------------------------------
user@debian:~$ echo hello
hello
user@debian:~$ exit
exit
----- End viafifo --------------------------------------------------------------
See 'viafifo.log'
viafifo used 8 seconds plus a few (5-10) seconds for preparing and finishing
real    0m13.295s
user    0m0.104s
sys 0m0.012s

viafifo.log

user@debian:~$ cat viafifo.log
Script started on Sat 05 Jan 2019 07:57:45 PM UTC
user@debian:~$ echo hello
hello
user@debian:~$ exit
exit
viafifo used 8 seconds
user@debian:~$