Synnefo » snf-ganeti » ganeti-local

  @param nics: list of tuples (ip, mac, mode, link, network) representing

    for idx, (ip, mac, mode, link, network) in enumerate(nics):

      env["INSTANCE_NIC%d_NETWORK" % idx] = network

    network = nic.network

    hooks_nics.append((ip, mac, mode, link, network))

    #TODO Export network to iallocator so that it chooses a pnode

    #     in a nodegroup that has the desired network connected to

      net = nic.get(constants.INIC_NETWORK, None)

      link = nic.get(constants.NIC_LINK, None)

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

      if net is None or net.lower() == constants.VALUE_NONE:

        net = None

        if nic_mode_req is not None or link is not None:

          raise errors.OpPrereqError("If network is given, no mode or link"

                                     " is allowed to be passed",

                                     errors.ECODE_INVAL)

        # We defer pool operations until later, so that the iallocator has

        # filled in the instance's node(s) dimara

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

          if net is None:

            raise errors.OpPrereqError("if ip=pool, parameter network"

                                       " must be passed too",

                                       errors.ECODE_INVAL)

        elif not netutils.IPAddress.IsValid(ip):

      self.nics.append(objects.NIC(mac=mac, ip=nic_ip,

                                   network=net, nicparams=check_params))

    # Fill in any IPs from IP pools. This must happen here, because we need to

    # know the nic's primary node, as specified by the iallocator

    for idx, nic in enumerate(self.nics):

      net = nic.network

      if net is not None:

        netparams = self.cfg.GetGroupNetParams(net, self.pnode.name)

        if netparams is None:

          raise errors.OpPrereqError("No netparams found for network"

                                     " %s. Propably not connected to"

                                     " node's %s nodegroup" %

                                     (net, self.pnode.name),

                                     errors.ECODE_INVAL)

        self.LogInfo("NIC/%d inherits netparams %s" %

                     (idx, netparams.values()))

        nic.nicparams = dict(netparams)

        if nic.ip is not None:

          filled_params = cluster.SimpleFillNIC(nic.nicparams)

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

            try:

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

            except errors.ReservationError:

              raise errors.OpPrereqError("Unable to get a free IP for NIC %d"

                                         " from the address pool" % idx,

                                         errors.ECODE_STATE)

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

          else:

            try:

              self.cfg.ReserveIp(net, nic.ip, self.proc.GetECId())

            except errors.ReservationError:

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

                                         " or does not belong to network %s" %

                                         (nic.ip, net),

                                         errors.ECODE_NOTUNIQUE)

      else:

        # net is None, ip None or given

        if self.op.conflicts_check:

          _CheckForConflictingIp(self, nic.ip, self.pnode.name)

          "network": nic.network,

def _CheckForConflictingIp(lu, ip, node):

  """In case of conflicting ip raise error.

  @type ip: string

  @param ip: ip address

  @type node: string

  @param node: node name

  """

  (conf_net, conf_netparams) = lu.cfg.CheckIPInNodeGroup(ip, node)

  if conf_net is not None:

    raise errors.OpPrereqError("Conflicting IP found:"

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

                               errors.ECODE_INVAL)

  return (None, None)