src/KERNEL_PY/kernel/threadhelper.py

   1 # -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
   3 #
   4 # Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   5 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   6 #
   7 # This library is free software; you can redistribute it and/or
   8 # modify it under the terms of the GNU Lesser General Public
   9 # License as published by the Free Software Foundation; either
  10 # version 2.1 of the License, or (at your option) any later version.
  11 #
  12 # This library is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 # Lesser General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Lesser General Public
  18 # License along with this library; if not, write to the Free Software
  19 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20 #
  21 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  22 #
  23
  24 __author__="gboulant"
  25 __date__ ="$1 avr. 2010 18:12:38$"
  26
  27 import time
  28 import threading
  29
  30 # ===========================================================================
  31 class Runner(threading.Thread):
  32     """
  33     This class provides a tool to run and drive a function in a dedicated thread.
  34     """
  35     def __init__(self, functionToRun=None,*argv):
  36         threading.Thread.__init__( self )
  37         self._stopevent = threading.Event()
  38         self.setFunction(functionToRun)
  39         self.setArguments(*argv)
  40         self._exception = None
  41         self._return    = None
  42         self._observer  = None
  43         self._callbackFunction = None
  44         # We create an id from the name and the time date in milliseconds
  45         self._id = functionToRun.__name__ +"/"+ str(time.time())
  46
  47     def setFunction(self,functionToRun):
  48         """
  49         Positionne la fonction � ex�cuter. La fonction peut �tre la
  50         m�thode d'un objet pass�e sous la forme 'monobjet.mamethode'.
  51         """
  52         self.clear()
  53         self._function = functionToRun
  54
  55     def setArguments(self,*argv):
  56         """
  57         Positionne les arguments � passer � la fonction
  58         """
  59         self.clear()
  60         self._argv = argv
  61
  62     def getReturn(self):
  63         """
  64         Retourne le resultat de la fonction. En cas d'erreur, on
  65         r�cup�rera l'exception lev�e au moyen de la m�thode
  66         getException().
  67         """
  68         return self._return
  69
  70     def setCallbackFunction(self, callbackFunction):
  71         self._callbackFunction = callbackFunction
  72
  73     def setObserver(self, observerToNotify):
  74         """
  75         Permet de sp�cifier un observateur � notifier en fin
  76         d'ex�cution. L'observateur est suppos� �tre un objet qui
  77         impl�mente une m�thode processNotification()
  78         """
  79         try:
  80             observerToNotify.processNotification
  81         except AttributeError:
  82             raise DevelException("The observer should implement the method processNotification()")
  83
  84         self._observer = observerToNotify
  85
  86     def run(self):
  87         """
  88         Ex�cution de la fonction. Impl�mentation de la m�thode run
  89         d�clench�e par l'appel � Thread.start().
  90         """
  91         print("##################### threadhelper.run")
  92         if self._function is None: return
  93         try:
  94             self._return = self._function(*self._argv)
  95         except Exception as e:
  96             print(e)
  97             self._exception = e
  98         self._stopevent.set()
  99         self.notifyObserver()
 100         self.callback()
 101         # _GBO_ Maybe it's no use to have both observers and a callback function.
 102         # One of the two mechanism should be sufficient
 103
 104     def notifyObserver(self):
 105         if self._observer is None:
 106             # Aucune notification pr�vue
 107             return
 108         try:
 109             self._observer.processNotification()
 110         except AttributeError as att:
 111             if str(att) == "processNotification":
 112                 print("L'observateur n'impl�mente pas la m�thode processNotification()")
 113             else:
 114                 print("La fonction processNotification() a lev� une exception:")
 115                 print(att)
 116         except Exception as e:
 117             print("La fonction processNotification() a lev� une exception:")
 118             print(e)
 119
 120     def callback(self):
 121         if self._callbackFunction is None: return
 122         self._callbackFunction()
 123
 124     def isEnded(self):
 125         """
 126         Retourne true si la fonction s'est termin�e naturellement
 127         (correctement ou en erreur). Utile pour les client qui
 128         pratique le pooling (interrogation r�p�t�e � intervalle
 129         r�gulier.
 130         """
 131         return self._stopevent.isSet()
 132         # _GBO_ On n'utilise pas isAlive() pour pouvoir ma�triser
 133         # l'indicateur de stop (exemple de la fonction kill)
 134         # return not self.isAlive()
 135
 136     def getException(self):
 137         return self._exception
 138
 139     def getId(self):
 140         return self._id
 141
 142     def wait(self,timeout=None):
 143         """
 144         Met fin au thread apr�s timeout seconde s'il est encore en
 145         ex�cution.
 146         Si le compte-�-rebours est atteind sans que la fonction
 147         functionToRun soit termin�e, alors le runner est laiss� dans
 148         l'�tat 'not Ended', c'est-�-dire que isEnded retourne
 149         false. On peut ainsi distinguer l'arr�t normal de l'arr�t �
 150         l'issue du timeout.
 151         """
 152         threading.Thread.join(self, timeout)
 153
 154
 155     def kill(self,message="Arr�t demand�"):
 156         """
 157         Cette m�thode doit �tre appeler pour interrombre le
 158         thread. Cet appel d�clare le thread comme en erreur (exception
 159         mise � disposition par la m�thode getException().
 160         """
 161         # On cr�e un exception indiquant la demande d'interruption
 162         self._exception = Exception(message)
 163         self._stopevent.set()
 164         # _GBO_ ATTENTION
 165         # Un thread python ne peut pas en r�alit� �tre int�rrompu.
 166         # La fonction reste donc en ex�cution m�me si on a rejoint le
 167         # thread appelant.
 168
 169     def clear(self):
 170         self._stopevent.clear()
 171         self._exception = None
 172         self._return    = None
 173
 174 # ===========================================================================
 175 CONTINUE=1
 176 STOP=0
 177
 178 class PeriodicTimer( threading.Thread ):
 179     """
 180     Cette classe permet d'amorcer un compte-�-rebours p�riodique pour
 181     op�rer un m�canisme de pooling. On d�finit la fonction appell�e
 182     p�riodiquement et la fonction terminale.
 183     """
 184     def __init__( self,  loopdelay, initdelay=0,
 185                   periodic_action=None,
 186                   ended_action=None,
 187                   *ended_argv ):
 188
 189         if periodic_action is None:
 190             self._periodic_action = self.defaultPeriodicAction
 191         else:
 192             self._periodic_action = periodic_action
 193         self._ended_action = ended_action
 194         self._loopdelay = loopdelay
 195         self._initdelay = initdelay
 196         self._running = CONTINUE
 197         self._ended_argv    = ended_argv
 198         threading.Thread.__init__( self )
 199
 200     def defaultPeriodicAction():
 201         """
 202         Les fonctions 'periodicAction' retournent CONTINU ou STOP
 203         apr�s avoir ex�cut� l'action de fin de boucle. Si STOP est
 204         retourn�, le cycle est interrompu.
 205         """
 206         return CONTINU
 207
 208     def run( self ):
 209         if self._initdelay:
 210             time.sleep( self._initdelay )
 211         self._runtime = time.time()
 212         while self._running == CONTINUE:
 213             start = time.time()
 214             self._running  = self._periodic_action()
 215             self._runtime += self._loopdelay
 216             time.sleep( max( 0, self._runtime - start ) )
 217         if self._ended_action is not None:
 218             self._ended_action( *self._ended_argv )
 219
 220     def stop( self ):
 221         self._running = STOP
 222
 223
 224
 225 #
 226 # ======================================================
 227 # Fonctions de test unitaire
 228 # ======================================================
 229 #
 230
 231 # ======================================================
 232 import os
 233 testfilename="/tmp/threadhelperTestFile"
 234 def testIfContinue():
 235     print("On examine la pr�sence du fichier ", testfilename)
 236     if os.path.exists(testfilename):
 237         return STOP
 238     else:
 239         return CONTINUE
 240
 241 def endedAction():
 242     print("FINI")
 243
 244 def TEST_PeriodicTimer():
 245     periodicTimer=PeriodicTimer(1,0,testIfContinue, endedAction)
 246     periodicTimer.start()
 247
 248
 249 # ======================================================
 250 def function_ok(nbsteps=5):
 251     """
 252     Fonction qui se termine correctement
 253     """
 254     print("D�but")
 255     cnt=0
 256     while ( cnt < nbsteps ):
 257         print("Etape ", cnt)
 258         time.sleep(0.6)
 259         cnt+=1
 260
 261     print("Fin")
 262
 263 def function_with_exception():
 264     """
 265     Fonction qui aboutie � une lev�e d'exception
 266     """
 267     print("D�but")
 268     cnt=0
 269     while ( cnt < 5 ):
 270         print("Etape ", cnt)
 271         time.sleep(1)
 272         cnt+=1
 273
 274     raise Exception("erreur d'ex�cution de la fonction")
 275     print("Fin")
 276
 277 def infinite_function():
 278     """
 279     fonction de dur�e infinie (tant qu'il y a du courant �l�ctrique) pour
 280     le test du timeout.
 281     """
 282     print("D�but")
 283     cnt=0
 284     while ( 1 ):
 285         print("Etape ", cnt)
 286         time.sleep(1)
 287         cnt+=1
 288
 289     raise Exception("erreur")
 290     print("Fin")
 291
 292
 293 def runWithRunner(functionToRun):
 294     """
 295     Ex�cute la fonction avec le runner. On illustre ici la modalit�
 296     d'utilisation du Runner.
 297     """
 298     print("###########")
 299     runner = Runner(functionToRun)
 300     runner.start()
 301
 302     while ( not runner.isEnded() ):
 303         print("La fonction est en cours")
 304         time.sleep(0.2)
 305     e = runner.getException()
 306     if e is not None:
 307         print("La fonction s'est termin�e en erreur")
 308         print(e)
 309         # On peut en fait la relancer
 310         # raise e
 311     else:
 312         print("La fonction s'est termin�e correctement")
 313
 314
 315 def runWithTimeout(functionToRun, timeout=10):
 316     """
 317     Ex�cute la fonction avec le runner. On illustre ici la modalit�
 318     d'utilisation du Runner.
 319     """
 320     print("runWithTimeout : DEBUT")
 321     runner = Runner(functionToRun)
 322     runner.start()
 323
 324     # On se fixe un temps au del� duquel on consid�re que la fonction
 325     # est en erreur => on tue le thread (timeout)
 326     runner.wait(timeout)
 327     print("Apr�s runner.timeout(timeout)")
 328     if not runner.isEnded():
 329         runner.kill()
 330     e = runner.getException()
 331     if e is not None:
 332         print("La fonction s'est termin�e en erreur")
 333         print(e)
 334         # On peut en fait la relancer
 335         # raise e
 336     else:
 337         print("La fonction s'est termin�e correctement")
 338
 339     print("runWithTimeout : FIN")
 340     import sys
 341     sys.exit(0)
 342
 343
 344 def TEST_Timeout():
 345     #runWithTimeout(function_ok)
 346     #runWithTimeout(function_ok,2)
 347     runWithTimeout(function_with_exception)
 348
 349
 350 def TEST_Runner():
 351     runWithRunner(function_ok)
 352     runWithRunner(function_with_exception)
 353     #runWithRunner(infinite_function)
 354
 355
 356 def myCallbackFunction():
 357     print("myCallbackFunction: the job is ended")
 358
 359
 360 def TEST_runWithCallback():
 361     runner = Runner(function_ok,8)
 362     runner.setCallbackFunction(myCallbackFunction)
 363     runner.start()
 364
 365     if runner.getException() is not None:
 366         return False
 367
 368     runnerId = runner.getId()
 369     print("A runner has been started with id="+str(runnerId))
 370     cpt = 0
 371     while ( not runner.isEnded() ):
 372         print("Waiting notification from process "+str(runner.getId())+", step n°"+str(cpt))
 373         time.sleep(0.2)
 374         cpt+=1
 375
 376     return True
 377
 378 if __name__ == "__main__":
 379     from . import unittester
 380     #TEST_PeriodicTimer()
 381     #TEST_Runner()
 382     #TEST_Timeout()
 383     unittester.run("threadhelper","TEST_runWithCallback")
 384
 385