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 le netcat se termine, la queue est laissée derrière. (Précision: si je n'utilise 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 queue?
Écrivez 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)
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 dis-tu de ça:
jobs -x echo %1
%1
est pour le premier travail de la chaîne, %2
pour le second, etc. jobs -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 ne fonctionnerait pas si un utilisateur pouvait exécuter le script pour deux "instances" sur le même ordinateur.
jobs -x echo %1
n'a pas fonctionné pour moi (la page de manuel n'ayant pas l'indicateur -x
) mais m'a donné l'idée d'essayer jobs -p
.
Vous pourriez peut-être utiliser un fifo pour pouvoir 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
ncat
termine 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
Enfin, j'ai réussi à trouver le processus final en utilisant ps
. Merci à l'idée de l'ennuikiller.
J'ai utilisé le ps
pour grep queue des arguments et le tuer. C'est un peu un bidouillage mais ça a fonctionné. :)
Si vous pouvez trouver un meilleur moyen s'il vous plaît partager.
Voici le script complet:
(La dernière version peut être trouvée ici: http://docs.karamatli.com/dotfiles/bin/logserver )
if [ -z "$1" ]; then
echo Usage: $0 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
Vous pouvez stocker le pid de la commande tail
dans une variable en 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
As-tu essayé:
nc -l -p 9977 -c "tail -f $1"
(non testé)
Ou -e
avec un fichier de script si votre nc
n'a pas -c
. Vous devrez peut-être avoir une nc
qui a été compilée avec l'option GAPING_SECURITY_HOLE
. Oui, vous devez déduire les mises en garde appropriées à partir de ce nom d'option.
Une solution serait simplement de faire un ps -ef et grep for tail avec votre script ppid
Pas une réponse idéale, mais j'ai trouvé une solution de contournement pour un démon enregistreur 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
Vous pouvez utiliser la commande coproc
deux fois.
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 echo
pour le dépannage.)
Utiliser coproc
ressemble beaucoup à utiliser Popen () dans divers autres langages de script.
L'option --pid to tail est votre meilleur ami ici. Cela vous permettra un contrôle total du pipeline 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, démontre la restriction "imposée" de la queue et la possibilité de lui dire de quitter à 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