Comment obtenir le PID d'un processus relié à un autre processus dans Bash?
https://stackoverflow.com/questions/1652680
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
J'essaie d'implémenter un serveur de journalisation simple dans Bash. Il devrait prendre un fichier en paramètre et le servir sur un port avec netcat.
( tail -f $1 & ) | nc -l -p 9977
Mais le problème est que lorsque Netcat se termine, la queue est laissée derrière. (Précision: si je ne lance pas le processus final, il continuera à fonctionner indéfiniment même le netcat se termine.)
Si je connais le PID de la queue, je pourrais le tuer après.
Évidemment, en utilisant $! renverra le PID de netcat.
Comment puis-je obtenir le PID du processus de traitement final?
La solution
Ecrivez le PID de tail dans le descripteur de fichier 3, puis capturez-le à partir de là.
( tail -f $1 & echo $! >&3 ) 3>pid | nc -l -p 9977
kill $(<pid)
Autres conseils
Une autre option: utiliser une redirection vers un sous-shell. Cela change l'ordre dans lequel les processus en arrière-plan sont démarrés, donc $! donne le PID du processus tail .
tail -f $1 > >(nc -l -p 9977) &
wait $!
que diriez-vous de cela:
jobs -x echo %1
% 1 correspond au premier travail de la chaîne, % 2 au second, etc. travaux -x remplace le spécificateur de travail par PID.
Cela fonctionne pour moi (SLES Linux):
tail -F xxxx | tee -a yyyy &
export TAIL_PID=`jobs -p`
# export TEE_PID="$!"
L'astuce ps | grep | kill mentionnée dans ce fil de discussion ne fonctionnerait pas si un utilisateur pouvait exécuter le script pour deux "instances". sur la même machine.
travaux -x echo% 1 ne fonctionnait pas pour moi (la page de manuel ne comportant pas l'indicateur -x ) mais m'a donné l'idée d'essayer travaux - p .
Peut-être pourriez-vous utiliser un fifo pour capturer le pid du premier processus , par exemple:
FIFO=my_fifo
rm -f $FIFO
mkfifo $FIFO
tail -f $1 > $FIFO &
TAIL_PID=$!
cat $FIFO | nc -l -p 9977
kill $TAIL_PID
rm -f $FIFO
Enfin, j'ai réussi à trouver le processus final avec ps . Merci à l'idée de l'ennuikiller.
J'ai utilisé le ps pour mettre fin à l'argument et le tuer. C'est un peu un bidouillage mais ça a fonctionné. :)
Si vous pouvez trouver un meilleur moyen, partagez-le.
Voici le script complet:
(La dernière version peut être trouvée ici: http://docs.karamatli.com/dotfiles/bin/ serveur de journaux )
if [ -z "$1" ]; then
echo Usage: <*> LOGFILE [PORT]
exit -1
fi
if [ -n "$2" ]; then
PORT=$2
else
PORT=9977
fi
TAIL_CMD="tail -f $1"
function kill_tail {
# find and kill the tail process that is detached from the current process
TAIL_PID=$(/bin/ps -eo pid,args | grep "$TAIL_CMD" | grep -v grep | awk '{ print $1 }')
kill $TAIL_PID
}
trap "kill_tail; exit 0" SIGINT SIGTERM
while true; do
( $TAIL_CMD & ) | nc -l -p $PORT -vvv
kill_tail
done
ncat ferme automatiquement tail -f à la sortie (sous Mac OS X 10.6.7)!
# simple log server in Bash using ncat
# cf. http://nmap.org/ncat/
touch file.log
ncat -l 9977 -c "tail -f file.log" </dev/null # terminal window 1
ncat localhost 9977 </dev/null # terminal window 2
echo hello > file.log # terminal window 3
Une solution serait simplement de faire un ps -ef et un grep pour tail avec votre script ppid
Avez-vous essayé:
nc -l -p 9977 -c "tail -f $1"
(non testé)
Ou -e avec un fichier de script si votre nc ne contient pas -c . Vous devrez peut-être disposer d'un nc qui a été compilé avec l'option GAPING_SECURITY_HOLE . Oui, vous devez déduire les mises en garde appropriées à partir de ce nom d'option.
Vous pouvez stocker le pid de la commande tail dans une variable utilisant uniquement les redirections Bash I / O (voir Comment obtenir le PID d'un processus dans un pipeline ).
# terminal window 1
# using nc on Mac OS X (FreeBSD nc)
: > /tmp/foo
PID=$( { { tail -f /tmp/foo 0<&4 & echo $! >&3 ; } 4<&0 | { nc -l 9977 ;} & } 3>&1 | head -1 )
kill $PID
# terminal window 2
nc localhost 9977
# terminal window 3
echo line > /tmp/foo
Ce n’est pas une réponse idéale, mais j’ai trouvé une solution de contournement pour un démon de journalisation sur lequel j'ai travaillé:
#!/bin/sh
tail -f /etc/service/rt4/log/main/current --pid=$ | grep error
à partir de $ info tail:
--pid=PID
with -f, terminate after process ID, PID dies
L'option --pid de queue est votre meilleur ami ici. Cela vous permettra un contrôle total du pipeline fonctionnant en arrière-plan. lisez les options de la commande tail pour plus de résilience dans le cas où votre fichier est soumis à une rotation active par un autre processus, ce qui pourrait vous laisser terminer un inode inactif. L’exemple ci-dessous, même s’il n’est pas utilisé pour traiter les données, illustre le comportement "imposé". restriction sur la queue et la possibilité de lui dire de sortir à tout moment. Ceci est utilisé pour mesurer la pression de service sur httpd.
# Set the tail to die in 100 second even if we die unexpectedlly.
sleep 100 & ; ctlpid=$!
tail -q -n 0 --follow=name --retry --max-unchanged-stats=1 --pid=$ctlpid -f /var/log/httpd/access_log 2>/dev/null | wc –l > /tmp/thisSampleRate &
…. Do some other work
…. Can kill the pipe at any time by killing $ctlpid
…. Calculate preassure if /tmp/thisSampleRate is ready
Vous pouvez utiliser la commande coproc à deux reprises.
L'exemple donné se traduit par:
coproc TAIL { tail -f $1; }; exec {TAIL[1]}<&-
coproc NC { nc -v -l -p 9977; } <&"${TAIL[0]}" >&1
wait $NC_PID; echo "nc exit code: $!"
kill $TAIL_PID; echo "done"
(J'ai jeté un -v et un couple de echo pour le dépannage.)
Utiliser coproc ressemble beaucoup à utiliser Popen () dans divers autres langages de script.
