Anständig aus Überwachung aussteigen

[R00TKiD]

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]

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]

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: Alles auswählen

###########################################################################
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;
}

Gruß P.

[Dill]

mit WConio geht das auch ganz nett. (falls dir keybint nicht reicht)
http://newcenturycomputers.net/projects/wconio.html

[PmanX]

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.

[Masaru]

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()