Anständig aus Überwachung aussteigen

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
R00TKiD
User
Beiträge: 6
Registriert: Dienstag 13. März 2007, 09:43

Anständig aus Überwachung aussteigen

Beitragvon R00TKiD » Dienstag 13. März 2007, 10:02

Hallo! an das Forum von einem Python-Neuling! ;)

Um mich ein bischen in Python hinein zu finden, möchte ich mir ein Skript schreiben, welches mir eine Textdatei (einen Streamlog) überwacht. Die in der Datei während des Streamings abgelegten Musiktitel sollen in einer anderen Datei abgelegt werden.

Ich denke, ich werde da durch eine While-Schleife hindurchlaufen müssen. Allerdings weiß ich nun nicht, wie ich aus dieser Schleife ordentlich wieder heraus komme. Ich möchte nach der eigentlichen Überwachung vielleicht noch etwas "aufräumen". Kann ich Python sagen, dass es "parallel" auf eine Abbruchbedingung warten und die Überwachung ausführen soll? Frei nach dem Motto: "Mach deine Arbeit, bis der User x drückt". Diese Abfrage muss eigentlich nicht wirklich parallel laufen. Man kann ja auch immer mal 3 Sekunden auf eine Eingabe warten und dann mit dem "Job" weiter machen, wenn keine Eingabe erfolgte. Bloß... (Wie) geht sowas in Python? Kann ich festlegen, dass ich auf eine Eingabe nur eine gewisse Zeit warten möchte?
BlackJack

Beitragvon BlackJack » Dienstag 13. März 2007, 10:58

Wenn Du keine grossen Ansprüche an die Eingabemöglichkeiten stellst, dann kannst Du einfach die Tastenkombination für den Programmabruch benutzten (Strg+C unter Linux, und ich glaube Strg+Z unter Windows):

Code: Alles auswählen

try:
    while True:
        # Mach irgend etwas.
except KeyboardInterrupt:
    pass

# Aufräumen.
PmanX
User
Beiträge: 123
Registriert: Donnerstag 25. Januar 2007, 13:50
Wohnort: Germany.BB.LOS
Kontaktdaten:

Beitragvon PmanX » Dienstag 13. März 2007, 11:33

Hallo,

mir fehlt jetzt die Zeit und ich bin noch Pythonanfänger, aber ich gehe davon aus, dass ein ALARM-Signal geeignet ist.

Perlcode der einen "Alarm" auslöst, wenn die Telnetverbindung nicht antwortet.

[code=]###########################################################################
sub send_cmd {
###########################################################################
use Socket;
my $crlf = "\r\n";
my $cmd = shift;
my $ret_str;
my $timeout = 5; # max. seconds to wait for response
my $iaddr = inet_aton('pc01);
my $proto = getprotobyname('tcp');
my $paddr = sockaddr_in(2001, $iaddr);

socket(SOCK, PF_INET, SOCK_STREAM, $proto);
connect(SOCK, $paddr);
my $old = select(SOCK); $| = 1; # Conn, Unbuffered
{
local $SIG{ALRM} = sub { die "timeout\n"; }; # NB: \n required
alarm $timeout;
while (<SOCK>) { last if str_end($_) }
print SOCK $cmd, $crlf;
while (<SOCK>) { $ret_str .= $_; last if str_end($_) }
print SOCK 'quit', $crlf;
while (<SOCK>) { last if str_end($_) }
alarm 0;
};
select($old);
close SOCK or warn "Close $! \n";
return $ret_str;
}
[/code]

Gruß P.
Benutzeravatar
Dill
User
Beiträge: 470
Registriert: Mittwoch 10. Januar 2007, 14:52
Wohnort: Köln

Beitragvon Dill » Dienstag 13. März 2007, 13:58

mit WConio geht das auch ganz nett. (falls dir keybint nicht reicht)
http://newcenturycomputers.net/projects/wconio.html
PmanX
User
Beiträge: 123
Registriert: Donnerstag 25. Januar 2007, 13:50
Wohnort: Germany.BB.LOS
Kontaktdaten:

Beitragvon PmanX » Dienstag 13. März 2007, 16:02

Code: Alles auswählen

import signal, os
from sys import exit
from time import sleep

# HandlerTest
def h1(sig, f):
   print 'Handler Signal %d gerufen' % sig


def h2(sig, f):
   print 'Handler Signal %d gerufen .. beende mich' % sig
   exit(1)


# PID
print 'my PID: %d' % os.getpid()

# Signale abfangen
signal.signal(signal.SIGUSR1, h1)
signal.signal(signal.SIGINT, h2)

while 1:
# SIGINT zb. KeyboardInterrupt beendet
   os.kill(os.getpid(), signal.SIGUSR1)
   sleep(10)
Ist in Python auch kein Problem.
Benutzeravatar
Masaru
User
Beiträge: 425
Registriert: Mittwoch 4. August 2004, 22:17

Beitragvon Masaru » Mittwoch 14. März 2007, 11:17

Anmrk: os.kill() funktioniert leider nicht unter allen Plattformen (so z.B. nicht unter Windows)

EDIT: (nachtrag)

Man könnte natürlich sich auch so etwas hier basteln:

Code: Alles auswählen

#! /usr/bin/env python

import threading
import time


def do_listen_stream(abort):
    while not abort.isSet():
        time.sleep(3)
        # was auch immer


def main():
    """Main method"""
    abort_event = threading.Event()

    print "Initialization of stream listening"
    action_thread = threading.Thread(
        target=do_listen_stream,
        args=(abort_event, ),
        )

    print "Starting stream listening"
    action_thread.start()

    quit = False
    while not quit:
        print "Current process is ... %s" % (
            ['ended', 'running'][action_thread.isAlive()])


        while True:
            prompt = raw_input("Command (r)efresh or (q)uit:")
            command = prompt.strip().lower()
            if command == 'r':
                break
            if command == 'q':
                quit = True
                break

    abort_event.set()
    max_loops = 3
    wait = 3
    for loop in range(1,max_loops+1):
        if not action_thread.isAlive():
            break
        print "... stream listening thread not ended, waiting %s second(s) " \
              "(loops until kill/shutdown: %s)" % (wait, max_loops - loop)
        time.sleep(wait)

    if action_thread.isAlive():
        print "... warning: stream listening thread still alive, programm " \
              "will end without warranty of termination"

    else:
        print "... programm successfully end"


if __name__ == '__main__':
    main()

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder