job & job_pid=$! ( while printf .; do sleep 1; done ) & ruler_pid=$! wait "$job_pid" kill "$ruler_pid"
On peut aussi rester compatible avec l'ensemble des shells "Bourne" en lancant la commande après l'affichage des points:
while 1; do printf .; sleep 1; done & #pas besoin des parenthèses pid=$! job kill $!
Pascal Bourguignon
Stephane Chazelas writes:
2004-12-15, 15:39(+00), Kevin Denis:
[bash - linux] Bonjour,
Dans un script bash, je lance un processus qui peut prendre plus ou moins longtemps.
Je voudrais le lancer en arriere plan, et afficher des points "." jusqu'a ce qu'il ait fini de se lancer.
Pour l'instant, j'utilise:
echo "Demarrage du process :" rm a (sleep 25 ; touch a)& while [ ! -f a ] do sleep 1 echo -n "." done echo "le process est termine"
Y'a pas mieux? (ca me parait pas propre comme methode) [...]
Tu peux faire:
job & job_pid=$! ( while printf .; do sleep 1; done ) & ruler_pid=$! wait "$job_pid" kill "$ruler_pid"
Ça ne me parait pas correspondre à ce qui est demandé, mais c'est normal, car la question n'a pas de sens (sur unix).
Que signifie qu'un processus unix est dans l'état "lancé" ? Rien du tout. Un processus unix peut être dans un des états suivant (voir par exemple linux/src/include/kernel/sched.h):
Maintenant, on peut définir pour certains processus, un sous état de RUNNING qu'on appellera LAUNCHED ou lancé qui se définirait comme l'état du processus principal d'une _application_ entre le moment où il est forké et le moment où l'application obtient son premier évènement.
Pour un programme classique, on pourrait vouloir définir cet état comme étant celui entre le fork/exec et le moment où le programme commence à s'éxécuter, mais étant donné les techniques moderne implémentée dans les noyaux unix afin d'accélérer le démarrage des processus (copy-on-write, chargement des exécutables page par page, édition de liens dynamique, etc) en général le programme commence tout de suite à s'éxécuter.
Dans les cas d'un application GUI, l'application peut avoir à charger une grosse quantité de "resources": sons, images, descriptions de fenêtres et menus, et autres initialisations avant de pouvoir commencer à traiter les évènements de l'utilisateurs (clics souris et pressions de touche de clavier). D'où l'introduction pour une application d'un état "lancé", représenté par exemple sur NeXTSTEP par l'illumination du fond de l'icône de l'application.
Mais comme ce n'est pas un état unix, ça nécessite une interaction entre l'environnement GUI (le "Workspace Manager" ou "Finder") et l'application elle même qui doit lui indiquer quand son "état" passe de "lancé" à "tourne".
Donc, pour un programme quelconque, la question est: comment le programme en question définit-il son état "lancé" ? S'il pouvait envoyer un signal à son parent pour l'avertir qu'il a fini de se lancer, ça ne serait pas mal.
trap 'kill $ruler_pid' USR1 job & ( while printf .; do sleep 1; done ) & ruler_pid=$! trap - USR1
Une autre solution serait qu'il écrive sur sa sortie standard son état. Par exemple: $ cat job
Dans un script bash, je lance un processus qui peut prendre plus ou
moins longtemps.
Je voudrais le lancer en arriere plan, et afficher des points "."
jusqu'a ce qu'il ait fini de se lancer.
Pour l'instant, j'utilise:
echo "Demarrage du process :"
rm a
(sleep 25 ; touch a)&
while [ ! -f a ]
do
sleep 1
echo -n "."
done
echo "le process est termine"
Y'a pas mieux? (ca me parait pas propre comme methode)
[...]
Tu peux faire:
job & job_pid=$!
( while printf .; do sleep 1; done ) & ruler_pid=$!
wait "$job_pid"
kill "$ruler_pid"
Ça ne me parait pas correspondre à ce qui est demandé, mais c'est
normal, car la question n'a pas de sens (sur unix).
Que signifie qu'un processus unix est dans l'état "lancé" ? Rien du
tout. Un processus unix peut être dans un des états suivant (voir par
exemple linux/src/include/kernel/sched.h):
Maintenant, on peut définir pour certains processus, un sous état de
RUNNING qu'on appellera LAUNCHED ou lancé qui se définirait comme
l'état du processus principal d'une _application_ entre le moment où
il est forké et le moment où l'application obtient son premier évènement.
Pour un programme classique, on pourrait vouloir définir cet état
comme étant celui entre le fork/exec et le moment où le programme
commence à s'éxécuter, mais étant donné les techniques moderne
implémentée dans les noyaux unix afin d'accélérer le démarrage des
processus (copy-on-write, chargement des exécutables page par page,
édition de liens dynamique, etc) en général le programme commence tout
de suite à s'éxécuter.
Dans les cas d'un application GUI, l'application peut avoir à charger
une grosse quantité de "resources": sons, images, descriptions de
fenêtres et menus, et autres initialisations avant de pouvoir
commencer à traiter les évènements de l'utilisateurs (clics souris et
pressions de touche de clavier). D'où l'introduction pour une
application d'un état "lancé", représenté par exemple sur NeXTSTEP par
l'illumination du fond de l'icône de l'application.
Mais comme ce n'est pas un état unix, ça nécessite une interaction
entre l'environnement GUI (le "Workspace Manager" ou "Finder") et
l'application elle même qui doit lui indiquer quand son "état" passe
de "lancé" à "tourne".
Donc, pour un programme quelconque, la question est: comment le
programme en question définit-il son état "lancé" ? S'il pouvait
envoyer un signal à son parent pour l'avertir qu'il a fini de se
lancer, ça ne serait pas mal.
trap 'kill $ruler_pid' USR1
job &
( while printf .; do sleep 1; done ) & ruler_pid=$!
trap - USR1
Une autre solution serait qu'il écrive sur sa sortie standard son
état. Par exemple:
$ cat job
Dans un script bash, je lance un processus qui peut prendre plus ou moins longtemps.
Je voudrais le lancer en arriere plan, et afficher des points "." jusqu'a ce qu'il ait fini de se lancer.
Pour l'instant, j'utilise:
echo "Demarrage du process :" rm a (sleep 25 ; touch a)& while [ ! -f a ] do sleep 1 echo -n "." done echo "le process est termine"
Y'a pas mieux? (ca me parait pas propre comme methode) [...]
Tu peux faire:
job & job_pid=$! ( while printf .; do sleep 1; done ) & ruler_pid=$! wait "$job_pid" kill "$ruler_pid"
Ça ne me parait pas correspondre à ce qui est demandé, mais c'est normal, car la question n'a pas de sens (sur unix).
Que signifie qu'un processus unix est dans l'état "lancé" ? Rien du tout. Un processus unix peut être dans un des états suivant (voir par exemple linux/src/include/kernel/sched.h):
Maintenant, on peut définir pour certains processus, un sous état de RUNNING qu'on appellera LAUNCHED ou lancé qui se définirait comme l'état du processus principal d'une _application_ entre le moment où il est forké et le moment où l'application obtient son premier évènement.
Pour un programme classique, on pourrait vouloir définir cet état comme étant celui entre le fork/exec et le moment où le programme commence à s'éxécuter, mais étant donné les techniques moderne implémentée dans les noyaux unix afin d'accélérer le démarrage des processus (copy-on-write, chargement des exécutables page par page, édition de liens dynamique, etc) en général le programme commence tout de suite à s'éxécuter.
Dans les cas d'un application GUI, l'application peut avoir à charger une grosse quantité de "resources": sons, images, descriptions de fenêtres et menus, et autres initialisations avant de pouvoir commencer à traiter les évènements de l'utilisateurs (clics souris et pressions de touche de clavier). D'où l'introduction pour une application d'un état "lancé", représenté par exemple sur NeXTSTEP par l'illumination du fond de l'icône de l'application.
Mais comme ce n'est pas un état unix, ça nécessite une interaction entre l'environnement GUI (le "Workspace Manager" ou "Finder") et l'application elle même qui doit lui indiquer quand son "état" passe de "lancé" à "tourne".
Donc, pour un programme quelconque, la question est: comment le programme en question définit-il son état "lancé" ? S'il pouvait envoyer un signal à son parent pour l'avertir qu'il a fini de se lancer, ça ne serait pas mal.
trap 'kill $ruler_pid' USR1 job & ( while printf .; do sleep 1; done ) & ruler_pid=$! trap - USR1
Une autre solution serait qu'il écrive sur sa sortie standard son état. Par exemple: $ cat job
