Discussion :

[Invité]

hello,

je lance un process en background.
je veux que quand je quitte mon script, mon process soit tué;
ET je veux également démarrer un processB une fois que le process s'est initialisé (il output sur stdout)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
trap : SIGTERM SIGINT
node process&
pid=$!
#ici au bout de mettons 3secondes, process fait un echo 'initialized'
waitForBackgroundProcessToEcho 'initialized'
processB
 
wait $pid
if [[ $? -gt 128 ]]
then
    kill $pid
fi

comment puis-je me débrouiller pour avoir l'équivalent de waitForBackgroundProcessToEcho ?

[Invité]

bon je m'en sors ainsi dans les grandes lignes

un gros fichier temporaire assez dégueux
un pid récupéré à la oneagain

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#!/bin/bash
trap : SIGTERM SIGINT
 
exec 3< <(
  program='machin.js'
  node $program "$@"&
  ps -ef|grep "$program"|grep -v 'grep'|awk '{print $2}'>/tmp/pid
)
# Read the output of wminput line by line until one line contains Ready
while read line; do
   echo $line|grep -q 'localhost' && break;
done <&3
# Close the file descriptor
exec 3<&-
 
firefox localhost:3000
#http://stackoverflow.com/questions/9052847/implementing-infinite-wait-in-shell-scripting
tail -f /dev/null & wait
if [[ $? -gt 128 ]]
then
    subPid=$(cat /tmp/pid)
    rm /tmp/pid
    kill $subPid
fi

[jack-ft]

bon je m'en sors ainsi dans les grandes lignes

un gros fichier temporaire assez dégueux

As-tu regardé du côté de "mkfifo"?

un pid récupéré à la oneagain

As-tu regardé du côté de "pgrep"?

[Invité]

J'avais réalisé une sorte de pacman qui utilisait plusieurs processus.
Le script principal s'occupait de l'affichage, les scripts lancés en background s'occupaient de déplacer le joueur et les fantômes.
Ce n'était pas vraiment optimisé, mais c'était motivant pour gérer les sous-processus et le passage d'information entre les divers script (obligé de passer par des fichiers temporaires ...)

Une partie du script principal :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
#!/bin/bash
 
main_sh=$$
...
./jeu2_monster.sh $main_sh 1 1.2 2>/dev/null &
...

jeu2_monster.sh :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
#!/bin/bash
 
...
main_sh=$1
...
kill -0 $main_sh
while [ $? -eq 0 ]
do
...
	sleep $3
	kill -0 $main_sh
done

Le script jeu2_monster.sh se terminait donc automatiquement si le script principal était arrêté

[jack-ft]

gérer les sous-processus et le passage d'information entre les divers script (obligé de passer par des fichiers temporaires ...)

Ben non! Normalement, on n'est pas obligé de passer par des fichiers temporaires... si on utilise mkfifo (comme indiqué dans mon message précédent)

Si tu es justement en mode "exercice", je t'en recommande l'essai (euh... si tu es en mode "sérieux", aussi!)

[Invité]

Ben je ne connaissais pas ta commande quand j'avais fait mon petit jeu :p
Il faudra que je teste ça quand j'aurais le temps, ça pourra m'être utile dans le futur.

[Invité]

Hello,

mkfifo à l'air de correspondre parfaitement à ce que je cherche
http://www.linuxjournal.com/content/...pes-fifos-bash

pgrep pareil avec pid du père ou gid..

J'updaterai ce poste avec un exemple dès que j'ai le temps (et l'envie) de scripter

thx!

update:
Je suis pas sur même environnement, mais j'ai l'impression que mon childprocess (node) est tué lors du ctrl+c (sigint).
Deux questions
* Quelqu'un peut-il confirmer que lors d'un sigint celui-ci est propagé aux processus fils?
* Pourquoi pgrep node -P 'processusPere==$$' me retourne vide et non pas le pid de node?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
#!/bin/bash
trap cleanExit EXIT
pipe=/tmp/testpipe
function cleanExit(){
  echo 'removing pipe' && rm -f $pipe
  #kill $nodePid
}
 
if [[ ! -p $pipe ]]; then
    mkfifo $pipe
fi
 
/usr/bin/node ./writer.js a b c > $pipe&
nodePid=$!
#pgrep does not find node with parent pid myPid...why?
myPid=$$
echo 'node PID = '$(pgrep node -P "$myPid")
 
#ok part
while true
do
    if read line <$pipe; then
        if [[ "$line" == 'ready' ]]; then
            break
        fi
        echo $line
    fi
done
 
#do whatever when ready
cat

writer.js: il attend 15 secondes avant d'écrire ready, et continue à attendre jusqu'à la fin des temps

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
var i=0;
args = process.argv.splice(2);
console.log(args)
function test(){
  console.log('here '+(++i));
  if(i==15){
    console.log('ready');
  }
   setTimeout(test, 1000)
}
test();

[Invité]

Ben non! Normalement, on n'est pas obligé de passer par des fichiers temporaires... si on utilise mkfifo (comme indiqué dans mon message précédent)

Si tu es justement en mode "exercice", je t'en recommande l'essai (euh... si tu es en mode "sérieux", aussi!)

Commande intéressante, mais qui n'est pas utilisable avec mon petit jeu. J'écrivais dans le fichier au début et puis toute les 1-2 secondes. Par contre la lecture était toutes les secondes.
Comme c'est de type fifo, il n'y a plus rien une fois qu'on l'a lu

* Quelqu'un peut-il confirmer que lors d'un sigint celui-ci est propagé aux processus fils?

Un Ctrl+C d'un script ne va pas stopper ceux lancés en background (via le &). Ils auront comme id de processus père le 1.
Par contre, si tu ne les lances pas en nohup ils seront arrêtés lorsque tu fermes le terminal.

* Pourquoi pgrep node -P 'processusPere==$$' me retourne vide et non pas le pid de node?

Peux-tu tester comme ceci ? D'après le man, le motif doit être à la fin, mais ce n'est pas une fonction que j'utilise donc je fais peux-être une erreur ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pgrep -P $$ node

[Invité]

a.sh

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
node ./writer.js > $pipe &
ps j $$
myPid=$$
ps j $(pgrep node -P "$myPid")

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
 2038  2605  2605  2038 pts/0     2605 S+    1000   0:00 /bin/bash ./a.sh
 PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
 2036  2038  2038  2038 pts/0     2605 Ss    1000   0:00 /bin/bash
 2038  2605  2605  2038 pts/0     2605 S+    1000   0:00 /bin/bash ./a.sh
 2605  2607  2605  2038 pts/0     2605 S+    1000   0:00 /bin/bash ./a.sh

je présume que la derniere ligne, ca devrait etre /usr/bin/node, mais bon, j'approfondirai le bg plus tard.

La question était à qui ctrl+c est lancé.
ctrl+c map un INT signal,
ce INT signal tape le foregroundgroup, qui est contient a.sh
il est envoyé à tous les process de ce group
dans ce group, il y a également PID 2607 qui correspond à node, qui recoit donc également SIGINT

Il reste donc à comprendre ce que fait le shell quand on passe node en background (pourquoi ps j ne displaye pas le nom node mais /bin/bash ./a.sh)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Ils auront comme id de processus père le 1.

non cf ci-dessus

[Invité]

Bizarre ce résultat ...

Je viens à nouveau de faire un test (mais sans utiliser node) et chez moi:
- le ctrl+c ne se propage pas
- le id de processus père devient 1

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
$ cat test.sh
#!/bin/bash
 
echo "test.sh: "$$
./tmp.sh &
sleep 60

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
$ cat tmp.sh
#!/bin/bash
 
echo "tmp.sh: "$$
ps -ef | grep $$
sleep 60

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
$ ./test.sh
test.sh: 1628
tmp.sh: 3624
    User    3816    3624 pty0     13:40:54 /usr/bin/ps
    User    3624    1628 pty0     13:40:54 /usr/bin/bash
    User    3696    3624 pty0     13:40:54 /usr/bin/grep

Après avoir fait le ctrl+c, je vois toujours le processus 3624 mais cette fois avec le PPID 1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
$ ps -ef | grep 3624
    User     432    3624 pty0     13:40:54 /usr/bin/sleep
    User    3624       1 pty0     13:40:54 /usr/bin/bash

Il me semblait pourtant que c'était le fonctionnement normal.
Avons-nous un résultat différent suivant la commande appelée en background ?

ps: test fait via cygwin et non sur une machine linux, donc le résultat est peut être faussé.