Come posso attivare una notifica al termine di un processo / processo?

Il posto in cui lavoro ha comandi che richiedono molto tempo per essere eseguiti.

C'è un comando / utilità che posso usare per avvisarmi quando l'esecuzione del comando è finita? Potrebbe essere una finestra popup o forse un piccolo suono.

In generale, se lo sai prima eseguendo il comando, puoi solo avviarlo con:

command; command-after &

Questo eseguirà il command-after dopo il comando precedente è uscito (indipendentemente dal suo codice di uscita). Il & lo avvierà in background.

Se ti interessa un'uscita riuscita o fallita, usa rispettivamente:

command && command-after-only-if-success &
command || command-after-only-if-fail &

Se il comando ha già iniziato puoi usare il controllo dei lavori per sospenderlo, quindi riportarlo in primo piano con fg incatenato con la tua notifica:

command
# enter Ctrl-z
fg ; command-after

Ora ... quello che vuoi fare dopo dipende dal tuo ambiente.

• Sopra qualsiasi sistema , Puoi "Suona" la campana del terminale . Dipende dal tuo sistema esatto che cosa funziona veramente (BSD vs. GNU Linux, ecc.), Ma tput bel dovresti ... dovrebbe. Non ho potuto testarlo in modo affidabile in questo momento, però. Cerca "suoneria" per saperne di più.

• Sopra Mac OS X , puoi usare AppleScript per far apparire una finestra di dialogo del Finder:

  osascript -e 'tell Application "Finder" to display dialog "Job finished" '
  

  Potresti dirti qualcosa:

  say "Job finished"
  

  Oppure puoi usare il sistema di notifica di Mountain Lion:

  sudo gem install terminal-notifier # <= only need to do this once
  terminal-notifier -message "Job finished!" -title "Info"
  

• Nel GNOME , zenity può mostrare una finestra di dialogo GTK, chiamata dalla riga di comando. Vedi anche questa domanda sull'overflow dello stack: mostrando una finestra di messaggio da uno script bash in linux . Può essere installato tramite il gestore di pacchetti preferito.

  zenity --info --text="Job finished"
  

• Alcune distribuzioni potrebbero avere xmessage. In particolare per gli ambienti GTK, c'è gxmessage.

• Ubuntu ha un sistema di notifica che puoi attivare con notify-send.

  notify-send "Job finished!"
  

• KDE usi kdialog, per esempio:

  kdialog --passivepopup 'Job finished'
  

Sui sistemi unix puoi suonare il campanello acustico:

echo -e "\a"

Ho creato uno strumento semplice, per MacOS X, che fa esattamente questo. https://github.com/vikfroberg/brb

Installazione

$ npm install -g brb

Istruzioni

$ sleep 3; brb

Ho appena iniziato a usare notifu per le notifiche desktop da Cygwin. È un'app di notifica della riga di comando per Windows.

Esempio:

ls -l && /c/notifu-1.6/notifu64 /m "This is a simple Notifu message."

Per ottenere una notifica sonora è possibile utilizzare spd-say "Some text". Esempio:

some-command; spd-say "Yo"

Per Linux, c'è un trucco ingegnoso per farlo automaticamente senza dover digitare un comando per la notifica ogni volta.

Prima installare Autokey. Questo aiuta a definire le azioni per diverse sequenze di tasti.

sudo apt-get install autokey-gtk

Ora, definire una nuova frase in autokey e assegnare il tasto di scelta rapida come Alt + Invio. Aggiungi questa frase:

; notify-send "Job finished!" &
  #

Si noti che una nuova riga dopo la prima riga è importante.

Inoltre, aggiungi un filtro finestra. Io uso guake e terminale. Includere qualsiasi altro terminale che si utilizza.

.*(guake)|(Terminal).*

Hai finito!!

Ora, ogni volta che è necessario ricevere notifiche per un comando, eseguirlo usando Alt + Invio invece di Invio / Invio.

Fonte: http://dotpad.blogspot.in/2014/12/notification-when-command-finished.html

Anche se altre risposte hanno già coperto la maggior parte dei modi per ottenere le notifiche su un lavoro finito, voglio dare i miei due centesimi da quando hai fatto la tua domanda nel seguente formato:

Il posto in cui lavoro ha comandi che richiedono molto tempo per essere eseguiti.

Ho lo stesso problema. A volte qualcosa può funzionare per 15 minuti.

Ho la seguente funzione nel mio .bashrc:

# push a notification to your phone. can be handy if you're running a
# build and you want to be notified when it's finished.
push() {
    curl -s -F "token=PUSHOVER_TOKEN" \
    -F "user=PUSHOVER_USER" \
    -F "title=terminal" \
    -F "message=$1" https://api.pushover.net/1/messages.json > /dev/null 2>&1
}

Questo utilizza l'app Pushover per inviare una notifica al mio telefono. In questo modo posso andare a pranzo o partecipare a una riunione e ricevere comunque una notifica sui lavori che ho iniziato sul mio computer prima di partire.

Lo uso nel modo seguente:

command_to_run && push "yes! command finished successfully!" || push "awww man! something failed :-("

Quindi, se il comando restituisce un codice di uscita corretto, verrà eseguita la prima pressione. In caso di errore, verrà eseguito il secondo.

Ofc è necessario creare un utente su Pushover e registrare un'app da cui inviare le notifiche https://pushover.net/

Spero che questo ha aiutato!

scrissi ntfy proprio per questo scopo. È piattaforme e può automaticamente invia notifiche quando terminano i comandi con esecuzione prolungata.

Se hai Python pip (la maggior parte delle distribuzioni Linux e MacOS ce l'hanno), ecco come installarlo e abilitare le notifiche automatiche:

$ sudo pip install ntfy
$ echo 'eval "$(ntfy shell-integration)"' >> ~/.bashrc
$ # restart your shell

Dai un'occhiata a http://ntfy.rtfd.io

Oltre a ciò, può anche:

• supress notifiche automatiche quando il terminale è in primo piano (X11, iTerm2 e Terminal.app supportati e abilitati di default)
• inviare notifiche basate su cloud (pushover, pushbullet e XMPP)
• essere utilizzato per inviare notifiche quando termina un processo (non il suddetto supporto automatico)
• inviare manualmente le notifiche (utile per gli script!)

Se usi csh o tcsh come shell interattiva, puoi usare notify comando:

% long-running-command &
[1] 14431
% notify %1
% 
(later, when the command finishes)
[1]    Done                          long-running-command

È possibile ottenere un effetto simile in bash con set -b o set -o notify.

Questo probabilmente non soddisfa le tue esigenze, poiché tutto ciò che fa è stampare un messaggio; Non penso che possa essere configurato per far apparire una finestra o suonare il campanello.

Sui sistemi con prova 'awk'

awk 'BEGIN{ print "\a" }'

è stato l'unico a lavorare per me.

Se stai usando npm poi node-notifier fornire un soluzione multipiattaforma .

notify -t "Agent Coulson" --icon https://raw.githubusercontent.com/mikaelbr/node-notifier/master/example/coulson.jpg -m "Well, that's new. "

Anteprima

• Linux KDE

• finestre

• Mac OS

• Ringhiare

Vorrei aver notato questo thread anni fa. La mia soluzione era essenzialmente uguale a quella di Slhck, ma ho scritto una sceneggiatura. Io lo uso per tutto il tempo. Pubblicando qui per condividerlo.

#!/bin/bash

msg='all done'
quiet=false
if [ "$1" = '-q' ]; then quiet=true; shift; fi
if [ $# -gt 0 ]; then msg="$*"; fi

echo -ne "\x1b]0;$msg\a"
if [ -x /usr/bin/zenity ]; then
  unset WINDOWID
  exec zenity --info --text="$msg"
elif [ -x /usr/bin/xmessage ]; then
  exec xmessage -nearmouse "$msg"
elif [ -x /usr/bin/osascript ]; then
  if ! $quiet; then say "done" &; fi
  osascript -e "tell application \"System Events\" to display dialog \"$msg\""
else
  echo $msg
fi

Una piccola spiegazione: la corda "\x1b]0;$msg\a" è la sequenza di escape ANSI per inserire il messaggio nella barra del titolo della finestra da cui è stato eseguito. Trovo abbastanza utile a volte essere in grado di vedere da quale finestra proviene il messaggio.

Quindi questo arriva abbastanza tardi, ma ho iniziato a usare un sistema per fare questo: Ho uno script bash che esegue qualunque comando gli venga passato in seguito

http://somesh.io/2017/02/19/get-notified-when-long-commands-are-done-executing-on-ubuntu/

#!/bin/bash


# file location : /usr/bin/n

set +e


# $@ executes whatever command is typed after the filename

$@


notify-send "Task Completed"

e poi ho semplicemente anteposto n

n bundle install
n npm install

Un'altra possibilità è usare alert, Funziona su Linux.

>any-command; alert

Fornisce una notifica come nell'immagine. notifica di avviso

Ho creato un'app che invierà una notifica al tuo telefono Android al termine di un processo in modo da non dover essere collegato al computer.

Installa, quindi aggiungi ;notifier.sh alla fine del tuo comando.

Ad esempio, se il tuo comando è stato make install, faresti il ​​tuo comando:

make install; notifier.sh

https://notifier.sh

https://play.google.com/store/apps/details?id=sh.notifier