Refactor to use 'interface' name where 'bridge' was used

slapos.cfg.example

@@ -9,7 +9,7 @@ buildout = /path/to/buildout/binary
 computer_xml = /opt/slapos/slapos.xml
 log_file = /opt/slapos/slapformat.log
 partition_amount = 200
-bridge_name = br0
+interface_name = br0
 partition_base_name = slappart
 user_base_name = slapuser
 tap_base_name = slaptap

slapos/format.py

@@ -73,24 +73,24 @@ class OS(object):
 class UsageError(Exception):
   pass
 
-class NoAddressOnBridge(Exception):
+class NoAddressOnInterface(Exception):
   """
-  Exception raised if there's not address on the bridge to construct IPv6
+  Exception raised if there's not address on the interface to construct IPv6
   address with.
 
   Attributes:
-    brige: String, the name of the bridge.
+    brige: String, the name of the interface.
   """
 
-  def __init__(self, bridge):
-    super(NoAddressOnBridge, self).__init__(
-      'No IPv6 found on bridge %s to construct IPv6 with.' % (bridge, )
+  def __init__(self, interface):
+    super(NoAddressOnInterface, self).__init__(
+      'No IPv6 found on interface %s to construct IPv6 with.' % (interface, )
     )
 
 class AddressGenerationError(Exception):
   """
   Exception raised if the generation of an IPv6 based on the prefix obtained
-  from the bridge failed.
+  from the interface failed.
 
   Attributes:
     addr: String, the invalid address the exception is raised for.
@@ -161,15 +161,15 @@ class Computer(object):
   instance_root = None
   software_root = None
 
-  def __init__(self, reference, bridge=None, addr=None, netmask=None,
+  def __init__(self, reference, interface=None, addr=None, netmask=None,
     ipv6_interface=None, software_user='slapsoft'):
     """
     Attributes:
       reference: String, the reference of the computer.
-      bridge: String, if it has one, the name of the computer's bridge.
+      interface: String, the name of the computer's used interface.
     """
     self.reference = str(reference)
-    self.bridge = bridge
+    self.interface = interface
     self.partition_list = []
     self.address = addr
     self.netmask = netmask
@@ -177,17 +177,17 @@ class Computer(object):
     self.software_user = software_user
 
   def __getinitargs__(self):
-    return (self.reference, self.bridge)
+    return (self.reference, self.interface)
 
   def getAddress(self):
     """
-    Return a list of the bridge address not attributed to any partition, (which
+    Return a list of the interface address not attributed to any partition, (which
     are therefore free for the computer itself).
 
     Returns:
-      False if the bridge isn't available, else the list of the free addresses.
+      False if the interface isn't available, else the list of the free addresses.
     """
-    if self.bridge is None:
+    if self.interface is None:
       return dict(addr=self.address, netmask=self.netmask)
 
     computer_partition_address_list = []
@@ -195,8 +195,8 @@ class Computer(object):
       for address in partition.address_list:
         if netaddr.valid_ipv6(address['addr']):
           computer_partition_address_list.append(address['addr'])
-    # Going through addresses of the computer's bridge interface
-    for address_dict in self.bridge.getGlobalScopeAddressList():
+    # Going through addresses of the computer's interface interface
+    for address_dict in self.interface.getGlobalScopeAddressList():
       # Comparing with computer's partition addresses
       if address_dict['addr'] not in computer_partition_address_list:
         return address_dict
@@ -204,8 +204,8 @@ class Computer(object):
     # all addresses on interface are for partition, so lets add new one
     computer_tap = Tap('compdummy')
     computer_tap.createWithOwner(User('root'), attach_to_tap=True)
-    self.bridge.addTap(computer_tap)
-    return self.bridge.addAddr()
+    self.interface.addTap(computer_tap)
+    return self.interface.addAddr()
 
   def send(self, config):
     """
@@ -296,7 +296,7 @@ class Computer(object):
     Construct the computer object as it is.
     """
     if alter_network and self.address is not None:
-      self.bridge.addAddr(self.address, self.netmask)
+      self.interface.addAddr(self.address, self.netmask)
 
     for path in self.instance_root, self.software_root: 
       if not os.path.exists(path):
@@ -330,13 +330,13 @@ class Computer(object):
 
         if alter_network:
           # In case it has to be  attached to the TAP network device, only one
-          # is necessary for the bridge to assert carrier
-          if self.bridge.attach_to_tap and partition_index == 0:
+          # is necessary for the interface to assert carrier
+          if self.interface.attach_to_tap and partition_index == 0:
             partition.tap.createWithOwner(owner, attach_to_tap=True)
           else:
             partition.tap.createWithOwner(owner)
 
-          self.bridge.addTap(partition.tap)
+          self.interface.addTap(partition.tap)
 
         # Reconstructing partition's directory
         partition.createPath(alter_user)
@@ -347,8 +347,8 @@ class Computer(object):
         #  * local IPv4, took from slapformat:ipv4_local_network
         if len(partition.address_list) == 0:
           # regenerate
-          partition.address_list.append(self.bridge.addIPv4LocalAddress())
-          partition.address_list.append(self.bridge.addAddr())
+          partition.address_list.append(self.interface.addIPv4LocalAddress())
+          partition.address_list.append(self.interface.addAddr())
         elif alter_network:
           # regenerate list of addresses
           old_partition_address_list = partition.address_list
@@ -363,16 +363,16 @@ class Computer(object):
             raise ValueError('Not valid ipv6 addresses loaded')
           for address in old_partition_address_list:
             if netaddr.valid_ipv6(address['addr']):
-              partition.address_list.append(self.bridge.addAddr(
+              partition.address_list.append(self.interface.addAddr(
                 address['addr'],
                 address['netmask']))
             elif netaddr.valid_ipv4(address['addr']):
-              partition.address_list.append(self.bridge.addIPv4LocalAddress(
+              partition.address_list.append(self.interface.addIPv4LocalAddress(
                 address['addr']))
             else:
               raise ValueError('Address %r is incorrect' % address['addr'])
     finally:
-      if alter_network and self.bridge.attach_to_tap:
+      if alter_network and self.interface.attach_to_tap:
         try:
           self.partition_list[0].tap.detach()
         except IndexError:
@@ -513,6 +513,7 @@ class Tap(object):
     there is  carrier, e.g.  the network  cable is plugged  into a  switch for
     example).
 
+    In case of bridge:
     In order  to be able to check  the uniqueness of IPv6  address assigned to
     the bridge, the network interface  must be up from an administrative *and*
     operational point of view.
@@ -574,20 +575,20 @@ class Tap(object):
     if attach_to_tap:
       threading.Thread(target=self.attach).start()
 
-class Bridge(object):
-  "Bridge represent a bridge on the system"
+class Interface(object):
+  "Interface represent a interface on the system"
 
   def __init__(self, name, ipv4_local_network, ipv6_interface=None):
     """
     Attributes:
-        name: String, the name of the bridge
+        name: String, the name of the interface
     """
 
     self.name = str(name)
     self.ipv4_local_network = ipv4_local_network
     self.ipv6_interface = ipv6_interface
 
-    # Attach to TAP  network interface, only if the  bridge interface does not
+    # Attach to TAP  network interface, only if the  interface interface does not
     # report carrier
     _, result = callAndRead(['ip', 'addr', 'list', self.name])
     self.attach_to_tap = 'DOWN' in result.split('\n', 1)[0]
@@ -630,19 +631,19 @@ class Bridge(object):
     return address_list
 
   def getInterfaceList(self):
-    """Returns list of interfaces already present on bridge"""
+    """Returns list of interfaces already present on interface"""
     interface_list = []
     _, result = callAndRead(['brctl', 'show'])
-    in_bridge = False
+    in_interface = False
     for line in result.split('\n'):
       if len(line.split()) > 1:
         if self.name in line:
           interface_list.append(line.split()[-1])
-          in_bridge = True
+          in_interface = True
           continue
-        if in_bridge:
+        if in_interface:
           break
-      elif in_bridge:
+      elif in_interface:
         if line.strip():
           interface_list.append(line.strip())
 
@@ -659,7 +660,7 @@ class Bridge(object):
       callAndRead(['brctl', 'addif', self.name, tap.name])
 
   def _addSystemAddress(self, address, netmask, ipv6=True):
-    """Adds system address to bridge
+    """Adds system address to interface
     
     Returns True if address was added successfully.
 
@@ -739,16 +740,16 @@ class Bridge(object):
 
   def addAddr(self, addr = None, netmask = None):
     """
-    Adds IP address to bridge.
+    Adds IP address to interface.
 
-    If addr is specified and exists already on bridge does nothing.
+    If addr is specified and exists already on interface does nothing.
 
-    If addr is specified and does not exists on bridge, tries to add given
+    If addr is specified and does not exists on interface, tries to add given
     address. If it is not possible (ex. because network changed) calculates new
     address.
 
     Args:
-      addr: Wished address to be added to bridge.
+      addr: Wished address to be added to interface.
       netmask: Wished netmask to be used.
 
     Returns:
@@ -756,33 +757,33 @@ class Bridge(object):
 
     Raises:
       AddressGenerationError: Couldn't construct valid address with existing
-          one's on the bridge.
-      NoAddressOnBridge: There's no address on the bridge to construct
+          one's on the interface.
+      NoAddressOnInterface: There's no address on the interface to construct
           an address with.
     """
-    # Getting one address of the bridge as base of the next addresses
+    # Getting one address of the interface as base of the next addresses
     if self.ipv6_interface:
       interface_name = self.ipv6_interface
     else:
       interface_name = self.name
-    bridge_addr_list = self.getGlobalScopeAddressList()
+    interface_addr_list = self.getGlobalScopeAddressList()
 
     # No address found
-    if len(bridge_addr_list) == 0:
-      raise NoAddressOnBridge(interface_name)
-    address_dict = bridge_addr_list[0]
+    if len(interface_addr_list) == 0:
+      raise NoAddressOnInterface(interface_name)
+    address_dict = interface_addr_list[0]
 
     if addr is not None:
-      if dict(addr=addr, netmask=netmask) in bridge_addr_list:
+      if dict(addr=addr, netmask=netmask) in interface_addr_list:
         # confirmed to be configured
         return dict(addr=addr, netmask=netmask)
       if netmask == address_dict['netmask']:
         # same netmask, so there is a chance to add good one
-        bridge_network = netaddr.ip.IPNetwork('%s/%s' % (address_dict['addr'],
+        interface_network = netaddr.ip.IPNetwork('%s/%s' % (address_dict['addr'],
           netmaskToPrefixIPv6(address_dict['netmask'])))
         requested_network = netaddr.ip.IPNetwork('%s/%s' % (addr,
           netmaskToPrefixIPv6(netmask)))
-        if bridge_network.network == requested_network.network:
+        if interface_network.network == requested_network.network:
           # same network, try to add
           if self._addSystemAddress(addr, netmask):
             # succeed, return it
@@ -871,19 +872,19 @@ def run(config):
       'software_user': 'slapsoft',
     })
     computer_definition.read(filepath)
-    bridge = None
+    interface = None
     address = None
     netmask = None
     if computer_definition.has_option('computer', 'address'):
       address, netmask = computer_definition.get('computer',
         'address').split('/')
-    if config.alter_network and config.bridge_name is not None \
+    if config.alter_network and config.interface_name is not None \
         and config.ipv4_local_network is not None:
-      bridge = Bridge(config.bridge_name, config.ipv4_local_network,
+      interface = Interface(config.interface_name, config.ipv4_local_network,
         config.ipv6_interface)
     computer = Computer(
         reference=config.computer_id,
-        bridge=bridge,
+        interface=interface,
         addr=address,
         netmask=netmask,
         ipv6_interface=config.ipv6_interface,
@@ -914,8 +915,8 @@ def run(config):
         config.computer_xml, ))
       computer = Computer.load(config.computer_xml,
         reference=config.computer_id, ipv6_interface=config.ipv6_interface)
-      # Connect to the bridge interface defined by the configuration
-      computer.bridge = Bridge(config.bridge_name, config.ipv4_local_network,
+      # Connect to the interface defined by the configuration
+      computer.interface = Interface(config.interface_name, config.ipv4_local_network,
           config.ipv6_interface)
     else:
       # If no pre-existent configuration found, creating a new computer object
@@ -923,7 +924,7 @@ def run(config):
         config.computer_id, ))
       computer = Computer(
         reference=config.computer_id,
-        bridge=Bridge(config.bridge_name, config.ipv4_local_network,
+        interface=Interface(config.interface_name, config.ipv4_local_network,
           config.ipv6_interface),
         addr=None,
         netmask=None,
@@ -1043,7 +1044,7 @@ class Config(object):
           setattr(self, key, configuration_dict[key])
 
     # setup some nones
-    for parameter in ['bridge_name', 'partition_base_name', 'user_base_name',
+    for parameter in ['interface_name', 'partition_base_name', 'user_base_name',
         'tap_base_name', 'ipv4_local_network', 'ipv6_interface']:
       if getattr(self, parameter, None) is None:
         setattr(self, parameter, None)
@@ -1147,12 +1148,12 @@ def main(*args):
       else:
         return 0, ''
     callAndRead = dry_callAndRead
-    real_addSystemAddress = Bridge._addSystemAddress
+    real_addSystemAddress = Interface._addSystemAddress
     def fake_addSystemAddress(*args, **kw):
       real_addSystemAddress(*args, **kw)
       # Fake success
       return True
-    Bridge._addSystemAddress = fake_addSystemAddress
+    Interface._addSystemAddress = fake_addSystemAddress
     def fake_getpwnam(user):
       class result(object):
         pw_uid = 12345