pylint fixups

(Logical change 1.118)


git-svn-id: https://svn.mcs.anl.gov/repos/bcfg/trunk/bcfg2@522 ce84e21b-d406-0410-9b95-82705330c041

2 files changed, 63 insertions, 42 deletions

diff --git a/src/lib/Client/Debian.py b/src/lib/Client/Debian.py
index 0c2d10faf..a85feb086 100644
--- a/src/lib/Client/Debian.py
+++ b/src/lib/Client/Debian.py
@@ -4,21 +4,16 @@ __revision__ = '$Revision$'
 
 from copy import deepcopy
 from glob import glob
-from os import environ, stat, system
+from os import environ, system
 from popen2 import Popen4
 
 import apt_pkg
 
 from Bcfg2.Client.Toolset import Toolset
 
-def Detect():
-    try:
-        stat('/etc/debian_version')
-        return True
-    except OSError:
-        return False
-
 class Debian(Toolset):
+    '''The Debian toolset implements package and service operations and inherits
+    the rest from Toolset.Toolset'''
     __important__ = ["/etc/apt/sources.list", "/var/cache/debconf/config.dat", \
                      "/var/cache/debconf/templates.dat", '/etc/passwd', '/etc/group']
 
@@ -30,19 +25,23 @@ class Debian(Toolset):
         if not self.setup['build']:
             system("dpkg-reconfigure -f noninteractive debconf < /dev/null")
         system("apt-get -q=2 -y update")
+        self.installed = {}
+        self.pkgwork = {'add':[], 'update':[], 'remove':[]}        
         self.Refresh()
 
     def Refresh(self):
+        '''Refresh memory hashes of packages'''
         apt_pkg.init()
-        self.cache = apt_pkg.GetCache()
+        cache = apt_pkg.GetCache()
         self.installed = {}
-        for pkg in self.cache.Packages:
+        for pkg in cache.Packages:
             if pkg.CurrentVer:
                 self.installed[pkg.Name] = pkg.CurrentVer.VerStr
 
     # implement entry (Verify|Install) ops
     
     def VerifyService(self, entry):
+        '''Verify Service status for entry'''
         files = glob("/etc/rc*.d/*%s" % (entry.get('name')))
         if entry.get('status') == 'off':
             if files:
@@ -56,6 +55,7 @@ class Debian(Toolset):
                 return False
 
     def InstallService(self, entry):
+        '''Install Service for entry'''
         if self.setup['verbose']:
             print "Installing Service %s" % (entry.get('name'))
         if entry.attrib['status'] == 'off':
@@ -63,18 +63,19 @@ class Debian(Toolset):
                 print "Disabling service %s" % (entry.get('name'))
                 return False
             else:
-                rc = system("update-rc.d -f %s remove" % entry.get('name'))
+                cmdrc = system("update-rc.d -f %s remove" % entry.get('name'))
         else:
             if self.setup['dryrun']:
                 print "Enabling service %s" % (entry.attrib['name'])
                 return False
             else:
-                rc = system("update-rc.d %s defaults" % (entry.attrib['name']))
-        if rc:
+                cmdrc = system("update-rc.d %s defaults" % (entry.attrib['name']))
+        if cmdrc:
             return False
         return True
 
     def VerifyPackage(self, entry, modlist=[]):
+        '''Verify Package for entry'''
         if self.installed.has_key(entry.attrib['name']):
             if self.installed[entry.attrib['name']] == entry.attrib['version']:
                 if not self.setup['quick']:
@@ -84,13 +85,14 @@ class Debian(Toolset):
                     while cstat == -1:
                         output += cmd.fromchild.read()
                         cstat = cmd.poll()
-                    output = [x for x in output.split('\n') if x]
-                    if [x for x in output if x not in modlist]:
+                    output = [line for line in output.split('\n') if line]
+                    if [filename for filename in output if filename not in modlist]:
                         return False
                 return True
         return False
 
     def InstallPackage(self, entry):
+        '''Install Package for entry - DEPRICATED'''
         if not entry.attrib.has_key('version'):
             print "Package entry for %s is malformed" % (entry.attrib['name'])
         if self.setup['dryrun'] or self.setup['verbose']:
@@ -98,6 +100,7 @@ class Debian(Toolset):
         return False
 
     def Inventory(self):
+        '''Inventory system status'''
         print "In Inventory::"
         Toolset.Inventory(self)
         self.pkgwork = {'add':[], 'update':[], 'remove':[]}
@@ -122,6 +125,7 @@ class Debian(Toolset):
         # all data remaining in all is extra packages
         
     def Install(self):
+        '''Correct detected misconfigurations'''
         print "Installing"
         cmd = "apt-get --reinstall -q=2 -y install %s"
         print "Need to remove:", self.pkgwork['remove']
@@ -130,7 +134,7 @@ class Debian(Toolset):
         # build up work queue
         work = self.pkgwork['add'] + self.pkgwork['update']
         # add non-package entries
-        work += [x for x in self.states if x.tag != 'Package' and not self.states[x]]
+        work += [ent for ent in self.states if ent.tag != 'Package' and not self.states[ent]]
 
         left = len(work)
         old = left + 1
@@ -143,17 +147,18 @@ class Debian(Toolset):
                                                         len(self.pkgwork['update']), len(self.pkgwork['remove']))
             count = count + 1
             old = left
-            packages = [x for x in work if x.tag == 'Package']
+            packages = [pkg for pkg in work if pkg.tag == 'Package']
 
-            for nonpkg in [x for x in work if x.tag != 'Package']:
+            for nonpkg in [ent for ent in work if ent.tag != 'Package']:
                 self.InstallEntry(nonpkg)
                 if self.states[nonpkg]:
                     work.remove(nonpkg)
             
             # try single large install
-            rc = system(cmd % " ".join(["%s=%s" % (x.get('name'), x.get('version', 'dummy')) for x in packages]))
+            cmdrc = system(cmd % " ".join(["%s=%s" % (pkg.get('name'), pkg.get('version', 'dummy'))
+                                           for pkg in packages]))
 
-            if rc == 0:
+            if cmdrc == 0:
                 # set all states to true and flush workqueues
                 for pkg in packages:
                     self.states[pkg] = True
@@ -169,8 +174,8 @@ class Debian(Toolset):
                         self.states[pkg] = True
                         work.remove(pkg)
                     else:
-                        rc = system(cmd % ("%s=%s" % (pkg.get('name'), pkg.get('version'))))
-                        if rc == 0:
+                        cmdrc = system(cmd % ("%s=%s" % (pkg.get('name'), pkg.get('version'))))
+                        if cmdrc == 0:
                             self.states[pkg] = True
                             work.remove(pkg)
                         else:
diff --git a/src/lib/Server/Core.py b/src/lib/Server/Core.py
index 9fb70994e..6ec285b77 100644
--- a/src/lib/Server/Core.py
+++ b/src/lib/Server/Core.py
@@ -12,23 +12,28 @@ from time import time
 import _fam
 
 class GeneratorError(Exception):
+    '''This error is raised upon generator failures'''
     pass
 
 class PublishError(Exception):
+    '''This error is raised upon publication failures'''
     pass
 
 class fam(object):
     '''The fam object is a set of callbacks for file alteration events'''
     
     def __init__(self):
+        object.__init__(self)
         self.fm = _fam.open()
         self.users = {}
         self.handles = {}
 
     def fileno(self):
+        '''return fam file handle number'''
         return self.fm.fileno()
 
     def AddMonitor(self, path, obj=None):
+        '''add a monitor to path, installing a callback to obj.HandleEvent'''
         mode = stat(path)[ST_MODE]
         if S_ISDIR(mode):
             handle = self.fm.monitorDirectory(path, None)
@@ -40,23 +45,28 @@ class fam(object):
         return handle.requestID()
 
     def HandleEvent(self):
+        '''Route a fam event to the proper callback'''
         event = self.fm.nextEvent()
         reqid = event.requestID
         if self.users.has_key(reqid):
             self.users[reqid].HandleEvent(event)
 
 class PublishedValue(object):
+    '''This is for data shared between generators'''
     def __init__(self, owner, key, value):
+        object.__init__(self)
         self.owner = owner
         self.key = key
         self.value = value
 
     def Update(self, owner, value):
+        '''Update the value after an ownership check succeeds'''
         if owner != self.owner:
             raise PublishError, (self.key, owner)
         self.value = value
 
 class Core(object):
+    '''The Core object is the container for all Bcfg2 Server logic, and modules'''
     def __init__(self, repository, structures, generators):
         object.__init__(self)
         self.datastore = repository
@@ -92,6 +102,7 @@ class Core(object):
             gen.CompleteSetup()
 
     def PublishValue(self, owner, key, value):
+        '''Publish a shared generator value'''
         if not self.pubspace.has_key(key):
             # This is a new entry
             self.pubspace[key] = PublishedValue(owner, key, value)
@@ -104,42 +115,47 @@ class Core(object):
                        (key, self.pubspace[key].owner, owner))
 
     def ReadValue(self, key):
+        '''Read a value published by another generator'''
         if self.pubspace.has_key(key):
             return self.pubspace[key].value
         raise KeyError, key
 
     def GetStructures(self, metadata):
+        '''Get all structures for client specified by metadata'''
         return reduce(lambda x, y:x+y,
-                      [z.Construct(metadata) for z in self.structures])
+                      [struct.Construct(metadata) for struct in self.structures])
 
     def BindStructure(self, structure, metadata):
-        for entry in [x for x in structure.getchildren() if x.tag not in ['SymLink', 'Directory']]:
+        '''Bind a complete structure'''
+        for entry in [child for child in structure.getchildren() if child.tag not in ['SymLink', 'Directory']]:
             try:
                 self.Bind(entry, metadata)
-            except KeyError, k:
-                syslog(LOG_ERR, "Unable to locate %s"%k)
+            except KeyError, key:
+                syslog(LOG_ERR, "Unable to locate %s" % key)
 
     def Bind(self, entry, metadata):
-        g = [x for x in self.generators if
-             x.__provides__.get(entry.tag, {}).has_key(entry.attrib['name'])]
-        if len(g) == 1:
-            return g[0].__provides__[entry.tag][entry.attrib['name']](entry, metadata)
-        elif len(g) > 1:
-            print "Data Integrity error for %s %s" % (entry.tag, entry.attrib['name'])
+        '''Bind an entry using the appropriate generator'''
+        glist = [gen for gen in self.generators if
+                 gen.__provides__.get(entry.tag, {}).has_key(entry.get('name'))]
+        if len(glist) == 1:
+            return glist[0].__provides__[entry.tag][entry.get('name')](entry, metadata)
+        elif len(glist) > 1:
+            print "Data Integrity error for %s %s" % (entry.tag, entry.get('name'))
         else:
-            for g in self.generators:
-                if hasattr(g, "FindHandler"):
+            for gen in self.generators:
+                if hasattr(gen, "FindHandler"):
                     try:
-                        return g.FindHandler(entry)(entry, metadata)
+                        return gen.FindHandler(entry)(entry, metadata)
                     except:
-                        print g, "failed"
-            raise KeyError, (entry.tag, entry.attrib['name'])
+                        print gen, "failed"
+            raise KeyError, (entry.tag, entry.get('name'))
                 
     def RunCronTasks(self):
-        g = [x for x in self.generators if x.__croninterval__]
-        for generator in g:
-            t = time()
-            if ((t - self.cron.get(generator, 0)) > generator.__croninterval__):
+        '''Run periodic tasks for generators'''
+        generators = [gen for gen in self.generators if gen.__croninterval__]
+        for generator in generators:
+            current = time()
+            if ((current - self.cron.get(generator, 0)) > generator.__croninterval__):
                 generator.Cron()
-                self.cron[generator] = t
+                self.cron[generator] = current