[thread] Thread Modbus et arrêt (le thread m'a tuer) sur Ubuntu

Version imprimable

Bonjour,
toujours mes problèmes de threads
j'ai bien compris par ailleurs au vu de mes différents post qu'on peut pas les arrêter "brutalement"
et donc qu'il est souhaitable de leur coller une variable pour les arrêter dans ce style

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class StoppableThread(threading.Thread):
    """Thread class with a stop() method. The thread itself has to check
    regularly for the stopped() condition."""
 
    def __init__(self):
        threading.Thread.__init__(self)
        self._stopper = threading.Event()
 
    def stopit(self):
        self._stopper.set()
 
    def stopped(self):
        return self._stopper.is_set()
 
    def run(self):
        while True:
            if self.stopped():
                return
            time.sleep(1)

toutefois la je rencontre un problème étonnant avec un serveur Modbus dans un thread
voici le code de mon serveur

Code:

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
77
78
import threading
import logging
from socketserver import TCPServer,ThreadingMixIn
from collections import defaultdict
 
from umodbus import conf
from umodbus.server.tcp import RequestHandler, get_server
from umodbus.utils import log_to_stream
from utils.AppUtilities import StoppableThread, Utilities
 
class ThreadingServer(ThreadingMixIn, TCPServer):
    pass
 
class ModbusServer(StoppableThread):
    '''
    Classe permettant la détection et le tracking des camions et voitures.
    '''
    def __init__(self, active = True, Host = 'localhost', Port = '5020'):
        '''
        Constructor
        '''
        StoppableThread.__init__(self)
        log_to_stream(level = logging.DEBUG)
        self.__mutex = threading.Lock()
        self.active = active
 
        # A very simple data store which maps addresss against their values.
        self.__data_store = defaultdict(int)
 
        # Enable values to be signed (default is False).
        conf.SIGNED_VALUES = False
 
        if self.active:
            TCPServer.allow_reuse_address = True
            self.app = get_server(ThreadingServer, (Host, Port), RequestHandler)
 
            @self.app.route(slave_ids = [1], function_codes = [3, 4], addresses = list(range(0, 100)))
            def read_data_store(slave_id, function_code, address):
                """" Return value of address. """
                return self.__data_store[address]
 
            @self.app.route(slave_ids = [1], function_codes = [6, 16], addresses = list(range(0, 100)))
            def write_data_store(slave_id, function_code, address, value):
                """" Set value for address. """
                with self.__mutex:
                    self.__data_store[address] = value
                    print(self.__data_store)
 
    def setData(self,address,value):
        if self.active:
            with self.__mutex:
                self.__data_store[address] = value
 
    def getData(self,address):
        if self.active:            
            with self.__mutex :
                return self.__data_store[address]
 
    def setDataStore(self,value):
        if self.active:
            with self.__mutex:
                self.__data_store = value
 
    def getDataStore(self):
        if self.active:
            with self.__mutex :
                return self.__data_store
 
    def stop(self):
        self.app.shutdown()
        self.app.server_close()
 
    def run(self):
        try:
            self.app.serve_forever()
        finally:              
            self.app.shutdown()            
            self.app.server_close()

j'utilise QModMaster comme client

bref celui ci se comporte comme un serveur TCP classique
c'est a dire qu'il doit avoir un accept puis a crée deux threads par client (réception et émission)
donc quand on fait un shutdown et un close ben les threads clients ne sont pas fermés et donc le programme ne s'arrête pas... évidement si le client se déconnecte ca marche

voici le code de test de que j'ai fait

Code:

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
def testModbusServer(boucle = True):
    print("- TEST MODEBUS ----------------------------------------------")
    ModbusThread = ModbusServer(True, "10.7.58.212", 5020)
    ModbusThread.start()
    #
    print("> pause")
    time.sleep(15)
    #
    print("> fin pause")
    ModbusThread.app.shutdown()
    ModbusThread.app.server_close()
    #
    print("> verification thread")
    while boucle:
        nbThreadRunning = 0       
        for t in threading.enumerate():
            if t.is_alive(): 
                print(f"thread en cours = {t.getName()}")
                nbThreadRunning += 1
                if t.name.startswith("Thread"):                   
                    cc = 0
                    pass
        # arret si il reste seulement MainThread
        if nbThreadRunning <= 1: break;
        time.sleep(1)
    pass
 
#--------------------------------------------------------------------------------
# Main
#--------------------------------------------------------------------------------
if __name__ == '__main__':
    print("--------------------------------------------------------------")
    print(f" Test ") 
    print("--------------------------------------------------------------")
 
    testModbusServer()
    print("-voila la veritable fin---------------------------------------")

je me doute que le passage en processus pourrait peut être marcher toutefois les fonction getData et setData serait pas forcement accessible facilement...

bref est ce que quelqu'un aurait une solution pour que lorsque que l'on shutdown ou close le serveur celui ci ferme toutes les socket qu'il a ouvert et ferme proprement ses threads

merci

16/02/2023, 08h08
tyrtamos

Bonjour

Sur le plan du principe, un thread déclaré comme "daemon" se supprime tout seul à la fermeture du programme qui l'a créé. cet argument se trouve dans l'appel à Thread de threading.
16/02/2023, 09h37
wiztricks

Salut,

Citation:

Envoyé par ikeas

bref est ce que quelqu'un aurait une solution pour que lorsque que l'on shutdown ou close le serveur celui ci ferme toutes les socket qu'il a ouvert et ferme proprement ses threads.

Déjà, il faudrait démontrer que l'appel à app.serve_forever() de la bibliothèque modbus sort bien après l'appel à app.shutdown().

Par ailleurs, hériter d'une classe nommée StoppableThread en poubélisant la mécanique qu'elle réalise n'apporte rien: juste un code plus compliqué à lire puisqu'on ne comprend pas l'intention.

Reste la solution de Tyrtamos (par ailleurs documentée) mais à utiliser lorsqu'on ne craint ni corruption ou perte de données.

- W

alors j'ai fait les modifications suivantes :
- class ModbusServer(threading.Thread): vu que le stoppable thread avait pas d'interet dans ce cas
- et dans mon test (en rajoutant deux trois trucs + ModbusThread.setDaemon(True))

Code:

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
import time
import os
import signal
import sys
import threading, multiprocessing
from utils.ModbusUtils import ModbusServer
 
def testModbusServer(boucle = True):
    print("- TEST MODBUS ------------------------------------------------")    
    ModbusThread = ModbusServer(True, "localhost", 5020)
    ModbusThread.setDaemon(True)
    ModbusThread.start()
    #
    print("> pause")
    print("> set value")
    i = 0
    while i < 30:
        print(f"- value = {i}")
        ModbusThread.setData(1,i)
        i += 1
        time.sleep(1)
    #
    print("> fin pause")
    print("> stop thread")
    ModbusThread.stop()
    print("> del thread")
    del ModbusThread
    print("> fin del thread")
    #
    print("> verification thread")
    while boucle:
        nbThreadRunning = 0       
        for t in threading.enumerate():
            if t.is_alive(): 
                print(f"thread en cours = {t.getName()}")
                nbThreadRunning += 1
                if t.name.startswith("Thread"):                   
                    cc = 0
                    pass
        # arret si il reste seulement MainThread
        if nbThreadRunning <= 1: break;
        time.sleep(1)
    pass
 
#--------------------------------------------------------------------------------
# Main
#--------------------------------------------------------------------------------
if __name__ == '__main__':
    print("--------------------------------------------------------------")
    print(f" Test CyCounter ") 
    print("--------------------------------------------------------------")   
    testModbusServer(False)
    print("-voila la veritable fin---------------------------------------")

- et juste pour controler j'ai rajouté ca au run du serveur

Code:

1
2
3
4
5
6
7
8
9
10
def run(self):
        try:
            self.app.serve_forever()
        finally:     
            print("> finally in thread")
            print(">> shutdown")
            self.app.shutdown()            
            print(">> close server")
            self.app.server_close()
            print(">> end finnaly")

donc on sort toujours pas de l'appli tant que mon QModMaster est connecté
si on utilise testModbusServer() plutot que testModbusServer(False)
on peut constater qu'il reste les deux threade créee par le serveur pour la connexion

Code:

1
2
3
thread en cours = MainThread
thread en cours = Thread-7
thread en cours = Thread-8

ce que je constate c'est que self.app.server_close() semble etre bloquant (enfin parfois)
dans tous les cas je vois bien le main trhead se terminer mais le programme s'arrete pas
j'ai tenté tous les arrêts a l'arrache style
#quit()
#sys.exit(0)
#exit(0)
#raise SystemExit
#os._exit(0)
mais le programme se termine que lorsque que ma connexion client se ferme

16/02/2023, 14h42
wiztricks

Salut,

Citation:

Envoyé par ikeas

donc on sort toujours pas de l'appli tant que mon QModMaster est connecté
si on utilise testModbusServer() plutot que testModbusServer(False)
on peut constater qu'il reste les deux threade créee par le serveur pour la connexion

Tester le côté modbus de la logique serve_forever, shutdown,... devrait se faire, dans un premier temps, sans thread.
Peut être avec un try...except KeyboardInterrupt (comme on le ferait pour aborter input).

Puis on avise en fonction du résultat.

- W
16/02/2023, 14h50
ikeas

j'ai trouvé une solution qui marche mais pas propre du tout
mais ca arrête effectivement mon soft et évidement ca ferme les connexions clients existantes
avec
os.kill(os.getpid(), signal.SIGBREAK)

je vais essayer la connexion modbus hors thread juste pour voir
après je pense que la fonction serve_forever est bloquante donc dans le MainThread c'est pas réaliste aussi
16/02/2023, 15h40
wiztricks

Citation:

Envoyé par ikeas

après je pense que la fonction serve_forever est bloquante donc dans le MainThread c'est pas réaliste aussi

Si on pense que... on teste pour le vérifier. Analyser/comprendre le problème à résoudre est un préalable à la construction d'une solution.

- W