Options: migrated client drivers to new parser

16 files changed, 303 insertions, 210 deletions

diff --git a/src/lib/Bcfg2/Client/Tools/APK.py b/src/lib/Bcfg2/Client/Tools/APK.py
index 46f46bb1c..457197c28 100644
--- a/src/lib/Bcfg2/Client/Tools/APK.py
+++ b/src/lib/Bcfg2/Client/Tools/APK.py
@@ -33,8 +33,6 @@ class APK(Bcfg2.Client.Tools.PkgTool):
         if entry.attrib['name'] in self.installed:
             if entry.attrib['version'] in \
                     ['auto', self.installed[entry.attrib['name']]]:
-                #if not self.setup['quick'] and \
-                #                entry.get('verify', 'true') == 'true':
                 #FIXME: Does APK have any sort of verification mechanism?
                 return True
             else:
diff --git a/src/lib/Bcfg2/Client/Tools/APT.py b/src/lib/Bcfg2/Client/Tools/APT.py
index f449557aa..5f14b43ed 100644
--- a/src/lib/Bcfg2/Client/Tools/APT.py
+++ b/src/lib/Bcfg2/Client/Tools/APT.py
@@ -4,16 +4,27 @@
 import warnings
 warnings.filterwarnings("ignore", "apt API not stable yet",
                         FutureWarning)
-import apt.cache
 import os
+import apt.cache
+import Bcfg2.Options
 import Bcfg2.Client.Tools
 
+
 class APT(Bcfg2.Client.Tools.Tool):
-    """The Debian toolset implements package and service operations and inherits
-    the rest from Toolset.Toolset.
+    """The Debian toolset implements package and service operations
+    and inherits the rest from Tools.Tool.  """
+
+    options = Bcfg2.Client.Tools.Tool.options + [
+        Bcfg2.Options.PathOption(
+           cf=('APT', 'install_path'), default='/usr', dest='apt_install_path',
+           help='Apt tools install path'),
+        Bcfg2.Options.PathOption(
+            cf=('APT', 'var_path'), default='/var', dest='apt_var_path',
+            help='Apt tools var path'),
+        Bcfg2.Options.PathOption(
+           cf=('APT', 'etc_path'), default='/etc', dest='apt_etc_path',
+           help='System etc path')]
 
-    """
-    name = 'APT'
     __execs__ = []
     __handles__ = [('Package', 'deb'), ('Path', 'ignore')]
     __req__ = {'Package': ['name', 'version'], 'Path': ['type']}
@@ -21,12 +32,9 @@ class APT(Bcfg2.Client.Tools.Tool):
     def __init__(self, config):
         Bcfg2.Client.Tools.Tool.__init__(self, config)
 
-        self.install_path = self.setup.get('apt_install_path', '/usr')
-        self.var_path = self.setup.get('apt_var_path', '/var')
-        self.etc_path = self.setup.get('apt_etc_path', '/etc')
-        self.debsums = '%s/bin/debsums' % self.install_path
-        self.aptget = '%s/bin/apt-get' % self.install_path
-        self.dpkg = '%s/bin/dpkg' % self.install_path
+        self.debsums = '%s/bin/debsums' % Bcfg2.Options.setup.apt_install_path
+        self.aptget = '%s/bin/apt-get' % Bcfg2.Options.setup.apt_install_path
+        self.dpkg = '%s/bin/dpkg' % Bcfg2.Options.setup.apt_install_path
         self.__execs__ = [self.debsums, self.aptget, self.dpkg]
 
         path_entries = os.environ['PATH'].split(':')
@@ -38,7 +46,7 @@ class APT(Bcfg2.Client.Tools.Tool):
                       '-o DPkg::Options::=--force-confmiss ' + \
                       '--reinstall ' + \
                       '--force-yes '
-        if not self.setup['debug']:
+        if not Bcfg2.Options.setup.debug:
             self.pkgcmd += '-q=2 '
         self.pkgcmd += '-y install %s'
         self.ignores = [entry.get('name') for struct in config \
@@ -46,19 +54,23 @@ class APT(Bcfg2.Client.Tools.Tool):
                         if entry.tag == 'Path' and \
                         entry.get('type') == 'ignore']
         self.__important__ = self.__important__ + \
-                             ["%s/cache/debconf/config.dat" % self.var_path,
-                              "%s/cache/debconf/templates.dat" % self.var_path,
-                              '/etc/passwd', '/etc/group',
-                              '%s/apt/apt.conf' % self.etc_path,
-                              '%s/dpkg/dpkg.cfg' % self.etc_path] + \
-                             [entry.get('name') for struct in config for entry in struct \
-                              if entry.tag == 'Path' and \
-                              entry.get('name').startswith('%s/apt/sources.list' % self.etc_path)]
-        self.nonexistent = [entry.get('name') for struct in config for entry in struct \
-                              if entry.tag == 'Path' and entry.get('type') == 'nonexistent']
+                             [
+            "%s/cache/debconf/config.dat" % Bcfg2.Options.setup.apt_var_path,
+            "%s/cache/debconf/templates.dat" % Bcfg2.Options.setup.apt_var_path,
+            '/etc/passwd', '/etc/group',
+            '%s/apt/apt.conf' % Bcfg2.Options.setup.apt_etc_path,
+            '%s/dpkg/dpkg.cfg' % Bcfg2.Options.setup.apt_etc_path] + \
+            [entry.get('name') for struct in config
+             for entry in struct
+             if (entry.tag == 'Path' and
+                 entry.get('name').startswith(
+                    '%s/apt/sources.list' % Bcfg2.Options.setup.apt_etc_path))]
+        self.nonexistent = [
+                entry.get('name') for struct in config for entry in struct
+                if entry.tag == 'Path' and entry.get('type') == 'nonexistent']
         os.environ["DEBIAN_FRONTEND"] = 'noninteractive'
         self.actions = {}
-        if self.setup['kevlar'] and not self.setup['dryrun']:
+        if Bcfg2.Options.setup.kevlar and not Bcfg2.Options.setup.dry_run:
             self.cmd.run("%s --force-confold --configure --pending" %
                          self.dpkg)
             self.cmd.run("%s clean" % self.aptget)
@@ -184,8 +196,9 @@ class APT(Bcfg2.Client.Tools.Tool):
             return False
         else:
             # version matches
-            if not self.setup['quick'] and entry.get('verify', 'true') == 'true' \
-                   and checksums:
+            if (not Bcfg2.Options.setup.quick and
+                entry.get('verify', 'true') == 'true'
+                and checksums):
                 pkgsums = self.VerifyDebsums(entry, modlist)
                 return pkgsums
             return True
diff --git a/src/lib/Bcfg2/Client/Tools/Action.py b/src/lib/Bcfg2/Client/Tools/Action.py
index 05e35befc..921d5723e 100644
--- a/src/lib/Bcfg2/Client/Tools/Action.py
+++ b/src/lib/Bcfg2/Client/Tools/Action.py
@@ -2,10 +2,9 @@
 
 import os
 import sys
-import select
 import Bcfg2.Client.Tools
-from Bcfg2.Client.Frame import matches_white_list, passes_black_list
-from Bcfg2.Compat import input  # pylint: disable=W0622
+from Bcfg2.Utils import safe_input
+from Bcfg2.Client import matches_white_list, passes_black_list
 
 
 class Action(Bcfg2.Client.Tools.Tool):
@@ -17,13 +16,13 @@ class Action(Bcfg2.Client.Tools.Tool):
     def _action_allowed(self, action):
         """ Return true if the given action is allowed to be run by
         the whitelist or blacklist """
-        if self.setup['decision'] == 'whitelist' and \
-           not matches_white_list(action, self.setup['decision_list']):
+        if (Bcfg2.Options.setup.decision == 'whitelist' and
+            not matches_white_list(action, Bcfg2.Options.setup.decision_list)):
             self.logger.info("In whitelist mode: suppressing Action: %s" %
                              action.get('name'))
             return False
-        if self.setup['decision'] == 'blacklist' and \
-           not passes_black_list(action, self.setup['decision_list']):
+        if (Bcfg2.Options.setup.decision == 'blacklist' and
+            not passes_black_list(action, Bcfg2.Options.setup.decision_list)):
             self.logger.info("In blacklist mode: suppressing Action: %s" %
                              action.get('name'))
             return False
@@ -37,19 +36,15 @@ class Action(Bcfg2.Client.Tools.Tool):
             shell = True
             shell_string = '(in shell) '
 
-        if not self.setup['dryrun']:
-            if self.setup['interactive']:
+        if not Bcfg2.Options.setup.dryrun:
+            if Bcfg2.Options.setup.interactive:
                 prompt = ('Run Action %s%s, %s: (y/N): ' %
                           (shell_string, entry.get('name'),
                            entry.get('command')))
-                # flush input buffer
-                while len(select.select([sys.stdin.fileno()], [], [],
-                                        0.0)[0]) > 0:
-                    os.read(sys.stdin.fileno(), 4096)
-                ans = input(prompt)
+                ans = safe_input(prompt)
                 if ans not in ['y', 'Y']:
                     return False
-            if self.setup['servicemode'] == 'build':
+            if Bcfg2.Options.setup.service_mode == 'build':
                 if entry.get('build', 'true') == 'false':
                     self.logger.debug("Action: Deferring execution of %s due "
                                       "to build mode" % entry.get('command'))
diff --git a/src/lib/Bcfg2/Client/Tools/Chkconfig.py b/src/lib/Bcfg2/Client/Tools/Chkconfig.py
index 156f76159..0d2269a3f 100644
--- a/src/lib/Bcfg2/Client/Tools/Chkconfig.py
+++ b/src/lib/Bcfg2/Client/Tools/Chkconfig.py
@@ -3,7 +3,6 @@
 """This is chkconfig support."""
 
 import os
-
 import Bcfg2.Client.Tools
 import Bcfg2.Client.XML
 
@@ -96,15 +95,15 @@ class Chkconfig(Bcfg2.Client.Tools.SvcTool):
                 bootcmd = '/sbin/chkconfig %s %s' % (entry.get('name'),
                                                      entry.get('bootstatus'))
             bootcmdrv = self.cmd.run(bootcmd).success
-            if self.setup['servicemode'] == 'disabled':
+            if Bcfg2.Options.setup.servicemode == 'disabled':
                 # 'disabled' means we don't attempt to modify running svcs
                 return bootcmdrv
-            buildmode = self.setup['servicemode'] == 'build'
-            if (entry.get('status') == 'on' and not buildmode) and \
-               entry.get('current_status') == 'off':
+            buildmode = Bcfg2.Options.setup.servicemode == 'build'
+            if ((entry.get('status') == 'on' and not buildmode) and
+                entry.get('current_status') == 'off'):
                 svccmdrv = self.start_service(entry)
-            elif (entry.get('status') == 'off' or buildmode) and \
-                    entry.get('current_status') == 'on':
+            elif ((entry.get('status') == 'off' or buildmode) and
+                  entry.get('current_status') == 'on'):
                 svccmdrv = self.stop_service(entry)
             else:
                 svccmdrv = True  # ignore status attribute
diff --git a/src/lib/Bcfg2/Client/Tools/MacPorts.py b/src/lib/Bcfg2/Client/Tools/MacPorts.py
index dcf58cfec..c28f8c743 100644
--- a/src/lib/Bcfg2/Client/Tools/MacPorts.py
+++ b/src/lib/Bcfg2/Client/Tools/MacPorts.py
@@ -39,8 +39,6 @@ class MacPorts(Bcfg2.Client.Tools.PkgTool):
         if entry.attrib['name'] in self.installed:
             if (self.installed[entry.attrib['name']] == entry.attrib['version']
                 or entry.attrib['version'] == 'any'):
-                #if not self.setup['quick'] and \
-                #                entry.get('verify', 'true') == 'true':
                 #FIXME: We should be able to check this once
                 #       http://trac.macports.org/ticket/15709 is implemented
                 return True
diff --git a/src/lib/Bcfg2/Client/Tools/POSIX/File.py b/src/lib/Bcfg2/Client/Tools/POSIX/File.py
index 9f47fb53a..482320e0d 100644
--- a/src/lib/Bcfg2/Client/Tools/POSIX/File.py
+++ b/src/lib/Bcfg2/Client/Tools/POSIX/File.py
@@ -6,6 +6,7 @@ import stat
 import time
 import difflib
 import tempfile
+import Bcfg2.Options
 from Bcfg2.Client.Tools.POSIX.base import POSIXTool
 from Bcfg2.Compat import unicode, b64encode, b64decode  # pylint: disable=W0622
 
@@ -43,7 +44,7 @@ class POSIXFile(POSIXTool):
             tempdata = entry.text
             if isinstance(tempdata, unicode) and unicode != str:
                 try:
-                    tempdata = tempdata.encode(self.setup['encoding'])
+                    tempdata = tempdata.encode(Bcfg2.Options.setup.encoding)
                 except UnicodeEncodeError:
                     err = sys.exc_info()[1]
                     self.logger.error("POSIX: Error encoding file %s: %s" %
@@ -82,7 +83,7 @@ class POSIXFile(POSIXTool):
             self.logger.debug("POSIX: %s has incorrect contents" %
                               entry.get("name"))
             self._get_diffs(
-                entry, interactive=self.setup['interactive'],
+                entry, interactive=Bcfg2.Options.setup.interactive,
                 sensitive=entry.get('sensitive', 'false').lower() == 'true',
                 is_binary=is_binary, content=content)
         return POSIXTool.verify(self, entry, modlist) and not different
@@ -170,7 +171,8 @@ class POSIXFile(POSIXTool):
                                   (entry.get("name"), sys.exc_info()[1]))
                 return False
         if not is_binary:
-            is_binary |= not self._is_string(content, self.setup['encoding'])
+            is_binary |= not self._is_string(content,
+                                             Bcfg2.Options.setup.encoding)
         if is_binary:
             # don't compute diffs if the file is binary
             prompt.append('Binary file, no printable diff')
@@ -183,7 +185,7 @@ class POSIXFile(POSIXTool):
                 if diff:
                     udiff = '\n'.join(l.rstrip('\n') for l in diff)
                     if hasattr(udiff, "decode"):
-                        udiff = udiff.decode(self.setup['encoding'])
+                        udiff = udiff.decode(Bcfg2.Options.setup.encoding)
                     try:
                         prompt.append(udiff)
                     except UnicodeEncodeError:
diff --git a/src/lib/Bcfg2/Client/Tools/POSIX/__init__.py b/src/lib/Bcfg2/Client/Tools/POSIX/__init__.py
index 4f1f8e5aa..db0fa96ab 100644
--- a/src/lib/Bcfg2/Client/Tools/POSIX/__init__.py
+++ b/src/lib/Bcfg2/Client/Tools/POSIX/__init__.py
@@ -4,20 +4,31 @@ import os
 import re
 import sys
 import shutil
-from datetime import datetime
+import Bcfg2.Options
 import Bcfg2.Client.Tools
+from datetime import datetime
 from Bcfg2.Compat import walk_packages
 from Bcfg2.Client.Tools.POSIX.base import POSIXTool
 
 
 class POSIX(Bcfg2.Client.Tools.Tool):
     """POSIX File support code."""
-    name = 'POSIX'
+
+    options = Bcfg2.Client.Tools.Tool.options + [
+        Bcfg2.Options.PathOption(
+            cf=('paranoid', 'path'), default='/var/cache/bcfg2',
+            dest='paranoid_path',
+            help='Specify path for paranoid file backups'),
+        Bcfg2.Options.Option(
+            cf=('paranoid', 'max_copies'), default=1, type=int,
+            dest='paranoid_copies',
+            help='Specify the number of paranoid copies you want'),
+        Bcfg2.Options.BooleanOption(
+            '-P', '--paranoid', cf=('client', 'paranoid'),
+            help='Make automatic backups of config files')]
 
     def __init__(self, config):
         Bcfg2.Client.Tools.Tool.__init__(self, config)
-        self.ppath = self.setup['ppath']
-        self.max_copies = self.setup['max_copies']
         self._handlers = self._load_handlers()
         self.logger.debug("POSIX: Handlers loaded: %s" %
                           (", ".join(self._handlers.keys())))
@@ -89,7 +100,7 @@ class POSIX(Bcfg2.Client.Tools.Tool):
         self.logger.debug("POSIX: Verifying entry %s:%s:%s" %
                           (entry.tag, entry.get("type"), entry.get("name")))
         ret = self._handlers[entry.get("type")].verify(entry, modlist)
-        if self.setup['interactive'] and not ret:
+        if Bcfg2.Options.setup.interactive and not ret:
             entry.set('qtext',
                       '%s\nInstall %s %s: (y/N) ' %
                       (entry.get('qtext', ''),
@@ -103,35 +114,39 @@ class POSIX(Bcfg2.Client.Tools.Tool):
             bkupnam + r'_\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{6}$')
         # current list of backups for this file
         try:
-            bkuplist = [f for f in os.listdir(self.ppath) if
-                        bkup_re.match(f)]
+            bkuplist = [f
+                        for f in os.listdir(Bcfg2.Options.setup.paranoid_path)
+                        if bkup_re.match(f)]
         except OSError:
             err = sys.exc_info()[1]
             self.logger.error("POSIX: Failed to create backup list in %s: %s" %
-                              (self.ppath, err))
+                              (Bcfg2.Options.setup.paranoid_path, err))
             return
         bkuplist.sort()
-        while len(bkuplist) >= int(self.max_copies):
+        while len(bkuplist) >= int(Bcfg2.Options.setup.paranoid_copies):
             # remove the oldest backup available
             oldest = bkuplist.pop(0)
             self.logger.info("POSIX: Removing old backup %s" % oldest)
             try:
-                os.remove(os.path.join(self.ppath, oldest))
+                os.remove(os.path.join(Bcfg2.Options.setup.paranoid_path,
+                                       oldest))
             except OSError:
                 err = sys.exc_info()[1]
-                self.logger.error("POSIX: Failed to remove old backup %s: %s" %
-                                  (os.path.join(self.ppath, oldest), err))
+                self.logger.error(
+                    "POSIX: Failed to remove old backup %s: %s" %
+                    (os.path.join(Bcfg2.Options.setup.paranoid_path, oldest),
+                     err))
 
     def _paranoid_backup(self, entry):
         """ Take a backup of the specified entry for paranoid mode """
         if (entry.get("paranoid", 'false').lower() == 'true' and
-            self.setup.get("paranoid", False) and
+            Bcfg2.Options.setup.paranoid and
             entry.get('current_exists', 'true') == 'true' and
             not os.path.isdir(entry.get("name"))):
             self._prune_old_backups(entry)
             bkupnam = "%s_%s" % (entry.get('name').replace('/', '_'),
                                  datetime.isoformat(datetime.now()))
-            bfile = os.path.join(self.ppath, bkupnam)
+            bfile = os.path.join(Bcfg2.Options.setup.paranoid_path, bkupnam)
             try:
                 shutil.copy(entry.get('name'), bfile)
                 self.logger.info("POSIX: Backup of %s saved to %s" %
diff --git a/src/lib/Bcfg2/Client/Tools/POSIX/base.py b/src/lib/Bcfg2/Client/Tools/POSIX/base.py
index 16fe0acb5..fad458003 100644
--- a/src/lib/Bcfg2/Client/Tools/POSIX/base.py
+++ b/src/lib/Bcfg2/Client/Tools/POSIX/base.py
@@ -105,23 +105,23 @@ class POSIXTool(Bcfg2.Client.Tools.Tool):
             path = entry.get("name")
 
         rv = True
-        if entry.get("owner") and entry.get("group"):
-            try:
-                self.logger.debug("POSIX: Setting ownership of %s to %s:%s" %
-                                  (path,
-                                   self._norm_entry_uid(entry),
-                                   self._norm_entry_gid(entry)))
-                os.chown(path, self._norm_entry_uid(entry),
-                         self._norm_entry_gid(entry))
-            except KeyError:
-                self.logger.error('POSIX: Failed to change ownership of %s' %
-                                  path)
-                rv = False
-                os.chown(path, 0, 0)
-            except OSError:
-                self.logger.error('POSIX: Failed to change ownership of %s' %
-                                  path)
-                rv = False
+        if os.geteuid() == 0:
+            if entry.get("owner") and entry.get("group"):
+                try:
+                    self.logger.debug("POSIX: Setting ownership of %s to %s:%s"
+                                      % (path,
+                                         self._norm_entry_uid(entry),
+                                         self._norm_entry_gid(entry)))
+                    os.chown(path, self._norm_entry_uid(entry),
+                             self._norm_entry_gid(entry))
+                except (OSError, KeyError):
+                    self.logger.error('POSIX: Failed to change ownership of %s'
+                                      % path)
+                    rv = False
+                    if sys.exc_info()[0] == KeyError:
+                        os.chown(path, 0, 0)
+        else:
+            self.logger.debug("POSIX: Run as non-root, not setting ownership")
 
         if entry.get("mode"):
             wanted_mode = int(entry.get('mode'), 8)
diff --git a/src/lib/Bcfg2/Client/Tools/POSIXUsers.py b/src/lib/Bcfg2/Client/Tools/POSIXUsers.py
index 8f6bc5f37..7a076e680 100644
--- a/src/lib/Bcfg2/Client/Tools/POSIXUsers.py
+++ b/src/lib/Bcfg2/Client/Tools/POSIXUsers.py
@@ -8,9 +8,31 @@ import Bcfg2.Client.Tools
 from Bcfg2.Utils import PackedDigitRange
 
 
+def uid_range_type(val):
+    return PackedDigitRange(*Bcfg2.Options.Types.comma_list(val))
+
+
 class POSIXUsers(Bcfg2.Client.Tools.Tool):
     """ A tool to handle creating users and groups with
     useradd/mod/del and groupadd/mod/del """
+    options = Bcfg2.Client.Tools.Tool.options + [
+        Bcfg2.Options.Option(
+            cf=('POSIXUsers', 'uid_whitelist'), default=[],
+            type=uid_range_type,
+            help="UID ranges the POSIXUsers tool will manage"),
+        Bcfg2.Options.Option(
+            cf=('POSIXUsers', 'gid_whitelist'), default=[],
+            type=uid_range_type,
+            help="GID ranges the POSIXUsers tool will manage"),
+        Bcfg2.Options.Option(
+            cf=('POSIXUsers', 'uid_blacklist'), default=[],
+            type=uid_range_type,
+            help="UID ranges the POSIXUsers tool will not manage"),
+        Bcfg2.Options.Option(
+            cf=('POSIXUsers', 'gid_blacklist'), default=[],
+            type=uid_range_type,
+            help="GID ranges the POSIXUsers tool will not manage")]
+
     __execs__ = ['/usr/sbin/useradd', '/usr/sbin/usermod', '/usr/sbin/userdel',
                  '/usr/sbin/groupadd', '/usr/sbin/groupmod',
                  '/usr/sbin/groupdel']
@@ -34,20 +56,10 @@ class POSIXUsers(Bcfg2.Client.Tools.Tool):
         self.set_defaults = dict(POSIXUser=self.populate_user_entry,
                                  POSIXGroup=lambda g: g)
         self._existing = None
-        self._whitelist = dict(POSIXUser=None, POSIXGroup=None)
-        self._blacklist = dict(POSIXUser=None, POSIXGroup=None)
-        if self.setup['posix_uid_whitelist']:
-            self._whitelist['POSIXUser'] = \
-                PackedDigitRange(*self.setup['posix_uid_whitelist'])
-        else:
-            self._blacklist['POSIXUser'] = \
-                PackedDigitRange(*self.setup['posix_uid_blacklist'])
-        if self.setup['posix_gid_whitelist']:
-            self._whitelist['POSIXGroup'] = \
-                PackedDigitRange(*self.setup['posix_gid_whitelist'])
-        else:
-            self._blacklist['POSIXGroup'] = \
-                PackedDigitRange(*self.setup['posix_gid_blacklist'])
+        self._whitelist = dict(POSIXUser=Bcfg2.Options.setup.uid_whitelist,
+                               POSIXGroup=Bcfg2.Options.setup.gid_whitelist)
+        self._blacklist = dict(POSIXUser=Bcfg2.Options.setup.uid_blacklist,
+                               POSIXGroup=Bcfg2.Options.setup.gid_blacklist)
 
     @property
     def existing(self):
@@ -164,7 +176,7 @@ class POSIXUsers(Bcfg2.Client.Tools.Tool):
                                      % (entry.tag, entry.get("name"),
                                         actual, expected)]))
                 rv = False
-        if self.setup['interactive'] and not rv:
+        if Bcfg2.Options.setup.interactive and not rv:
             entry.set('qtext',
                       '%s\nInstall %s %s: (y/N) ' %
                       (entry.get('qtext', ''), entry.tag, entry.get('name')))
@@ -173,7 +185,7 @@ class POSIXUsers(Bcfg2.Client.Tools.Tool):
     def VerifyPOSIXGroup(self, entry, _):
         """ Verify a POSIXGroup entry """
         rv = self._verify(entry)
-        if self.setup['interactive'] and not rv:
+        if Bcfg2.Options.setup.interactive and not rv:
             entry.set('qtext',
                       '%s\nInstall %s %s: (y/N) ' %
                       (entry.get('qtext', ''), entry.tag, entry.get('name')))
diff --git a/src/lib/Bcfg2/Client/Tools/Pacman.py b/src/lib/Bcfg2/Client/Tools/Pacman.py
index d7d60a66d..2ab9b7403 100644
--- a/src/lib/Bcfg2/Client/Tools/Pacman.py
+++ b/src/lib/Bcfg2/Client/Tools/Pacman.py
@@ -38,8 +38,6 @@ class Pacman(Bcfg2.Client.Tools.PkgTool):
                 return True
             elif self.installed[entry.attrib['name']] == \
                     entry.attrib['version']:
-                #if not self.setup['quick'] and \
-                #                entry.get('verify', 'true') == 'true':
                 #FIXME: need to figure out if pacman
                 #       allows you to verify packages
                 return True
diff --git a/src/lib/Bcfg2/Client/Tools/Portage.py b/src/lib/Bcfg2/Client/Tools/Portage.py
index e52da081b..a877b564f 100644
--- a/src/lib/Bcfg2/Client/Tools/Portage.py
+++ b/src/lib/Bcfg2/Client/Tools/Portage.py
@@ -5,9 +5,13 @@ import Bcfg2.Client.Tools
 
 
 class Portage(Bcfg2.Client.Tools.PkgTool):
-    """The Gentoo toolset implements package and service operations and
-    inherits the rest from Toolset.Toolset."""
-    name = 'Portage'
+    """The Gentoo toolset implements package and service operations
+    and inherits the rest from Tools.Tool."""
+
+    options = Bcfg2.Client.Tools.PkgTool.options + [
+        Bcfg2.Options.BooleanOption(
+            cf=('Portage', 'binpkgonly'), help='Portage binary packages only')]
+
     __execs__ = ['/usr/bin/emerge', '/usr/bin/equery']
     __handles__ = [('Package', 'ebuild')]
     __req__ = {'Package': ['name', 'version']}
@@ -25,8 +29,7 @@ class Portage(Bcfg2.Client.Tools.PkgTool):
         self._pkg_pattern = re.compile(r'(.*)-(\d.*)')
         self._ebuild_pattern = re.compile('(ebuild|binary)')
         self.installed = {}
-        self._binpkgonly = self.setup.get('portage_binpkgonly', False)
-        if self._binpkgonly:
+        if Bcfg2.Options.setup.binpkgonly:
             self.pkgtool = self._binpkgtool
         self.RefreshPackages()
 
@@ -61,7 +64,7 @@ class Portage(Bcfg2.Client.Tools.PkgTool):
         version = self.installed[entry.get('name')]
         entry.set('current_version', version)
 
-        if not self.setup['quick']:
+        if not Bcfg2.Options.setup.quick:
             if ('verify' not in entry.attrib or
                 entry.get('verify').lower() == 'true'):
 
diff --git a/src/lib/Bcfg2/Client/Tools/RPM.py b/src/lib/Bcfg2/Client/Tools/RPM.py
index be5ad01e2..1ebc61c93 100644
--- a/src/lib/Bcfg2/Client/Tools/RPM.py
+++ b/src/lib/Bcfg2/Client/Tools/RPM.py
@@ -1075,6 +1075,42 @@ if __name__ == "__main__":
 
 class RPM(Bcfg2.Client.Tools.PkgTool):
     """Support for RPM packages."""
+    options = Bcfg2.Client.Tools.PkgTool.options + [
+        Bcfg2.Options.Option(
+            cf=('RPM', 'installonlypackages'), dest="rpm_installonly",
+            type=Bcfg2.Options.Types.comma_list,
+            default=['kernel', 'kernel-bigmem', 'kernel-enterprise',
+                     'kernel-smp', 'kernel-modules', 'kernel-debug',
+                     'kernel-unsupported', 'kernel-devel', 'kernel-source',
+                     'kernel-default', 'kernel-largesmp-devel',
+                     'kernel-largesmp', 'kernel-xen', 'gpg-pubkey'],
+            help='RPM install-only packages'),
+        Bcfg2.Options.BooleanOption(
+            cf=('RPM', 'pkg_checks'), default=True, dest="rpm_pkg_checks",
+            help="Perform RPM package checks"),
+        Bcfg2.Options.BooleanOption(
+            cf=('RPM', 'pkg_verify'), default=True, dest="rpm_pkg_verify",
+            help="Perform RPM package verify"),
+        Bcfg2.Options.BooleanOption(
+            cf=('RPM', 'install_missing'), default=True,
+            dest="rpm_install_missing",
+            help="Install missing packages"),
+        Bcfg2.Options.Option(
+            cf=('RPM', 'erase_flags'), default=["allmatches"],
+            dest="rpm_erase_flags",
+            help="RPM erase flags"),
+        Bcfg2.Options.BooleanOption(
+            cf=('RPM', 'fix_version'), default=True,
+            dest="rpm_fix_version",
+            help="Fix (upgrade or downgrade) packages with the wrong version"),
+        Bcfg2.Options.BooleanOption(
+            cf=('RPM', 'reinstall_broken'), default=True,
+            dest="rpm_reinstall_broken",
+            help="Reinstall packages that fail to verify"),
+        Bcfg2.Options.Option(
+            cf=('RPM', 'verify_flags'), default=[], dest="rpm_verify_flags",
+            help="RPM verify flags")]
+
     __execs__ = ['/bin/rpm', '/var/lib/rpm']
     __handles__ = [('Package', 'rpm')]
 
@@ -1109,43 +1145,36 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
         self.modlists = {}
         self.gpg_keyids = self.getinstalledgpg()
 
-        opt_prefix = self.name.lower()
-        self.installOnlyPkgs = self.setup["%s_installonly" % opt_prefix]
+        self.installOnlyPkgs = Bcfg2.Options.setup.rpm_installonly
         if 'gpg-pubkey' not in self.installOnlyPkgs:
             self.installOnlyPkgs.append('gpg-pubkey')
-        self.erase_flags = self.setup['%s_erase_flags' % opt_prefix]
-        self.pkg_checks = self.setup['%s_pkg_checks' % opt_prefix]
-        self.pkg_verify = self.setup['%s_pkg_verify' % opt_prefix]
-        self.installed_action = self.setup['%s_installed_action' % opt_prefix]
-        self.version_fail_action = self.setup['%s_version_fail_action' %
-                                              opt_prefix]
-        self.verify_fail_action = self.setup['%s_verify_fail_action' %
-                                             opt_prefix]
-        self.verify_flags = self.setup['%s_verify_flags' % opt_prefix]
+        self.verify_flags = Bcfg2.Options.setup.rpm_verify_flags
         if '' in self.verify_flags:
             self.verify_flags.remove('')
 
         self.logger.debug('%s: installOnlyPackages = %s' %
                           (self.name, self.installOnlyPkgs))
         self.logger.debug('%s: erase_flags = %s' %
-                          (self.name, self.erase_flags))
+                          (self.name, Bcfg2.Options.setup.rpm_erase_flags))
         self.logger.debug('%s: pkg_checks = %s' %
-                          (self.name, self.pkg_checks))
+                          (self.name, Bcfg2.Options.setup.rpm_pkg_checks))
         self.logger.debug('%s: pkg_verify = %s' %
-                          (self.name, self.pkg_verify))
-        self.logger.debug('%s: installed_action = %s' %
-                          (self.name, self.installed_action))
-        self.logger.debug('%s: version_fail_action = %s' %
-                          (self.name, self.version_fail_action))
-        self.logger.debug('%s: verify_fail_action = %s' %
-                          (self.name, self.verify_fail_action))
+                          (self.name, Bcfg2.Options.setup.rpm_pkg_verify))
+        self.logger.debug('%s: install_missing = %s' %
+                          (self.name, Bcfg2.Options.setup.install_missing))
+        self.logger.debug('%s: fix_version = %s' %
+                          (self.name, Bcfg2.Options.setup.rpm_fix_version))
+        self.logger.debug('%s: reinstall_broken = %s' %
+                          (self.name,
+                           Bcfg2.Options.setup.rpm_reinstall_broken))
         self.logger.debug('%s: verify_flags = %s' %
                           (self.name, self.verify_flags))
 
         # Force a re- prelink of all packages if prelink exists.
         # Many, if not most package verifies can be caused by out of
         # date prelinking.
-        if os.path.isfile('/usr/sbin/prelink') and not self.setup['dryrun']:
+        if (os.path.isfile('/usr/sbin/prelink') and
+            not Bcfg2.Options.setup.dry_run):
             rv = self.cmd.run('/usr/sbin/prelink -a -mR')
             if rv.success:
                 self.logger.debug('Pre-emptive prelink succeeded')
@@ -1176,7 +1205,7 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
         refresh_ts.setVSFlags(rpm._RPMVSF_NODIGESTS|rpm._RPMVSF_NOSIGNATURES)
         for nevra in rpmpackagelist(refresh_ts):
             self.installed.setdefault(nevra['name'], []).append(nevra)
-        if self.setup['debug']:
+        if Bcfg2.Options.setup.debug:
             print("The following package instances are installed:")
             for name, instances in list(self.installed.items()):
                 self.logger.debug("    " + name)
@@ -1217,7 +1246,7 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
             instance = Bcfg2.Client.XML.SubElement(entry, 'Package')
             for attrib in list(entry.attrib.keys()):
                 instance.attrib[attrib] = entry.attrib[attrib]
-            if (self.pkg_checks and
+            if (Bcfg2.Options.setup.rpm_pkg_checks and
                 entry.get('pkg_checks', 'true').lower() == 'true'):
                 if 'any' in [entry.get('version'), pinned_version]:
                     version, release = 'any', 'any'
@@ -1240,7 +1269,7 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
 
         if entry.get('name') in self.installed:
             # There is at least one instance installed.
-            if (self.pkg_checks and
+            if (Bcfg2.Options.setup.rpm_pkg_checks and
                 entry.get('pkg_checks', 'true').lower() == 'true'):
                 rpmTs = rpm.TransactionSet()
                 rpmHeader = None
@@ -1269,7 +1298,7 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
                                 self.logger.debug("        %s" % self.str_evra(inst))
                                 self.instance_status[inst]['installed'] = True
 
-                                if (self.pkg_verify and
+                                if (Bcfg2.Options.setup.rpm_pkg_verify and
                                     inst.get('pkg_verify', 'true').lower() == 'true'):
                                     flags = inst.get('verify_flags', '').split(',') + self.verify_flags
                                     if pkg.get('gpgkeyid', '')[-8:] not in self.gpg_keyids and \
@@ -1280,7 +1309,7 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
                                                               pkg.get('gpgkeyid', '')))
                                         self.logger.debug('         Disabling signature check.')
 
-                                    if self.setup.get('quick', False):
+                                    if Bcfg2.Options.setup.quick:
                                         if prelink_exists:
                                             flags += ['nomd5', 'nosize']
                                         else:
@@ -1328,7 +1357,7 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
                                     self.logger.debug("        %s" % self.str_evra(inst))
                                     self.instance_status[inst]['installed'] = True
 
-                                    if (self.pkg_verify and
+                                    if (Bcfg2.Options.setup.rpm_pkg_verify and
                                         inst.get('pkg_verify', 'true').lower() == 'true'):
                                         flags = inst.get('verify_flags', '').split(',') + self.verify_flags
                                         if pkg.get('gpgkeyid', '')[-8:] not in self.gpg_keyids and \
@@ -1339,7 +1368,7 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
                                                             pkg.get('gpgkeyid', '')))
                                             self.logger.info('         Disabling signature check.')
 
-                                        if self.setup.get('quick', False):
+                                        if Bcfg2.Options.setup.quick:
                                             if prelink_exists:
                                                 flags += ['nomd5', 'nosize']
                                             else:
@@ -1374,7 +1403,8 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
                     instance_fail = False
                     # Dump the rpm verify results.
                     #****Write something to format this nicely.*****
-                    if self.setup['debug'] and self.instance_status[inst].get('verify', None):
+                    if (Bcfg2.Options.setup.debug and
+                        self.instance_status[inst].get('verify', None)):
                         self.logger.debug(self.instance_status[inst]['verify'])
 
                     self.instance_status[inst]['verify_fail'] = False
@@ -1502,7 +1532,7 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
                     self.logger.info("         This package will be deleted in a future version of the RPM driver.")
                 #pkgspec_list.append(pkg_spec)
 
-        erase_results = rpm_erase(pkgspec_list, self.erase_flags)
+        erase_results = rpm_erase(pkgspec_list, Bcfg2.Options.setup.rpm_erase_flags)
         if erase_results == []:
             self.modified += packages
             for pkg in pkgspec_list:
@@ -1530,7 +1560,9 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
                                                    % (pkgspec.get('name'), self.str_evra(pkgspec)))
                         self.logger.info("         This package will be deleted in a future version of the RPM driver.")
                         continue # Don't delete the gpg-pubkey packages for now.
-                    erase_results = rpm_erase([pkgspec], self.erase_flags)
+                    erase_results = rpm_erase(
+                        [pkgspec],
+                        Bcfg2.Options.setup.rpm_erase_flags)
                     if erase_results == []:
                         pkg_modified = True
                         self.logger.info("Deleted %s %s" % \
@@ -1555,28 +1587,27 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
         """
         fix = False
 
-        if inst_status.get('installed', False) == False:
-            if instance.get('installed_action', 'install') == "install" and \
-               self.installed_action == "install":
+        if not inst_status.get('installed', False):
+            if (instance.get('install_missing', 'true').lower() == "true" and
+                Bcfg2.Options.setup.rpm_install_missing):
                 fix = True
             else:
                 self.logger.debug('Installed Action for %s %s is to not install' % \
                                   (inst_status.get('pkg').get('name'),
                                    self.str_evra(instance)))
 
-        elif inst_status.get('version_fail', False) == True:
-            if instance.get('version_fail_action', 'upgrade') == "upgrade" and \
-                self.version_fail_action == "upgrade":
+        elif inst_status.get('version_fail', False):
+            if (instance.get('fix_version', 'true').lower() == "true" and
+                Bcfg2.Options.setup.rpm_fix_version):
                 fix = True
             else:
                 self.logger.debug('Version Fail Action for %s %s is to not upgrade' % \
                                   (inst_status.get('pkg').get('name'),
                                    self.str_evra(instance)))
 
-        elif inst_status.get('verify_fail', False) == True and self.name == "RPM":
-            # yum can't reinstall packages so only do this for rpm.
-            if instance.get('verify_fail_action', 'reinstall') == "reinstall" and \
-               self.verify_fail_action == "reinstall":
+        elif inst_status.get('verify_fail', False):
+            if (instance.get('reinstall_broken', 'true').lower() == "true" and
+                Bcfg2.Options.setup.rpm_reinstall_broken):
                 for inst in inst_status.get('verify'):
                     # This needs to be a for loop rather than a straight get()
                     # because the underlying routines handle multiple packages
@@ -1633,9 +1664,8 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
         # Remove extra instances.
         # Can not reverify because we don't have a package entry.
         if len(self.extra_instances) > 0:
-            if (self.setup.get('remove') == 'all' or \
-                self.setup.get('remove') == 'packages') and\
-                not self.setup.get('dryrun'):
+            if (Bcfg2.Options.setup.remove in ['all', 'packages'] and
+                not Bcfg2.Options.setup.dry_run):
                 self.Remove(self.extra_instances)
             else:
                 self.logger.info("The following extra package instances will be removed by the '-r' option:")
@@ -1744,7 +1774,7 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
                                                       for inst in upgrade_pkgs])
                 self.RefreshPackages()
 
-        if not self.setup['kevlar']:
+        if not Bcfg2.Options.setup.kevlar:
             for pkg_entry in packages:
                 self.logger.debug("Reverifying Failed Package %s" % (pkg_entry.get('name')))
                 states[pkg_entry] = self.VerifyPackage(pkg_entry, \
@@ -1847,7 +1877,7 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
             return False
 
         # We don't want to do any checks so we don't care what the entry has in it.
-        if (not self.pkg_checks or
+        if (not Bcfg2.Options.setup.rpm_pkg_checks or
             entry.get('pkg_checks', 'true').lower() == 'false'):
             return True
 
@@ -1914,7 +1944,7 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
             if name not in packages:
                 extra_entry = Bcfg2.Client.XML.Element('Package', name=name, type=self.pkgtype)
                 for installed_inst in instances:
-                    if self.setup['extra']:
+                    if Bcfg2.Options.setup.extra:
                         self.logger.info("Extra Package %s %s." % \
                                          (name, self.str_evra(installed_inst)))
                     tmp_entry = Bcfg2.Client.XML.SubElement(extra_entry, 'Instance', \
@@ -1927,7 +1957,6 @@ class RPM(Bcfg2.Client.Tools.PkgTool):
                 extras.append(extra_entry)
         return extras
 
-
     def FindExtraInstances(self, pkg_entry, installed_entry):
         """
             Check for installed instances that are not in the config.
diff --git a/src/lib/Bcfg2/Client/Tools/SELinux.py b/src/lib/Bcfg2/Client/Tools/SELinux.py
index 92572ef1d..ef89ef46d 100644
--- a/src/lib/Bcfg2/Client/Tools/SELinux.py
+++ b/src/lib/Bcfg2/Client/Tools/SELinux.py
@@ -141,7 +141,7 @@ class SELinux(Bcfg2.Client.Tools.Tool):
     def GenericSEVerify(self, entry, _):
         """Dispatch verify to the proper method according to entry tag"""
         rv = self.handlers[entry.tag].Verify(entry)
-        if entry.get('qtext') and self.setup['interactive']:
+        if entry.get('qtext') and Bcfg2.Options.setup.interactive:
             entry.set('qtext',
                       '%s\nInstall %s: (y/N) ' %
                       (entry.get('qtext'),
@@ -174,7 +174,6 @@ class SELinuxEntryHandler(object):
     def __init__(self, tool, config):
         self.tool = tool
         self.logger = logging.getLogger(self.__class__.__name__)
-        self.setup = tool.setup
         self.config = config
         self._records = None
         self._all = None
diff --git a/src/lib/Bcfg2/Client/Tools/SYSV.py b/src/lib/Bcfg2/Client/Tools/SYSV.py
index 7be7b6fa3..f149be7af 100644
--- a/src/lib/Bcfg2/Client/Tools/SYSV.py
+++ b/src/lib/Bcfg2/Client/Tools/SYSV.py
@@ -80,7 +80,7 @@ class SYSV(Bcfg2.Client.Tools.PkgTool):
                 self.logger.debug("Package %s not installed" %
                                   entry.get("name"))
         else:
-            if (self.setup['quick'] or
+            if (Bcfg2.Options.setup.quick or
                 entry.attrib.get('verify', 'true') == 'false'):
                 return True
             rv = self.cmd.run("/usr/sbin/pkgchk -n %s" % entry.get('name'))
diff --git a/src/lib/Bcfg2/Client/Tools/YUM.py b/src/lib/Bcfg2/Client/Tools/YUM.py
index 147615f47..c9b74dcd0 100644
--- a/src/lib/Bcfg2/Client/Tools/YUM.py
+++ b/src/lib/Bcfg2/Client/Tools/YUM.py
@@ -119,6 +119,34 @@ class YumDisplay(yum.callbacks.ProcessTransBaseCallback):
 
 class YUM(Bcfg2.Client.Tools.PkgTool):
     """Support for Yum packages."""
+
+    options = Bcfg2.Client.Tools.PkgTool.options + [
+        Bcfg2.Options.BooleanOption(
+            cf=('YUM', 'pkg_checks'), default=True, dest="yum_pkg_checks",
+            help="Perform YUM package checks"),
+        Bcfg2.Options.BooleanOption(
+            cf=('YUM', 'pkg_verify'), default=True, dest="yum_pkg_verify",
+            help="Perform YUM package verify"),
+        Bcfg2.Options.BooleanOption(
+            cf=('YUM', 'install_missing'), default=True,
+            dest="yum_install_missing",
+            help="Install missing packages"),
+        Bcfg2.Options.Option(
+            cf=('YUM', 'erase_flags'), default=["allmatches"],
+            dest="yum_erase_flags",
+            help="YUM erase flags"),
+        Bcfg2.Options.BooleanOption(
+            cf=('YUM', 'fix_version'), default=True,
+            dest="yum_fix_version",
+            help="Fix (upgrade or downgrade) packages with the wrong version"),
+        Bcfg2.Options.BooleanOption(
+            cf=('YUM', 'reinstall_broken'), default=True,
+            dest="yum_reinstall_broken",
+            help="Reinstall packages that fail to verify"),
+        Bcfg2.Options.Option(
+            cf=('YUM', 'verify_flags'), default=[], dest="yum_verify_flags",
+            help="YUM verify flags")]
+
     pkgtype = 'yum'
     __execs__ = []
     __handles__ = [('Package', 'yum'),
@@ -173,26 +201,23 @@ class YUM(Bcfg2.Client.Tools.PkgTool):
                 else:
                     dest[pname] = dict(data)
 
-        # Process the Yum section from the config file.  These are all
-        # boolean flags, either we do stuff or we don't
-        self.pkg_checks = self.setup["yum_pkg_checks"]
-        self.pkg_verify = self.setup["yum_pkg_verify"]
-        self.do_install = self.setup["yum_installed_action"] == "install"
-        self.do_upgrade = self.setup["yum_version_fail_action"] == "upgrade"
-        self.do_reinst = self.setup["yum_verify_fail_action"] == "reinstall"
-        self.verify_flags = self.setup["yum_verify_flags"]
-
         self.installonlypkgs = self.yumbase.conf.installonlypkgs
         if 'gpg-pubkey' not in self.installonlypkgs:
             self.installonlypkgs.append('gpg-pubkey')
 
-        self.logger.debug("Yum: Install missing: %s" % self.do_install)
-        self.logger.debug("Yum: pkg_checks: %s" % self.pkg_checks)
-        self.logger.debug("Yum: pkg_verify: %s" % self.pkg_verify)
-        self.logger.debug("Yum: Upgrade on version fail: %s" % self.do_upgrade)
-        self.logger.debug("Yum: Reinstall on verify fail: %s" % self.do_reinst)
+        self.logger.debug("Yum: Install missing: %s" %
+                          Bcfg2.Options.setup.yum_install_missing)
+        self.logger.debug("Yum: pkg_checks: %s" %
+                          Bcfg2.Options.setup.yum_pkg_checks)
+        self.logger.debug("Yum: pkg_verify: %s" %
+                          Bcfg2.Options.setup.yum_pkg_verify)
+        self.logger.debug("Yum: Upgrade on version fail: %s" %
+                          Bcfg2.Options.setup.yum_fix_version)
+        self.logger.debug("Yum: Reinstall on verify fail: %s" %
+                          Bcfg2.Options.setup.yum_reinstall_broken)
         self.logger.debug("Yum: installonlypkgs: %s" % self.installonlypkgs)
-        self.logger.debug("Yum: verify_flags: %s" % self.verify_flags)
+        self.logger.debug("Yum: verify_flags: %s" %
+                          Bcfg2.Options.setup.yum_verify_flags)
 
     def _loadYumBase(self):
         ''' this may be called before PkgTool.__init__() is called on
@@ -203,18 +228,14 @@ class YUM(Bcfg2.Client.Tools.PkgTool):
         packages. '''
         rv = yum.YumBase()  # pylint: disable=C0103
 
-        if hasattr(self, "setup"):
-            setup = self.setup
-        else:
-            setup = Bcfg2.Options.get_option_parser()
         if hasattr(self, "logger"):
             logger = self.logger
         else:
             logger = logging.getLogger(self.name)
 
-        if setup['debug']:
+        if Bcfg2.Options.setup.debug:
             debuglevel = 3
-        elif setup['verbose']:
+        elif Bcfg2.Options.setup.verbose:
             debuglevel = 2
         else:
             debuglevel = 0
@@ -314,7 +335,7 @@ class YUM(Bcfg2.Client.Tools.PkgTool):
             using. Disabling file checksums is a new feature yum
             3.2.17-ish """
             try:
-                return pkg.verify(fast=self.setup.get('quick', False))
+                return pkg.verify(fast=Bcfg2.Options.setup.quick)
             except TypeError:
                 # Older Yum API
                 return pkg.verify()
@@ -439,9 +460,9 @@ class YUM(Bcfg2.Client.Tools.PkgTool):
         package_fail = False
         qtext_versions = []
         virt_pkg = False
-        pkg_checks = (self.pkg_checks and
+        pkg_checks = (Bcfg2.Options.setup.yum_pkg_checks and
                       entry.get('pkg_checks', 'true').lower() == 'true')
-        pkg_verify = (self.pkg_verify and
+        pkg_verify = (Bcfg2.Options.setup.yum_pkg_verify and
                       entry.get('pkg_verify', 'true').lower() == 'true')
         yum_group = False
 
@@ -534,7 +555,7 @@ class YUM(Bcfg2.Client.Tools.PkgTool):
                     inst.get('verify_flags').lower().replace(' ',
                                                              ',').split(',')
             else:
-                verify_flags = self.verify_flags
+                verify_flags = Bcfg2.Options.setup.yum_verify_flags
 
             if 'arch' in nevra:
                 # If arch is specified use it to select the package
@@ -622,7 +643,7 @@ class YUM(Bcfg2.Client.Tools.PkgTool):
                 qtext_versions.append("U(%s)" % str(all_pkg_objs[0]))
                 continue
 
-            if self.setup.get('quick', False):
+            if Bcfg2.Options.setup.quick:
                 # Passed -q on the command line
                 continue
             if not (pkg_verify and
@@ -696,7 +717,7 @@ class YUM(Bcfg2.Client.Tools.PkgTool):
             install_only = False
 
         if virt_pkg or \
-           (install_only and not self.setup['kevlar']) or \
+           (install_only and not Bcfg2.Options.setup.kevlar) or \
            yum_group:
             # virtual capability supplied, we are probably dealing
             # with multiple packages of different names.  This check
@@ -904,8 +925,7 @@ class YUM(Bcfg2.Client.Tools.PkgTool):
         # Remove extra instances.
         # Can not reverify because we don't have a package entry.
         if self.extra_instances is not None and len(self.extra_instances) > 0:
-            if (self.setup.get('remove') == 'all' or
-                self.setup.get('remove') == 'packages'):
+            if Bcfg2.Options.setup.remove in ['all', 'packages']:
                 self.Remove(self.extra_instances)
             else:
                 self.logger.info("The following extra package instances will "
@@ -930,11 +950,14 @@ class YUM(Bcfg2.Client.Tools.PkgTool):
                             nevra2string(build_yname(pkg.get('name'), inst)))
                         continue
                     status = self.instance_status[inst]
-                    if not status.get('installed', False) and self.do_install:
+                    if (not status.get('installed', False) and
+                        Bcfg2.Options.setup.yum_install_missing):
                         queue_pkg(pkg, inst, install_pkgs)
-                    elif status.get('version_fail', False) and self.do_upgrade:
+                    elif (status.get('version_fail', False) and
+                          Bcfg2.Options.yum_fix_version):
                         queue_pkg(pkg, inst, upgrade_pkgs)
-                    elif status.get('verify_fail', False) and self.do_reinst:
+                    elif (status.get('verify_fail', False) and
+                          Bcfg2.Options.yum_reinstall_broken):
                         queue_pkg(pkg, inst, reinstall_pkgs)
                     else:
                         # Either there was no Install/Version/Verify
@@ -1010,7 +1033,7 @@ class YUM(Bcfg2.Client.Tools.PkgTool):
 
         self._runYumTransaction()
 
-        if not self.setup['kevlar']:
+        if not Bcfg2.Options.setup.kevlar:
             for pkg_entry in [p for p in packages if self.canVerify(p)]:
                 self.logger.debug("Reverifying Failed Package %s" %
                                   pkg_entry.get('name'))
diff --git a/src/lib/Bcfg2/Client/Tools/__init__.py b/src/lib/Bcfg2/Client/Tools/__init__.py
index 885e22761..5f59e8160 100644
--- a/src/lib/Bcfg2/Client/Tools/__init__.py
+++ b/src/lib/Bcfg2/Client/Tools/__init__.py
@@ -4,11 +4,11 @@ import os
 import sys
 import stat
 import logging
+import Bcfg2.Options
 import Bcfg2.Client
 import Bcfg2.Client.XML
 from Bcfg2.Utils import Executor, ClassName
 from Bcfg2.Compat import walk_packages  # pylint: disable=W0622
-import Bcfg2.Options
 
 __all__ = [m[1] for m in walk_packages(path=__path__)]
 
@@ -28,6 +28,12 @@ class Tool(object):
     .. autoattribute:: Bcfg2.Client.Tools.Tool.__important__
     """
 
+    options = [
+        Bcfg2.Options.Option(
+            cf=('client', 'command_timeout'),
+            help="Timeout when running external commands other than probes",
+            type=Bcfg2.Options.Types.timeout)]
+
     #: The name of the tool.  By default this uses
     #: :class:`Bcfg2.Client.Tools.ClassName` to ensure that it is the
     #: same as the name of the class.
@@ -77,10 +83,6 @@ class Tool(object):
         :type config: lxml.etree._Element
         :raises: :exc:`Bcfg2.Client.Tools.ToolInstantiationError`
         """
-        #: A :class:`Bcfg2.Options.OptionParser` object describing the
-        #: option set Bcfg2 was invoked with
-        self.setup = Bcfg2.Options.get_option_parser()
-
         #: A :class:`logging.Logger` object that will be used by this
         #: tool for logging
         self.logger = logging.getLogger(self.name)
@@ -90,7 +92,7 @@ class Tool(object):
 
         #: An :class:`Bcfg2.Utils.Executor` object for
         #: running external commands.
-        self.cmd = Executor(timeout=self.setup['command_timeout'])
+        self.cmd = Executor(timeout=Bcfg2.Options.setup.command_timeout)
 
         #: A list of entries that have been modified by this tool
         self.modified = []
@@ -136,7 +138,7 @@ class Tool(object):
         :param bundle: The bundle that has been updated
         :type bundle: lxml.etree._Element
         :returns: dict - A dict of the state of entries suitable for
-                  updating :attr:`Bcfg2.Client.Frame.Frame.states`
+                  updating :attr:`Bcfg2.Client.Client.states`
         """
         return dict()
 
@@ -146,7 +148,7 @@ class Tool(object):
         :param bundle: The bundle that has been updated
         :type bundle: lxml.etree._Element
         :returns: dict - A dict of the state of entries suitable for
-                  updating :attr:`Bcfg2.Client.Frame.Frame.states`
+                  updating :attr:`Bcfg2.Client.Client.states`
         """
         return dict()
 
@@ -172,7 +174,7 @@ class Tool(object):
                            be used.
         :type structures: list of lxml.etree._Element
         :returns: dict - A dict of the state of entries suitable for
-                  updating :attr:`Bcfg2.Client.Frame.Frame.states`
+                  updating :attr:`Bcfg2.Client.Client.states`
         """
         if not structures:
             structures = self.config.getchildren()
@@ -210,7 +212,7 @@ class Tool(object):
         :param entries: The entries to install
         :type entries: list of lxml.etree._Element
         :returns: dict - A dict of the state of entries suitable for
-                  updating :attr:`Bcfg2.Client.Frame.Frame.states`
+                  updating :attr:`Bcfg2.Client.Client.states`
         """
         states = dict()
         for entry in entries:
@@ -435,7 +437,7 @@ class PkgTool(Tool):
         :param entries: The entries to install
         :type entries: list of lxml.etree._Element
         :returns: dict - A dict of the state of entries suitable for
-                  updating :attr:`Bcfg2.Client.Frame.Frame.states`
+                  updating :attr:`Bcfg2.Client.Client.states`
         """
         self.logger.info("Trying single pass package install for pkgtype %s" %
                          self.pkgtype)
@@ -493,6 +495,12 @@ class PkgTool(Tool):
 class SvcTool(Tool):
     """ Base class for tools that handle Service entries """
 
+    options = Tool.options + [
+        Bcfg2.Options.Option(
+            '-s', '--service-mode', default='default',
+            choices = ['default', 'disabled', 'build'],
+            help='Set client service mode')]
+
     def __init__(self, config):
         Tool.__init__(self, config)
         #: List of services that have been restarted
@@ -571,14 +579,14 @@ class SvcTool(Tool):
         return bool(self.cmd.run(self.get_svc_command(service, 'status')))
 
     def Remove(self, services):
-        if self.setup['servicemode'] != 'disabled':
+        if Bcfg2.Options.setup.service_mode != 'disabled':
             for entry in services:
                 entry.set("status", "off")
                 self.InstallService(entry)
     Remove.__doc__ = Tool.Remove.__doc__
 
     def BundleUpdated(self, bundle):
-        if self.setup['servicemode'] == 'disabled':
+        if Bcfg2.Options.setup.service_mode == 'disabled':
             return
 
         for entry in bundle:
@@ -587,15 +595,16 @@ class SvcTool(Tool):
 
             restart = entry.get("restart", "true").lower()
             if (restart == "false" or
-                (restart == "interactive" and not self.setup['interactive'])):
+                (restart == "interactive" and
+                 not Bcfg2.Options.setup.interactive)):
                 continue
 
             success = False
             if entry.get('status') == 'on':
-                if self.setup['servicemode'] == 'build':
+                if Bcfg2.Options.setup.service_mode == 'build':
                     success = self.stop_service(entry)
                 elif entry.get('name') not in self.restarted:
-                    if self.setup['interactive']:
+                    if Bcfg2.Options.setup.interactive:
                         if not Bcfg2.Client.prompt('Restart service %s? (y/N) '
                                                    % entry.get('name')):
                             continue