Synnefo » snf-ganeti » ganeti-local

      req_net = params.get(constants.INIC_NETWORK, None)

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

      mode = params.get(constants.NIC_MODE, None)

      if req_net is not None:

        if req_net.lower() == constants.VALUE_NONE:

          params[constants.INIC_NETWORK] = None

          req_net = None

        elif link is not None or mode is not None:

          raise errors.OpPrereqError("If network is given"

                                     " mode or link should not",

                                     errors.ECODE_INVAL)

      if ip is not None:

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

          params[constants.INIC_IP] = None

        else:

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

            if op == constants.DDM_ADD and req_net is None:

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

                                         " cannot be none",

                                         errors.ECODE_INVAL)

          else:

            if not netutils.IPAddress.IsValid(ip):

              raise errors.OpPrereqError("Invalid IP address '%s'" % ip,

                                         errors.ECODE_INVAL)

        nics.append((nic.ip, nic.mac, mode, link, nic.network))

  def _PrepareNicModification(self, params, private, old_ip, old_net,

                              old_params, cluster, pnode):

    req_link = update_params_dict.get(constants.NIC_LINK, None)

    req_mode = update_params_dict.get(constants.NIC_MODE, None)

    new_net = params.get(constants.INIC_NETWORK, old_net)

    if new_net is not None:

      netparams = self.cfg.GetGroupNetParams(new_net, pnode)

      if netparams is None:

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

                                   " %s, propably not connected." % new_net,

                                   errors.ECODE_INVAL)

      new_params = dict(netparams)

    else:

      new_params = _GetUpdatedParams(old_params, update_params_dict)

    elif new_net != old_net:

      def get_net_prefix(net):

        if net:

          uuid = self.cfg.LookupNetwork(net)

          if uuid:

            nobj = self.cfg.GetNetwork(uuid)

            return nobj.mac_prefix

        return None

      new_prefix = get_net_prefix(new_net)

      old_prefix = get_net_prefix(old_net)

      if old_prefix != new_prefix:

        params[constants.INIC_MAC] = \

          self.cfg.GenerateMAC(self.proc.GetECId())

    #if there is a change in nic-network configuration

    new_ip = params.get(constants.INIC_IP, old_ip)

    if (new_ip, new_net) != (old_ip, old_net):

      if new_ip:

        if new_net:

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

            try:

              new_ip = self.cfg.GenerateIp(new_net, self.proc.GetECId())

            except errors.ReservationError:

              raise errors.OpPrereqError("Unable to get a free IP"

                                        " from the address pool",

                                         errors.ECODE_STATE)

            self.LogInfo("Chose IP %s from pool %s", new_ip, new_net)

            params[constants.INIC_IP] = new_ip

          elif new_ip != old_ip or new_net != old_net:

            try:

              self.LogInfo("Reserving IP %s in pool %s", new_ip, new_net)

              self.cfg.ReserveIp(new_net, new_ip, self.proc.GetECId())

            except errors.ReservationError:

              raise errors.OpPrereqError("IP %s not available in network %s" %

                                         (new_ip, new_net),

                                         errors.ECODE_NOTUNIQUE)

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

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

                                     ECODEE_INVAL)

        else:

          # new net is None

          if self.op.conflicts_check:

            _CheckForConflictingIp(self, new_ip, pnode)

      if old_ip:

        if old_net:

          try:

            self.cfg.ReleaseIp(old_net, old_ip, self.proc.GetECId())

          except errors.AddressPoolError:

            logging.warning("Release IP %s not contained in network %s",

                            old_ip, old_net)

    # there are no changes in (net, ip) tuple

    elif (old_net is not None and

          (req_link is not None or req_mode is not None)):

      raise errors.OpPrereqError("Not allowed to change link or mode of"

                                 " a NIC that is connected to a network.",

                                 errors.ECODE_INVAL)

      self._PrepareNicModification(params, private, None, None,

                                   {}, cluster, pnode)

      self._PrepareNicModification(params, private, nic.ip, nic.network,

    def _PrepareNicRemove(_, params, private):

      ip = params.ip

      net = params.network

      if net is not None and ip is not None:

        self.cfg.ReleaseIp(net, ip, self.proc.GetECId())

                       _PrepareNicCreate, _PrepareNicMod, _PrepareNicRemove)

    network = params.get(constants.INIC_NETWORK, None)

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

    nicparams = private.filled

    return (objects.NIC(mac=mac, ip=ip, network=network, nicparams=nicparams), [

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

       private.filled[constants.NIC_LINK],

       network)),

    for key in [constants.INIC_MAC, constants.INIC_IP, constants.INIC_NETWORK]:

    if private.filled:

      nic.nicparams = private.filled

      for (key, val) in nic.nicparams.items():

    self.cfg.Update(instance, feedback_fn, self.proc.GetECId())