Como posso acionar uma notificação quando um trabalho / processo termina?

O local em que trabalho possui comandos que levam muito tempo para serem executados.

Existe um comando / utilitário que eu possa usar para me notificar quando a execução do comando terminar? Pode ser uma janela pop-up ou talvez um pouco de som.

Geralmente, se você sabe disso antes de executar o comando, basta iniciá-lo com:

command; command-after &

Isso executará command-after após a saída do comando anterior (independentemente do seu código de saída). O &iniciará em segundo plano.

Se você se preocupa com uma saída bem-sucedida ou com falha, use respectivamente:

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

Se o comando já foi iniciado, você pode usar o controle de tarefas para suspendê-lo, retorne-o ao primeiro plano com o fgacorrentado com sua notificação:

command
# enter Ctrl-z
fg ; command-after

Agora ... o que você quer fazer depois disso depende do seu ambiente.

• Em qualquer sistema , você pode "tocar" a campainha do terminal . Depende do seu sistema exato, o que realmente funciona (BSD vs. GNU Linux, etc.), mas tput beldeve funcionar. Eu não poderia testá-lo com confiabilidade no momento, no entanto. Pesquise "campainha" para descobrir mais.

• No Mac OS X , você pode usar o AppleScript para abrir uma caixa de diálogo do Finder:

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

  Você poderia dizer algo para você:

  say "Job finished"
  

  Ou você pode usar o sistema de notificação do Mountain Lion:

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

• No GNOME , zenitypode mostrar uma caixa de diálogo GTK, chamada na linha de comando. Veja também esta questão do Stack Overflow: mostrando uma caixa de mensagem de um script bash no linux . Pode ser instalado através do seu gerenciador de pacotes favorito.

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

• Algumas distribuições podem ter xmessage. Especificamente para ambientes GTK, existe gxmessage.

• Em ambientes de desktop que implementam a Especificação de notificações da área de trabalho , como Ubuntu e GNOME , existe um sistema de notificação que você pode acionar notify-send(parte de libnotify).

  notify-send "Job finished!"
  

• O KDE usa kdialog, por exemplo:

  kdialog --passivepopup 'Job finished'
  

Em sistemas tipo Unix, você pode tocar a campainha audível:

echo -e "\a"

Criei uma ferramenta simples, para o MacOS X, que faz exatamente isso. https://github.com/vikfroberg/brb

Instalação

$ npm install -g brb

Instruções

$ sleep 3; brb

Para obter uma notificação sonora, você pode usar spd-say "Some text". Exemplo:

some-command; spd-say "Yo"

Comecei a usar o notifu para notificações da Cygwin na área de trabalho. É um aplicativo de notificação de linha de comando para Windows.

Exemplo:

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

Eu escrevi ntfyexatamente para esse fim. É multiplataforma e pode enviar notificações automaticamente quando os comandos de execução longa terminam.

Se você possui o Python pip(a maioria das distribuições Linux e MacOS possui), veja como instalá-lo e ativar as notificações automáticas:

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

Confira em http://ntfy.rtfd.io

Além disso, também pode:

• suprimir notificações automáticas quando o terminal estiver em primeiro plano (X11, iTerm2 e Terminal.app suportado e ativado por padrão)
• enviar notificações baseadas na nuvem (Pushover, Pushbullet e XMPP)
• ser usado para enviar notificações quando um processo terminar (não o suporte automático mencionado acima)
• enviar notificações manualmente (bom para uso em scripts!)

Para o Linux, há um truque bacana para fazer isso automaticamente, sem a necessidade de digitar um comando para notificação sempre.

Primeiro instale o autokey. Isso ajuda a definir ações para diferentes pressionamentos de tecla.

sudo apt-get install autokey-gtk

Agora, defina uma nova frase na tecla automática e atribua a tecla de atalho como Alt + Enter. Adicione esta frase:

; notify-send "Job finished!" &
  #

Observe que uma nova linha após a primeira é importante.

Além disso, adicione um filtro de janela. Eu uso guake e terminal. Inclua qualquer outro terminal que você use.

.*(guake)|(Terminal).*

Você Terminou!!

Agora, sempre que precisar receber notificações para um comando, execute-o usando Alt + Enter em vez de Enter / Return.

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

Embora outras respostas já abranjam a maioria das maneiras de obter notificações de um trabalho concluído, quero dar meus dois centavos desde que você fez sua pergunta no seguinte formato:

O local em que trabalho possui comandos que levam muito tempo para serem executados.

Eu tenho o mesmo problema. Às vezes, algo pode durar 15 minutos.

Eu tenho a seguinte função no meu .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
}

Isso usa o aplicativo Pushover para enviar uma notificação para o meu telefone. Dessa forma, posso almoçar ou entrar em uma reunião e ainda ser notificado sobre os trabalhos que iniciei no computador antes de sair.

Eu o uso da seguinte maneira:

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

Portanto, se o comando retornar um código de saída correto, o primeiro push será executado. Em caso de erro, o segundo será executado.

Ofc, você precisa criar um usuário no Pushover e registrar um aplicativo para enviar notificações em https://pushover.net/

espero que isso tenha ajudado!

Se você usar csh ou tcsh como seu shell interativo, poderá usar o notifycomando:

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

Você pode obter um efeito semelhante ao bash com set -bou set -o notify.

Provavelmente isso não atende aos seus requisitos, pois tudo o que faz é imprimir uma mensagem; Acho que não pode ser configurado para abrir uma janela ou tocar a campainha.

Em sistemas com tentativa 'awk'

awk 'BEGIN{ print "\a" }'

foi o único a trabalhar para mim.

Se você estiver usando npm, o node-notifier fornece uma solução de plataforma cruzada .

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

Pré-visualização

• Linux KDE

• janelas

• Mac OS

• Rosnar

Gostaria de ter notado essa discussão anos atrás. Minha solução era essencialmente a mesma que a do slhck, mas escrevi um script. Eu uso isso o tempo todo. Postando aqui para compartilhá-lo.

#!/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

Uma pequena explicação: a sequência "\x1b]0;$msg\a"é a sequência de escape ANSI para colocar a mensagem na barra de título da janela da qual foi executada. Às vezes, acho bastante útil ver de qual janela foi a origem da mensagem.

Portanto, isso é bastante tarde, mas comecei a usar um sistema para fazer isso: Eu tenho um script bash que executa qualquer comando que for passado posteriormente a ele

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 então eu simplesmente prefixo n

n bundle install
n npm install

Outra possibilidade é usar o alertWorks on Linux.

>any-command; alert

Dá uma notificação como na imagem. notificação de alerta

Eu criei um aplicativo que enviará uma notificação para o seu telefone Android quando um processo terminar, para que você não precise estar conectado ao seu computador.

Instale e adicione ;notifier.shao final do seu comando.

Por exemplo, se o seu comando fosse make install, você faria o seu comando:

make install; notifier.sh

https://notifier.sh

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