Notifica desktop al termine dei comandi di lunga durata

Vorrei ricevere una notifica desktop ogni volta che un comando eseguito per più di, diciamo 15 secondi, termina in una shell interattiva.

In altre parole, vorrei che tutti i comandi fossero racchiusi in qualcosa del genere

start=$(date +%s);
ORIGINAL_COMMAND;
[ $(($(date +%s) - start)) -le 15 ] || notify-send "Long running command finished"

Qual è il modo migliore per ottenere questo risultato in bash?

Vuoi https://launchpad.net/undistract-me (installabile dagli archivi Ubuntu con sudo apt-get install undistract-me) che fa esattamente quello che stai chiedendo, incluso lavorare automaticamente (cioè, senza dover ricordare di aggiungere qualcosa in più a potenzialmente lungo- comandi in esecuzione).

Per quanto ho capito, vuoi un involucro . E vuoi usare un comando attraverso di esso in modo che ti dia la notifica desiderata se il tempo di esecuzione del tuo comando è superiore a 15 sec. Quindi eccolo qui.

wrapper(){
    start=$(date +%s)
    "$@"
    [ $(($(date +%s) - start)) -le 15 ] || notify-send "Notification" "Long\
 running command \"$(echo $@)\" took $(($(date +%s) - start)) seconds to finish"
}

Copia questa funzione nel tuo ~/.bashrce sorgente ~/.bashrccome,

. ~/.bashrc

Usage

wrapper <your_command>

Se impiega più di 15 secondi, riceverai una notifica sul desktop che descrive il comando e il suo tempo di esecuzione.

Esempio

wrapper sudo apt-get update

In ~/.bashrcc'è un alias alertdefinito come:

alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'

che può essere utilizzato per notificare il completamento dell'esecuzione del comando.

Uso:

$ the_command; alert

per esempio

$ sudo apt-get update; alert

Puoi personalizzare l'alias secondo le tue necessità e desideri.

A parte un involucro come suggerito souravc, non c'è davvero alcun buon modo per farlo in bash. Puoi aggirarti con una trappola DEBUG e un PROMPT_COMMAND. Una trap DEBUG viene attivata ogni volta che si esegue un comando e PROMPT_COMMAND viene eseguito subito prima della scrittura del prompt.

Quindi roba per ~/.bashrcdiventa qualcosa di simile

trap '_start=$SECONDS' DEBUG
PROMPT_COMMAND='(if (( SECONDS - _start > 15 )); then notify-send "Long running command ended"; fi)'

Questo è un trucco, quindi non sorprenderti se incontri strani effetti collaterali con questo.

MODIFICARE

TL; DR : crea il collegamento al completamento automatico .inputrce funzione in .bashrc . Esegui il comando come al solito, digita, ma invece di ENTER, premi il collegamento che hai specificato.inputrc

La persona che ha posto la grazia a questa domanda ha detto:

"Tutte le risposte esistenti richiedono di digitare un comando aggiuntivo dopo il comando. Voglio una risposta che lo faccia automaticamente."

Durante la ricerca delle soluzioni a questo problema mi sono imbattuto in questa domanda da StackExchange, che consente l'associazione CtrlJa una sequenza di comandi: Ctrla(sposta all'inizio della riga), posiziona la stringa "mesure" davanti al comando che hai inserito, Ctrlm(esegui)

In questo modo ottieni funzionalità di auto-completamento e ENTERcomando separato per misurare il tempo, pur mantenendo lo scopo originale della seconda funzione che ho pubblicato qui sotto.

A partire da ora, ecco i contenuti del mio ~/.inputrcfile:

"\C-j": "\C-a measure \C-m"

Ed ecco il contenuto di .bashrc(nota, non uso mai bash da sempre - uso mksh come shell, quindi è quello che vedi nel post originale. La funzionalità è sempre la stessa)

PS1=' serg@ubuntu [$(pwd)]
================================
$ '
function measure () 
{

/usr/bin/time --output="/home/xieerqi/.timefile" -f "%e" $@ 

if [ $( cat ~/.timefile| cut -d'.' -f1 ) -gt 15 ]; then

    notify-send "Hi , $@ is done !"

fi


}

Posta originale

Ecco la mia idea: utilizzare una funzione in .bashrc. Principio di base: utilizzare /usr/bin/timeper misurare il tempo necessario per il completamento del comando e, se è superiore a 15 secondi, inviare una notifica.

function measure () 
{

if [ $( /usr/bin/time -f "%e" $@ 2>&1 >/dev/null ) -gt 15 ]; then

    notify-send "Hi , $@ is done !"

fi


}

Qui sto reindirizzando l'output /dev/nullma per visualizzare l'output, è possibile eseguire anche il reindirizzamento al file.

Un approccio molto migliore, IMHO, è di inviare l'output di tempo ad alcuni file nella cartella home (solo per non inquinare il sistema con i file temporali e sapere sempre dove cercare). Ecco quella seconda versione

function measure () 
{

/usr/bin/time --output=~/.timefile -f "%e" $@ 

if [ $( cat ~/.timefile | cut -d'.' -f1 ) -gt 15 ]; then

    notify-send "Hi , $@ is done !"

fi


}

Ed ecco gli screenshot della prima e della seconda versione, in questo ordine

Prima versione, nessun output

Seconda versione, con output

Di recente ho creato uno strumento che serve a questo scopo. Può essere eseguito come wrapper o automaticamente con l'integrazione della shell. Dai un'occhiata qui: http://ntfy.rtfd.io

Per installarlo:

sudo pip install ntfy

Per usarlo come wrapper:

ntfy done sleep 3

Per ricevere automaticamente le notifiche, aggiungilo al tuo .bashrco .zshrc:

eval "$(ntfy shell-integration)"

Il tuo script funziona abbastanza bene, assicurati di includere la riga 'shebang' ( #!/bin/bash) . Altri #!/bin/bashcitati qui , ma il più delle volte, #!/bin/bashfunzionano bene con gli script Unix bash. È richiesto dall'interprete di script in modo da sapere che tipo di script è.

Questo sembra funzionare come uno script di test:

#!/bin/bash
start=$(date +%s);
   echo Started
   sleep 20;
   echo Finished!
[ $(($(date +%s) - start)) -le 15 ] || notify-send -i dialog-warning-symbolic "Header" "Message"

^{Per modificare questo script, inserisci i comandi in corrispondenza delle righe echoe sleep.}

Nota con notify-send, puoi usare anche -iper specificare un'icona :-)

Inoltre, assicurati che sia eseguibile eseguendolo chmod +x /PATH/TO/FILEprima.

È possibile modificare Bash per implementare la funzionalità wrapper desiderata.

Se sei propenso ad apportare molte di tali modifiche alla tua shell interattiva, potresti prendere in considerazione il passaggio a una shell intrinsecamente hackerabile come eshell, che è costruita usando Emacs elisp e ha tutta la sua leggendaria personalizzazione:

http://www.masteringemacs.org/articles/2010/12/13/complete-guide-mastering-eshell/

Puoi anche farlo con una semplice istruzione if come questa

#!/bin/bash

START=$(date +%s)

TIME=$(($START+15))

ORIGINAL_COMMAND;

END=$(date +%s)

if [ $END -gt $TIME ]
then
    notify-send "Task Completed"
fi

Puoi usare i tuoi nomi di variabili.

Posso confermare che funziona, ho testato con un comando che richiede molto tempo per terminare e uno che non funziona e la notifica arriva per quella che richiede molto tempo

È anche possibile fare questo con qualsiasi comando, sostituendo ORIGINAL_COMMANDcon $@e l'esecuzione dello script come ./script command.