merge brad's changes that address most review feedback

10 files changed, 157 insertions, 153 deletions

diff --git a/bin/nova-manage b/bin/nova-manage
index 051079ef3..3a17818b2 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -804,11 +804,11 @@ class NetworkCommands(object):
     def quantum_list(self):
         """List all created networks with Quantum-relevant fields"""
         _fmt = "%-32s\t%-10s\t%-10s\t%s , %s"
-        print _fmt % ( _('uuid'),
-                       _('project'),
-                       _('priority'),
-                       _('cidr_v4'),
-                       _('cidr_v6'))
+        print _fmt % (_('uuid'),
+                      _('project'),
+                      _('priority'),
+                      _('cidr_v4'),
+                      _('cidr_v6'))
         for network in db.network_get_all(context.get_admin_context()):
             print _fmt % (network.uuid,
                           network.project_id,
@@ -825,7 +825,6 @@ class NetworkCommands(object):
         net_manager = utils.import_object(FLAGS.network_manager)
         net_manager.delete_network(context.get_admin_context(), fixed_range)
 
-
     @args('--network', dest="fixed_range", metavar='<x.x.x.x/yy>',
             help='Network to modify')
     @args('--project', dest="project", metavar='<project name>',
diff --git a/nova/network/manager.py b/nova/network/manager.py
index b625e7823..426ff2f33 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -547,7 +547,7 @@ class NetworkManager(manager.SchedulerDependentManager):
                    'network_id': network_id,
                    'uuid': str(utils.gen_uuid())}
         # try FLAG times to create a vif record with a unique mac_address
-        for i in range(FLAGS.create_unique_mac_address_attempts):
+        for i in xrange(FLAGS.create_unique_mac_address_attempts):
             try:
                 return self.db.virtual_interface_create(context, vif)
             except exception.VirtualInterfaceCreateException:
diff --git a/nova/network/quantum/client.py b/nova/network/quantum/client.py
index 613369c7d..82f23b6b5 100644
--- a/nova/network/quantum/client.py
+++ b/nova/network/quantum/client.py
@@ -22,11 +22,12 @@ import socket
 import urllib
 
 
-# this is a simple json-only serializer to use until
-# we can just grab the standard serializer
-# from the quantum library
-class Serializer:
-
+class JSONSerializer(object):
+    """
+    This is a simple json-only serializer to use until we can just grab
+    the standard serializer from the quantum library.
+    TODO(danwent): replace serializer with quantum implementation
+    """
     def serialize(self, data, content_type):
         try:
             return json.dumps(data)
@@ -40,12 +41,12 @@ class Serializer:
 
 class api_call(object):
     """A Decorator to add support for format and tenant overriding"""
-    def __init__(self, f):
-        self.f = f
+    def __init__(self, func):
+        self.func = func
 
     def __get__(self, instance, owner):
         def with_params(*args, **kwargs):
-            # Temporarily set format and tenant for this request
+            """Temporarily set format and tenant for this request"""
             (format, tenant) = (instance.format, instance.tenant)
 
             if 'format' in kwargs:
@@ -53,14 +54,16 @@ class api_call(object):
             if 'tenant' in kwargs:
                 instance.tenant = kwargs['tenant']
 
-            ret = self.f(instance, *args)
-            (instance.format, instance.tenant) = (format, tenant)
+            ret = None
+            try:
+                ret = self.func(instance, *args)
+            finally:
+                (instance.format, instance.tenant) = (format, tenant)
             return ret
         return with_params
 
 
 class Client(object):
-
     """A base client class - derived from Glance.BaseClient"""
 
     action_prefix = '/v1.0/tenants/{tenant_id}'
@@ -73,8 +76,8 @@ class Client(object):
     attachment_path = "/networks/%s/ports/%s/attachment"
 
     def __init__(self, host="127.0.0.1", port=9696, use_ssl=False, tenant=None,
-                format="xml", testingStub=None, key_file=None, cert_file=None,
-                logger=None):
+                 format="xml", testing_stub=None, key_file=None,
+                 cert_file=None, logger=None):
         """
         Creates a new client to some service.
 
@@ -83,7 +86,7 @@ class Client(object):
         :param use_ssl: True to use SSL, False to use HTTP
         :param tenant: The tenant ID to make requests with
         :param format: The format to query the server with
-        :param testingStub: A class that stubs basic server methods for tests
+        :param testing_stub: A class that stubs basic server methods for tests
         :param key_file: The SSL key file to use if use_ssl is true
         :param cert_file: The SSL cert file to use if use_ssl is true
         """
@@ -93,7 +96,7 @@ class Client(object):
         self.tenant = tenant
         self.format = format
         self.connection = None
-        self.testingStub = testingStub
+        self.testing_stub = testing_stub
         self.key_file = key_file
         self.cert_file = cert_file
         self.logger = logger
@@ -102,9 +105,9 @@ class Client(object):
         """
         Returns the proper connection type
         """
-        if self.testingStub:
-            return self.testingStub
-        if self.use_ssl:
+        if self.testing_stub:
+            return self.testing_stub
+        elif self.use_ssl:
             return httplib.HTTPSConnection
         else:
             return httplib.HTTPConnection
@@ -126,7 +129,7 @@ class Client(object):
 
         # Ensure we have a tenant id
         if not self.tenant:
-            raise Exception("Tenant ID not set")
+            raise Exception(_("Tenant ID not set"))
 
         # Add format and tenant_id
         action += ".%s" % self.format
@@ -151,8 +154,8 @@ class Client(object):
                 c = connection_type(self.host, self.port)
 
             if self.logger:
-                self.logger.debug("Quantum Client Request:\n" \
-                        + method + " " + action + "\n")
+                self.logger.debug(_("Quantum Client Request:\n%s %s\n" %
+                                    (method, action)))
                 if body:
                     self.logger.debug(body)
 
@@ -172,11 +175,11 @@ class Client(object):
                 if data is not None and len(data):
                     return self.deserialize(data, status_code)
             else:
-                raise Exception("Server returned error: %s" % res.read())
+                raise Exception(_("Server returned error: %s" % res.read()))
 
         except (socket.error, IOError), e:
-            raise Exception("Unable to connect to "
-                            "server. Got error: %s" % e)
+            raise Exception(_("Unable to connect to "
+                              "server. Got error: %s" % e))
 
     def get_status_code(self, response):
         """
@@ -189,18 +192,18 @@ class Client(object):
             return response.status
 
     def serialize(self, data):
-        if data is None:
+        if not data:
             return None
         elif type(data) is dict:
-            return Serializer().serialize(data, self.content_type())
+            return JSONSerializer().serialize(data, self.content_type())
         else:
-            raise Exception("unable to deserialize object of type = '%s'" \
-                                % type(data))
+            raise Exception(_("unable to deserialize object of type = '%s'" %
+                              type(data)))
 
     def deserialize(self, data, status_code):
         if status_code == 202:
             return data
-        return Serializer().deserialize(data, self.content_type())
+        return JSONSerializer().deserialize(data, self.content_type())
 
     def content_type(self, format=None):
         if not format:
diff --git a/nova/network/quantum/fake.py b/nova/network/quantum/fake.py
index 00cdd8e08..f668edfed 100644
--- a/nova/network/quantum/fake.py
+++ b/nova/network/quantum/fake.py
@@ -15,9 +15,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import math
-from netaddr import IPNetwork
-
 from nova import exception
 from nova import ipv6
 from nova import log as logging
@@ -29,7 +26,7 @@ LOG = logging.getLogger("network.quantum.fake")
 
 # this class can be used for unit functional/testing on nova,
 # as it does not actually make remote calls to the Quantum service
-class FakeQuantumClientConnection:
+class FakeQuantumClientConnection(object):
 
     def __init__(self):
         self.nets = {}
@@ -56,20 +53,20 @@ class FakeQuantumClientConnection:
     def network_exists(self, tenant_id, net_id):
         try:
             return self.nets[net_id]['tenant-id'] == tenant_id
-        except:
+        except KeyError:
             return False
 
     def _confirm_not_attached(self, interface_id):
         for n in self.nets.values():
             for p in n['ports'].values():
                 if p['attachment-id'] == interface_id:
-                    raise Exception("interface '%s' is already attached" %\
-                                        interface_id)
+                    raise Exception(_("interface '%s' is already attached" %
+                                          interface_id))
 
     def create_and_attach_port(self, tenant_id, net_id, interface_id):
         if not self.network_exists(tenant_id, net_id):
-            raise Exception("network %s does not exist for tenant %s" %\
-                                (net_id, tenant_id))
+            raise Exception(_("network %s does not exist for tenant %s" %
+                              (net_id, tenant_id)))
 
         self._confirm_not_attached(interface_id)
         uuid = str(utils.gen_uuid())
@@ -79,8 +76,8 @@ class FakeQuantumClientConnection:
 
     def detach_and_delete_port(self, tenant_id, net_id, port_id):
         if not self.network_exists(tenant_id, net_id):
-            raise Exception("network %s does not exist for tenant %s" %\
-                                (net_id, tenant_id))
+            raise Exception(_("network %s does not exist for tenant %s" %\
+                                  (net_id, tenant_id)))
         del self.nets[net_id]['ports'][port_id]
 
     def get_port_by_attachment(self, tenant_id, attachment_id):
diff --git a/nova/network/quantum/manager.py b/nova/network/quantum/manager.py
index a002a3d7b..c03622218 100644
--- a/nova/network/quantum/manager.py
+++ b/nova/network/quantum/manager.py
@@ -84,16 +84,15 @@ class QuantumManager(manager.FlatManager):
             In both cases, we initialize a subnet using the IPAM lib.
         """
         if num_networks != 1:
-            raise Exception("QuantumManager requires that only one"
-                            " network is created per call")
-        q_tenant_id = kwargs["project_id"] or \
-                            FLAGS.quantum_default_tenant_id
+            raise Exception(_("QuantumManager requires that only one"
+                              " network is created per call"))
+        q_tenant_id = kwargs["project_id"] or FLAGS.quantum_default_tenant_id
         quantum_net_id = uuid
         if quantum_net_id:
             if not self.q_conn.network_exists(q_tenant_id, quantum_net_id):
-                    raise Exception("Unable to find existing quantum " \
-                        " network for tenant '%s' with net-id '%s'" % \
-                         (q_tenant_id, quantum_net_id))
+                    raise Exception(_("Unable to find existing quantum " \
+                                " network for tenant '%s' with net-id '%s'" % \
+                                (q_tenant_id, quantum_net_id)))
         else:
             # otherwise, create network from default quantum pool
             quantum_net_id = self.q_conn.create_network(q_tenant_id, label)
@@ -156,18 +155,18 @@ class QuantumManager(manager.FlatManager):
         # Create a port via quantum and attach the vif
         for (quantum_net_id, project_id) in net_proj_pairs:
 
-            # FIXME: (danwent). We'd like to have the manager be completely
-            # decoupled from the nova networks table.
-            # However, other parts of nova sometimes go behind
-            # our back and access network data directly from the DB.  So
+            # FIXME(danwent): We'd like to have the manager be
+            # completely decoupled from the nova networks table.
+            # However, other parts of nova sometimes go behind our
+            # back and access network data directly from the DB.  So
             # for now, the quantum manager knows that there is a nova
-            # networks DB table and accesses it here.
-            # updating the virtual_interfaces table to use UUIDs would
-            # be one solution, but this would require significant work
+            # networks DB table and accesses it here.  updating the
+            # virtual_interfaces table to use UUIDs would be one
+            # solution, but this would require significant work
             # elsewhere.
             admin_context = context.elevated()
             network_ref = db.network_get_by_uuid(admin_context,
-                                                quantum_net_id)
+                                                 quantum_net_id)
 
             vif_rec = manager.FlatManager.add_virtual_interface(self,
                                   context, instance_id, network_ref['id'])
@@ -177,10 +176,10 @@ class QuantumManager(manager.FlatManager):
             self.q_conn.create_and_attach_port(q_tenant_id, quantum_net_id,
                                                vif_rec['uuid'])
             self.ipam.allocate_fixed_ip(context, project_id, quantum_net_id,
-                                                                    vif_rec)
+                                        vif_rec)
 
         return self.get_instance_nw_info(context, instance_id,
-                                            instance_type_id, host)
+                                         instance_type_id, host)
 
     def get_instance_nw_info(self, context, instance_id,
                                 instance_type_id, host):
@@ -214,8 +213,8 @@ class QuantumManager(manager.FlatManager):
                 net_id, port_id = self.q_conn.get_port_by_attachment(
                                              q_tenant_id, vif['uuid'])
             if not net_id:
-                raise Exception(_("No network for for virtual interface %s") %\
-                                        vif['uuid'])
+                raise Exception(_("No network for for virtual interface %s") %
+                                vif['uuid'])
             (v4_subnet, v6_subnet) = self.ipam.get_subnets_by_net_id(context,
                                         ipam_tenant_id, net_id)
             v4_ips = self.ipam.get_v4_ips_by_interface(context,
@@ -288,17 +287,21 @@ class QuantumManager(manager.FlatManager):
                 (net_id, port_id) = self.q_conn.get_port_by_attachment(
                                         q_tenant_id, interface_id)
             if not net_id:
-                LOG.error("Unable to find port with attachment: %s" % \
-                                                        (interface_id))
+                LOG.error("Unable to find port with attachment: %s" %
+                          (interface_id))
                 continue
             self.q_conn.detach_and_delete_port(q_tenant_id,
-                                                   net_id, port_id)
+                                               net_id, port_id)
 
             self.ipam.deallocate_ips_by_vif(context, ipam_tenant_id,
-                                                    net_id, vif_ref)
+                                            net_id, vif_ref)
 
-        db.virtual_interface_delete_by_instance(admin_context,
-                                                            instance_id)
+        try:
+            db.virtual_interface_delete_by_instance(admin_context,
+                                                    instance_id)
+        except exception.InstanceNotFound:
+            LOG.error(_("Attempted to deallocate non-existent instance: %s" %
+                        (instance_id)))
         self._do_trigger_security_group_members_refresh_for_instance(
                                                                    instance_id)
 
diff --git a/nova/network/quantum/melange_connection.py b/nova/network/quantum/melange_connection.py
index 2d884fa60..1ee0c29a2 100644
--- a/nova/network/quantum/melange_connection.py
+++ b/nova/network/quantum/melange_connection.py
@@ -73,10 +73,10 @@ class MelangeConnection(object):
             response_str = response.read()
             if response.status < 400:
                 return response_str
-            raise Exception("Server returned error: %s", response_str)
+            raise Exception(_("Server returned error: %s", response_str))
         except (socket.error, IOError), e:
-            raise Exception("Unable to connect to "
-                            "server. Got error: %s" % e)
+            raise Exception(_("Unable to connect to "
+                            "server. Got error: %s" % e))
 
     def allocate_ip(self, network_id, vif_id,
                     project_id=None, mac_address=None):
diff --git a/nova/network/quantum/melange_ipam_lib.py b/nova/network/quantum/melange_ipam_lib.py
index 7b7baf281..24a7c5404 100644
--- a/nova/network/quantum/melange_ipam_lib.py
+++ b/nova/network/quantum/melange_ipam_lib.py
@@ -31,7 +31,7 @@ def get_ipam_lib(net_man):
     return QuantumMelangeIPAMLib()
 
 
-class QuantumMelangeIPAMLib:
+class QuantumMelangeIPAMLib(object):
     """ Implements Quantum IP Address Management (IPAM) interface
         using the Melange service, which is access using the Melange
         web services API.
@@ -42,9 +42,9 @@ class QuantumMelangeIPAMLib:
         self.m_conn = melange_connection.MelangeConnection()
 
     def create_subnet(self, context, label, project_id,
-                                quantum_net_id, priority, cidr=None,
-                                gateway_v6=None, cidr_v6=None,
-                                dns1=None, dns2=None):
+                      quantum_net_id, priority, cidr=None,
+                      gateway_v6=None, cidr_v6=None,
+                      dns1=None, dns2=None):
         """ Contact Melange and create a subnet for any non-NULL
             IPv4 or IPv6 subnets.
 
@@ -56,25 +56,25 @@ class QuantumMelangeIPAMLib:
         tenant_id = project_id or FLAGS.quantum_default_tenant_id
         if cidr:
             self.m_conn.create_block(quantum_net_id, cidr,
-                            project_id=tenant_id,
-                            dns1=dns1, dns2=dns2)
+                                     project_id=tenant_id,
+                                     dns1=dns1, dns2=dns2)
         if cidr_v6:
             self.m_conn.create_block(quantum_net_id, cidr_v6,
                                      project_id=tenant_id,
                                      dns1=dns1, dns2=dns2)
 
         net = {"uuid": quantum_net_id,
-                   "project_id": project_id,
-                   "priority": priority,
-                   "label": label}
+               "project_id": project_id,
+               "priority": priority,
+               "label": label}
         network = self.db.network_create_safe(context, net)
 
     def allocate_fixed_ip(self, context, project_id, quantum_net_id, vif_ref):
         """ Pass call to allocate fixed IP on to Melange"""
         tenant_id = project_id or FLAGS.quantum_default_tenant_id
         self.m_conn.allocate_ip(quantum_net_id,
-                               vif_ref['uuid'], project_id=tenant_id,
-                               mac_address=vif_ref['address'])
+                                vif_ref['uuid'], project_id=tenant_id,
+                                mac_address=vif_ref['address'])
 
     def get_network_id_by_cidr(self, context, cidr, project_id):
         """ Find the Quantum UUID associated with a IPv4 CIDR
@@ -85,7 +85,7 @@ class QuantumMelangeIPAMLib:
         for b in all_blocks['ip_blocks']:
             if b['cidr'] == cidr:
                 return b['network_id']
-        raise Exception("No network found for cidr %s" % cidr)
+        raise Exception(_("No network found for cidr %s" % cidr))
 
     def delete_subnets_by_net_id(self, context, net_id, project_id):
         """ Find Melange block associated with the Quantum UUID,
@@ -107,38 +107,38 @@ class QuantumMelangeIPAMLib:
             that are "global" (i.e., have no project set).
             Returns list sorted by 'priority'.
         """
-        admin_context = context.elevated()
-        id_proj_map = {}
         if project_id is None:
-            raise Exception("get_project_and_global_net_ids must be called" \
-                    " with a non-null project_id")
-        tenant_id = project_id
-        all_tenant_blocks = self.m_conn.get_blocks(tenant_id)
-        for b in all_tenant_blocks['ip_blocks']:
-            id_proj_map[b['network_id']] = tenant_id
-        tenant_id = FLAGS.quantum_default_tenant_id
-        all_provider_blocks = self.m_conn.get_blocks(tenant_id)
-        for b in all_provider_blocks['ip_blocks']:
-            id_proj_map[b['network_id']] = tenant_id
-
-        id_priority_map = {}
-        for net_id, project_id in id_project_map.item():
-            network = db.network_get_by_uuid(admin_context, net_id)
-            if network is None:
-                del id_proj_map[net_id]
-            else:
-                id_priority_map[net_id] = network['priority']
-        return sorted(id_priority_map.items(),
-                        key=lambda x: id_priority_map[x[0]])
+            raise Exception(_("get_project_and_global_net_ids must be called"
+                              " with a non-null project_id"))
+
+        admin_context = context.elevated()
+
+        # Decorate with priority
+        priority_nets = []
+        for tenant_id in (project_id, FLAGS.quantum_default_tenant_id):
+            blocks = self.m_conn.get_blocks(tenant_id)
+            for ip_block in blocks['ip_blocks']:
+                network_id = ip_block['network_id']
+                network = db.network_get_by_uuid(admin_context, network_id)
+                if network:
+                    priority = network['priority']
+                    priority_nets.append((priority, network_id, tenant_id))
+
+        # Sort by priority
+        priority_nets.sort()
+
+        # Undecorate
+        return [(network_id, tenant_id)
+                for priority, network_id, tenant_id in priority_nets]
 
     def get_subnets_by_net_id(self, context, project_id, net_id):
         """ Returns information about the IPv4 and IPv6 subnets
             associated with a Quantum Network UUID.
         """
 
-        # FIXME: (danwent) Melange actually returns the subnet info
-        # when we query for a particular interface.  we may want to
-        # reworks the ipam_manager python API to let us take advantage of
+        # FIXME(danwent):  Melange actually returns the subnet info
+        # when we query for a particular interface.  We may want to
+        # rework the ipam_manager python API to let us take advantage of
         # this, as right now we have to get all blocks and cycle through
         # them.
         subnet_v4 = None
@@ -148,12 +148,12 @@ class QuantumMelangeIPAMLib:
         for b in all_blocks['ip_blocks']:
             if b['network_id'] == net_id:
                 subnet = {'network_id': b['network_id'],
-                             'cidr': b['cidr'],
-                             'gateway': b['gateway'],
-                             'broadcast': b['broadcast'],
-                             'netmask': b['netmask'],
-                             'dns1': b['dns1'],
-                             'dns2': b['dns2']}
+                          'cidr': b['cidr'],
+                          'gateway': b['gateway'],
+                          'broadcast': b['broadcast'],
+                          'netmask': b['netmask'],
+                          'dns1': b['dns1'],
+                          'dns2': b['dns2']}
 
                 if IPNetwork(b['cidr']).version == 6:
                     subnet_v6 = subnet
@@ -182,8 +182,8 @@ class QuantumMelangeIPAMLib:
         """
         tenant_id = project_id or FLAGS.quantum_default_tenant_id
         ip_list = self.m_conn.get_allocated_ips(net_id, vif_id, tenant_id)
-        return [ip['address'] for ip in ip_list \
-                        if IPNetwork(ip['address']).version == ip_version]
+        return [ip['address'] for ip in ip_list
+                if IPNetwork(ip['address']).version == ip_version]
 
     def verify_subnet_exists(self, context, project_id, quantum_net_id):
         """ Confirms that a subnet exists that is associated with the
diff --git a/nova/network/quantum/nova_ipam_lib.py b/nova/network/quantum/nova_ipam_lib.py
index ce7d3efcb..4f62887d1 100644
--- a/nova/network/quantum/nova_ipam_lib.py
+++ b/nova/network/quantum/nova_ipam_lib.py
@@ -36,7 +36,7 @@ def get_ipam_lib(net_man):
     return QuantumNovaIPAMLib(net_man)
 
 
-class QuantumNovaIPAMLib:
+class QuantumNovaIPAMLib(object):
     """ Implements Quantum IP Address Management (IPAM) interface
         using the local Nova database.  This implementation is inline
         with how IPAM is used by other NetworkManagers.
@@ -50,9 +50,9 @@ class QuantumNovaIPAMLib:
         self.net_manager = net_manager
 
     def create_subnet(self, context, label, tenant_id,
-                                quantum_net_id, priority, cidr=None,
-                                gateway_v6=None, cidr_v6=None,
-                                dns1=None, dns2=None):
+                      quantum_net_id, priority, cidr=None,
+                      gateway_v6=None, cidr_v6=None,
+                      dns1=None, dns2=None):
         """ Re-use the basic FlatManager create_networks method to
             initialize the networks and fixed_ips tables in Nova DB.
 
@@ -60,6 +60,7 @@ class QuantumNovaIPAMLib:
             are needed by Quantum but not the FlatManager.
         """
         admin_context = context.elevated()
+        # FIXME(danwent): Use the netaddr library here
         subnet_size = int(math.pow(2, (32 - int(cidr.split("/")[1]))))
         networks = manager.FlatManager.create_networks(self.net_manager,
                     admin_context, label, cidr,
@@ -67,12 +68,12 @@ class QuantumNovaIPAMLib:
                     gateway_v6, quantum_net_id, None, dns1, dns2)
 
         if len(networks) != 1:
-            raise Exception("Error creating network entry")
+            raise Exception(_("Error creating network entry"))
 
         network = networks[0]
         net = {"project_id": tenant_id,
-                   "priority": priority,
-                   "uuid": quantum_net_id}
+               "priority": priority,
+               "uuid": quantum_net_id}
         db.network_update(admin_context, network['id'], net)
 
     def get_network_id_by_cidr(self, context, cidr, project_id):
@@ -80,7 +81,8 @@ class QuantumNovaIPAMLib:
         admin_context = context.elevated()
         network = db.network_get_by_cidr(admin_context, cidr)
         if not network:
-            raise Exception("No network with fixed_range = %s" % fixed_range)
+            raise Exception(_("No network with fixed_range = %s" %
+                              fixed_range))
         return network['uuid']
 
     def delete_subnets_by_net_id(self, context, net_id, project_id):
@@ -90,10 +92,10 @@ class QuantumNovaIPAMLib:
         admin_context = context.elevated()
         network = db.network_get_by_uuid(admin_context, net_id)
         if not network:
-            raise Exception("No network with net_id = %s" % net_id)
+            raise Exception(_("No network with net_id = %s" % net_id))
         manager.FlatManager.delete_network(self.net_manager,
-                                        admin_context, network['cidr'],
-                                        require_disassociated=False)
+                                           admin_context, network['cidr'],
+                                           require_disassociated=False)
 
     def get_project_and_global_net_ids(self, context, project_id):
         """ Fetches all networks associated with this project, or
@@ -118,8 +120,8 @@ class QuantumNovaIPAMLib:
         network = db.network_get_by_uuid(admin_context, quantum_net_id)
         if network['cidr']:
             address = db.fixed_ip_associate_pool(admin_context,
-                                                      network['id'],
-                                                      vif_rec['instance_id'])
+                                                 network['id'],
+                                                 vif_rec['instance_id'])
             values = {'allocated': True,
                       'virtual_interface_id': vif_rec['id']}
             db.fixed_ip_update(admin_context, address, values)
@@ -186,10 +188,10 @@ class QuantumNovaIPAMLib:
             admin_context = context.elevated()
             fixed_ips = db.fixed_ip_get_by_virtual_interface(admin_context,
                                                              vif_ref['id'])
-            for f in fixed_ips:
-                db.fixed_ip_update(admin_context, f['address'],
-                                {'allocated': False,
-                                 'virtual_interface_id': None})
+            for fixed_ip in fixed_ips:
+                db.fixed_ip_update(admin_context, fixed_ip['address'],
+                                   {'allocated': False,
+                                    'virtual_interface_id': None})
         except exception.FixedIpNotFoundForInstance:
-            LOG.error(_('No fixed IPs to deallocate for vif %s' % \
-                                                            vif_ref['id']))
+            LOG.error(_('No fixed IPs to deallocate for vif %s' %
+                            vif_ref['id']))
diff --git a/nova/network/quantum/quantum_connection.py b/nova/network/quantum/quantum_connection.py
index bd3592c2c..e2218c68d 100644
--- a/nova/network/quantum/quantum_connection.py
+++ b/nova/network/quantum/quantum_connection.py
@@ -37,7 +37,7 @@ flags.DEFINE_string('quantum_default_tenant_id',
                     'Default tenant id when creating quantum networks')
 
 
-class QuantumClientConnection:
+class QuantumClientConnection(object):
     """ Abstracts connection to Quantum service into higher level
         operations performed by the QuantumManager.
 
@@ -71,7 +71,7 @@ class QuantumClientConnection:
         try:
             self.client.show_network_details(net_id, tenant=tenant_id)
         except:
-            # FIXME: (danwent) client lib should expose granular exceptions
+            # FIXME(danwent): client lib should expose granular exceptions
             # so we can confirm we're getting a 404 and not some other error
             return False
         return True
@@ -81,8 +81,8 @@ class QuantumClientConnection:
             status to ACTIVE to enable traffic, and attaches the
             vNIC with the specified interface-id.
         """
-        LOG.debug("Connecting interface %s to net %s for %s" % \
-                    (interface_id, net_id, tenant_id))
+        LOG.debug(_("Connecting interface %s to net %s for %s" %
+                    (interface_id, net_id, tenant_id)))
         port_data = {'port': {'state': 'ACTIVE'}}
         resdict = self.client.create_port(net_id, port_data, tenant=tenant_id)
         port_id = resdict["port"]["id"]
@@ -103,7 +103,7 @@ class QuantumClientConnection:
         """ Given a tenant, search for the Quantum network and port
             UUID that has the specified interface-id attachment.
         """
-        # FIXME: (danwent) this will be inefficient until the Quantum
+        # FIXME(danwent): this will be inefficient until the Quantum
         # API implements querying a port by the interface-id
         net_list_resdict = self.client.list_networks(tenant=tenant_id)
         for n in net_list_resdict["networks"]:
diff --git a/nova/tests/test_quantum.py b/nova/tests/test_quantum.py
index 3efdba910..2cc83adf1 100644
--- a/nova/tests/test_quantum.py
+++ b/nova/tests/test_quantum.py
@@ -155,9 +155,9 @@ class QuantumTestCaseBase(object):
         self.assertTrue(nw_info[1][0]['cidr_v6'].startswith("2001:1db8:"))
 
         # v6 address
-        self.assertTrue(\
+        self.assertTrue(
             nw_info[0][1]['ip6s'][0]['ip'].startswith("2001:1dba:"))
-        self.assertTrue(\
+        self.assertTrue(
             nw_info[1][1]['ip6s'][0]['ip'].startswith("2001:1db8:"))
 
         self.net_man.deallocate_for_instance(ctx,
@@ -233,24 +233,24 @@ class QuantumNovaIPAMTestCase(QuantumTestCaseBase, test.TestCase):
         self.net_man = quantum_manager.QuantumManager( \
                 ipam_lib="nova.network.quantum.nova_ipam_lib")
 
-        # tests seem to create some networks by default, which
-        # don't want.  So we delete them.
+        # Tests seem to create some networks by default, which
+        # we don't want.  So we delete them.
 
         ctx = context.RequestContext('user1', 'fake_project1').elevated()
         for n in db.network_get_all(ctx):
             db.network_delete_safe(ctx, n['id'])
 
-        # I've found that other unit tests have a nasty habit of
-        # of creating fixed IPs and not cleaning up, which can
-        # confuse these tests, so we clean them all.
+        # NOTE(danwent): I've found that other unit tests have a nasty
+        # habit of of creating fixed IPs and not cleaning up, which
+        # can confuse these tests, so we clean them all.
         session = get_session()
         result = session.query(models.FixedIp).all()
         with session.begin():
             for fip_ref in result:
                 session.delete(fip_ref)
 
-# Cannot run this unit tests auotmatically for now, as it requires
-# melange to be running locally.
+# FIXME(danwent): Cannot run this unit tests automatically for now, as
+# it requires melange to be running locally.
 #
 #class QuantumMelangeIPAMTestCase(QuantumTestCaseBase, test.TestCase):
 #