From fa24082ea54cf5de51e865a21db1b1f03f4269d4 Mon Sep 17 00:00:00 2001 From: Michel Albert Date: Fri, 6 Apr 2012 15:51:11 +0200 Subject: [PATCH] Daemonizing and logging added, 'stdin mode' fixed --- tools/pypmmn/pypmmn/daemon.py | 210 +++++++++++++++++++++++++ tools/pypmmn/pypmmn/pypmmn.py | 280 ++++++++++++++++++++++++++-------- 2 files changed, 426 insertions(+), 64 deletions(-) create mode 100644 tools/pypmmn/pypmmn/daemon.py diff --git a/tools/pypmmn/pypmmn/daemon.py b/tools/pypmmn/pypmmn/daemon.py new file mode 100644 index 00000000..f966072a --- /dev/null +++ b/tools/pypmmn/pypmmn/daemon.py @@ -0,0 +1,210 @@ +## {{{ http://code.activestate.com/recipes/278731/ (r6) +"""Disk And Execution MONitor (Daemon) + +Configurable daemon behaviors: + + 1.) The current working directory set to the "/" directory. + 2.) The current file creation mode mask set to 0. + 3.) Close all open files (1024). + 4.) Redirect standard I/O streams to "/dev/null". + +A failed call to fork() now raises an exception. + +References: + 1) Advanced Programming in the Unix Environment: W. Richard Stevens + 2) Unix Programming Frequently Asked Questions: + http://www.erlenstar.demon.co.uk/unix/faq_toc.html +""" + +__author__ = "Chad J. Schroeder" +__copyright__ = "Copyright (C) 2005 Chad J. Schroeder" + +__revision__ = "$Id$" +__version__ = "0.2" + +# Standard Python modules. +import os # Miscellaneous OS interfaces. +import sys # System-specific parameters and functions. + +# Default daemon parameters. +# File mode creation mask of the daemon. +UMASK = 0 + +# Default working directory for the daemon. +WORKDIR = "/" + +# Default maximum for the number of available file descriptors. +MAXFD = 1024 + +# The standard I/O file descriptors are redirected to /dev/null by default. +if (hasattr(os, "devnull")): + REDIRECT_TO = os.devnull +else: + REDIRECT_TO = "/dev/null" + +def createDaemon(): + """Detach a process from the controlling terminal and run it in the + background as a daemon. + """ + + try: + # Fork a child process so the parent can exit. This returns control to + # the command-line or shell. It also guarantees that the child will not + # be a process group leader, since the child receives a new process ID + # and inherits the parent's process group ID. This step is required + # to insure that the next call to os.setsid is successful. + pid = os.fork() + except OSError, e: + raise Exception, "%s [%d]" % (e.strerror, e.errno) + + if (pid == 0): # The first child. + # To become the session leader of this new session and the process group + # leader of the new process group, we call os.setsid(). The process is + # also guaranteed not to have a controlling terminal. + os.setsid() + + # Is ignoring SIGHUP necessary? + # + # It's often suggested that the SIGHUP signal should be ignored before + # the second fork to avoid premature termination of the process. The + # reason is that when the first child terminates, all processes, e.g. + # the second child, in the orphaned group will be sent a SIGHUP. + # + # "However, as part of the session management system, there are exactly + # two cases where SIGHUP is sent on the death of a process: + # + # 1) When the process that dies is the session leader of a session that + # is attached to a terminal device, SIGHUP is sent to all processes + # in the foreground process group of that terminal device. + # 2) When the death of a process causes a process group to become + # orphaned, and one or more processes in the orphaned group are + # stopped, then SIGHUP and SIGCONT are sent to all members of the + # orphaned group." [2] + # + # The first case can be ignored since the child is guaranteed not to have + # a controlling terminal. The second case isn't so easy to dismiss. + # The process group is orphaned when the first child terminates and + # POSIX.1 requires that every STOPPED process in an orphaned process + # group be sent a SIGHUP signal followed by a SIGCONT signal. Since the + # second child is not STOPPED though, we can safely forego ignoring the + # SIGHUP signal. In any case, there are no ill-effects if it is ignored. + # + # import signal # Set handlers for asynchronous events. + # signal.signal(signal.SIGHUP, signal.SIG_IGN) + + try: + # Fork a second child and exit immediately to prevent zombies. This + # causes the second child process to be orphaned, making the init + # process responsible for its cleanup. And, since the first child is + # a session leader without a controlling terminal, it's possible for + # it to acquire one by opening a terminal in the future (System V- + # based systems). This second fork guarantees that the child is no + # longer a session leader, preventing the daemon from ever acquiring + # a controlling terminal. + pid = os.fork() # Fork a second child. + except OSError, e: + raise Exception, "%s [%d]" % (e.strerror, e.errno) + + if (pid == 0): # The second child. + # Since the current working directory may be a mounted filesystem, we + # avoid the issue of not being able to unmount the filesystem at + # shutdown time by changing it to the root directory. + os.chdir(WORKDIR) + # We probably don't want the file mode creation mask inherited from + # the parent, so we give the child complete control over permissions. + os.umask(UMASK) + else: + # exit() or _exit()? See below. + os._exit(0) # Exit parent (the first child) of the second child. + else: + # exit() or _exit()? + # _exit is like exit(), but it doesn't call any functions registered + # with atexit (and on_exit) or any registered signal handlers. It also + # closes any open file descriptors. Using exit() may cause all stdio + # streams to be flushed twice and any temporary files may be unexpectedly + # removed. It's therefore recommended that child branches of a fork() + # and the parent branch(es) of a daemon use _exit(). + os._exit(0) # Exit parent of the first child. + + # Close all open file descriptors. This prevents the child from keeping + # open any file descriptors inherited from the parent. There is a variety + # of methods to accomplish this task. Three are listed below. + # + # Try the system configuration variable, SC_OPEN_MAX, to obtain the maximum + # number of open file descriptors to close. If it doesn't exists, use + # the default value (configurable). + # + # try: + # maxfd = os.sysconf("SC_OPEN_MAX") + # except (AttributeError, ValueError): + # maxfd = MAXFD + # + # OR + # + # if (os.sysconf_names.has_key("SC_OPEN_MAX")): + # maxfd = os.sysconf("SC_OPEN_MAX") + # else: + # maxfd = MAXFD + # + # OR + # + # Use the getrlimit method to retrieve the maximum file descriptor number + # that can be opened by this process. If there is not limit on the + # resource, use the default value. + # + import resource # Resource usage information. + maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1] + if (maxfd == resource.RLIM_INFINITY): + maxfd = MAXFD + + # Iterate through and close all file descriptors. + for fd in range(0, maxfd): + try: + os.close(fd) + except OSError: # ERROR, fd wasn't open to begin with (ignored) + pass + + # Redirect the standard I/O file descriptors to the specified file. Since + # the daemon has no controlling terminal, most daemons redirect stdin, + # stdout, and stderr to /dev/null. This is done to prevent side-effects + # from reads and writes to the standard I/O file descriptors. + + # This call to open is guaranteed to return the lowest file descriptor, + # which will be 0 (stdin), since it was closed above. + os.open(REDIRECT_TO, os.O_RDWR) # standard input (0) + + # Duplicate standard input to standard output and standard error. + os.dup2(0, 1) # standard output (1) + os.dup2(0, 2) # standard error (2) + + return(0) + +if __name__ == "__main__": + + retCode = createDaemon() + + # The code, as is, will create a new file in the root directory, when + # executed with superuser privileges. The file will contain the following + # daemon related process parameters: return code, process ID, parent + # process group ID, session ID, user ID, effective user ID, real group ID, + # and the effective group ID. Notice the relationship between the daemon's + # process ID, process group ID, and its parent's process ID. + + procParams = """ + return code = %s + process ID = %s + parent process ID = %s + process group ID = %s + session ID = %s + user ID = %s + effective user ID = %s + real group ID = %s + effective group ID = %s + """ % (retCode, os.getpid(), os.getppid(), os.getpgrp(), os.getsid(0), + os.getuid(), os.geteuid(), os.getgid(), os.getegid()) + + open("createDaemon.log", "w").write(procParams + "\n") + + sys.exit(retCode) +## end of http://code.activestate.com/recipes/278731/ }}} + diff --git a/tools/pypmmn/pypmmn/pypmmn.py b/tools/pypmmn/pypmmn/pypmmn.py index 53512a8a..88391809 100644 --- a/tools/pypmmn/pypmmn/pypmmn.py +++ b/tools/pypmmn/pypmmn/pypmmn.py @@ -1,20 +1,39 @@ #!/usr/bin/python +from logging.handlers import RotatingFileHandler from optparse import OptionParser -from os import listdir, access, X_OK -from os.path import join, isdir +from os import listdir, access, X_OK, getpid +from os.path import join, isdir, abspath, dirname, exists from subprocess import Popen, PIPE -from socket import gethostname, SHUT_RDWR from time import sleep +import logging +import socket import sys +LOG = logging.getLogger(__name__) +LOG_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' -__version__ = '1.0dev3' +from pypmmn.daemon import createDaemon + + +__version__ = '1.0dev4' class CmdHandler(object): + """ + This handler defines the protocol between munin and this munin node. + Each method starting with ``do_`` responds to the corresponding munin + command. + """ def __init__(self, get_fun, put_fun, options): + """ + Constructor + + :param get_fun: The function used to receive a message from munin + :param put_fun: The function used to send a message back to munin + :param options: The command-line options object + """ self.get_fun = get_fun self.put_fun = put_fun self.options = options @@ -23,6 +42,7 @@ class CmdHandler(object): """ Prints the version of this instance. """ + LOG.debug('Command "version" executed with args: %r' % arg) self.put_fun('# munin node at %s\n' % ( self.options.host, )) @@ -31,26 +51,32 @@ class CmdHandler(object): """ Prints this hostname """ + LOG.debug('Command "nodes" executed with args: %r' % arg) self.put_fun('%s\n' % self.options.host) - self.put_fun('.') + self.put_fun('.\n') def do_quit(self, arg): """ Stops this process """ + LOG.debug('Command "quit" executed with args: %r' % arg) sys.exit(0) def do_list(self, arg): """ Print a list of plugins """ + LOG.debug('Command "list" executed with args: %r' % arg) try: + LOG.debug('Listing files inside %s' % self.options.plugin_dir) for filename in listdir(self.options.plugin_dir): if not access(join(self.options.plugin_dir, filename), X_OK): + LOG.warning('Non-executable plugin %s found!' % filename) continue + #LOG.debug('Found plugin: %s' % filename) self.put_fun("%s " % filename) except OSError, exc: - sys.stdout.write("# ERROR: %s" % exc) + self.put_fun("# ERROR: %s" % exc) self.put_fun("\n") def _caf(self, arg, cmd): @@ -60,7 +86,9 @@ class CmdHandler(object): """ plugin_filename = join(self.options.plugin_dir, arg) if isdir(plugin_filename) or not access(plugin_filename, X_OK): - self.put_fun("# Unknown plugin [%s] for %s" % (arg, cmd)) + msg = "# Unknown plugin [%s] for %s" % (arg, cmd) + LOG.warning(msg) + self.put_fun(msg) return if cmd == 'fetch': @@ -69,29 +97,55 @@ class CmdHandler(object): arg_plugin = cmd try: - output = Popen([plugin_filename, arg_plugin], stdout=PIPE).communicate()[0] + cmd = [plugin_filename, arg_plugin] + LOG.debug('Executing %r' % cmd) + output = Popen(cmd, stdout=PIPE).communicate()[0] except OSError, exc: + LOG.exception() self.put_fun("# ERROR: %s" % exc) return self.put_fun(output) self.put_fun('.\n') def do_alert(self, arg): + """ + Handle command "alert" + """ + LOG.debug('Command "alert" executed with args: %r' % arg) self._caf(arg, 'alert') def do_fetch(self, arg): + """ + Handles command "fetch" + """ + LOG.debug('Command "fetch" executed with args: %r' % arg) self._caf(arg, 'fetch') def do_config(self, arg): + """ + Handles command "config" + """ + LOG.debug('Command "config" executed with args: %r' % arg) self._caf(arg, 'config') def do_cap(self, arg): + """ + Handles command "cap" + """ + LOG.debug('Command "cap" executed with args: %r' % arg) self.put_fun("cap ") if self.options.spoolfetch_dir: self.put_fun("spool") - self.put_fun("cap \n") + else: + LOG.debug('No spoolfetch_dir specified. Result spooling disabled') + + self.put_fun("\n") def do_spoolfetch(self, arg): + """ + Handles command "spoolfetch" + """ + LOG.debug('Command "spellfetch" executed with args: %r' % arg) output = Popen(['%s/spoolfetch_%s' % (self.options.spoolfetch_dir, self.options.host), arg]).communicate()[0] @@ -101,8 +155,10 @@ class CmdHandler(object): # aliases do_exit = do_quit - def handle_input(self, line): + """ + Handles one input line and sends any result back using ``put_fun`` + """ line = line.strip() line = line.split(' ') cmd = line[0] @@ -111,7 +167,8 @@ class CmdHandler(object): elif len(line) == 2: arg = line[1] else: - raise ValueError('Invalid input: %s' % line) + self.put_fun('# Invalid input: %s\n' % line) + return if not cmd: return @@ -119,7 +176,8 @@ class CmdHandler(object): func = getattr(self, 'do_%s' % cmd, None) if not func: commands = [_[3:] for _ in dir(self) if _.startswith('do_')] - self.put_fun("# Unknown command. Supported commands: %s" % commands) + self.put_fun("# Unknown command. Supported commands: %s\n" % ( + commands)) return func(arg) @@ -144,75 +202,169 @@ def get_options(): ' Default: /plugins')) parser.add_option('-h', '--host', dest='host', help=('The hostname which will be reported in the plugins.' - ' Default: %s' % gethostname()), - default=gethostname()) + ' Default: %s' % socket.gethostname()), + default=socket.gethostname()) + parser.add_option('-n', '--no-daemon', dest='no_daemon', + default=False, + action='store_true', + help='Run in foreground. Do not daemonize. ' + 'Will also enable debug logging to stdout.') + parser.add_option('-l', '--log-dir', dest='log_dir', + default=None, + help='The log folder. Default: disabled') parser.add_option('-s', '--spoolfech-dir', dest='spoolfetch_dir', default=None, help='The spoolfetch folder. Default: disabled') parser.add_option('--help', action='callback', callback=usage, help='Shows this help') - return parser.parse_args() + + options, args = parser.parse_args() + + # ensure we are using absolute paths (for daemonizing) + if options.log_dir: + options.log_dir = abspath(options.log_dir) + + if options.spoolfetch_dir: + options.spoolfetch_dir = abspath(options.spoolfetch_dir) + + if options.plugin_dir: + options.plugin_dir = abspath(options.plugin_dir) + + return (options, args) -def main(): - options, args = get_options() - handler = CmdHandler(None, None, options) - if not options.port: - handler.get_fun = sys.stdin.read - handler.put_fun = sys.stdout.write - else: - import socket - host = '' - port = int(options.port) - s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) - s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) - s.bind((host, port)) - s.listen(1) +def process_stdin(options): + rfhandler = RotatingFileHandler( + join(abspath(dirname(__file__)), 'log', 'pypmmn.log'), + maxBytes=100 * 1024, + backupCount=5 + ) + rfhandler.setFormatter(logging.Formatter(LOG_FORMAT)) + logging.getLogger().addHandler(rfhandler) + handler = CmdHandler(sys.stdin.read, sys.stdout.write, options) + handler.do_version(None) + LOG.info('STDIN handler opened') + while True: + data = sys.stdin.readline().strip() + handler.handle_input(data) - conn, addr = s.accept() - handler.get_fun = conn.recv - handler.put_fun = conn.send - handler.do_version(None) - counter = 0 - print 'Connected by', addr - while True: - data = conn.recv(1024) - if not data.strip(): - sleep(1) - counter += 1 - if counter > 3: - conn.shutdown(SHUT_RDWR) - conn.close() - conn, addr = s.accept() - counter = 0 - handler.get_fun = conn.recv - handler.put_fun = conn.send - handler.do_version(None) - print "sleep" - try: - data = conn.recv(1024) - print 'data2', `data` - except socket.error, exc: - conn, addr = s.accept() - counter = 0 - handler.get_fun = conn.recv - handler.put_fun = conn.send - handler.do_version(None) - print "Socket error: %s" % exc +def process_socket(options): - if data.strip() == 'quit': - print 'shutting down remote connection' - conn.shutdown(SHUT_RDWR) + if options.no_daemon: + # set up on-screen-logging + console_handler = logging.StreamHandler(sys.stdout) + console_handler.setFormatter(logging.Formatter(LOG_FORMAT)) + logging.getLogger().addHandler(console_handler) + + retcode = 0 + if not options.no_daemon: + retcode = createDaemon() + rfhandler = RotatingFileHandler( + join(options.log_dir, 'daemon.log'), + maxBytes=100 * 1024, + backupCount=5 + ) + rfhandler.setFormatter(logging.Formatter(LOG_FORMAT)) + logging.getLogger().addHandler(rfhandler) + LOG.info('Process PID: %d' % getpid()) + pidfile = open(join(options.log_dir, 'pypmmn.pid'), 'w') + pidfile.write(str(getpid())) + pidfile.close() + LOG.info('PID file created in %s' % join(options.log_dir, + 'pypmmn.pid')) + + LOG.info('Socket handler started.') + + host = '' + port = int(options.port) + s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + s.bind((host, port)) + s.listen(1) + + LOG.info('Listening on host %r, port %r' % (host, port)) + + conn, addr = s.accept() + handler = CmdHandler(conn.recv, conn.send, options) + handler.do_version(None) + counter = 0 + + LOG.info("Accepting incoming connection from %s" % (addr, )) + while True: + data = conn.recv(1024) + if not data.strip(): + sleep(1) + counter += 1 + if counter > 3: + LOG.info('Session timeout.') + conn.shutdown(socket.SHUT_RDWR) conn.close() + + LOG.info('Listening on host %r, port %r' % (host, port)) + conn, addr = s.accept() counter = 0 handler.get_fun = conn.recv handler.put_fun = conn.send handler.do_version(None) - continue - handler.handle_input(data) + LOG.info("Accepting incoming connection from %s" % (addr, )) + try: + data = conn.recv(1024) + except socket.error, exc: + LOG.warning("Socket error. Reinitialising.: %s" % exc) + conn, addr = s.accept() + counter = 0 + handler.get_fun = conn.recv + handler.put_fun = conn.send + handler.do_version(None) + + LOG.info("Accepting incoming connection from %s" % (addr, )) + + if data.strip() == 'quit': + LOG.info('Client requested session end. Closing connection.') + conn.shutdown(socket.SHUT_RDWR) + conn.close() + + LOG.info('Listening on host %r, port %r' % (host, port)) + + conn, addr = s.accept() + counter = 0 + handler.get_fun = conn.recv + handler.put_fun = conn.send + handler.do_version(None) + + LOG.info("Accepting incoming connection from %s" % (addr, )) + + continue + + handler.handle_input(data) + + sys.exit(retcode) + + +def main(): + """ + The main entry point of the application + """ + options, args = get_options() + + # Handle logging as early as possible. + if options.log_dir: + if not exists(options.log_dir): + raise IOError('[Errno 2] No such file or directory: %r' % ( + options.log_dir)) + # set up logging if requested + root_logger = logging.getLogger() + root_logger.setLevel(logging.NOTSET) # TODO: Make configurable + + # Start either the "stdin" interface, or the socked daemon. Depending on + # whether a port was given on startup or not. + if not options.port: + process_stdin(options) + else: + process_socket(options) if __name__ == '__main__':