Synnefo » snf-ganeti

"""IP pool related commands"""

# W0401: Wildcard import ganeti.cli

# W0614: Unused import %s from wildcard import (since we need cli)

                            network6=opts.network6,

                            mac_prefix=opts.mac_prefix,

                            network_type=opts.network_type,

                            tags=tags)

  SubmitOpCode(op, opts=opts)

                           not opts.no_headers)

  """Show network information.

  @param opts: the command line options selected by the user

  for (name, network, gateway, network6, gateway6,

       mac_prefix, network_type, free_count, reserved_count,

    size = free_count + reserved_count

    ToStdout("Network name: %s", name)

    ToStdout("  subnet: %s", network)

             100 * float(free_count)/float(size))

    ToStdout("  usage map:")

    idx = 0

      ToStdout("     %s %s %d", str(idx).rjust(3), line.ljust(64), idx + 63)

      idx += 64

    ToStdout("         (X) used    (.) free")

                                                ["nic.ips", "nic.networks"],

                                                use_locking=False)

                                    for idx, (ip, net) in enumerate(value)

                                      if net == name)

    else:

      ToStdout("  not used by any instances")

    ToStderr("Please give at least one of the parameters.")

    return 1

  # TODO: add feedback to user, e.g. list the modifications

  SubmitOrSend(op, opts)

import shutil

import itertools

import operator

from ganeti import ssh

from ganeti import utils

  """Wrapper over L{_ExpandItemName} for instance."""

  return _ExpandItemName(cfg.ExpandInstanceName, name, "Instance")

                         network_type, mac_prefix, tags):

  env = dict()

  if name:

    env["NETWORK_NAME"] = name

  if gateway:

    env["NETWORK_GATEWAY"] = gateway

  if network6:

  return env

  args = {

  }

def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,

  }

  if nics:

    nic_count = len(nics)

      if ip is None:

        ip = ""

      env["INSTANCE_NIC%d_IP" % idx] = ip

      env["INSTANCE_NIC%d_MODE" % idx] = mode

      env["INSTANCE_NIC%d_LINK" % idx] = link

      if network:

        if netinfo:

          nobj = objects.Network.FromDict(netinfo)

          if nobj.network:

  return env

def _NICToTuple(lu, nic):

  """Build a tupple of nic information.

  @param nic: nic to convert to hooks tuple

  """

  ip = nic.ip

  mac = nic.mac

  filled_params = cluster.SimpleFillNIC(nic.nicparams)

  mode = filled_params[constants.NIC_MODE]

  link = filled_params[constants.NIC_LINK]

  netinfo = None

    if net_uuid:

      nobj = lu.cfg.GetNetwork(net_uuid)

      netinfo = objects.Network.ToDict(nobj)

def _NICListToTuple(lu, nics):

  """Build a list of nic information tuples.

  """

  hooks_nics = []

  for nic in nics:

    hooks_nics.append(_NICToTuple(lu, nic))

  return hooks_nics

def _BuildInstanceHookEnvByObject(lu, instance, override=None):

  """Builds instance related env variables for hooks from an object.

  """

  nics = []

    nic_mode_req = nic.get(constants.INIC_MODE, None)

    nic_mode = nic_mode_req

    if nic_mode is None or nic_mode == constants.VALUE_AUTO:

                     (idx, netparams.values()))

        nic.nicparams = dict(netparams)

        if nic.ip is not None:

          if nic.ip.lower() == constants.NIC_IP_POOL:

            try:

              nic.ip = self.cfg.GenerateIp(net, self.proc.GetECId())

                                         errors.ECODE_NOTUNIQUE)

        elif new_ip.lower() == constants.NIC_IP_POOL:

          raise errors.OpPrereqError("ip=pool, but no network found",

        else:

          # new net is None

          if self.op.conflicts_check:

                                   nic.nicparams, cluster, pnode)

      return None

      ip = params.ip

      net = params.network

      if net is not None and ip is not None:

    """

    mac = params[constants.INIC_MAC]

    ip = params.get(constants.INIC_IP, None)

    #TODO: not private.filled?? can a nic have no nicparams??

    nicparams = private.filled

      ("nic.%d" % idx,

       "add:mac=%s,ip=%s,mode=%s,link=%s,network=%s" %

       (mac, ip, private.filled[constants.NIC_MODE],

       private.filled[constants.NIC_LINK],

      ])

  @staticmethod

    """

    args = {

      "name": self.op.network_name,

      "gateway": self.op.gateway,

      "network6": self.op.network6,

      "gateway6": self.op.gateway6,

      "network_type": self.op.network_type,

      "tags": self.op.tags,

      }

  def Exec(self, feedback_fn):

    """Add the ip pool to the cluster.

    # Verify that the network is not conncted.

    node_groups = [group.name

                   for group in self.cfg.GetAllNodeGroupsInfo().values()

    if node_groups:

      self.LogWarning("Nework '%s' is connected to the following"

    """

    args = {

      "name": self.op.network_name,

      "gateway": self.gateway,

      "network6": self.network6,

      "gateway6": self.gateway6,

      "network_type": self.network_type,

      "tags": self.tags,

      }

  def BuildHooksNodes(self):

    """Build hooks nodes.

    do_instances = query.NETQ_INST in self.requested_data

    do_groups = do_instances or (query.NETQ_GROUP in self.requested_data)

    do_stats = query.NETQ_STATS in self.requested_data

    network_to_groups = None

    network_to_instances = None

    if do_groups:

      all_groups = lu.cfg.GetAllNodeGroupsInfo()

      network_to_groups = dict((uuid, []) for uuid in self.wanted)

      if do_instances:

        all_instances = lu.cfg.GetAllInstancesInfo()

    ret["GROUP_NAME"] = self.group_name

    ret["GROUP_NETWORK_MODE"] = self.network_mode

    ret["GROUP_NETWORK_LINK"] = self.network_link

    return ret

  def BuildHooksNodes(self):

      instances = [(instance.name, idx, nic.ip)

                   for instance in groupinstances

                   for idx, nic in enumerate(instance.nics)

      if instances:

        self.LogWarning("Following occurences use IPs from network %s"

                        " that is about to connect to nodegroup %s: %s" %

  def BuildHooksEnv(self):

    ret = dict()

    ret["GROUP_NAME"] = self.group_name

    return ret

  def BuildHooksNodes(self):

  @param node: node name

  """

  if conf_net is not None:

    raise errors.OpPrereqError("Conflicting IP found:"

                               " %s <> %s." % (ip, conf_net),

  return result

class ConfigWriter:

  """The interface to the cluster configuration.

      return wraps(view_func)(_decorator)

    return _get_mac_prefix

  @locking.ssynchronized(_config_lock, shared=1)

  def GetNdParams(self, node):

    """Get the node params populated with cluster defaults.

    """

    existing = self._AllMACs()

    return self._temporary_ids.Generate(existing, gen_mac, ec_id)

  @locking.ssynchronized(_config_lock, shared=1)

    as reserved.

    """

    self._temporary_ips.Reserve(ec_id, ('release', address, net_uuid))

  @locking.ssynchronized(_config_lock, shared=1)

    """Give a specified IP address back to an IP pool.

    This is just a wrapper around _UnlockedReleaseIp.

    """

    if net_uuid:

      self._UnlockedReleaseIp(net_uuid, address, ec_id)

        raise errors.ReservationError("Cannot generate IP. Network is full")

      return ("reserve", ip, net_uuid)

    return address

  def _UnlockedReserveIp(self, net_uuid, address, ec_id):

    """Get a list of network names

    """

    return names

  def _UnlockedGetNetwork(self, uuid):

    for net_uuid in nodegroup_info.networks.keys():

      net_info = self._UnlockedGetNetwork(net_uuid)

      pool = network.AddressPool(net_info)

        return (net_info.name, nodegroup_info.networks[net_uuid])

    return (None, None)

      self.reservations = bitarray(self.net.reservations)

    else:

      self.reservations = bitarray(self.network.numhosts)

      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)

      self.ext_reservations.setall(False)

    assert len(self.reservations) == self.network.numhosts

    assert len(self.ext_reservations) == self.network.numhosts

    if address is None:

      return False

    addr = ipaddr.IPAddress(address)

    return int(addr) - int(self.network.network)

    """Write address pools back to the network object"""

    self.net.ext_reservations = self.ext_reservations.to01()

    self.net.reservations = self.reservations.to01()

      self.ext_reservations[idx] = value

    else:

      self.reservations[idx] = value

  def _GetSize(self):

    return 2**(32 - self.network.prefixlen)

    def _iter_free():

      for idx in self.all_reservations.search("0", 64):

        yield str(self.network[idx])

    return _iter_free().next

  def GetExternalReservations(self):

    """

    obj = cls(net)

    for ip in [obj.network[0], obj.network[-1]]:

      obj.Reserve(ip, external=True)

    if obj.net.gateway is not None:

_NETWORK_STATS_FIELDS = {

  "free_count": ("FreeCount", QFT_NUMBER, 0, "How many addresses are free"),

  "map": ("Map", QFT_TEXT, 0, "The actual mapping"),

  }

  """Gets the value of a "stats" field from L{NetworkQueryData}.

  @param field: Field name

  fields.extend([

    (_MakeField(name, title, kind, doc),

     NETQ_CONFIG, 0, _GetItemAttr(name))

    ])

  def _GetLength(getter):

  fields.extend([

    (_MakeField(name, title, kind, doc), NETQ_STATS, 0,

    compat.partial(_GetNetworkStatsField, name, kind))

    ])

  return _PrepareFieldList(fields, [])