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

Você pode monitorar a atividade de

1. um fifo usando o shellscript viafifoou
2. um xtermarquivo de log usando o shellscriptvialog

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

1. Inicie uma zenitymensagem de informação, quando houver entrada de um programa monitorado usando um fifo usando viafifo.

O shellscript a seguir pode monitorar o diálogo de saída de um programa e enviar um alerta. Ele precisa espeake script(e scriptnão precisa ser instalado no Ubuntu).

sudo apt update
sudo apt install espeak

• assumindo um ambiente gráfico de área de trabalho
• iniciar um shellscript em uma janela de terminal, vamos chamá-lo de viafifo.
• iniciando o programa a ser monitorado 'em viafifo'
• executando o diálogo na janela do terminal (é onde você escreve sua entrada)
• usando um fifo para obter acesso à saída do programa a ser monitorado, /dev/stdin, /dev/stdoute dev/stderr. A principal tarefa no shellscript é a linha com o programa script, que está monitorando a atividade na janela do terminal e gravando no fifo.
• executando um whileloop
  • testando se o fifo foi modificado e nesse caso
    • iniciar uma zenityjanela de mensagem de informação e uma mensagem falada correspondente com espeak.
    • atrasos curtos 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.

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

#!/bin/bash

# date        editor   comment
# 2019-01-01  sudodus  version 1.0
# 2019-01-05  sudodus  fixed output of version
# 2019-01-05  sudodus  version 1.1

version=1.1

name=${0##*/}

# Usage

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 <options>
Example: $name
         $name -h       # this help text
         $name -v       # show version"
 exit
elif [ "$1" == "-v" ]
then
 echo "$name version $version"
 exit
fi

# Preparation

message="Check, if the monitored program asks for input"

inversvid="\0033[7m"
resetvid="\0033[0m"
tmpdir=$(mktemp -d)
tmpfifo=$(mktemp --tmpdir=$tmpdir)
rm "$tmpfifo"
mkfifo "$tmpfifo"
#ls -l "$tmpdir"
sleep 1
cnt1=$(stat --printf "%Y" "$tmpfifo")

< "$tmpfifo" cat >> $tmpdir/${name}.log  &

# Monitor the output from program with a while loop

while true
do
  if test -f $tmpdir/stop
  then
   break
  fi
  cnt0=$cnt1
  sleep 0.5
  cnt1=$(stat --printf "%Y" "$tmpfifo")

  if [ $cnt1 -gt $((cnt0+8)) ]
  then
#   zenity --notification --text="$message" 2> /dev/null
   espeak "$message" &
   zenity --info --title="${0##*/} ${1##*/} $2 ..." \
    --text="$message" --width=500  2> /dev/null
   sleep 0.5
   cnt1=$(stat --printf "%Y" "$tmpfifo")
  fi
  sleep 1
done &

# Prepare for the monitoring

echo -en "\0033]0;$name: 'exit' to leave subshell\0007"
echo -en "\0033]1;$name\0007"
ncol=$(tput cols)
nfill=$((ncol -13 -${#name}))
hyphs=$(for ((i=1;i<=nfill;i++));do echo -n '-';done;echo '')
echo -e "$inversvid----- Start $name $hyphs$resetvid"
tstart=$(date '+%s')

# Monitoring

script -fq $tmpfifo

# Finish writing after monitoring

tend=$(date '+%s')
tuse=$((tend-tstart))
winttl=$(pwd)
echo -en "\0033]0;$winttl\0007"
echo -en "\0033]1;$winttl\0007"
ncol=$(tput cols)
nfill=$((ncol -11 -${#name}))
hyphs=$(for ((i=1;i<=nfill;i++));do echo -n '-';done;echo '')
echo -e "$inversvid----- End $name $hyphs$resetvid"

touch $tmpdir/stop  # to break the while loop
sleep 3

savlog="Finished. Save the log '${name}.log'?"

espeak "$savlog" &
zenity --question --title="${0##*/} ${1##*/} $2 ..." \
    --text="$savlog" --width=500  2> /dev/null
if [ $? = 0 ]
then
 echo "$name used $tuse seconds" >> $tmpdir/${name}.log
 mv $tmpdir/${name}.log . && echo "See '${name}.log'" || echo "Failed to save the log file"
fi
echo "$name used $tuse seconds plus a few (5-10) seconds for preparing and finishing"

# Clean up

rm -r "$tmpdir"

2. Inicie uma zenitymensagem de informação, quando algo for escrito em uma xtermjanela (do programa monitorado ou do usuário) usando vialog.

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

sudo apt update
sudo apt install espeak xterm

• assumindo um ambiente gráfico de área de trabalho
• iniciar um shellscript em uma janela de terminal, que é usada como um 'console' paravialog
• 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
    • iniciar uma zenityjanela de mensagem de informação e uma mensagem falada correspondente com espeak.
    • atrasos curtos 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.

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"

3. Ubuntu Server monitorado remotamente viassh

Uma versão especial pode ser feita para o Ubuntu Server que funciona em modo texto, a menos que a ferramenta GUI funcione por meio de uma janela de terminal e via ssh.

Eu verifiquei e essas ferramentas funcionam com um servidor por meio de uma conexão em modo texto por meio sshde um computador com um ambiente gráfico de área de trabalho.

• A captura de tela a seguir ilustra como vialogé iniciado no cliente (um laptop com Ubuntu persistente ao vivo).
• Em seguida, sshconecta-se ao servidor e executa algumas tarefas demoradas (aqui ilustradas pela cópia de alguns arquivos ISO grandes.
• Demora bastante para copiar o arquivo iso do Ubuntu Studio para que o alerta seja ativado, quando o comando quiser uma decisão minha no meio do processo (sobrescrever ou não).