Synnefo » snf-ganeti » ganeti-local

    validity.

    """

    self.op = op

    self.cfg = cfg

    self.sstore = sstore

                     "please restart manually.")

  """Sleep and poll for an instance's disk to sync.

  """

    return True

  if not oneshot:

  node = instance.primary_node

    cumul_degraded = False

    rstats = rpc.call_blockdev_getmirrorstatus(node, instance.disks)

    if not rstats:

      retries += 1

      if retries >= 10:

        raise errors.RemoteError("Can't contact node %s for mirror data,"

    for i in range(len(rstats)):

      mstat = rstats[i]

      if mstat is None:

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

        continue

      # we ignore the ldisk parameter

          max_time = est_time

        else:

          rem_time = "no time estimate"

    if done or oneshot:

      break

        utils.Lock('cmd')

  if done:

  return not cumul_degraded

    self.cfg.AddInstance(iobj)

    if self.op.wait_for_sync:

    elif iobj.disk_template in constants.DTS_NET_MIRROR:

      # make sure the disks are not degraded (still sync-ing is ok)

      time.sleep(15)

      feedback_fn("* checking mirrors status")

    else:

      disk_abort = False

    self.cfg.AddInstance(instance)

    return 0

    # 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

    # so check manually all the devices

    for name in iv_names:

    """

    steps_total = 6

    instance = self.instance

    iv_names = {}

    vgname = self.cfg.GetVGName()

    oth_node = self.oth_node

    # Step: check device activation

    info("checking volume groups")

    my_vg = cfg.GetVGName()

    results = rpc.call_vg_list([oth_node, tgt_node])

                                   (dev.iv_name, node))

    # Step: check other node consistency

    for dev in instance.disks:

      if not dev.iv_name in self.op.disks:

        continue

                                 (oth_node, tgt_node))

    # Step: create new storage

    for dev in instance.disks:

      if not dev.iv_name in self.op.disks:

        continue

                                   (new_lv.logical_id[1], tgt_node))

    # Step: for each lv, detach+rename*2+attach

    for dev, old_lvs, new_lvs in iv_names.itervalues():

      info("detaching %s drbd from local storage" % dev.iv_name)

      if not rpc.call_blockdev_removechildren(tgt_node, dev, old_lvs):

    # 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

    # so check manually all the devices

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

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

    # Step: remove old storage

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

      info("remove logical volumes for %s" % name)

      for lv in old_lvs:

    """

    steps_total = 6

    instance = self.instance

    iv_names = {}

    vgname = self.cfg.GetVGName()

    pri_node = instance.primary_node

    # Step: check device activation

    info("checking volume groups")

    my_vg = cfg.GetVGName()

    results = rpc.call_vg_list([pri_node, new_node])

                                 (dev.iv_name, pri_node))

    # Step: check other node consistency

    for dev in instance.disks:

      if not dev.iv_name in self.op.disks:

        continue

                                 pri_node)

    # Step: create new storage

    for dev in instance.disks:

      size = dev.size

      info("adding new local storage on %s for %s" % (new_node, dev.iv_name))

      iv_names[dev.iv_name] = (dev, dev.children)

    for dev in instance.disks:

      size = dev.size

      info("activating a new drbd on %s for %s" % (new_node, dev.iv_name))

    # 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

    # so check manually all the devices

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

      if is_degr:

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

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

      info("remove logical volumes for %s" % name)

      for lv in old_lvs:

    # shutdown the instance, unless requested not to do so

    if self.op.shutdown:

      op = opcodes.OpShutdownInstance(instance_name=instance.name)

    vgname = self.cfg.GetVGName()

      if self.op.shutdown:

        op = opcodes.OpStartupInstance(instance_name=instance.name,

                                       force=False)

    # TODO: check for size

    # substitutes an empty list with the full cluster node list.

    if nodelist:

      op = opcodes.OpQueryExports(nodes=nodelist)

      for node in exportlist:

        if instance.name in exportlist[node]:

          if not rpc.call_export_remove(node, instance.name):

    logger.Debug("Step %d/%d %s" % (current, total, message))

    self._feedback_fn("STEP %d/%d %s" % (current, total, message))

    """Log a warning to the logs and the user.

    """

    logger.Error(message)

    self._feedback_fn(" - WARNING: %s" % message)

  def LogInfo(self, message):

    """Log an informational message to the logs and the user.