more pylint checks

3 files changed, 90 insertions, 75 deletions

diff --git a/src/lib/Bcfg2/Server/Plugins/Bundler.py b/src/lib/Bcfg2/Server/Plugins/Bundler.py
index 65914c371..15f8031ca 100644
--- a/src/lib/Bcfg2/Server/Plugins/Bundler.py
+++ b/src/lib/Bcfg2/Server/Plugins/Bundler.py
@@ -14,22 +14,27 @@ import Bcfg2.Server.Lint
 try:
     import genshi.template.base
     import Bcfg2.Server.Plugins.TGenshi
-    have_genshi = True
-except:
-    have_genshi = False
+    HAS_GENSHI = True
+except ImportError:
+    HAS_GENSHI = False
 
 
 class BundleFile(Bcfg2.Server.Plugin.StructFile):
+    """ Representation of a bundle XML file """
     def get_xml_value(self, metadata):
+        """ get the XML data that applies to the given client """
         bundlename = os.path.splitext(os.path.basename(self.name))[0]
         bundle = lxml.etree.Element('Bundle', name=bundlename)
-        [bundle.append(copy.copy(item)) for item in self.Match(metadata)]
+        for item in self.Match(metadata):
+            bundle.append(copy.copy(item))
         return bundle
 
 
-if have_genshi:
+if HAS_GENSHI:
     class BundleTemplateFile(Bcfg2.Server.Plugins.TGenshi.TemplateFile,
                              Bcfg2.Server.Plugin.StructFile):
+        """ Representation of a Genshi-templated bundle XML file """
+
         def __init__(self, name, specific, encoding):
             Bcfg2.Server.Plugins.TGenshi.TemplateFile.__init__(self, name,
                                                                specific,
@@ -38,54 +43,43 @@ if have_genshi:
             self.logger = logging.getLogger(name)
 
         def get_xml_value(self, metadata):
+            """ get the rendered XML data that applies to the given
+            client """
             if not hasattr(self, 'template'):
                 self.logger.error("No parsed template information for %s" %
                              self.name)
                 raise Bcfg2.Server.Plugin.PluginExecutionError
-            try:
-                stream = self.template.generate(metadata=metadata).filter(
-                    Bcfg2.Server.Plugins.TGenshi.removecomment)
-                data = lxml.etree.XML(stream.render('xml',
-                                                    strip_whitespace=False),
-                                      parser=Bcfg2.Server.XMLParser)
-                bundlename = os.path.splitext(os.path.basename(self.name))[0]
-                bundle = lxml.etree.Element('Bundle', name=bundlename)
-                for item in self.Match(metadata, data):
-                    bundle.append(copy.deepcopy(item))
-                return bundle
-            except LookupError:
-                lerror = sys.exc_info()[1]
-                self.logger.error('Genshi lookup error: %s' % lerror)
-            except genshi.template.TemplateError:
-                terror = sys.exc_info()[1]
-                self.logger.error('Genshi template error: %s' % terror)
-                raise
-            except genshi.input.ParseError:
-                perror = sys.exc_info()[1]
-                self.logger.error('Genshi parse error: %s' % perror)
-            raise
-
-        def Match(self, metadata, xdata):
+            stream = self.template.generate(metadata=metadata).filter(
+                Bcfg2.Server.Plugins.TGenshi.removecomment)
+            data = lxml.etree.XML(stream.render('xml',
+                                                strip_whitespace=False),
+                                  parser=Bcfg2.Server.XMLParser)
+            bundlename = os.path.splitext(os.path.basename(self.name))[0]
+            bundle = lxml.etree.Element('Bundle', name=bundlename)
+            for item in self.Match(metadata, data):
+                bundle.append(copy.deepcopy(item))
+            return bundle
+
+        def Match(self, metadata, xdata):  # pylint: disable=W0221
             """Return matching fragments of parsed template."""
             rv = []
             for child in xdata.getchildren():
                 rv.extend(self._match(child, metadata))
-            self.logger.debug("File %s got %d match(es)" % (self.name, len(rv)))
+            self.logger.debug("File %s got %d match(es)" % (self.name,
+                                                            len(rv)))
             return rv
 
-
     class SGenshiTemplateFile(BundleTemplateFile):
-        # provided for backwards compat
+        """ provided for backwards compat with the deprecated SGenshi
+        plugin """
         pass
 
 
 class Bundler(Bcfg2.Server.Plugin.Plugin,
               Bcfg2.Server.Plugin.Structure,
               Bcfg2.Server.Plugin.XMLDirectoryBacked):
-    """The bundler creates dependent clauses based on the
-       bundle/translation scheme from Bcfg1.
-    """
-    name = 'Bundler'
+    """ The bundler creates dependent clauses based on the
+    bundle/translation scheme from Bcfg1. """
     __author__ = 'bcfg-dev@mcs.anl.gov'
     patterns = re.compile('^(?P<name>.*)\.(xml|genshi)$')
 
@@ -103,17 +97,22 @@ class Bundler(Bcfg2.Server.Plugin.Plugin,
             raise Bcfg2.Server.Plugin.PluginInitError
 
     def template_dispatch(self, name, _):
+        """ Add the correct child entry type to Bundler depending on
+        whether the XML file in question is a plain XML file or a
+        templated bundle """
         bundle = lxml.etree.parse(name,
                                   parser=Bcfg2.Server.XMLParser)
         nsmap = bundle.getroot().nsmap
         if (name.endswith('.genshi') or
             ('py' in nsmap and
              nsmap['py'] == 'http://genshi.edgewall.org/')):
-            if have_genshi:
+            if HAS_GENSHI:
                 spec = Bcfg2.Server.Plugin.Specificity()
                 return BundleTemplateFile(name, spec, self.encoding)
             else:
-                raise Bcfg2.Server.Plugin.PluginExecutionError("Genshi not available: %s" % name)
+                raise Bcfg2.Server.Plugin.PluginExecutionError("Genshi not "
+                                                               "available: %s"
+                                                               % name)
         else:
             return BundleFile(name, self.fam)
 
@@ -123,8 +122,9 @@ class Bundler(Bcfg2.Server.Plugin.Plugin,
 
         bundle_entries = {}
         for key, item in self.entries.items():
-            bundle_entries.setdefault(self.patterns.match(os.path.basename(key)).group('name'),
-                                      []).append(item)
+            bundle_entries.setdefault(
+                self.patterns.match(os.path.basename(key)).group('name'),
+                []).append(item)
 
         for bundlename in metadata.bundles:
             try:
@@ -136,10 +136,9 @@ class Bundler(Bcfg2.Server.Plugin.Plugin,
             try:
                 bundleset.append(entries[0].get_xml_value(metadata))
             except genshi.template.base.TemplateError:
-                t = sys.exc_info()[1]
-                self.logger.error("Bundler: Failed to template genshi bundle %s"
-                                  % bundlename)
-                self.logger.error(t)
+                err = sys.exc_info()[1]
+                self.logger.error("Bundler: Failed to render templated bundle "
+                                  "%s: %s" % (bundlename, err))
             except:
                 self.logger.error("Bundler: Unexpected bundler error for %s" %
                                   bundlename, exc_info=1)
@@ -148,19 +147,20 @@ class Bundler(Bcfg2.Server.Plugin.Plugin,
 
 class BundlerLint(Bcfg2.Server.Lint.ServerPlugin):
     """ Perform various bundle checks """
+
     def Run(self):
         """ run plugin """
         self.missing_bundles()
         for bundle in self.core.plugins['Bundler'].entries.values():
             if (self.HandlesFile(bundle.name) and
-                (not have_genshi or
+                (not HAS_GENSHI or
                  not isinstance(bundle, BundleTemplateFile))):
-                    self.bundle_names(bundle)
+                self.bundle_names(bundle)
 
     @classmethod
     def Errors(cls):
-        return {"bundle-not-found":"error",
-                "inconsistent-bundle-name":"warning"}
+        return {"bundle-not-found": "error",
+                "inconsistent-bundle-name": "warning"}
 
     def missing_bundles(self):
         """ find bundles listed in Metadata but not implemented in Bundler """
diff --git a/src/lib/Bcfg2/Server/Plugins/GroupPatterns.py b/src/lib/Bcfg2/Server/Plugins/GroupPatterns.py
index 955a46c6c..6f0695bc3 100644
--- a/src/lib/Bcfg2/Server/Plugins/GroupPatterns.py
+++ b/src/lib/Bcfg2/Server/Plugins/GroupPatterns.py
@@ -1,12 +1,16 @@
+""" set group membership based on client hostnames """
+
 import os
 import re
 import sys
 import logging
-import lxml.etree
 import Bcfg2.Server.Lint
 import Bcfg2.Server.Plugin
 
+
 class PackedDigitRange(object):
+    """ Helper object for NameRange entries """
+
     def __init__(self, digit_range):
         self.sparse = list()
         self.ranges = list()
@@ -17,6 +21,7 @@ class PackedDigitRange(object):
                 self.sparse.append(int(item))
 
     def includes(self, other):
+        """ return True if other is included in this range """
         iother = int(other)
         if iother in self.sparse:
             return True
@@ -27,7 +32,7 @@ class PackedDigitRange(object):
 
 
 class PatternMap(object):
-    range_finder = r'\[\[[\d\-,]+\]\]'
+    """ Handler for a single pattern or range """
 
     def __init__(self, pattern, rangestr, groups):
         self.pattern = pattern
@@ -39,10 +44,11 @@ class PatternMap(object):
         elif rangestr != None:
             if '\\' in rangestr:
                 raise Exception("Backslashes are not allowed in NameRanges")
+            range_finder = r'\[\[[\d\-,]+\]\]'
             self.process = self.process_range
-            self.re = re.compile('^' + re.sub(self.range_finder, '(\d+)',
+            self.re = re.compile('^' + re.sub(range_finder, '(\d+)',
                                               rangestr))
-            dmatcher = re.compile(re.sub(self.range_finder,
+            dmatcher = re.compile(re.sub(range_finder,
                                          r'\[\[([\d\-,]+)\]\]',
                                          rangestr))
             self.dranges = [PackedDigitRange(x)
@@ -51,16 +57,18 @@ class PatternMap(object):
             raise Exception("No pattern or range given")
 
     def process_range(self, name):
+        """ match the given hostname against a range-based NameRange """
         match = self.re.match(name)
         if not match:
             return None
         digits = match.groups()
-        for i in range(len(digits)):
-            if not self.dranges[i].includes(digits[i]):
+        for grp in range(len(digits)):
+            if not self.dranges[grp].includes(digits[grp]):
                 return None
         return self.groups
 
     def process_re(self, name):
+        """ match the given hostname against a regex-based NamePattern """
         match = self.re.search(name)
         if not match:
             return None
@@ -79,6 +87,7 @@ class PatternMap(object):
 
 
 class PatternFile(Bcfg2.Server.Plugin.XMLFileBacked):
+    """ representation of GroupPatterns config.xml """
     __identifier__ = None
 
     def __init__(self, filename, core=None):
@@ -107,27 +116,29 @@ class PatternFile(Bcfg2.Server.Plugin.XMLFileBacked):
                 for range_ent in entry.findall('NameRange'):
                     rng = range_ent.text
                     self.patterns.append(PatternMap(None, rng, groups))
-            except:
-                self.logger.error("GroupPatterns: Failed to initialize pattern "
-                                  "%s" % entry.get('pattern'))
+            except:  # pylint: disable=W0702
+                self.logger.error("GroupPatterns: Failed to initialize "
+                                  "pattern %s" % entry.get('pattern'))
 
     def process_patterns(self, hostname):
+        """ return a list of groups that should be added to the given
+        client based on patterns that match the hostname """
         ret = []
         for pattern in self.patterns:
             try:
-                gn = pattern.process(hostname)
-                if gn is not None:
-                    ret.extend(gn)
-            except:
-                self.logger.error("GroupPatterns: Failed to process pattern %s "
-                                  "for %s" % (pattern.pattern, hostname),
+                grpname = pattern.process(hostname)
+                if grpname is not None:
+                    ret.extend(grpname)
+            except:  # pylint: disable=W0702
+                self.logger.error("GroupPatterns: Failed to process pattern "
+                                  "%s for %s" % (pattern.pattern, hostname),
                                   exc_info=1)
         return ret
 
 
 class GroupPatterns(Bcfg2.Server.Plugin.Plugin,
                     Bcfg2.Server.Plugin.Connector):
-    name = "GroupPatterns"
+    """ set group membership based on client hostnames """
 
     def __init__(self, core, datastore):
         Bcfg2.Server.Plugin.Plugin.__init__(self, core, datastore)
@@ -140,8 +151,9 @@ class GroupPatterns(Bcfg2.Server.Plugin.Plugin,
 
 
 class GroupPatternsLint(Bcfg2.Server.Lint.ServerPlugin):
+    """ bcfg2-lint plugin for GroupPatterns """
+
     def Run(self):
-        """ run plugin """
         cfg = self.core.plugins['GroupPatterns'].config
         for entry in cfg.xdata.xpath('//GroupPattern'):
             groups = [g.text for g in entry.findall('Group')]
@@ -150,9 +162,10 @@ class GroupPatternsLint(Bcfg2.Server.Lint.ServerPlugin):
 
     @classmethod
     def Errors(cls):
-        return {"pattern-fails-to-initialize":"error"}
+        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:
@@ -162,7 +175,7 @@ class GroupPatternsLint(Bcfg2.Server.Lint.ServerPlugin):
             pat = el.text
             try:
                 pmap(pat)
-            except:
+            except:  # pylint: disable=W0702
                 err = sys.exc_info()[1]
                 self.LintError("pattern-fails-to-initialize",
                                "Failed to initialize %s %s for %s: %s" %
diff --git a/src/lib/Bcfg2/Server/Plugins/Ohai.py b/src/lib/Bcfg2/Server/Plugins/Ohai.py
index 052597f84..fbb46f004 100644
--- a/src/lib/Bcfg2/Server/Plugins/Ohai.py
+++ b/src/lib/Bcfg2/Server/Plugins/Ohai.py
@@ -1,6 +1,9 @@
+"""The Ohai plugin is used to detect information about the client
+operating system using ohai
+(http://wiki.opscode.com/display/chef/Ohai) """
+
 import lxml.etree
 import os
-import logging
 import Bcfg2.Server.Plugin
 
 # pylint: disable=F0401
@@ -10,10 +13,7 @@ except ImportError:
     import simplejson as json
 # pylint: enable=F0401
 
-logger = logging.getLogger('Bcfg2.Plugins.Ohai')
-
-
-probecode = """#!/bin/sh
+PROBECODE = """#!/bin/sh
 
 export PATH=$PATH:/sbin:/usr/sbin
 
@@ -27,6 +27,8 @@ fi
 
 
 class OhaiCache(object):
+    """ Storage for Ohai output on the local filesystem so that the
+    output can be used by bcfg2-info, etc. """
     def __init__(self, dirname):
         self.dirname = dirname
         self.cache = dict()
@@ -68,14 +70,14 @@ class Ohai(Bcfg2.Server.Plugin.Plugin,
         Bcfg2.Server.Plugin.Connector.__init__(self)
         self.probe = lxml.etree.Element('probe', name='Ohai', source='Ohai',
                                         interpreter='/bin/sh')
-        self.probe.text = probecode
+        self.probe.text = PROBECODE
         try:
             os.stat(self.data)
-        except:
+        except OSError:
             os.makedirs(self.data)
         self.cache = OhaiCache(self.data)
 
-    def GetProbes(self, meta, force=False):
+    def GetProbes(self, _):
         return [self.probe]
 
     def ReceiveData(self, meta, datalist):