Cleaned up pep8/pylint for bin/* files. I did not fix rsapi since this is already cleaned up in another branch.

bin/nova-api

@@ -29,8 +29,6 @@ from nova import flags
 from nova import rpc
 from nova import server
 from nova import utils
-from nova.auth import manager
-from nova.compute import model
 from nova.endpoint import admin
 from nova.endpoint import api
 from nova.endpoint import cloud
@@ -39,10 +37,10 @@ FLAGS = flags.FLAGS
 
 
 def main(_argv):
+    """Load the controllers and start the tornado I/O loop."""
     controllers = {
         'Cloud': cloud.CloudController(),
-        'Admin': admin.AdminController()
+        'Admin': admin.AdminController()}
-    }
     _app = api.APIServerApplication(controllers)
 
     conn = rpc.Connection.instance()

bin/nova-dhcpbridge

@@ -18,8 +18,6 @@
 #    under the License.
 
 """
-nova-dhcpbridge
-
 Handle lease database updates from DHCP servers.
 """
 
@@ -42,34 +40,43 @@ from nova.network import service
 FLAGS = flags.FLAGS
 
 
-def add_lease(mac, ip, hostname, interface):
+def add_lease(_mac, ip, _hostname, _interface):
+    """Set the IP that was assigned by the DHCP server."""
     if FLAGS.fake_rabbit:
         service.VlanNetworkService().lease_ip(ip)
     else:
-        rpc.cast("%s.%s" (FLAGS.network_topic, FLAGS.node_name),
+        rpc.cast("%s.%s" % (FLAGS.network_topic, FLAGS.node_name),
                  {"method": "lease_ip",
-                  "args" : {"fixed_ip": ip}})
+                  "args": {"fixed_ip": ip}})
 
-def old_lease(mac, ip, hostname, interface):
+
+def old_lease(_mac, _ip, _hostname, _interface):
+    """Do nothing, just an old lease update."""
     logging.debug("Adopted old lease or got a change of mac/hostname")
 
-def del_lease(mac, ip, hostname, interface):
+
+def del_lease(_mac, ip, _hostname, _interface):
+    """Remove the leased IP from the databases."""
     if FLAGS.fake_rabbit:
         service.VlanNetworkService().release_ip(ip)
     else:
-        rpc.cast("%s.%s" (FLAGS.network_topic, FLAGS.node_name),
+        rpc.cast("%s.%s" % (FLAGS.network_topic, FLAGS.node_name),
                  {"method": "release_ip",
-                  "args" : {"fixed_ip": ip}})
+                  "args": {"fixed_ip": ip}})
+
 
 def init_leases(interface):
+    """Get the list of hosts for an interface."""
     net = model.get_network_by_interface(interface)
     res = ""
     for host_name in net.hosts:
-        res += "%s\n" % linux_net.hostDHCP(net, host_name, net.hosts[host_name])
+        res += "%s\n" % linux_net.hostDHCP(net, host_name,
+                                           net.hosts[host_name])
     return res
 
 
 def main():
+    """Parse environment and arguments and call the approproate action."""
     flagfile = os.environ.get('FLAGFILE', FLAGS.dhcpbridge_flagfile)
     utils.default_flagfile(flagfile)
     argv = FLAGS(sys.argv)
@@ -79,18 +86,19 @@ def main():
         FLAGS.redis_db = 8
         FLAGS.network_size = 32
         FLAGS.connection_type = 'fake'
-        FLAGS.fake_network=True
+        FLAGS.fake_network = True
-        FLAGS.auth_driver='nova.auth.ldapdriver.FakeLdapDriver'
+        FLAGS.auth_driver = 'nova.auth.ldapdriver.FakeLdapDriver'
     action = argv[1]
-    if action in ['add','del','old']:
+    if action in ['add', 'del', 'old']:
         mac = argv[2]
         ip = argv[3]
         hostname = argv[4]
-        logging.debug("Called %s for mac %s with ip %s and hostname %s on interface %s" % (action, mac, ip, hostname, interface))
+        logging.debug("Called %s for mac %s with ip %s and "
-        globals()[action+'_lease'](mac, ip, hostname, interface)
+                      "hostname %s on interface %s",
+                      action, mac, ip, hostname, interface)
+        globals()[action + '_lease'](mac, ip, hostname, interface)
     else:
         print init_leases(interface)
-    exit(0)
 
 if __name__ == "__main__":
-    sys.exit(main())
+    main()

bin/nova-import-canonical-imagestore

@@ -37,20 +37,17 @@ FLAGS = flags.FLAGS
 
 api_url = 'https://imagestore.canonical.com/api/dashboard'
 
-image_cache = None
-def images():
-    global image_cache
-    if not image_cache:
-        try:
-            images = json.load(urllib2.urlopen(api_url))['images']
-            image_cache = [i for i in images if i['title'].find('amd64') > -1]
-        except Exception:
-            print 'unable to download canonical image list'
-            sys.exit(1)
-    return image_cache
 
-# FIXME(ja): add checksum/signature checks
+def get_images():
+    """Get a list of the images from the imagestore URL."""
+    images = json.load(urllib2.urlopen(api_url))['images']
+    images = [img for img in images if img['title'].find('amd64') > -1]
+    return images
+
+
 def download(img):
+    """Download an image to the local filesystem."""
+    # FIXME(ja): add checksum/signature checks
     tempdir = tempfile.mkdtemp(prefix='cis-')
 
     kernel_id = None
@@ -79,20 +76,22 @@ def download(img):
 
     shutil.rmtree(tempdir)
 
+
 def main():
+    """Main entry point."""
     utils.default_flagfile()
     argv = FLAGS(sys.argv)
+    images = get_images()
 
     if len(argv) == 2:
-        for img in images():
+        for img in images:
             if argv[1] == 'all' or argv[1] == img['title']:
                 download(img)
     else:
         print 'usage: %s (title|all)'
         print 'available images:'
-        for image in images():
+        for img in images:
-            print image['title']
+            print img['title']
 
 if __name__ == '__main__':
     main()
-

bin/nova-instancemonitor

@@ -22,7 +22,6 @@
 """
 
 import logging
-from twisted.internet import task
 from twisted.application import service
 
 from nova import twistd
@@ -30,7 +29,11 @@ from nova.compute import monitor
 
 logging.getLogger('boto').setLevel(logging.WARN)
 
-def main():
+
+if __name__ == '__main__':
+    twistd.serve(__file__)
+
+if __name__ == '__builtin__':
     logging.warn('Starting instance monitor')
     m = monitor.InstanceMonitor()
 
@@ -38,14 +41,3 @@ def main():
     # parses this file, return it so that we can get it into globals below
     application = service.Application('nova-instancemonitor')
     m.setServiceParent(application)
-    return application
-
-if __name__ == '__main__':
-    twistd.serve(__file__)
-
-if __name__ == '__builtin__':
-    application = main()
-
-
-
-

bin/nova-manage

@@ -37,12 +37,15 @@ FLAGS = flags.FLAGS
 
 
 class VpnCommands(object):
+    """Class for managing VPNs."""
+
     def __init__(self):
         self.manager = manager.AuthManager()
         self.instdir = model.InstanceDirectory()
         self.pipe = pipelib.CloudPipe(cloud.CloudController())
 
     def list(self):
+        """Print a listing of the VPNs for all projects."""
         print "%-12s\t" % 'project',
         print "%-12s\t" % 'ip:port',
         print "%s" % 'state'
@@ -50,9 +53,10 @@ class VpnCommands(object):
             print "%-12s\t" % project.name,
             print "%s:%s\t" % (project.vpn_ip, project.vpn_port),
 
-            vpn = self.__vpn_for(project.id)
+            vpn = self._vpn_for(project.id)
             if vpn:
-                out, err = utils.execute("ping -c1 -w1 %s > /dev/null; echo $?" % vpn['private_dns_name'])
+                command = "ping -c1 -w1 %s > /dev/null; echo $?"
+                out, _err = utils.execute(command % vpn['private_dns_name'])
                 if out.strip() == '0':
                     net = 'up'
                 else:
@@ -66,25 +70,32 @@ class VpnCommands(object):
             else:
                 print None
 
-    def __vpn_for(self, project_id):
+    def _vpn_for(self, project_id):
+        """Get the VPN instance for a project ID."""
         for instance in self.instdir.all:
-            if (instance.state.has_key('image_id')
+            if ('image_id' in instance.state
                 and instance['image_id'] == FLAGS.vpn_image_id
-                and not instance['state_description'] in ['shutting_down', 'shutdown']
+                and not instance['state_description'] in
+                    ['shutting_down', 'shutdown']
                 and instance['project_id'] == project_id):
                 return instance
 
     def spawn(self):
+        """Run all VPNs."""
         for p in reversed(self.manager.get_projects()):
-             if not self.__vpn_for(p.id):
+            if not self._vpn_for(p.id):
-                 print 'spawning %s' % p.id
+                print 'spawning %s' % p.id
-                 self.pipe.launch_vpn_instance(p.id)
+                self.pipe.launch_vpn_instance(p.id)
-                 time.sleep(10)
+                time.sleep(10)
 
     def run(self, project_id):
+        """Start the VPN for a given project."""
         self.pipe.launch_vpn_instance(project_id)
 
+
 class RoleCommands(object):
+    """Class for managing roles."""
+
     def __init__(self):
         self.manager = manager.AuthManager()
 
@@ -107,25 +118,24 @@ class RoleCommands(object):
         arguments: user, role [project]"""
         self.manager.remove_role(user, role, project)
 
+
 class UserCommands(object):
+    """Class for managing users."""
+
     def __init__(self):
         self.manager = manager.AuthManager()
 
-    def __print_export(self, user):
-        print 'export EC2_ACCESS_KEY=%s' % user.access
-        print 'export EC2_SECRET_KEY=%s' % user.secret
-
     def admin(self, name, access=None, secret=None):
         """creates a new admin and prints exports
         arguments: name [access] [secret]"""
         user = self.manager.create_user(name, access, secret, True)
-        self.__print_export(user)
+        print_export(user)
 
     def create(self, name, access=None, secret=None):
         """creates a new user and prints exports
         arguments: name [access] [secret]"""
         user = self.manager.create_user(name, access, secret, False)
-        self.__print_export(user)
+        print_export(user)
 
     def delete(self, name):
         """deletes an existing user
@@ -137,7 +147,7 @@ class UserCommands(object):
         arguments: name"""
         user = self.manager.get_user(name)
         if user:
-            self.__print_export(user)
+            print_export(user)
         else:
             print "User %s doesn't exist" % name
 
@@ -147,53 +157,58 @@ class UserCommands(object):
         for user in self.manager.get_users():
             print user.name
 
+
+def print_export(user):
+    """Print export variables to use with API."""
+    print 'export EC2_ACCESS_KEY=%s' % user.access
+    print 'export EC2_SECRET_KEY=%s' % user.secret
+
+
 class ProjectCommands(object):
+    """Class for managing projects."""
+
     def __init__(self):
         self.manager = manager.AuthManager()
 
     def add(self, project, user):
-        """adds user to project
+        """Adds user to project
         arguments: project user"""
         self.manager.add_to_project(user, project)
 
     def create(self, name, project_manager, description=None):
-        """creates a new project
+        """Creates a new project
         arguments: name project_manager [description]"""
-        user = self.manager.create_project(name, project_manager, description)
+        self.manager.create_project(name, project_manager, description)
 
     def delete(self, name):
-        """deletes an existing project
+        """Deletes an existing project
         arguments: name"""
         self.manager.delete_project(name)
 
     def environment(self, project_id, user_id, filename='novarc'):
-        """exports environment variables to an sourcable file
+        """Exports environment variables to an sourcable file
         arguments: project_id user_id [filename='novarc]"""
         rc = self.manager.get_environment_rc(project_id, user_id)
         with open(filename, 'w') as f:
             f.write(rc)
 
     def list(self):
-        """lists all projects
+        """Lists all projects
         arguments: <none>"""
         for project in self.manager.get_projects():
             print project.name
 
     def remove(self, project, user):
-        """removes user from project
+        """Removes user from project
         arguments: project user"""
         self.manager.remove_from_project(user, project)
 
-    def zip(self, project_id, user_id, filename='nova.zip'):
+    def create_zip(self, project_id, user_id, filename='nova.zip'):
-        """exports credentials for project to a zip file
+        """Exports credentials for project to a zip file
         arguments: project_id user_id [filename='nova.zip]"""
-        zip = self.manager.get_credentials(project_id, user_id)
+        zip_file = self.manager.get_credentials(project_id, user_id)
         with open(filename, 'w') as f:
-            f.write(zip)
+            f.write(zip_file)
-
-
-def usage(script_name):
-    print script_name + " category action [<args>]"
 
 
 categories = [
@@ -205,62 +220,61 @@ categories = [
 
 
 def lazy_match(name, key_value_tuples):
-    """finds all objects that have a key that case insensitively contains [name]
+    """Finds all objects that have a key that case insensitively contains
-    key_value_tuples is a list of tuples of the form (key, value)
+    [name] key_value_tuples is a list of tuples of the form (key, value)
     returns a list of tuples of the form (key, value)"""
-    return [(k, v) for (k, v) in key_value_tuples if k.lower().find(name.lower()) == 0]
+    result = []
+    for (k, v) in key_value_tuples:
+        if k.lower().find(name.lower()) == 0:
+            result.append((k, v))
+    if len(result) == 0:
+        print "%s does not match any options:" % name
+        for k, _v in key_value_tuples:
+            print "\t%s" % k
+        sys.exit(2)
+    if len(result) > 1:
+        print "%s matched multiple options:" % name
+        for k, _v in result:
+            print "\t%s" % k
+        sys.exit(2)
+    return result
 
 
 def methods_of(obj):
-    """get all callable methods of an object that don't start with underscore
+    """Get all callable methods of an object that don't start with underscore
     returns a list of tuples of the form (method_name, method)"""
-    return [(i, getattr(obj, i)) for i in dir(obj) if callable(getattr(obj, i)) and not i.startswith('_')]
+    result = []
+    for i in dir(obj):
+        if callable(getattr(obj, i)) and not i.startswith('_'):
+            result.append((i, getattr(obj, i)))
+    return result
 
 
-if __name__ == '__main__':
+def main():
+    """Parse options and call the appropriate class/method."""
     utils.default_flagfile('/etc/nova/nova-manage.conf')
     argv = FLAGS(sys.argv)
     script_name = argv.pop(0)
     if len(argv) < 1:
-        usage(script_name)
+        print script_name + " category action [<args>]"
         print "Available categories:"
-        for k, v in categories:
+        for k, _ in categories:
             print "\t%s" % k
         sys.exit(2)
     category = argv.pop(0)
     matches = lazy_match(category, categories)
-    if len(matches) == 0:
-        print "%s does not match any categories:" % category
-        for k, v in categories:
-            print "\t%s" % k
-        sys.exit(2)
-    if len(matches) > 1:
-        print "%s matched multiple categories:" % category
-        for k, v in matches:
-            print "\t%s" % k
-        sys.exit(2)
     # instantiate the command group object
     category, fn = matches[0]
     command_object = fn()
     actions = methods_of(command_object)
     if len(argv) < 1:
-        usage(script_name)
+        print script_name + " category action [<args>]"
         print "Available actions for %s category:" % category
-        for k, v in actions:
+        for k, _v in actions:
             print "\t%s" % k
         sys.exit(2)
     action = argv.pop(0)
     matches = lazy_match(action, actions)
-    if len(matches) == 0:
-        print "%s does not match any actions" % action
-        for k, v in actions:
-            print "\t%s" % k
-        sys.exit(2)
-    if len(matches) > 1:
-        print "%s matched multiple actions:" % action
-        for k, v in matches:
-            print "\t%s" % k
-        sys.exit(2)
     action, fn = matches[0]
     # call the action with the remaining arguments
     try:
@@ -271,3 +285,5 @@ if __name__ == '__main__':
         print "%s %s: %s" % (category, action, fn.__doc__)
         sys.exit(2)
 
+if __name__ == '__main__':
+    main()

bin/nova-objectstore

@@ -30,15 +30,9 @@ from nova.objectstore import handler
 FLAGS = flags.FLAGS
 
 
-def main():
-    app = handler.get_application()
-    print app
-    return app
-
-# NOTE(soren): Stolen from nova-compute
 if __name__ == '__main__':
     twistd.serve(__file__)
 
 if __name__ == '__builtin__':
     utils.default_flagfile()
-    application = main()
+    application = handler.get_application()

pylintrc

@@ -1,3 +1,6 @@
+[Messages Control]
+disable-msg=C0103
+
 [Basic]
 method-rgx=[a-z_][a-z0-9_]{2,50}$
 

run_tests.py

@@ -68,7 +68,8 @@ flags.DEFINE_bool('flush_db', True,
                   'Flush the database before running fake tests')
 
 flags.DEFINE_string('tests_stderr', 'run_tests.err.log',
-                    'Path to where to pipe STDERR during test runs. Default = "run_tests.err.log"')
+                    'Path to where to pipe STDERR during test runs. '
+                    'Default = "run_tests.err.log"')
 
 if __name__ == '__main__':
     OptionsClass = twistd.WrapTwistedOptions(trial_script.Options)