Synnefo » snf-ganeti » ganeti-local

    # cheap checks, mostly valid constants given

    if self.op.hypervisor is None:

      self.op.hypervisor = self.cfg.GetHypervisorType()

    cluster = self.cfg.GetClusterInfo()

    enabled_hvs = cluster.enabled_hypervisors

    if self.op.hypervisor not in enabled_hvs:

      raise errors.OpPrereqError("Selected hypervisor (%s) not enabled in the"

                                 " cluster (%s)" % (self.op.hypervisor,

                                  ",".join(enabled_hvs)),

                                 errors.ECODE_STATE)

    # check hypervisor parameter syntax (locally)

    utils.ForceDictType(self.op.hvparams, constants.HVS_PARAMETER_TYPES)

    filled_hvp = objects.FillDict(cluster.hvparams[self.op.hypervisor],

                                  self.op.hvparams)

    hv_type = hypervisor.GetHypervisor(self.op.hypervisor)

    hv_type.CheckParameterSyntax(filled_hvp)

    self.hv_full = filled_hvp

    # check that we don't specify global parameters on an instance

    _CheckGlobalHvParams(self.op.hvparams)

    # fill and remember the beparams dict

    utils.ForceDictType(self.op.beparams, constants.BES_PARAMETER_TYPES)

    self.be_full = objects.FillDict(cluster.beparams[constants.PP_DEFAULT],

                                    self.op.beparams)

    #### instance parameters check

    # NIC buildup

    self.nics = []

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

      nic_mode_req = nic.get("mode", None)

      nic_mode = nic_mode_req

      if nic_mode is None:

        nic_mode = cluster.nicparams[constants.PP_DEFAULT][constants.NIC_MODE]

      # in routed mode, for the first nic, the default ip is 'auto'

      if nic_mode == constants.NIC_MODE_ROUTED and idx == 0:

        default_ip_mode = constants.VALUE_AUTO

      else:

        default_ip_mode = constants.VALUE_NONE

      # ip validity checks

      ip = nic.get("ip", default_ip_mode)

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

        nic_ip = None

      elif ip.lower() == constants.VALUE_AUTO:

        if not self.op.name_check:

          raise errors.OpPrereqError("IP address set to auto but name checks"

                                     " have been skipped. Aborting.",

                                     errors.ECODE_INVAL)

        nic_ip = self.hostname1.ip

      else:

        if not utils.IsValidIP(ip):

          raise errors.OpPrereqError("Given IP address '%s' doesn't look"

                                     " like a valid IP" % ip,

                                     errors.ECODE_INVAL)

        nic_ip = ip

      # TODO: check the ip address for uniqueness

      if nic_mode == constants.NIC_MODE_ROUTED and not nic_ip:

        raise errors.OpPrereqError("Routed nic mode requires an ip address",

                                   errors.ECODE_INVAL)

      # MAC address verification

      mac = nic.get("mac", constants.VALUE_AUTO)

      if mac not in (constants.VALUE_AUTO, constants.VALUE_GENERATE):

        mac = utils.NormalizeAndValidateMac(mac)

        try:

          self.cfg.ReserveMAC(mac, self.proc.GetECId())

        except errors.ReservationError:

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

                                     " in cluster" % mac,

                                     errors.ECODE_NOTUNIQUE)

      # bridge verification

      bridge = nic.get("bridge", None)

      link = nic.get("link", None)

      if bridge and link:

        raise errors.OpPrereqError("Cannot pass 'bridge' and 'link'"

                                   " at the same time", errors.ECODE_INVAL)

      elif bridge and nic_mode == constants.NIC_MODE_ROUTED:

        raise errors.OpPrereqError("Cannot pass 'bridge' on a routed nic",

                                   errors.ECODE_INVAL)

      elif bridge:

        link = bridge

      nicparams = {}

      if nic_mode_req:

        nicparams[constants.NIC_MODE] = nic_mode_req

      if link:

        nicparams[constants.NIC_LINK] = link

      check_params = objects.FillDict(cluster.nicparams[constants.PP_DEFAULT],

                                      nicparams)

      objects.NIC.CheckParameterSyntax(check_params)

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

    # disk checks/pre-build

    self.disks = []

    for disk in self.op.disks:

      mode = disk.get("mode", constants.DISK_RDWR)

      if mode not in constants.DISK_ACCESS_SET:

        raise errors.OpPrereqError("Invalid disk access mode '%s'" %

                                   mode, errors.ECODE_INVAL)

      size = disk.get("size", None)

      if size is None:

        raise errors.OpPrereqError("Missing disk size", errors.ECODE_INVAL)

      try:

        size = int(size)

      except (TypeError, ValueError):

        raise errors.OpPrereqError("Invalid disk size '%s'" % size,

                                   errors.ECODE_INVAL)

      new_disk = {"size": size, "mode": mode}

      if "adopt" in disk:

        new_disk["adopt"] = disk["adopt"]

      self.disks.append(new_disk)