Synnefo » snf-ganeti » ganeti-local

- Replaced ``--disks`` option of ``gnt-instance replace-disks`` with a

  more flexible ``--disk`` option. Now disk size and mode can be changed

  upon recreation.

from ganeti import ht

  disks = []

    for didx, ddict in opts.disks:

      didx = int(didx)

      if not ht.TDict(ddict):

        msg = "Invalid disk/%d value: expected dict, got %s" % (didx, ddict)

        raise errors.OpPrereqError(msg)

      if constants.IDISK_SIZE in ddict:

        try:

          ddict[constants.IDISK_SIZE] = \

            utils.ParseUnit(ddict[constants.IDISK_SIZE])

        except ValueError, err:

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

                                     (didx, err))

      disks.append((didx, ddict))

    # TODO: Verify modifyable parameters (already done in

    # LUInstanceRecreateDisks, but it'd be nice to have in the client)

                                       disks=disks, nodes=nodes)

    [SUBMIT_OPT, DISK_OPT, NODE_PLACEMENT_OPT, DRY_RUN_OPT, PRIORITY_OPT],

  _MODIFYABLE = frozenset([

    constants.IDISK_SIZE,

    constants.IDISK_MODE,

    ])

  # New or changed disk parameters may have different semantics

  assert constants.IDISK_PARAMS == (_MODIFYABLE | frozenset([

    constants.IDISK_ADOPT,

    # TODO: Implement support changing VG while recreating

    constants.IDISK_VG,

    constants.IDISK_METAVG,

    ]))

    if self.op.disks and ht.TPositiveInt(self.op.disks[0]):

      # Normalize and convert deprecated list of disk indices

      self.op.disks = [(idx, {}) for idx in sorted(frozenset(self.op.disks))]

    duplicates = utils.FindDuplicates(map(compat.fst, self.op.disks))

    if duplicates:

      raise errors.OpPrereqError("Some disks have been specified more than"

                                 " once: %s" % utils.CommaJoin(duplicates),

                                 errors.ECODE_INVAL)

    for (idx, params) in self.op.disks:

      utils.ForceDictType(params, constants.IDISK_PARAMS_TYPES)

      unsupported = frozenset(params.keys()) - self._MODIFYABLE

      if unsupported:

        raise errors.OpPrereqError("Parameters for disk %s try to change"

                                   " unmodifyable parameter(s): %s" %

                                   (idx, utils.CommaJoin(unsupported)),

                                   errors.ECODE_INVAL)

    if self.op.disks:

      self.disks = dict(self.op.disks)

      self.disks = dict((idx, {}) for idx in range(len(instance.disks)))

    maxidx = max(self.disks.keys())

    if maxidx >= len(instance.disks):

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

                                 errors.ECODE_INVAL)

    if (self.op.nodes and

        sorted(self.disks.keys()) != range(len(instance.disks))):

    mods = [] # keeps track of needed changes

      try:

        changes = self.disks[idx]

      except KeyError:

        # Disk should not be recreated

      if self.op.nodes and disk.dev_type == constants.LD_DRBD8:

        # need to update the nodes and minors

        assert len(self.op.nodes) == 2

        assert len(disk.logical_id) == 6 # otherwise disk internals

                                         # have changed

        (_, _, old_port, _, _, old_secret) = disk.logical_id

        new_minors = self.cfg.AllocateDRBDMinor(self.op.nodes, instance.name)

        new_id = (self.op.nodes[0], self.op.nodes[1], old_port,

                  new_minors[0], new_minors[1], old_secret)

        assert len(disk.logical_id) == len(new_id)

      else:

        new_id = None

      mods.append((idx, new_id, changes))

    for idx, new_id, changes in mods:

      disk = instance.disks[idx]

      if new_id is not None:

        assert disk.dev_type == constants.LD_DRBD8

        disk.logical_id = new_id

      if changes:

        disk.Update(size=changes.get(constants.IDISK_SIZE, None),

                    mode=changes.get(constants.IDISK_MODE, None))

  def Update(self, size=None, mode=None):

    """Apply changes to size and mode.

    """

    if self.dev_type == constants.LD_DRBD8:

      if self.children:

        self.children[0].Update(size=size, mode=mode)

    else:

      assert not self.children

    if size is not None:

      self.size = size

    if mode is not None:

      self.mode = mode

# TODO: Generate check from constants.IDISK_PARAMS_TYPES (however, not all users

# of this check support all parameters)

_TDiskParams = ht.TDictOf(ht.TElemOf(constants.IDISK_PARAMS),

                          ht.TOr(ht.TNonEmptyString, ht.TInt))

    ("disks", ht.NoDefault, ht.TListOf(_TDiskParams),

  _TDiskChanges = \

    ht.TAnd(ht.TIsLength(2),

            ht.TItems([ht.Comment("Disk index")(ht.TPositiveInt),

                       ht.Comment("Parameters")(_TDiskParams)]))

    ("disks", ht.EmptyList,

     ht.TOr(ht.TListOf(ht.TPositiveInt), ht.TListOf(_TDiskChanges)),

     "List of disk indexes (deprecated) or a list of tuples containing a disk"

     " index and a possibly empty dictionary with disk parameter changes"),

| **recreate-disks** [--submit] [-n node1:[node2]]

| [--disk=*N*[:[size=*VAL*][,mode=*ro\|rw*]]] {*instance*}

Recreates all or a subset of disks of the given instance.

If only a subset should be recreated, any number of ``disk`` options can

be specified. It expects a disk index and an optional list of disk

parameters to change. Only ``size`` and ``mode`` can be changed while

recreating disks. To recreate all disks while changing parameters on

a subset only, a ``--disk`` option must be given for every disk of the

instance.

has. Note that changing nodes is only allowed when all disks are

replaced, e.g. when no ``--disk`` option is passed.