Synnefo » snf-ganeti

  @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)