watchdog bei einer while-Schleife (Allgemeines zu Perl)

[thread]19810[/thread]

watchdog bei einer while-Schleife

Tags: perl5 Ähnliche Threads

Leser: 16

Articles: hide open all | hide show old branches

+21 replies
Gast perlensammler22

2015-09-22 07:29

Hallo,

ihr habt mir letztes mal so gute Tipps gegeben,
daher dachte ich mir, vielleicht gibts wider einen tollen Tipp von euch.

Ich habe ein Programm das auf STDIN warten.
Realisiert habe ich das mit einer while (<>) { abfrage.
Die Quelle sendet mindestens alle 3 Minuten.
Nun die eigentliche Frage:

Wie kann man eine watchdog einbauen, der mindesten alle 10 Minuten zurückgesetzt werden muss?
Und falls der Watchdog zuschlägt das Start-Stop Script aufgerufen wird.

Gruß
perlensammler22
Last edited: 2015-09-22 09:18:37 +0200 (CEST)
- +3 replies
- Muffi
  
  2015-09-22 09:30
  
  User since
  2012-07-18
  1465 Artikel
  BenutzerIn
  
  Der Start-Stop wird dann für deine Quelle aufgerufen?
  Und wie kommt danach das Zeugs wieder nach STDIN?
  1 + 1 = 10
  - +2 replies
  - Gast perlensammler22
    
    2015-09-22 10:31
    
    Das ist nicht wichtig, da die Daten nicht mehr benötigt werden.
    
    Momentan startet ich das ganze auf der Console so:
    
    # programm | mein_perl.pl
    
    Falls jetzt das "programm" nicht mehr funktioniert und keine Daten liefert soll einfach alles gekillt und neu gestartet werden.
    Das mach ein Start/Stop Script jetzt schon.
    Das Script kennt auch reboot.
    Last edited: 2015-09-22 11:09:42 +0200 (CEST)
    - Muffi
      
      2015-09-22 12:04
      
      User since
      2012-07-18
      1465 Artikel
      BenutzerIn
      
      Mir fällt da spontan die Funktion alarm() ein.
      (Ist aber evtl. Betriebssystemabhängig, bin ich mir nicht sicher)
      1 + 1 = 10
- +17 replies
- lichtkind
  
  2015-09-22 15:28
  
  User since
  2004-03-22
  5697 Artikel
  ModeratorIn + EditorIn
  
  naja fork (main fork schläft einfach 10 min und lässt alle 10 min ein kind ab) wäre auch eine lösung aber beschreib mal logisch wie das ablaufen soll, weil das hab ich immer noch nicht verstanden
  Tutorien in der Wiki, mein zeug:
  kephra, baumhaus, garten, gezwitscher
  
  Es beginnt immer mit einer Entscheidung.
  - +16 replies
  - Gast perlensammler22
    
    2015-09-22 17:43
    ok, ich Versuchs noch mal zu beschreiben.
    
    Ich habe ein Programm geschrieben, das auf Aktionen an STDIN wartet.
    Die Schleife beginnt mit
    
    Code: (dl )
    
    1 2 3 4 5 6 7
    
    #lesen von STDIN while (<>) { chomp; .... } #Ende while (<>) {
    
    Aufgerufen wird das gane mit: $ ./quelle|meinperl.pl
    
    Solange auf STDIN nichts kommt, solange wartet die Schleife. Es wird also nichts abgearbeitet.
    ich weiß allerdings das Systembedingt von der "quelle" mindestens alle 4 Minuten etwas kommen muss.
    Sollt das allerdings ausbleiben, möchte ich die quelle + meinperl.pl neu starten.
    
    Das es unter /etc/init.d ein passende Start-Script gibt. Reich es, wenn nach Ablauf der Zeit 2x4 Minuten diese Script aufgerufen wird.
    
    Ich könnte das ganze mit einem zweiten Programm realisieren, das regelmäßig ein Zeitstempel in einer Datei prüft.
    Diesen Zeitstempel schreibt meinperl.de.
    Allerdings finde ich diese Lösung nicht Elegant und dachte mir da muss es doch sicherlich etwas fertiges geben.
    
    Gruß
    perlensammler
    Last edited: 2015-09-22 18:14:34 +0200 (CEST)
    - +5 replies
    - hlubenow
      
      2015-09-22 18:30
      
      User since
      2009-02-22
      875 Artikel
      BenutzerIn
      
      Neulich war hier schonmal so'ne Frage: Am einfachsten ist es wahrscheinlich, innerhalb der Schleife mit "time()" die Systemzeit auszulesen und die mit einem Startwert zu vergleichen.
      
      Threads wären eine weitere Möglichkeit, aber komplizierter.
      - +4 replies
      - hlubenow
        
        2015-09-23 17:11
        
        User since
        2009-02-22
        875 Artikel
        BenutzerIn
        
        Ich finde das schlüssiger:
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
        
        #!/usr/bin/perl use warnings; use strict; my $tstart = time(); my $t; print "Please wait (five seconds).\n"; while(1) { $t = time() - $tstart; if ($t >= 5) { print "Five seconds reached.\n"; last; } }
        
        +3 replies
        
        Gast perlensammler22
        
        2015-09-24 06:51
        
        @hlubenow
        
        Guten Morgen,
        
        dein Code ist mir nicht verständlich.
        
        Deine while Schleife wird doch nie dauerhaft abgearbeitet,
        wenn meine while Schleife die auf STDIN wartet quasi den Programmfluss stoppt?
        Der rücksetzt Operator muss ja in der while Schleife von STDIN stecken, weil indirekt die Quelle überwacht wird, ob die noch Daten sendet.
        
        Gibts nichts fertiges das man per use einbinden kann?
        
        Gruß
        perlensammler
        Last edited: 2015-09-24 08:45:56 +0200 (CEST)
        
        +2 replies
        
        Muffi
        
        2015-09-24 08:59
        
        User since
        2012-07-18
        1465 Artikel
        BenutzerIn
        
        Ja, ich glaub dein Gedankengang ist richtig.
        
        Ansonsten könnte man STDIN noch als Socket (oder Handle oder ähnliches) betrachten. Wenn mich nicht alles täuscht müssts da zum Einlesen auch Timeouts geben.
        
        Aber ob das dann einfacher als mit alarm() wird ... da müsst ich auch erst mal rumgrasen wie man das hinkriegt.
        Last edited: 2015-09-24 09:00:18 +0200 (CEST)
        1 + 1 = 10
        
        Muffi
        
        2015-09-24 10:05
        
        User since
        2012-07-18
        1465 Artikel
        BenutzerIn
        
        So ungefähr müssts gehn.
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8
        
        use IO::Select; my $s = IO::Select->new(\*STDIN); while (1) { if ($s->can_read(1)) { my $foo = <STDIN>; } }
        
        Allerdings, was ich nach ewiger rumtesterei festgestellt hab: wohl wieder nicht unter Windows
        1 + 1 = 10
    - Gast wer
      
      2015-09-23 13:41
      
      Code (perl): (dl )
      
      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
      
      eval { # das eval-block "sterben lassen" (verlassen) wenn ALARM ausgelöst wird: local $SIG{ALRM}=sub{ die() }; # 10 Sekunden Warten alarm(10); #lesen von STDIN while (<>) { chomp; ... # 10 Sekunden Warten Timer zurück setzen alarm(10); } # kein Alarm alarm(0); }; # kein Alarm alarm(0); ...
      
      Last edited: 2015-09-23 13:55:00 +0200 (CEST)
    - +9 replies
    - Linuxer
      
      2015-09-24 00:01
      
      User since
      2006-01-27
      3890 Artikel
      HausmeisterIn
      
      Hi,
      
      ich wollt es selber mal ausprobieren...
      
      Zunächst ein simples Skript, um alle X Sekunden einen Output zu generieren:
      
      datastream (3.6kb)
      
      Dann ein Skript, welches über die Argumente genannt bekommt, von welchem Programm es lesen soll und wie lange es dauern soll, bis ein Timeout vorliegt:
      
      readstream (9.0kb)
      
      Der Aufruf dann als:
      
      Code: (dl )
      
      ./readstream --timeout 3 -- ./datastream --interval 5
      
      Mit -- endet die Optionsliste für readstream; alles was danach kommt, wird für das auszuführende Kommando verwendet; hier also ./datastream --interval 5.
      datastream soll nur alle 5 Sekunden eine Ausgabe liefern, und readstream soll schon nach 3 Sekunden einen Timeout melden.
      
      Resultat:
      
      Code: (dl )
      
      1 2 3 4 5 6 7 8 9 10 11 12
      
      pid 4964 : ./datastream -int 5 READ: Wed Sep 23 23:56:03 2015 ALARM received! pid 4965 : ./datastream -int 5 READ: Wed Sep 23 23:56:06 2015 ALARM received! pid 4966 : ./datastream -int 5 READ: Wed Sep 23 23:56:09 2015 ALARM received! pid 4967 : ./datastream -int 5 READ: Wed Sep 23 23:56:12 2015 ^C
      
      Alle 5 Sekunden kommt die Ausgabe von datastream; aber schon nach 3 Sekunden meldet sich der alarm mit der Timeout Meldung. Mit der exec()-Zeile wird dann das Skript selber nochmal aufgerufen (man beachte die steigende PID für datastream bei den Ausgaben). Die PID für readstream bleibt dabei dieselbe (beachte perlfunc exec).
      meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
      Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
      - +8 replies
      - hlubenow
        
        2015-09-24 01:28
        
        User since
        2009-02-22
        875 Artikel
        BenutzerIn
        
        Zu kompliziert. Probier' doch mal mein Skript oben. ;)
        
        Muffi
        
        2015-09-24 08:55
        
        User since
        2012-07-18
        1465 Artikel
        BenutzerIn
        
        Dafür funktionierts ;)
        1 + 1 = 10
        
        +6 replies
        
        Linuxer
        
        2015-09-24 11:23
        
        User since
        2006-01-27
        3890 Artikel
        HausmeisterIn
        
        Welches Skript meinst Du? Das, das keine Daten liest und damit an der Aufgabe vorbei geht? ;-)
        
        Das Lesen von einem Handle mit <> blockiert, bis da was ankommt. Da hilft ein Vergleich der Systemzeit nicht viel, weil der Vergleich nicht stattfinden kann, wenn eben auf Daten vom Handle gewartet wird.
        
        Aber Du bist herzlich eingeladen, Deinen Ansatz weiterzuführen und mir zu zeigen, wie Du das mit Deinem Ansatz weniger kompliziert umsetzen kannst.
        meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
        Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
        
        +5 replies
        
        hlubenow
        
        2015-09-24 17:09
        
        User since
        2009-02-22
        875 Artikel
        BenutzerIn
        
        Linuxer
        (man beachte die steigende PID für datastream bei den Ausgaben)
        
        Bedeutet das, daß bei jedem Lesen eine neue Pipe zu datastream geöffnet wird?
        
        Linuxer
        Das Lesen von einem Handle mit <> blockiert, bis da was ankommt.
        
        Hmm, ok, das ist natürlich ein blödes Problem. Man bräuchte also unbuffered/non-blocked Reading, von STDIN, bzw. aus der Pipe. Für die Tastatur gibt's ja Term::Readkey, aber bei einer Pipe ist das etwas umständlich. Hier sind ein paar Ansätze:
        
        https://davesource.com/Solutions/20080924.Perl-Non...
        http://www.perlmonks.org/?node_id=55241
        
        Wird dann in der Tat kompliziert. Möchte das jetzt nicht umsetzen. Don't want to be Suffering from Buffering. ;)
        Last edited: 2015-09-24 17:11:43 +0200 (CEST)
        
        +2 replies
        
        Linuxer
        
        2015-09-24 17:11
        
        User since
        2006-01-27
        3890 Artikel
        HausmeisterIn
        
        Bitte entferne den dritten Link. Dessen Legalität ist afaik strittig/zweifelhaft.
        meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
        Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
        
        hlubenow
        
        2015-09-24 17:12
        
        User since
        2009-02-22
        875 Artikel
        BenutzerIn
        
        Ah, ok, kein Problem.
        
        +2 replies
        
        Linuxer
        
        2015-09-24 17:22
        
        User since
        2006-01-27
        3890 Artikel
        HausmeisterIn
        
        2015-09-24T15:09:35 hlubenow
        Linuxer
        (man beachte die steigende PID für datastream bei den Ausgaben)
        
        Bedeutet das, daß bei jedem Lesen eine neue Pipe zu datastream geöffnet wird?
        
        Ja, weil das gesamte Skript neu gestartet wird.
        Das ist ja eine Anforderung von perlensammler22 gewesen, den gesamten Aufruf neu zu starten.
        
        perlensammler22
        ich weiß allerdings das Systembedingt von der "quelle" mindestens alle 4 Minuten etwas kommen muss.
        Sollt das allerdings ausbleiben, möchte ich die quelle + meinperl.pl neu starten.
        
        meine Beiträge: I.d.R. alle Angaben ohne Gewähr und auf Linux abgestimmt!
        Die Sprache heisst Perl, nicht PERL. - Bitte Crossposts als solche kenntlich machen!
        
        hlubenow
        
        2015-09-24 21:27
        
        User since
        2009-02-22
        875 Artikel
        BenutzerIn
        
        Also, hier nochmal ein Beispiel:
        
        Code (perl): (dl )
        
        1 2 3 4 5 6 7 8 9 10 11 12
        
        #!/usr/bin/perl use strict; use warnings; # datastream.pl - Print local time every three seconds. $| = 1; # unbuffered STDOUT while ( 1 ) { print scalar(localtime), "\n"; sleep 3; }
        
        und
        
        Code (perl): (dl )
        
        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 33
        
        #!/usr/bin/perl use warnings; use strict; # readstream.pl use Fcntl; fcntl(STDIN, F_SETFL, O_NONBLOCK); my $input; my $res; my $str = ""; my $reading = 0; my $notread = 0; while(1) { $res = sysread(STDIN, $input, 1); if (defined($res)) { $reading = 1; $str .= $input; if ($notread) { print "Unsuccessful attempts to read: $notread.\n"; } $notread = 0; } else { if ($reading == 1) { print $str; } $reading = 0; $notread++; $str = ""; } }
        
        Aufruf:
        
        Code: (dl )
        
        datastream.pl | readstream.pl
        
        Auf Linux liest er dann ungeblockt, und man kann mitzählen, wie oft er nichts gelesen hat (so daß man eine Zahl festlegen könnte, bei der er das Lesen abbrechen soll). Problem ist: In den drei Sekunden waren das bei mir ca. 4,5 Millionen mal! Irgendwo würde ich ihm da gern noch eine sleep-Pause gönnen.

View all threads created 2015-09-22 07:29.