oops, branching gone wrong

git-svn-id: svn+ssh://svn.fedorahosted.org/svn/sos/trunk@224 ef72aa8b-4018-0410-8976-d6e080ef94d8

1 files changed, 0 insertions, 725 deletions

diff --git a/trunk/src/sosreport b/trunk/src/sosreport
deleted file mode 100755
index 86d66b4d..00000000
--- a/trunk/src/sosreport
+++ /dev/null
@@ -1,725 +0,0 @@
-#!/usr/bin/env python
-"""
-Gather information about a system and report it using plugins
-supplied for application-specific information
-"""
-## sosreport.py
-## gather information about a system and report it
-
-## Copyright (C) 2006 Steve Conklin <sconklin@redhat.com>
-
-### 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., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-# pylint: disable-msg = W0611
-# pylint: disable-msg = W0702
-
-import sys
-import os
-#import curses
-from optparse import OptionParser, Option
-import sos.policyredhat
-from sos.helpers import *
-from snack import *
-from threading import Thread, activeCount, enumerate
-import signal
-import logging
-from stat import *
-from time import strftime, localtime, time
-from pwd import getpwuid
-import gettext
-from threading import Semaphore
-
-__version__ = 1.7
-
-__breakHits__ = 0  # Use this to track how many times we enter the exit routine
-
-## Set up routines to be linked to signals for termination handling
-def exittermhandler(signum, frame):
-    doExitCode()
-
-def doExitCode():
-    global __breakHits__
-    __breakHits__ += 1
-    if ( ( activeCount() > 1 ) and ( __breakHits__ == 1 ) ):
-        print "SIGTERM received, multiple threads detected, waiting for all threads to exit"
-        for thread in enumerate():
-            if thread.getName() != "MainThread":
-               thread.join()
-        print "All threads ended, cleaning up."
-    if ( ( activeCount() > 1 ) and ( __breakHits__ > 1 ) ):
-        print "Multiple SIGTERMs, multiple threads, attempting to signal threads to die immediately"
-        ## FIXME: Add thread-kill code (see FIXME below)
-        print "Threads dead, cleaning up."
-    if ( ( activeCount() == 1 ) and ( __breakHits__ > 2 ) ):
-        print "Multiple SIGTERMs, single thread, exiting without cleaning up."
-        sys.exit(3)
-
-    # FIXME: Add code here to clean up /tmp
-    sys.exit("Abnormal exit")
-    
-# Handle any sort of exit signal cleanly
-# Currently, we intercept only sig 15 (TERM)
-signal.signal(signal.SIGTERM, exittermhandler)
-
-## FIXME: Need to figure out how to IPC with child threads in case of
-## multiple SIGTERMs.
-## FIXME: Need to figure out how to handle SIGKILL - we can't intercept it.
-
-# for debugging
-__raisePlugins__ = 1
-
-class SosOption (Option):
-    """Allow to specify comma delimited list of plugins"""
-    ACTIONS = Option.ACTIONS + ("extend",)
-    STORE_ACTIONS = Option.STORE_ACTIONS + ("extend",)
-    TYPED_ACTIONS = Option.TYPED_ACTIONS + ("extend",)
-
-    def take_action(self, action, dest, opt, value, values, parser):
-        if action == "extend":
-            try: lvalue = value.split(",")
-            except: pass
-            else: values.ensure_value(dest, []).extend(lvalue)
-        else:
-            Option.take_action(self, action, dest, opt, value, values, parser)
-
-__cmdParser__ = OptionParser(option_class=SosOption)
-__cmdParser__.add_option("-a", "--alloptions", action="store_true", \
-                     dest="usealloptions", default=False, \
-                     help="Use all options for loaded plugins")
-__cmdParser__.add_option("-f", "--fastoptions", action="store_true", \
-                     dest="fastoptions", default=False, \
-                     help="Use only fast options for loaded plugins")
-__cmdParser__.add_option("-g", "--gatheronly", action="store_true", \
-                     dest="gatheronly", default=False, \
-                     help="Gather information locally but don't package or submit")
-__cmdParser__.add_option("-l", "--list-plugins", action="store_true", \
-                     dest="listPlugins", default=False, \
-                     help="list existing plugins")
-__cmdParser__.add_option("-n", "--noplugin", action="extend", \
-                     dest="noplugins", type="string", \
-                     help="skip these plugins", default = [])
-__cmdParser__.add_option("-o", "--onlyplugin", action="extend", \
-                     dest="onlyplugins", type="string", \
-                     help="enable these plugins only", default = [])
-__cmdParser__.add_option("-e", "--enableplugin", action="extend", \
-                     dest="enableplugins", type="string", \
-                     help="list of inactive plugins to be enabled", default = [])
-__cmdParser__.add_option("-k", "--pluginopts", action="extend", \
-                     dest="plugopts", type="string", \
-                     help="plugin options in plugin_name.option=value format")
-__cmdParser__.add_option("-v", "--verbose", action="count", \
-                     dest="verbosity", \
-                     help="How obnoxious we're being about telling the user what we're doing.")
-__cmdParser__.add_option("-c", "--curses", action="store_true", \
-                     dest="use_curses", default=False, \
-                     help="Display a text GUI menu to modify plugin options.")
-__cmdParser__.add_option("--no-progressbar", action="store_false", \
-                     dest="progressbar", default=True, \
-                     help="Do not display a progress bar.")
-__cmdParser__.add_option("--no-multithread", action="store_true", \
-                     dest="nomultithread", \
-                     help="Disable multi-threaded gathering mode (slower)", default=False)
-(__cmdLineOpts__, __cmdLineArgs__)=__cmdParser__.parse_args()
-
-def textcolor(text, fg, bg=None, raw=0):
-    colors = {  "black":"30", "red":"31", "green":"32", "brown":"33", "blue":"34",
-		"purple":"35", "cyan":"36", "lgray":"37", "gray":"1;30", "lred":"1;31",
-		"lgreen":"1;32", "yellow":"1;33", "lblue":"1;34", "pink":"1;35",
-		"lcyan":"1;36", "white":"1;37" }
-    opencol = "\033["
-    closecol = "m"
-    clear = opencol + "0" + closecol
-    f = opencol + colors[fg] + closecol
-    return "%s%s%s" % (f, text, clear)
-
-def get_curse_options(alloptions):
-    """
-    use curses to enable the user to select some options
-    """
-    # alloptions is an array of (plug, plugname, optname, parms(dictionary)) tuples
-    plugName = []
-    out = []
-    
-    # get a sorted list of all plugin names
-    for rrr in alloptions:
-        if rrr[1] not in plugName:
-            plugName.append(rrr[1])
-
-    plugName.sort()
-    plugCbox = CheckboxTree(height=5, scroll=1)
-
-    countOpt = -1
-
-    optDic = {}
-    optDicCounter = 0
-
-    # iterate over all plugins with options
-    for curPlugName in plugName:
-        plugCbox.addItem(curPlugName, (snackArgs['append'],))
-        countOpt = countOpt+1
-
-        for opt in alloptions:
-            if opt[1] != curPlugName:
-                continue
-
-            snt = opt[2] + " ("+opt[3]['desc']+") is " + opt[3]['speed']
-            plugCbox.addItem(snt, (countOpt, snackArgs['append']), item = optDicCounter, selected = opt[3]['enabled'])
-            optDic[optDicCounter] = opt
-            optDicCounter += 1
-            
-
-    screen = SnackScreen()
-    bb = ButtonBar(screen, (("Ok", "ok"), ("Cancel", "cancel")))
-    g = GridForm(screen, "Select Sosreport Options", 1, 10)
-    g.add(plugCbox, 0, 0)
-    g.add(bb, 0, 1, growx = 1)
-    result = g.runOnce()
-
-    screen.finish()
-
-    if bb.buttonPressed(result) == "cancel":
-        raise "Cancelled"
-
-    for rrr in range(0, optDicCounter):
-        optDic[rrr][3]['enabled'] =  plugCbox.getEntryValue(rrr)[1]
-        out.append((optDic[rrr]))
-
-    return out
-
-class progressBar:
-    def __init__(self, minValue = 0, maxValue = 10, totalWidth=40):
-        self.progBar = "[]"   # This holds the progress bar string
-        self.min = minValue
-        self.max = maxValue
-        self.width = totalWidth
-        self.amount = 0       # When amount == max, we are 100% done
-        self.time_start = time()
-        self.eta = 0
-        self.last_amount_update = time()
-        self.update()
-
-    def updateAmount(self, newAmount = 0):
-        if newAmount < self.min: newAmount = self.min
-        if newAmount > self.max: newAmount = self.max
-        if self.amount != newAmount:
-            self.last_amount_update = time()
-            self.amount = newAmount
-            last_update_relative = round(self.last_amount_update - self.time_start)
-            self.eta = round(last_update_relative * self.max / self.amount)
-
-        # generate ETA
-        timeElapsed = round(time() - self.time_start)
-        last_update_relative = round(self.last_amount_update - self.time_start)
-        if timeElapsed >= 10 and self.amount > 0:
-            percentDone = round(timeElapsed * 100 / self.eta)
-            if percentDone > 100:
-               percentDone = 100
-               ETA = timeElapsed
-            elif self.eta < timeElapsed:
-               ETA = timeElapsed
-            else:
-               ETA = self.eta
-            ETA = "[%02d:%02d/%02d:%02d]" % (round(timeElapsed/60), timeElapsed % 60, round(ETA/60), ETA % 60)
-        else:
-            ETA = "[%02d:%02d/--:--]" % (round(timeElapsed/60), timeElapsed % 60)
-            if self.amount < self.max:
-               percentDone = 0
-            else:
-               percentDone = 100
-
-        # Figure out how many hash bars the percentage should be
-        allFull = self.width - 2
-        numHashes = (percentDone / 100.0) * allFull
-        numHashes = int(round(numHashes))
-
-        # build a progress bar with hashes and spaces
-        self.progBar = " [" + '#'*numHashes + ' '*(allFull-numHashes) + "]"
-
-        # figure out where to put the percentage, roughly centered
-        percentPlace = (len(self.progBar) / 2) - len(str(percentDone)) 
-        percentString = str(percentDone) + "%"
-
-        # slice the percentage into the bar
-        self.progBar = " Progress" + self.progBar[0:percentPlace] + percentString + self.progBar[percentPlace+len(percentString):] + ETA
-
-    def incAmount(self, toInc = 1):
-        self.updateAmount(self.amount+toInc)
-
-    def finished(self):
-        self.updateAmount(self.max)
-        sys.stdout.write(self.progBar + '\n')
-        sys.stdout.flush()
-
-    def update(self):
-        self.updateAmount(self.amount)
-        sys.stdout.write(self.progBar + '\r')
-        sys.stdout.flush()
-
-class XmlReport:
-    def __init__(self):
-        try:
-            import libxml2
-        except:
-            self.enabled = False
-            return
-        else:
-            self.enabled = True
-        self.doc = libxml2.newDoc("1.0")
-        self.root = self.doc.newChild(None, "sos", None)
-        self.commands = self.root.newChild(None, "commands", None)
-        self.files = self.root.newChild(None, "files", None)
-
-    def add_command(self,cmdline,exitcode,stdout = None,stderr = None,f_stdout=None,f_stderr=None, runtime=None):
-        if not self.enabled: return
-
-        cmd = self.commands.newChild(None, "cmd", None)
-
-        cmd.setNsProp(None, "cmdline", cmdline)
-
-        cmdchild = cmd.newChild(None, "exitcode", str(exitcode))
-
-        if runtime:
-            cmd.newChild(None, "runtime", str(runtime))
-
-        if stdout or f_stdout:
-            cmdchild = cmd.newChild(None, "stdout", stdout)
-            if f_stdout:
-                cmdchild.setNsProp(None, "file", f_stdout)
-
-        if stderr or f_stderr:
-            cmdchild = cmd.newChild(None, "stderr", stderr)
-            if f_stderr:
-                cmdchild.setNsProp(None, "file", f_stderr)
-
-    def add_file(self,fname,stats):
-        if not self.enabled: return
-
-        cfile = self.files.newChild(None,"file",None)
-
-        cfile.setNsProp(None, "fname", fname)
-
-        cchild = cfile.newChild(None, "uid", str(stats[ST_UID]))
-        cchild.setNsProp(None,"name", getpwuid(stats[ST_UID])[0])
-        cchild = cfile.newChild(None, "gid", str(stats[ST_GID]))
-        cchild.setNsProp(None,"name", getpwuid(stats[ST_GID])[0])
-        cfile.newChild(None, "mode", str(oct(S_IMODE(stats[ST_MODE]))))
-        cchild = cfile.newChild(None, "ctime", strftime('%a %b %d %H:%M:%S %Y', localtime(stats[ST_CTIME])))
-        cchild.setNsProp(None,"tstamp", str(stats[ST_CTIME]))
-        cchild = cfile.newChild(None, "atime", strftime('%a %b %d %H:%M:%S %Y', localtime(stats[ST_ATIME])))
-        cchild.setNsProp(None,"tstamp", str(stats[ST_ATIME]))
-        cchild = cfile.newChild(None, "mtime", strftime('%a %b %d %H:%M:%S %Y', localtime(stats[ST_MTIME])))
-        cchild.setNsProp(None,"tstamp", str(stats[ST_MTIME]))
-
-    def serialize(self):
-        if not self.enabled: return
-
-        print self.doc.serialize(None,  1)
-
-    def serialize_to_file(self,fname):
-        if not self.enabled: return
-
-        outfn = open(fname,"w")
-        outfn.write(self.doc.serialize(None,1))
-        outfn.close()
-
-def sosreport():
-    # pylint: disable-msg = R0912
-    # pylint: disable-msg = R0914
-    # pylint: disable-msg = R0915
-    """
-    This is the top-level function that gathers and processes all sosreport information
-    """
-    loadedplugins = []
-    skippedplugins = []
-    alloptions = []
-
-    # perhaps we should automatically locate the policy module??
-    policy = sos.policyredhat.SosPolicy()
-
-    # find the plugins path
-    paths = sys.path
-    for path in paths:
-        if  path.strip()[-len("site-packages"):] == "site-packages":
-            pluginpath = path + "/sos/plugins"
-            reporterpath = path + "/sos/reporters"
-
-    # Set up common info and create destinations
-    
-    dstroot = sosFindTmpDir()
-    cmddir = os.path.join(dstroot, "sos_commands")
-    logdir = os.path.join(dstroot, "sos_logs")
-    rptdir = os.path.join(dstroot, "sos_reports")
-    os.mkdir(cmddir, 0755)
-    os.mkdir(logdir, 0755)
-    os.mkdir(rptdir, 0755)
-
-    # initialize i18n language localization
-    gettext.install('sos', '/usr/share/locale', unicode=False) 
-
-    # initialize logging
-    soslog = logging.getLogger('sos')
-    soslog.setLevel(logging.DEBUG)
-
-    # log to a file
-    flog = logging.FileHandler(logdir + "/sos.log")
-    flog.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: %(message)s'))
-    flog.setLevel(logging.DEBUG)
-    soslog.addHandler(flog)
-
-    # define a Handler which writes INFO messages or higher to the sys.stderr
-    console = logging.StreamHandler(sys.stderr)
-    if __cmdLineOpts__.verbosity > 0:
-        console.setLevel(20 - __cmdLineOpts__.verbosity)
-        __cmdLineOpts__.progressbar = False
-    else:
-        console.setLevel(logging.INFO)
-    console.setFormatter(logging.Formatter('%(message)s'))
-    soslog.addHandler(console)
-
-    logging.VERBOSE  = logging.INFO - 1
-    logging.VERBOSE2 = logging.INFO - 2
-    logging.VERBOSE3 = logging.INFO - 3 
-    logging.addLevelName(logging.VERBOSE, "verbose")
-    logging.addLevelName(logging.VERBOSE2,"verbose2")
-    logging.addLevelName(logging.VERBOSE3,"verbose3")
-
-    xmlrep = XmlReport()
-
-    # set up dict so everyone can share the following
-    commons = {'dstroot': dstroot, 'cmddir': cmddir, 'logdir': logdir, 'rptdir': rptdir,
-               'soslog': soslog, 'policy': policy, 'verbosity' : __cmdLineOpts__.verbosity,
-               'xmlreport' : xmlrep }
-
-    # Make policy aware of the commons
-    policy.setCommons(commons)
-
-    print
-    soslog.info ( _("sosreport (version %s)") % __version__)
-    print
-    
-    # generate list of available plugins
-    plugins = os.listdir(pluginpath)
-    plugins.sort()
-
-    # validate and load plugins
-    for plug in plugins:
-        plugbase =  plug[:-3]
-        if not plug[-3:] == '.py' or plugbase == "__init__":
-            continue
-        try:
-            #print "importing plugin: %s" % plugbase
-            try:
-                if policy.validatePlugin(pluginpath + plug):
-                    pluginClass = importPlugin("sos.plugins." + plugbase, plugbase)
-                else:
-                    soslog.warning(_("plugin %s does not validate, skipping") % plug)
-                    skippedplugins.append((plugbase, pluginClass(plugbase, commons)))
-                    continue
-                if plugbase in __cmdLineOpts__.noplugins:
-                    soslog.log(logging.VERBOSE, _("plug %s skipped (noplugins)") % plugbase)
-                    skippedplugins.append((plugbase, pluginClass(plugbase, commons)))
-                    continue
-                if not pluginClass(plugbase, commons).checkenabled() and not plugbase in __cmdLineOpts__.enableplugins  and not plugbase in __cmdLineOpts__.onlyplugins:
-                    soslog.log(logging.VERBOSE, _("plugin %s is inactive (use -e or -o to enable).") % plug)
-                    skippedplugins.append((plugbase, pluginClass(plugbase, commons)))
-                    continue
-                if not pluginClass(plugbase, commons).defaultenabled() and not plugbase in __cmdLineOpts__.enableplugins and not plugbase in __cmdLineOpts__.onlyplugins:
-                    soslog.log(logging.VERBOSE, "plugin %s not loaded by default (use -e or -o to enable)." % plug)
-                    skippedplugins.append((plugbase, pluginClass(plugbase, commons)))
-                    continue
-                if __cmdLineOpts__.onlyplugins and not plugbase in __cmdLineOpts__.onlyplugins:
-                    soslog.log(logging.VERBOSE, _("plugin %s not specified in --onlyplugin list") % plug)
-                    skippedplugins.append((plugbase, pluginClass(plugbase, commons)))
-                    continue
-                loadedplugins.append((plugbase, pluginClass(plugbase, commons)))
-            except:
-                soslog.warning(_("plugin %s does not install, skipping") % plug)
-                raise
-        except:
-           soslog.warning(_("could not load plugin %s") % plug)
-           if __raisePlugins__:
-                raise
-
-    # First, gather and process options
-    for plugname, plug in loadedplugins:
-        soslog.log(logging.VERBOSE3, _("processing options from plugin: %s") % plugname)
-        names, parms = plug.getAllOptions()
-        for optname, optparm  in zip(names, parms):
-            alloptions.append((plug, plugname, optname, optparm))
-
-    if __cmdLineOpts__.listPlugins:
-        if not len(loadedplugins) and not len(skippedplugins):
-           soslog.error(_("no valid plugins found"))
-           sys.exit(1)
-
-        if len(loadedplugins):
-	   print _("The following plugins are currently enabled:")
-           print
-           for (plugname,plug) in loadedplugins:
-              print " %-25s  %s" % (textcolor(plugname,"lblue"),plug.get_description())
-        else:
-           print _("No plugin enabled.")
-        print
-
-        if len(alloptions):
-           print _("The following plugin options are available:")
-           print
-           for (plug, plugname, optname, optparm)  in alloptions:
-              print " %-25s  %s [%d]" % (plugname + "." + optname, optparm["desc"], optparm["enabled"])
-        else:
-           print _("No plugin options available.")
-
-        if len(skippedplugins):
-           print
-           print _("The following plugins are currently disabled:")
-           print
-           for (plugname,plugclass) in skippedplugins:
-              print " %-25s  %s" % (textcolor(plugname,"blue"),plugclass.get_description())
-
-        print
-        sys.exit()
-
-    # to go anywhere further than listing the plugins we will need root permissions.
-    #
-    if os.getuid() != 0:
-        print _('sosreport requires root permissions to run.')
-        sys.exit(1)
-
-    # we don't need to keep in memory plugins we are not going to use
-    del skippedplugins
-
-    if not len(loadedplugins):
-        soslog.error(_("no valid plugins were enabled"))
-        sys.exit(1)
-
-    try:
-        raw_input(_("""This utility will collect some detailed  information about the
-hardware and  setup of your  Red Hat Enterprise Linux  system.
-This information will be used  to diagnose problems with  your 
-system and will be considered confidential information.
-Red Hat will use this information for diagnostic purposes ONLY.
-
-This process may take a while to complete.
-No changes will be made to your system.
-
-Press ENTER to continue, or CTRL-C to quit.
-"""))
-    except KeyboardInterrupt:
-        print
-        sys.exit(0)
-
-    # setup plugin options
-    if __cmdLineOpts__.plugopts:
-        opts = {}
-        for opt in __cmdLineOpts__.plugopts:
-           try: opt, val = opt.split("=")
-           except: val=1
-           plug, opt = opt.split(".")
-           try: val = int(val) # try to convert string "val" to int()
-           except: pass
-           try: opts[plug]
-           except KeyError: opts[plug] = []
-           opts[plug].append( (opt,val) )
-        for plugname, plug in loadedplugins:
-           if opts.has_key(plugname):
-               for opt,val in opts[plugname]:
-                   soslog.log(logging.VERBOSE, "setting option %s for plugin %s to %s" % (plugname,opt,val))
-                   plug.setOption(opt,val)
-        del opt,opts,val
-    elif not __cmdLineOpts__.fastoptions and not __cmdLineOpts__.usealloptions:
-        if len(alloptions) and __cmdLineOpts__.use_curses:
-            try:
-                get_curse_options(alloptions)
-            except "Cancelled":
-                sys.exit(_("Exiting."))
-    elif __cmdLineOpts__.fastoptions:
-        for i in range(len(alloptions)):
-            for plug, plugname, optname, optparm in alloptions:
-                if optparm['speed'] == 'fast':
-                    plug.setOption(optname, 1)
-                else:
-                    plug.setOption(optname, 0)
-    elif __cmdLineOpts__.usealloptions:
-        for i in range(len(alloptions)):
-            for plug, plugname, optname, optparm in alloptions:
-                plug.setOption(optname, 1)
-
-    # Call the diagnose() method for each plugin
-    tmpcount = 0
-    for plugname, plug in loadedplugins:
-        soslog.log(logging.VERBOSE2, "Performing sanity check for plugin %s" % plugname)
-        plug.diagnose()
-        tmpcount += len(plug.diagnose_msgs)
-    if tmpcount > 0:
-        print _("One or more plugin has detected a problem in your configuration.")
-        print _("Please review the following messages:")
-        print
-        for plugname, plug in loadedplugins:
-           for msg in plug.diagnose_msgs:
-               soslog.warning(" * %s: %s", plugname, msg)
-        print
-        try:
-           raw_input( _("Press ENTER to continue, or CTRL-C to quit.\n") )
-        except KeyboardInterrupt:
-           print
-           sys.exit(0)
-
-    # Call the setup() method for each plugin
-    for plugname, plug in loadedplugins:
-        soslog.log(logging.VERBOSE2, "Preloading files and commands to be gathered by plugin %s" % plugname)
-        plug.setup()
-
-    # Setup the progress bar
-    if __cmdLineOpts__.progressbar:
-        # gather information useful for generating ETA
-        eta_weight = len(loadedplugins)
-        for plugname, plug in loadedplugins:
-            eta_weight += plug.eta_weight
-        pbar = progressBar(minValue = 0, maxValue = eta_weight)
-        # pbar.max = number_of_plugins + weight (default 1 per plugin)
-
-    if __cmdLineOpts__.nomultithread:
-        soslog.log(logging.VERBOSE, "using single-threading")
-    else:
-        soslog.log(logging.VERBOSE, "using multi-threading")
-
-    # Call the collect method for each plugin
-    plugrunning = Semaphore(2)
-    for plugname, plug in loadedplugins:
-        soslog.log(logging.VERBOSE, "executing plugin %s" % plugname)
-        if not __cmdLineOpts__.nomultithread:
-            plug.copyStuff(threaded = True, semaphore = plugrunning)
-        else:
-            plug.copyStuff()    
-            if __cmdLineOpts__.progressbar:
-                pbar.incAmount(plug.eta_weight)
-                pbar.update()
-    del plugrunning
-
-    # Wait for all the collection threads to exit
-    if not __cmdLineOpts__.nomultithread:
-        finishedplugins = []
-        while len(loadedplugins) > 0:
-            plugname, plug = loadedplugins.pop(0)
-            if not plug.wait(0.5):
-                finishedplugins.append((plugname,plug))
-                soslog.log(logging.VERBOSE2, "plugin %s has returned" % plugname)
-                if __cmdLineOpts__.progressbar:
-                   pbar.incAmount(plug.eta_weight)
-            else:
-                soslog.log(logging.VERBOSE3, "plugin %s still hasn't returned" % plugname)
-                loadedplugins.append((plugname,plug))
-            if __cmdLineOpts__.progressbar:
-                pbar.update()
-        loadedplugins = finishedplugins
-        del finishedplugins
-
-    xmlrep.serialize_to_file(rptdir + "/" + "sosreport.xml")
-
-    # Call the analyze method for each plugin
-    for plugname, plug in loadedplugins:
-        soslog.log(logging.VERBOSE2, "Analyzing results of plugin %s" % plugname,)
-        try:
-            plug.analyze()
-        except:
-            # catch exceptions in analyse() and keep working
-            pass
-        if __cmdLineOpts__.progressbar:
-            pbar.incAmount()
-            pbar.update()
-
-    if __cmdLineOpts__.progressbar:
-        pbar.finished()
-        sys.stdout.write("\n")
-
-    # Generate the header for the html output file
-    rfd = open(rptdir + "/" + "sosreport.html", "w")
-    rfd.write("""
-    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-    <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
-        <head>
-    <link rel="stylesheet" type="text/css" media="screen" href="donot.css" />
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <title>Sos System Report</title>
-        </head>
-
-        <body>
-    """)
-
-
-    # Make a pass to gather Alerts and a list of module names
-    allAlerts = []
-    plugNames = []
-    for plugname, plug in loadedplugins:
-        for alert in plug.alerts:
-            allAlerts.append('<a href="#%s">%s</a>: %s' % (plugname, plugname, alert))
-        plugNames.append(plugname)
-
-
-
-    # Create a table of links to the module info
-    rfd.write("<hr/><h3>Loaded Plugins:</h3>")
-    rfd.write("<table><tr>\n")
-    rr = 0
-    for i in range(len(plugNames)):
-        rfd.write('<td><a href="#%s">%s</a></td>\n' % (plugNames[i], plugNames[i]))
-        rr = divmod(i, 4)[1]
-        if (rr == 3):
-            rfd.write('</tr>')
-    if not (rr == 3):
-        rfd.write('</tr>')
-    rfd.write('</table>\n')
-
-    rfd.write('<hr/><h3>Alerts:</h3>')
-    rfd.write('<ul>')
-    for alert in allAlerts:
-        rfd.write('<li>%s</li>' % alert)
-    rfd.write('</ul>')
-
-
-    # Call the report method for each plugin
-    for plugname, plug in loadedplugins:
-        html = plug.report()
-        rfd.write(html)
-
-    rfd.write("</body></html>")
-
-    rfd.close()
-
-    # Collect any needed user information (name, etc)
-
-    # Call the postproc method for each plugin
-    for plugname, plug in loadedplugins:
-        plug.postproc()
-  
-    if __cmdLineOpts__.gatheronly:
-        soslog.info(_("Collected information is in ") + dstroot)
-        soslog.info(_("Your html report is in ") + rptdir + "/" + "sosreport.html")
-    else:
-        # package up the results for the support organization
-        policy.packageResults()
-        # delete gathered files
-        os.system("/bin/rm -rf %s" % dstroot)
-        # automated submission will go here
-
-    # Close all log files and perform any cleanup
-    logging.shutdown()
- 
-    
-if __name__ == '__main__':
-    try:
-        sosreport()
-    except KeyboardInterrupt:
-        doExitCode()