Synnefo » snf-ganeti

bitfields, the length of the network size each:

``reservations``

``external reservations``

  This field holds all IP addresses that are manually reserved by the

The bitfields are implemented using the python-bitarray package for

space efficiency and their binary value stored base64-encoded for JSON

compatibility. This approach gives relatively compact representations

even for large IPv4 networks (e.g. /20).

Helper ConfigWriter methods provide free IP address generation and

reservation, using a TemporaryReservationManager.

We also introduce a new ``ip`` address value, ``constants.NIC_IP_POOL``,

that specifies that a given NIC's IP address should be obtained using

for NICs belonging to a network. A NIC's IP address can also be

specified manually, as long as it is contained in the network the NIC

Hooks

            self.LogInfo("Chose IP %s from network %s", nic.ip, nobj.name)

          else:

            try:

            except errors.ReservationError:

              raise errors.OpPrereqError("IP address %s already in use"

                                         " or does not belong to network %s" %

        # Reserve new IP if in the new network if any

        elif new_net_uuid:

          try:

            self.LogInfo("Reserving IP %s in network %s",

                         new_ip, new_net_obj.name)

          except errors.ReservationError:

    if self.op.add_reserved_ips:

      for ip in self.op.add_reserved_ips:

        try:

        except errors.AddressPoolError, err:

          self.LogWarning("Cannot reserve IP address %s: %s", ip, err)

          self.LogWarning("Cannot unreserve Gateway's IP")

          continue

        try:

        except errors.AddressPoolError, err:

          self.LogWarning("Cannot release IP address %s: %s", ip, err)

    _, address, _ = self._temporary_ips.Generate([], gen_one, ec_id)

    return address

    """Reserve a given IPv4 address for use by an instance.

    """

    pool = network.AddressPool(nobj)

    try:

      isreserved = pool.IsReserved(address)

    except errors.AddressPoolError:

      raise errors.ReservationError("IP address not in network")

    if isreserved:

      raise errors.ReservationError("IP address already in use")

    return self._temporary_ips.Reserve(ec_id,

                                       (constants.RESERVE_ACTION,

                                        address, net_uuid))

  @locking.ssynchronized(_config_lock, shared=1)

    """Reserve a given IPv4 address for use by an instance.

    """

    if net_uuid:

  @locking.ssynchronized(_config_lock, shared=1)

  def ReserveLV(self, lv_name, ec_id):

  def Validate(self):

    assert len(self.reservations) == self._GetSize()

    assert len(self.ext_reservations) == self._GetSize()

    if self.gateway is not None:

      assert self.gateway in self.network

    """

    return self.all_reservations.to01().replace("1", "X").replace("0", ".")

    """Checks if the given IP is reserved.

    """

    idx = self._GetAddrIndex(address)

  def Reserve(self, address, external=False):

    """Mark an address as used.

    """

    self._Mark(address, external=external)

  def Release(self, address, external=False):

    """Release a given address reservation.

    """

    self._Mark(address, value=False, external=external)

  def GetFreeAddress(self):

    connected to the said network. ``--no-conflicts-check`` can be used

    to override this check. The special value **pool** causes Ganeti to

    select an IP from the the network the NIC is or will be connected to.

mode

    specifies the connection mode for this NIC: routed, bridged or

from ganeti import config

from ganeti import constants

from ganeti import objects

import mocks

    if mac is None:

      mac = "aa:00:00:aa:%02x:%02x" % (nic_id / 0xff, nic_id % 0xff)

    if isinstance(network, objects.Network):

      network = network.uuid

    if nicparams is None:

      nicparams = {}