Synnefo » snf-ganeti

    # If the instance's disk template is `rbd' and there was a successful

    # migration, unmap the device from the source node.

    if self.instance.disk_template == constants.DT_RBD:

      disks = _ExpandCheckDisks(instance, instance.disks)

      self.feedback_fn("* unmapping instance's disks from %s" % source_node)

      for disk in disks:

        result = self.rpc.call_blockdev_shutdown(source_node, disk)

        msg = result.fail_msg

        if msg:

          logging.error("Migration was successful, but couldn't unmap the"

                        " block device %s on source node %s: %s",

                        disk.iv_name, source_node, msg)

          logging.error("You need to unmap the device %s manually on %s",

                        disk.iv_name, source_node)

  elif disk_template == constants.DT_RBD:

    params = {

      constants.LDP_POOL: dt_params[constants.RBD_POOL]

      }

    params = \

      objects.FillDict(constants.DISK_LD_DEFAULTS[constants.LD_RBD],

                       params)

    result.append(params)

  elif template_name == constants.DT_RBD:

    if secondary_nodes:

      raise errors.ProgrammerError("Wrong template configuration")

    names = _GenerateUniqueNames(lu, [".rbd.disk%d" % (base_index + i)

                                      for i in range(disk_count)])

    for idx, disk in enumerate(disk_info):

      disk_index = idx + base_index

      disk_dev = objects.Disk(dev_type=constants.LD_RBD,

                              size=disk[constants.IDISK_SIZE],

                              logical_id=("rbd", names[idx]),

                              iv_name="disk/%d" % disk_index,

                              mode=disk[constants.IDISK_MODE],

                              params=ld_params[0])

      disks.append(disk_dev)

    constants.DT_RBD: 0,

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

        # _CheckRADOSFreeSpace() is just a placeholder.

        # Any function that checks prerequisites can be placed here.

        # Check if there is enough space on the RADOS cluster.

        _CheckRADOSFreeSpace()

      else:

        # Check lv size requirements, if not adopting

        req_sizes = _ComputeDiskSizePerVG(self.op.disk_template, self.disks)

        _CheckNodesFreeDiskPerVG(self, nodenames, req_sizes)

def _CheckRADOSFreeSpace():

  """Compute disk size requirements inside the RADOS cluster.

  """

  # For the RADOS cluster we assume there is always enough space.

  pass

                                      constants.DT_SHARED_FILE,

                                      constants.DT_RBD):