¿Cómo puedo activar una notificación cuando finaliza un trabajo / proceso?

El lugar en el que trabajo tiene comandos que tardan mucho en ejecutarse.

¿Hay algún comando / utilidad que pueda usar para notificarme cuando finalice la ejecución del comando? Podría ser una ventana emergente o quizás un pequeño sonido.

En general, si sabe esto antes de ejecutar el comando, puede comenzarlo con:

command; command-after &

Esto ejecutará command-after después de que el comando anterior haya salido (independientemente de su código de salida). La &iniciará en segundo plano.

Si le importa una salida exitosa o fallida, use respectivamente:

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

Si el comando ya se ha iniciado, puede usar el control de trabajo para suspenderlo y luego devolverlo al primer plano fgcon su notificación encadenada:

command
# enter Ctrl-z
fg ; command-after

Ahora ... lo que quieras hacer después de esto depende de tu entorno.

• En cualquier sistema , puede "tocar" el timbre del terminal . Depende de su sistema exacto lo que realmente funciona (BSD vs. GNU Linux, etc.), pero tput beldebería hacerlo. Sin embargo, no podría probarlo de manera confiable en este momento. Busque "campana de llamada" para obtener más información.

• En Mac OS X , puede usar AppleScript para abrir un cuadro de diálogo del Finder:

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

  Podrías hacer que te dijera algo:

  say "Job finished"
  

  O puede usar el sistema de notificación de Mountain Lion:

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

• En GNOME , zenitypuede mostrar un cuadro de diálogo GTK, llamado desde la línea de comando. Véase también esta pregunta desbordamiento de pila: muestra un cuadro de mensaje de un script bash en Linux . Se puede instalar a través de su administrador de paquetes favorito.

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

• Algunas distribuciones pueden tener xmessage. Específicamente para entornos GTK, los hay gxmessage.

• En entornos de escritorio que implementan la Especificación de notificaciones de escritorio , como Ubuntu y GNOME , hay un sistema de notificación con el que puede activar notify-send(parte de libnotify).

  notify-send "Job finished!"
  

• KDE usa kdialog, por ejemplo:

  kdialog --passivepopup 'Job finished'
  

En sistemas similares a Unix, puede tocar el timbre audible:

echo -e "\a"

Creé una herramienta simple, para MacOS X, que hace exactamente esto. https://github.com/vikfroberg/brb

Instalación

$ npm install -g brb

Instrucciones

$ sleep 3; brb

Para obtener una notificación de sonido que puede usar spd-say "Some text". Ejemplo:

some-command; spd-say "Yo"

Acabo de comenzar a usar notifu para las notificaciones de escritorio de Cygwin. Es una aplicación de notificación de línea de comandos para Windows.

Ejemplo:

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

Escribí ntfyexactamente para este propósito. Es multiplataforma y puede enviar notificaciones automáticamente cuando finalizan los comandos de ejecución larga.

Si tiene Python pip(la mayoría de las distribuciones de Linux y MacOS lo tienen), aquí le mostramos cómo instalarlo y habilitar las notificaciones automáticas:

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

Compruébalo en http://ntfy.rtfd.io

Además de eso, también puede:

• suprima las notificaciones automáticas cuando el terminal está en primer plano (X11, iTerm2 y Terminal.app son compatibles y están habilitados de forma predeterminada)
• enviar notificaciones basadas en la nube (Pushover, Pushbullet y XMPP)
• se utilizará para enviar notificaciones cuando finalice un proceso (no el soporte automático mencionado anteriormente)
• Enviar notificaciones manualmente (¡bueno para usar en scripts!)

Para Linux, hay un ingenioso truco para hacer esto automáticamente sin tener que escribir un comando de notificación cada vez.

Primero instale autokey. Esto ayuda a definir acciones para diferentes pulsaciones de teclas.

sudo apt-get install autokey-gtk

Ahora, defina una nueva frase en autokey y asigne la tecla de acceso rápido como Alt + Enter. Agrega esta frase:

; notify-send "Job finished!" &
  #

Tenga en cuenta que una nueva línea después de la primera línea es importante.

Además, agregue un filtro de ventana. Yo uso guake y terminal. Incluya cualquier otra terminal que use.

.*(guake)|(Terminal).*

¡Ya terminaste!

Ahora, cada vez que necesite recibir notificaciones para un comando, ejecútelo usando Alt + Enter en lugar de Enter / Return.

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

Aunque otras respuestas ya cubrieron la mayoría de las formas de recibir notificaciones sobre un trabajo terminado, quiero dar mis dos centavos ya que usted hizo su pregunta en el siguiente formato:

El lugar en el que trabajo tiene comandos que tardan mucho en ejecutarse.

Tengo el mismo problema. A veces algo puede funcionar durante 15 minutos.

Tengo la siguiente función en mi .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
}

Esto usa la aplicación Pushover para enviar una notificación a mi teléfono. De esta manera puedo ir a almorzar o ingresar a una reunión y aún así recibir notificaciones sobre los trabajos que comencé en mi computadora antes de irme.

Lo uso de la siguiente manera:

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

Entonces, si el comando devuelve un código de salida correcto, se ejecutará la primera inserción. En caso de error, se ejecutará el segundo.

Ofc necesita crear un usuario en Pushover y registrar una aplicación para enviar notificaciones desde https://pushover.net/

Espero que esto haya ayudado!

Si usa csh o tcsh como su shell interactivo, puede usar el notifycomando:

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

Puede lograr un efecto similar en bash con set -bo set -o notify.

Esto probablemente no cumpla con sus requisitos, ya que todo lo que hace es imprimir un mensaje; No creo que se pueda configurar para abrir una ventana o tocar el timbre.

En sistemas con prueba 'awk'

awk 'BEGIN{ print "\a" }'

fue el único que trabajó para mí.

Si está utilizando npm, el nodo-notificador proporciona una solución multiplataforma .

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

Avance

• Linux KDE

• Ventanas

• Mac OS

• Gruñido

Ojalá hubiera notado este hilo hace años. Mi solución era esencialmente la misma que la de slhck, pero escribí un script. Lo uso todo el tiempo. Publicando aquí para compartirlo.

#!/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 pequeña explicación: la cadena "\x1b]0;$msg\a"es la secuencia de escape ANSI para colocar el mensaje en la barra de título de la ventana desde la que se ejecutó. A veces me resulta bastante útil poder ver de qué ventana proviene el mensaje.

Esto llega bastante tarde, pero comencé a usar un sistema para hacer esto: tengo un script bash que ejecuta cualquier comando que se le pase después

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"

y luego simplemente antepongo n

n bundle install
n npm install

Otra posibilidad es usar alert, Works on Linux.

>any-command; alert

Da una notificación como en la imagen. notificación de alerta

Hice una aplicación que enviará una notificación a su teléfono Android cuando finalice un proceso para que no tenga que estar atado a su computadora.

Instale, luego agregue ;notifier.shal final de su comando.

Por ejemplo, si su comando fuera make install, haría su comando:

make install; notifier.sh

https://notifier.sh

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