X-Git-Url: https://git.llucax.com/software/pymin.git/blobdiff_plain/2de15b2c62a45af56ffcfb3d4aa8e5e60377bd72..af3261630a29ae3ee1f4c9a4eb574998b3e1a47b:/pymin/procman.py?ds=inline diff --git a/pymin/procman.py b/pymin/procman.py index 423ace0..dfa7873 100644 --- a/pymin/procman.py +++ b/pymin/procman.py @@ -2,48 +2,157 @@ import os import errno +import signal import subprocess +import logging ; log = logging.getLogger('pymin.procman') + +__ALL__ = ('ProcessManager', 'manager', 'register', 'unregister', 'call', + 'start', 'stop', 'kill', 'get', 'has', 'sigchild_handler') 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.process = process + self.command = command + self.callback = callback + if args is None: args = list() self.args = args + if kw is None: kw = dict() self.kw = kw - self.callback = callback 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.running = False + 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.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): + log.debug(u'ProcessInfo.kill(): killing pid %s with signal %s', + self.process.pid, signum) + assert self.process is not None + os.kill(self.process.pid, signum) + self.signal = signum 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): + self.services = dict() self.namemap = dict() self.pidmap = dict() + log.debug(u'ProcessManager()') + + def register(self, name, command, callback=None, persist=False, + *args, **kw): + log.debug(u'ProcessManager.register(%s, %s, %s, %s, %s, %s)', + name, command, callback, persist, args, kw) + self.services[name] = ProcessInfo(name, command, callback, persist, + args, kw) + + def unregister(self, name): + log.debug(u'ProcessManager.unregister(%s)', 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): + log.debug(u'ProcessManager.call(%s, %s, %s, %s, %s, %s)', + name, command, callback, persist, args, kw) + pi = ProcessInfo(name, command, callback, persist, args, kw) + self._call(pi) + + def start(self, name): + log.debug(u'ProcessManager.start(%s)', name) + assert name not in self.namemap + self._call(self.services[name]) + + def stop(self, name): + log.debug(u'ProcessManager.stop(%s)', name) + assert name in self.namemap + self.namemap[name].stop() + + def restart(self, name): + log.debug(u'ProcessManager.restart(%s)', name) + if name in self.namemap: + self.namemap[name].stop() + self.namemap[name].wait() + self.namemap[name].restart() + else: + self.namemap[name].start() - 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 kill(self, name, signum): + log.debug(u'ProcessManager.kill(%s, %s)', name, signum) + assert name in self.namemap + self.namemap[name].kill(name, stop) - def sigchild_handler(self, signum): + def sigchild_handler(self, signum, stack_frame=None): + log.debug(u'ProcessManager.sigchild_handler(%s)', signum) try: (pid, status) = os.waitpid(-1, os.WNOHANG) except OSError, e: - if e.errno is e.ECHILD: + log.debug(u'ProcessManager.sigchild_handler(): OSError') + if e.errno is errno.ECHILD: + log.debug(u'ProcessManager.sigchild_handler(): OSError ECHILD') return raise + log.debug(u'ProcessManager.sigchild_handler: pid=%s, status=%s', + pid, status) while pid: if pid in self.pidmap: p = self.pidmap[pid] - del self.namemap[p.name] - del self.pidmap[pid] + p.process.returncode = status if p.callback is not None: - p.callback(p) - if p.persist: - self.call(p.name, p.callback, True, *p.args, **p.kw) + 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: + 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) + 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 + log.debug(u'ProcessManager.sigchild_handler: ' + u'return OK, resetting error_count') + else: + p.error_count += 1 + log.debug(u'ProcessManager.sigchild_handler: return' + u'not 0, error_count + 1 = %s', p.error_count) + del self.pidmap[pid] + p.restart() + self.pidmap[p.process.pid] = p try: (pid, status) = os.waitpid(-1, os.WNOHANG) except OSError, e: @@ -51,17 +160,54 @@ class ProcessManager: return raise - def __getitem__(self, name): + def get(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 - return self.pidmap[name] + if name in self.pidmap: + return self.pidmap[name] + raise KeyError, name - def __contains__(self, name): + def has(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 - return name in self.pidmap + 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) + + +if __name__ == '__main__': + logging.basicConfig( + level = logging.DEBUG, + format = '%(asctime)s %(levelname)-8s %(message)s', + datefmt = '%H:%M:%S', + ) + + +# Globals +manager = ProcessManager() +register = manager.register +unregister = manager.unregister +call = manager.call +start = manager.start +stop = manager.stop +kill = manager.kill +get = manager.get +has = manager.has +sigchild_handler = manager.sigchild_handler if __name__ == '__main__': @@ -70,29 +216,37 @@ if __name__ == '__main__': import time sig = None + count = 0 - def sigchild_handler(signum, stacktrace): + def SIGCHLD_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() + register('test-service', ('sleep', '2'), notify, True) + register('test2', ('sleep', '3'), notify, False) - signal.signal(signal.SIGCHLD, sigchild_handler) + signal.signal(signal.SIGCHLD, SIGCHLD_handler) - procman.call('test', test_notify, True, ('sleep', '5')) + call('test', ('sleep', '5'), notify) + start('test-service') - while True: - time.sleep(1) - print "Esperando...", - if 'test' in procman: - print procman['test'] - else: - print + print "Esperando...", [pi.name for pi in manager.namemap.values()] + while manager.pidmap: + signal.pause() if sig == signal.SIGCHLD: + sigchild_handler(sig) sig = None - procman.sigchild_handler(sig) + print "Esperando...", [pi.name for pi in manager.namemap.values()]