X-Git-Url: https://git.llucax.com/software/pymin.git/blobdiff_plain/296d853cc95fd5bef262248cfe21b507abd26a4f..e69fa50ae7f488fb49641d4a5d98d14428c526b1:/pymin/pymindaemon.py diff --git a/pymin/pymindaemon.py b/pymin/pymindaemon.py index be2c975..6f4fa73 100644 --- a/pymin/pymindaemon.py +++ b/pymin/pymindaemon.py @@ -10,91 +10,171 @@ command-line. import signal import socket +import formencode +import logging ; log = logging.getLogger('pymin.pymindaemon') +from pymin.dispatcher import handler +from pymin import dispatcher from pymin import eventloop from pymin import serializer +from pymin import procman class PyminDaemon(eventloop.EventLoop): - r"""PyminDaemon(bind_addr, routes) -> PyminDaemon instance + r"""PyminDaemon(root, bind_addr) -> PyminDaemon instance This class is well suited to run as a single process. It handles signals for controlled termination (SIGINT and SIGTERM), as well as a user signal to reload the configuration files (SIGUSR1). - bind_addr - is a tuple of (ip, port) where to bind the UDP socket to. + root - the root handler. This is passed directly to the Dispatcher. - routes - is a dictionary where the key is a command string and the value - is the command handler. This is passed directly to the Dispatcher. + bind_addr - is a tuple of (ip, port) where to bind the UDP socket to. Here is a simple usage example: - >>> def test_handler(*args): print 'test:', args - >>> PyminDaemon(('', 9999), dict(test=test_handler)).run() + >>> from pymin import dispatcher + >>> class Root(dispatcher.Handler): + @handler('Test command.') + def test(self, *args): + print 'test:', args + >>> PyminDaemon(Root(), ('', 9999)).run() + + The daemon then will be listening to messages to UDP port 9999. Messages + will be dispatcher throgh the pymin.dispatcher mechanism. If all goes ok, + an OK response is sent. If there was a problem, an ERROR response is sent. + + The general syntax of responses is:: + + (OK|ERROR) LENGTH + CSV MESSAGE + + So, first is a response code (OK or ERROR), then it comes the length of + the CSV MESSAGE (the bufer needed to receive the rest of the message). + + CSV MESSAGE is the body of the response, which it could be void (if lenght + is 0), a simple string (a CVS with only one column and row), a single row + or a full "table" (a CSV with multiple rows and columns). + + There are 2 kind of errors considered "normal": dispatcher.Error and + formencode.Invalid. In general, response bodies of errors are simple + strings, except, for example, for formencode.Invalid errors where an + error_dict is provided. In that case the error is a "table", where the + first colunm is the name of an invalid argument, and the second is the + description of the error for that argument. Any other kind of exception + raised by the handlers will return an ERROR response with the description + "Internal server error". + + All messages (requests and responses) should be UTF-8 encoded and the CVS + responses are formated in "Excel" format, as known by the csv module. """ - def __init__(self, routes=dict(), bind_addr=('', 9999)): + def __init__(self, root, bind_addr=('', 9999), timer=1): r"""Initialize the PyminDaemon object. See PyminDaemon class documentation for more info. """ + log.debug(u'PyminDaemon(%r, %r, %r)', root, bind_addr, timer) + # Timer timeout time + self.timer = timer # Create and bind socket sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind(bind_addr) - # Create EventLoop - eventloop.EventLoop.__init__(self, sock) - # Create Dispatcher - self.dispatcher = Dispatcher(routes) # Signal handling - def quit(signum, frame): - print "Shuting down ..." - self.stop() # tell main event loop to stop - def reload_config(signum, frame): - print "Reloading configuration..." + def quit(loop, signum): + log.debug(u'PyminDaemon quit() handler: signal %r', signum) + log.info(u'Shutting down...') + loop.stop() # tell main event loop to stop + def reload_config(loop, signum): + log.debug(u'PyminDaemon reload_config() handler: signal %r', signum) + log.info(u'Reloading configuration...') # TODO iterate handlers list propagating reload action - signal.signal(signal.SIGINT, quit) - signal.signal(signal.SIGTERM, quit) - signal.signal(signal.SIGUSR1, reload_config) + def timer(loop, signum): + loop.handle_timer() + signal.alarm(loop.timer) + def child(loop, signum): + procman.sigchild_handler(signum) + # Create EventLoop + eventloop.EventLoop.__init__(self, sock, signals={ + signal.SIGINT: quit, + signal.SIGTERM: quit, + signal.SIGUSR1: reload_config, + signal.SIGALRM: timer, + signal.SIGCHLD: child, + }) + # Create Dispatcher + #TODO root.pymin = PyminHandler() + self.dispatcher = dispatcher.Dispatcher(root) def handle(self): r"handle() -> None :: Handle incoming events using the dispatcher." (msg, addr) = self.file.recvfrom(65535) + log.debug(u'PyminDaemon.handle: message %r from %r', msg, addr) + response = u'ERROR' try: - result = self.dispatcher.dispatch(msg) + result = self.dispatcher.dispatch(unicode(msg, 'utf-8')) if result is not None: result = serializer.serialize(result) - response = u'OK ' + response = u'OK' except dispatcher.Error, e: result = unicode(e) + u'\n' - response = u'ERROR ' + except formencode.Invalid, e: + if e.error_dict: + result = serializer.serialize(e.error_dict) + else: + result = unicode(e) + u'\n' except Exception, e: import traceback result = u'Internal server error\n' - traceback.print_exc() # TODO logging! - response = u'ERROR ' + log.exception(u'PyminDaemon.handle: unhandled exception') if result is None: - response += u'0\n' + response += u' 0\n' else: - response += u'%d\n%s' % (len(result), result) - self.file.sendto(response, addr) + response += u' %d\n%s' % (len(result), result) + log.debug(u'PyminDaemon.handle: response %r to %r', response, addr) + self.file.sendto(response.encode('utf-8'), addr) + + def handle_timer(self): + r"handle_timer() -> None :: Call handle_timer() on handlers." + self.dispatcher.root.handle_timer() def run(self): r"run() -> None :: Run the event loop (shortcut to loop())" + log.debug(u'PyminDaemon.loop()') + # Start the timer + self.handle_timer() + signal.alarm(self.timer) + # Loop try: return self.loop() except eventloop.LoopInterruptedError, e: + log.debug(u'PyminDaemon.loop: interrupted') pass if __name__ == '__main__': - @handler(u"Print all the arguments, return nothing.") - def test_handler(*args): - print 'test:', args - - @handler(u"Echo the message passed as argument.") - def echo_handler(message): - print 'echo:', message - return message - - PyminDaemon(dict(test=test_handler, echo=echo_handler)).run() + logging.basicConfig( + level = logging.DEBUG, + format = '%(asctime)s %(levelname)-8s %(message)s', + datefmt = '%H:%M:%S', + ) + + class Scheme(formencode.Schema): + mod = formencode.validators.OneOf(['upper', 'lower'], if_empty='lower') + ip = formencode.validators.CIDR + + class Root(dispatcher.Handler): + @handler(u"Print all the arguments, return nothing.") + def test(self, *args): + print 'test:', args + @handler(u"Echo the message passed as argument.") + def echo(self, message, mod=None, ip=None): + vals = Scheme.to_python(dict(mod=mod, ip=ip)) + mod = vals['mod'] + ip = vals['ip'] + message = getattr(message, mod)() + print 'echo:', message + return message + + PyminDaemon(Root()).run()