Options: migrated plugins to new options parser

39 files changed, 499 insertions, 973 deletions

diff --git a/src/lib/Bcfg2/Server/Plugin/__init__.py b/src/lib/Bcfg2/Server/Plugin/__init__.py
index ed1282ba0..0c7d111f3 100644
--- a/src/lib/Bcfg2/Server/Plugin/__init__.py
+++ b/src/lib/Bcfg2/Server/Plugin/__init__.py
@@ -14,6 +14,7 @@ documentation it's not necessary to use the submodules.  E.g., you can
 
 import os
 import sys
+import Bcfg2.Options
 sys.path.append(os.path.dirname(__file__))
 
 # pylint: disable=W0401
@@ -21,3 +22,31 @@ from Bcfg2.Server.Plugin.base import *
 from Bcfg2.Server.Plugin.interfaces import *
 from Bcfg2.Server.Plugin.helpers import *
 from Bcfg2.Server.Plugin.exceptions import *
+
+
+class _OptionContainer(object):
+    options = [
+        Bcfg2.Options.Common.default_paranoid,
+        Bcfg2.Options.Option(
+           cf=('mdata', 'owner'), dest="default_owner", default='root',
+           help='Default Path owner'),
+        Bcfg2.Options.Option(
+           cf=('mdata', 'group'), dest="default_group", default='root',
+           help='Default Path group'),
+        Bcfg2.Options.Option(
+            cf=('mdata', 'important'), dest="default_important",
+            default='false', choices=['true', 'false'],
+            help='Default Path priority (importance)'),
+        Bcfg2.Options.Option(
+            cf=('mdata', 'mode'), dest="default_mode", default='644',
+            help='Default mode for Path'),
+        Bcfg2.Options.Option(
+            cf=('mdata', 'secontext'), dest="default_secontext",
+            default='__default__', help='Default SELinux context'),
+        Bcfg2.Options.Option(
+            cf=('mdata', 'sensitive'), dest="default_sensitive",
+            default='false',
+            help='Default Path sensitivity setting')]
+
+
+Bcfg2.Options.get_parser().add_component(_OptionContainer)
diff --git a/src/lib/Bcfg2/Server/Plugin/base.py b/src/lib/Bcfg2/Server/Plugin/base.py
index c825a57b5..e94ab9335 100644
--- a/src/lib/Bcfg2/Server/Plugin/base.py
+++ b/src/lib/Bcfg2/Server/Plugin/base.py
@@ -1,65 +1,10 @@
 """This module provides the base class for Bcfg2 server plugins."""
 
 import os
-import logging
+from Bcfg2.Logger import Debuggable
 from Bcfg2.Utils import ClassName
 
 
-class Debuggable(object):
-    """ Mixin to add a debugging interface to an object and expose it
-    via XML-RPC on :class:`Bcfg2.Server.Plugin.base.Plugin` objects """
-
-    #: List of names of methods to be exposed as XML-RPC functions
-    __rmi__ = ['toggle_debug', 'set_debug']
-
-    def __init__(self, name=None):
-        """
-        :param name: The name of the logger object to get.  If none is
-                     supplied, the full name of the class (including
-                     module) will be used.
-        :type name: string
-
-        .. autoattribute:: __rmi__
-        """
-        if name is None:
-            name = "%s.%s" % (self.__class__.__module__,
-                              self.__class__.__name__)
-        self.debug_flag = False
-        self.logger = logging.getLogger(name)
-
-    def set_debug(self, debug):
-        """ Explicitly enable or disable debugging.  This method is exposed
-        via XML-RPC.
-
-        :returns: bool - The new value of the debug flag
-        """
-        self.debug_flag = debug
-        self.debug_log("%s: debug = %s" % (self.__class__.__name__,
-                                           self.debug_flag),
-                       flag=True)
-        return debug
-
-    def toggle_debug(self):
-        """ Turn debugging output on or off.  This method is exposed
-        via XML-RPC.
-
-        :returns: bool - The new value of the debug flag
-        """
-        return self.set_debug(not self.debug_flag)
-
-    def debug_log(self, message, flag=None):
-        """ Log a message at the debug level.
-
-        :param message: The message to log
-        :type message: string
-        :param flag: Override the current debug flag with this value
-        :type flag: bool
-        :returns: None
-        """
-        if (flag is None and self.debug_flag) or flag:
-            self.logger.error(message)
-
-
 class Plugin(Debuggable):
     """ The base class for all Bcfg2 Server plugins. """
 
diff --git a/src/lib/Bcfg2/Server/Plugin/helpers.py b/src/lib/Bcfg2/Server/Plugin/helpers.py
index c76346bc5..f52662bde 100644
--- a/src/lib/Bcfg2/Server/Plugin/helpers.py
+++ b/src/lib/Bcfg2/Server/Plugin/helpers.py
@@ -13,8 +13,10 @@ import lxml.etree
 import Bcfg2.Server
 import Bcfg2.Options
 import Bcfg2.Server.FileMonitor
+from Bcfg2.Utils import ClassName
+from Bcfg2.Logger import Debuggable
 from Bcfg2.Compat import CmpMixin, wraps
-from Bcfg2.Server.Plugin.base import Debuggable, Plugin
+from Bcfg2.Server.Plugin.base import Plugin
 from Bcfg2.Server.Plugin.interfaces import Generator
 from Bcfg2.Server.Plugin.exceptions import SpecificityError, \
     PluginExecutionError
@@ -144,48 +146,39 @@ def default_path_metadata():
 
     :returns: dict of metadata attributes and their default values
     """
-    attrs = Bcfg2.Options.PATH_METADATA_OPTIONS.keys()
-    setup = Bcfg2.Options.get_option_parser()
-    if not set(attrs).issubset(setup.keys()):
-        setup.add_options(Bcfg2.Options.PATH_METADATA_OPTIONS)
-        setup.reparse(argv=[Bcfg2.Options.CFILE.cmd, Bcfg2.Options.CFILE])
-    return dict([(k, setup[k]) for k in attrs])
+    return dict([(k, getattr(Bcfg2.Options.setup, "default_%s" % k))
+                 for k in ['owner', 'group', 'mode', 'secontext', 'important',
+                           'paranoid', 'sensitive']])
 
 
 class DatabaseBacked(Plugin):
     """ Provides capabilities for a plugin to read and write to a
-    database.
+    database. The plugin must add an option to flag database use with
+    something like:
+
+    options = Bcfg2.Server.Plugin.Plugins.options + [
+        Bcfg2.Options.BooleanOption(
+            cf=('metadata', 'use_database'), dest="metadata_db",
+            help="Use database capabilities of the Metadata plugin")
+
+    This must be done manually due to various limitations in Python.
 
     .. private-include: _use_db
     .. private-include: _must_lock
     """
 
-    #: The option to look up in :attr:`section` to determine whether or
-    #: not to use the database capabilities of this plugin.  The option
-    #: is retrieved with
-    #: :py:func:`ConfigParser.SafeConfigParser.getboolean`, and so must
-    #: conform to the possible values that function can handle.
-    option = "use_database"
-
-    def _section(self):
-        """ The section to look in for :attr:`DatabaseBacked.option`
-        """
-        return self.name.lower()
-    section = property(_section)
-
     @property
     def _use_db(self):
         """ Whether or not this plugin is configured to use the
         database. """
-        use_db = self.core.setup.cfp.getboolean(self.section,
-                                                self.option,
-                                                default=False)
+        use_db = getattr(Bcfg2.Options.setup, "%s_db" % self.name.lower(),
+                         False)
         if use_db and HAS_DJANGO and self.core.database_available:
             return True
         elif not use_db:
             return False
         else:
-            self.logger.error("%s is true but django not found" % self.option)
+            self.logger.error("use_database is true but django not found")
             return False
 
     @property
@@ -193,11 +186,7 @@ class DatabaseBacked(Plugin):
         """ Whether or not the backend database must acquire a thread
         lock before writing, because it does not allow multiple
         threads to write."""
-        engine = \
-            self.core.setup.cfp.get(Bcfg2.Options.DB_ENGINE.cf[0],
-                                    Bcfg2.Options.DB_ENGINE.cf[1],
-                                    default=Bcfg2.Options.DB_ENGINE.default)
-        return engine == 'sqlite3'
+        return Bcfg2.Options.setup.db_engine == 'sqlite3'
 
     @staticmethod
     def get_db_lock(func):
@@ -679,24 +668,9 @@ class StructFile(XMLFileBacked):
         dict(Group=lambda el, md, *args: el.get('name') in md.groups,
              Client=lambda el, md, *args: el.get('name') == md.hostname)
 
-    #: Callbacks used to determine if children of items with the given
-    #: tags should be included in the return value of
-    #: :func:`Bcfg2.Server.Plugin.helpers.StructFile.Match` and
-    #: :func:`Bcfg2.Server.Plugin.helpers.StructFile.XMLMatch`.  Each
-    #: callback is passed the same arguments as
-    #: :func:`Bcfg2.Server.Plugin.helpers.StructFile._include_element`.
-    #: It should return True if children of the element should be
-    #: included in the match, False otherwise.  The callback does
-    #: *not* need to consider negation; that will be handled in
-    #: :func:`Bcfg2.Server.Plugin.helpers.StructFile._include_element`
-    _include_tests = \
-        dict(Group=lambda el, md, *args: el.get('name') in md.groups,
-             Client=lambda el, md, *args: el.get('name') == md.hostname)
-
-    def __init__(self, filename, should_monitor=False):
-        XMLFileBacked.__init__(self, filename, should_monitor=should_monitor)
-        self.setup = Bcfg2.Options.get_option_parser()
-        self.encoding = self.setup['encoding']
+    def __init__(self, filename, should_monitor=False, create=None):
+        XMLFileBacked.__init__(self, filename, should_monitor=should_monitor,
+                               create=create)
         self.template = None
 
     def Index(self):
@@ -706,9 +680,10 @@ class StructFile(XMLFileBacked):
              self.xdata.nsmap['py'] == 'http://genshi.edgewall.org/')):
             try:
                 loader = genshi.template.TemplateLoader()
-                self.template = loader.load(self.name,
-                                            cls=genshi.template.MarkupTemplate,
-                                            encoding=self.encoding)
+                self.template = \
+                    loader.load(self.name,
+                                cls=genshi.template.MarkupTemplate,
+                                encoding=Bcfg2.Options.setup.encoding)
             except LookupError:
                 err = sys.exc_info()[1]
                 self.logger.error('Genshi lookup error in %s: %s' % (self.name,
@@ -723,10 +698,9 @@ class StructFile(XMLFileBacked):
                                                                     err))
 
         if HAS_CRYPTO:
-            strict = self.xdata.get(
-                "decrypt",
-                self.setup.cfp.get(Bcfg2.Server.Encryption.CFG_SECTION,
-                                   "decrypt", default="strict")) == "strict"
+            lax_decrypt = self.xdata.get(
+                "lax_decryption",
+                str(Bcfg2.Options.setup.lax_decryption)).lower() == "true"
             for el in self.xdata.xpath("//*[@encrypted]"):
                 try:
                     el.text = self._decrypt(el).encode('ascii',
@@ -737,17 +711,17 @@ class StructFile(XMLFileBacked):
                 except Bcfg2.Server.Encryption.EVPError:
                     msg = "Failed to decrypt %s element in %s" % (el.tag,
                                                                   self.name)
-                    if strict:
-                        raise PluginExecutionError(msg)
-                    else:
+                    if lax_decrypt:
                         self.logger.warning(msg)
+                    else:
+                        raise PluginExecutionError(msg)
     Index.__doc__ = XMLFileBacked.Index.__doc__
 
     def _decrypt(self, element):
         """ Decrypt a single encrypted properties file element """
         if not element.text or not element.text.strip():
             return
-        passes = Bcfg2.Server.Encryption.get_passphrases()
+        passes = Bcfg2.Options.setup.passphrases
         try:
             passphrase = passes[element.get("encrypted")]
             try:
@@ -794,7 +768,7 @@ class StructFile(XMLFileBacked):
         """
         stream = self.template.generate(
             metadata=metadata,
-            repo=self.setup['repo']).filter(removecomment)
+            repo=Bcfg2.Options.setup.repository).filter(removecomment)
         return lxml.etree.XML(stream.render('xml',
                                             strip_whitespace=False),
                               parser=Bcfg2.Server.XMLParser)
@@ -911,7 +885,7 @@ class InfoXML(StructFile):
     metadata (permissions, owner, etc.) of files. """
     encryption = False
 
-    _include_tests = StructFile._include_tests
+    _include_tests = copy.copy(StructFile._include_tests)
     _include_tests['Path'] = lambda el, md, entry, *args: \
         entry.get("name") == el.get("name")
 
@@ -1166,7 +1140,7 @@ class SpecificData(Debuggable):
     """ A file that is specific to certain clients, groups, or all
     clients. """
 
-    def __init__(self, name, specific, encoding):  # pylint: disable=W0613
+    def __init__(self, name, specific):  # pylint: disable=W0613
         """
         :param name: The full path to the file
         :type name: string
@@ -1175,8 +1149,6 @@ class SpecificData(Debuggable):
                          object describing what clients this file
                          applies to.
         :type specific: Bcfg2.Server.Plugin.helpers.Specificity
-        :param encoding: The encoding to use for data in this file
-        :type encoding: string
         """
         Debuggable.__init__(self)
         self.name = name
@@ -1224,7 +1196,7 @@ class EntrySet(Debuggable):
     #: considered a plain string and filenames must match exactly.
     basename_is_regex = False
 
-    def __init__(self, basename, path, entry_type, encoding):
+    def __init__(self, basename, path, entry_type):
         """
         :param basename: The filename or regular expression that files
                          in this EntrySet must match.  See
@@ -1239,12 +1211,10 @@ class EntrySet(Debuggable):
                            be an object factory or similar callable.
                            See below for the expected signature.
         :type entry_type: callable
-        :param encoding: The encoding of all files in this entry set.
-        :type encoding: string
 
         The ``entry_type`` callable must have the following signature::
 
-            entry_type(filepath, specificity, encoding)
+            entry_type(filepath, specificity)
 
         Where the parameters are:
 
@@ -1255,8 +1225,6 @@ class EntrySet(Debuggable):
                          object describing what clients this file
                          applies to.
         :type specific: Bcfg2.Server.Plugin.helpers.Specificity
-        :param encoding: The encoding to use for data in this file
-        :type encoding: string
 
         Additionally, the object returned by ``entry_type`` must have
         a ``specific`` attribute that is sortable (e.g., a
@@ -1271,7 +1239,6 @@ class EntrySet(Debuggable):
         self.entries = {}
         self.metadata = default_path_metadata()
         self.infoxml = None
-        self.encoding = encoding
 
         if self.basename_is_regex:
             base_pat = basename
@@ -1288,6 +1255,12 @@ class EntrySet(Debuggable):
         #: be overridden on a per-entry basis in :func:`entry_init`.
         self.specific = re.compile(pattern)
 
+    def set_debug(self, debug):
+        rv = Debuggable.set_debug(self, debug)
+        for entry in self.entries.values():
+            entry.set_debug(debug)
+        return rv
+
     def get_matching(self, metadata):
         """ Get a list of all entries that apply to the given client.
         This gets all matching entries; for example, there could be an
@@ -1405,8 +1378,7 @@ class EntrySet(Debuggable):
                     self.logger.error("Could not process filename %s; ignoring"
                                       % fpath)
                 return
-            self.entries[event.filename] = entry_type(fpath, spec,
-                                                      self.encoding)
+            self.entries[event.filename] = entry_type(fpath, spec)
         self.entries[event.filename].handle_event(event)
 
     def specificity_from_filename(self, fname, specific=None):
@@ -1553,7 +1525,6 @@ class GroupSpool(Plugin, Generator):
         self.entries = {}
         self.handles = {}
         self.AddDirectoryMonitor('')
-        self.encoding = core.setup['encoding']
     __init__.__doc__ = Plugin.__init__.__doc__
 
     def add_entry(self, event):
@@ -1577,8 +1548,7 @@ class GroupSpool(Plugin, Generator):
             dirpath = self.data + ident
             self.entries[ident] = self.es_cls(self.filename_pattern,
                                               dirpath,
-                                              self.es_child_cls,
-                                              self.encoding)
+                                              self.es_child_cls)
             self.Entries[self.entry_type][ident] = \
                 self.entries[ident].bind_entry
         if not os.path.isdir(epath):
diff --git a/src/lib/Bcfg2/Server/Plugin/interfaces.py b/src/lib/Bcfg2/Server/Plugin/interfaces.py
index 7909eaa03..619d72afd 100644
--- a/src/lib/Bcfg2/Server/Plugin/interfaces.py
+++ b/src/lib/Bcfg2/Server/Plugin/interfaces.py
@@ -6,6 +6,7 @@ import copy
 import threading
 import lxml.etree
 import Bcfg2.Server
+import Bcfg2.Options
 from Bcfg2.Compat import Queue, Empty, Full, cPickle
 from Bcfg2.Server.Plugin.base import Plugin
 from Bcfg2.Server.Plugin.exceptions import PluginInitError, \
@@ -530,6 +531,11 @@ class Version(Plugin):
 
     create = False
 
+    options = Plugin.options + [
+        Bcfg2.Options.PathOption(cf=('server', 'vcs_root'),
+                                 default='<repository>',
+                                 help='Server VCS repository root')]
+
     #: The path to the VCS metadata file or directory, relative to the
     #: base of the Bcfg2 repository.  E.g., for Subversion this would
     #: be ".svn"
@@ -540,12 +546,8 @@ class Version(Plugin):
     def __init__(self, core, datastore):
         Plugin.__init__(self, core, datastore)
 
-        if core.setup['vcs_root']:
-            self.vcs_root = core.setup['vcs_root']
-        else:
-            self.vcs_root = datastore
         if self.__vcs_metadata_path__:
-            self.vcs_path = os.path.join(self.vcs_root,
+            self.vcs_path = os.path.join(Bcfg2.Options.setup.vcs_root,
                                          self.__vcs_metadata_path__)
 
             if not os.path.exists(self.vcs_path):
diff --git a/src/lib/Bcfg2/Server/Plugins/Bundler.py b/src/lib/Bcfg2/Server/Plugins/Bundler.py
index 2473a3ed2..f91bac634 100644
--- a/src/lib/Bcfg2/Server/Plugins/Bundler.py
+++ b/src/lib/Bcfg2/Server/Plugins/Bundler.py
@@ -6,7 +6,6 @@ import sys
 import copy
 import Bcfg2.Server
 import Bcfg2.Server.Plugin
-import Bcfg2.Server.Lint
 from genshi.template import TemplateError
 
 
@@ -45,6 +44,7 @@ class Bundler(Bcfg2.Server.Plugin.Plugin,
     bundle/translation scheme from Bcfg1. """
     __author__ = 'bcfg-dev@mcs.anl.gov'
     __child__ = BundleFile
+    patterns = re.compile(r'^.*\.(?:xml|genshi)$')
 
     def __init__(self, core, datastore):
         Bcfg2.Server.Plugin.Plugin.__init__(self, core, datastore)
@@ -123,57 +123,3 @@ class Bundler(Bcfg2.Server.Plugin.Plugin,
         return bundleset
     BuildStructures.__doc__ = \
         Bcfg2.Server.Plugin.Structure.BuildStructures.__doc__
-
-
-class BundlerLint(Bcfg2.Server.Lint.ServerPlugin):
-    """ Perform various :ref:`Bundler
-    <server-plugins-structures-bundler-index>` checks. """
-
-    def Run(self):
-        self.missing_bundles()
-        for bundle in self.core.plugins['Bundler'].entries.values():
-            if self.HandlesFile(bundle.name):
-                self.bundle_names(bundle)
-
-    @classmethod
-    def Errors(cls):
-        return {"bundle-not-found": "error",
-                "unused-bundle": "warning",
-                "explicit-bundle-name": "error",
-                "genshi-extension-bundle": "error"}
-
-    def missing_bundles(self):
-        """ Find bundles listed in Metadata but not implemented in
-        Bundler. """
-        if self.files is None:
-            # when given a list of files on stdin, this check is
-            # useless, so skip it
-            groupdata = self.metadata.groups_xml.xdata
-            ref_bundles = set([b.get("name")
-                               for b in groupdata.findall("//Bundle")])
-
-            allbundles = self.core.plugins['Bundler'].bundles.keys()
-            for bundle in ref_bundles:
-                if bundle not in allbundles:
-                    self.LintError("bundle-not-found",
-                                   "Bundle %s referenced, but does not exist" %
-                                   bundle)
-
-            for bundle in allbundles:
-                if bundle not in ref_bundles:
-                    self.LintError("unused-bundle",
-                                   "Bundle %s defined, but is not referenced "
-                                   "in Metadata" % bundle)
-
-    def bundle_names(self, bundle):
-        """ Verify that deprecated bundle .genshi bundles and explicit
-        bundle names aren't used """
-        if bundle.xdata.get('name'):
-            self.LintError("explicit-bundle-name",
-                           "Deprecated explicit bundle name in %s" %
-                           bundle.name)
-
-        if bundle.name.endswith(".genshi"):
-            self.LintError("genshi-extension-bundle",
-                           "Bundle %s uses deprecated .genshi extension" %
-                           bundle.name)
diff --git a/src/lib/Bcfg2/Server/Plugins/Bzr.py b/src/lib/Bcfg2/Server/Plugins/Bzr.py
index e0cbdf72a..f91cc1943 100644
--- a/src/lib/Bcfg2/Server/Plugins/Bzr.py
+++ b/src/lib/Bcfg2/Server/Plugins/Bzr.py
@@ -14,13 +14,13 @@ class Bzr(Bcfg2.Server.Plugin.Version):
     def __init__(self, core, datastore):
         Bcfg2.Server.Plugin.Version.__init__(self, core, datastore)
         self.logger.debug("Initialized Bazaar plugin with directory %s at "
-                          "revision = %s" % (self.vcs_root,
+                          "revision = %s" % (Bcfg2.Options.setup.vcs_root,
                                              self.get_revision()))
 
     def get_revision(self):
         """Read Bazaar revision information for the Bcfg2 repository."""
         try:
-            working_tree = WorkingTree.open(self.vcs_root)
+            working_tree = WorkingTree.open(Bcfg2.Options.setup.vcs_root)
             revision = str(working_tree.branch.revno())
             if (working_tree.has_changes(working_tree.basis_tree()) or
                 working_tree.unknowns()):
diff --git a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgAuthorizedKeysGenerator.py b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgAuthorizedKeysGenerator.py
index a859da0ba..50de498e6 100644
--- a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgAuthorizedKeysGenerator.py
+++ b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgAuthorizedKeysGenerator.py
@@ -3,6 +3,7 @@ based on an XML specification of which SSH keypairs should granted
 access. """
 
 import lxml.etree
+import Bcfg2.Options
 from Bcfg2.Server.Plugin import StructFile, PluginExecutionError
 from Bcfg2.Server.Plugins.Cfg import CfgGenerator, CFG
 from Bcfg2.Server.Plugins.Metadata import ClientMetadata
@@ -27,15 +28,6 @@ class CfgAuthorizedKeysGenerator(CfgGenerator, StructFile):
         self.core = CFG.core
     __init__.__doc__ = CfgGenerator.__init__.__doc__
 
-    @property
-    def category(self):
-        """ The name of the metadata category that generated keys are
-        specific to """
-        if (self.setup.cfp.has_section("sshkeys") and
-            self.setup.cfp.has_option("sshkeys", "category")):
-            return self.setup.cfp.get("sshkeys", "category")
-        return None
-
     def handle_event(self, event):
         CfgGenerator.handle_event(self, event)
         StructFile.HandleEvent(self, event)
@@ -61,12 +53,13 @@ class CfgAuthorizedKeysGenerator(CfgGenerator, StructFile):
                     key_md = ClientMetadata("dummy", group, [group], [],
                                             set(), set(), dict(), None,
                                             None, None, None)
-                elif (self.category and
-                      not metadata.group_in_category(self.category)):
+                elif (Bcfg2.Options.setup.sshkeys_category and
+                      not metadata.group_in_category(
+                        Bcfg2.Options.setup.sshkeys_category)):
                     self.logger.warning("Cfg: %s ignoring Allow from %s: "
                                         "No group in category %s" %
                                         (metadata.hostname, pubkey_name,
-                                         self.category))
+                                         Bcfg2.Options.setup.sshkeys_category))
                     continue
                 else:
                     key_md = metadata
diff --git a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgCheetahGenerator.py b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgCheetahGenerator.py
index 4c8adceec..476dc1fc6 100644
--- a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgCheetahGenerator.py
+++ b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgCheetahGenerator.py
@@ -2,6 +2,7 @@
 <http://www.cheetahtemplate.org/>`_ templating system to generate
 :ref:`server-plugins-generators-cfg` files. """
 
+import Bcfg2.Options
 from Bcfg2.Server.Plugin import PluginExecutionError
 from Bcfg2.Server.Plugins.Cfg import CfgGenerator
 
@@ -27,19 +28,19 @@ class CfgCheetahGenerator(CfgGenerator):
     #: :class:`Cheetah.Template.Template` compiler settings
     settings = dict(useStackFrames=False)
 
-    def __init__(self, fname, spec, encoding):
-        CfgGenerator.__init__(self, fname, spec, encoding)
+    def __init__(self, fname, spec):
+        CfgGenerator.__init__(self, fname, spec)
         if not HAS_CHEETAH:
             raise PluginExecutionError("Cheetah is not available")
     __init__.__doc__ = CfgGenerator.__init__.__doc__
 
     def get_data(self, entry, metadata):
-        template = Template(self.data.decode(self.encoding),
+        template = Template(self.data.decode(Bcfg2.Options.setup.encoding),
                             compilerSettings=self.settings)
         template.metadata = metadata
         template.name = entry.get('realname', entry.get('name'))
         template.path = entry.get('realname', entry.get('name'))
         template.source_path = self.name
-        template.repo = self.setup['repo']
+        template.repo = Bcfg2.Options.setup.repository
         return template.respond()
     get_data.__doc__ = CfgGenerator.get_data.__doc__
diff --git a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgEncryptedGenerator.py b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgEncryptedGenerator.py
index 516eba2f6..e2a2f696a 100644
--- a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgEncryptedGenerator.py
+++ b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgEncryptedGenerator.py
@@ -21,8 +21,8 @@ class CfgEncryptedGenerator(CfgGenerator):
     #: .genshi.crypt and .cheetah.crypt files
     __priority__ = 50
 
-    def __init__(self, fname, spec, encoding):
-        CfgGenerator.__init__(self, fname, spec, encoding)
+    def __init__(self, fname, spec):
+        CfgGenerator.__init__(self, fname, spec)
         if not HAS_CRYPTO:
             raise PluginExecutionError("M2Crypto is not available")
     __init__.__doc__ = CfgGenerator.__init__.__doc__
diff --git a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgEncryptedGenshiGenerator.py b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgEncryptedGenshiGenerator.py
index 0521485e8..f69ab8e5f 100644
--- a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgEncryptedGenshiGenerator.py
+++ b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgEncryptedGenshiGenerator.py
@@ -37,7 +37,7 @@ class CfgEncryptedGenshiGenerator(CfgGenshiGenerator):
     #: when it's read in
     __loader_cls__ = EncryptedTemplateLoader
 
-    def __init__(self, fname, spec, encoding):
-        CfgGenshiGenerator.__init__(self, fname, spec, encoding)
+    def __init__(self, fname, spec):
+        CfgGenshiGenerator.__init__(self, fname, spec)
         if not HAS_CRYPTO:
             raise PluginExecutionError("M2Crypto is not available")
diff --git a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgExternalCommandVerifier.py b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgExternalCommandVerifier.py
index d06b864ac..953473a12 100644
--- a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgExternalCommandVerifier.py
+++ b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgExternalCommandVerifier.py
@@ -15,8 +15,8 @@ class CfgExternalCommandVerifier(CfgVerifier):
     #: Handle :file:`:test` files
     __basenames__ = [':test']
 
-    def __init__(self, name, specific, encoding):
-        CfgVerifier.__init__(self, name, specific, encoding)
+    def __init__(self, name, specific):
+        CfgVerifier.__init__(self, name, specific)
         self.cmd = []
         self.exc = Executor(timeout=30)
     __init__.__doc__ = CfgVerifier.__init__.__doc__
diff --git a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgGenshiGenerator.py b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgGenshiGenerator.py
index e056c871a..7ba8c4491 100644
--- a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgGenshiGenerator.py
+++ b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgGenshiGenerator.py
@@ -5,9 +5,9 @@
 import re
 import sys
 import traceback
+import Bcfg2.Options
 from Bcfg2.Server.Plugin import PluginExecutionError, removecomment
 from Bcfg2.Server.Plugins.Cfg import CfgGenerator
-
 from genshi.template import TemplateLoader, NewTextTemplate
 from genshi.template.eval import UndefinedError, Suite
 
@@ -70,8 +70,8 @@ class CfgGenshiGenerator(CfgGenerator):
     #: occurred.
     pyerror_re = re.compile(r'<\w+ u?[\'"](.*?)\s*\.\.\.[\'"]>')
 
-    def __init__(self, fname, spec, encoding):
-        CfgGenerator.__init__(self, fname, spec, encoding)
+    def __init__(self, fname, spec):
+        CfgGenerator.__init__(self, fname, spec)
         self.template = None
         self.loader = self.__loader_cls__(max_cache_size=0)
     __init__.__doc__ = CfgGenerator.__init__.__doc__
@@ -87,13 +87,15 @@ class CfgGenshiGenerator(CfgGenerator):
             metadata=metadata,
             path=self.name,
             source_path=self.name,
-            repo=self.setup['repo']).filter(removecomment)
+            repo=Bcfg2.Options.setup.repository).filter(removecomment)
         try:
             try:
-                return stream.render('text', encoding=self.encoding,
+                return stream.render('text',
+                                     encoding=Bcfg2.Options.setup.encoding,
                                      strip_whitespace=False)
             except TypeError:
-                return stream.render('text', encoding=self.encoding)
+                return stream.render('text',
+                                     encoding=Bcfg2.Options.setup.encoding)
         except UndefinedError:
             # a failure in a genshi expression _other_ than %{ python ... %}
             err = sys.exc_info()[1]
@@ -172,8 +174,9 @@ class CfgGenshiGenerator(CfgGenerator):
     def handle_event(self, event):
         CfgGenerator.handle_event(self, event)
         try:
-            self.template = self.loader.load(self.name, cls=NewTextTemplate,
-                                             encoding=self.encoding)
+            self.template = \
+                self.loader.load(self.name, cls=NewTextTemplate,
+                                 encoding=Bcfg2.Options.setup.encoding)
         except:
             raise PluginExecutionError("Failed to load template: %s" %
                                        sys.exc_info()[1])
diff --git a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgPrivateKeyCreator.py b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgPrivateKeyCreator.py
index 862726788..7bb5d3cf5 100644
--- a/src/lib/Bcfg2/Server/Plugins/Cfg/CfgPrivateKeyCreator.py
+++ b/src/lib/Bcfg2/Server/Plugins/Cfg/CfgPrivateKeyCreator.py
@@ -3,8 +3,8 @@
 import os
 import shutil
 import tempfile
+import Bcfg2.Options
 from Bcfg2.Utils import Executor
-from Bcfg2.Options import get_option_parser
 from Bcfg2.Server.Plugin import StructFile
 from Bcfg2.Server.Plugins.Cfg import CfgCreator, CfgCreationError
 from Bcfg2.Server.Plugins.Cfg.CfgPublicKeyCreator import CfgPublicKeyCreator
@@ -25,6 +25,14 @@ class CfgPrivateKeyCreator(CfgCreator, StructFile):
     #: Handle XML specifications of private keys
     __basenames__ = ['privkey.xml']
 
+    options = [
+        Bcfg2.Options.Option(
+            cf=("sshkeys", "category"), dest="sshkeys_category",
+            help="Metadata category that generated SSH keys are specific to"),
+        Bcfg2.Options.Option(
+            cf=("sshkeys", "passphrase"), dest="sshkeys_passphrase",
+            help="Passphrase used to encrypt generated SSH private keys")]
+
     def __init__(self, fname):
         CfgCreator.__init__(self, fname)
         StructFile.__init__(self, fname)
@@ -32,27 +40,15 @@ class CfgPrivateKeyCreator(CfgCreator, StructFile):
         pubkey_path = os.path.dirname(self.name) + ".pub"
         pubkey_name = os.path.join(pubkey_path, os.path.basename(pubkey_path))
         self.pubkey_creator = CfgPublicKeyCreator(pubkey_name)
-        self.setup = get_option_parser()
         self.cmd = Executor()
     __init__.__doc__ = CfgCreator.__init__.__doc__
 
     @property
-    def category(self):
-        """ The name of the metadata category that generated keys are
-        specific to """
-        if (self.setup.cfp.has_section("sshkeys") and
-            self.setup.cfp.has_option("sshkeys", "category")):
-            return self.setup.cfp.get("sshkeys", "category")
-        return None
-
-    @property
     def passphrase(self):
         """ The passphrase used to encrypt private keys """
-        if (HAS_CRYPTO and
-            self.setup.cfp.has_section("sshkeys") and
-            self.setup.cfp.has_option("sshkeys", "passphrase")):
-            return Bcfg2.Server.Encryption.get_passphrases()[
-                self.setup.cfp.get("sshkeys", "passphrase")]
+        if HAS_CRYPTO and Bcfg2.Options.setup.sshkeys_passphrase:
+            return Bcfg2.Options.setup.passphrases[
+                Bcfg2.Options.setup.sshkeys_passphrase]
         return None
 
     def handle_event(self, event):
@@ -141,7 +137,7 @@ class CfgPrivateKeyCreator(CfgCreator, StructFile):
         """
         if spec is None:
             spec = self.XMLMatch(metadata)
-        category = spec.get("category", self.category)
+        category = spec.get("category", Bcfg2.Options.setup.sshkeys_category)
         if category is None:
             per_host_default = "true"
         else:
diff --git a/src/lib/Bcfg2/Server/Plugins/Cfg/__init__.py b/src/lib/Bcfg2/Server/Plugins/Cfg/__init__.py
index 8a787751c..ed349c87c 100644
--- a/src/lib/Bcfg2/Server/Plugins/Cfg/__init__.py
+++ b/src/lib/Bcfg2/Server/Plugins/Cfg/__init__.py
@@ -3,17 +3,14 @@
 import re
 import os
 import sys
-import stat
 import errno
 import operator
 import lxml.etree
 import Bcfg2.Options
 import Bcfg2.Server.Plugin
-import Bcfg2.Server.Lint
 from Bcfg2.Server.Plugin import PluginExecutionError
 # pylint: disable=W0622
-from Bcfg2.Compat import u_str, unicode, b64encode, walk_packages, \
-    any, oct_mode
+from Bcfg2.Compat import u_str, unicode, b64encode, any, oct_mode
 # pylint: enable=W0622
 
 #: CFG is a reference to the :class:`Bcfg2.Server.Plugins.Cfg.Cfg`
@@ -24,27 +21,8 @@ from Bcfg2.Compat import u_str, unicode, b64encode, walk_packages, \
 #: facility for passing it otherwise.
 CFG = None
 
-_HANDLERS = []
 
-
-def handlers():
-    """ A list of Cfg handler classes. Loading the handlers must
-    be done at run-time, not at compile-time, or it causes a
-    circular import and Bad Things Happen."""
-    if not _HANDLERS:
-        for submodule in walk_packages(path=__path__, prefix=__name__ + "."):
-            mname = submodule[1].rsplit('.', 1)[-1]
-            module = getattr(__import__(submodule[1]).Server.Plugins.Cfg,
-                             mname)
-            hdlr = getattr(module, mname)
-            if issubclass(hdlr, CfgBaseFileMatcher):
-                _HANDLERS.append(hdlr)
-        _HANDLERS.sort(key=operator.attrgetter("__priority__"))
-    return _HANDLERS
-
-
-class CfgBaseFileMatcher(Bcfg2.Server.Plugin.SpecificData,
-                         Bcfg2.Server.Plugin.Debuggable):
+class CfgBaseFileMatcher(Bcfg2.Server.Plugin.SpecificData):
     """ .. currentmodule:: Bcfg2.Server.Plugins.Cfg
 
     CfgBaseFileMatcher is the parent class for all Cfg handler
@@ -88,12 +66,8 @@ class CfgBaseFileMatcher(Bcfg2.Server.Plugin.SpecificData,
     #: Flag to indicate an experimental handler.
     experimental = False
 
-    def __init__(self, name, specific, encoding):
-        Bcfg2.Server.Plugin.SpecificData.__init__(self, name, specific,
-                                                  encoding)
-        Bcfg2.Server.Plugin.Debuggable.__init__(self)
-        self.encoding = encoding
-        self.setup = Bcfg2.Options.get_option_parser()
+    def __init__(self, name, specific):
+        Bcfg2.Server.Plugin.SpecificData.__init__(self, name, specific)
     __init__.__doc__ = Bcfg2.Server.Plugin.SpecificData.__init__.__doc__ + \
         """
 .. -----
@@ -184,7 +158,7 @@ class CfgGenerator(CfgBaseFileMatcher):
     client. See :class:`Bcfg2.Server.Plugin.helpers.EntrySet` for more
     details on how the best handler is chosen."""
 
-    def __init__(self, name, specific, encoding):
+    def __init__(self, name, specific):
         # we define an __init__ that just calls the parent __init__,
         # so that we can set the docstring on __init__ to something
         # different from the parent __init__ -- namely, the parent
@@ -192,7 +166,7 @@ class CfgGenerator(CfgBaseFileMatcher):
         # which we use to delineate the actual docs from the
         # .. autoattribute hacks we have to do to get private
         # attributes included in sphinx 1.0 """
-        CfgBaseFileMatcher.__init__(self, name, specific, encoding)
+        CfgBaseFileMatcher.__init__(self, name, specific)
     __init__.__doc__ = CfgBaseFileMatcher.__init__.__doc__.split(".. -----")[0]
 
     def get_data(self, entry, metadata):  # pylint: disable=W0613
@@ -212,9 +186,9 @@ class CfgFilter(CfgBaseFileMatcher):
     """ CfgFilters modify the initial content of a file after it has
     been generated by a :class:`Bcfg2.Server.Plugins.Cfg.CfgGenerator`. """
 
-    def __init__(self, name, specific, encoding):
+    def __init__(self, name, specific):
         # see comment on CfgGenerator.__init__ above
-        CfgBaseFileMatcher.__init__(self, name, specific, encoding)
+        CfgBaseFileMatcher.__init__(self, name, specific)
     __init__.__doc__ = CfgBaseFileMatcher.__init__.__doc__.split(".. -----")[0]
 
     def modify_data(self, entry, metadata, data):
@@ -252,7 +226,7 @@ class CfgInfo(CfgBaseFileMatcher):
         .. -----
         .. autoattribute:: Bcfg2.Server.Plugins.Cfg.CfgInfo.__specific__
         """
-        CfgBaseFileMatcher.__init__(self, fname, None, None)
+        CfgBaseFileMatcher.__init__(self, fname, None)
 
     def bind_info_to_entry(self, entry, metadata):
         """ Assign the appropriate attributes to the entry, modifying
@@ -275,9 +249,9 @@ class CfgVerifier(CfgBaseFileMatcher):
     etc.), or both.
     """
 
-    def __init__(self, name, specific, encoding):
+    def __init__(self, name, specific):
         # see comment on CfgGenerator.__init__ above
-        CfgBaseFileMatcher.__init__(self, name, specific, encoding)
+        CfgBaseFileMatcher.__init__(self, name, specific)
     __init__.__doc__ = CfgBaseFileMatcher.__init__.__doc__.split(".. -----")[0]
 
     def verify_entry(self, entry, metadata, data):
@@ -316,7 +290,7 @@ class CfgCreator(CfgBaseFileMatcher):
         .. -----
         .. autoattribute:: Bcfg2.Server.Plugins.Cfg.CfgCreator.__specific__
         """
-        CfgBaseFileMatcher.__init__(self, fname, None, None)
+        CfgBaseFileMatcher.__init__(self, fname, None)
 
     def create_data(self, entry, metadata):
         """ Create new data for the given entry and write it to disk
@@ -430,26 +404,31 @@ class CfgDefaultInfo(CfgInfo):
     bind_info_to_entry.__doc__ = CfgInfo.bind_info_to_entry.__doc__
 
 
-class CfgEntrySet(Bcfg2.Server.Plugin.EntrySet,
-                  Bcfg2.Server.Plugin.Debuggable):
+class CfgEntrySet(Bcfg2.Server.Plugin.EntrySet):
     """ Handle a collection of host- and group-specific Cfg files with
     multiple different Cfg handlers in a single directory. """
 
-    def __init__(self, basename, path, entry_type, encoding):
-        Bcfg2.Server.Plugin.EntrySet.__init__(self, basename, path,
-                                              entry_type, encoding)
-        Bcfg2.Server.Plugin.Debuggable.__init__(self)
+    def __init__(self, basename, path, entry_type):
+        Bcfg2.Server.Plugin.EntrySet.__init__(self, basename, path, entry_type)
         self.specific = None
         self._handlers = None
-        self.setup = Bcfg2.Options.get_option_parser()
     __init__.__doc__ = Bcfg2.Server.Plugin.EntrySet.__doc__
 
+
     def set_debug(self, debug):
-        rv = Bcfg2.Server.Plugin.Debuggable.set_debug(self, debug)
+        rv = Bcfg2.Server.Plugin.EntrySet.set_debug(self, debug)
         for entry in self.entries.values():
             entry.set_debug(debug)
         return rv
 
+    @property
+    def handlers(self):
+        """ A list of Cfg handler classes. """
+        if self._handlers is None:
+            self._handlers = Bcfg2.Options.setup.cfg_handlers
+            self._handlers.sort(key=operator.attrgetter("__priority__"))
+        return self._handlers
+
     def handle_event(self, event):
         """ Dispatch a FAM event to :func:`entry_init` or the
         appropriate child handler object.
@@ -466,7 +445,7 @@ class CfgEntrySet(Bcfg2.Server.Plugin.EntrySet,
                 # process a bogus changed event like a created
                 return
 
-            for hdlr in handlers():
+            for hdlr in self.handlers:
                 if hdlr.handles(event, basename=self.path):
                     if action == 'changed':
                         # warn about a bogus 'changed' event, but
@@ -559,7 +538,7 @@ class CfgEntrySet(Bcfg2.Server.Plugin.EntrySet,
                     # most specific to least specific.
                     data = fltr.modify_data(entry, metadata, data)
 
-        if self.setup['validate']:
+        if Bcfg2.Options.setup.cfg_validation:
             try:
                 self._validate_data(entry, metadata, data)
             except CfgVerificationError:
@@ -575,7 +554,7 @@ class CfgEntrySet(Bcfg2.Server.Plugin.EntrySet,
                 if not isinstance(data, unicode):
                     if not isinstance(data, str):
                         data = data.decode('utf-8')
-                    data = u_str(data, self.encoding)
+                    data = u_str(data, Bcfg2.Options.setup.encoding)
             except UnicodeDecodeError:
                 msg = "Failed to decode %s: %s" % (entry.get('name'),
                                                    sys.exc_info()[1])
@@ -756,10 +735,10 @@ class CfgEntrySet(Bcfg2.Server.Plugin.EntrySet,
                 self.logger.error(msg)
                 raise PluginExecutionError(msg)
             try:
-                etext = new_entry['text'].encode(self.encoding)
+                etext = new_entry['text'].encode(Bcfg2.Options.setup.encoding)
             except:
                 msg = "Cfg: Cannot encode content of %s as %s" % \
-                    (name, self.encoding)
+                    (name, Bcfg2.Options.setup.encoding)
                 self.logger.error(msg)
                 raise PluginExecutionError(msg)
             open(name, 'w').write(etext)
@@ -784,6 +763,10 @@ class CfgEntrySet(Bcfg2.Server.Plugin.EntrySet,
                            flag=log)
 
 
+class CfgHandlerAction(Bcfg2.Options.ComponentAction):
+    bases = ['Bcfg2.Server.Plugins.Cfg']
+
+
 class Cfg(Bcfg2.Server.Plugin.GroupSpool,
           Bcfg2.Server.Plugin.PullTarget):
     """ The Cfg plugin provides a repository to describe configuration
@@ -795,17 +778,27 @@ class Cfg(Bcfg2.Server.Plugin.GroupSpool,
     es_cls = CfgEntrySet
     es_child_cls = Bcfg2.Server.Plugin.SpecificData
 
+    options = Bcfg2.Server.Plugin.GroupSpool.options + [
+        Bcfg2.Options.BooleanOption(
+           '--cfg-validation', cf=('cfg', 'validation'), default=True,
+           help='Run validation on Cfg files'),
+        Bcfg2.Options.Option(
+            cf=("cfg", "handlers"), dest="cfg_handlers",
+            help="Cfg handlers to load",
+            type=Bcfg2.Options.Types.comma_list, action=CfgHandlerAction,
+            default=['CfgAuthorizedKeysGenerator', 'CfgEncryptedGenerator',
+                     'CfgCheetahGenerator', 'CfgEncryptedCheetahGenerator',
+                     'CfgGenshiGenerator', 'CfgEncryptedGenshiGenerator',
+                     'CfgExternalCommandVerifier', 'CfgInfoXML',
+                     'CfgPlaintextGenerator',
+                     'CfgPrivateKeyCreator', 'CfgPublicKeyCreator'])]
+
     def __init__(self, core, datastore):
         global CFG  # pylint: disable=W0603
         Bcfg2.Server.Plugin.GroupSpool.__init__(self, core, datastore)
         Bcfg2.Server.Plugin.PullTarget.__init__(self)
 
         CFG = self
-
-        setup = Bcfg2.Options.get_option_parser()
-        if 'validate' not in setup:
-            setup.add_option('validate', Bcfg2.Options.CFG_VALIDATION)
-            setup.reparse()
     __init__.__doc__ = Bcfg2.Server.Plugin.GroupSpool.__init__.__doc__
 
     def has_generator(self, entry, metadata):
@@ -839,77 +832,3 @@ class Cfg(Bcfg2.Server.Plugin.GroupSpool,
                                                                 log)
     AcceptPullData.__doc__ = \
         Bcfg2.Server.Plugin.PullTarget.AcceptPullData.__doc__
-
-
-class CfgLint(Bcfg2.Server.Lint.ServerPlugin):
-    """ warn about usage of .cat and .diff files """
-
-    def Run(self):
-        for basename, entry in list(self.core.plugins['Cfg'].entries.items()):
-            self.check_pubkey(basename, entry)
-        self.check_missing_files()
-
-    @classmethod
-    def Errors(cls):
-        return {"no-pubkey-xml": "warning",
-                "unknown-cfg-files": "error",
-                "extra-cfg-files": "error"}
-
-    def check_pubkey(self, basename, entry):
-        """ check that privkey.xml files have corresponding pubkey.xml
-        files """
-        if "privkey.xml" not in entry.entries:
-            return
-        privkey = entry.entries["privkey.xml"]
-        if not self.HandlesFile(privkey.name):
-            return
-
-        pubkey = basename + ".pub"
-        if pubkey not in self.core.plugins['Cfg'].entries:
-            self.LintError("no-pubkey-xml",
-                           "%s has no corresponding pubkey.xml at %s" %
-                           (basename, pubkey))
-        else:
-            pubset = self.core.plugins['Cfg'].entries[pubkey]
-            if "pubkey.xml" not in pubset.entries:
-                self.LintError("no-pubkey-xml",
-                               "%s has no corresponding pubkey.xml at %s" %
-                               (basename, pubkey))
-
-    def check_missing_files(self):
-        """ check that all files on the filesystem are known to Cfg """
-        cfg = self.core.plugins['Cfg']
-
-        # first, collect ignore patterns from handlers
-        ignore = []
-        for hdlr in handlers():
-            ignore.extend(hdlr.__ignore__)
-
-        # next, get a list of all non-ignored files on the filesystem
-        all_files = set()
-        for root, _, files in os.walk(cfg.data):
-            all_files.update(os.path.join(root, fname)
-                             for fname in files
-                             if not any(fname.endswith("." + i)
-                                        for i in ignore))
-
-        # next, get a list of all files known to Cfg
-        cfg_files = set()
-        for root, eset in cfg.entries.items():
-            cfg_files.update(os.path.join(cfg.data, root.lstrip("/"), fname)
-                             for fname in eset.entries.keys())
-
-        # finally, compare the two
-        unknown_files = all_files - cfg_files
-        extra_files = cfg_files - all_files
-        if unknown_files:
-            self.LintError(
-                "unknown-cfg-files",
-                "Files on the filesystem could not be understood by Cfg: %s" %
-                "; ".join(unknown_files))
-        if extra_files:
-            self.LintError(
-                "extra-cfg-files",
-                "Cfg has entries for files that do not exist on the "
-                "filesystem: %s\nThis is probably a bug." %
-                "; ".join(extra_files))
diff --git a/src/lib/Bcfg2/Server/Plugins/Cvs.py b/src/lib/Bcfg2/Server/Plugins/Cvs.py
index 0054a8a37..09fbfaea7 100644
--- a/src/lib/Bcfg2/Server/Plugins/Cvs.py
+++ b/src/lib/Bcfg2/Server/Plugins/Cvs.py
@@ -20,7 +20,7 @@ class Cvs(Bcfg2.Server.Plugin.Version):
     def get_revision(self):
         """Read cvs revision information for the Bcfg2 repository."""
         result = self.cmd.run(["env LC_ALL=C", "cvs", "log"],
-                              shell=True, cwd=self.vcs_root)
+                              shell=True, cwd=Bcfg2.Options.setup.vcs_root)
         try:
             return result.stdout.splitlines()[0].strip()
         except (IndexError, AttributeError):
diff --git a/src/lib/Bcfg2/Server/Plugins/Darcs.py b/src/lib/Bcfg2/Server/Plugins/Darcs.py
index 2c6dde393..b48809cac 100644
--- a/src/lib/Bcfg2/Server/Plugins/Darcs.py
+++ b/src/lib/Bcfg2/Server/Plugins/Darcs.py
@@ -20,7 +20,7 @@ class Darcs(Bcfg2.Server.Plugin.Version):
     def get_revision(self):
         """Read Darcs changeset information for the Bcfg2 repository."""
         result = self.cmd.run(["env LC_ALL=C", "darcs", "changes"],
-                              shell=True, cwd=self.vcs_root)
+                              shell=True, cwd=Bcfg2.Options.setup.vcs_root)
         if result.success:
             return result.stdout.splitlines()[0].strip()
         else:
diff --git a/src/lib/Bcfg2/Server/Plugins/Defaults.py b/src/lib/Bcfg2/Server/Plugins/Defaults.py
index 04c14aa96..79e2ca0e2 100644
--- a/src/lib/Bcfg2/Server/Plugins/Defaults.py
+++ b/src/lib/Bcfg2/Server/Plugins/Defaults.py
@@ -9,6 +9,8 @@ class Defaults(Bcfg2.Server.Plugins.Rules.Rules,
     """Set default attributes on bound entries"""
     __author__ = 'bcfg-dev@mcs.anl.gov'
 
+    options = Bcfg2.Server.Plugin.PrioDir.options
+
     # Rules is a Generator that happens to implement all of the
     # functionality we want, so we overload it, but Defaults should
     # _not_ handle any entries; it does its stuff in the structure
diff --git a/src/lib/Bcfg2/Server/Plugins/Deps.py b/src/lib/Bcfg2/Server/Plugins/Deps.py
index 312b03bae..fa821aad3 100644
--- a/src/lib/Bcfg2/Server/Plugins/Deps.py
+++ b/src/lib/Bcfg2/Server/Plugins/Deps.py
@@ -48,7 +48,8 @@ class Deps(Bcfg2.Server.Plugin.PrioDir,
             prereqs = self.calculate_prereqs(metadata, entries)
             self.cache[(entries, groups)] = prereqs
 
-        newstruct = lxml.etree.Element("Independent")
+        newstruct = lxml.etree.Element("Independent",
+                                       name=self.__class__.__name__)
         for tag, name in prereqs:
             lxml.etree.SubElement(newstruct, tag, name=name)
         structures.append(newstruct)
diff --git a/src/lib/Bcfg2/Server/Plugins/FileProbes.py b/src/lib/Bcfg2/Server/Plugins/FileProbes.py
index a3bba14f3..45511eb52 100644
--- a/src/lib/Bcfg2/Server/Plugins/FileProbes.py
+++ b/src/lib/Bcfg2/Server/Plugins/FileProbes.py
@@ -8,7 +8,6 @@ import os
 import sys
 import errno
 import lxml.etree
-import Bcfg2.Options
 import Bcfg2.Server
 import Bcfg2.Server.Plugin
 import Bcfg2.Server.FileMonitor
@@ -220,12 +219,12 @@ class FileProbes(Bcfg2.Server.Plugin.Plugin,
             return
 
         self.logger.info("Writing %s for %s" % (infoxml, data.get("name")))
+        default_mdata = Bcfg2.Server.Plugin.default_path_metadata()
         info = lxml.etree.Element(
             "Info",
-            owner=data.get("owner", Bcfg2.Options.MDATA_OWNER.value),
-            group=data.get("group", Bcfg2.Options.MDATA_GROUP.value),
-            mode=data.get("mode", Bcfg2.Options.MDATA_MODE.value),
-            encoding=entry.get("encoding", Bcfg2.Options.ENCODING.value))
+            owner=data.get("owner", default_mdata['owner']),
+            group=data.get("group", default_mdata['group']),
+            mode=data.get("mode", default_mdata['mode']))
 
         root = lxml.etree.Element("FileInfo")
         root.append(info)
diff --git a/src/lib/Bcfg2/Server/Plugins/Fossil.py b/src/lib/Bcfg2/Server/Plugins/Fossil.py
index 05cf4e5d4..f6aa3221a 100644
--- a/src/lib/Bcfg2/Server/Plugins/Fossil.py
+++ b/src/lib/Bcfg2/Server/Plugins/Fossil.py
@@ -20,7 +20,7 @@ class Fossil(Bcfg2.Server.Plugin.Version):
     def get_revision(self):
         """Read fossil revision information for the Bcfg2 repository."""
         result = self.cmd.run(["env LC_ALL=C", "fossil", "info"],
-                              shell=True, cwd=self.vcs_root)
+                              shell=True, cwd=Bcfg2.Options.setup.vcs_root)
         try:
             revision = None
             for line in result.stdout.splitlines():
diff --git a/src/lib/Bcfg2/Server/Plugins/Git.py b/src/lib/Bcfg2/Server/Plugins/Git.py
index 58a5c58f0..d0502ed6a 100644
--- a/src/lib/Bcfg2/Server/Plugins/Git.py
+++ b/src/lib/Bcfg2/Server/Plugins/Git.py
@@ -23,7 +23,7 @@ class Git(Version):
     def __init__(self, core, datastore):
         Version.__init__(self, core, datastore)
         if HAS_GITPYTHON:
-            self.repo = git.Repo(self.vcs_root)
+            self.repo = git.Repo(Bcfg2.Options.setup.vcs_root)
             self.cmd = None
         else:
             self.logger.debug("Git: GitPython not found, using CLI interface "
@@ -45,7 +45,8 @@ class Git(Version):
                 return self.repo.head.commit.hexsha
             else:
                 cmd = ["git", "--git-dir", self.vcs_path,
-                       "--work-tree", self.vcs_root, "rev-parse", "HEAD"]
+                       "--work-tree", Bcfg2.Options.setup.vcs_root,
+                       "rev-parse", "HEAD"]
                 self.debug_log("Git: Running %s" % cmd)
                 result = self.cmd.run(cmd)
                 if not result.success:
@@ -53,7 +54,7 @@ class Git(Version):
                 return result.stdout
         except:
             raise PluginExecutionError("Git: Error getting revision from %s: "
-                                       "%s" % (self.vcs_root,
+                                       "%s" % (Bcfg2.Options.setup.vcs_root,
                                                sys.exc_info()[1]))
 
     def Update(self, ref=None):
@@ -62,14 +63,15 @@ class Git(Version):
         """
         self.logger.info("Git: Git.Update(ref='%s')" % ref)
         self.debug_log("Git: Performing garbage collection on repo at %s" %
-                       self.vcs_root)
+                       Bcfg2.Options.setup.vcs_root)
         try:
             self._log_git_cmd(self.repo.git.gc('--auto'))
         except git.GitCommandError:
             self.logger.warning("Git: Failed to perform garbage collection: %s"
                                 % sys.exc_info()[1])
 
-        self.debug_log("Git: Fetching all refs for repo at %s" % self.vcs_root)
+        self.debug_log("Git: Fetching all refs for repo at %s" %
+                       Bcfg2.Options.setup.vcs_root)
         try:
             self._log_git_cmd(self.repo.git.fetch('--all'))
         except git.GitCommandError:
@@ -102,5 +104,5 @@ class Git(Version):
                                            "upstream: %s" % sys.exc_info()[1])
 
         self.logger.info("Git: Repo at %s updated to %s" %
-                         (self.vcs_root, self.get_revision()))
+                         (Bcfg2.Options.setup.vcs_root, self.get_revision()))
         return True
diff --git a/src/lib/Bcfg2/Server/Plugins/GroupPatterns.py b/src/lib/Bcfg2/Server/Plugins/GroupPatterns.py
index 3e5508160..90cbd083d 100644
--- a/src/lib/Bcfg2/Server/Plugins/GroupPatterns.py
+++ b/src/lib/Bcfg2/Server/Plugins/GroupPatterns.py
@@ -122,40 +122,3 @@ class GroupPatterns(Bcfg2.Server.Plugin.Plugin,
 
     def get_additional_groups(self, metadata):
         return self.config.process_patterns(metadata.hostname)
-
-
-class GroupPatternsLint(Bcfg2.Server.Lint.ServerPlugin):
-    """ ``bcfg2-lint`` plugin to check all given :ref:`GroupPatterns
-    <server-plugins-grouping-grouppatterns>` patterns for validity.
-    This is simply done by trying to create a
-    :class:`Bcfg2.Server.Plugins.GroupPatterns.PatternMap` object for
-    each pattern, and catching exceptions and presenting them as
-    ``bcfg2-lint`` errors."""
-
-    def Run(self):
-        cfg = self.core.plugins['GroupPatterns'].config
-        for entry in cfg.xdata.xpath('//GroupPattern'):
-            groups = [g.text for g in entry.findall('Group')]
-            self.check(entry, groups, ptype='NamePattern')
-            self.check(entry, groups, ptype='NameRange')
-
-    @classmethod
-    def Errors(cls):
-        return {"pattern-fails-to-initialize": "error"}
-
-    def check(self, entry, groups, ptype="NamePattern"):
-        """ Check a single pattern for validity """
-        if ptype == "NamePattern":
-            pmap = lambda p: PatternMap(p, None, groups)
-        else:
-            pmap = lambda p: PatternMap(None, p, groups)
-
-        for el in entry.findall(ptype):
-            pat = el.text
-            try:
-                pmap(pat)
-            except:  # pylint: disable=W0702
-                err = sys.exc_info()[1]
-                self.LintError("pattern-fails-to-initialize",
-                               "Failed to initialize %s %s for %s: %s" %
-                               (ptype, pat, entry.get('pattern'), err))
diff --git a/src/lib/Bcfg2/Server/Plugins/Hg.py b/src/lib/Bcfg2/Server/Plugins/Hg.py
index 3fd3918bd..f9a9f858c 100644
--- a/src/lib/Bcfg2/Server/Plugins/Hg.py
+++ b/src/lib/Bcfg2/Server/Plugins/Hg.py
@@ -20,7 +20,7 @@ class Hg(Bcfg2.Server.Plugin.Version):
     def get_revision(self):
         """Read hg revision information for the Bcfg2 repository."""
         try:
-            repo_path = self.vcs_root + "/"
+            repo_path = Bcfg2.Options.setup.vcs_root + "/"
             repo = hg.repository(ui.ui(), repo_path)
             tip = repo.changelog.tip()
             return repo.changelog.rev(tip)
diff --git a/src/lib/Bcfg2/Server/Plugins/Ldap.py b/src/lib/Bcfg2/Server/Plugins/Ldap.py
index 8e8b078d9..6fc89b4f3 100644
--- a/src/lib/Bcfg2/Server/Plugins/Ldap.py
+++ b/src/lib/Bcfg2/Server/Plugins/Ldap.py
@@ -3,7 +3,6 @@ import logging
 import sys
 import time
 import traceback
-import Bcfg2.Options
 import Bcfg2.Server.Plugin
 
 logger = logging.getLogger('Bcfg2.Plugins.Ldap')
diff --git a/src/lib/Bcfg2/Server/Plugins/Metadata.py b/src/lib/Bcfg2/Server/Plugins/Metadata.py
index a9b622637..a2eeffc3d 100644
--- a/src/lib/Bcfg2/Server/Plugins/Metadata.py
+++ b/src/lib/Bcfg2/Server/Plugins/Metadata.py
@@ -12,39 +12,45 @@ import socket
 import logging
 import lxml.etree
 import Bcfg2.Server
-import Bcfg2.Server.Lint
+import Bcfg2.Options
 import Bcfg2.Server.Plugin
 import Bcfg2.Server.FileMonitor
 from Bcfg2.Utils import locked
 from Bcfg2.Compat import MutableMapping, all, wraps  # pylint: disable=W0622
 from Bcfg2.version import Bcfg2VersionInfo
 
-try:
-    from django.db import models
-    HAS_DJANGO = True
-except ImportError:
-    HAS_DJANGO = False
 
-LOGGER = logging.getLogger(__name__)
+MetadataClientModel = None
+HAS_DJANGO = False
 
 
-if HAS_DJANGO:
+def load_django_models():
+    global MetadataClientModel, ClientVersions, HAS_DJANGO
+
+    try:
+        from django.db import models
+        HAS_DJANGO = True
+    except ImportError:
+        HAS_DJANGO = False
+        return
+
     class MetadataClientModel(models.Model,
                               Bcfg2.Server.Plugin.PluginDatabaseModel):
         """ django model for storing clients in the database """
         hostname = models.CharField(max_length=255, primary_key=True)
         version = models.CharField(max_length=31, null=True)
 
+
     class ClientVersions(MutableMapping,
                          Bcfg2.Server.Plugin.DatabaseBacked):
         """ dict-like object to make it easier to access client bcfg2
         versions from the database """
-
         create = False
 
         def __getitem__(self, key):
             try:
-                return MetadataClientModel.objects.get(hostname=key).version
+                return MetadataClientModel.objects.get(
+                    hostname=key).version
             except MetadataClientModel.DoesNotExist:
                 raise KeyError(key)
 
@@ -350,6 +356,8 @@ class MetadataQuery(object):
 
     def __init__(self, by_name, get_clients, by_groups, by_profiles,
                  all_groups, all_groups_in_category):
+        self.logger = logging.getLogger(self.__class__.__name__)
+
         #: Get :class:`Bcfg2.Server.Plugins.Metadata.ClientMetadata`
         #: object for the given hostname.
         #:
@@ -402,8 +410,9 @@ class MetadataQuery(object):
         @wraps(func)
         def inner(arg):
             if isinstance(arg, str):
-                LOGGER.warning("%s: %s takes a list as argument, not a string"
-                               % (self.__class__.__name__, func.__name__))
+                self.logger.warning("%s: %s takes a list as argument, not a "
+                                    "string" % (self.__class__.__name__,
+                                                func.__name__))
             return func(arg)
         # pylint: enable=C0111
 
@@ -492,6 +501,16 @@ class Metadata(Bcfg2.Server.Plugin.Metadata,
     __author__ = 'bcfg-dev@mcs.anl.gov'
     sort_order = 500
 
+    options = Bcfg2.Server.Plugin.DatabaseBacked.options + [
+        Bcfg2.Options.Common.password,
+        Bcfg2.Options.BooleanOption(
+            cf=('metadata', 'use_database'), dest="metadata_db",
+            help="Use database capabilities of the Metadata plugin"),
+        Bcfg2.Options.Option(
+            cf=('communication', 'authentication'), default='cert+password',
+            choices=['cert', 'bootstrap', 'cert+password'],
+            help='Default client authentication method')]
+
     def __init__(self, core, datastore, watch_clients=True):
         Bcfg2.Server.Plugin.Metadata.__init__(self)
         Bcfg2.Server.Plugin.ClientRunHooks.__init__(self)
@@ -539,7 +558,7 @@ class Metadata(Bcfg2.Server.Plugin.Metadata,
         self.session_cache = {}
         self.default = None
         self.pdirty = False
-        self.password = core.setup['password']
+        self.password = Bcfg2.Options.setup.password
         self.query = MetadataQuery(core.build_metadata,
                                    lambda: list(self.clients),
                                    self.get_client_names_by_groups,
@@ -1141,9 +1160,8 @@ class Metadata(Bcfg2.Server.Plugin.Metadata,
                                  require_public=False)
                 profile = _add_group(pgroup)
             else:
-                msg = "Cannot add new client %s; no default group set" % client
-                self.logger.error(msg)
-                raise Bcfg2.Server.Plugin.MetadataConsistencyError(msg)
+                raise Bcfg2.Server.Plugin.MetadataConsistencyError(
+                    "Cannot add new client %s; no default group set" % client)
 
         for cgroup in self.clientgroups.get(client, []):
             if cgroup in groups:
@@ -1287,6 +1305,7 @@ class Metadata(Bcfg2.Server.Plugin.Metadata,
                 return False
         resolved = self.resolve_client(addresspair)
         if resolved.lower() == client.lower():
+            self.logger.debug("Client %s address validates" % client)
             return True
         else:
             self.logger.error("Got request for %s from incorrect address %s" %
@@ -1306,7 +1325,7 @@ class Metadata(Bcfg2.Server.Plugin.Metadata,
             client = certinfo['commonName']
             self.debug_log("Got cN %s; using as client name" % client)
             auth_type = self.auth.get(client,
-                                      self.core.setup['authentication'])
+                                      Bcfg2.Options.setup.authentication)
         elif user == 'root':
             id_method = 'address'
             try:
@@ -1337,6 +1356,7 @@ class Metadata(Bcfg2.Server.Plugin.Metadata,
             # remember the cert-derived client name for this connection
             if client in self.floating:
                 self.session_cache[address] = (time.time(), client)
+            self.logger.debug("Client %s certificate validates" % client)
             # we are done if cert+password not required
             return True
 
@@ -1363,13 +1383,14 @@ class Metadata(Bcfg2.Server.Plugin.Metadata,
         # populate the session cache
         if user != 'root':
             self.session_cache[address] = (time.time(), client)
+        self.logger.debug("Client %s authenticated successfully" % client)
         return True
     # pylint: enable=R0911,R0912
 
     def end_statistics(self, metadata):
         """ Hook to toggle clients in bootstrap mode """
         if self.auth.get(metadata.hostname,
-                         self.core.setup['authentication']) == 'bootstrap':
+                         Bcfg2.Options.setup.authentication) == 'bootstrap':
             self.update_client(metadata.hostname, dict(auth='cert'))
 
     def viz(self, hosts, bundles, key, only_client, colors):
@@ -1485,149 +1506,6 @@ class Metadata(Bcfg2.Server.Plugin.Metadata,
                               (group.get('name'), parent.get('name')))
         return rv
 
-
-class MetadataLint(Bcfg2.Server.Lint.ServerPlugin):
-    """ ``bcfg2-lint`` plugin for :ref:`Metadata
-    <server-plugins-grouping-metadata>`.  This checks for several things:
-
-    * ``<Client>`` tags nested inside other ``<Client>`` tags;
-    * Deprecated options (like ``location="floating"``);
-    * Profiles that don't exist, or that aren't profile groups;
-    * Groups or clients that are defined multiple times;
-    * Multiple default groups or a default group that isn't a profile
-      group.
-    """
-
-    def Run(self):
-        self.nested_clients()
-        self.deprecated_options()
-        self.bogus_profiles()
-        self.duplicate_groups()
-        self.duplicate_default_groups()
-        self.duplicate_clients()
-        self.default_is_profile()
-
-    @classmethod
-    def Errors(cls):
-        return {"nested-client-tags": "warning",
-                "deprecated-clients-options": "warning",
-                "nonexistent-profile-group": "error",
-                "non-profile-set-as-profile": "error",
-                "duplicate-group": "error",
-                "duplicate-client": "error",
-                "multiple-default-groups": "error",
-                "default-is-not-profile": "error"}
-
-    def deprecated_options(self):
-        """ Check for the ``location='floating'`` option, which has
-        been deprecated in favor of ``floating='true'``. """
-        if not hasattr(self.metadata, "clients_xml"):
-            # using metadata database
-            return
-        clientdata = self.metadata.clients_xml.xdata
-        for el in clientdata.xpath("//Client"):
-            loc = el.get("location")
-            if loc:
-                if loc == "floating":
-                    floating = True
-                else:
-                    floating = False
-                self.LintError("deprecated-clients-options",
-                               "The location='%s' option is deprecated.  "
-                               "Please use floating='%s' instead:\n%s" %
-                               (loc, floating, self.RenderXML(el)))
-
-    def nested_clients(self):
-        """ Check for a ``<Client/>`` tag inside a ``<Client/>`` tag,
-        which is either redundant or will never match. """
-        groupdata = self.metadata.groups_xml.xdata
-        for el in groupdata.xpath("//Client//Client"):
-            self.LintError("nested-client-tags",
-                           "Client %s nested within Client tag: %s" %
-                           (el.get("name"), self.RenderXML(el)))
-
-    def bogus_profiles(self):
-        """ Check for clients that have profiles that are either not
-        flagged as profile groups in ``groups.xml``, or don't exist. """
-        if not hasattr(self.metadata, "clients_xml"):
-            # using metadata database
-            return
-        for client in self.metadata.clients_xml.xdata.findall('.//Client'):
-            profile = client.get("profile")
-            if profile not in self.metadata.groups:
-                self.LintError("nonexistent-profile-group",
-                               "%s has nonexistent profile group %s:\n%s" %
-                               (client.get("name"), profile,
-                                self.RenderXML(client)))
-            elif not self.metadata.groups[profile].is_profile:
-                self.LintError("non-profile-set-as-profile",
-                               "%s is set as profile for %s, but %s is not a "
-                               "profile group:\n%s" %
-                               (profile, client.get("name"), profile,
-                                self.RenderXML(client)))
-
-    def duplicate_default_groups(self):
-        """ Check for multiple default groups. """
-        defaults = []
-        for grp in self.metadata.groups_xml.xdata.xpath("//Groups/Group") + \
-                self.metadata.groups_xml.xdata.xpath("//Groups/Group//Group"):
-            if grp.get("default", "false").lower() == "true":
-                defaults.append(self.RenderXML(grp))
-        if len(defaults) > 1:
-            self.LintError("multiple-default-groups",
-                           "Multiple default groups defined:\n%s" %
-                           "\n".join(defaults))
-
-    def duplicate_clients(self):
-        """ Check for clients that are defined more than once. """
-        if not hasattr(self.metadata, "clients_xml"):
-            # using metadata database
-            return
-        self.duplicate_entries(
-            self.metadata.clients_xml.xdata.xpath("//Client"),
-            "client")
-
-    def duplicate_groups(self):
-        """ Check for groups that are defined more than once.  We
-        count a group tag as a definition if it a) has profile or
-        public set; or b) has any children."""
-        allgroups = [
-            g
-            for g in self.metadata.groups_xml.xdata.xpath("//Groups/Group") +
-            self.metadata.groups_xml.xdata.xpath("//Groups/Group//Group")
-            if g.get("profile") or g.get("public") or g.getchildren()]
-        self.duplicate_entries(allgroups, "group")
-
-    def duplicate_entries(self, allentries, etype):
-        """ Generic duplicate entry finder.
-
-        :param allentries: A list of all entries to check for
-                           duplicates.
-        :type allentries: list of lxml.etree._Element
-        :param etype: The entry type. This will be used to determine
-                      the error name (``duplicate-<etype>``) and for
-                      display to the end user.
-        :type etype: string
-        """
-        entries = dict()
-        for el in allentries:
-            if el.get("name") in entries:
-                entries[el.get("name")].append(self.RenderXML(el))
-            else:
-                entries[el.get("name")] = [self.RenderXML(el)]
-        for ename, els in entries.items():
-            if len(els) > 1:
-                self.LintError("duplicate-%s" % etype,
-                               "%s %s is defined multiple times:\n%s" %
-                               (etype.title(), ename, "\n".join(els)))
-
-    def default_is_profile(self):
-        """ Ensure that the default group is a profile group. """
-        if (self.metadata.default and
-            not self.metadata.groups[self.metadata.default].is_profile):
-            xdata = \
-                self.metadata.groups_xml.xdata.xpath("//Group[@name='%s']" %
-                                                     self.metadata.default)[0]
-            self.LintError("default-is-not-profile",
-                           "Default group is not a profile group:\n%s" %
-                           self.RenderXML(xdata))
+    @staticmethod
+    def options_parsed_hook():
+        load_django_models()
diff --git a/src/lib/Bcfg2/Server/Plugins/Packages/Collection.py b/src/lib/Bcfg2/Server/Plugins/Packages/Collection.py
index 59eefe143..1ff097471 100644
--- a/src/lib/Bcfg2/Server/Plugins/Packages/Collection.py
+++ b/src/lib/Bcfg2/Server/Plugins/Packages/Collection.py
@@ -73,20 +73,17 @@ The Collection Module
 ---------------------
 """
 
-import sys
 import copy
-import logging
 import lxml.etree
+import Bcfg2.Options
 import Bcfg2.Server.Plugin
-from Bcfg2.Server.FileMonitor import get_fam
-from Bcfg2.Options import get_option_parser
+from Bcfg2.Logger import Debuggable
 from Bcfg2.Compat import any, md5  # pylint: disable=W0622
+from Bcfg2.Server.FileMonitor import get_fam
 from Bcfg2.Server.Statistics import track_statistics
 
-LOGGER = logging.getLogger(__name__)
 
-
-class Collection(list, Bcfg2.Server.Plugin.Debuggable):
+class Collection(list, Debuggable):
     """ ``Collection`` objects represent the set of
     :class:`Bcfg2.Server.Plugins.Packages.Source` objects that apply
     to a given client, and can be used to query all software
@@ -119,15 +116,14 @@ class Collection(list, Bcfg2.Server.Plugin.Debuggable):
         .. -----
         .. autoattribute:: __package_groups__
         """
-        Bcfg2.Server.Plugin.Debuggable.__init__(self)
+        Debuggable.__init__(self)
         list.__init__(self, sources)
-        self.debug_flag = debug
+        self.debug_flag = self.debug_flag or debug
         self.metadata = metadata
         self.basepath = basepath
         self.cachepath = cachepath
         self.virt_pkgs = dict()
         self.fam = get_fam()
-        self.setup = get_option_parser()
 
         try:
             self.ptype = sources[0].ptype
@@ -447,9 +443,7 @@ class Collection(list, Bcfg2.Server.Plugin.Debuggable):
         """
         for pkg in pkglist:
             lxml.etree.SubElement(entry, 'BoundPackage', name=pkg,
-                                  version=self.setup.cfp.get("packages",
-                                                             "version",
-                                                             default="auto"),
+                                  version=Bcfg2.Options.setup.packages_version,
                                   type=self.ptype, origin='Packages')
 
     def get_new_packages(self, initial, complete):
@@ -597,22 +591,9 @@ def get_collection_class(source_type):
     :type source_type: string
     :returns: type - the Collection subclass that should be used to
               instantiate an object to contain sources of the given type. """
-    modname = "Bcfg2.Server.Plugins.Packages.%s" % source_type.title()
-    try:
-        module = sys.modules[modname]
-    except KeyError:
-        try:
-            module = __import__(modname).Server.Plugins.Packages
-        except ImportError:
-            msg = "Packages: Unknown source type %s" % source_type
-            LOGGER.error(msg)
-            raise Bcfg2.Server.Plugin.PluginExecutionError(msg)
-
-    try:
-        cclass = getattr(module, source_type.title() + "Collection")
-    except AttributeError:
-        msg = "Packages: No collection class found for %s sources" % \
-            source_type
-        LOGGER.error(msg)
-        raise Bcfg2.Server.Plugin.PluginExecutionError(msg)
-    return cclass
+    cls = None
+    for mod in Bcfg2.Options.setup.packages_backends:
+        if mod.__name__.endswith(".%s" % source_type.title()):
+            return getattr(mod, "%sCollection" % source_type.title())
+    raise Bcfg2.Server.Plugin.PluginExecutionError(
+        "Packages: No collection class found for %s sources" % source_type)
diff --git a/src/lib/Bcfg2/Server/Plugins/Packages/PackagesSources.py b/src/lib/Bcfg2/Server/Plugins/Packages/PackagesSources.py
index aa6127f57..1a56d77c4 100644
--- a/src/lib/Bcfg2/Server/Plugins/Packages/PackagesSources.py
+++ b/src/lib/Bcfg2/Server/Plugins/Packages/PackagesSources.py
@@ -4,14 +4,12 @@
 import os
 import sys
 import Bcfg2.Server.Plugin
-from Bcfg2.Options import get_option_parser
 from Bcfg2.Server.Statistics import track_statistics
 from Bcfg2.Server.Plugins.Packages.Source import SourceInitError
 
 
 # pylint: disable=E0012,R0924
-class PackagesSources(Bcfg2.Server.Plugin.StructFile,
-                      Bcfg2.Server.Plugin.Debuggable):
+class PackagesSources(Bcfg2.Server.Plugin.StructFile):
     """ PackagesSources handles parsing of the
     :mod:`Bcfg2.Server.Plugins.Packages` ``sources.xml`` file, and the
     creation of the appropriate
@@ -37,7 +35,6 @@ class PackagesSources(Bcfg2.Server.Plugin.StructFile,
         :raises: :class:`Bcfg2.Server.Plugin.exceptions.PluginInitError` -
                  If ``sources.xml`` cannot be read
         """
-        Bcfg2.Server.Plugin.Debuggable.__init__(self)
         Bcfg2.Server.Plugin.StructFile.__init__(self, filename,
                                                 should_monitor=True)
 
@@ -54,8 +51,6 @@ class PackagesSources(Bcfg2.Server.Plugin.StructFile,
                 err = sys.exc_info()[1]
                 self.logger.error("Could not create Packages cache at %s: %s" %
                                   (self.cachepath, err))
-        #: The Bcfg2 options dict
-        self.setup = get_option_parser()
 
         #: The :class:`Bcfg2.Server.Plugins.Packages.Packages` that
         #: instantiated this ``PackagesSources`` object
@@ -69,10 +64,9 @@ class PackagesSources(Bcfg2.Server.Plugin.StructFile,
         self.parsed = set()
 
     def set_debug(self, debug):
-        Bcfg2.Server.Plugin.Debuggable.set_debug(self, debug)
+        Bcfg2.Server.Plugin.StructFile.set_debug(self, debug)
         for source in self.entries:
             source.set_debug(debug)
-    set_debug.__doc__ = Bcfg2.Server.Plugin.Plugin.set_debug.__doc__
 
     def HandleEvent(self, event=None):
         """ HandleEvent is called whenever the FAM registers an event.
@@ -138,15 +132,13 @@ class PackagesSources(Bcfg2.Server.Plugin.StructFile,
                                                         xsource.get("url"))))
             return None
 
-        try:
-            module = getattr(__import__("Bcfg2.Server.Plugins.Packages.%s" %
-                                        stype.title()).Server.Plugins.Packages,
-                             stype.title())
-            cls = getattr(module, "%sSource" % stype.title())
-        except (ImportError, AttributeError):
-            err = sys.exc_info()[1]
-            self.logger.error("Packages: Unknown source type %s (%s)" % (stype,
-                                                                         err))
+        cls = None
+        for mod in Bcfg2.Options.setup.packages_backends:
+            if mod.__name__.endswith(".%s" % stype.title()):
+                cls = getattr(mod, "%sSource" % stype.title())
+                break
+        else:
+            self.logger.error("Packages: Unknown source type %s" % stype)
             return None
 
         try:
diff --git a/src/lib/Bcfg2/Server/Plugins/Packages/Source.py b/src/lib/Bcfg2/Server/Plugins/Packages/Source.py
index 767ac13ac..e1659dbb3 100644
--- a/src/lib/Bcfg2/Server/Plugins/Packages/Source.py
+++ b/src/lib/Bcfg2/Server/Plugins/Packages/Source.py
@@ -50,7 +50,7 @@ import os
 import re
 import sys
 import Bcfg2.Server.Plugin
-from Bcfg2.Options import get_option_parser
+from Bcfg2.Logger import Debuggable
 from Bcfg2.Compat import HTTPError, HTTPBasicAuthHandler, \
     HTTPPasswordMgrWithDefaultRealm, install_opener, build_opener, urlopen, \
     cPickle, md5
@@ -93,7 +93,7 @@ class SourceInitError(Exception):
 REPO_RE = re.compile(r'(?:pulp/repos/|/RPMS\.|/)([^/]+)/?$')
 
 
-class Source(Bcfg2.Server.Plugin.Debuggable):  # pylint: disable=R0902
+class Source(Debuggable):  # pylint: disable=R0902
     """ ``Source`` objects represent a single <Source> tag in
     ``sources.xml``.  Note that a single Source tag can itself
     describe multiple repositories (if it uses the "url" attribute
@@ -121,7 +121,7 @@ class Source(Bcfg2.Server.Plugin.Debuggable):  # pylint: disable=R0902
         :type source: lxml.etree._Element
         :raises: :class:`Bcfg2.Server.Plugins.Packages.Source.SourceInitError`
         """
-        Bcfg2.Server.Plugin.Debuggable.__init__(self)
+        Debuggable.__init__(self)
 
         #: The base filesystem path under which cache data for this
         #: source should be stored
@@ -130,9 +130,6 @@ class Source(Bcfg2.Server.Plugin.Debuggable):  # pylint: disable=R0902
         #: The XML tag that describes this source
         self.xsource = xsource
 
-        #: A Bcfg2 options dict
-        self.setup = get_option_parser()
-
         #: A set of package names that are deemed "essential" by this
         #: source
         self.essentialpkgs = set()
diff --git a/src/lib/Bcfg2/Server/Plugins/Packages/Yum.py b/src/lib/Bcfg2/Server/Plugins/Packages/Yum.py
index 98add2ccf..4bbcc59f7 100644
--- a/src/lib/Bcfg2/Server/Plugins/Packages/Yum.py
+++ b/src/lib/Bcfg2/Server/Plugins/Packages/Yum.py
@@ -58,10 +58,10 @@ import errno
 import socket
 import logging
 import lxml.etree
-import Bcfg2.Server.FileMonitor
+import Bcfg2.Options
 import Bcfg2.Server.Plugin
+import Bcfg2.Server.FileMonitor
 from Bcfg2.Utils import Executor
-from Bcfg2.Options import get_option_parser
 # pylint: disable=W0622
 from Bcfg2.Compat import StringIO, cPickle, HTTPError, URLError, \
     ConfigParser, any
@@ -106,6 +106,30 @@ PULPSERVER = None
 PULPCONFIG = None
 
 
+options = [
+    Bcfg2.Options.PathOption(
+        cf=("packages:yum", "helper"), dest="yum_helper",
+        help="Path to the bcfg2-yum-helper executable"),
+    Bcfg2.Options.BooleanOption(
+        cf=("packages:yum", "use_yum_libraries"),
+        help="Use Python yum libraries"),
+    Bcfg2.Options.PathOption(
+        cf=("packages:yum", "gpg_keypath"), default="/etc/pki/rpm-gpg",
+        help="GPG key path on the client"),
+    Bcfg2.Options.Option(
+        cf=("packages:yum", "*"), dest="yum_options",
+        help="Other yum options to include in generated yum configs")]
+if HAS_PULP:
+    options.append(
+        Bcfg2.Options.Option(
+            cf=("packages:pulp", "username"), dest="pulp_username",
+            help="Username for Pulp authentication"))
+    options.append(
+        Bcfg2.Options.Option(
+            cf=("packages:pulp", "password"), dest="pulp_password",
+            help="Password for Pulp authentication"))
+
+
 def _setup_pulp():
     """ Connect to a Pulp server and pass authentication credentials.
     This only needs to be called once, but multiple calls won't hurt
@@ -121,20 +145,6 @@ def _setup_pulp():
         raise Bcfg2.Server.Plugin.PluginInitError(msg)
 
     if PULPSERVER is None:
-        setup = get_option_parser()
-        try:
-            username = setup.cfp.get("packages:pulp", "username")
-            password = setup.cfp.get("packages:pulp", "password")
-        except ConfigParser.NoSectionError:
-            msg = "Packages: No [pulp] section found in bcfg2.conf"
-            LOGGER.error(msg)
-            raise Bcfg2.Server.Plugin.PluginInitError(msg)
-        except ConfigParser.NoOptionError:
-            msg = "Packages: Required option not found in bcfg2.conf: %s" % \
-                sys.exc_info()[1]
-            LOGGER.error(msg)
-            raise Bcfg2.Server.Plugin.PluginInitError(msg)
-
         PULPCONFIG = ConsumerConfig()
         serveropts = PULPCONFIG.server
 
@@ -142,7 +152,9 @@ def _setup_pulp():
                                        int(serveropts['port']),
                                        serveropts['scheme'],
                                        serveropts['path'])
-        PULPSERVER.set_basic_auth_credentials(username, password)
+        PULPSERVER.set_basic_auth_credentials(
+            Bcfg2.Options.setup.pulp_username,
+            Bcfg2.Options.setup.pulp_password)
         server.set_active_server(PULPSERVER)
     return PULPSERVER
 
@@ -325,9 +337,8 @@ class YumCollection(Collection):
         forking, but apparently not); finally we check in /usr/sbin,
         the default location. """
         if not self._helper:
-            try:
-                self._helper = self.setup.cfp.get("packages:yum", "helper")
-            except (ConfigParser.NoOptionError, ConfigParser.NoSectionError):
+            self._helper = Bcfg2.Options.setup.yum_helper
+            if not self._helper:
                 # first see if bcfg2-yum-helper is in PATH
                 try:
                     self.debug_log("Checking for bcfg2-yum-helper in $PATH")
@@ -341,9 +352,7 @@ class YumCollection(Collection):
     def use_yum(self):
         """ True if we should use the yum Python libraries, False
         otherwise """
-        return HAS_YUM and self.setup.cfp.getboolean("packages:yum",
-                                                     "use_yum_libraries",
-                                                     default=False)
+        return HAS_YUM and Bcfg2.Options.setup.use_yum_libraries
 
     @property
     def has_pulp_sources(self):
@@ -378,15 +387,15 @@ class YumCollection(Collection):
                             debuglevel="0",
                             sslverify="0",
                             reposdir="/dev/null")
-            if self.setup['debug']:
+            if Bcfg2.Options.setup.debug:
                 mainopts['debuglevel'] = "5"
-            elif self.setup['verbose']:
+            elif Bcfg2.Options.setup.verbose:
                 mainopts['debuglevel'] = "2"
 
             try:
-                for opt in self.setup.cfp.options("packages:yum"):
+                for opt, val in Bcfg2.Options.setup.yum_options.items():
                     if opt not in self.option_blacklist:
-                        mainopts[opt] = self.setup.cfp.get("packages:yum", opt)
+                        mainopts[opt] = val
             except ConfigParser.NoSectionError:
                 pass
 
@@ -508,8 +517,7 @@ class YumCollection(Collection):
 
             for key in needkeys:
                 # figure out the path of the key on the client
-                keydir = self.setup.cfp.get("global", "gpg_keypath",
-                                            default="/etc/pki/rpm-gpg")
+                keydir = Bcfg2.Options.setup.gpg_keypath
                 remotekey = os.path.join(keydir, os.path.basename(key))
                 localkey = os.path.join(self.keypath, os.path.basename(key))
                 kdata = open(localkey).read()
@@ -728,8 +736,7 @@ class YumCollection(Collection):
         """ Given a package tuple, return a dict of attributes
         suitable for applying to either a Package or an Instance
         tag """
-        attrs = dict(version=self.setup.cfp.get("packages", "version",
-                                                default="auto"))
+        attrs = dict(version=Bcfg2.Options.setup.packages_version)
         if attrs['version'] == 'any' or not isinstance(pkgtup, tuple):
             return attrs
 
@@ -877,14 +884,10 @@ class YumCollection(Collection):
                   ``bcfg2-yum-helper`` command.
         """
         cmd = [self.helper, "-c", self.cfgfile]
-        if self.setup['verbose']:
+        if Bcfg2.Options.setup.verbose:
             cmd.append("-v")
         if self.debug_flag:
-            if not self.setup['verbose']:
-                # ensure that running in debug gets -vv, even if
-                # verbose is not enabled
-                cmd.append("-v")
-            cmd.append("-v")
+            cmd.append("-d")
         cmd.append(command)
         self.debug_log("Packages: running %s" % " ".join(cmd))
         if inputdata:
@@ -1007,9 +1010,7 @@ class YumSource(Source):
     def use_yum(self):
         """ True if we should use the yum Python libraries, False
         otherwise """
-        return HAS_YUM and self.setup.cfp.getboolean("packages:yum",
-                                                     "use_yum_libraries",
-                                                     default=False)
+        return HAS_YUM and Bcfg2.Options.setup.use_yum_libraries
 
     def save_state(self):
         """ If using the builtin yum parser, save state to
diff --git a/src/lib/Bcfg2/Server/Plugins/Packages/__init__.py b/src/lib/Bcfg2/Server/Plugins/Packages/__init__.py
index 8c272cf53..5b7c76765 100644
--- a/src/lib/Bcfg2/Server/Plugins/Packages/__init__.py
+++ b/src/lib/Bcfg2/Server/Plugins/Packages/__init__.py
@@ -7,20 +7,30 @@ import sys
 import glob
 import shutil
 import lxml.etree
-import Bcfg2.Logger
+import Bcfg2.Options
 import Bcfg2.Server.Plugin
-from Bcfg2.Compat import ConfigParser, urlopen, HTTPError, URLError
+from Bcfg2.Compat import urlopen, HTTPError, URLError
 from Bcfg2.Server.Plugins.Packages.Collection import Collection, \
     get_collection_class
 from Bcfg2.Server.Plugins.Packages.PackagesSources import PackagesSources
 from Bcfg2.Server.Statistics import track_statistics
 
-#: The default path for generated yum configs
-YUM_CONFIG_DEFAULT = "/etc/yum.repos.d/bcfg2.repo"
 
-#: The default path for generated apt configs
-APT_CONFIG_DEFAULT = \
-    "/etc/apt/sources.list.d/bcfg2-packages-generated-sources.list"
+def packages_boolean(value):
+    """ For historical reasons, the Packages booleans 'resolver' and
+    'metadata' both accept "enabled" in addition to the normal boolean
+    values. """
+    if value == 'disabled':
+        return False
+    elif value == 'enabled':
+        return True
+    else:
+        return value
+
+
+class PackagesBackendAction(Bcfg2.Options.ComponentAction):
+    bases = ['Bcfg2.Server.Plugins.Packages']
+    module = True
 
 
 class Packages(Bcfg2.Server.Plugin.Plugin,
@@ -38,6 +48,37 @@ class Packages(Bcfg2.Server.Plugin.Plugin,
 
     .. private-include: _build_packages"""
 
+    options = [
+        Bcfg2.Options.Option(
+            cf=("packages", "backends"), dest="packages_backends",
+            help="Packages backends to load",
+            type=Bcfg2.Options.Types.comma_list,
+            action=PackagesBackendAction, default=['Yum', 'Apt', 'Pac']),
+        Bcfg2.Options.PathOption(
+            cf=("packages", "cache"), dest="packages_cache",
+            help="Path to the Packages cache",
+            default='<repository>/Packages/cache'),
+        Bcfg2.Options.Option(
+            cf=("packages", "resolver"), dest="packages_resolver",
+            help="Disable the Packages resolver",
+            type=packages_boolean, default=True),
+        Bcfg2.Options.Option(
+            cf=("packages", "metadata"), dest="packages_metadata",
+            help="Disable all Packages metadata processing",
+            type=packages_boolean, default=True),
+        Bcfg2.Options.Option(
+            cf=("packages", "version"), dest="packages_version",
+            help="Set default Package entry version", default="auto",
+            choices=["auto", "any"]),
+        Bcfg2.Options.PathOption(
+            cf=("packages", "yum_config"),
+            help="The default path for generated yum configs",
+            default="/etc/yum.repos.d/bcfg2.repo"),
+        Bcfg2.Options.PathOption(
+            cf=("packages", "apt_config"),
+            help="The default path for generated apt configs",
+            default="/etc/apt/sources.list.d/bcfg2-packages-generated-sources.list")]
+
     #: Packages is an alternative to
     #: :mod:`Bcfg2.Server.Plugins.Pkgmgr` and conflicts with it.
     conflicts = ['Pkgmgr']
@@ -56,9 +97,7 @@ class Packages(Bcfg2.Server.Plugin.Plugin,
         #: Packages does a potentially tremendous amount of on-disk
         #: caching.  ``cachepath`` holds the base directory to where
         #: data should be cached.
-        self.cachepath = \
-            self.core.setup.cfp.get("packages", "cache",
-                                    default=os.path.join(self.data, 'cache'))
+        self.cachepath = Bcfg2.Options.setup.packages_cache
 
         #: Where Packages should store downloaded GPG key files
         self.keypath = os.path.join(self.cachepath, 'keys')
@@ -121,40 +160,17 @@ class Packages(Bcfg2.Server.Plugin.Plugin,
         :attr:`disableMetaData`) implies disabling the resolver.
 
         This property cannot be set. """
-        if self.disableMetaData:
-            # disabling metadata without disabling the resolver Breaks
-            # Things
-            return True
-        try:
-            return not self.core.setup.cfp.getboolean("packages", "resolver")
-        except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
-            return False
-        except ValueError:
-            # for historical reasons we also accept "enabled" and
-            # "disabled", which are not handled according to the
-            # Python docs but appear to be handled properly by
-            # ConfigParser in at least some versions
-            return self.core.setup.cfp.get(
-                "packages",
-                "resolver",
-                default="enabled").lower() == "disabled"
+        # disabling metadata without disabling the resolver Breaks
+        # Things
+        return not Bcfg2.Options.setup.packages_metadata or \
+            not Bcfg2.Options.setup.packages_resolver
 
     @property
     def disableMetaData(self):
         """ Report whether or not metadata processing is enabled.
 
         This property cannot be set. """
-        try:
-            return not self.core.setup.cfp.getboolean("packages", "resolver")
-        except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
-            return False
-        except ValueError:
-            # for historical reasons we also accept "enabled" and
-            # "disabled"
-            return self.core.setup.cfp.get(
-                "packages",
-                "metadata",
-                default="enabled").lower() == "disabled"
+        return not Bcfg2.Options.setup.packages_metadata
 
     def create_config(self, entry, metadata):
         """ Create yum/apt config for the specified client.
@@ -203,9 +219,7 @@ class Packages(Bcfg2.Server.Plugin.Plugin,
         """
         if entry.tag == 'Package':
             collection = self.get_collection(metadata)
-            entry.set('version', self.core.setup.cfp.get("packages",
-                                                         "version",
-                                                         default="auto"))
+            entry.set('version', Bcfg2.Options.setup.packages_version)
             entry.set('type', collection.ptype)
         elif entry.tag == 'Path':
             self.create_config(entry, metadata)
@@ -234,14 +248,8 @@ class Packages(Bcfg2.Server.Plugin.Plugin,
             return True
         elif entry.tag == 'Path':
             # managed entries for yum/apt configs
-            if (entry.get("name") ==
-                self.core.setup.cfp.get("packages",
-                                        "yum_config",
-                                        default=YUM_CONFIG_DEFAULT) or
-                entry.get("name") ==
-                self.core.setup.cfp.get("packages",
-                                        "apt_config",
-                                        default=APT_CONFIG_DEFAULT)):
+            if entry.get("name") in [Bcfg2.Options.setup.apt_config,
+                                     Bcfg2.Options.setup.yum_config]:
                 return True
         return False
 
@@ -274,7 +282,7 @@ class Packages(Bcfg2.Server.Plugin.Plugin,
         :returns: None
         """
         collection = self.get_collection(metadata)
-        indep = lxml.etree.Element('Independent')
+        indep = lxml.etree.Element('Independent', name=self.__class__.__name__)
         self._build_packages(metadata, indep, structures,
                              collection=collection)
         collection.build_extra_structures(indep)
diff --git a/src/lib/Bcfg2/Server/Plugins/Pkgmgr.py b/src/lib/Bcfg2/Server/Plugins/Pkgmgr.py
index 293ec8e1a..c85bc7d41 100644
--- a/src/lib/Bcfg2/Server/Plugins/Pkgmgr.py
+++ b/src/lib/Bcfg2/Server/Plugins/Pkgmgr.py
@@ -1,12 +1,9 @@
 '''This module implements a package management scheme for all images'''
 
-import os
 import re
 import sys
-import glob
 import logging
 import lxml.etree
-import Bcfg2.Server.Lint
 import Bcfg2.Server.Plugin
 from Bcfg2.Server.Plugin import PluginExecutionError
 
@@ -295,44 +292,3 @@ class Pkgmgr(Bcfg2.Server.Plugin.PrioDir):
 
     def HandleEntry(self, entry, metadata):
         self.BindEntry(entry, metadata)
-
-
-class PkgmgrLint(Bcfg2.Server.Lint.ServerlessPlugin):
-    """ Find duplicate :ref:`Pkgmgr
-    <server-plugins-generators-pkgmgr>` entries with the same
-    priority. """
-
-    def Run(self):
-        pset = set()
-        for pfile in glob.glob(os.path.join(self.config['repo'], 'Pkgmgr',
-                                            '*.xml')):
-            if self.HandlesFile(pfile):
-                xdata = lxml.etree.parse(pfile).getroot()
-                # get priority, type, group
-                priority = xdata.get('priority')
-                ptype = xdata.get('type')
-                for pkg in xdata.xpath("//Package"):
-                    if pkg.getparent().tag == 'Group':
-                        grp = pkg.getparent().get('name')
-                        if (type(grp) is not str and
-                            grp.getparent().tag == 'Group'):
-                            pgrp = grp.getparent().get('name')
-                        else:
-                            pgrp = 'none'
-                    else:
-                        grp = 'none'
-                        pgrp = 'none'
-                    ptuple = (pkg.get('name'), priority, ptype, grp, pgrp)
-                    # check if package is already listed with same
-                    # priority, type, grp
-                    if ptuple in pset:
-                        self.LintError(
-                            "duplicate-package",
-                            "Duplicate Package %s, priority:%s, type:%s" %
-                            (pkg.get('name'), priority, ptype))
-                    else:
-                        pset.add(ptuple)
-
-    @classmethod
-    def Errors(cls):
-        return {"duplicate-packages": "error"}
diff --git a/src/lib/Bcfg2/Server/Plugins/Probes.py b/src/lib/Bcfg2/Server/Plugins/Probes.py
index 6827c3d1f..9b485e29b 100644
--- a/src/lib/Bcfg2/Server/Plugins/Probes.py
+++ b/src/lib/Bcfg2/Server/Plugins/Probes.py
@@ -12,10 +12,19 @@ import Bcfg2.Server.Plugin
 import Bcfg2.Server.FileMonitor
 from Bcfg2.Server.Statistics import track_statistics
 
-try:
-    from django.db import models
-    from django.core.exceptions import MultipleObjectsReturned
-    HAS_DJANGO = True
+HAS_DJANGO = False
+ProbesDataModel = None
+ProbesGroupModel = None
+
+
+def load_django_models():
+    global ProbesDataModel, ProbesGroupModel, HAS_DJANGO
+    try:
+        from django.db import models
+        HAS_DJANGO = True
+    except ImportError:
+        HAS_DJANGO = False
+        return
 
     class ProbesDataModel(models.Model,
                           Bcfg2.Server.Plugin.PluginDatabaseModel):
@@ -30,8 +39,7 @@ try:
         """ The database model for storing probe groups """
         hostname = models.CharField(max_length=255)
         group = models.CharField(max_length=255)
-except ImportError:
-    HAS_DJANGO = False
+
 
 try:
     import json
@@ -120,11 +128,15 @@ class ProbeSet(Bcfg2.Server.Plugin.EntrySet):
     bangline = re.compile(r'^#!\s*(?P<interpreter>.*)$')
     basename_is_regex = True
 
-    def __init__(self, path, encoding, plugin_name):
+    options = [
+        Bcfg2.Options.BooleanOption(
+            cf=('probes', 'use_database'), dest="probes_db",
+            help="Use database capabilities of the Probes plugin")]
+
+    def __init__(self, path, plugin_name):
         self.plugin_name = plugin_name
         Bcfg2.Server.Plugin.EntrySet.__init__(self, r'[0-9A-Za-z_\-]+', path,
-                                              Bcfg2.Server.Plugin.SpecificData,
-                                              encoding)
+                                              Bcfg2.Server.Plugin.SpecificData)
         Bcfg2.Server.FileMonitor.get_fam().AddMonitor(path, self)
 
     def HandleEvent(self, event):
@@ -194,8 +206,7 @@ class Probes(Bcfg2.Server.Plugin.Probing,
         Bcfg2.Server.Plugin.DatabaseBacked.__init__(self, core, datastore)
 
         try:
-            self.probes = ProbeSet(self.data, core.setup['encoding'],
-                                   self.name)
+            self.probes = ProbeSet(self.data, self.name)
         except:
             err = sys.exc_info()[1]
             raise Bcfg2.Server.Plugin.PluginInitError(err)
@@ -258,7 +269,7 @@ class Probes(Bcfg2.Server.Plugin.Probing,
                 ProbesGroupsModel.objects.get_or_create(
                     hostname=client.hostname,
                     group=group)
-            except MultipleObjectsReturned:
+            except ProbesGroupsModel.MultipleObjectsReturned:
                 ProbesGroupsModel.objects.filter(hostname=client.hostname,
                                                  group=group).delete()
                 ProbesGroupsModel.objects.get_or_create(
diff --git a/src/lib/Bcfg2/Server/Plugins/Properties.py b/src/lib/Bcfg2/Server/Plugins/Properties.py
index 8e54da19b..bbc00556b 100644
--- a/src/lib/Bcfg2/Server/Plugins/Properties.py
+++ b/src/lib/Bcfg2/Server/Plugins/Properties.py
@@ -7,7 +7,7 @@ import sys
 import copy
 import logging
 import lxml.etree
-from Bcfg2.Options import get_option_parser
+import Bcfg2.Options
 import Bcfg2.Server.Plugin
 from Bcfg2.Server.Plugin import PluginExecutionError
 
@@ -40,18 +40,14 @@ class PropertyFile(object):
         .. automethod:: _write
         """
         self.name = name
-        self.setup = get_option_parser()
 
     def write(self):
         """ Write the data in this data structure back to the property
         file. This public method performs checking to ensure that
         writing is possible and then calls :func:`_write`. """
-        if not self.setup.cfp.getboolean("properties", "writes_enabled",
-                                         default=True):
-            msg = "Properties files write-back is disabled in the " + \
-                "configuration"
-            LOGGER.error(msg)
-            raise PluginExecutionError(msg)
+        if not Bcfg2.Options.setup.writes_enabled:
+            raise PluginExecutionError("Properties files write-back is "
+                                       "disabled in the configuration")
         try:
             self.validate_data()
         except PluginExecutionError:
@@ -199,7 +195,7 @@ class XMLPropertyFile(Bcfg2.Server.Plugin.StructFile, PropertyFile):
     validate_data.__doc__ = PropertyFile.validate_data.__doc__
 
     def get_additional_data(self, metadata):
-        if self.setup.cfp.getboolean("properties", "automatch", default=False):
+        if Bcfg2.Options.setup.automatch:
             default_automatch = "true"
         else:
             default_automatch = "false"
@@ -221,6 +217,13 @@ class Properties(Bcfg2.Server.Plugin.Plugin,
                  Bcfg2.Server.Plugin.DirectoryBacked):
     """ The properties plugin maps property files into client metadata
     instances. """
+    options = [
+        Bcfg2.Options.BooleanOption(
+            cf=("properties", "writes_enabled"), default=True,
+            help="Enable or disable Properties write-back"),
+        Bcfg2.Options.BooleanOption(
+            cf=("properties", "automatch"),
+            help="Enable Properties automatch")]
 
     #: Extensions that are understood by Properties.
     extensions = ["xml"]
diff --git a/src/lib/Bcfg2/Server/Plugins/Reporting.py b/src/lib/Bcfg2/Server/Plugins/Reporting.py
index 3354763d4..9d1019441 100644
--- a/src/lib/Bcfg2/Server/Plugins/Reporting.py
+++ b/src/lib/Bcfg2/Server/Plugins/Reporting.py
@@ -5,11 +5,10 @@ import time
 import platform
 import traceback
 import lxml.etree
-from Bcfg2.Reporting.Transport import load_transport_from_config, \
-    TransportError
-from Bcfg2.Options import REPORTING_COMMON_OPTIONS
+import Bcfg2.Options
+from Bcfg2.Reporting.Transport.base import TransportError
 from Bcfg2.Server.Plugin import Statistics, PullSource, Threaded, \
-    Debuggable, PluginInitError, PluginExecutionError
+    PluginInitError, PluginExecutionError
 
 # required for reporting
 try:
@@ -33,9 +32,11 @@ def _rpc_call(method):
 
 
 # pylint: disable=W0223
-class Reporting(Statistics, Threaded, PullSource, Debuggable):
+class Reporting(Statistics, Threaded, PullSource):
     """ Unified statistics and reporting plugin """
-    __rmi__ = Debuggable.__rmi__ + ['Ping', 'GetExtra', 'GetCurrentEntry']
+    __rmi__ = Statistics.__rmi__ + ['Ping', 'GetExtra', 'GetCurrentEntry']
+
+    options = [Bcfg2.Options.Common.reporting_transport]
 
     CLIENT_METADATA_FIELDS = ('profile', 'bundles', 'aliases', 'addresses',
                               'groups', 'categories', 'uuid', 'version')
@@ -44,14 +45,10 @@ class Reporting(Statistics, Threaded, PullSource, Debuggable):
         Statistics.__init__(self, core, datastore)
         PullSource.__init__(self)
         Threaded.__init__(self)
-        Debuggable.__init__(self)
 
         self.whoami = platform.node()
         self.transport = None
 
-        core.setup.update(REPORTING_COMMON_OPTIONS)
-        core.setup.reparse()
-
         if not HAS_SOUTH:
             msg = "Django south is required for Reporting"
             self.logger.error(msg)
@@ -59,17 +56,15 @@ class Reporting(Statistics, Threaded, PullSource, Debuggable):
 
     def start_threads(self):
         try:
-            self.transport = load_transport_from_config(self.core.setup)
+            self.transport = Bcfg2.Options.setup.reporting_transport()
         except TransportError:
-            msg = "%s: Failed to load transport: %s" % \
-                (self.name, traceback.format_exc().splitlines()[-1])
-            self.logger.error(msg)
-            raise PluginInitError(msg)
+            raise PluginInitError("%s: Failed to instantiate transport: %s" %
+                                  (self.name, sys.exc_info()[1]))
         if self.debug_flag:
             self.transport.set_debug(self.debug_flag)
 
     def set_debug(self, debug):
-        rv = Debuggable.set_debug(self, debug)
+        rv = Statistics.set_debug(self, debug)
         if self.transport is not None:
             self.transport.set_debug(debug)
         return rv
diff --git a/src/lib/Bcfg2/Server/Plugins/Rules.py b/src/lib/Bcfg2/Server/Plugins/Rules.py
index 3d4e8671d..541116db3 100644
--- a/src/lib/Bcfg2/Server/Plugins/Rules.py
+++ b/src/lib/Bcfg2/Server/Plugins/Rules.py
@@ -1,6 +1,7 @@
 """This generator provides rule-based entry mappings."""
 
 import re
+import Bcfg2.Options
 import Bcfg2.Server.Plugin
 
 
@@ -8,6 +9,11 @@ class Rules(Bcfg2.Server.Plugin.PrioDir):
     """This is a generator that handles service assignments."""
     __author__ = 'bcfg-dev@mcs.anl.gov'
 
+    options = Bcfg2.Server.Plugin.PrioDir.options + [
+        Bcfg2.Options.BooleanOption(
+            cf=("rules", "regex"), dest="rules_regex",
+            help="Allow regular expressions in Rules")]
+
     def __init__(self, core, datastore):
         Bcfg2.Server.Plugin.PrioDir.__init__(self, core, datastore)
         self._regex_cache = dict()
@@ -42,4 +48,4 @@ class Rules(Bcfg2.Server.Plugin.PrioDir):
     @property
     def _regex_enabled(self):
         """ Return True if rules regexes are enabled, False otherwise """
-        return self.core.setup.cfp.getboolean("rules", "regex", default=False)
+        return Bcfg2.Options.setup.rules_regex
diff --git a/src/lib/Bcfg2/Server/Plugins/SSHbase.py b/src/lib/Bcfg2/Server/Plugins/SSHbase.py
index 84dcf2780..186d61c6e 100644
--- a/src/lib/Bcfg2/Server/Plugins/SSHbase.py
+++ b/src/lib/Bcfg2/Server/Plugins/SSHbase.py
@@ -7,8 +7,9 @@ import socket
 import shutil
 import logging
 import tempfile
-from itertools import chain
+import Bcfg2.Options
 import Bcfg2.Server.Plugin
+from itertools import chain
 from Bcfg2.Utils import Executor
 from Bcfg2.Server.Plugin import PluginExecutionError
 from Bcfg2.Compat import any, u_str, b64encode  # pylint: disable=W0622
@@ -20,8 +21,7 @@ class KeyData(Bcfg2.Server.Plugin.SpecificData):
     """ class to handle key data for HostKeyEntrySet """
 
     def __init__(self, name, specific, encoding):
-        Bcfg2.Server.Plugin.SpecificData.__init__(self, name, specific,
-                                                  encoding)
+        Bcfg2.Server.Plugin.SpecificData.__init__(self, name, specific)
         self.encoding = encoding
 
     def __lt__(self, other):
@@ -62,27 +62,30 @@ class HostKeyEntrySet(Bcfg2.Server.Plugin.EntrySet):
     """ EntrySet to handle all kinds of host keys """
     def __init__(self, basename, path):
         if basename.startswith("ssh_host_key"):
-            encoding = "base64"
+            self.encoding = "base64"
         else:
-            encoding = None
-        Bcfg2.Server.Plugin.EntrySet.__init__(self, basename, path, KeyData,
-                                              encoding)
+            self.encoding = None
+        Bcfg2.Server.Plugin.EntrySet.__init__(self, basename, path, KeyData)
         self.metadata = {'owner': 'root',
                          'group': 'root',
                          'type': 'file'}
-        if encoding is not None:
-            self.metadata['encoding'] = encoding
+        if self.encoding is not None:
+            self.metadata['encoding'] = self.encoding
         if basename.endswith('.pub'):
             self.metadata['mode'] = '0644'
         else:
             self.metadata['mode'] = '0600'
 
+    def get_keydata_object(self, filepath, specificity):
+        return KeyData(filepath, specificity,
+                       self.encoding or Bcfg2.Options.setup.encoding)
+
 
 class KnownHostsEntrySet(Bcfg2.Server.Plugin.EntrySet):
     """ EntrySet to handle the ssh_known_hosts file """
     def __init__(self, path):
         Bcfg2.Server.Plugin.EntrySet.__init__(self, "ssh_known_hosts", path,
-                                              KeyData, None)
+                                              KeyData)
         self.metadata = {'owner': 'root',
                          'group': 'root',
                          'type': 'file',
diff --git a/src/lib/Bcfg2/Server/Plugins/SSLCA.py b/src/lib/Bcfg2/Server/Plugins/SSLCA.py
index b21732666..74d8833f4 100644
--- a/src/lib/Bcfg2/Server/Plugins/SSLCA.py
+++ b/src/lib/Bcfg2/Server/Plugins/SSLCA.py
@@ -3,17 +3,13 @@ certificates and their keys. """
 
 import os
 import sys
-import logging
 import tempfile
 import lxml.etree
-import Bcfg2.Options
 import Bcfg2.Server.Plugin
 from Bcfg2.Utils import Executor
 from Bcfg2.Compat import ConfigParser
 from Bcfg2.Server.Plugin import PluginExecutionError
 
-LOGGER = logging.getLogger(__name__)
-
 
 class SSLCAXMLSpec(Bcfg2.Server.Plugin.StructFile):
     """ Base class to handle key.xml and cert.xml """
@@ -31,10 +27,9 @@ class SSLCAXMLSpec(Bcfg2.Server.Plugin.StructFile):
                                                   metadata.hostname,
                                                   self.name))
         elif len(entries) > 1:
-            LOGGER.warning("More than one matching %s entry found for %s in "
-                           "%s; using first match" % (self.tag,
-                                                      metadata.hostname,
-                                                      self.name))
+            self.logger.warning(
+                "More than one matching %s entry found for %s in %s; "
+                "using first match" % (self.tag, metadata.hostname, self.name))
         rv = dict()
         for attr, default in self.attrs.items():
             val = entries[0].get(attr.lower(), default)
@@ -84,9 +79,9 @@ class SSLCADataFile(Bcfg2.Server.Plugin.SpecificData):
 
 class SSLCAEntrySet(Bcfg2.Server.Plugin.EntrySet):
     """ Entry set to handle SSLCA entries and XML files """
-    def __init__(self, _, path, entry_type, encoding, parent=None):
+    def __init__(self, _, path, entry_type, parent=None):
         Bcfg2.Server.Plugin.EntrySet.__init__(self, os.path.basename(path),
-                                              path, entry_type, encoding)
+                                              path, entry_type)
         self.parent = parent
         self.key = None
         self.cert = None
@@ -361,10 +356,32 @@ class SSLCA(Bcfg2.Server.Plugin.GroupSpool):
     """ The SSLCA generator handles the creation and management of ssl
     certificates and their keys. """
     __author__ = 'g.hagger@gmail.com'
+
+    options = Bcfg2.Server.Plugin.GroupSpool.options + [
+        Bcfg2.Options.WildcardSectionGroup(
+            Bcfg2.Options.PathOption(
+                cf=("sslca_*", "config"),
+                help="Path to the openssl config for the CA"),
+            Bcfg2.Options.Option(
+                cf=("sslca_*", "passphrase"),
+                help="Passphrase for the CA private key"),
+            Bcfg2.Options.PathOption(
+                cf=("sslca_*", "chaincert"),
+                help="Path to the SSL chaining certificate for verification"),
+            Bcfg2.Options.BooleanOption(
+                cf=("sslca_*", "root_ca"),
+                help="Whether or not <chaincert> is a root CA (as opposed to "
+                "an intermediate cert"))]
+
     # python 2.5 doesn't support mixing *magic and keyword arguments
     es_cls = lambda self, *args: SSLCAEntrySet(*args, **dict(parent=self))
     es_child_cls = SSLCADataFile
 
     def get_ca(self, name):
         """ get a dict describing a CA from the config file """
-        return dict(self.core.setup.cfp.items("sslca_%s" % name))
+        rv = dict()
+        prefix = "sslca_%s_" % name
+        for attr in dir(Bcfg2.Options.setup):
+            if attr.startswith(prefix):
+                rv[attr[len(prefix):]] = getattr(Bcfg2.Options.setup, attr)
+        return rv
diff --git a/src/lib/Bcfg2/Server/Plugins/Svn.py b/src/lib/Bcfg2/Server/Plugins/Svn.py
index dfe864d48..679e38ff9 100644
--- a/src/lib/Bcfg2/Server/Plugins/Svn.py
+++ b/src/lib/Bcfg2/Server/Plugins/Svn.py
@@ -4,8 +4,8 @@ additional XML-RPC methods for committing data to the repository and
 updating the repository. """
 
 import sys
+import Bcfg2.Options
 import Bcfg2.Server.Plugin
-from Bcfg2.Compat import ConfigParser
 try:
     import pysvn
     HAS_SVN = True
@@ -16,6 +16,21 @@ except ImportError:
 
 class Svn(Bcfg2.Server.Plugin.Version):
     """Svn is a version plugin for dealing with Bcfg2 repos."""
+    options = Bcfg2.Server.Plugin.Version.options + [
+        Bcfg2.Options.Option(
+            cf=("svn", "conflict_resolution"), dest="svn_conflict_resolution",
+            type=lambda v: v.replace("-", "_"),
+            choices=dir(pysvn.wc_conflict_choice),
+            default=pysvn.wc_conflict_choice.postpone,
+            help="SVN conflict resolution method"),
+        Bcfg2.Options.Option(
+            cf=("svn", "user"), dest="svn_user", help="SVN username"),
+        Bcfg2.Options.Option(
+            cf=("svn", "password"), dest="svn_password", help="SVN password"),
+        Bcfg2.Options.BooleanOption(
+            cf=("svn", "always_trust"), dest="svn_trust_ssl",
+            help="Always trust SSL certs from SVN server")]
+
     __author__ = 'bcfg-dev@mcs.anl.gov'
     __vcs_metadata_path__ = ".svn"
     if HAS_SVN:
@@ -36,62 +51,29 @@ class Svn(Bcfg2.Server.Plugin.Version):
             self.cmd = Executor()
         else:
             self.client = pysvn.Client()
-            # pylint: disable=E1101
-            choice = pysvn.wc_conflict_choice.postpone
-            try:
-                resolution = self.core.setup.cfp.get(
-                    "svn",
-                    "conflict_resolution").replace('-', '_')
-                if resolution in ["edit", "launch", "working"]:
-                    self.logger.warning("Svn: Conflict resolver %s requires "
-                                        "manual intervention, using %s" %
-                                        choice)
-                else:
-                    choice = getattr(pysvn.wc_conflict_choice, resolution)
-            except AttributeError:
-                self.logger.warning("Svn: Conflict resolver %s does not "
-                                    "exist, using %s" % choice)
-            except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
-                self.logger.info("Svn: No conflict resolution method "
-                                 "selected, using %s" % choice)
-            # pylint: enable=E1101
             self.debug_log("Svn: Conflicts will be resolved with %s" %
-                           choice)
-            self.client.callback_conflict_resolver = \
-                self.get_conflict_resolver(choice)
+                           Bcfg2.Options.setup.svn_conflict_resolution)
+            self.client.callback_conflict_resolver = self.conflict_resolver
 
-            try:
-                if self.core.setup.cfp.get(
-                        "svn",
-                        "always_trust").lower() == "true":
-                    self.client.callback_ssl_server_trust_prompt = \
-                        self.ssl_server_trust_prompt
-            except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
-                self.logger.debug("Svn: Using subversion cache for SSL "
-                                  "certificate trust")
+            if Bcfg2.Options.setup.svn_trust_ssl:
+                self.client.callback_ssl_server_trust_prompt = \
+                    self.ssl_server_trust_prompt
 
-            try:
-                if (self.core.setup.cfp.get("svn", "user") and
-                    self.core.setup.cfp.get("svn", "password")):
-                    self.client.callback_get_login = \
-                        self.get_login
-            except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
-                self.logger.info("Svn: Using subversion cache for "
-                                 "password-based authetication")
+            if (Bcfg2.Options.setup.svn_user and
+                Bcfg2.Options.setup.svn_password):
+                self.client.callback_get_login = self.get_login
 
         self.logger.debug("Svn: Initialized svn plugin with SVN directory %s" %
                           self.vcs_path)
 
-    # pylint: disable=W0613
-    def get_login(self, realm, username, may_save):
+    def get_login(self, realm, username, may_save):  # pylint: disable=W0613
         """ PySvn callback to get credentials for HTTP basic authentication """
         self.logger.debug("Svn: Logging in with username: %s" %
-                          self.core.setup.cfp.get("svn", "user"))
-        return True, \
-            self.core.setup.cfp.get("svn", "user"), \
-            self.core.setup.cfp.get("svn", "password"), \
-            False
-    # pylint: enable=W0613
+                          Bcfg2.Options.setup.svn_user)
+        return (True,
+                Bcfg2.Options.setup.svn_user,
+                Bcfg2.Options.setup.svn_password,
+                False)
 
     def ssl_server_trust_prompt(self, trust_dict):
         """ PySvn callback to always trust SSL certificates from SVN server """
@@ -102,22 +84,19 @@ class Svn(Bcfg2.Server.Plugin.Version):
                            trust_dict['realm']))
         return True, trust_dict['failures'], False
 
-    def get_conflict_resolver(self, choice):
-        """ Get a PySvn conflict resolution callback """
-        def callback(conflict_description):
-            """ PySvn callback function to resolve conflicts """
-            self.logger.info("Svn: Resolving conflict for %s with %s" %
-                             (conflict_description['path'], choice))
-            return choice, None, False
-
-        return callback
+    def conflict_resolver(self, conflict_description):
+        """ PySvn callback function to resolve conflicts """
+        self.logger.info("Svn: Resolving conflict for %s with %s" %
+                         (conflict_description['path'],
+                          Bcfg2.Options.setup.svn_conflict_resolution))
+        return Bcfg2.Options.setup.svn_conflict_resolution, None, False
 
     def get_revision(self):
         """Read svn revision information for the Bcfg2 repository."""
         msg = None
         if HAS_SVN:
             try:
-                info = self.client.info(self.vcs_root)
+                info = self.client.info(Bcfg2.Options.setup.vcs_root)
                 self.revision = info.revision
                 self.svn_root = info.url
                 return str(self.revision.number)
@@ -125,7 +104,7 @@ class Svn(Bcfg2.Server.Plugin.Version):
                 msg = "Svn: Failed to get revision: %s" % sys.exc_info()[1]
         else:
             result = self.cmd.run(["env LC_ALL=C", "svn", "info",
-                                   self.vcs_root],
+                                   Bcfg2.Options.setup.vcs_root],
                                   shell=True)
             if result.success:
                 self.revision = [line.split(': ')[1]
@@ -141,7 +120,8 @@ class Svn(Bcfg2.Server.Plugin.Version):
         '''Svn.Update() => True|False\nUpdate svn working copy\n'''
         try:
             old_revision = self.revision.number
-            self.revision = self.client.update(self.vcs_root, recurse=True)[0]
+            self.revision = self.client.update(Bcfg2.Options.setup.vcs_root,
+                                               recurse=True)[0]
         except pysvn.ClientError:  # pylint: disable=E1101
             err = sys.exc_info()[1]
             # try to be smart about the error we got back
@@ -163,7 +143,7 @@ class Svn(Bcfg2.Server.Plugin.Version):
             self.logger.debug("repository is current")
         else:
             self.logger.info("Updated %s from revision %s to %s" %
-                             (self.vcs_root, old_revision,
+                             (Bcfg2.Options.setup.vcs_root, old_revision,
                               self.revision.number))
         return True
 
@@ -176,10 +156,11 @@ class Svn(Bcfg2.Server.Plugin.Version):
             return False
 
         try:
-            self.revision = self.client.checkin([self.vcs_root],
+            self.revision = self.client.checkin([Bcfg2.Options.setup.vcs_root],
                                                 'Svn: autocommit',
                                                 recurse=True)
-            self.revision = self.client.update(self.vcs_root, recurse=True)[0]
+            self.revision = self.client.update(Bcfg2.Options.setup.vcs_root,
+                                               recurse=True)[0]
             self.logger.info("Svn: Commited changes. At %s" %
                              self.revision.number)
             return True
diff --git a/src/lib/Bcfg2/Server/Plugins/TemplateHelper.py b/src/lib/Bcfg2/Server/Plugins/TemplateHelper.py
index 77bdd6576..a32b7dea2 100644
--- a/src/lib/Bcfg2/Server/Plugins/TemplateHelper.py
+++ b/src/lib/Bcfg2/Server/Plugins/TemplateHelper.py
@@ -4,7 +4,6 @@ import re
 import imp
 import sys
 import logging
-import Bcfg2.Server.Lint
 import Bcfg2.Server.Plugin
 
 LOGGER = logging.getLogger(__name__)
@@ -93,75 +92,3 @@ class TemplateHelper(Bcfg2.Server.Plugin.Plugin,
     def get_additional_data(self, _):
         return dict([(h._module_name, h)  # pylint: disable=W0212
                      for h in self.entries.values()])
-
-
-class TemplateHelperLint(Bcfg2.Server.Lint.ServerPlugin):
-    """ ``bcfg2-lint`` plugin to ensure that all :ref:`TemplateHelper
-    <server-plugins-connectors-templatehelper>` modules are valid.
-    This can check for:
-
-    * A TemplateHelper module that cannot be imported due to syntax or
-      other compile-time errors;
-    * A TemplateHelper module that does not have an ``__export__``
-      attribute, or whose ``__export__`` is not a list;
-    * Bogus symbols listed in ``__export__``, including symbols that
-      don't exist, that are reserved, or that start with underscores.
-    """
-
-    def __init__(self, *args, **kwargs):
-        Bcfg2.Server.Lint.ServerPlugin.__init__(self, *args, **kwargs)
-        self.reserved_keywords = dir(HelperModule("foo.py"))
-
-    def Run(self):
-        for helper in self.core.plugins['TemplateHelper'].entries.values():
-            if self.HandlesFile(helper.name):
-                self.check_helper(helper.name)
-
-    def check_helper(self, helper):
-        """ Check a single helper module.
-
-        :param helper: The filename of the helper module
-        :type helper: string
-        """
-        module_name = MODULE_RE.search(helper).group(1)
-
-        try:
-            module = imp.load_source(safe_module_name(module_name), helper)
-        except:  # pylint: disable=W0702
-            err = sys.exc_info()[1]
-            self.LintError("templatehelper-import-error",
-                           "Failed to import %s: %s" %
-                           (helper, err))
-            return
-
-        if not hasattr(module, "__export__"):
-            self.LintError("templatehelper-no-export",
-                           "%s has no __export__ list" % helper)
-            return
-        elif not isinstance(module.__export__, list):
-            self.LintError("templatehelper-nonlist-export",
-                           "__export__ is not a list in %s" % helper)
-            return
-
-        for sym in module.__export__:
-            if not hasattr(module, sym):
-                self.LintError("templatehelper-nonexistent-export",
-                               "%s: exported symbol %s does not exist" %
-                               (helper, sym))
-            elif sym in self.reserved_keywords:
-                self.LintError("templatehelper-reserved-export",
-                               "%s: exported symbol %s is reserved" %
-                               (helper, sym))
-            elif sym.startswith("_"):
-                self.LintError("templatehelper-underscore-export",
-                               "%s: exported symbol %s starts with underscore"
-                               % (helper, sym))
-
-    @classmethod
-    def Errors(cls):
-        return {"templatehelper-import-error": "error",
-                "templatehelper-no-export": "error",
-                "templatehelper-nonlist-export": "error",
-                "templatehelper-nonexistent-export": "error",
-                "templatehelper-reserved-export": "error",
-                "templatehelper-underscore-export": "warning"}