docstring cleanup, nova/network dir

5 files changed, 188 insertions, 179 deletions

diff --git a/nova/network/api.py b/nova/network/api.py
index 1d8193b28..e2eacdf42 100644
--- a/nova/network/api.py
+++ b/nova/network/api.py
@@ -16,9 +16,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-"""
-Handles all requests relating to instances (guest vms).
-"""
+"""Handles all requests relating to instances (guest vms)."""
 
 from nova import db
 from nova import exception
@@ -28,6 +26,7 @@ from nova import quota
 from nova import rpc
 from nova.db import base
 
+
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.network')
 
@@ -37,19 +36,19 @@ class API(base.Base):
 
     def allocate_floating_ip(self, context):
         if quota.allowed_floating_ips(context, 1) < 1:
-            LOG.warn(_("Quota exceeeded for %s, tried to allocate "
-                           "address"),
-                         context.project_id)
-            raise quota.QuotaError(_("Address quota exceeded. You cannot "
-                                     "allocate any more addresses"))
+            LOG.warn(_('Quota exceeeded for %s, tried to allocate '
+                       'address'),
+                     context.project_id)
+            raise quota.QuotaError(_('Address quota exceeded. You cannot '
+                                     'allocate any more addresses'))
         # NOTE(vish): We don't know which network host should get the ip
         #             when we allocate, so just send it to any one.  This
         #             will probably need to move into a network supervisor
         #             at some point.
         return rpc.call(context,
                         FLAGS.network_topic,
-                        {"method": "allocate_floating_ip",
-                         "args": {"project_id": context.project_id}})
+                        {'method': 'allocate_floating_ip',
+                         'args': {'project_id': context.project_id}})
 
     def release_floating_ip(self, context, address,
                             affect_auto_assigned=False):
@@ -62,8 +61,8 @@ class API(base.Base):
         #             at some point.
         rpc.cast(context,
                  FLAGS.network_topic,
-                 {"method": "deallocate_floating_ip",
-                  "args": {"floating_address": floating_ip['address']}})
+                 {'method': 'deallocate_floating_ip',
+                  'args': {'floating_address': floating_ip['address']}})
 
     def associate_floating_ip(self, context, floating_ip, fixed_ip,
                               affect_auto_assigned=False):
@@ -74,17 +73,17 @@ class API(base.Base):
             return
         # Check if the floating ip address is allocated
         if floating_ip['project_id'] is None:
-            raise exception.ApiError(_("Address (%s) is not allocated") %
+            raise exception.ApiError(_('Address (%s) is not allocated') %
                                        floating_ip['address'])
         # Check if the floating ip address is allocated to the same project
         if floating_ip['project_id'] != context.project_id:
-            LOG.warn(_("Address (%(address)s) is not allocated to your "
-                       "project (%(project)s)"),
+            LOG.warn(_('Address (%(address)s) is not allocated to your '
+                       'project (%(project)s)'),
                        {'address': floating_ip['address'],
                        'project': context.project_id})
-            raise exception.ApiError(_("Address (%(address)s) is not "
-                                       "allocated to your project"
-                                       "(%(project)s)") %
+            raise exception.ApiError(_('Address (%(address)s) is not '
+                                       'allocated to your project'
+                                       '(%(project)s)') %
                                         {'address': floating_ip['address'],
                                         'project': context.project_id})
         # NOTE(vish): Perhaps we should just pass this on to compute and
@@ -92,9 +91,9 @@ class API(base.Base):
         host = fixed_ip['network']['host']
         rpc.cast(context,
                  self.db.queue_get_for(context, FLAGS.network_topic, host),
-                 {"method": "associate_floating_ip",
-                  "args": {"floating_address": floating_ip['address'],
-                           "fixed_address": fixed_ip['address']}})
+                 {'method': 'associate_floating_ip',
+                  'args': {'floating_address': floating_ip['address'],
+                           'fixed_address': fixed_ip['address']}})
 
     def disassociate_floating_ip(self, context, address,
                                  affect_auto_assigned=False):
@@ -108,5 +107,5 @@ class API(base.Base):
         host = floating_ip['fixed_ip']['network']['host']
         rpc.cast(context,
                  self.db.queue_get_for(context, FLAGS.network_topic, host),
-                 {"method": "disassociate_floating_ip",
-                  "args": {"floating_address": floating_ip['address']}})
+                 {'method': 'disassociate_floating_ip',
+                  'args': {'floating_address': floating_ip['address']}})
diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index b50a4b4ea..af91804a1 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -15,13 +15,12 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
-"""
-Implements vlans, bridges, and iptables rules using linux utilities.
-"""
 
+"""Implements vlans, bridges, and iptables rules using linux utilities."""
+
+import calendar
 import inspect
 import os
-import calendar
 
 from nova import db
 from nova import exception
@@ -29,12 +28,13 @@ from nova import flags
 from nova import log as logging
 from nova import utils
 
+
 LOG = logging.getLogger("nova.linux_net")
 
 
 def _bin_file(script):
-    """Return the absolute path to scipt in the bin directory"""
-    return os.path.abspath(os.path.join(__file__, "../../../bin", script))
+    """Return the absolute path to scipt in the bin directory."""
+    return os.path.abspath(os.path.join(__file__, '../../../bin', script))
 
 
 FLAGS = flags.FLAGS
@@ -66,11 +66,13 @@ binary_name = os.path.basename(inspect.stack()[-1][1])
 
 
 class IptablesRule(object):
-    """An iptables rule
+    """An iptables rule.
 
     You shouldn't need to use this class directly, it's only used by
-    IptablesManager
+    IptablesManager.
+
     """
+
     def __init__(self, chain, rule, wrap=True, top=False):
         self.chain = chain
         self.rule = rule
@@ -95,7 +97,7 @@ class IptablesRule(object):
 
 
 class IptablesTable(object):
-    """An iptables table"""
+    """An iptables table."""
 
     def __init__(self):
         self.rules = []
@@ -103,15 +105,16 @@ class IptablesTable(object):
         self.unwrapped_chains = set()
 
     def add_chain(self, name, wrap=True):
-        """Adds a named chain to the table
+        """Adds a named chain to the table.
 
         The chain name is wrapped to be unique for the component creating
         it, so different components of Nova can safely create identically
         named chains without interfering with one another.
 
         At the moment, its wrapped name is <binary name>-<chain name>,
-        so if nova-compute creates a chain named "OUTPUT", it'll actually
-        end up named "nova-compute-OUTPUT".
+        so if nova-compute creates a chain named 'OUTPUT', it'll actually
+        end up named 'nova-compute-OUTPUT'.
+
         """
         if wrap:
             self.chains.add(name)
@@ -119,12 +122,13 @@ class IptablesTable(object):
             self.unwrapped_chains.add(name)
 
     def remove_chain(self, name, wrap=True):
-        """Remove named chain
+        """Remove named chain.
 
         This removal "cascades". All rule in the chain are removed, as are
         all rules in other chains that jump to it.
 
         If the chain is not found, this is merely logged.
+
         """
         if wrap:
             chain_set = self.chains
@@ -132,7 +136,7 @@ class IptablesTable(object):
             chain_set = self.unwrapped_chains
 
         if name not in chain_set:
-            LOG.debug(_("Attempted to remove chain %s which doesn't exist"),
+            LOG.debug(_('Attempted to remove chain %s which does not exist'),
                       name)
             return
 
@@ -147,17 +151,18 @@ class IptablesTable(object):
         self.rules = filter(lambda r: jump_snippet not in r.rule, self.rules)
 
     def add_rule(self, chain, rule, wrap=True, top=False):
-        """Add a rule to the table
+        """Add a rule to the table.
 
         This is just like what you'd feed to iptables, just without
-        the "-A <chain name>" bit at the start.
+        the '-A <chain name>' bit at the start.
 
         However, if you need to jump to one of your wrapped chains,
         prepend its name with a '$' which will ensure the wrapping
         is applied correctly.
+
         """
         if wrap and chain not in self.chains:
-            raise ValueError(_("Unknown chain: %r") % chain)
+            raise ValueError(_('Unknown chain: %r') % chain)
 
         if '$' in rule:
             rule = ' '.join(map(self._wrap_target_chain, rule.split(' ')))
@@ -170,23 +175,24 @@ class IptablesTable(object):
         return s
 
     def remove_rule(self, chain, rule, wrap=True, top=False):
-        """Remove a rule from a chain
+        """Remove a rule from a chain.
 
         Note: The rule must be exactly identical to the one that was added.
         You cannot switch arguments around like you can with the iptables
         CLI tool.
+
         """
         try:
             self.rules.remove(IptablesRule(chain, rule, wrap, top))
         except ValueError:
-            LOG.debug(_("Tried to remove rule that wasn't there:"
-                        " %(chain)r %(rule)r %(wrap)r %(top)r"),
+            LOG.debug(_('Tried to remove rule that was not there:'
+                        ' %(chain)r %(rule)r %(wrap)r %(top)r'),
                       {'chain': chain, 'rule': rule,
                        'top': top, 'wrap': wrap})
 
 
 class IptablesManager(object):
-    """Wrapper for iptables
+    """Wrapper for iptables.
 
     See IptablesTable for some usage docs
 
@@ -205,7 +211,9 @@ class IptablesManager(object):
     For ipv4, the builtin PREROUTING, OUTPUT, and POSTROUTING nat chains are
     wrapped in the same was as the builtin filter chains. Additionally, there's
     a snat chain that is applied after the POSTROUTING chain.
+
     """
+
     def __init__(self, execute=None):
         if not execute:
             self.execute = _execute
@@ -267,11 +275,12 @@ class IptablesManager(object):
 
     @utils.synchronized('iptables', external=True)
     def apply(self):
-        """Apply the current in-memory set of iptables rules
+        """Apply the current in-memory set of iptables rules.
 
         This will blow away any rules left over from previous runs of the
         same component of Nova, and replace them with our current set of
         rules. This happens atomically, thanks to iptables-restore.
+
         """
         s = [('iptables', self.ipv4)]
         if FLAGS.use_ipv6:
@@ -348,63 +357,63 @@ class IptablesManager(object):
 
 
 def metadata_forward():
-    """Create forwarding rule for metadata"""
-    iptables_manager.ipv4['nat'].add_rule("PREROUTING",
-                                          "-s 0.0.0.0/0 -d 169.254.169.254/32 "
-                                          "-p tcp -m tcp --dport 80 -j DNAT "
-                                          "--to-destination %s:%s" % \
+    """Create forwarding rule for metadata."""
+    iptables_manager.ipv4['nat'].add_rule('PREROUTING',
+                                          '-s 0.0.0.0/0 -d 169.254.169.254/32 '
+                                          '-p tcp -m tcp --dport 80 -j DNAT '
+                                          '--to-destination %s:%s' % \
                                           (FLAGS.ec2_dmz_host, FLAGS.ec2_port))
     iptables_manager.apply()
 
 
 def init_host():
-    """Basic networking setup goes here"""
+    """Basic networking setup goes here."""
     # NOTE(devcamcar): Cloud public SNAT entries and the default
     # SNAT rule for outbound traffic.
-    iptables_manager.ipv4['nat'].add_rule("snat",
-                                          "-s %s -j SNAT --to-source %s" % \
+    iptables_manager.ipv4['nat'].add_rule('snat',
+                                          '-s %s -j SNAT --to-source %s' % \
                                            (FLAGS.fixed_range,
                                             FLAGS.routing_source_ip))
 
-    iptables_manager.ipv4['nat'].add_rule("POSTROUTING",
-                                          "-s %s -d %s -j ACCEPT" % \
+    iptables_manager.ipv4['nat'].add_rule('POSTROUTING',
+                                          '-s %s -d %s -j ACCEPT' % \
                                           (FLAGS.fixed_range, FLAGS.dmz_cidr))
 
-    iptables_manager.ipv4['nat'].add_rule("POSTROUTING",
-                                          "-s %(range)s -d %(range)s "
-                                          "-j ACCEPT" % \
+    iptables_manager.ipv4['nat'].add_rule('POSTROUTING',
+                                          '-s %(range)s -d %(range)s '
+                                          '-j ACCEPT' % \
                                           {'range': FLAGS.fixed_range})
     iptables_manager.apply()
 
 
 def bind_floating_ip(floating_ip, check_exit_code=True):
-    """Bind ip to public interface"""
+    """Bind ip to public interface."""
     _execute('sudo', 'ip', 'addr', 'add', floating_ip,
              'dev', FLAGS.public_interface,
              check_exit_code=check_exit_code)
 
 
 def unbind_floating_ip(floating_ip):
-    """Unbind a public ip from public interface"""
+    """Unbind a public ip from public interface."""
     _execute('sudo', 'ip', 'addr', 'del', floating_ip,
              'dev', FLAGS.public_interface)
 
 
 def ensure_metadata_ip():
-    """Sets up local metadata ip"""
+    """Sets up local metadata ip."""
     _execute('sudo', 'ip', 'addr', 'add', '169.254.169.254/32',
              'scope', 'link', 'dev', 'lo', check_exit_code=False)
 
 
 def ensure_vlan_forward(public_ip, port, private_ip):
-    """Sets up forwarding rules for vlan"""
-    iptables_manager.ipv4['filter'].add_rule("FORWARD",
-                                             "-d %s -p udp "
-                                             "--dport 1194 "
-                                             "-j ACCEPT" % private_ip)
-    iptables_manager.ipv4['nat'].add_rule("PREROUTING",
-                                          "-d %s -p udp "
-                                          "--dport %s -j DNAT --to %s:1194" %
+    """Sets up forwarding rules for vlan."""
+    iptables_manager.ipv4['filter'].add_rule('FORWARD',
+                                             '-d %s -p udp '
+                                             '--dport 1194 '
+                                             '-j ACCEPT' % private_ip)
+    iptables_manager.ipv4['nat'].add_rule('PREROUTING',
+                                          '-d %s -p udp '
+                                          '--dport %s -j DNAT --to %s:1194' %
                                           (public_ip, port, private_ip))
     iptables_manager.ipv4['nat'].add_rule("OUTPUT",
                                           "-d %s -p udp "
@@ -414,37 +423,37 @@ def ensure_vlan_forward(public_ip, port, private_ip):
 
 
 def ensure_floating_forward(floating_ip, fixed_ip):
-    """Ensure floating ip forwarding rule"""
+    """Ensure floating ip forwarding rule."""
     for chain, rule in floating_forward_rules(floating_ip, fixed_ip):
         iptables_manager.ipv4['nat'].add_rule(chain, rule)
     iptables_manager.apply()
 
 
 def remove_floating_forward(floating_ip, fixed_ip):
-    """Remove forwarding for floating ip"""
+    """Remove forwarding for floating ip."""
     for chain, rule in floating_forward_rules(floating_ip, fixed_ip):
         iptables_manager.ipv4['nat'].remove_rule(chain, rule)
     iptables_manager.apply()
 
 
 def floating_forward_rules(floating_ip, fixed_ip):
-    return [("PREROUTING", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
-            ("OUTPUT", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
-            ("floating-snat",
-             "-s %s -j SNAT --to %s" % (fixed_ip, floating_ip))]
+    return [('PREROUTING', '-d %s -j DNAT --to %s' % (floating_ip, fixed_ip)),
+            ('OUTPUT', '-d %s -j DNAT --to %s' % (floating_ip, fixed_ip)),
+            ('floating-snat',
+             '-s %s -j SNAT --to %s' % (fixed_ip, floating_ip))]
 
 
 def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
-    """Create a vlan and bridge unless they already exist"""
+    """Create a vlan and bridge unless they already exist."""
     interface = ensure_vlan(vlan_num)
     ensure_bridge(bridge, interface, net_attrs)
 
 
 def ensure_vlan(vlan_num):
-    """Create a vlan unless it already exists"""
-    interface = "vlan%s" % vlan_num
+    """Create a vlan unless it already exists."""
+    interface = 'vlan%s' % vlan_num
     if not _device_exists(interface):
-        LOG.debug(_("Starting VLAN inteface %s"), interface)
+        LOG.debug(_('Starting VLAN inteface %s'), interface)
         _execute('sudo', 'vconfig', 'set_name_type', 'VLAN_PLUS_VID_NO_PAD')
         _execute('sudo', 'vconfig', 'add', FLAGS.vlan_interface, vlan_num)
         _execute('sudo', 'ip', 'link', 'set', interface, 'up')
@@ -464,12 +473,13 @@ def ensure_bridge(bridge, interface, net_attrs=None):
 
     The code will attempt to move any ips that already exist on the interface
     onto the bridge and reset the default gateway if necessary.
+
     """
     if not _device_exists(bridge):
-        LOG.debug(_("Starting Bridge interface for %s"), interface)
+        LOG.debug(_('Starting Bridge interface for %s'), interface)
         _execute('sudo', 'brctl', 'addbr', bridge)
         _execute('sudo', 'brctl', 'setfd', bridge, 0)
-        # _execute("sudo brctl setageing %s 10" % bridge)
+        # _execute('sudo brctl setageing %s 10' % bridge)
         _execute('sudo', 'brctl', 'stp', bridge, 'off')
         _execute('sudo', 'ip', 'link', 'set', bridge, 'up')
     if net_attrs:
@@ -477,15 +487,15 @@ def ensure_bridge(bridge, interface, net_attrs=None):
         #             bridge for it to respond to reqests properly
         suffix = net_attrs['cidr'].rpartition('/')[2]
         out, err = _execute('sudo', 'ip', 'addr', 'add',
-                            "%s/%s" %
+                            '%s/%s' %
                             (net_attrs['gateway'], suffix),
                             'brd',
                             net_attrs['broadcast'],
                             'dev',
                             bridge,
                             check_exit_code=False)
-        if err and err != "RTNETLINK answers: File exists\n":
-            raise exception.Error("Failed to add ip: %s" % err)
+        if err and err != 'RTNETLINK answers: File exists\n':
+            raise exception.Error('Failed to add ip: %s' % err)
         if(FLAGS.use_ipv6):
             _execute('sudo', 'ip', '-f', 'inet6', 'addr',
                      'change', net_attrs['cidr_v6'],
@@ -501,17 +511,17 @@ def ensure_bridge(bridge, interface, net_attrs=None):
         #             interface, so we move any ips to the bridge
         gateway = None
         out, err = _execute('sudo', 'route', '-n')
-        for line in out.split("\n"):
+        for line in out.split('\n'):
             fields = line.split()
-            if fields and fields[0] == "0.0.0.0" and fields[-1] == interface:
+            if fields and fields[0] == '0.0.0.0' and fields[-1] == interface:
                 gateway = fields[1]
                 _execute('sudo', 'route', 'del', 'default', 'gw', gateway,
                          'dev', interface, check_exit_code=False)
         out, err = _execute('sudo', 'ip', 'addr', 'show', 'dev', interface,
                             'scope', 'global')
-        for line in out.split("\n"):
+        for line in out.split('\n'):
             fields = line.split()
-            if fields and fields[0] == "inet":
+            if fields and fields[0] == 'inet':
                 params = fields[1:-1]
                 _execute(*_ip_bridge_cmd('del', params, fields[-1]))
                 _execute(*_ip_bridge_cmd('add', params, bridge))
@@ -522,18 +532,18 @@ def ensure_bridge(bridge, interface, net_attrs=None):
 
         if (err and err != "device %s is already a member of a bridge; can't "
                            "enslave it to bridge %s.\n" % (interface, bridge)):
-            raise exception.Error("Failed to add interface: %s" % err)
+            raise exception.Error('Failed to add interface: %s' % err)
 
-    iptables_manager.ipv4['filter'].add_rule("FORWARD",
-                                             "--in-interface %s -j ACCEPT" % \
+    iptables_manager.ipv4['filter'].add_rule('FORWARD',
+                                             '--in-interface %s -j ACCEPT' % \
                                              bridge)
-    iptables_manager.ipv4['filter'].add_rule("FORWARD",
-                                             "--out-interface %s -j ACCEPT" % \
+    iptables_manager.ipv4['filter'].add_rule('FORWARD',
+                                             '--out-interface %s -j ACCEPT' % \
                                              bridge)
 
 
 def get_dhcp_leases(context, network_id):
-    """Return a network's hosts config in dnsmasq leasefile format"""
+    """Return a network's hosts config in dnsmasq leasefile format."""
     hosts = []
     for fixed_ip_ref in db.network_get_associated_fixed_ips(context,
                                                             network_id):
@@ -542,7 +552,7 @@ def get_dhcp_leases(context, network_id):
 
 
 def get_dhcp_hosts(context, network_id):
-    """Get a string containing a network's hosts config in dhcp-host format"""
+    """Get network's hosts config in dhcp-host format."""
     hosts = []
     for fixed_ip_ref in db.network_get_associated_fixed_ips(context,
                                                             network_id):
@@ -555,10 +565,11 @@ def get_dhcp_hosts(context, network_id):
 #           aren't reloaded.
 @utils.synchronized('dnsmasq_start')
 def update_dhcp(context, network_id):
-    """(Re)starts a dnsmasq server for a given network
+    """(Re)starts a dnsmasq server for a given network.
+
+    If a dnsmasq instance is already running then send a HUP
+    signal causing it to reload, otherwise spawn a new instance.
 
-    if a dnsmasq instance is already running then send a HUP
-    signal causing it to reload, otherwise spawn a new instance
     """
     network_ref = db.network_get(context, network_id)
 
@@ -573,16 +584,16 @@ def update_dhcp(context, network_id):
 
     # if dnsmasq is already running, then tell it to reload
     if pid:
-        out, _err = _execute('cat', "/proc/%d/cmdline" % pid,
+        out, _err = _execute('cat', '/proc/%d/cmdline' % pid,
                              check_exit_code=False)
         if conffile in out:
             try:
                 _execute('sudo', 'kill', '-HUP', pid)
                 return
             except Exception as exc:  # pylint: disable=W0703
-                LOG.debug(_("Hupping dnsmasq threw %s"), exc)
+                LOG.debug(_('Hupping dnsmasq threw %s'), exc)
         else:
-            LOG.debug(_("Pid %d is stale, relaunching dnsmasq"), pid)
+            LOG.debug(_('Pid %d is stale, relaunching dnsmasq'), pid)
 
     # FLAGFILE and DNSMASQ_INTERFACE in env
     env = {'FLAGFILE': FLAGS.dhcpbridge_flagfile,
@@ -625,18 +636,18 @@ interface %s
             try:
                 _execute('sudo', 'kill', pid)
             except Exception as exc:  # pylint: disable=W0703
-                LOG.debug(_("killing radvd threw %s"), exc)
+                LOG.debug(_('killing radvd threw %s'), exc)
         else:
-            LOG.debug(_("Pid %d is stale, relaunching radvd"), pid)
+            LOG.debug(_('Pid %d is stale, relaunching radvd'), pid)
     command = _ra_cmd(network_ref)
     _execute(*command)
     db.network_update(context, network_id,
-                      {"gateway_v6":
+                      {'gateway_v6':
                        utils.get_my_linklocal(network_ref['bridge'])})
 
 
 def _host_lease(fixed_ip_ref):
-    """Return a host string for an address in leasefile format"""
+    """Return a host string for an address in leasefile format."""
     instance_ref = fixed_ip_ref['instance']
     if instance_ref['updated_at']:
         timestamp = instance_ref['updated_at']
@@ -645,39 +656,39 @@ def _host_lease(fixed_ip_ref):
 
     seconds_since_epoch = calendar.timegm(timestamp.utctimetuple())
 
-    return "%d %s %s %s *" % (seconds_since_epoch + FLAGS.dhcp_lease_time,
+    return '%d %s %s %s *' % (seconds_since_epoch + FLAGS.dhcp_lease_time,
                               instance_ref['mac_address'],
                               fixed_ip_ref['address'],
                               instance_ref['hostname'] or '*')
 
 
 def _host_dhcp(fixed_ip_ref):
-    """Return a host string for an address in dhcp-host format"""
+    """Return a host string for an address in dhcp-host format."""
     instance_ref = fixed_ip_ref['instance']
-    return "%s,%s.%s,%s" % (instance_ref['mac_address'],
+    return '%s,%s.%s,%s' % (instance_ref['mac_address'],
                                    instance_ref['hostname'],
                                    FLAGS.dhcp_domain,
                                    fixed_ip_ref['address'])
 
 
 def _execute(*cmd, **kwargs):
-    """Wrapper around utils._execute for fake_network"""
+    """Wrapper around utils._execute for fake_network."""
     if FLAGS.fake_network:
-        LOG.debug("FAKE NET: %s", " ".join(map(str, cmd)))
-        return "fake", 0
+        LOG.debug('FAKE NET: %s', ' '.join(map(str, cmd)))
+        return 'fake', 0
     else:
         return utils.execute(*cmd, **kwargs)
 
 
 def _device_exists(device):
-    """Check if ethernet device exists"""
+    """Check if ethernet device exists."""
     (_out, err) = _execute('ip', 'link', 'show', 'dev', device,
                            check_exit_code=False)
     return not err
 
 
 def _dnsmasq_cmd(net):
-    """Builds dnsmasq command"""
+    """Builds dnsmasq command."""
     cmd = ['sudo', '-E', 'dnsmasq',
            '--strict-order',
            '--bind-interfaces',
@@ -696,7 +707,7 @@ def _dnsmasq_cmd(net):
 
 
 def _ra_cmd(net):
-    """Builds radvd command"""
+    """Builds radvd command."""
     cmd = ['sudo', '-E', 'radvd',
 #           '-u', 'nobody',
            '-C', '%s' % _ra_file(net['bridge'], 'conf'),
@@ -705,44 +716,44 @@ def _ra_cmd(net):
 
 
 def _stop_dnsmasq(network):
-    """Stops the dnsmasq instance for a given network"""
+    """Stops the dnsmasq instance for a given network."""
     pid = _dnsmasq_pid_for(network)
 
     if pid:
         try:
             _execute('sudo', 'kill', '-TERM', pid)
         except Exception as exc:  # pylint: disable=W0703
-            LOG.debug(_("Killing dnsmasq threw %s"), exc)
+            LOG.debug(_('Killing dnsmasq threw %s'), exc)
 
 
 def _dhcp_file(bridge, kind):
-    """Return path to a pid, leases or conf file for a bridge"""
+    """Return path to a pid, leases or conf file for a bridge."""
 
     if not os.path.exists(FLAGS.networks_path):
         os.makedirs(FLAGS.networks_path)
-    return os.path.abspath("%s/nova-%s.%s" % (FLAGS.networks_path,
+    return os.path.abspath('%s/nova-%s.%s' % (FLAGS.networks_path,
                                               bridge,
                                               kind))
 
 
 def _ra_file(bridge, kind):
-    """Return path to a pid or conf file for a bridge"""
+    """Return path to a pid or conf file for a bridge."""
 
     if not os.path.exists(FLAGS.networks_path):
         os.makedirs(FLAGS.networks_path)
-    return os.path.abspath("%s/nova-ra-%s.%s" % (FLAGS.networks_path,
+    return os.path.abspath('%s/nova-ra-%s.%s' % (FLAGS.networks_path,
                                               bridge,
                                               kind))
 
 
 def _dnsmasq_pid_for(bridge):
-    """Returns the pid for prior dnsmasq instance for a bridge
+    """Returns the pid for prior dnsmasq instance for a bridge.
 
-    Returns None if no pid file exists
+    Returns None if no pid file exists.
 
-    If machine has rebooted pid might be incorrect (caller should check)
-    """
+    If machine has rebooted pid might be incorrect (caller should check).
 
+    """
     pid_file = _dhcp_file(bridge, 'pid')
 
     if os.path.exists(pid_file):
@@ -751,13 +762,13 @@ def _dnsmasq_pid_for(bridge):
 
 
 def _ra_pid_for(bridge):
-    """Returns the pid for prior radvd instance for a bridge
+    """Returns the pid for prior radvd instance for a bridge.
 
-    Returns None if no pid file exists
+    Returns None if no pid file exists.
 
-    If machine has rebooted pid might be incorrect (caller should check)
-    """
+    If machine has rebooted pid might be incorrect (caller should check).
 
+    """
     pid_file = _ra_file(bridge, 'pid')
 
     if os.path.exists(pid_file):
@@ -766,7 +777,7 @@ def _ra_pid_for(bridge):
 
 
 def _ip_bridge_cmd(action, params, device):
-    """Build commands to add/del ips to bridges/devices"""
+    """Build commands to add/del ips to bridges/devices."""
 
     cmd = ['sudo', 'ip', 'addr', action]
     cmd.extend(params)
diff --git a/nova/network/manager.py b/nova/network/manager.py
index 0dd7f2360..5a6fdde5a 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -16,8 +16,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-"""
-Network Hosts are responsible for allocating ips and setting up network.
+"""Network Hosts are responsible for allocating ips and setting up network.
 
 There are multiple backend drivers that handle specific types of networking
 topologies.  All of the network commands are issued to a subclass of
@@ -61,6 +60,8 @@ from nova import rpc
 
 
 LOG = logging.getLogger("nova.network.manager")
+
+
 FLAGS = flags.FLAGS
 flags.DEFINE_string('flat_network_bridge', 'br100',
                     'Bridge for simple network instances')
@@ -111,7 +112,9 @@ class NetworkManager(manager.SchedulerDependentManager):
     """Implements common network manager functionality.
 
     This class must be subclassed to support specific topologies.
+
     """
+
     timeout_fixed_ips = True
 
     def __init__(self, network_driver=None, *args, **kwargs):
@@ -122,9 +125,7 @@ class NetworkManager(manager.SchedulerDependentManager):
                                                 *args, **kwargs)
 
     def init_host(self):
-        """Do any initialization that needs to be run if this is a
-        standalone service.
-        """
+        """Do any initialization for a standalone service."""
         self.driver.init_host()
         self.driver.ensure_metadata_ip()
         # Set up networking for the projects for which we're already
@@ -154,11 +155,11 @@ class NetworkManager(manager.SchedulerDependentManager):
                                                                self.host,
                                                                time)
             if num:
-                LOG.debug(_("Dissassociated %s stale fixed ip(s)"), num)
+                LOG.debug(_('Dissassociated %s stale fixed ip(s)'), num)
 
     def set_network_host(self, context, network_id):
         """Safely sets the host of the network."""
-        LOG.debug(_("setting network host"), context=context)
+        LOG.debug(_('setting network host'), context=context)
         host = self.db.network_set_host(context,
                                         network_id,
                                         self.host)
@@ -224,39 +225,39 @@ class NetworkManager(manager.SchedulerDependentManager):
 
     def lease_fixed_ip(self, context, mac, address):
         """Called by dhcp-bridge when ip is leased."""
-        LOG.debug(_("Leasing IP %s"), address, context=context)
+        LOG.debug(_('Leasing IP %s'), address, context=context)
         fixed_ip_ref = self.db.fixed_ip_get_by_address(context, address)
         instance_ref = fixed_ip_ref['instance']
         if not instance_ref:
-            raise exception.Error(_("IP %s leased that isn't associated") %
+            raise exception.Error(_('IP %s leased that is not associated') %
                                   address)
         if instance_ref['mac_address'] != mac:
             inst_addr = instance_ref['mac_address']
-            raise exception.Error(_("IP %(address)s leased to bad"
-                    " mac %(inst_addr)s vs %(mac)s") % locals())
+            raise exception.Error(_('IP %(address)s leased to bad mac'
+                                    ' %(inst_addr)s vs %(mac)s') % locals())
         now = datetime.datetime.utcnow()
         self.db.fixed_ip_update(context,
                                 fixed_ip_ref['address'],
                                 {'leased': True,
                                  'updated_at': now})
         if not fixed_ip_ref['allocated']:
-            LOG.warn(_("IP %s leased that was already deallocated"), address,
+            LOG.warn(_('IP %s leased that was already deallocated'), address,
                      context=context)
 
     def release_fixed_ip(self, context, mac, address):
         """Called by dhcp-bridge when ip is released."""
-        LOG.debug(_("Releasing IP %s"), address, context=context)
+        LOG.debug(_('Releasing IP %s'), address, context=context)
         fixed_ip_ref = self.db.fixed_ip_get_by_address(context, address)
         instance_ref = fixed_ip_ref['instance']
         if not instance_ref:
-            raise exception.Error(_("IP %s released that isn't associated") %
+            raise exception.Error(_('IP %s released that is not associated') %
                                   address)
         if instance_ref['mac_address'] != mac:
             inst_addr = instance_ref['mac_address']
-            raise exception.Error(_("IP %(address)s released from"
-                    " bad mac %(inst_addr)s vs %(mac)s") % locals())
+            raise exception.Error(_('IP %(address)s released from bad mac'
+                                    ' %(inst_addr)s vs %(mac)s') % locals())
         if not fixed_ip_ref['leased']:
-            LOG.warn(_("IP %s released that was not leased"), address,
+            LOG.warn(_('IP %s released that was not leased'), address,
                      context=context)
         self.db.fixed_ip_update(context,
                                 fixed_ip_ref['address'],
@@ -286,8 +287,8 @@ class NetworkManager(manager.SchedulerDependentManager):
                 return self.set_network_host(context, network_ref['id'])
             host = rpc.call(context,
                             FLAGS.network_topic,
-                            {"method": "set_network_host",
-                             "args": {"network_id": network_ref['id']}})
+                            {'method': 'set_network_host',
+                             'args': {'network_id': network_ref['id']}})
         return host
 
     def create_networks(self, context, cidr, num_networks, network_size,
@@ -302,7 +303,7 @@ class NetworkManager(manager.SchedulerDependentManager):
             start = index * network_size
             start_v6 = index * network_size_v6
             significant_bits = 32 - int(math.log(network_size, 2))
-            cidr = "%s/%s" % (fixed_net[start], significant_bits)
+            cidr = '%s/%s' % (fixed_net[start], significant_bits)
             project_net = IPy.IP(cidr)
             net = {}
             net['bridge'] = FLAGS.flat_network_bridge
@@ -313,13 +314,13 @@ class NetworkManager(manager.SchedulerDependentManager):
             net['broadcast'] = str(project_net.broadcast())
             net['dhcp_start'] = str(project_net[2])
             if num_networks > 1:
-                net['label'] = "%s_%d" % (label, count)
+                net['label'] = '%s_%d' % (label, count)
             else:
                 net['label'] = label
             count += 1
 
             if(FLAGS.use_ipv6):
-                cidr_v6 = "%s/%s" % (fixed_net_v6[start_v6],
+                cidr_v6 = '%s/%s' % (fixed_net_v6[start_v6],
                                      significant_bits_v6)
                 net['cidr_v6'] = cidr_v6
                 project_net_v6 = IPy.IP(cidr_v6)
@@ -386,13 +387,13 @@ class FlatManager(NetworkManager):
     Metadata forwarding must be handled by the gateway, and since nova does
     not do any setup in this mode, it must be done manually.  Requests to
     169.254.169.254 port 80 will need to be forwarded to the api server.
+
     """
+
     timeout_fixed_ips = False
 
     def init_host(self):
-        """Do any initialization that needs to be run if this is a
-        standalone service.
-        """
+        """Do any initialization for a standalone service."""
         #Fix for bug 723298 - do not call init_host on superclass
         #Following code has been copied for NetworkManager.init_host
         ctxt = context.get_admin_context()
@@ -433,12 +434,11 @@ class FlatDHCPManager(NetworkManager):
     FlatDHCPManager will start up one dhcp server to give out addresses.
     It never injects network settings into the guest. Otherwise it behaves
     like FlatDHCPManager.
+
     """
 
     def init_host(self):
-        """Do any initialization that needs to be run if this is a
-        standalone service.
-        """
+        """Do any initialization for a standalone service."""
         super(FlatDHCPManager, self).init_host()
         self.driver.metadata_forward()
 
@@ -490,12 +490,11 @@ class VlanManager(NetworkManager):
     A dhcp server is run for each subnet, so each project will have its own.
     For this mode to be useful, each project will need a vpn to access the
     instances in its subnet.
+
     """
 
     def init_host(self):
-        """Do any initialization that needs to be run if this is a
-        standalone service.
-        """
+        """Do any initialization for a standalone service."""
         super(VlanManager, self).init_host()
         self.driver.metadata_forward()
 
@@ -566,7 +565,7 @@ class VlanManager(NetworkManager):
             net['vlan'] = vlan
             net['bridge'] = 'br%s' % vlan
             if(FLAGS.use_ipv6):
-                cidr_v6 = "%s/%s" % (fixed_net_v6[start_v6],
+                cidr_v6 = '%s/%s' % (fixed_net_v6[start_v6],
                                      significant_bits_v6)
                 net['cidr_v6'] = cidr_v6
 
@@ -600,8 +599,8 @@ class VlanManager(NetworkManager):
                 return self.set_network_host(context, network_ref['id'])
             host = rpc.call(context,
                             FLAGS.network_topic,
-                            {"method": "set_network_host",
-                             "args": {"network_id": network_ref['id']}})
+                            {'method': 'set_network_host',
+                             'args': {'network_id': network_ref['id']}})
 
         return host
 
diff --git a/nova/network/vmwareapi_net.py b/nova/network/vmwareapi_net.py
index 9b2db7b8f..bf1070995 100644
--- a/nova/network/vmwareapi_net.py
+++ b/nova/network/vmwareapi_net.py
@@ -15,9 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-"""
-Implements vlans for vmwareapi.
-"""
+"""Implements vlans for vmwareapi."""
 
 from nova import db
 from nova import exception
@@ -27,8 +25,10 @@ from nova import utils
 from nova.virt.vmwareapi_conn import VMWareAPISession
 from nova.virt.vmwareapi import network_utils
 
+
 LOG = logging.getLogger("nova.network.vmwareapi_net")
 
+
 FLAGS = flags.FLAGS
 flags.DEFINE_string('vlan_interface', 'vmnic0',
                     'Physical network adapter name in VMware ESX host for '
@@ -42,10 +42,10 @@ def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
     host_username = FLAGS.vmwareapi_host_username
     host_password = FLAGS.vmwareapi_host_password
     if not host_ip or host_username is None or host_password is None:
-        raise Exception(_("Must specify vmwareapi_host_ip,"
-                        "vmwareapi_host_username "
-                        "and vmwareapi_host_password to use"
-                        "connection_type=vmwareapi"))
+        raise Exception(_('Must specify vmwareapi_host_ip,'
+                          'vmwareapi_host_username '
+                          'and vmwareapi_host_password to use'
+                          'connection_type=vmwareapi'))
     session = VMWareAPISession(host_ip, host_username, host_password,
                                FLAGS.vmwareapi_api_retry_count)
     vlan_interface = FLAGS.vlan_interface
diff --git a/nova/network/xenapi_net.py b/nova/network/xenapi_net.py
index 8c22a7d4b..709ef7f34 100644
--- a/nova/network/xenapi_net.py
+++ b/nova/network/xenapi_net.py
@@ -15,9 +15,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-"""
-Implements vlans, bridges, and iptables rules using linux utilities.
-"""
+"""Implements vlans, bridges, and iptables rules using linux utilities."""
 
 import os
 
@@ -26,22 +24,24 @@ from nova import exception
 from nova import flags
 from nova import log as logging
 from nova import utils
-from nova.virt.xenapi_conn import XenAPISession
+from nova.virt import xenapi_conn
 from nova.virt.xenapi import network_utils
 
+
 LOG = logging.getLogger("nova.xenapi_net")
 
+
 FLAGS = flags.FLAGS
 
 
 def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
     """Create a vlan and bridge unless they already exist."""
     # Open xenapi session
-    LOG.debug("ENTERING ensure_vlan_bridge in xenapi net")
+    LOG.debug('ENTERING ensure_vlan_bridge in xenapi net')
     url = FLAGS.xenapi_connection_url
     username = FLAGS.xenapi_connection_username
     password = FLAGS.xenapi_connection_password
-    session = XenAPISession(url, username, password)
+    session = xenapi_conn.XenAPISession(url, username, password)
     # Check whether bridge already exists
     # Retrieve network whose name_label is "bridge"
     network_ref = network_utils.NetworkHelper.find_network_with_name_label(
@@ -50,14 +50,14 @@ def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
     if network_ref is None:
         # If bridge does not exists
         # 1 - create network
-        description = "network for nova bridge %s" % bridge
+        description = 'network for nova bridge %s' % bridge
         network_rec = {'name_label': bridge,
                        'name_description': description,
                        'other_config': {}}
         network_ref = session.call_xenapi('network.create', network_rec)
         # 2 - find PIF for VLAN
-        expr = 'field "device" = "%s" and \
-                field "VLAN" = "-1"' % FLAGS.vlan_interface
+        expr = "field 'device' = '%s' and \
+                field 'VLAN' = '-1'" % FLAGS.vlan_interface
         pifs = session.call_xenapi('PIF.get_all_records_where', expr)
         pif_ref = None
         # Multiple PIF are ok: we are dealing with a pool