processus de contrôle Démarré par Bash Daemon

Question

En bash, j'ai créé d'un simple démon d'exécuter des commandes lorsque mes changements de connexion Internet:

#!/bin/bash 

doService(){ 
    while 
    do 
    checkTheInternetConnection 
    sleep 15 
    done 
} 

checkTheInternetConnection(){ 
    if unchanged since last check 
     return 
    else 
     execute someCommand 
    fi 
} 

someCommand(){ 
    do something 
} 

doService 

ce qui a travaillé assez bien pour ce que je besoin de le faire.

Le seul problème est que comme une partie de ma « unecommandequelconque » et « checkTheInternetConnection » j'utiliser d'autres utilitaires intégrés comme arp, awk, grep, tête, etc.

Cependant, 99% du temps , Je vais juste besoin d'arp.

Première question: Est-il nécessaire de garder les autres commandes ouvertes? Y at-il un moyen de tuer une commande une fois que j'ai déjà traité sa sortie?

---

Une autre question: (À UN NOUVEAU PROPOSÉE POST) J'ai un enfer d'un temps à essayer d'écrire une fonction « tuer tous les autres processus de démon ». Je ne veux jamais plus d'un démon en même temps. Aucune suggestion? Voilà ce que j'ai:

otherprocess=`ps ux | awk '/BashScriptName/ && !/awk/ {print $2}'| grep -Ev $$` 

    WriteLogLine "Checking for running daemons." 

    if [ "$otherprocess" != "" ]; then 
     WriteLogLine "There are other daemons running, killing all others." 
     VAR=`echo "$otherprocess" |grep -Ev $$| sed 's/^/kill /'` 
     `$VAR` 
    else 
     WriteLogLine "There are no daemons running."  
    fi 

Answer 1

Pouvez-vous détailler plus la première question?Je pense que vous demandez à propos de l'exécution de nombreuses commandes canalisées ensemble (cat xxx | grep yyy | tail -zzz).

Chaque commande continuera à fonctionner jusqu'à ce que son tube ait des données (non atteint EOF). Donc, dans cet exemple, grep ne sortira que lorsque cat aura traité toutes les entrées et fermé son extrémité. Mais il y a une astuce ici, chat ne fermera son extrémité du tuyau que si grep a déjà tout lu (tamponné, au moins) l'entrée, parce que l'appel d'écriture dans les tuyaux sont bloquants. Donc, vous devez avoir cela à l'esprit lors de la conception de vos scripts.

Mais je ne pense pas que vous devriez vous inquiéter des utilitaires intégrés. Généralement, ils ont une empreinte mémoire faible, si cela est le problème.

Answer 2

Pour votre première question. Je ne comprends pas tout à fait, mais je peux voir que vous demandez peut-être une de deux choses.

1. Vous exécutez les choses dans une fonction bash (grep, awk, sed, etc.) et parce que cette fonction est longue marche, vous avez peur que les services publics que vous exécutez sont en quelque sorte reste ouvert.
2. Vous acheminez la sortie d'une commande à une autre et avez peur que la commande reste ouverte après son exécution.

Ni 1 ni 2 ne laisseront les commandes d'utilitaires "ouvertes" après leur exécution. Vous pouvez le prouver en mettant

ps -ef | grep "command" | grep -v 'grep' 

dans tout le code pour voir exactement ce qui fonctionne sous ce nom. ou

ps -ef | grep "$$" | grep -v 'grep' 

qui énumérera les éléments générés par le processus en cours.

MISE À JOUR:

Ainsi, il semble que vous êtes intéressé par la façon dont les choses se passent d'un tuyau. Vous pouvez le voir visuellement à l'aide de la commande suivante:

$ ls/| grep bin | grep bin | ps -ef | grep ls 
$ 

comparer avec quelque chose comme:

$ find ~ | grep bin | ps -ef | grep find 
$ 

Remarquez comment les « ls » ne sont plus dans la liste des processus, mais la découverte est. Vous devrez peut-être ajouter plus de commandes "grep bin" dans le pipeline pour obtenir l'effet. Une fois la première commande terminée, elle se ferme, même si le reste des commandes n'est pas encore terminé. Les autres commandes finiront comme elles sont finies en traitant la sortie du premier (donc la nature du tuyau)