pep8 cleanup

6 files changed, 100 insertions, 55 deletions

diff --git a/nova/network/exception.py b/nova/network/exception.py
index 5722e9672..884ea54b4 100644
--- a/nova/network/exception.py
+++ b/nova/network/exception.py
@@ -26,15 +26,18 @@ from nova.exception import Error
 class NoMoreAddresses(Error):
     pass
 
+
 class AddressNotAllocated(Error):
     pass
 
+
 class AddressAlreadyAssociated(Error):
     pass
 
+
 class AddressNotAssociated(Error):
     pass
 
+
 class NotValidNetworkSize(Error):
     pass
-
diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 4a4b4c8a8..35bfded49 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -23,15 +23,16 @@ import subprocess
 
 # todo(ja): does the definition of network_path belong here?
 
+from nova import flags
 from nova import utils
 
-from nova import flags
-FLAGS=flags.FLAGS
+FLAGS = flags.FLAGS
 
 flags.DEFINE_string('dhcpbridge_flagfile',
                     '/etc/nova/nova-dhcpbridge.conf',
                     'location of flagfile for dhcpbridge')
 
+
 def execute(cmd, addl_env=None):
     if FLAGS.fake_network:
         logging.debug("FAKE NET: %s" % cmd)
@@ -39,11 +40,13 @@ def execute(cmd, addl_env=None):
     else:
         return utils.execute(cmd, addl_env=addl_env)
 
+
 def runthis(desc, cmd):
     if FLAGS.fake_network:
         return execute(cmd)
     else:
-        return utils.runthis(desc,cmd)
+        return utils.runthis(desc, cmd)
+
 
 def Popen(cmd):
     if FLAGS.fake_network:
@@ -56,18 +59,25 @@ def device_exists(device):
     (out, err) = execute("ifconfig %s" % device)
     return not err
 
+
 def confirm_rule(cmd):
     execute("sudo iptables --delete %s" % (cmd))
     execute("sudo iptables -I %s" % (cmd))
 
+
 def remove_rule(cmd):
     execute("sudo iptables --delete %s" % (cmd))
 
+
 def bind_public_ip(ip, interface):
-    runthis("Binding IP to interface: %s", "sudo ip addr add %s dev %s" % (ip, interface))
+    runthis("Binding IP to interface: %s",
+            "sudo ip addr add %s dev %s" % (ip, interface))
+
 
 def unbind_public_ip(ip, interface):
-    runthis("Binding IP to interface: %s", "sudo ip addr del %s dev %s" % (ip, interface))
+    runthis("Binding IP to interface: %s",
+            "sudo ip addr del %s dev %s" % (ip, interface))
+
 
 def vlan_create(net):
     """ create a vlan on on a bridge device unless vlan already exists """
@@ -77,6 +87,7 @@ def vlan_create(net):
         execute("sudo vconfig add %s %s" % (FLAGS.bridge_dev, net['vlan']))
         execute("sudo ifconfig vlan%s up" % (net['vlan']))
 
+
 def bridge_create(net):
     """ create a bridge on a vlan unless it already exists """
     if not device_exists(net['bridge_name']):
@@ -85,14 +96,17 @@ def bridge_create(net):
         execute("sudo brctl setfd %s 0" % (net.bridge_name))
         # execute("sudo brctl setageing %s 10" % (net.bridge_name))
         execute("sudo brctl stp %s off" % (net['bridge_name']))
-        execute("sudo brctl addif %s vlan%s" % (net['bridge_name'], net['vlan']))
+        execute("sudo brctl addif %s vlan%s" % (net['bridge_name'],
+                                                net['vlan']))
         if net.bridge_gets_ip:
             execute("sudo ifconfig %s %s broadcast %s netmask %s up" % \
                 (net['bridge_name'], net.gateway, net.broadcast, net.netmask))
-            confirm_rule("FORWARD --in-interface %s -j ACCEPT" % (net['bridge_name']))
+            confirm_rule("FORWARD --in-interface %s -j ACCEPT" %
+                         (net['bridge_name']))
         else:
             execute("sudo ifconfig %s up" % net['bridge_name'])
 
+
 def dnsmasq_cmd(net):
     cmd = ['sudo -E dnsmasq',
         ' --strict-order',
@@ -107,12 +121,15 @@ def dnsmasq_cmd(net):
         ' --leasefile-ro']
     return ''.join(cmd)
 
+
 def hostDHCP(network, host, mac):
-    idx = host.split(".")[-1] # Logically, the idx of instances they've launched in this net
+    # Logically, the idx of instances they've launched in this net
+    idx = host.split(".")[-1]
     return "%s,%s-%s-%s.novalocal,%s" % \
         (mac, network['user_id'], network['vlan'], idx, host)
 
-# todo(ja): if the system has restarted or pid numbers have wrapped
+
+# TODO(ja): if the system has restarted or pid numbers have wrapped
 #           then you cannot be certain that the pid refers to the
 #           dnsmasq.  As well, sending a HUP only reloads the hostfile,
 #           so any configuration options (like dchp-range, vlan, ...)
@@ -125,13 +142,15 @@ def start_dnsmasq(network):
     """
     with open(dhcp_file(network['vlan'], 'conf'), 'w') as f:
         for host_name in network.hosts:
-            f.write("%s\n" % hostDHCP(network, host_name, network.hosts[host_name]))
+            f.write("%s\n" % hostDHCP(network,
+                                      host_name,
+                                      network.hosts[host_name]))
 
     pid = dnsmasq_pid_for(network)
 
     # if dnsmasq is already running, then tell it to reload
     if pid:
-        # todo(ja): use "/proc/%d/cmdline" % (pid) to determine if pid refers
+        # TODO(ja): use "/proc/%d/cmdline" % (pid) to determine if pid refers
         #           correct dnsmasq process
         try:
             os.kill(pid, signal.SIGHUP)
@@ -148,6 +167,7 @@ def start_dnsmasq(network):
            'DNSMASQ_INTERFACE': network['bridge_name']}
     execute(dnsmasq_cmd(network), addl_env=env)
 
+
 def stop_dnsmasq(network):
     """ stops the dnsmasq instance for a given network """
     pid = dnsmasq_pid_for(network)
@@ -158,14 +178,17 @@ def stop_dnsmasq(network):
         except Exception, e:
             logging.debug("Killing dnsmasq threw %s", e)
 
+
 def dhcp_file(vlan, kind):
     """ return path to a pid, leases or conf file for a vlan """
 
     return os.path.abspath("%s/nova-%s.%s" % (FLAGS.networks_path, vlan, kind))
 
+
 def bin_file(script):
     return os.path.abspath(os.path.join(__file__, "../../../bin", script))
 
+
 def dnsmasq_pid_for(network):
     """ the pid for prior dnsmasq instance for a vlan,
     returns None if no pid file exists
@@ -178,4 +201,3 @@ def dnsmasq_pid_for(network):
     if os.path.exists(pid_file):
         with open(pid_file, 'r') as f:
             return int(f.read())
-
diff --git a/nova/network/model.py b/nova/network/model.py
index 2074a6d46..734a3f7a9 100644
--- a/nova/network/model.py
+++ b/nova/network/model.py
@@ -119,7 +119,9 @@ class Vlan(datastore.BasicModel):
         default way of saving into "vlan:ID" and adding to a set of "vlans".
         """
         set_name = self._redis_set_name(self.__class__.__name__)
-        datastore.Redis.instance().hset(set_name, self.project_id, self.vlan_id)
+        datastore.Redis.instance().hset(set_name,
+                                        self.project_id,
+                                        self.vlan_id)
 
     @datastore.absorb_connection_error
     def destroy(self):
@@ -129,17 +131,16 @@ class Vlan(datastore.BasicModel):
     def subnet(self):
         vlan = int(self.vlan_id)
         network = IPy.IP(FLAGS.private_range)
-        start = (vlan-FLAGS.vlan_start) * FLAGS.network_size
+        start = (vlan - FLAGS.vlan_start) * FLAGS.network_size
         # minus one for the gateway.
         return "%s-%s" % (network[start],
                           network[start + FLAGS.network_size - 1])
 
+
 # CLEANUP:
 # TODO(ja): Save the IPs at the top of each subnet for cloudpipe vpn clients
 # TODO(ja): does vlanpool "keeper" need to know the min/max -
 #           shouldn't FLAGS always win?
-# TODO(joshua): Save the IPs at the top of each subnet for cloudpipe vpn clients
-
 class BaseNetwork(datastore.BasicModel):
     override_type = 'network'
 
@@ -223,11 +224,11 @@ class BaseNetwork(datastore.BasicModel):
 
     @property
     def num_bottom_reserved_ips(self):
-        return 2 # Network, Gateway
+        return 2  # Network, Gateway
 
     @property
     def num_top_reserved_ips(self):
-        return 1 # Broadcast
+        return 1  # Broadcast
 
     def allocate_ip(self, user_id, project_id, mac):
         for address in self.available:
@@ -257,8 +258,11 @@ class BaseNetwork(datastore.BasicModel):
         for address in self.hosts:
             yield address
 
-    def express(self, address=None): pass
-    def deexpress(self, address=None): pass
+    def express(self, address=None):
+        pass
+
+    def deexpress(self, address=None):
+        pass
 
 
 class BridgedNetwork(BaseNetwork):
@@ -298,6 +302,7 @@ class BridgedNetwork(BaseNetwork):
         linux_net.vlan_create(self)
         linux_net.bridge_create(self)
 
+
 class DHCPNetwork(BridgedNetwork):
     """
     properties:
@@ -365,6 +370,7 @@ class DHCPNetwork(BridgedNetwork):
         else:
             linux_net.start_dnsmasq(self)
 
+
 class PublicAddress(datastore.BasicModel):
     override_type = "address"
 
@@ -391,6 +397,8 @@ class PublicAddress(datastore.BasicModel):
 
 
 DEFAULT_PORTS = [("tcp", 80), ("tcp", 22), ("udp", 1194), ("tcp", 443)]
+
+
 class PublicNetworkController(BaseNetwork):
     override_type = 'network'
 
@@ -400,7 +408,8 @@ class PublicNetworkController(BaseNetwork):
             FLAGS.public_range)
         self['user_id'] = "public"
         self['project_id'] = "public"
-        self["create_time"] = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
+        self["create_time"] = time.strftime('%Y-%m-%dT%H:%M:%SZ',
+                                            time.gmtime())
         self["vlan"] = FLAGS.public_vlan
         self.save()
         self.express()
@@ -458,7 +467,7 @@ class PublicNetworkController(BaseNetwork):
         if address:
             addresses = [self.get_host(address)]
         for addr in addresses:
-            if addr.get('private_ip','available') == 'available':
+            if addr.get('private_ip', 'available') == 'available':
                 continue
             public_ip = addr['address']
             private_ip = addr['private_ip']
@@ -490,8 +499,9 @@ class PublicNetworkController(BaseNetwork):
                                   % (private_ip, protocol, port))
 
 
-# FIXME(todd): does this present a race condition, or is there some piece of
-#              architecture that mitigates it (only one queue listener per net)?
+# FIXME(todd): does this present a race condition, or is there some
+#              piece of architecture that mitigates it (only one queue
+#              listener per net)?
 def get_vlan_for_project(project_id):
     """
     Allocate vlan IDs to individual users.
@@ -502,7 +512,7 @@ def get_vlan_for_project(project_id):
     known_vlans = Vlan.dict_by_vlan()
     for vnum in range(FLAGS.vlan_start, FLAGS.vlan_end):
         vstr = str(vnum)
-        if not known_vlans.has_key(vstr):
+        if not vstr in known_vlans:
             return Vlan.create(project_id, vnum)
         old_project_id = known_vlans[vstr]
         if not manager.AuthManager().get_project(old_project_id):
@@ -526,6 +536,7 @@ def get_vlan_for_project(project_id):
                 return Vlan.create(project_id, vnum)
     raise exception.AddressNotAllocated("Out of VLANs")
 
+
 def get_project_network(project_id, security_group='default'):
     """ get a project's private network, allocating one if needed """
     project = manager.AuthManager().get_project(project_id)
@@ -556,10 +567,8 @@ def get_network_by_interface(iface, security_group='default'):
     return get_project_network(project_id, security_group)
 
 
-
 def get_public_ip_for_instance(instance_id):
     # FIXME: this should be a lookup - iteration won't scale
     for address_record in PublicAddress.all():
         if address_record.get('instance_id', 'available') == instance_id:
             return address_record['address']
-
diff --git a/nova/network/service.py b/nova/network/service.py
index 1a61f49d4..f13324103 100644
--- a/nova/network/service.py
+++ b/nova/network/service.py
@@ -38,7 +38,7 @@ flags.DEFINE_string('network_type',
 flags.DEFINE_string('flat_network_bridge', 'br100',
                     'Bridge for simple network instances')
 flags.DEFINE_list('flat_network_ips',
-                  ['192.168.0.2','192.168.0.3','192.168.0.4'],
+                  ['192.168.0.2', '192.168.0.3', '192.168.0.4'],
                   'Available ips for simple network')
 flags.DEFINE_string('flat_network_network', '192.168.0.0',
                        'Network for simple network')
@@ -51,17 +51,21 @@ flags.DEFINE_string('flat_network_broadcast', '192.168.0.255',
 flags.DEFINE_string('flat_network_dns', '8.8.4.4',
                        'Dns for simple network')
 
+
 def type_to_class(network_type):
     if network_type == 'flat':
         return FlatNetworkService
-    elif network_type  == 'vlan':
+    elif network_type == 'vlan':
         return VlanNetworkService
     raise NotFound("Couldn't find %s network type" % network_type)
 
 
 def setup_compute_network(network_type, user_id, project_id, security_group):
     srv = type_to_class(network_type)
-    srv.setup_compute_network(network_type, user_id, project_id, security_group)
+    srv.setup_compute_network(network_type,
+                              user_id,
+                              project_id,
+                              security_group)
 
 
 def get_host_for_project(project_id):
@@ -175,6 +179,7 @@ class FlatNetworkService(BaseNetworkService):
         """Returns an ip to the pool"""
         datastore.Redis.instance().sadd('ips', fixed_ip)
 
+
 class VlanNetworkService(BaseNetworkService):
     """Vlan network with dhcp"""
     # NOTE(vish): A lot of the interactions with network/model.py can be
@@ -194,7 +199,7 @@ class VlanNetworkService(BaseNetworkService):
         return {'network_type': FLAGS.network_type,
                 'bridge_name': net['bridge_name'],
                 'mac_address': mac,
-                'private_dns_name' : fixed_ip}
+                'private_dns_name': fixed_ip}
 
     def deallocate_fixed_ip(self, fixed_ip,
                             *args, **kwargs):
diff --git a/nova/network/vpn.py b/nova/network/vpn.py
index 1b6dd7a56..74eebf9a8 100644
--- a/nova/network/vpn.py
+++ b/nova/network/vpn.py
@@ -33,6 +33,7 @@ flags.DEFINE_integer('vpn_start_port', 1000,
 flags.DEFINE_integer('vpn_end_port', 2000,
                     'End port for the cloudpipe VPN servers')
 
+
 class NoMorePorts(exception.Error):
     pass
 
@@ -121,4 +122,3 @@ class NetworkData(datastore.BasicModel):
         self.unassociate_with('ip', self.ip)
         datastore.Redis.instance().sadd('ip:%s:ports' % self.ip, self.port)
         super(NetworkData, self).destroy()
-
diff --git a/nova/tests/network_unittest.py b/nova/tests/network_unittest.py
index 94d10200e..9aa39e516 100644
--- a/nova/tests/network_unittest.py
+++ b/nova/tests/network_unittest.py
@@ -31,6 +31,7 @@ from nova.network.exception import NoMoreAddresses
 
 FLAGS = flags.FLAGS
 
+
 class NetworkTestCase(test.TrialTestCase):
     def setUp(self):
         super(NetworkTestCase, self).setUp()
@@ -66,12 +67,14 @@ class NetworkTestCase(test.TrialTestCase):
 
     def test_public_network_allocation(self):
         pubnet = IPy.IP(flags.FLAGS.public_range)
-        address = self.network.allocate_ip(self.user.id, self.projects[0].id, "public")
+        address = self.network.allocate_ip(self.user.id,
+                                           self.projects[0].id,
+                                           "public")
         self.assertTrue(IPy.IP(address) in pubnet)
         self.assertTrue(IPy.IP(address) in self.network.network)
 
     def test_allocate_deallocate_fixed_ip(self):
-        result  = self.service.allocate_fixed_ip(
+        result = self.service.allocate_fixed_ip(
                 self.user.id, self.projects[0].id)
         address = result['private_dns_name']
         mac = result['mac_address']
@@ -103,7 +106,8 @@ class NetworkTestCase(test.TrialTestCase):
         secondnet = model.get_project_network(self.projects[1].id, "default")
 
         self.assertEqual(True, is_in_project(address, self.projects[0].id))
-        self.assertEqual(True, is_in_project(secondaddress, self.projects[1].id))
+        self.assertEqual(True, is_in_project(secondaddress,
+                                             self.projects[1].id))
         self.assertEqual(False, is_in_project(address, self.projects[1].id))
 
         # Addresses are allocated before they're issued
@@ -116,19 +120,21 @@ class NetworkTestCase(test.TrialTestCase):
         self.assertEqual(False, is_in_project(address, self.projects[0].id))
 
         # First address release shouldn't affect the second
-        self.assertEqual(True, is_in_project(secondaddress, self.projects[1].id))
+        self.assertEqual(True, is_in_project(secondaddress,
+                                             self.projects[1].id))
 
         rv = self.service.deallocate_fixed_ip(secondaddress)
         self.dnsmasq.release_ip(secondmac, secondaddress,
                                 hostname, secondnet.bridge_name)
-        self.assertEqual(False, is_in_project(secondaddress, self.projects[1].id))
+        self.assertEqual(False, is_in_project(secondaddress,
+                                              self.projects[1].id))
 
     def test_subnet_edge(self):
         result = self.service.allocate_fixed_ip(self.user.id,
                                                        self.projects[0].id)
         firstaddress = result['private_dns_name']
         hostname = "toomany-hosts"
-        for i in range(1,5):
+        for i in range(1, 5):
             project_id = self.projects[i].id
             result = self.service.allocate_fixed_ip(
                     self.user, project_id)
@@ -142,9 +148,12 @@ class NetworkTestCase(test.TrialTestCase):
                    self.user, project_id)
             mac3 = result['mac_address']
             address3 = result['private_dns_name']
-            self.assertEqual(False, is_in_project(address, self.projects[0].id))
-            self.assertEqual(False, is_in_project(address2, self.projects[0].id))
-            self.assertEqual(False, is_in_project(address3, self.projects[0].id))
+            self.assertEqual(False, is_in_project(address,
+                                                  self.projects[0].id))
+            self.assertEqual(False, is_in_project(address2,
+                                                  self.projects[0].id))
+            self.assertEqual(False, is_in_project(address3,
+                                                  self.projects[0].id))
             rv = self.service.deallocate_fixed_ip(address)
             rv = self.service.deallocate_fixed_ip(address2)
             rv = self.service.deallocate_fixed_ip(address3)
@@ -212,9 +221,10 @@ class NetworkTestCase(test.TrialTestCase):
         """
         net = model.get_project_network(self.projects[0].id, "default")
         num_preallocated_ips = len(net.hosts.keys())
-        num_available_ips = flags.FLAGS.network_size - (net.num_bottom_reserved_ips +
-                                                        num_preallocated_ips +
-                                                        net.num_top_reserved_ips)
+        net_size = flags.FLAGS.network_size
+        num_available_ips = net_size - (net.num_bottom_reserved_ips +
+                                        num_preallocated_ips +
+                                        net.num_top_reserved_ips)
         self.assertEqual(num_available_ips, len(list(net.available)))
 
     def test_too_many_addresses(self):
@@ -249,25 +259,22 @@ class NetworkTestCase(test.TrialTestCase):
                                     net.bridge_name)
         self.assertEqual(len(list(net.available)), num_available_ips)
 
+
 def is_in_project(address, project_id):
     return address in model.get_project_network(project_id).list_addresses()
 
-def _get_project_addresses(project_id):
-    project_addresses = []
-    for addr in model.get_project_network(project_id).list_addresses():
-        project_addresses.append(addr)
-    return project_addresses
 
 def binpath(script):
     return os.path.abspath(os.path.join(__file__, "../../../bin", script))
 
+
 class FakeDNSMasq(object):
     def issue_ip(self, mac, ip, hostname, interface):
         cmd = "%s add %s %s %s" % (binpath('nova-dhcpbridge'),
                                    mac, ip, hostname)
         env = {'DNSMASQ_INTERFACE': interface,
-               'TESTING' : '1',
-               'FLAGFILE' : FLAGS.dhcpbridge_flagfile}
+               'TESTING': '1',
+               'FLAGFILE': FLAGS.dhcpbridge_flagfile}
         (out, err) = utils.execute(cmd, addl_env=env)
         logging.debug("ISSUE_IP: %s, %s " % (out, err))
 
@@ -275,8 +282,7 @@ class FakeDNSMasq(object):
         cmd = "%s del %s %s %s" % (binpath('nova-dhcpbridge'),
                                    mac, ip, hostname)
         env = {'DNSMASQ_INTERFACE': interface,
-               'TESTING' : '1',
-               'FLAGFILE' : FLAGS.dhcpbridge_flagfile}
+               'TESTING': '1',
+               'FLAGFILE': FLAGS.dhcpbridge_flagfile}
         (out, err) = utils.execute(cmd, addl_env=env)
         logging.debug("RELEASE_IP: %s, %s " % (out, err))
-