Synnefo » snf-ganeti

  rbd = _RecursiveFindBD(disk)

  if rbd is None:

    return rbd

def UploadFile(file_name, data, mode, uid, gid, atime, mtime):

    status of the mirror.

    Returns:

    If estimated_time is None, it means we can't estimate

    If is_degraded is True, it means the device is missing

    redundancy. This is usually a sign that something went wrong in

    the device setup, if sync_percent is None.

    """

  def CombinedSyncStatus(self):

    children.

    """

    if self._children:

      for child in self._children:

        if min_percent is None:

          min_percent = c_percent

        elif c_percent is not None:

        elif c_time is not None:

          max_time = max(max_time, c_time)

        is_degraded = is_degraded or c_degraded

  def SetInfo(self, text):

    status of the mirror.

    Returns:

    For logical volumes, sync_percent and estimated_time are always

    None (no recovery in progress, as we don't handle the mirrored LV

    """

    result = utils.RunCmd(["lvs", "--noheadings", "-olv_attr", self.dev_path])

    if result.failed:

      logger.Error("Can't display lv: %s" % result.fail_reason)

    out = result.stdout.strip()

    # format: type/permissions/alloc/fixed_minor/state/open

    if len(out) != 6:

  def Open(self, force=False):

    """Make the device ready for I/O.

    """Returns the sync status of the device.

    Returns:

    If sync_percent is None, it means all is ok

    If estimated_time is None, it means we can't esimate

    """

    if self.minor is None and not self.Attach():

    sync_status = f.readline().strip()

    f.close()

    if sync_status == "idle":

    f = file(sys_path + "sync_completed")

    sync_completed = f.readline().strip().split(" / ")

    f.close()

    if len(sync_completed) != 2:

    sync_done, sync_total = [float(i) for i in sync_completed]

    sync_percent = 100.0*sync_done/sync_total

    f = file(sys_path + "sync_speed")

      time_est = None

    else:

      time_est = (sync_total - sync_done) / 2 / sync_speed_k

  def Open(self, force=False):

    """Make the device ready for I/O.

    """Returns the sync status of the device.

    Returns:

    If sync_percent is None, it means all is ok

    If estimated_time is None, it means we can't esimate

    """

    if self.minor is None and not self.Attach():

                                    self.minor)

    client_state = match.group(1)

    is_degraded = client_state != "Connected"

  def GetStatus(self):

    """Compute the status of the DRBD device

    If sync_percent is None, it means all is ok

    If estimated_time is None, it means we can't esimate

    """

    if self.minor is None and not self.Attach():

                                    self.minor)

    client_state = match.group(1)

    local_disk_state = match.group(2)

  def GetStatus(self):

    """Compute the status of the DRBD device

        logger.ToStderr("Can't compute data for node %s/%s" %

                        (node, instance.disks[i].iv_name))

        continue

      cumul_degraded = cumul_degraded or (is_degraded and perc_done is None)

      if perc_done is not None:

        done = False

  return not cumul_degraded

  """Check that mirrors are not degraded.

  """

  cfgw.SetDiskID(dev, node)

  result = True

  if on_primary or dev.AssembleOnSecondary():

      logger.ToStderr("Can't get any data from node %s" % node)

      result = False

    else:

  if dev.children:

    for child in dev.children:

      result = result and _CheckDiskConsistency(cfgw, child, node, on_primary)

      "OLD_SECONDARY": self.instance.secondary_nodes[0],

      }

    env.update(_BuildInstanceHookEnvByObject(self.instance))

    return env, nl, nl

  def CheckPrereq(self):

      raise errors.OpPrereqError("The specified node is the primary node of"

                                 " the instance.")

    elif remote_node == self.sec_node:

      # the user gave the current secondary, switch to

      remote_node = None

    if (instance.disk_template == constants.DT_REMOTE_RAID1 and

        self.op.mode != constants.REPLACE_DISK_ALL):

      - remove all disks from the old secondary

    Failures are not very well handled.

    """

    instance = self.instance

    iv_names = {}

    vgname = self.cfg.GetVGName()

    old_node = self.tgt_node

    new_node = self.new_node

    pri_node = instance.primary_node

    for dev in instance.disks:

      size = dev.size

      # since we *always* want to create this LV, we use the

      # _Create...OnPrimary (which forces the creation), even if we

      # are talking about the secondary node

                                   " node '%s'" %

                                   (new_lv.logical_id[1], new_node))

      # create new devices on new_node

      new_drbd = objects.Disk(dev_type=constants.LD_DRBD8,

                              logical_id=(pri_node, new_node,

        raise errors.OpExecError("Failed to create new DRBD on"

                                 " node '%s'" % new_node)

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

      cfg.SetDiskID(dev, old_node)

      if not rpc.call_blockdev_shutdown(old_node, dev):

      # we have new storage, we 'rename' the network on the primary

      cfg.SetDiskID(dev, pri_node)

      # rename to the ip of the new node

      new_uid = list(dev.physical_id)

      new_uid[2] = self.remote_node_info.secondary_ip

      rlist = [(dev, tuple(new_uid))]

      if not rpc.call_blockdev_rename(pri_node, rlist):

                                 " %s from %s to %s" %

                                 (dev.iv_name, pri_node, old_node, new_node))

      dev.logical_id = (pri_node, new_node, dev.logical_id[2])

      cfg.SetDiskID(dev, pri_node)

      cfg.Update(instance)

    # this can fail as the old devices are degraded and _WaitForSync

    # does a combined result over all disks, so we don't check its

    # return value

    _WaitForSync(cfg, instance, unlock=True)

    # so check manually all the devices

      if is_degr:

        raise errors.OpExecError("DRBD device %s is degraded!" % name)

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

      for lv in old_lvs:

        cfg.SetDiskID(lv, old_node)

        if not rpc.call_blockdev_remove(old_node, lv):

  def Exec(self, feedback_fn):

    """Execute disk replacement.

# various versions

CONFIG_VERSION = 3

RELEASE_VERSION = _autoconf.PACKAGE_VERSION

OS_API_VERSION = 5

EXPORT_VERSION = 0

    if not status:

      buf.write("not active\n")

    else:

      buf.write("%s (%d:%d)" % (path, major, minor))

      if dtype in (constants.LD_MD_R1, constants.LD_DRBD7, constants.LD_DRBD8):

        if syncp is not None:

          degr_text = "*DEGRADED*"

        else:

          degr_text = "ok"

      elif dtype == constants.LD_LV:

        else:

      buf.write("\n")

  if dev["iv_name"] is not None: