class SoSReport(object): """The main sosreport class""" def __init__(self, args): self.loaded_plugins = deque() self.skipped_plugins = deque() self.all_options = deque() self.xml_report = XmlReport() self.global_plugin_options = {} self.archive = None self.tempfile_util = None try: import signal signal.signal(signal.SIGTERM, self.get_exit_handler()) except Exception: pass # not available in java, but we don't care self.opts = SoSOptions(args) self._set_debug() self._read_config() try: self.policy = sos.policies.load() except KeyboardInterrupt: self._exit(0) self._is_root = self.policy.is_root() self.tmpdir = os.path.abspath( self.policy.get_tmp_dir(self.opts.tmp_dir)) if not os.path.isdir(self.tmpdir) \ or not os.access(self.tmpdir, os.W_OK): # write directly to stderr as logging is not initialised yet sys.stderr.write("temporary directory %s " % self.tmpdir + "does not exist or is not writable\n") self._exit(1) self.tempfile_util = TempFileUtil(self.tmpdir) self._set_directories() def print_header(self): self.ui_log.info("\n%s\n" % _("sosreport (version %s)" % (__version__,))) def get_commons(self): return { 'cmddir': self.cmddir, 'logdir': self.logdir, 'rptdir': self.rptdir, 'tmpdir': self.tmpdir, 'soslog': self.soslog, 'policy': self.policy, 'verbosity': self.opts.verbosity, 'xmlreport': self.xml_report, 'cmdlineopts': self.opts, 'config': self.config, 'global_plugin_options': self.global_plugin_options, } def get_temp_file(self): return self.tempfile_util.new() def _set_archive(self): archive_name = os.path.join(self.tmpdir, self.policy.get_archive_name()) if self.opts.compression_type == 'auto': auto_archive = self.policy.get_preferred_archive() self.archive = auto_archive(archive_name, self.tmpdir) elif self.opts.compression_type == 'zip': self.archive = ZipFileArchive(archive_name, self.tmpdir) else: self.archive = TarFileArchive(archive_name, self.tmpdir) self.archive.set_debug(True if self.opts.debug else False) def _make_archive_paths(self): self.archive.makedirs(self.cmddir, 0o755) self.archive.makedirs(self.logdir, 0o755) self.archive.makedirs(self.rptdir, 0o755) def _set_directories(self): self.cmddir = 'sos_commands' self.logdir = 'sos_logs' self.rptdir = 'sos_reports' def _set_debug(self): if self.opts.debug: sys.excepthook = self._exception self.raise_plugins = True else: self.raise_plugins = False @staticmethod def _exception(etype, eval_, etrace): """ Wrap exception in debugger if not in tty """ if hasattr(sys, 'ps1') or not sys.stderr.isatty(): # we are in interactive mode or we don't have a tty-like # device, so we call the default hook sys.__excepthook__(etype, eval_, etrace) else: import pdb # we are NOT in interactive mode, print the exception... traceback.print_exception(etype, eval_, etrace, limit=2, file=sys.stdout) print_() # ...then start the debugger in post-mortem mode. pdb.pm() def _exit(self, error=0): raise SystemExit() # sys.exit(error) def get_exit_handler(self): def exit_handler(signum, frame): self._exit() return exit_handler def _read_config(self): self.config = ConfigParser() if self.opts.config_file: config_file = self.opts.config_file else: config_file = '/etc/sos.conf' try: self.config.readfp(open(config_file)) except IOError: pass def _setup_logging(self): # main soslog self.soslog = logging.getLogger('sos') self.soslog.setLevel(logging.DEBUG) self.sos_log_file = self.get_temp_file() self.sos_log_file.close() flog = logging.FileHandler(self.sos_log_file.name) flog.setFormatter(logging.Formatter( '%(asctime)s %(levelname)s: %(message)s')) flog.setLevel(logging.INFO) self.soslog.addHandler(flog) if not self.opts.quiet: console = logging.StreamHandler(sys.stderr) console.setFormatter(logging.Formatter('%(message)s')) if self.opts.verbosity and self.opts.verbosity > 1: console.setLevel(logging.DEBUG) flog.setLevel(logging.DEBUG) elif self.opts.verbosity and self.opts.verbosity > 0: console.setLevel(logging.INFO) flog.setLevel(logging.DEBUG) else: console.setLevel(logging.WARNING) self.soslog.addHandler(console) # ui log self.ui_log = logging.getLogger('sos_ui') self.ui_log.setLevel(logging.INFO) self.sos_ui_log_file = self.get_temp_file() self.sos_ui_log_file.close() ui_fhandler = logging.FileHandler(self.sos_ui_log_file.name) ui_fhandler.setFormatter(logging.Formatter( '%(asctime)s %(levelname)s: %(message)s')) self.ui_log.addHandler(ui_fhandler) if not self.opts.quiet: ui_console = logging.StreamHandler(sys.stdout) ui_console.setFormatter(logging.Formatter('%(message)s')) ui_console.setLevel(logging.INFO) self.ui_log.addHandler(ui_console) def _finish_logging(self): logging.shutdown() # the logging module seems to persist in the jython/jboss/eap world # so the handlers need to be removed for logger in [logging.getLogger(x) for x in ('sos', 'sos_ui')]: for h in logger.handlers: logger.removeHandler(h) if getattr(self, "sos_log_file", None): self.archive.add_file(self.sos_log_file.name, dest=os.path.join('sos_logs', 'sos.log')) if getattr(self, "sos_ui_log_file", None): self.archive.add_file(self.sos_ui_log_file.name, dest=os.path.join('sos_logs', 'ui.log')) def _get_disabled_plugins(self): disabled = [] if self.config.has_option("plugins", "disable"): disabled = [plugin.strip() for plugin in self.config.get("plugins", "disable").split(',')] return disabled def _is_skipped(self, plugin_name): return (plugin_name in self.opts.noplugins or plugin_name in self._get_disabled_plugins()) def _is_inactive(self, plugin_name, pluginClass): return (not pluginClass(self.get_commons()).check_enabled() and plugin_name not in self.opts.enableplugins and plugin_name not in self.opts.onlyplugins) def _is_not_default(self, plugin_name, pluginClass): return (not pluginClass(self.get_commons()).default_enabled() and plugin_name not in self.opts.enableplugins and plugin_name not in self.opts.onlyplugins) def _is_not_specified(self, plugin_name): return (self.opts.onlyplugins and plugin_name not in self.opts.onlyplugins) def _skip(self, plugin_class, reason="unknown"): self.skipped_plugins.append(( plugin_class.name(), plugin_class(self.get_commons()), reason )) def _load(self, plugin_class): self.loaded_plugins.append(( plugin_class.name(), plugin_class(self.get_commons()) )) def load_plugins(self): import sos.plugins helper = ImporterHelper(sos.plugins) plugins = helper.get_modules() self.plugin_names = deque() # validate and load plugins for plug in plugins: plugbase, ext = os.path.splitext(plug) try: plugin_classes = import_plugin( plugbase, tuple(self.policy.valid_subclasses)) if not len(plugin_classes): # no valid plugin classes for this policy continue plugin_class = self.policy.match_plugin(plugin_classes) if not self.policy.validate_plugin(plugin_class): self.soslog.warning( _("plugin %s does not validate, skipping") % plug) if self.opts.verbosity > 0: self._skip(plugin_class, _("does not validate")) continue if plugin_class.requires_root and not self._is_root: self.soslog.info(_("plugin %s requires root permissions" "to execute, skipping") % plug) self._skip(plugin_class, _("requires root")) continue # plug-in is valid, let's decide whether run it or not self.plugin_names.append(plugbase) if self._is_skipped(plugbase): self._skip(plugin_class, _("skipped")) continue if self._is_inactive(plugbase, plugin_class): self._skip(plugin_class, _("inactive")) continue if self._is_not_default(plugbase, plugin_class): self._skip(plugin_class, _("not default")) continue if self._is_not_specified(plugbase): self._skip(plugin_class, _("not specified")) continue self._load(plugin_class) except Exception as e: self.soslog.warning(_("plugin %s does not install, " "skipping: %s") % (plug, e)) if self.raise_plugins: raise def _set_all_options(self): if self.opts.usealloptions: for plugname, plug in self.loaded_plugins: for name, parms in zip(plug.opt_names, plug.opt_parms): if type(parms["enabled"]) == bool: parms["enabled"] = True def _set_tunables(self): if self.config.has_section("tunables"): if not self.opts.plugopts: self.opts.plugopts = deque() for opt, val in self.config.items("tunables"): if not opt.split('.')[0] in self._get_disabled_plugins(): self.opts.plugopts.append(opt + "=" + val) if self.opts.plugopts: opts = {} for opt in self.opts.plugopts: # split up "general.syslogsize=5" try: opt, val = opt.split("=") except: val = True else: if val.lower() in ["off", "disable", "disabled", "false"]: val = False else: # try to convert string "val" to int() try: val = int(val) except: pass # split up "general.syslogsize" try: plug, opt = opt.split(".") except: plug = opt opt = True try: opts[plug] except KeyError: opts[plug] = deque() opts[plug].append((opt, val)) for plugname, plug in self.loaded_plugins: if plugname in opts: for opt, val in opts[plugname]: if not plug.set_option(opt, val): self.soslog.error('no such option "%s" for plugin ' '(%s)' % (opt, plugname)) self._exit(1) del opts[plugname] for plugname in opts.keys(): self.soslog.error('unable to set option for disabled or ' 'non-existing plugin (%s)' % (plugname)) def _check_for_unknown_plugins(self): import itertools for plugin in itertools.chain(self.opts.onlyplugins, self.opts.noplugins, self.opts.enableplugins): plugin_name = plugin.split(".")[0] if plugin_name not in self.plugin_names: self.soslog.fatal('a non-existing plugin (%s) was specified' 'in the command line' % (plugin_name)) self._exit(1) def _set_plugin_options(self): for plugin_name, plugin in self.loaded_plugins: names, parms = plugin.get_all_options() for optname, optparm in zip(names, parms): self.all_options.append((plugin, plugin_name, optname, optparm)) def list_plugins(self): if not self.loaded_plugins and not self.skipped_plugins: self.soslog.fatal(_("no valid plugins found")) return if self.loaded_plugins: self.ui_log.info(_("The following plugins are currently enabled:")) self.ui_log.info("") for (plugname, plug) in self.loaded_plugins: self.ui_log.info(" %-20s %s" % (plugname, plug.get_description())) else: self.ui_log.info(_("No plugin enabled.")) self.ui_log.info("") if self.skipped_plugins: self.ui_log.info(_("The following plugins are currently " "disabled:")) self.ui_log.info("") for (plugname, plugclass, reason) in self.skipped_plugins: self.ui_log.info(" %-20s %-14s %s" % ( plugname, reason, plugclass.get_description())) self.ui_log.info("") if self.all_options: self.ui_log.info(_("The following plugin options are available:")) self.ui_log.info("") for (plug, plugname, optname, optparm) in self.all_options: # format option value based on its type (int or bool) if type(optparm["enabled"]) == bool: if optparm["enabled"] is True: tmpopt = "on" else: tmpopt = "off" else: tmpopt = optparm["enabled"] self.ui_log.info(" %-25s %-15s %s" % ( plugname + "." + optname, tmpopt, optparm["desc"])) else: self.ui_log.info(_("No plugin options available.")) self.ui_log.info("") def batch(self): if self.opts.batch: self.ui_log.info(self.policy.get_msg()) else: msg = self.policy.get_msg() msg += _("Press ENTER to continue, or CTRL-C to quit.\n") try: input(msg) except: self.ui_log.info("") self._exit() def _log_plugin_exception(self, plugin_name): self.soslog.error("%s\n%s" % (plugin_name, traceback.format_exc())) def prework(self): self.policy.pre_work() try: self.ui_log.info(_(" Setting up archive ...")) compression_methods = ('auto', 'zip', 'bzip2', 'gzip', 'xz') method = self.opts.compression_type if method not in compression_methods: compression_list = ', '.join(compression_methods) self.ui_log.error("") self.ui_log.error("Invalid compression specified: " + method) self.ui_log.error("Valid types are: " + compression_list) self.ui_log.error("") self._exit(1) self._set_archive() self._make_archive_paths() return except (OSError, IOError) as e: if e.errno in fatal_fs_errors: self.ui_log.error("") self.ui_log.error(" %s while setting up archive" % e.strerror) self.ui_log.error("") else: raise e except Exception as e: import traceback self.ui_log.error("") self.ui_log.error(" Unexpected exception setting up archive:") traceback.print_exc(e) self.ui_log.error(e) self._exit(1) def setup(self): self.ui_log.info(_(" Setting up plugins ...")) for plugname, plug in self.loaded_plugins: try: plug.archive = self.archive plug.setup() except KeyboardInterrupt: raise except (OSError, IOError) as e: if e.errno in fatal_fs_errors: self.ui_log.error("") self.ui_log.error(" %s while setting up plugins" % e.strerror) self.ui_log.error("") self._exit(1) except: if self.raise_plugins: raise else: self._log_plugin_exception(plugname) def version(self): """Fetch version information from all plugins and store in the report version file""" versions = [] versions.append("sosreport: %s" % __version__) for plugname, plug in self.loaded_plugins: versions.append("%s: %s" % (plugname, plug.version)) self.archive.add_string(content="\n".join(versions), dest='version.txt') def collect(self): self.ui_log.info(_(" Running plugins. Please wait ...")) self.ui_log.info("") plugruncount = 0 for i in zip(self.loaded_plugins): plugruncount += 1 plugname, plug = i[0] status_line = (" Running %d/%d: %s... " % (plugruncount, len(self.loaded_plugins), plugname)) if self.opts.verbosity == 0: status_line = "\r%s" % status_line else: status_line = "%s\n" % status_line if not self.opts.quiet: sys.stdout.write(status_line) sys.stdout.flush() try: plug.collect() except KeyboardInterrupt: raise except (OSError, IOError) as e: if e.errno in fatal_fs_errors: self.ui_log.error("") self.ui_log.error(" %s while collecting plugin data" % e.strerror) self.ui_log.error("") self._exit(1) except: if self.raise_plugins: raise else: self._log_plugin_exception(plugname) self.ui_log.info("") def report(self): for plugname, plug in self.loaded_plugins: for oneFile in plug.copied_files: try: self.xml_report.add_file(oneFile["srcpath"], os.stat(oneFile["srcpath"])) except: pass try: self.xml_report.serialize_to_file(os.path.join(self.rptdir, "sosreport.xml")) except (OSError, IOError) as e: if e.errno in fatal_fs_errors: self.ui_log.error("") self.ui_log.error(" %s while writing report data" % e.strerror) self.ui_log.error("") self._exit(1) def plain_report(self): report = Report() for plugname, plug in self.loaded_plugins: section = Section(name=plugname) for alert in plug.alerts: section.add(Alert(alert)) if plug.custom_text: section.add(Note(plug.custom_text)) for f in plug.copied_files: section.add(CopiedFile(name=f['srcpath'], href=".." + f['dstpath'])) for cmd in plug.executed_commands: section.add(Command(name=cmd['exe'], return_code=0, href="../" + cmd['file'])) for content, f in plug.copy_strings: section.add(CreatedFile(name=f)) report.add(section) try: fd = self.get_temp_file() fd.write(str(PlainTextReport(report))) fd.flush() self.archive.add_file(fd.name, dest=os.path.join('sos_reports', 'sos.txt')) except (OSError, IOError) as e: if e.errno in fatal_fs_errors: self.ui_log.error("") self.ui_log.error(" %s while writing text report" % e.strerror) self.ui_log.error("") self._exit(1) def html_report(self): try: self._html_report() except (OSError, IOError) as e: if e.errno in fatal_fs_errors: self.ui_log.error("") self.ui_log.error(" %s while writing HTML report" % e.strerror) self.ui_log.error("") self._exit(1) def _html_report(self): # Generate the header for the html output file rfd = self.get_temp_file() 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 = deque() plugNames = deque() for plugname, plug in self.loaded_plugins: 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 self.loaded_plugins: try: html = plug.report() except: if self.raise_plugins: raise else: rfd.write(html) rfd.write("</body></html>") rfd.flush() self.archive.add_file(rfd.name, dest=os.path.join('sos_reports', 'sos.html')) def postproc(self): for plugname, plug in self.loaded_plugins: try: plug.postproc() except (OSError, IOError) as e: if e.errno in fatal_fs_errors: self.ui_log.error("") self.ui_log.error(" %s while post-processing plugin data" % e.strerror) self.ui_log.error("") self._exit(1) except: if self.raise_plugins: raise def final_work(self): # this must come before archive creation to ensure that log # files are closed and cleaned up at exit. self._finish_logging() # package up the results for the support organization if not self.opts.build: print(_("Creating compressed archive...")) # compression could fail for a number of reasons try: final_filename = self.archive.finalize( self.opts.compression_type) except (OSError, IOError) as e: if e.errno in fatal_fs_errors: self.ui_log.error("") self.ui_log.error(" %s while finalizing archive" % e.strerror) self.ui_log.error("") self._exit(1) except: if self.opts.debug: raise else: return False else: final_filename = self.archive.get_archive_path() self.policy.display_results(final_filename, build=self.opts.build) self.tempfile_util.clean() return True def verify_plugins(self): if not self.loaded_plugins: self.soslog.error(_("no valid plugins were enabled")) return False return True def set_global_plugin_option(self, key, value): self.global_plugin_options[key] = value def execute(self): try: self._setup_logging() self.policy.set_commons(self.get_commons()) self.print_header() self.load_plugins() self._set_all_options() self._set_tunables() self._check_for_unknown_plugins() self._set_plugin_options() if self.opts.list_plugins: self.list_plugins() return True # verify that at least one plug-in is enabled if not self.verify_plugins(): return False self.batch() self.prework() self.setup() self.collect() if not self.opts.report: self.report() self.html_report() self.plain_report() self.postproc() self.version() return self.final_work() except (SystemExit, KeyboardInterrupt): if self.archive: self.archive.cleanup() if self.tempfile_util: self.tempfile_util.clean() return False
class SoSComponent(): """Any sub-command that sos supports needs to subclass SoSComponent in order to be properly supported by the sos binary. This class contains the standardized entrypoint for subcommands, as well as building out supported options from both globally shared option lists, and options supported by that specific subcommand. When sos initializes, it will load an unintialized instance of each class found within one recursion of the module root directory that subclasses SoSComponent. If sos is able to match the user-specified subcommand to one that exists locally, then that SoSComponent is initialized, logging is setup, and a policy is loaded. From there, the component's execute() method takes over. Added in 4.0 """ desc = 'unset' arg_defaults = {} configure_logging = True load_policy = True _arg_defaults = { "config_file": '/etc/sos.conf', "debug": False, "quiet": False, "threads": 4, "tmp_dir": '', "sysroot": None, "verbosity": 0 } def __init__(self, parser, parsed_args, cmdline_args): self.parser = parser self.args = parsed_args self.cmdline = cmdline_args self.exit_process = False self.archive = None self.tmpdir = None self.tempfile_util = None try: import signal signal.signal(signal.SIGTERM, self.get_exit_handler()) except Exception: pass # update args from component's arg_defaults defintion self._arg_defaults.update(self.arg_defaults) self.opts = self.load_options() if self.configure_logging: tmpdir = self.get_tmpdir_default() if not os.path.isdir(tmpdir) \ or not os.access(tmpdir, os.W_OK): msg = "temporary directory %s " % tmpdir msg += "does not exist or is not writable\n" # write directly to stderr as logging is not initialised yet sys.stderr.write(msg) self._exit(1) self.sys_tmp = tmpdir self.tmpdir = tempfile.mkdtemp(prefix="sos.", dir=self.sys_tmp) self.tempfile_util = TempFileUtil(self.tmpdir) self._setup_logging() if self.load_policy: try: self.policy = sos.policies.load(sysroot=self.opts.sysroot) except KeyboardInterrupt: self._exit(0) self._is_root = self.policy.is_root() def get_exit_handler(self): def exit_handler(signum, frame): self.exit_process = True self._exit() return exit_handler def _exit(self, error=0): raise SystemExit(error) def get_tmpdir_default(self): """If --tmp-dir is not specified, provide a default location. Normally this is /var/tmp, but if we detect we are in a container, then use a standardized env var to redirect to the host's filesystem instead """ if self.opts.tmp_dir: return self.opts.tmp_dir tmpdir = '/var/tmp' if os.getenv('HOST', None) and os.getenv('container', None): tmpdir = os.path.join(os.getenv('HOST'), tmpdir.lstrip('/')) return tmpdir def check_listing_options(self): opts = [o for o in self.opts.dict().keys() if o.startswith('list')] if opts: return any([getattr(self.opts, opt) for opt in opts]) @classmethod def add_parser_options(cls, parser): """This should be overridden by each subcommand to add its own unique options to the parser """ pass def load_options(self): """Compile arguments loaded from defaults, config files, and the command line into a usable set of options """ # load the defaults defined by the component and the shared options opts = SoSOptions(arg_defaults=self._arg_defaults) for option in self.parser._actions: if option.default != SUPPRESS: option.default = None # load values from cmdline cmdopts = SoSOptions().from_args(self.parser.parse_args(self.cmdline)) opts.merge(cmdopts) # load values from config file opts.update_from_conf(opts.config_file) return opts def cleanup(self): # archive and tempfile cleanup may fail due to a fatal # OSError exception (ENOSPC, EROFS etc.). if self.archive: self.archive.cleanup() if self.tempfile_util: self.tempfile_util.clean() if self.tmpdir: rmtree(self.tmpdir) def setup_archive(self, name=''): enc_opts = { 'encrypt': True if (self.opts.encrypt_pass or self.opts.encrypt_key) else False, 'key': self.opts.encrypt_key, 'password': self.opts.encrypt_pass } if not name: name = self.policy.get_archive_name() archive_name = os.path.join(self.tmpdir, name) if self.opts.compression_type == 'auto': auto_archive = self.policy.get_preferred_archive() self.archive = auto_archive(archive_name, self.tmpdir, self.policy, self.opts.threads, enc_opts, self.opts.sysroot) else: self.archive = TarFileArchive(archive_name, self.tmpdir, self.policy, self.opts.threads, enc_opts, self.opts.sysroot) self.archive.set_debug(True if self.opts.debug else False) def _setup_logging(self): """Creates the log handler that shall be used by all components and any and all related bits to those components that need to log either to the console or to the log file for that run of sos. """ # main soslog self.soslog = logging.getLogger('sos') self.soslog.setLevel(logging.DEBUG) flog = None if not self.check_listing_options(): self.sos_log_file = self.get_temp_file() flog = logging.StreamHandler(self.sos_log_file) flog.setFormatter(logging.Formatter( '%(asctime)s %(levelname)s: %(message)s')) flog.setLevel(logging.INFO) self.soslog.addHandler(flog) if not self.opts.quiet: console = logging.StreamHandler(sys.stdout) console.setFormatter(logging.Formatter('%(message)s')) if self.opts.verbosity and self.opts.verbosity > 1: console.setLevel(logging.DEBUG) if flog: flog.setLevel(logging.DEBUG) elif self.opts.verbosity and self.opts.verbosity > 0: console.setLevel(logging.INFO) if flog: flog.setLevel(logging.DEBUG) else: console.setLevel(logging.WARNING) self.soslog.addHandler(console) # still log ERROR level message to console, but only setup this handler # when --quiet is used, as otherwise we'll double log else: console_err = logging.StreamHandler(sys.stderr) console_err.setFormatter(logging.Formatter('%(message)s')) console_err.setLevel(logging.ERROR) self.soslog.addHandler(console_err) # ui log self.ui_log = logging.getLogger('sos_ui') self.ui_log.setLevel(logging.INFO) if not self.check_listing_options(): self.sos_ui_log_file = self.get_temp_file() ui_fhandler = logging.StreamHandler(self.sos_ui_log_file) ui_fhandler.setFormatter(logging.Formatter( '%(asctime)s %(levelname)s: %(message)s')) self.ui_log.addHandler(ui_fhandler) if not self.opts.quiet: ui_console = logging.StreamHandler(sys.stdout) ui_console.setFormatter(logging.Formatter('%(message)s')) ui_console.setLevel(logging.INFO) self.ui_log.addHandler(ui_console) def get_temp_file(self): return self.tempfile_util.new()
class SoSComponent(): """Any sub-command that sos supports needs to subclass SoSComponent in order to be properly supported by the sos binary. This class contains the standardized entrypoint for subcommands, as well as building out supported options from both globally shared option lists, and options supported by that specific subcommand. When sos initializes, it will load an unintialized instance of each class found within one recursion of the module root directory that subclasses SoSComponent. If sos is able to match the user-specified subcommand to one that exists locally, then that SoSComponent is initialized, logging is setup, and a policy is loaded. From there, the component's execute() method takes over. Added in 4.0 """ desc = 'unset' arg_defaults = {} configure_logging = True load_policy = True root_required = False _arg_defaults = { "batch": False, "compression_type": 'auto', "config_file": '/etc/sos/sos.conf', "debug": False, "encrypt_key": None, "encrypt_pass": None, "quiet": False, "threads": 4, "tmp_dir": '', "sysroot": None, "verbosity": 0 } def __init__(self, parser, parsed_args, cmdline_args): self.parser = parser self.args = parsed_args self.cmdline = cmdline_args self.exit_process = False self.archive = None self.tmpdir = None self.tempfile_util = None self.manifest = None try: import signal signal.signal(signal.SIGTERM, self.get_exit_handler()) except Exception: pass # update args from component's arg_defaults defintion self._arg_defaults.update(self.arg_defaults) self.opts = self.load_options() # lgtm [py/init-calls-subclass] if self.configure_logging: tmpdir = self.get_tmpdir_default() # only setup metadata if we are logging self.manifest = SoSMetadata() if not os.path.isdir(tmpdir) \ or not os.access(tmpdir, os.W_OK): msg = "temporary directory %s " % tmpdir msg += "does not exist or is not writable\n" # write directly to stderr as logging is not initialised yet sys.stderr.write(msg) self._exit(1) self.sys_tmp = tmpdir self.tmpdir = tempfile.mkdtemp(prefix="sos.", dir=self.sys_tmp) self.tempfile_util = TempFileUtil(self.tmpdir) self._setup_logging() if self.load_policy: try: import sos.policies self.policy = sos.policies.load(sysroot=self.opts.sysroot) self.sysroot = self.policy.host_sysroot() except KeyboardInterrupt: self._exit(0) self._is_root = self.policy.is_root() if self.manifest is not None: self.manifest.add_field('version', __version__) self.manifest.add_field('cmdline', ' '.join(self.cmdline)) self.manifest.add_field('start_time', datetime.now()) # these three will be set later, add here for organization self.manifest.add_field('end_time', '') self.manifest.add_field('run_time', '') self.manifest.add_field('compression', '') self.manifest.add_field('policy', self.policy.distro) self.manifest.add_section('components') def execute(self): raise NotImplementedError def get_exit_handler(self): def exit_handler(signum, frame): self.exit_process = True self._exit() return exit_handler def _exit(self, error=0): raise SystemExit(error) def get_tmpdir_default(self): """If --tmp-dir is not specified, provide a default location. Normally this is /var/tmp, but if we detect we are in a container, then use a standardized env var to redirect to the host's filesystem instead """ if self.opts.tmp_dir: return os.path.abspath(self.opts.tmp_dir) tmpdir = '/var/tmp' if os.getenv('HOST', None) and os.getenv('container', None): tmpdir = os.path.join(os.getenv('HOST'), tmpdir.lstrip('/')) return tmpdir def check_listing_options(self): opts = [o for o in self.opts.dict().keys() if o.startswith('list')] if opts: return any([getattr(self.opts, opt) for opt in opts]) @classmethod def add_parser_options(cls, parser): """This should be overridden by each subcommand to add its own unique options to the parser """ pass def apply_options_from_cmdline(self, opts): """(Re-)apply options specified via the cmdline to an options instance There are several cases where we may need to re-apply the options from the cmdline over previously loaded options - for instance when an option is specified in both a config file and cmdline, or a preset and the cmdline, or all three. Use this to re-apply cmdline option overrides to anything that may change the default values of options Positional arguments: :param opts: SoSOptions object to update """ # override the values from config files with the values from the # cmdline iff that value was explicitly specified, and compare it to # the _current_ set of opts from the config files as a default cmdopts = SoSOptions().from_args( self.parser.parse_args(self.cmdline), arg_defaults=opts.dict(preset_filter=False)) # we can't use merge() here, as argparse will pass default values for # unset options which would effectively negate config file settings and # set all values back to their normal default codict = cmdopts.dict(preset_filter=False) for opt, val in codict.items(): if opt not in cmdopts.arg_defaults.keys(): continue if val not in [None, [], ''] and val != opts.arg_defaults[opt]: setattr(opts, opt, val) return opts def load_options(self): """Compile arguments loaded from defaults, config files, and the command line into a usable set of options """ # load the defaults defined by the component and the shared options opts = SoSOptions(arg_defaults=self._arg_defaults) for option in self.parser._actions: if option.default != SUPPRESS: option.default = None opts.update_from_conf(self.args.config_file, self.args.component) # directly check the cmdline options here as they have yet to be loaded # as SoSOptions, and if we do this check after they are loaded we would # need to do a second update from cmdline options for overriding config # file values if '--clean' in self.cmdline or '--mask' in self.cmdline: opts.update_from_conf(self.args.config_file, 'clean') if os.getuid() != 0: userconf = os.path.join(Path.home(), '.config/sos/sos.conf') if os.path.exists(userconf): opts.update_from_conf(userconf, self.args.component) opts = self.apply_options_from_cmdline(opts) return opts def cleanup(self): # archive and tempfile cleanup may fail due to a fatal # OSError exception (ENOSPC, EROFS etc.). try: if self.archive: self.archive.cleanup() if self.tempfile_util: self.tempfile_util.clean() if self.tmpdir: rmtree(self.tmpdir) except Exception as err: print("Failed to finish cleanup: %s\nContents may remain in %s" % (err, self.tmpdir)) def setup_archive(self, name=''): enc_opts = { 'encrypt': True if (self.opts.encrypt_pass or self.opts.encrypt_key) else False, 'key': self.opts.encrypt_key, 'password': self.opts.encrypt_pass } if not name: name = self.policy.get_archive_name() archive_name = os.path.join(self.tmpdir, name) if self.opts.compression_type == 'auto': auto_archive = self.policy.get_preferred_archive() self.archive = auto_archive(archive_name, self.tmpdir, self.policy, self.opts.threads, enc_opts, self.sysroot, self.manifest) else: self.archive = TarFileArchive(archive_name, self.tmpdir, self.policy, self.opts.threads, enc_opts, self.sysroot, self.manifest) self.archive.set_debug(self.opts.verbosity > 2) def _setup_logging(self): """Creates the log handler that shall be used by all components and any and all related bits to those components that need to log either to the console or to the log file for that run of sos. """ # main soslog self.soslog = logging.getLogger('sos') self.soslog.setLevel(logging.DEBUG) flog = None if not self.check_listing_options(): self.sos_log_file = self.get_temp_file() flog = logging.StreamHandler(self.sos_log_file) flog.setFormatter( logging.Formatter('%(asctime)s %(levelname)s: %(message)s')) flog.setLevel(logging.INFO) self.soslog.addHandler(flog) if not self.opts.quiet: console = logging.StreamHandler(sys.stdout) console.setFormatter(logging.Formatter('%(message)s')) if self.opts.verbosity and self.opts.verbosity > 1: console.setLevel(logging.DEBUG) if flog: flog.setLevel(logging.DEBUG) elif self.opts.verbosity and self.opts.verbosity > 0: console.setLevel(logging.WARNING) if flog: flog.setLevel(logging.DEBUG) else: console.setLevel(logging.WARNING) self.soslog.addHandler(console) # still log ERROR level message to console, but only setup this handler # when --quiet is used, as otherwise we'll double log else: console_err = logging.StreamHandler(sys.stderr) console_err.setFormatter(logging.Formatter('%(message)s')) console_err.setLevel(logging.ERROR) self.soslog.addHandler(console_err) # ui log self.ui_log = logging.getLogger('sos_ui') self.ui_log.setLevel(logging.INFO) if not self.check_listing_options(): self.sos_ui_log_file = self.get_temp_file() ui_fhandler = logging.StreamHandler(self.sos_ui_log_file) ui_fhandler.setFormatter( logging.Formatter('%(asctime)s %(levelname)s: %(message)s')) self.ui_log.addHandler(ui_fhandler) if not self.opts.quiet: ui_console = logging.StreamHandler(sys.stdout) ui_console.setFormatter(logging.Formatter('%(message)s')) ui_console.setLevel(logging.INFO) self.ui_log.addHandler(ui_console) def get_temp_file(self): return self.tempfile_util.new()