🚀 go-pugleaf

"Kristoff Bonne" <kristoff.bonne@compaqnet.nospam.be> wrote in message
news:u0ced9.ih6.ln@frigg.belbone.net...
> Gegroet,
>
> Misschien kan iemand me helpen met het volgende probleempje:
>
> Ik zou het volgende willen programeren.
>
> Alles begint met 'BB', het programma 'Big Brother' voor network- en
> device-monitoring tool (zie http://bb4.com/).
>
> Dit programma start een extern programma op; op door BB gekozen
> momenten (normaal ongeveer om de 5 minuten).
> Laten we dat process 'mama' noemen.
>
> Mama wordt geschreven door mij (liefst in perl), en die start (op haar
> beurt) een aantal 'children' op.
> Elk 'child' doet monitoring van een aan type devices, in een bepaald
> stuk van het network, en 'rapporteert' dit terug naar BB.
>
> Voor zover geen probleem, ware het niet dat de 'children' twee
> vervelende eigenschappen hebben.
> - Soms duren ze langer dan 300 seconden (de 'snelheid' waarmee BB mama
> opstart); en riskeert er dus een 'overlap' te gebeuren tussen twee
> maal hetzelfde 'child'-process die na elkaar opgestart worden.
>
> Aangezien sommige van die processen gebruik maken van gegevens uit de
> vorige 'poll-cyclus' (en dus met '.dbm'-bestanden zitten voor het
> bewaren van die informatie); wil ik hier problemen vermijden.
>
> - Soms gebeurd het wel eens dat een van die 'child' processen blijft
> hangen; of 'voortijdig' sterft. (meestal door netwerk-gerelateerde
> problemen).
>
>
> - Bijkomend probleem is dat BB enkele 'mama' gaat opstarten indien
> die er NIET meer is. ('mama' mag dus niet een hele tijd actief blijven).
> Het moet iets zijn van 'opstarten en wegwezen'.
>
>
> Mogelijk oplossingen:
> 1/ De meest 'logisch' manier is dat het 'child'-process eerst een 'lock'
> zet (ergens in een bestandje), maar gezien eigenschap 2 (soms voortijdig
> sterven) wil ik vermijden dat er 'locks' blijven staan (die niet konden
> gewist worden door het child-process wegens een 'plotse dood').
>
> 2/ Ik zoek dus iets dat een 'lock' aanmaakt, maar dat 'automatisch'
> verdwijnt als het child-process verdwijnt; ook als (bv.) dat process
> 'afgemaakt' wordt door een 'kill -9'.
>
> 3/ Een andere mogelijkheid zou zijn dat 'mama' een lijst bijhoudt van
> de 'pid's van haar children. De vraag is dan hoe 'mama' (de volgende
> keer dat ze opgestart wordt) dat process nr. xxx effectief 'haar'
> child is, en niet iets anders dat toevallig opgestart is onder dat pid?
>
> 4/ De enige manier die ik gevonden heb, is dat elk 'child'-process een
> TCP-socket zou openen als 'lock'. (want een 'tcp-socket' verdwijnt
> vanzelf als het process 'achter' die socket verdwijnt), maar dat lijkt
> me allemaal wel serieus 'zwaar'.
>
> Dus, zou het kunnen om iets 'lichters' daarvoor gebruiken (fifo's,
> semaforen, ...).
>
>
> Iemand enig idee?
>

Het duurde eventjes (tot je kill -9 vermeldde, om precies te zijn) tot ik
door had dat het hier een Unix systeem betrof.
Er is een zeer eenvoudige oplossing: lockf(). Een lock valt automatisch weg
wanneer een proces sterft.
"Started" is een naam van een file die uniek is voor een child "type".

In het child doe je dit:

extern int errno;
int fd;
fd=open ( Started, O_RDWR+O_CREAT , 0744 );
if (fd==-1) {
  // Er is werkelijk iets vreselijk fout. Als Started een legale naam bevat,
zou dit steeds moeten lukken
  // log een error en hou er mee op
}

if (lockf (fd, F_TLOCK, 0L) == -1)
    if ((errno==EAGAIN) || (errno==EACCES)) {
      // AHA! Een vorige instantie van een child dat dit "type" behandelt is
actief
      // Eventueel kun je hier de inhoud van de file lezen, dan heb je de
PID, en dan kun je daarop kill(-9) loslaten
      // Dan kun je eventuele onzin die de vorige instance wegschreef
opruimen
      // Daarna close(fd), dan weer open() en lock() uitvoeren zoals
hierboven
    }
    else {
      // Dit zou ook nooit mogen voorkomen - log een error, en hou er maar
mee op
    }

// Als we tot hier geraken, zijn we het enige proces voor dit "type"
// De file is open _en_ locked tot wij sterven...
// Hier kun je nu met write() de PID van het child process in de file
schrijven, zodat een volgende instantie van dit child ons kan terugvinden en
desnoods killen


// En hier kun je de main code schrijven

// Het is niet nodig unlock of close van fd te doen, dat gebeurt automatisch
bij onze dood...

Indien gewenst kun je 1 en ander in "mama" doen, bovenstaande code is het
simpelst wanneer je het allemaal in het childproces zet.

Luc