Synnefo » snf-ganeti

      result["DISK_%d_BACKEND_TYPE" % idx] = "block"

    elif disk.dev_type in [constants.DT_FILE, constants.DT_SHARED_FILE]:

      result["DISK_%d_BACKEND_TYPE" % idx] = \

  # NICs

  for idx, nic in enumerate(instance.nics):

      config.set(constants.INISECT_INS, "disk%d_ivname" % disk_count,

                 ("%s" % disk.iv_name))

      config.set(constants.INISECT_INS, "disk%d_dump" % disk_count,

      config.set(constants.INISECT_INS, "disk%d_size" % disk_count,

                 ("%d" % disk.size))

  """Rename a list of block devices.

  @type devlist: list of tuples

  @rtype: boolean

  @return: True if all renames succeeded, False otherwise

  return data

def _FormatBlockDevInfo(idx, top_level, dev, roman):

  """Show block device information.

      data.append(("logical_id", l_id[0]))

    else:

      data.extend(l_id)

  if dev["pstatus"]:

    data.append(("on primary", helper(dev["dev_type"], dev["pstatus"])))

                   " node %s" % (self.instance.name,

                                 self.cfg.GetNodeName(src_node_uuid)))

    activate_disks = not self.instance.disks_active

    if activate_disks:

        continue

      newl = [(v[2].Copy(), v[0]) for v in dskl]

      node_name = self.cfg.GetNodeName(node_uuid)

      result = self.rpc.call_blockdev_getdimensions(node_uuid, newl)

      if result.fail_msg:

      for (inst_uuid, dev) in disks:

        (anno_disk,) = AnnotateDiskParams(instanceinfo[inst_uuid], [dev],

                                          self.cfg)

        dev_inst_only.append((anno_disk, instanceinfo[inst_uuid]))

      node_disks_dev_inst_only[nuuid] = dev_inst_only

def FindFaultyInstanceDisks(cfg, rpc_runner, instance, node_uuid, prereq):

  faulty = []

  result = rpc_runner.call_blockdev_getmirrorstatus(

             node_uuid, (instance.disks, instance))

  result.Raise("Failed to get disk status from node %s" %

        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[constants.IDISK_ADOPT])

        result = self.rpc.call_blockdev_rename(self.pnode.uuid,

                                               zip(tmp_disks, rename_to))

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

    ReleaseLocks(self, locking.LEVEL_NODE_RES)

    if iobj.disk_template != constants.DT_DISKLESS and not self.adopt_disks:

      if self.op.mode == constants.INSTANCE_CREATE:

        if not self.op.no_install:

          pause_sync = (iobj.disk_template in constants.DTS_INT_MIRROR and

    info = GetInstanceInfoText(renamed_inst)

    for (idx, disk) in enumerate(renamed_inst.disks):

      for node_uuid in renamed_inst.all_nodes:

        result = self.rpc.call_blockdev_setinfo(node_uuid,

                                                (disk, renamed_inst), info)

        result.Warn("Error setting info on node %s for disk %s" %

    except errors.GenericError, e:

      feedback_fn("Initializing of DRBD devices failed;"

                  " renaming back original volumes...")

      rename_back_list = [(n.children[0], o.logical_id)

                          for (n, o) in zip(new_disks, self.instance.disks)]

      result = self.rpc.call_blockdev_rename(pnode_uuid, rename_back_list)

    feedback_fn("Removing volumes on the secondary node...")

    for disk in old_disks:

      result = self.rpc.call_blockdev_remove(snode_uuid, (disk, self.instance))

      result.Warn("Could not remove block device %s on node %s,"

                  " continuing anyway" %

    feedback_fn("Removing unneeded volumes on the primary node...")

    for idx, disk in enumerate(old_disks):

      meta = disk.children[1]

      result = self.rpc.call_blockdev_remove(pnode_uuid, (meta, self.instance))

      result.Warn("Could not remove metadata for disk %d on node %s,"

                  " continuing anyway" %

    (anno_disk,) = AnnotateDiskParams(self.instance, [root], self.cfg)

    for node_uuid, disk in anno_disk.ComputeNodeTree(

                             self.instance.primary_node):

      msg = self.rpc.call_blockdev_remove(node_uuid, (disk, self.instance)) \

              .fail_msg

      if msg:

    self.feedback_fn("* switching node %s to secondary mode" %

                     self.cfg.GetNodeName(node_uuid))

    result = self.rpc.call_blockdev_close(node_uuid, self.instance.name,

                                          (self.instance.disks, self.instance))

    result.Raise("Cannot change disk to secondary on node %s" %

    if instance_running and \

        self.op.reboot_type in [constants.INSTANCE_REBOOT_SOFT,

                                constants.INSTANCE_REBOOT_HARD]:

      result = self.rpc.call_instance_reboot(current_node_uuid, self.instance,

                                             self.op.reboot_type,

                                             self.op.shutdown_timeout,

    if self.op.static or not node_uuid:

      return None

    result = self.rpc.call_blockdev_find(node_uuid, (dev, instance))

    if result.offline:

      return None

      "dev_type": dev.dev_type,

      "logical_id": dev.logical_id,

      "drbd_info": drbd_info,

      "pstatus": dev_pstatus,

      "sstatus": dev_sstatus,

      "children": dev_children,

  @param excl_stor: Whether exclusive_storage is active for the node

  """

  result = lu.rpc.call_blockdev_create(node_uuid, (device, instance),

                                       device.size, instance.name, force_open,

                                       info, excl_stor)

               " node %s for instance %s" % (device,

                                             lu.cfg.GetNodeName(node_uuid),

                                             instance.name))

def _CreateBlockDevInner(lu, node_uuid, instance, device, force_create,

  """

  for (node_uuid, disk) in disks_created:

    result = lu.rpc.call_blockdev_remove(node_uuid, (disk, instance))

    result.Warn("Failed to remove newly-created disk %s on node %s" %

                (disk, lu.cfg.GetNodeName(node_uuid)), logging.warning)

    disks = [(idx, disk, 0)

             for (idx, disk) in enumerate(instance.disks)]

  logging.info("Pausing synchronization of disks of instance '%s'",

               instance.name)

  result = lu.rpc.call_blockdev_pause_resume_sync(node_uuid,

  node_uuid = instance.primary_node

  node_name = lu.cfg.GetNodeName(node_uuid)

  # TODO: Convert to utils.Retry

  retries = 0

  for disk in disks:

    for node_uuid, top_disk in disk.ComputeNodeTree(instance.primary_node):

      result = lu.rpc.call_blockdev_shutdown(node_uuid, (top_disk, instance))

      msg = result.fail_msg

      if msg:

      if ignore_size:

        node_disk = node_disk.Copy()

        node_disk.UnsetSize()

      result = lu.rpc.call_blockdev_assemble(node_uuid, (node_disk, instance),

                                             instance.name, False, idx)

      msg = result.fail_msg

      if ignore_size:

        node_disk = node_disk.Copy()

        node_disk.UnsetSize()

      result = lu.rpc.call_blockdev_assemble(node_uuid, (node_disk, instance),

                                             instance.name, True, idx)

      msg = result.fail_msg

    device_info.append((lu.cfg.GetNodeName(instance.primary_node),

                        inst_disk.iv_name, dev_path))

  if not disks_ok:

    lu.cfg.MarkInstanceDisksInactive(instance.uuid)

    # First run all grow ops in dry-run mode

    for node_uuid in self.instance.all_nodes:

      result = self.rpc.call_blockdev_grow(node_uuid,

                                           (self.disk, self.instance),

                                           self.delta, True, True,

    if wipe_disks:

      # Get disk size from primary node for wiping

      result = self.rpc.call_blockdev_getdimensions(

                 self.instance.primary_node, ([self.disk], self.instance))

      result.Raise("Failed to retrieve disk size from node '%s'" %

    # We know that (as far as we can test) operations across different

    # nodes will succeed, time to run it for real on the backing storage

    for node_uuid in self.instance.all_nodes:

      result = self.rpc.call_blockdev_grow(node_uuid,

                                           (self.disk, self.instance),

                                           self.delta, False, True,

    # And now execute it for logical storage, on the primary node

    node_uuid = self.instance.primary_node

    result = self.rpc.call_blockdev_grow(node_uuid, (self.disk, self.instance),

                                         self.delta, False, False,

                                         self.node_es_flags[node_uuid])

  the device(s)) to the ldisk (representing the local storage status).

  """

  result = True

  if on_primary or dev.AssembleOnSecondary():

      for node_uuid in node_uuids:

        self.lu.LogInfo("Checking disk/%d on %s", idx,

                        self.cfg.GetNodeName(node_uuid))

        result = _BlockdevFind(self, node_uuid, dev, instance)

      for node_uuid in node_uuids:

        self.lu.LogInfo("Checking disk/%d on %s", idx,

                        self.cfg.GetNodeName(node_uuid))

        result = _BlockdevFind(self, node_uuid, dev, self.instance)

      self.lu.LogInfo("Adding storage on %s for disk/%d",

                      self.cfg.GetNodeName(node_uuid), idx)

      lv_names = [".disk%d_%s" % (idx, suffix) for suffix in ["data", "meta"]]

      names = _GenerateUniqueNames(self.lu, lv_names)

  def _CheckDevices(self, node_uuid, iv_names):

    for name, (dev, _, _) in iv_names.iteritems():

      result = _BlockdevFind(self, node_uuid, dev, self.instance)

      msg = result.fail_msg

      self.lu.LogInfo("Remove logical volumes for %s", name)

      for lv in old_lvs:

        msg = self.rpc.call_blockdev_remove(node_uuid, (lv, self.instance)) \

                .fail_msg

        if msg:

      # ok, we created the new LVs, so now we know we have the needed

      # storage; as such, we proceed on the target node to rename

      # old_lv to _old, and new_lv to old_lv; note that we rename LVs

      # FIXME(iustin): use a better name for the replaced LVs

      temp_suffix = int(time.time())

      # Build the rename list based on what LVs exist on the node

      rename_old_to_new = []

      # Now we rename the new LVs to the old LVs

      self.lu.LogInfo("Renaming the new LVs on the target node")

                           for old, new in zip(old_lvs, new_lvs)]

      result = self.rpc.call_blockdev_rename(self.target_node_uuid,

                                             rename_new_to_old)

    # We have new devices, shutdown the drbd on the old secondary

    for idx, dev in enumerate(self.instance.disks):

      self.lu.LogInfo("Shutting down drbd for disk/%d on old node", idx)

      msg = self.rpc.call_blockdev_shutdown(self.target_node_uuid,

                                            (dev, self.instance)).fail_msg

      if msg:

    self.lu.LogInfo("Updating instance configuration")

    for dev, _, new_logical_id in iv_names.itervalues():

      dev.logical_id = new_logical_id

    self.cfg.Update(self.instance, feedback_fn)

    else:

      edata = device.ComputeNodeTree(instance.primary_node)

    for node_uuid, disk in edata:

      result = lu.rpc.call_blockdev_remove(node_uuid, (disk, instance))

      if result.fail_msg:

        lu.LogWarning("Could not remove disk %s on node %s,"

    return result

    """Compute duplicate disk IDs

    @type disk: L{objects.Disk}

    @param disk: the disk at which to start searching

    @type l_ids: list

    @param l_ids: list of current logical ids

    @rtype: list

    @return: a list of error messages

        result.append("duplicate logical id %s" % str(disk.logical_id))

      else:

        l_ids.append(disk.logical_id)

    if disk.children:

      for child in disk.children:

    return result

  def _UnlockedVerifyConfig(self):

    data = self._config_data

    cluster = data.cluster

    seen_lids = []

    # global cluster checks

    if not cluster.enabled_hypervisors:

      for idx, disk in enumerate(instance.disks):

        result.extend(["instance '%s' disk %d error: %s" %

                       (instance.name, idx, msg) for msg in disk.Verify()])

      wrong_names = _CheckInstanceDiskIvNames(instance.disks)

      if wrong_names:

    """

    return self._UnlockedVerifyConfig()

  @locking.ssynchronized(_config_lock)

  def AddTcpUdpPort(self, port):

    """Adds a new port to the available port pool.

        disk.logical_id = (disk.logical_id[0],

                           utils.PathJoin(file_storage_dir, inst.name,

                                          "disk%s" % idx))

    # Force update of ssconf files

    self._config_data.cluster.serial_no += 1

      mode = "r"

    if cfdev.dev_type in [constants.DT_FILE, constants.DT_SHARED_FILE]:

    else:

      driver = "phy"

        disk_id = tuple(result.payload)

        disk_params = constants.DISK_LD_DEFAULTS[constants.DT_PLAIN].copy()

        new_dev = objects.Disk(dev_type=constants.DT_PLAIN, size=disk.size,

                               params=disk_params)

      self._snap_disks.append(new_dev)

        continue

      path = utils.PathJoin(pathutils.EXPORT_DIR, "%s.new" % instance.name,

      finished_fn = compat.partial(self._TransferFinished, idx)

class Disk(ConfigObject):

  """Config object representing a block device."""

                "size", "mode", "params", "spindles"] + _UUID +

               # dynamic_params is special. It depends on the node this instance

               # is sent to, and should not be persisted.

      obj.children = outils.ContainerFromDicts(obj.children, list, Disk)

    if obj.logical_id and isinstance(obj.logical_id, list):

      obj.logical_id = tuple(obj.logical_id)

    if obj.dev_type in constants.LDS_DRBD:

      # we need a tuple of length six here

      if len(obj.logical_id) < 6:

    elif self.dev_type in constants.LDS_DRBD:

      node_a, node_b, port, minor_a, minor_b = self.logical_id[:5]

      val = "<DRBD8("

      if self.children and self.children.count(None) == 0:

        val += "backend=%s, metadev=%s" % (self.children[0], self.children[1])

      else:

        val += "no local storage"

    else:

    if self.iv_name is None:

      val += ", not visible"

    else:

-- code currently can't build it.

data Disk = Disk

  { diskLogicalId  :: DiskLogicalId

  , diskChildren   :: [Disk]

  , diskIvName     :: String

  , diskSize       :: Int

$(buildObjectSerialisation "Disk" $

  [ customField 'decodeDLId 'encodeFullDLId ["dev_type"] $

      simpleField "logical_id"    [t| DiskLogicalId   |]

  , defaultField  [| [] |] $ simpleField "children" [t| [Disk] |]

  , defaultField [| "" |] $ simpleField "iv_name" [t| String |]

  , simpleField "size" [t| Int |]