Un processus A (de contrôle/monitoring) enfante des processus de type B
(processus métier). A est prévenu de la mort des B par SIGCHLD. Mon
problème survient quand A décède, puis est ressuscité de ses propres
cendres : dans ce cas, A interroge le système (à base de moultes ps |
grep | awk > /tmp/...) pour savoir quel est l'état des processus B. En
particulier quand ils existent, A enregistre leur PID respectif et s'en
sert pour reprendre leur contrôle sans avoir à les ré-instancier. En
revanche les processus B étant devenus des fils d'Init dans cette sombre
histoire de paricide, A ne reçoit plus SIGCHLD et n'est plus informé de
la mort de ses enfants adoptés par un autre.
Je crois avoir lu dans un message d'il y a fort longtemps qu'adopter des
processus n'était pas possible. Pouvez-vous me confirmer que cela est
toujours le cas ?
Quelqu'un aurait-il une idée de contournement de ce problème, le but
étant de trouver un moyen par lequel A serait informé de la mort des B ?
Toute sera grandement appréciée.
Vous remerciant,
Fabrice
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Pascal Bourguignon
fabrizio writes:
Bonjour,
Un processus A (de contrôle/monitoring) enfante des processus de type B (processus métier). A est prévenu de la mort des B par SIGCHLD. Mon problème survient quand A décède, puis est ressuscité de ses propres cendres : dans ce cas, A interroge le système (à base de moultes ps | grep | awk > /tmp/...) pour savoir quel est l'état des processus B. En particulier quand ils existent, A enregistre leur PID respectif et s'en sert pour reprendre leur contrôle sans avoir à les ré-instancier. En revanche les processus B étant devenus des fils d'Init dans cette sombre histoire de paricide, A ne reçoit plus SIGCHLD et n'est plus informé de la mort de ses enfants adoptés par un autre.
Je crois avoir lu dans un message d'il y a fort longtemps qu'adopter des processus n'était pas possible. Pouvez-vous me confirmer que cela est toujours le cas ?
En effet.
Quelqu'un aurait-il une idée de contournement de ce problème, le but étant de trouver un moyen par lequel A serait informé de la mort des B ?
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux. Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE quand on écrit sur le pipe ou la socket. Il suffit donc que les processus s'envoient périodiquement un jeton (s'ils n'ont vraiement rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
-- __Pascal Bourguignon__ http://www.informatimago.com/ Until real software engineering is developed, the next best practice is to develop with a dynamic system that has extreme late binding in all aspects. The first system to really do this in an important way is Lisp. -- Alan Kay
fabrizio <watch.the@stars.mw> writes:
Bonjour,
Un processus A (de contrôle/monitoring) enfante des processus de type B
(processus métier). A est prévenu de la mort des B par SIGCHLD. Mon
problème survient quand A décède, puis est ressuscité de ses propres
cendres : dans ce cas, A interroge le système (à base de moultes ps |
grep | awk > /tmp/...) pour savoir quel est l'état des processus B. En
particulier quand ils existent, A enregistre leur PID respectif et s'en
sert pour reprendre leur contrôle sans avoir à les ré-instancier. En
revanche les processus B étant devenus des fils d'Init dans cette sombre
histoire de paricide, A ne reçoit plus SIGCHLD et n'est plus informé de
la mort de ses enfants adoptés par un autre.
Je crois avoir lu dans un message d'il y a fort longtemps qu'adopter des
processus n'était pas possible. Pouvez-vous me confirmer que cela est
toujours le cas ?
En effet.
Quelqu'un aurait-il une idée de contournement de ce problème, le but
étant de trouver un moyen par lequel A serait informé de la mort des B ?
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux.
Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE
quand on écrit sur le pipe ou la socket. Il suffit donc que les
processus s'envoient périodiquement un jeton (s'ils n'ont vraiement
rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
--
__Pascal Bourguignon__ http://www.informatimago.com/
Until real software engineering is developed, the next best practice
is to develop with a dynamic system that has extreme late binding in
all aspects. The first system to really do this in an important way
is Lisp. -- Alan Kay
Un processus A (de contrôle/monitoring) enfante des processus de type B (processus métier). A est prévenu de la mort des B par SIGCHLD. Mon problème survient quand A décède, puis est ressuscité de ses propres cendres : dans ce cas, A interroge le système (à base de moultes ps | grep | awk > /tmp/...) pour savoir quel est l'état des processus B. En particulier quand ils existent, A enregistre leur PID respectif et s'en sert pour reprendre leur contrôle sans avoir à les ré-instancier. En revanche les processus B étant devenus des fils d'Init dans cette sombre histoire de paricide, A ne reçoit plus SIGCHLD et n'est plus informé de la mort de ses enfants adoptés par un autre.
Je crois avoir lu dans un message d'il y a fort longtemps qu'adopter des processus n'était pas possible. Pouvez-vous me confirmer que cela est toujours le cas ?
En effet.
Quelqu'un aurait-il une idée de contournement de ce problème, le but étant de trouver un moyen par lequel A serait informé de la mort des B ?
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux. Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE quand on écrit sur le pipe ou la socket. Il suffit donc que les processus s'envoient périodiquement un jeton (s'ils n'ont vraiement rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
-- __Pascal Bourguignon__ http://www.informatimago.com/ Until real software engineering is developed, the next best practice is to develop with a dynamic system that has extreme late binding in all aspects. The first system to really do this in an important way is Lisp. -- Alan Kay
Nicolas George
Pascal Bourguignon wrote in message :
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux. Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE quand on écrit sur le pipe ou la socket. Il suffit donc que les processus s'envoient périodiquement un jeton (s'ils n'ont vraiement rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
Même pas besoin de ça : si c'est bien fait, quand l'un des processus meurt, l'autre reçoit une fin de fichier, ce qui peut se détecter avec poll si on ne veut pas bloquer. On doit même pouvoir utiliser de l'aio, si on se sent téméraire.
Pascal Bourguignon wrote in message
<87d5afsg1n.fsf@thalassa.informatimago.com>:
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux.
Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE
quand on écrit sur le pipe ou la socket. Il suffit donc que les
processus s'envoient périodiquement un jeton (s'ils n'ont vraiement
rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
Même pas besoin de ça : si c'est bien fait, quand l'un des processus meurt,
l'autre reçoit une fin de fichier, ce qui peut se détecter avec poll si on
ne veut pas bloquer. On doit même pouvoir utiliser de l'aio, si on se sent
téméraire.
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux. Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE quand on écrit sur le pipe ou la socket. Il suffit donc que les processus s'envoient périodiquement un jeton (s'ils n'ont vraiement rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
Même pas besoin de ça : si c'est bien fait, quand l'un des processus meurt, l'autre reçoit une fin de fichier, ce qui peut se détecter avec poll si on ne veut pas bloquer. On doit même pouvoir utiliser de l'aio, si on se sent téméraire.
Harpo
Pascal Bourguignon wrote:
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux. Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE quand on écrit sur le pipe ou la socket. Il suffit donc que les processus s'envoient périodiquement un jeton (s'ils n'ont vraiement rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
Un socket serait peut-être mieux, le remplaçant de mettant à l'écoute sur le même port que le défunt, port que les enfants après avoir reçu SIGPIPE testeraient de temps en temps.
Enfin faut voir...
-- http://patrick.davalan.free.fr/
Pascal Bourguignon wrote:
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux.
Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE
quand on écrit sur le pipe ou la socket. Il suffit donc que les
processus s'envoient périodiquement un jeton (s'ils n'ont vraiement
rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
Un socket serait peut-être mieux, le remplaçant de mettant à l'écoute
sur le même port que le défunt, port que les enfants après avoir reçu
SIGPIPE testeraient de temps en temps.
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux. Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE quand on écrit sur le pipe ou la socket. Il suffit donc que les processus s'envoient périodiquement un jeton (s'ils n'ont vraiement rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
Un socket serait peut-être mieux, le remplaçant de mettant à l'écoute sur le même port que le défunt, port que les enfants après avoir reçu SIGPIPE testeraient de temps en temps.
Enfin faut voir...
-- http://patrick.davalan.free.fr/
fabrizio
01/09/2006 19:06 - Harpo :
Pascal Bourguignon wrote:
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux. Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE quand on écrit sur le pipe ou la socket. Il suffit donc que les processus s'envoient périodiquement un jeton (s'ils n'ont vraiement rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
Un socket serait peut-être mieux, le remplaçant de mettant à l'écoute sur le même port que le défunt, port que les enfants après avoir reçu SIGPIPE testeraient de temps en temps.
Merci à tous pour ces réponses éclairées.
01/09/2006 19:06 - Harpo :
Pascal Bourguignon wrote:
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux.
Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE
quand on écrit sur le pipe ou la socket. Il suffit donc que les
processus s'envoient périodiquement un jeton (s'ils n'ont vraiement
rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
Un socket serait peut-être mieux, le remplaçant de mettant à l'écoute
sur le même port que le défunt, port que les enfants après avoir reçu
SIGPIPE testeraient de temps en temps.
Le plus simple sera d'ouvrir un pipe ou une socket entre les deux. Lorsque qu'un des processus meurt, on peut recevoir un signal SIGPIPE quand on écrit sur le pipe ou la socket. Il suffit donc que les processus s'envoient périodiquement un jeton (s'ils n'ont vraiement rien d'autre à se dire...), pour être informés lorsque l'autre meurt.
Un socket serait peut-être mieux, le remplaçant de mettant à l'écoute sur le même port que le défunt, port que les enfants après avoir reçu SIGPIPE testeraient de temps en temps.
