Synnefo » snf-ganeti » ganeti-local

  # Note: this needs to be kept in sync with adding of disks in

  # LUSetInstanceParams

  _OP_REQP = ["instance_name"]

  def CheckArguments(self):

    if not hasattr(self.op, 'nics'):

      self.op.nics = []

    if not hasattr(self.op, 'disks'):

      self.op.disks = []

    if not hasattr(self.op, 'beparams'):

      self.op.beparams = {}

    if not hasattr(self.op, 'hvparams'):

      self.op.hvparams = {}

    self.op.force = getattr(self.op, "force", False)

    if not (self.op.nics or self.op.disks or

            self.op.hvparams or self.op.beparams):

      raise errors.OpPrereqError("No changes submitted")

    for item in (constants.BE_MEMORY, constants.BE_VCPUS):

      val = self.op.beparams.get(item, None)

      if val is not None:

        try:

          val = int(val)

        except ValueError, err:

          raise errors.OpPrereqError("Invalid %s size: %s" % (item, str(err)))

        self.op.beparams[item] = val

    # Disk validation

    disk_addremove = 0

    for disk_op, disk_dict in self.op.disks:

      if disk_op == constants.DDM_REMOVE:

        disk_addremove += 1

        continue

      elif disk_op == constants.DDM_ADD:

        disk_addremove += 1

      else:

        if not isinstance(disk_op, int):

          raise errors.OpPrereqError("Invalid disk index")

      if disk_op == constants.DDM_ADD:

        mode = disk_dict.setdefault('mode', constants.DISK_RDWR)

        if mode not in (constants.DISK_RDONLY, constants.DISK_RDWR):

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

        size = disk_dict.get('size', None)

        if size is None:

          raise errors.OpPrereqError("Required disk parameter size missing")

        try:

          size = int(size)

        except ValueError, err:

          raise errors.OpPrereqError("Invalid disk size parameter: %s" %

                                     str(err))

        disk_dict['size'] = size

      else:

        # modification of disk

        if 'size' in disk_dict:

          raise errors.OpPrereqError("Disk size change not possible, use"

                                     " grow-disk")

    if disk_addremove > 1:

      raise errors.OpPrereqError("Only one disk add or remove operation"

                                 " supported at a time")

    # NIC validation

    nic_addremove = 0

    for nic_op, nic_dict in self.op.nics:

      if nic_op == constants.DDM_REMOVE:

        nic_addremove += 1

        continue

      elif nic_op == constants.DDM_ADD:

        nic_addremove += 1

      else:

        if not isinstance(nic_op, int):

          raise errors.OpPrereqError("Invalid nic index")

      # nic_dict should be a dict

      nic_ip = nic_dict.get('ip', None)

      if nic_ip is not None:

        if nic_ip.lower() == "none":

          nic_dict['ip'] = None

        else:

          if not utils.IsValidIP(nic_ip):

            raise errors.OpPrereqError("Invalid IP address '%s'" % nic_ip)

      # we can only check None bridges and assign the default one

      nic_bridge = nic_dict.get('bridge', None)

      if nic_bridge is None:

        nic_dict['bridge'] = self.cfg.GetDefBridge()

      # but we can validate MACs

      nic_mac = nic_dict.get('mac', None)

      if nic_mac is not None:

        if self.cfg.IsMacInUse(nic_mac):

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

                                     " in cluster" % nic_mac)

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

          if not utils.IsValidMac(nic_mac):

            raise errors.OpPrereqError("Invalid MAC address %s" % nic_mac)

    if nic_addremove > 1:

      raise errors.OpPrereqError("Only one NIC add or remove operation"

                                 " supported at a time")

    # FIXME: readd disk/nic changes

    force = self.force = self.op.force

    # NIC processing

    for nic_op, nic_dict in self.op.nics:

      if nic_op == constants.DDM_REMOVE:

        if not instance.nics:

          raise errors.OpPrereqError("Instance has no NICs, cannot remove")

        continue

      if nic_op != constants.DDM_ADD:

        # an existing nic

        if nic_op < 0 or nic_op >= len(instance.nics):

          raise errors.OpPrereqError("Invalid NIC index %s, valid values"

                                     " are 0 to %d" %

                                     (nic_op, len(instance.nics)))

      nic_bridge = nic_dict.get('bridge', None)

      if nic_bridge is not None:

        if not self.rpc.call_bridges_exist(pnode, [nic_bridge]):

          msg = ("Bridge '%s' doesn't exist on one of"

                 " the instance nodes" % nic_bridge)

          if self.force:

            self.warn.append(msg)

          else:

            raise errors.OpPrereqError(msg)

    # DISK processing

    if self.op.disks and instance.disk_template == constants.DT_DISKLESS:

      raise errors.OpPrereqError("Disk operations not supported for"

                                 " diskless instances")

    for disk_op, disk_dict in self.op.disks:

      if disk_op == constants.DDM_REMOVE:

        if len(instance.disks) == 1:

          raise errors.OpPrereqError("Cannot remove the last disk of"

                                     " an instance")

        ins_l = self.rpc.call_instance_list([pnode], [instance.hypervisor])

        ins_l = ins_l[pnode]

        if not type(ins_l) is list:

          raise errors.OpPrereqError("Can't contact node '%s'" % pnode)

        if instance.name in ins_l:

          raise errors.OpPrereqError("Instance is running, can't remove"

                                     " disks.")

      if (disk_op == constants.DDM_ADD and

          len(instance.nics) >= constants.MAX_DISKS):

        raise errors.OpPrereqError("Instance has too many disks (%d), cannot"

                                   " add more" % constants.MAX_DISKS)

      if disk_op not in (constants.DDM_ADD, constants.DDM_REMOVE):

        # an existing disk

        if disk_op < 0 or disk_op >= len(instance.disks):

          raise errors.OpPrereqError("Invalid disk index %s, valid values"

                                     " are 0 to %d" %

                                     (disk_op, len(instance.disks)))

    # disk changes

    for disk_op, disk_dict in self.op.disks:

      if disk_op == constants.DDM_REMOVE:

        # remove the last disk

        device = instance.disks.pop()

        device_idx = len(instance.disks)

        for node, disk in device.ComputeNodeTree(instance.primary_node):

          self.cfg.SetDiskID(disk, node)

          if not self.rpc.call_blockdev_remove(node, disk):

            self.proc.LogWarning("Could not remove disk/%d on node %s,"

                                 " continuing anyway", device_idx, node)

        result.append(("disk/%d" % device_idx, "remove"))

      elif disk_op == constants.DDM_ADD:

        # add a new disk

        if instance.disk_template == constants.DT_FILE:

          file_driver, file_path = instance.disks[0].logical_id

          file_path = os.path.dirname(file_path)

        else:

          file_driver = file_path = None

        disk_idx_base = len(instance.disks)

        new_disk = _GenerateDiskTemplate(self,

                                         instance.disk_template,

                                         instance, instance.primary_node,

                                         instance.secondary_nodes,

                                         [disk_dict],

                                         file_path,

                                         file_driver,

                                         disk_idx_base)[0]

        new_disk.mode = disk_dict['mode']

        instance.disks.append(new_disk)

        info = _GetInstanceInfoText(instance)

        logging.info("Creating volume %s for instance %s",

                     new_disk.iv_name, instance.name)

        # Note: this needs to be kept in sync with _CreateDisks

        #HARDCODE

        for secondary_node in instance.secondary_nodes:

          if not _CreateBlockDevOnSecondary(self, secondary_node, instance,

                                            new_disk, False, info):

            self.LogWarning("Failed to create volume %s (%s) on"

                            " secondary node %s!",

                            new_disk.iv_name, new_disk, secondary_node)

        #HARDCODE

        if not _CreateBlockDevOnPrimary(self, instance.primary_node,

                                        instance, new_disk, info):

          self.LogWarning("Failed to create volume %s on primary!",

                          new_disk.iv_name)

        result.append(("disk/%d" % disk_idx_base, "add:size=%s,mode=%s" %

                       (new_disk.size, new_disk.mode)))

      else:

        # change a given disk

        instance.disks[disk_op].mode = disk_dict['mode']

        result.append(("disk.mode/%d" % disk_op, disk_dict['mode']))

    # NIC changes

    for nic_op, nic_dict in self.op.nics:

      if nic_op == constants.DDM_REMOVE:

        # remove the last nic

        del instance.nics[-1]

        result.append(("nic.%d" % len(instance.nics), "remove"))

      elif nic_op == constants.DDM_ADD:

        # add a new nic

        if 'mac' not in nic_dict:

          mac = constants.VALUE_GENERATE

        else:

          mac = nic_dict['mac']

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

          mac = self.cfg.GenerateMAC()

        new_nic = objects.NIC(mac=mac, ip=nic_dict.get('ip', None),

                              bridge=nic_dict.get('bridge', None))

        instance.nics.append(new_nic)

        result.append(("nic.%d" % (len(instance.nics) - 1),

                       "add:mac=%s,ip=%s,bridge=%s" %

                       (new_nic.mac, new_nic.ip, new_nic.bridge)))

      else:

        # change a given nic

        for key in 'mac', 'ip', 'bridge':

          if key in nic_dict:

            setattr(instance.nics[nic_op], key, nic_dict[key])

            result.append(("nic.%s/%d" % (key, nic_op), nic_dict[key]))

    # hvparams changes

    # beparams changes

DISK_RDONLY = "ro"

DISK_RDWR = "rw"

# dynamic device modification

DDM_ADD = 'add'

DDM_REMOVE = 'remove'

# max dynamnic devices

MAX_NICS = 8

MAX_DISKS = 16

    "instance_name",

    "nics", "disks",

  if not (opts.nics or opts.disks or

  for idx, (nic_op, nic_dict) in enumerate(opts.nics):

    try:

      nic_op = int(nic_op)

      opts.nics[idx] = (nic_op, nic_dict)

    except ValueError:

      pass

  for idx, (disk_op, disk_dict) in enumerate(opts.disks):

    try:

      disk_op = int(disk_op)

      opts.disks[idx] = (disk_op, disk_dict)

    except ValueError:

      pass

    if disk_op == constants.DDM_ADD:

      if 'size' not in disk_dict:

        raise errors.OpPrereqError("Missing required parameter 'size'")

      disk_dict['size'] = utils.ParseUnit(disk_dict['size'])

                                   nics=opts.nics,

                                   disks=opts.disks,

              ikv_option("--disk", help="Disk changes",

                         default=[], dest="disks",

                         action="append",

                         type="identkeyval"),

              ikv_option("--net", help="NIC changes",

                         default=[], dest="nics",

                         action="append",

                         type="identkeyval"),