X-Git-Url: https://git.llucax.com/software/pymin.git/blobdiff_plain/6253fd538884266caab60f3c30a7c1b08a56881b..919343bd2a4fc08c45559e5090f8168dbe9996f3:/pymin/procman.py?ds=sidebyside diff --git a/pymin/procman.py b/pymin/procman.py index 9816997..269117b 100644 --- a/pymin/procman.py +++ b/pymin/procman.py @@ -6,13 +6,13 @@ import signal import subprocess import logging ; log = logging.getLogger('pymin.procman') -__all__ = ('ProcessManager', 'manager', 'register', 'unregister', 'call', - 'start', 'stop', 'kill', 'get', 'has', 'sigchild_handler') +__all__ = ('ProcessManager', 'manager', 'register', 'unregister', 'once', + 'start', 'stop', 'restart', 'kill', 'get', 'has', 'sigchild_handler') class ProcessInfo: def __init__(self, name, command, callback=None, persist=False, max_errors=3, args=None, kwargs=None): - self.name = name + self._name = name self.command = command self.callback = callback if args is None: args = list() @@ -23,23 +23,22 @@ class ProcessInfo: 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.running = False + self._dont_run = False + self._signal = None + self._process = None + self._error_count = 0 def start(self): assert self.process is None self.restart() def restart(self): self.clear() log.debug(u'ProcessInfo.restart(): executing %s', self.command) - self.process = subprocess.Popen(self.command, *self.args, **self.kwargs) - self.running = True + self._process = subprocess.Popen(self.command, + *self.args, **self.kwargs) def stop(self): assert self.process is not None - self.dont_run = True - if self.signal == signal.SIGTERM or self.signal == signal.SIGKILL: + self._dont_run = True + if self._signal == signal.SIGTERM or self._signal == signal.SIGKILL: # Allready stopped, kill it self.kill(signal.SIGKILL) else: @@ -50,14 +49,26 @@ class ProcessInfo: self.process.pid, signum) assert self.process is not None os.kill(self.process.pid, signum) - self.signal = signum + self._signal = signum + @property + def running(self): + return self.process is not None and self.process.poll() is None + @property + def name(self): + return self._name + @property + def process(self): + return self._process + @property + def error_count(self): + return self._error_count def __repr__(self): 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__) + self.callback and self.callback.__name__ or None) class ProcessManager: @@ -67,52 +78,94 @@ class ProcessManager: self.pidmap = dict() log.debug(u'ProcessManager()') - def register(self, name, command, callback=None, persist=False, + def register(self, name, command=None, callback=None, persist=False, max_errors=3, *args, **kwargs): log.debug(u'ProcessManager.register(%s, %s, %s, %s, %s, %s, %s)', name, command, callback, persist, max_errors, args, kwargs) - self.services[name] = ProcessInfo(name, command, callback, persist, - max_errors, args, kwargs) + if not isinstance(name, ProcessInfo): + pi = ProcessInfo(name, command, callback, persist, max_errors, + args, kwargs) + else: + pi = name + name = pi.name + assert not self.has(name) + self.services[name] = pi + return pi def unregister(self, name): log.debug(u'ProcessManager.unregister(%s)', name) + if isinstance(name, ProcessInfo): + pi = name + name = pi.name + else: + pi = self.services[name] del self.services[name] + return pi 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, + def once(self, name, command=None, callback=None, persist=False, max_errors=3, *args, **kwargs): - log.debug(u'ProcessManager.call(%s, %s, %s, %s, %s, %s, %s)', + log.debug(u'ProcessManager.once(%s, %s, %s, %s, %s, %s, %s)', name, command, callback, persist, max_errors, args, kwargs) - pi = ProcessInfo(name, command, callback, persist, max_errors, - args, kwargs) + if not isinstance(name, ProcessInfo): + pi = ProcessInfo(name, command, callback, persist, max_errors, + args, kwargs) + else: + pi = name + name = pi.name + assert not self.has(name) self._call(pi) + return pi def start(self, name): log.debug(u'ProcessManager.start(%s)', name) - assert name not in self.namemap - self._call(self.services[name]) + if isinstance(name, ProcessInfo): + name = name.name + if name not in self.namemap: + self._call(self.services[name]) + return True + return False def stop(self, name): log.debug(u'ProcessManager.stop(%s)', name) - assert name in self.namemap - self.namemap[name].stop() + if isinstance(name, ProcessInfo): + name = name.name + if name in self.namemap: + self.namemap[name].stop() + return True + return False def restart(self, name): log.debug(u'ProcessManager.restart(%s)', name) + if isinstance(name, ProcessInfo): + name = name.name + # we have to check first in namemap in case is an unregistered + # process (added with once()) if name in self.namemap: - self.namemap[name].stop() - self.namemap[name].wait() - self.namemap[name].restart() + pi = self.namemap[name] + # the process will change its PID, so we delete it while we know it + del self.pidmap[pi.process.pid] + pi.stop() + pi.process.wait() + pi.restart() + # add the new PID + self.pidmap[pi.process.pid] = pi + return True else: - self.namemap[name].start() + self.start(name) + return False def kill(self, name, signum): log.debug(u'ProcessManager.kill(%s, %s)', name, signum) - assert name in self.namemap - self.namemap[name].kill(name, stop) + if isinstance(name, ProcessInfo): + name = name.name + if name in self.namemap: + self.namemap[name].kill(name, stop) + return True + return False def sigchild_handler(self, signum, stack_frame=None): log.debug(u'ProcessManager.sigchild_handler(%s)', signum) @@ -134,24 +187,25 @@ class ProcessManager: log.debug(u'ProcessManager.sigchild_handler: ' u'calling %s(%s)', p.callback.__name__, p) p.callback(self, p) - if p.dont_run or not p.persist or p.error_count >= p.max_errors: + if (p._dont_run or not p.persist + or p._error_count >= p.max_errors): log.debug(u"ProcessManager.sigchild_handler: can't " u'persist, dont_run=%s, persist=%s, error_cout=%s, ' - u'max_errors=%s', p.dont_run, p.persist, - p.error_count, p.max_errors) + u'max_errors=%s', p._dont_run, p.persist, + p._error_count, p.max_errors) del self.namemap[p.name] del self.pidmap[pid] p.clear() else: log.debug(u'ProcessManager.sigchild_handler: persist') if p.process.returncode == 0: - p.error_count = 0 + p._error_count = 0 log.debug(u'ProcessManager.sigchild_handler: ' u'return OK, resetting error_count') else: - p.error_count += 1 + p._error_count += 1 log.debug(u'ProcessManager.sigchild_handler: return' - u'not 0, error_count + 1 = %s', p.error_count) + u'not 0, error_count + 1 = %s', p._error_count) del self.pidmap[pid] p.restart() self.pidmap[p.process.pid] = p @@ -172,6 +226,8 @@ class ProcessManager: if name in self.pidmap: return self.pidmap[name] raise KeyError, name + # Syntax sugar for self[name] + __getitem__ = get def has(self, name): if isinstance(name, basestring): # is a name @@ -183,12 +239,8 @@ class ProcessManager: if name in self.pidmap: return True return False - - def __getitem__(self, name): - return self.get(name) - - def __contains__(self, name): - return self.has(name) + # Syntax sugar for name in self + __contains__ = has if __name__ == '__main__': @@ -203,9 +255,10 @@ if __name__ == '__main__': manager = ProcessManager() register = manager.register unregister = manager.unregister -call = manager.call +once = manager.once start = manager.start stop = manager.stop +restart = manager.restart kill = manager.kill get = manager.get has = manager.has @@ -231,24 +284,72 @@ if __name__ == '__main__': print 'test-service count =', count count += 1 if count > 4: - print 'test-service not persistent anymore, start test2' + print 'set test-service non-persistent, start test-service-2' pi.persist = False - pm.start('test2') + assert 'test-service-2' not in manager.namemap + pm.start('test-service-2') + assert 'test-service-2' in manager.namemap + assert get('test-service-2').running print 'died:', pi.name, pi.command register('test-service', ('sleep', '2'), notify, True) - register('test2', ('sleep', '3'), notify, False) + assert 'test-service' in manager.services + assert 'test-service' not in manager.namemap + assert not get('test-service').running + assert manager['test-service'] == get('test-service') + assert has('test-service') + assert 'test-service' in manager + + register('test-service-2', ('sleep', '3'), notify, False) + assert 'test-service-2' in manager.services + assert 'test-service-2' not in manager.namemap + assert not get('test-service-2').running signal.signal(signal.SIGCHLD, SIGCHLD_handler) - call('test', ('sleep', '5'), notify) - start('test-service') + once('test-once', ('sleep', '5'), notify) + assert 'test-once' not in manager.services + assert 'test-once' in manager.namemap + assert get('test-once').running + assert get('test-once').process.pid + pid = get('test-once').process.pid + restart('test-once') + assert pid != get('test-once').process.pid + assert pid != manager.pidmap[get('test-once').process.pid].process.pid - print "Esperando...", [pi.name for pi in manager.namemap.values()] + start('test-service') + assert 'test-service' in manager.namemap + assert get('test-service').running + assert get('test-service').process.pid + pid = get('test-service').process.pid + restart('test-service') + assert pid != get('test-service').process.pid + assert pid != manager.pidmap[get('test-service').process.pid].process.pid + + print "Known processes:", manager.services.keys() + print "Waiting...", manager.namemap.keys() + print "------------------------------------------------------------------" while manager.pidmap: signal.pause() if sig == signal.SIGCHLD: sigchild_handler(sig) sig = None - print "Esperando...", [pi.name for pi in manager.namemap.values()] + print "Known processes:", manager.services.keys() + print "Waiting...", manager.namemap.keys() + print "------------------------------------------------------------------" + assert 'test-service' not in manager.namemap + assert 'test-service-2' not in manager.namemap + assert 'test-once' not in manager.services + assert 'test-once' not in manager.namemap + + restart('test-service') + assert get('test-service').process.pid + assert manager.pidmap[get('test-service').process.pid].process.pid + + once('test-wait', ('sleep', '2')) + print 'test-wait running?', get('test-wait').running + assert get('test-wait').running + print 'Waiting test-wait to return...' + ret = get('test-wait').process.wait() + print 'Done! returned:', ret