This commit was manufactured by cvs2svn to create branch

'Release_2_1-maint'.

1 files changed, 270 insertions, 0 deletions

diff --git a/bin/qrunner b/bin/qrunner
new file mode 100644
index 00000000..bb2f62d3
--- /dev/null
+++ b/bin/qrunner
@@ -0,0 +1,270 @@
+#! @PYTHON@
+
+# Copyright (C) 2001,2002 by the Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+"""Run one or more qrunners, once or repeatedly.
+
+Each named runner class is run in round-robin fashion.  In other words, the
+first named runner is run to consume all the files currently in its
+directory.  When that qrunner is done, the next one is run to consume all the
+files in /its/ directory, and so on.  The number of total iterations can be
+given on the command line.
+
+Usage: %(PROGRAM)s [options]
+
+Options:
+
+    -r runner[:slice:range]
+    --runner=runner[:slice:range]
+        Run the named qrunner, which must be one of the strings returned by
+        the -l option.  Optional slice:range if given, is used to assign
+        multiple qrunner processes to a queue.  range is the total number of
+        qrunners for this queue while slice is the number of this qrunner from
+        [0..range).
+
+        If using the slice:range form, you better make sure that each qrunner
+        for the queue is given the same range value.  If slice:runner is not
+        given, then 1:1 is used.
+
+        Multiple -r options may be given, in which case each qrunner will run
+        once in round-robin fashion.  The special runner `All' is shorthand
+        for a qrunner for each listed by the -l option.
+
+    --once
+    -o
+        Run each named qrunner exactly once through its main loop.  Otherwise,
+        each qrunner runs indefinitely, until the process receives a SIGTERM
+        or SIGINT.
+
+    -l/--list
+        Shows the available qrunner names and exit.
+
+    -v/--verbose
+        Spit out more debugging information to the logs/qrunner log file.
+
+    -s/--subproc
+        This should only be used when running qrunner as a subprocess of the
+        mailmanctl startup script.  It changes some of the exit-on-error
+        behavior to work better with that framework.
+
+    -h/--help
+        Print this message and exit.
+
+runner is required unless -l or -h is given, and it must be one of the names
+displayed by the -l switch.
+"""
+
+import sys
+import getopt
+import signal
+
+import paths
+from Mailman import mm_cfg
+from Mailman.i18n import _
+from Mailman.Logging.Syslog import syslog
+from Mailman.Logging.Utils import LogStdErr
+
+PROGRAM = sys.argv[0]
+COMMASPACE = ', '
+
+# Flag which says whether we're running under mailmanctl or not.
+AS_SUBPROC = 0
+
+LogStdErr('error', 'qrunner', manual_reprime=0)
+
+
+
+def usage(code, msg=''):
+    if code:
+        fd = sys.stderr
+    else:
+        fd = sys.stdout
+    print >> fd, _(__doc__)
+    if msg:
+        print >> fd, msg
+    sys.exit(code)
+
+
+
+def make_qrunner(name, slice, range, once=0):
+    modulename = 'Mailman.Queue.' + name
+    try:
+        __import__(modulename)
+    except ImportError, e:
+        if AS_SUBPROC:
+            # Exit with SIGTERM exit code so mailmanctl won't try to restart us
+            print >> sys.stderr, 'Cannot import runner module', modulename
+            print >> sys.stderr, e
+            sys.exit(signal.SIGTERM)
+        else:
+            usage(1, e)
+    qrclass = getattr(sys.modules[modulename], name)
+    if once:
+        # Subclass to hack in the setting of the stop flag in _doperiodic()
+        class Once(qrclass):
+            def _doperiodic(self):
+                self.stop()
+        qrunner = Once(slice, range)
+    else:
+        qrunner = qrclass(slice, range)
+    return qrunner
+
+
+
+def set_signals(loop):
+    # Set up the SIGTERM handler for stopping the loop
+    def sigterm_handler(signum, frame, loop=loop):
+        # Exit the qrunner cleanly
+        loop.stop()
+        loop.status = signal.SIGTERM
+        syslog('qrunner', '%s qrunner caught SIGTERM.  Stopping.', loop.name())
+    signal.signal(signal.SIGTERM, sigterm_handler)
+    # Set up the SIGINT handler for stopping the loop.  For us, SIGINT is
+    # the same as SIGTERM, but our parent treats the exit statuses
+    # differently (it restarts a SIGINT but not a SIGTERM).
+    def sigint_handler(signum, frame, loop=loop):
+        # Exit the qrunner cleanly
+        loop.stop()
+        loop.status = signal.SIGINT
+        syslog('qrunner', '%s qrunner caught SIGINT.  Stopping.', loop.name())
+    signal.signal(signal.SIGINT, sigint_handler)
+    # SIGHUP just tells us to close our log files.  They'll be
+    # automatically reopened at the next log print :)
+    def sighup_handler(signum, frame, loop=loop):
+        syslog.close()
+        syslog('qrunner', '%s qrunner caught SIGHUP.  Reopening logs.',
+               loop.name())
+    signal.signal(signal.SIGHUP, sighup_handler)
+
+
+
+def main():
+    global AS_SUBPROC
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], 'hlor:vs',
+            ['help', 'list', 'once', 'runner=', 'verbose', 'subproc'])
+    except getopt.error, msg:
+        usage(1, msg)
+
+    once = 0
+    runners = []
+    verbose = 0
+    for opt, arg in opts:
+        if opt in ('-h', '--help'):
+            usage(0)
+        elif opt in ('-l', '--list'):
+            for runnername, slices in mm_cfg.QRUNNERS:
+                if runnername.endswith('Runner'):
+                    name = runnername[:-len('Runner')]
+                else:
+                    name = runnername
+                print _('%(name)s runs the %(runnername)s qrunner')
+            print _('All runs all the above qrunners')
+            sys.exit(0)
+        elif opt in ('-o', '--once'):
+            once = 1
+        elif opt in ('-r', '--runner'):
+            runnerspec = arg
+            parts = runnerspec.split(':')
+            if len(parts) == 1:
+                runner = parts[0]
+                slice = 1
+                range = 1
+            elif len(parts) == 3:
+                runner = parts[0]
+                try:
+                    slice = int(parts[1])
+                    range = int(parts[2])
+                except ValueError:
+                    usage(1, 'Bad runner specification: %(runnerspec)s')
+            else:
+                usage(1, 'Bad runner specification: %(runnerspec)s')
+            if runner == 'All':
+                for runnername, slices in mm_cfg.QRUNNERS:
+                    runners.append((runnername, slice, range))
+            else:
+                if runner.endswith('Runner'):
+                    runners.append((runner, slice, range))
+                else:
+                    runners.append((runner + 'Runner', slice, range))
+        elif opt in ('-s', '--subproc'):
+            AS_SUBPROC = 1
+        elif opt in ('-v', '--verbose'):
+            verbose = 1
+
+    if len(args) <> 0:
+        usage(1)
+    if len(runners) == 0:
+        usage(1, _('No runner name given.'))
+
+    # Fast track for one infinite runner
+    if len(runners) == 1 and not once:
+        qrunner = make_qrunner(*runners[0])
+        class Loop:
+            status = 0
+            def __init__(self, qrunner):
+                self.__qrunner = qrunner
+            def name(self):
+                return self.__qrunner.__class__.__name__
+            def stop(self):
+                self.__qrunner.stop()
+        loop = Loop(qrunner)
+        set_signals(loop)
+        # Now start up the main loop
+        syslog('qrunner', '%s qrunner started.', loop.name())
+        qrunner.run()
+        syslog('qrunner', '%s qrunner exiting.', loop.name())
+    else:
+        # Anything else we have to handle a bit more specially
+        qrunners = []
+        for runner, slice, range in runners:
+            qrunner = make_qrunner(runner, slice, range, 1)
+            qrunners.append(qrunner)
+        # This class is used to manage the main loop
+        class Loop:
+            status = 0
+            def __init__(self):
+                self.__isdone = 0
+            def name(self):
+                return 'Main loop'
+            def stop(self):
+                self.__isdone = 1
+            def isdone(self):
+                return self.__isdone
+        loop = Loop()
+        set_signals(loop)
+        syslog('qrunner', 'Main qrunner loop started.')
+        while not loop.isdone():
+            for qrunner in qrunners:
+                # In case the SIGTERM came in the middle of this iteration
+                if loop.isdone():
+                    break
+                if verbose:
+                    syslog('qrunner', 'Now doing a %s qrunner iteration',
+                           qrunner.__class__.__bases__[0].__name__)
+                qrunner.run()
+            if once:
+                break
+        syslog('qrunner', 'Main qrunner loop exiting.')
+    # All done
+    sys.exit(loop.status)
+
+
+
+if __name__ == '__main__':
+    main()