cmdlib: Node whitelist support for allocation request

[ganeti-local] / lib / network.py

diff --git a/lib/network.py b/lib/network.py
index 96ed654..cc3bfd6 100644 (file)
--- a/lib/network.py
+++ b/lib/network.py
@@ -1,7 +1,7 @@
 #
 #
 
-# Copyright (C) 2011 Google Inc.
+# Copyright (C) 2011, 2012 Google Inc.
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -19,7 +19,7 @@
 # 02110-1301, USA.
 
 
-"""Ip address pool management functions.
+"""IP address pool management functions.
 
 """
 
@@ -29,15 +29,19 @@ from bitarray import bitarray
 
 from ganeti import errors
 
+
 class AddressPool(object):
-  """Address pool class, wrapping an objects.Network object
+  """Address pool class, wrapping an C{objects.Network} object.
 
   This class provides methods to manipulate address pools, backed by
   L{objects.Network} objects.
 
   """
+  FREE = bitarray("0")
+  RESERVED = bitarray("1")
+
   def __init__(self, network):
-    """Initialize a new IPv4 address pool from an objects.Network object
+    """Initialize a new IPv4 address pool from an L{objects.Network} object.
 
     @type network: L{objects.Network}
     @param network: the network object from which the pool will be generated
@@ -63,18 +67,20 @@ class AddressPool(object):
       self.reservations = bitarray(self.net.reservations)
     else:
       self.reservations = bitarray(self.network.numhosts)
+      # pylint: disable=E1103
       self.reservations.setall(False)
 
     if self.net.ext_reservations:
       self.ext_reservations = bitarray(self.net.ext_reservations)
     else:
       self.ext_reservations = bitarray(self.network.numhosts)
+      # pylint: disable=E1103
       self.ext_reservations.setall(False)
 
     assert len(self.reservations) == self.network.numhosts
     assert len(self.ext_reservations) == self.network.numhosts
 
-  def _Contains(self, address):
+  def Contains(self, address):
     if address is None:
       return False
     addr = ipaddr.IPAddress(address)
@@ -90,8 +96,11 @@ class AddressPool(object):
 
     return int(addr) - int(self.network.network)
 
-  def _Update(self):
-    """Write address pools back to the network object"""
+  def Update(self):
+    """Write address pools back to the network object.
+
+    """
+    # pylint: disable=E1103
     self.net.ext_reservations = self.ext_reservations.to01()
     self.net.reservations = self.reservations.to01()
 
@@ -101,14 +110,16 @@ class AddressPool(object):
       self.ext_reservations[idx] = value
     else:
       self.reservations[idx] = value
-    self._Update()
+    self.Update()
 
   def _GetSize(self):
-    return 2**(32 - self.network.prefixlen)
+    return 2 ** (32 - self.network.prefixlen)
 
   @property
   def all_reservations(self):
-    """Return a combined map of internal + external reservations."""
+    """Return a combined map of internal and external reservations.
+
+    """
     return (self.reservations | self.ext_reservations)
 
   def Validate(self):
@@ -128,38 +139,54 @@ class AddressPool(object):
     return True
 
   def IsFull(self):
-    """Check whether the network is full"""
+    """Check whether the network is full.
+
+    """
     return self.all_reservations.all()
 
   def GetReservedCount(self):
-    """Get the count of reserved addresses"""
+    """Get the count of reserved addresses.
+
+    """
     return self.all_reservations.count(True)
 
   def GetFreeCount(self):
-    """Get the count of unused addresses"""
+    """Get the count of unused addresses.
+
+    """
     return self.all_reservations.count(False)
 
   def GetMap(self):
-    """Return a textual representation of the network's occupation status."""
+    """Return a textual representation of the network's occupation status.
+
+    """
     return self.all_reservations.to01().replace("1", "X").replace("0", ".")
 
   def IsReserved(self, address):
-    """Checks if the given IP is reserved"""
+    """Checks if the given IP is reserved.
+
+    """
     idx = self._GetAddrIndex(address)
     return self.all_reservations[idx]
 
   def Reserve(self, address, external=False):
-    """Mark an address as used."""
+    """Mark an address as used.
+
+    """
     if self.IsReserved(address):
       raise errors.AddressPoolError("%s is already reserved" % address)
     self._Mark(address, external=external)
 
   def Release(self, address, external=False):
-    """Release a given address reservation."""
+    """Release a given address reservation.
+
+    """
     self._Mark(address, value=False, external=external)
 
   def GetFreeAddress(self):
-    """Returns the first available address."""
+    """Returns the first available address.
+
+    """
     if self.IsFull():
       raise errors.AddressPoolError("%s is full" % self.network)
 
@@ -169,27 +196,34 @@ class AddressPool(object):
     return address
 
   def GenerateFree(self):
-    """A generator for free addresses."""
-    def _iter_free():
-      for idx in self.all_reservations.search("0", 64):
-        yield str(self.network[idx])
+    """Returns the first free address of the network.
 
-    return _iter_free().next
+    @raise errors.AddressPoolError: Pool is full
+
+    """
+    idx = self.all_reservations.search(self.FREE, 1)
+    if idx:
+      return str(self.network[idx[0]])
+    else:
+      raise errors.AddressPoolError("%s is full" % self.network)
 
   def GetExternalReservations(self):
-    """Returns a list of all externally reserved addresses"""
-    idxs = self.ext_reservations.search("1")
+    """Returns a list of all externally reserved addresses.
+
+    """
+    # pylint: disable=E1103
+    idxs = self.ext_reservations.search(self.RESERVED)
     return [str(self.network[idx]) for idx in idxs]
 
   @classmethod
   def InitializeNetwork(cls, net):
-    """Initialize an L{objects.Network} object
+    """Initialize an L{objects.Network} object.
 
-    Reserve the network, broadcast and gateway IPs
+    Reserve the network, broadcast and gateway IP addresses.
 
     """
     obj = cls(net)
-    obj._Update()
+    obj.Update()
     for ip in [obj.network[0], obj.network[-1]]:
       obj.Reserve(ip, external=True)
     if obj.net.gateway is not None: