Merge branch 'options-rewrite'

Conflicts:
	src/lib/Bcfg2/Client/Frame.py
	src/lib/Bcfg2/Options.py
	src/lib/Bcfg2/Server/Admin/Init.py
	src/lib/Bcfg2/Server/Admin/Xcmd.py
	src/lib/Bcfg2/Server/BuiltinCore.py
	src/lib/Bcfg2/Server/Core.py
	src/lib/Bcfg2/Server/MultiprocessingCore.py
	src/lib/Bcfg2/Server/Plugin/base.py
	src/lib/Bcfg2/Server/Plugin/helpers.py
	src/lib/Bcfg2/Server/Plugins/Cfg/__init__.py
	src/lib/Bcfg2/Server/Plugins/Packages/Yum.py
	src/lib/Bcfg2/Server/Plugins/Packages/__init__.py
	src/lib/Bcfg2/Server/SSLServer.py
	src/lib/Bcfg2/Utils.py
	src/lib/Bcfg2/settings.py
	src/sbin/bcfg2-crypt
	src/sbin/bcfg2-info
	src/sbin/bcfg2-lint
	src/sbin/bcfg2-test
	src/sbin/bcfg2-yum-helper
	tools/bcfg2-profile-templates.py

1 files changed, 182 insertions, 22 deletions

diff --git a/src/lib/Bcfg2/Server/Lint/__init__.py b/src/lib/Bcfg2/Server/Lint/__init__.py
index 28644263f..4f64fd006 100644
--- a/src/lib/Bcfg2/Server/Lint/__init__.py
+++ b/src/lib/Bcfg2/Server/Lint/__init__.py
@@ -2,16 +2,17 @@
 
 import os
 import sys
+import time
+import copy
+import fcntl
+import struct
+import termios
 import logging
-from copy import copy
 import textwrap
 import lxml.etree
-import fcntl
-import termios
-import struct
-from Bcfg2.Compat import walk_packages
-
-plugins = [m[1] for m in walk_packages(path=__path__)]  # pylint: disable=C0103
+import Bcfg2.Options
+import Bcfg2.Server.Core
+import Bcfg2.Server.Plugins
 
 
 def _ioctl_GWINSZ(fd):  # pylint: disable=C0103
@@ -46,10 +47,10 @@ def get_termsize():
 class Plugin(object):
     """ Base class for all bcfg2-lint plugins """
 
-    def __init__(self, config, errorhandler=None, files=None):
+    options = [Bcfg2.Options.Common.repository]
+
+    def __init__(self, errorhandler=None, files=None):
         """
-        :param config: A :mod:`Bcfg2.Options` setup dict
-        :type config: dict
         :param errorhandler: A :class:`Bcfg2.Server.Lint.ErrorHandler`
                              that will be used to handle lint errors.
                              If one is not provided, a new one will be
@@ -63,9 +64,6 @@ class Plugin(object):
         #: The list of files that bcfg2-lint should be run against
         self.files = files
 
-        #: The Bcfg2.Options setup dict
-        self.config = config
-
         self.logger = logging.getLogger('bcfg2-lint')
         if errorhandler is None:
             #: The error handler
@@ -96,9 +94,10 @@ class Plugin(object):
         False otherwise. """
         return (self.files is None or
                 fname in self.files or
-                os.path.join(self.config['repo'], fname) in self.files or
+                os.path.join(Bcfg2.Options.setup.repository,
+                             fname) in self.files or
                 os.path.abspath(fname) in self.files or
-                os.path.abspath(os.path.join(self.config['repo'],
+                os.path.abspath(os.path.join(Bcfg2.Options.setup.repository,
                                              fname)) in self.files)
 
     def LintError(self, err, msg):
@@ -125,7 +124,7 @@ class Plugin(object):
         """
         xml = None
         if len(element) or element.text:
-            el = copy(element)
+            el = copy.copy(element)
             if el.text and not keep_text:
                 el.text = '...'
             for child in el.iterchildren():
@@ -145,8 +144,8 @@ class ErrorHandler(object):
 
     def __init__(self, errors=None):
         """
-        :param config: An initial dict of errors to register
-        :type config: dict
+        :param errors: An initial dict of errors to register
+        :type errors: dict
         """
         #: The number of errors passed to this error handler
         self.errors = 0
@@ -267,12 +266,10 @@ class ServerPlugin(Plugin):  # pylint: disable=W0223
     """ Base class for bcfg2-lint plugins that check things that
     require the running Bcfg2 server. """
 
-    def __init__(self, core, config, errorhandler=None, files=None):
+    def __init__(self, core, errorhandler=None, files=None):
         """
         :param core: The Bcfg2 server core
         :type core: Bcfg2.Server.Core.BaseCore
-        :param config: A :mod:`Bcfg2.Options` setup dict
-        :type config: dict
         :param errorhandler: A :class:`Bcfg2.Server.Lint.ErrorHandler`
                              that will be used to handle lint errors.
                              If one is not provided, a new one will be
@@ -282,7 +279,7 @@ class ServerPlugin(Plugin):  # pylint: disable=W0223
                       the bcfg2-lint ``--stdin`` option.)
         :type files: list of strings
         """
-        Plugin.__init__(self, config, errorhandler=errorhandler, files=files)
+        Plugin.__init__(self, errorhandler=errorhandler, files=files)
 
         #: The server core
         self.core = core
@@ -290,3 +287,166 @@ class ServerPlugin(Plugin):  # pylint: disable=W0223
 
         #: The metadata plugin
         self.metadata = self.core.metadata
+
+
+class LintPluginAction(Bcfg2.Options.ComponentAction):
+    """ We want to load all lint plugins that pertain to server
+    plugins.  In order to do this, we hijack the __call__() method of
+    this action and add all of the server plugins on the fly """
+
+    bases = ['Bcfg2.Server.Lint']
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        for plugin in getattr(Bcfg2.Options.setup, "plugins", []):
+            module = sys.modules[plugin.__module__]
+            if hasattr(module, "%sLint" % plugin.name):
+                print("Adding lint plugin %s" % plugin)
+                values.append(plugin)
+        Bcfg2.Options.ComponentAction.__call__(self, parser, namespace, values,
+                                               option_string)
+
+
+class CLI(object):
+    """ The bcfg2-lint CLI """
+    options = Bcfg2.Server.Core.Core.options + [
+        Bcfg2.Options.PathOption(
+            '--lint-config', default='/etc/bcfg2-lint.conf',
+            action=Bcfg2.Options.ConfigFileAction,
+            help='Specify bcfg2-lint configuration file'),
+        Bcfg2.Options.Option(
+            "--lint-plugins", cf=('lint', 'plugins'),
+            type=Bcfg2.Options.Types.comma_list, action=LintPluginAction,
+            help='bcfg2-lint plugin list'),
+        Bcfg2.Options.BooleanOption(
+            '--list-errors', help='Show error handling'),
+        Bcfg2.Options.BooleanOption(
+            '--stdin', help='Operate on a list of files supplied on stdin'),
+        Bcfg2.Options.Option(
+            cf=("errors", '*'), dest="lint_errors",
+            help="How to handle bcfg2-lint errors")]
+
+    def __init__(self):
+        parser = Bcfg2.Options.get_parser(
+            description="Manage a running Bcfg2 server",
+            components=[self])
+        parser.parse()
+
+        self.logger = logging.getLogger(parser.prog)
+
+        # automatically add Lint plugins for loaded server plugins
+        for plugin in Bcfg2.Options.setup.plugins:
+            try:
+                Bcfg2.Options.setup.lint_plugins.append(
+                    getattr(
+                        __import__("Bcfg2.Server.Lint.%s" % plugin.__name__,
+                                   fromlist=[plugin.__name__]),
+                        plugin.__name__))
+                self.logger.debug("Automatically adding lint plugin %s" %
+                                  plugin.__name__)
+            except ImportError:
+                # no lint plugin for this server plugin
+                self.logger.debug("No lint plugin for %s" % plugin.__name__)
+                pass
+            except AttributeError:
+                self.logger.error("Failed to load plugin %s: %s" %
+                                  (plugin.__name__, sys.exc_info()[1]))
+
+        self.logger.debug("Running lint with plugins: %s" %
+                          [p.__name__
+                           for p in Bcfg2.Options.setup.lint_plugins])
+
+        if Bcfg2.Options.setup.stdin:
+            self.files = [s.strip() for s in sys.stdin.readlines()]
+        else:
+            self.files = None
+        self.errorhandler = self.get_errorhandler()
+        self.serverlessplugins = []
+        self.serverplugins = []
+        for plugin in Bcfg2.Options.setup.lint_plugins:
+            if issubclass(plugin, ServerPlugin):
+                self.serverplugins.append(plugin)
+            else:
+                self.serverlessplugins.append(plugin)
+
+    def run(self):
+        if Bcfg2.Options.setup.list_errors:
+            for plugin in self.serverplugins + self.serverlessplugins:
+                self.errorhandler.RegisterErrors(getattr(plugin, 'Errors')())
+
+            print("%-35s %-35s" % ("Error name", "Handler"))
+            for err, handler in self.errorhandler.errortypes.items():
+                print("%-35s %-35s" % (err, handler.__name__))
+            return 0
+
+        if not self.serverplugins and not self.serverlessplugins:
+            self.logger.error("No lint plugins loaded!")
+            return 1
+
+        self.run_serverless_plugins()
+
+        if self.serverplugins:
+            if self.errorhandler.errors:
+                # it would be swell if we could try to start the server
+                # even if there were errors with the serverless plugins,
+                # but since XML parsing errors occur in the FAM thread
+                # (not in the core server thread), there's no way we can
+                # start the server and try to catch exceptions --
+                # bcfg2-lint isn't in the same stack as the exceptions.
+                # so we're forced to assume that a serverless plugin error
+                # will prevent the server from starting
+                print("Serverless plugins encountered errors, skipping server "
+                      "plugins")
+            else:
+                self.run_server_plugins()
+
+        if (self.errorhandler.errors or
+            self.errorhandler.warnings or
+            Bcfg2.Options.setup.verbose):
+            print("%d errors" % self.errorhandler.errors)
+            print("%d warnings" % self.errorhandler.warnings)
+
+        if self.errorhandler.errors:
+            return 2
+        elif self.errorhandler.warnings:
+            return 3
+        else:
+            return 0
+
+    def get_errorhandler(self):
+        """ get a Bcfg2.Server.Lint.ErrorHandler object """
+        return Bcfg2.Server.Lint.ErrorHandler(
+            errors=Bcfg2.Options.setup.lint_errors)
+
+    def run_serverless_plugins(self):
+        """ Run serverless plugins """
+        self.logger.debug("Running serverless plugins: %s" %
+                          [p.__name__ for p in self.serverlessplugins])
+        for plugin in self.serverlessplugins:
+            self.logger.debug("  Running %s" % plugin.__name__)
+            plugin(files=self.files, errorhandler=self.errorhandler).Run()
+
+    def run_server_plugins(self):
+        """ run plugins that require a running server to run """
+        core = Bcfg2.Server.Core.Core()
+        core.load_plugins()
+        core.block_for_fam_events(handle_events=True)
+        try:
+            self.logger.debug("Running server plugins: %s" %
+                              [p.__name__ for p in self.serverplugins])
+            for plugin in self.serverplugins:
+                self.logger.debug("  Running %s" % plugin.__name__)
+                plugin(core,
+                       files=self.files, errorhandler=self.errorhandler).Run()
+        finally:
+            core.shutdown()
+
+    def _run_plugin(self, plugin, args=None):
+        if args is None:
+            args = []
+        start = time.time()
+        # python 2.5 doesn't support mixing *magic and keyword arguments
+        kwargs = dict(files=self.files, errorhandler=self.errorhandler)
+        rv = plugin(*args, **kwargs).Run()
+        self.logger.debug("  Ran %s in %0.2f seconds" % (plugin.__name__,
+                                                         time.time() - start))
+        return rv