bash de bip à la commande prend de 1 minute pour terminer

Je suis à la recherche de mon bash pour bip, si la commande que j'execute prendre plus de
plus d'un certain mur de temps ( disons 1 minute ).

si elle garde des bips toutes les quelques minutes après jusqu'à ce que je la touche entrée
ou quelque chose .. c'est greate.

Toutes les idées intelligentes ?

Je peux utiliser l'écran du moniteur de la fonction en tant que dernier recours.
(Je suis sur cygwin, mais qui ne devrait pas d'importance ).

Permettez-moi de préciser:

 $ ls    
   < output appears >   
 $ rsync foo bar 
   < since this takes lot of time, i switch to other console
      and forget this .. .and remember only after some time >
    < so when this finished, i want it to beep >

j'espère que le script fourni est ce que vous avez besoin

OriginalL'auteur |

bash exec

3

Une humble suggestion: Si vous avez une commande qui va prendre un certain temps, il suffit de suivre la commande par un point-virgule, puis un bip.
```
rsync foo bar; beep
```
OriginalL'auteur
2

Il y a des commandes Linux qui émettra un bip pour vous. Découvrez le code source de bip disponible avec Ubuntu (et probablement d'autres distributions) ou avoir un coup d'oeil à http://www.johnath.com/beep/beep.c pour une autre source (c'est le même code, je crois).

Il permet de contrôler la fréquence, la durée et les répétitions (entre autres choses) avec facilité.

De la faire travailler, vous aurez besoin d'un script qui démarre votre travailleur programme en arrière-plan, puis s'en va dans un "sleep 60" boucle, des bips jusqu'à la fin.

Le script suivant doit être un bon début. Vous l'exécutez avec quelque chose comme:
```
beeper sleep 3600
```
et qu'il exécute la sleep 3600 en arrière-plan, des bips toutes les minutes jusqu'à la fin.
```
#!/bin/bash
$* &
pid=$!
oldmin=$(date +%M)
exf=$pid
while [[ $exf == $pid ]] ; do
    min=$(date +%M)
    if [[ $oldmin != $min ]] ; then
        beep
        oldmin=$min
    fi
    exf="$(ps -ef | awk '{print $2}' | grep $pid)"
    sleep 2
done
```
C'est la façon dont il fonctionne. Il exécute les arguments comme un processus d'arrière-plan et enregistre l'ID de processus. Puis il fait une boucle pour chaque couple de secondes, la vérification lors de les changements de dernière minute et les bips quand c'est le cas (le premier bip ici peuvent aller jusqu'à une minute).

La sortie de la boucle se produit lorsque le processus disparaît à partir de la sortie de ps.

Vous pouvez même le faire beeper sommeil 3600 & mettre le tout dans le fond. Pour arrêter le signal sonore, soit tuer le signal sonore (si vous voulez que le travail à poursuivre sans bip) ou de tuer des processus de travail lui-même (qui va s'arrêter à la fois le travail et le bip).

1. $*? Wordsplitting et chemin d'accès de l'extension de manger vos bébés. 2. ps pour vérifier si un PID est encore en vie? Nonono, l'homme de tuer, de lire à propos de tuer -0. 3. Alambiqué?
C'est pourquoi j'ai dit que le scénario était un début (je n'ai pas d'ajouter d'autres fonctionnalités comme un message d'aide ou d'erreur vérifie si la commande est lancée). Le ps fonctionne bien, donc il n'y a pas besoin de le changer, en dépit d'autres fonctionnalités disponibles (j'avoue que je ne connaissais pas le "tuer -0', c'est agréable).

OriginalL'auteur paxdiablo
0

Je suis sûr que j'ai utilisé quelque chose comme:
```
echo "echo "echo "\007"
7"
7"
```
n'ont pas un *nix shell pratique pour tester.

echo -e "\007" fonctionne pour moi sur linux/bsd

OriginalL'auteur ninesided

echo "echo "echo "\007"
7"
7"

bips pour moi.

$!
retourne le pid du dernier processus a couru dans le fond de bash, donc vous pouvez dormir sur elle et de vérifier si elle est toujours en cours.

Pour être plus clair, capture de pid à l'aide de $! et dormir dans la boucle sans fin et de vérifier si pid ci-dessus est encore en vie.

Après (j'espère) que la compréhension de ce que vous souhaitez, voici le code:

#! /bin/bash

if [[ "$#" != "1" ]]
then
  echo "Usage: $0 <command>"
  echo "Will wait till the command finishes and starts beeping once a minute"
  exit 1
fi

CMD="$1"
SECS_BETWEEN_BEEPS="60"

# echo commmand and start time:
echo "@@ Command: '${CMD}'"
echo "@@ Starting at `date`"

# execute and wait till finish:
"${CMD}"
wait

# echo finish time:
echo "@@ Finished at `date`"

# beep once in SECS_BETWEEN_BEEPS:
while ((1))
do
  echo -en '\a'
  sleep "${SECS_BETWEEN_BEEPS}"
done

OriginalL'auteur Drakosha

0

J'aime la réponse fournie par Pax. Jetez un oeil à ce que "beep" peut faire:
```
root@tower:/usr/src/linux # beep --help
```
Utilisation: bip [-f freq] [-l longueur] [-r
reps] [-d delay] [-D delay] [-s] [-c]
[-e de l'appareil]

bip [Options...] [-n] [- nouvelles]
[Options...] ... bip [-h] [--help]
bip [-v] [-V] [--version]

Donc, vous pouvez le faire osciller les bips (en les rendant plus fort, plus long, ou les deux) que le programme continue de s'exécuter plus de temps que prévu.

Si vous travaillez à lui, vous pouvez avoir le script de jouer MUSAC versions préféré de tous les 80's hits, qui va sûrement attirer quelqu'un à la borne, si pour aucune autre raison que de faire ce qu'il arrête.

OriginalL'auteur
-1

Je ne sais pas désinvolte, si ça marche sur le coup, mais avec de nombreuses coquilles quelque chose comme
```
command && echo ^G
```
(ctrl-g) émet un bip après l'achèvement de la commande. C'est souvent utile lorsque vous voulez exécuter une commande et ensuite aller travailler dans une autre fenêtre, mais être averti lors de la première chose de fini. (Je suis pas clair si c'est votre but ou pas.)

OriginalL'auteur Brian
-2

Vous demandons deux choses totalement différentes ici. D'abord vous vous demandez quoi faire pour obtenir de bips après une minute, puis vous demandez à obtenir de bips après la commande est terminée. Ce sont deux choses qui sont approchés d'entièrement différent.
```
# bof [command] [args...] - Beep on Finish
bof() {
    "$@"; local r=$?

    printf '\a'
    return $r
}
```
Cette fonction exécute une commande et ensuite bips un temps une fois que la commande est fait, tout en s'assurant que le code de sortie de la commande est le code de sortie de la fonction.
```
# bot [command] [args...] - Beep on Timeout
bot() {
    { sleep 60; printf '\a'; } &

    "$@"; local r=$?

    kill $!
    return $r
}
```
Cette fonction émet un bip après un certain temps, à moins que la commande s'est terminée avant ce moment (ici, 60 secondes, une minute).
```
# bem [command] [args...] - Beep every Minute
bem() {
    { while sleep 60; do printf '\a'; done; } &

    "$@"; local r=$?

    kill $!
    return $r
}
```
C'est une simple adaptation de la fonction la plus ancienne qui bips chaque minutes le temps que votre commande est toujours en vie.
```
# bofem [command] [args...] - Beep on Finish every Minute
bofem() {
    "$@"; local r=$?

    until read -t 60 -n 1; do printf '\a'; done
    return $r
}
```
Et enfin, une fonction qui retentit chaque minutes, mais seulement après la commande est terminée. Sonne sans arrêt jusqu'à ce que vous appuyez sur une touche pour l'arrêter. Ensuite, la fonction retourne le code de sortie de votre commande.

Je pense que vais couvrir toutes les bases que vous pourriez avoir avec votre question.

Utiliser (et de les combiner):
```
bof rsync foo bar:      # Beep when rsync finishes.
bot ssh foo 'ls bar/'   # Beep if the 'ssh' process takes too long to run.
```
OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.