Merge lp:~kangol/openobject-server/5.0-monocron into lp:openobject-server/5.0

[Christophe Simonis (OpenERP)]

[Stephane Wirtel (OpenERP) (stephane-openerp)]

Functional: Seems to be good for me

Technical: I think you shoud use some explicit names, because dt, fn, etc... are not readable.

dt -> datetime
ts -> timestamp
fn -> function
ct -> current_thread
etc...

[lp:~kangol/openobject-server/5.0-monocron]

2124. By Christophe Simonis (OpenERP) on 2010-09-16

[IMP] netsvc.Agent: use better variable names

2125. By Christophe Simonis (OpenERP) on 2010-09-16

[IMP] netsvc.Agent: add doctrings

[Olivier Dony (Odoo) (odo-openerp)]

Note: a pass of spellchecking for the documentation could be useful ;-)

review: Approve

[lp:~kangol/openobject-server/5.0-monocron]

2126. By Maxime Glorieux on 2010-09-16

[IMP] netsvc.Agent: correct docstrings

2127. By Christophe Simonis (OpenERP) on 2010-09-17

[FIX] netsvc.Agent: remove tasks from __tasks_by_db

2128. By Christophe Simonis (OpenERP) on 2010-09-20

[FIX] netsvc.Agent: be nice

=== modified file 'bin/netsvc.py'
--- bin/netsvc.py	2010-09-03 16:38:14 +0000
+++ bin/netsvc.py	2010-09-20 11:07:49 +0000
@@ -39,6 +39,7 @@
 import xmlrpclib
 import release
 from pprint import pformat
+import heapq
 
 SERVICES = {}
 GROUPS = {}
@@ -201,34 +202,68 @@
 init_logger()
 
 class Agent(object):
-    _timers = {}
+    """Singleton that keeps track of cancellable tasks to run at a given
+       timestamp.
+       The tasks are caracterised by:
+            * a timestamp
+            * the database on which the task run
+            * the function to call
+            * the arguments and keyword arguments to pass to the function
+
+        Implementation details:
+          Tasks are stored as list, allowing the cancellation by setting
+          the timestamp to 0.
+          A heapq is used to store tasks, so we don't need to sort
+          tasks ourself.
+    """
+    __tasks = []
+    __tasks_by_db = {}
     _logger = Logger()
 
-    def setAlarm(self, fn, dt, db_name, *args, **kwargs):
-        wait = dt - time.time()
-        if wait > 0:
-            self._logger.notifyChannel('timers', LOG_DEBUG, "Job scheduled in %s seconds for %s.%s" % (wait, fn.im_class.__name__, fn.func_name))
-            timer = threading.Timer(wait, fn, args, kwargs)
-            timer.start()
-            self._timers.setdefault(db_name, []).append(timer)
-
-        for db in self._timers:
-            for timer in self._timers[db]:
-                if not timer.isAlive():
-                    self._timers[db].remove(timer)
+    @classmethod
+    def setAlarm(cls, function, timestamp, db_name, *args, **kwargs):
+        task = [timestamp, db_name, function, args, kwargs]
+        heapq.heappush(cls.__tasks, task)
+        cls.__tasks_by_db.setdefault(db_name, []).append(task)
 
     @classmethod
     def cancel(cls, db_name):
-        """Cancel all timers for a given database. If None passed, all timers are cancelled"""
-        for db in cls._timers:
-            if db_name is None or db == db_name:
-                for timer in cls._timers[db]:
-                    timer.cancel()
+        """Cancel all tasks for a given database. If None is passed, all tasks are cancelled"""
+        if db_name is None:
+            cls.__tasks, cls.__tasks_by_db = [], {}
+        else:
+            if db_name in cls.__tasks_by_db:
+                for task in cls.__tasks_by_db[db_name]:
+                    task[0] = 0
 
     @classmethod
     def quit(cls):
         cls.cancel(None)
 
+    @classmethod
+    def runner(cls):
+        """Neverending function (intended to be ran in a dedicated thread) that
+           checks every 60 seconds tasks to run.
+        """
+        current_thread = threading.currentThread()
+        while True:
+            while cls.__tasks and cls.__tasks[0][0] < time.time():
+                task = heapq.heappop(cls.__tasks)
+                timestamp, dbname, function, args, kwargs = task
+                cls.__tasks_by_db[dbname].remove(task)
+                if not timestamp:
+                    # null timestamp -> cancelled task
+                    continue
+                current_thread.dbname = dbname   # hack hack
+                cls._logger.notifyChannel('timers', LOG_DEBUG, "Run %s.%s(*%r, **%r)" % (function.im_class.__name__, function.func_name, args, kwargs))
+                delattr(current_thread, 'dbname')
+                threading.Thread(target=function, args=args, kwargs=kwargs).start()
+                time.sleep(1)
+            time.sleep(60)
+
+threading.Thread(target=Agent.runner).start()
+
+
 import traceback
 
 class xmlrpc(object):