Discussion :

[Samb95]

Bonjour à tous,

Voilà j'ai un programme qui utilise des threads mais mon problème c'est que j'utilise une fonction qui m'empêche de tuer les threads quand je fait un "Ctrl+c".

La fonction en question émule le fonctionnement de la commande système "tail -f".

Voici mon programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
import re
import time
import threading
 
def tail_f(fh):
    interval = 1.0
 
    while True:
        where = fh.tell()
        line = fh.readline()
        if not line:
            time.sleep(interval)
            fh.seek(where)
        else:
            yield line
 
class FileParser(threading.Thread):
 
    def __init__(self, file_name):
        threading.Thread.__init__(self)
        self.file_name = file_name
        self.file = open(file_name)
        self._stopevent = threading.Event( )
 
    def run(self):
        while not self._stopevent.isSet():
            file_name = self.file_name
            sum_type = "VOP"
            node_name = ""
            operation_type = ""
            operation_counter = ""
 
            for line in tail_f(self.file):
                # TODO: Parse the lines and print the right output for collectd
                line = line.rstrip("\n")
                regex="\s%s\sSUMMARY\s\[(\w+)\.\w+\]\s(\w+)\scnt\/(\d+)\s" % sum_type
                pattern = re.compile(regex)                found = pattern.search(line)
 
                if found:
                    node_name = found.group(1)
                    operation_type = found.group(2)
                    operation_counter = found.group(3)
                    timestamp = time.time()
                    print "PUTVAL %s.lbdaq.cern.ch/cvfs-%s/operations-%s %d:%s\n" % (node_name, file_name, operation_type, timestamp, operation_counter)
 
            self.file.close()
            self._stopevent.wait(2.0)
 
    def stop(self):
        self._stopevent.set()
 
def main():
    files = sys.argv[1:]
    threads = []
 
    for name in files:
        thread = FileParser(name)
        thread.start()
        threads.append(thread)
 
    while True:
        try:
            time.sleep(1)
        except KeyboardInterrupt:
            print "stoping"
            for thread in threads:
                thread.stop()
                print "thread tue"
            print "done"
            sys.exit(0)
 
if __name__ == '__main__':
    main()

Quand je fais un "Ctrl+c", je vois bien les print qui me disent que les thread sont tués mais le programme continue de tourner. Le problème vient de la fonction tail_f qui continue de tourner.

Il faudrait que je puisse arrêter la fonction quand je tue les threads. Est-ce que quelqu'un aurait une idée de comment je pourrai faire ça ?

Merci d'avance.

[Samb95]

J'ai trouvé une solution qui consiste à créer un classe Tail qui permet de simuler le fonctionnement de la commande système tail. Je peux ainsi tuer les instances de Tail quand je tue les threads.