Improve ProcessManager to manage registerable named services.

Besides call, now ProcessManager can register (and unregister) named
services. Once registered, they can be started and stopped (or killed if
multiple stop are issued before the process actually dies) at will, just
like regular processes. Processes can be signaled too.

Documentation is still missing.

diff --git a/pymin/procman.py b/pymin/procman.py
index 423ace010cb647720443ee4cf85821ef3c123f05..e0f3017976bb5b112ccfba8cc0d863998ced1f33 100644 (file)
--- a/pymin/procman.py
+++ b/pymin/procman.py
@@ -2,31 +2,91 @@
 
 import os
 import errno
 
 import os
 import errno

+import signal

 import subprocess
 
 class ProcessInfo:
 import subprocess
 
 class ProcessInfo:

-    def __init__(self, name, process, args, kw, callback=None, persist=False):
+    def __init__(self, name, command, callback=None, persist=False,
+                       args=None, kw=None, max_errors=3):

         self.name = name
         self.name = name

-        self.process = process
+        self.command = command
+        self.callback = callback
+        if args is None: args = list()

         self.args = args
         self.args = args

+        if kw is None: kw = dict()

         self.kw = kw
         self.kw = kw

-        self.callback = callback

         self.persist = persist
         self.persist = persist

+        self.max_errors = max_errors
+        self.clear()
+    def clear(self):
+        self.dont_run = False
+        self.signal = None
+        self.process = None
+        self.error_count = 0
+        self.last_return = None
+        self.running = False
+    def start(self):
+        assert self.process is None
+        self.restart()
+    def restart(self):
+        self.clear()
+        self.process = subprocess.Popen(self.command, *self.args, **self.kw)
+        self.running = True
+    def stop(self):
+        assert self.process is not None
+        self.dont_run = True
+        if self.signal == signal.SIGTERM or self.signal == signal.SIGKILL:
+            # Allready stopped, kill it
+            self.kill(signal.SIGKILL)
+        else:
+            # Stop it
+            self.kill(signal.SIGTERM)
+    def kill(self, signum):
+        assert self.process is not None
+        os.kill(pi.process.pid, signum)
+        self.signal = signum

     def __repr__(self):
     def __repr__(self):

-        return 'ProcessInfo(name=%s, pid=%s, persist=%s, cb=%s, args=%s)' % (
-                    self.name, self.process.pid, self.persist,
-                    self.callback.__name__, self.args)
+        pid = None
+        if self.process is not None:
+            pid = self.process.pid
+        return 'ProcessInfo(name=%s, pid=%s command=%s, persist=%s, cb=%s)' % (
+                    self.name, pid, self.command, self.persist,
+                    self.callback.__name__)

 
 class ProcessManager:
 
     def __init__(self):
 
 class ProcessManager:
 
     def __init__(self):

+        self.services = dict()

         self.namemap = dict()
         self.pidmap = dict()
 
         self.namemap = dict()
         self.pidmap = dict()
 

-    def call(self, name, callback, persist, *args, **kw):
-        proc = subprocess.Popen(*args, **kw)
-        procinfo = ProcessInfo(name, proc, args, kw, callback, persist)
-        self.namemap[name] = self.pidmap[proc.pid] = procinfo
+    def register(self, name, command, callback=None, persist=False,
+                       *args, **kw):
+        self.services[name] = ProcessInfo(name, command, callback, persist,
+                                          args, kw)
+
+    def unregister(self, name):
+        del self.services[name]
+
+    def _call(self, pi):
+        pi.start()
+        self.namemap[pi.name] = self.pidmap[pi.process.pid] = pi
+
+    def call(self, name, command, callback=None, persist=False, *args, **kw):
+        pi = ProcessInfo(name, command, callback, persist, args, kw)
+        self._call(pi)
+
+    def start(self, name):
+        assert name not in self.namemap
+        self._call(self.services[name])
+
+    def stop(self, name):
+        assert name in self.namemap
+        self.namemap[name].stop(name)
+
+    def kill(self, name, signum):
+        assert name in self.namemap
+        self.namemap[name].kill(name, stop)

 
     def sigchild_handler(self, signum):
         try:
 
     def sigchild_handler(self, signum):
         try:


@@ -38,12 +98,20 @@ class ProcessManager:
         while pid:
             if pid in self.pidmap:
                 p = self.pidmap[pid]
         while pid:
             if pid in self.pidmap:
                 p = self.pidmap[pid]

-                del self.namemap[p.name]
-                del self.pidmap[pid]

                 if p.callback is not None:
                 if p.callback is not None:

-                    p.callback(p)
-                if p.persist:
-                    self.call(p.name, p.callback, True, *p.args, **p.kw)
+                    p.callback(self, p)
+                if p.dont_run or not p.persist or p.error_count >= p.max_errors:
+                    del self.namemap[p.name]
+                    del self.pidmap[pid]
+                    p.clear()
+                else:
+                    if p.process.returncode == 0:
+                        p.error_count = 0
+                    else:
+                        p.error_count += 1
+                    del self.pidmap[pid]
+                    p.restart()
+                    self.pidmap[p.process.pid] = p

             try:
                 (pid, status) = os.waitpid(-1, os.WNOHANG)
             except OSError, e:
             try:
                 (pid, status) = os.waitpid(-1, os.WNOHANG)
             except OSError, e:


@@ -53,15 +121,25 @@ class ProcessManager:
 
     def __getitem__(self, name):
         if isinstance(name, basestring): # is a name
 
     def __getitem__(self, name):
         if isinstance(name, basestring): # is a name

-            return self.namemap[name]
+            if name in self.namemap:
+                return self.namemap[name]
+            if name in self.services:
+                return self.services[name]

         else: # is a pid
         else: # is a pid

-            return self.pidmap[name]
+            if name in self.pidmap:
+                return self.pidmap[name]
+        return KeyError, name

 
     def __contains__(self, name):
         if isinstance(name, basestring): # is a name
 
     def __contains__(self, name):
         if isinstance(name, basestring): # is a name

-            return name in self.namemap
+            if name in self.namemap:
+                return True
+            if name in self.services:
+                return True

         else: # is a pid
         else: # is a pid

-            return name in self.pidmap
+            if name in self.pidmap:
+                return True
+        return False

 
 
 if __name__ == '__main__':
 
 
 if __name__ == '__main__':


@@ -70,29 +148,38 @@ if __name__ == '__main__':
     import time
 
     sig = None
     import time
 
     sig = None

+    count = 0

 
     def sigchild_handler(signum, stacktrace):
         global sig
         sig = signum
         print 'SIGCHLD', signum
 
 
     def sigchild_handler(signum, stacktrace):
         global sig
         sig = signum
         print 'SIGCHLD', signum
 

-    def test_notify(proc):
-        print 'test died:', proc, proc.name, proc.process.pid
+    def notify(pm, pi):
+        global count
+        if pi.name == 'test-service':
+            print 'test-service count =', count
+            count += 1
+            if count > 4:
+                print 'test-service not persistent anymore, start test2'
+                pi.persist = False
+                pm.start('test2')
+        print 'died:', pi.name, pi.command

 
     procman = ProcessManager()
 
 
     procman = ProcessManager()
 

+    procman.register('test-service', ('sleep', '2'), notify, True)
+    procman.register('test2', ('sleep', '3'), notify, False)
+

     signal.signal(signal.SIGCHLD, sigchild_handler)
 
     signal.signal(signal.SIGCHLD, sigchild_handler)
 

-    procman.call('test', test_notify, True, ('sleep', '5'))
+    procman.call('test', ('sleep', '5'), notify)
+    procman.start('test-service')

 
 

-    while True:
+    while procman.pidmap:

         time.sleep(1)
         time.sleep(1)

-        print "Esperando...",
-        if 'test' in procman:
-            print procman['test']
-        else:
-            print

         if sig == signal.SIGCHLD:
             sig = None
             procman.sigchild_handler(sig)
         if sig == signal.SIGCHLD:
             sig = None
             procman.sigchild_handler(sig)

+        print "Esperando...", [pi.name for pi in procman.namemap.values()]