Synnefo » snf-ganeti

  elif template_name == constants.DT_BLOCK:

    if len(secondary_nodes) != 0:

      raise errors.ProgrammerError("Wrong template configuration")

    for idx, disk in enumerate(disk_info):

      disk_index = idx + base_index

      disk_dev = objects.Disk(dev_type=constants.LD_BLOCKDEV, size=disk["size"],

                              logical_id=(constants.BLOCKDEV_DRIVER_MANUAL,

                                          disk["adopt"]),

                              iv_name="disk/%d" % disk_index,

                              mode=disk["mode"])

      disks.append(disk_dev)

    constants.DT_BLOCK: 0,

    else:

      if self.op.disk_template in constants.DTS_MUST_ADOPT:

        raise errors.OpPrereqError("Disk template %s requires disk adoption,"

                                   " but no 'adopt' parameter given" %

                                   self.op.disk_template,

                                   errors.ECODE_INVAL)

    elif self.op.disk_template == constants.DT_PLAIN: # Check the adoption data

    elif self.op.disk_template == constants.DT_BLOCK:

      # Normalize and de-duplicate device paths

      all_disks = set([os.path.abspath(i["adopt"]) for i in self.disks])

      if len(all_disks) != len(self.disks):

        raise errors.OpPrereqError("Duplicate disk names given for adoption",

                                   errors.ECODE_INVAL)

      baddisks = [d for d in all_disks

                  if not d.startswith(constants.ADOPTABLE_BLOCKDEV_ROOT)]

      if baddisks:

        raise errors.OpPrereqError("Device node(s) %s lie outside %s and"

                                   " cannot be adopted" %

                                   (", ".join(baddisks),

                                    constants.ADOPTABLE_BLOCKDEV_ROOT),

                                   errors.ECODE_INVAL)

      node_disks = self.rpc.call_bdev_sizes([pnode.name],

                                            list(all_disks))[pnode.name]

      node_disks.Raise("Cannot get block device information from node %s" %

                       pnode.name)

      node_disks = node_disks.payload

      delta = all_disks.difference(node_disks.keys())

      if delta:

        raise errors.OpPrereqError("Missing block device(s): %s" %

                                   utils.CommaJoin(delta),

                                   errors.ECODE_INVAL)

      for dsk in self.disks:

        dsk["size"] = int(float(node_disks[dsk["adopt"]]))

      if self.op.disk_template == constants.DT_PLAIN:

        # rename LVs to the newly-generated names; we need to construct

        # 'fake' LV disks with the old data, plus the new unique_id

        tmp_disks = [objects.Disk.FromDict(v.ToDict()) for v in disks]

        rename_to = []

        for t_dsk, a_dsk in zip (tmp_disks, self.disks):

          rename_to.append(t_dsk.logical_id)

          t_dsk.logical_id = (t_dsk.logical_id[0], a_dsk["adopt"])

          self.cfg.SetDiskID(t_dsk, pnode_name)

        result = self.rpc.call_blockdev_rename(pnode_name,

                                               zip(tmp_disks, rename_to))

        result.Raise("Failed to rename adoped LVs")