Comment puis-je arrêter la queue de commande dans le script

Ce que je veux faire - Commencer à capturer les CHANGEMENTS dans un fichier journal à l'aide d'un custom client ssh code***. Après un certain temps (pas une valeur fixe et est basée sur les événements), d'une commande pour arrêter la filature. C'est la commande que j'utilise pour capturer les dernières modifications apportées à un fichier journal - tail -f logfile.txt

Je veux être en mesure d'en finir avec quelque chose comme :q qui je puisse émettre à partir d'un script. Je ne veux pas de clavier des commandes comme ctrl + c.

*** Pseudo-code pour mon custom client ssh code (écrit dans un langage de programmation orientée objet)

include ssh-api
ssh = getSSHConnection();
cmd = 'cd to folder';
ssh.command(cmd);
cmd = 'tail -f log.txt';
ssh.command(cmd);
wait for special event to occur...
cmd = 'stop the tail now!'
out = ssh.command(cmd);
print "the changes made to log file were\n"  + out;

Je n'ai pas d'accès en écriture pour le serveur sur lequel le fichier journal se trouve.

Ce que j'ai essayé - http://www.linuxquestions.org/questions/red-hat-31/how-to-stop-tail-f-in-scipt-529419/

Je ne suis pas en mesure de comprendre la solution y (post 2). Quelqu'un peut-il expliquer la solution ou suggérer une autre façon de le faire?

Merci.

Si il y avait un moyen pour envoyer la combinaison de touches Ctrl+C à partir de votre client ssh, serait-ce pour vous?
sûrement. qui fonctionne pas trop. Tout ce que je veux faire est de dire unix à la queue d'un fichier, d'arrêter de sombrer quand je veux, et me faire la sortie entre début et de fin de la filature. Merci.
Quand vous dites que vous obtenez la sortie entre le début et la fin de la queue que tu veux dire dans un fichier ?
Une fois le bounty expire, ce devrait être fermé comme un doublon. C'est une FAQ et vous pouvez facilement avoir trouvé la réponse sur google.
double possible de stackoverflow.com/questions/2041437/...

OriginalL'auteur Borat Sagdiyev | 2015-02-19

  1. 18

    À l'intérieur de votre script, vous pouvez faire usage de $! variable.

    # run tail -f in background
tail -f /var/log/sample.log > out 2>&1 &

# process id of tail command
tailpid=$!

# wait for sometime
sleep 10

# now kill the tail process
kill $tailpid

    $! Se développe pour l'ID de processus les plus récemment exécuté en arrière-plan (asynchrone) de commande.

    Merci. En fait, je suis l'émission "queue de début" et "fin" des commandes à partir d'un autre code qui ouvre une session. En d'autres termes, le sommeil n'est pas une valeur fixe. Votre approche du travail ici?
    tail -f /var/log/sample.log > out 2>&1 & résultats dans bash: Permission denied. Même sudo tail-f....n'aide pas.
    &1 n'est pas un fichier, mais la référence au descripteur de fichier=1 qui est sortie standard (stdout). Vous pouvez avoir besoin de lire quelques-uns tutoriel de base sur la redirection dans unix. Si vous voulez le garder dans un fichier, puis utilisez tail -f /var/log/sample.log > /tmp/file.out 2>&1 & en Supposant que vous disposez des autorisations d'écriture dans /tmp/file.out
    Voici un tutoriel sur Unix redirection
    Permettez-moi de reformuler ce que. Idéalement, je veux mon code pour obtenir la sortie de la console, à la manière de mastic, c'est vivre. Actuellement, je viens de mettre la queue de sortie dans le dossier tmp, puis de les récupérer à partir de là. L'espoir qui fait sens. Je vous remercie.

    OriginalL'auteur anubhava

  2. 3

    Certains des moyens que j'utilise pour contourner tail -f, à l'aide de bash.

    D'attente pour certains incomming:

    Je l'utiliser souvent:

    sed -une '
    /DHCPOFFER/{
        s/^\(.*\) [^ ]\+ dhcpd: DHCPOFFER on \([0-9.]\+\) to \([0-9a-f:]\+\) .*$/  -> /p;
        q;
    }' < <(
      tail -f /var/log/syslog
    )

    Avec cette commande, j'ai pu attendre pour le prochain client dhcp et le temps de l'événement, l'adresse mac et offert IP.

    Dans un script:

    #!/bin/bash

read rMac rIp rDate < <(
  sed -une '
    /DHCPOFFER/{
      s/^\(.*\) [^ ]\+ dhcpd: DHCPOFFER on \([0-9.]\+\) to \([0-9a-f:]\+\) .*$/  /p;
      q;
    }' < <(
      tail -n0 -f /var/log/syslog
))

printf "Date:\t%s\nMac:\t%s\nIP:\t%s\n" "$rDate" $rMac $rIp

    Pour avoir un script à distance arrêté:

    La fifo façon:

    mkfifo /tmp/holder
tail -f /var/log/syslog &
TailPid=$!
cat >/dev/null /tmp/holder
kill -9 $TailPid

    ... Puis d'ailleurs:

    echo >/tmp/holder

    mettra fin à la queue de commande.

    La lockpid façon

    #!/bin/bash

[ -e /tmp/lockfile ] && exit
echo $$ >/tmp/lockfile
[ $(</tmp/lockfile) -ne $$ ] && exit
cd /var/log
tail -f syslog &
export tPid=$!
trap "kill $tPid;rm /tmp/lockfile;exit 0" 12
wait $tPid

    Puis, d'ailleurs:

    kill -USR2 $(</tmp/lockfile)

    Via SSH

    La deuxième méthode de travail fine à travers ssh:

    ssh -T root@remoteMachine /bin/bash <<"eocmd"
    [ -e /tmp/lockfile ] && exit
    echo $$ >/tmp/lockfile
    [ $(</tmp/lockfile) -ne $$ ] && exit
    cd /var/log
    tail -f syslog &
    export tPid=$!
    trap "kill $tPid;rm /tmp/lockfile;exit 0" 12
    wait $tPid
eocmd

    (soins à propos des guillemets doubles autour de script en ligne de la balise)

    Puis, d'ailleurs:

    ssh root@remoteMachine '/bin/bash -c "kill -USR2 $(</tmp/lockfile)"'

    (soins sur devis et devis double, dans cet ordre)

    Nota à propos de considération de la sécurité des: Ce n'est pas prendre soin sur les questions de sécurité! Avoir ce genre de lockfile situé dans /tmp pourrait être une mauvaise idée...

    OriginalL'auteur F. Hauri

  3. 2

    Vous pouvez exécuter la queue dans l'arrière-plan tout en réorientant sa sortie à un autre fichier (par exemple,/tmp/mylog) et d'écrire le pid du processus, quelque part dans un fichier pid (par exemple ~/mytail.pid):

    tail -f logfile > /tmp/mylog & echo $! > ~/mytail.pid

    Ensuite, lorsque vous voulez l'arrêter, exécutez simplement:

    kill `cat ~/mytail.pid`

    Ensuite, vous pouvez voir le contenu du journal que vous avez recueillies dans l'intervalle (c'est aussi une bonne idée de le supprimer plus tard):

    cat /tmp/mylog
rm /tmp/mylog # just don't forget it there

    OriginalL'auteur lp_

  4. 1

    Le post #2 à laquelle vous faites allusion est le suivant:a la bonne réponse.

    Il dit:

    tail -f /etc/httpd/logs/access_log & # This starts tailing the file in background (see & at the end)
kill `ps | grep tail | awk '{print $1;}'` # This finds the process running above tail command and kills it

    Vous pouvez introduire sleep 100 ou quelque chose en fonction de votre besoin, sinon, les deux ci-dessus commande entraînera des résidus juste pour une fraction de temps avant de le tuer.

    Puis-je émettre ces commandes manuellement, l'un après l'autre pour les tests?
    Oui, mais il vous sera difficile de le faire - parce que la première commande va continuer à la queue du fichier sur votre écran. Vous aurez à copier coller la deuxième ligne sur le terminal et appuyez sur ENTRÉE. Si vous le faites à droite, la filature de sortie sur l'écran doit s'arrêter.
    Ce n'est pas une bonne solution, il va essayer de tuer tous queue processus que l'utilisateur a l'autorisation de le tuer... ou, en fait, d'un processus qui a "queue" n'importe où dans son nom!
    Il n'est pas. J'essayais juste d'expliquer la "solution" trouvée par les OP. Édité ma réponse à préciser que.

    OriginalL'auteur Gaurav

  5. 1

    En fonction de votre commentaire @psmears, vous pouvez utiliser CTRL+C

    @psmears - sûrement. qui fonctionne pas trop. Tout ce que je veux faire est de dire unix à la queue d'un fichier, d'arrêter de sombrer quand je veux, et me faire la sortie entre début et de fin de la filature. Merci. – Borat Sagdiyev 2 jours il ya

    De sorte que vous pouvez simplement lancer votre commande au sein de la ssh paramètre.

     ssh username@remotehost tail -f /var/log/remotelog.txt | tee result.log

    Et lorsque vous avez terminé, appuyez sur CTRL+C

    Dans la commande précédente, j'ai utilisé le tee de commande afin de voir dans mon terminal des lignes nouvelles et de les stocker dans le fichier.

    Si vous voulez qu'il soit de ce scriptable

    Vous pouvez effectuer les opérations suivantes:

     ## store result to file
 FILE=result.log

 ## launch tail remote log, and store result to result.log
 ssh -n username@remote-host tail -f /path/to/remote.log > $FILE &

 ## store pid
 SSHPID=$!

 ## wait for ":q" command
 while [ "$cmd" != ":q" ]; do
    echo -ne "\n$ "
    read -n 2 cmd
 done

 ## kill ssh when you've enough
 kill $SSHPID

 ## read result
 echo "the changes made to log file were\n"
 cat $FILE

    Noter que si vous souhaitez séparer de démarrer et d'arrêter de scripts, vous avez juste à stocker SSHPID dans un fichier dans le script

     echo $SSHPID > ~/.sshpid

    et de le récupérer à partir de la seconde

     SSHPID=`cat ~/.sshpid`

    OriginalL'auteur Adam

  6. 0

    De mieux que de tuer, c'est de laisser la queue de quitter correctement:

    tail -n0 --pid=$(($BASHPID+1)) -F logfile | sed '/special event string in the log/q'

    Lorsque la tuyauterie, les PIDs sont séquentiels, de sorte que le pid de la queue sera de $BASHPID et le pid de la dsi sera de $BASHPID+1. L' --pid commutateur cause de la queue de sortie (correctement!) lorsque le sed de commande se ferme. Évidemment, c'est un bashism.

    OriginalL'auteur Christian Herr