Synnefo » snf-ganeti

  try:

    processor.Enable()

  except errors.ConfigurationError:

    logging.warning("Confd is starting in disabled mode")

    pass

  server = ConfdAsyncUDPServer(options.bind_address, options.port, processor)

        else:

          rem_time = "no time estimate"

        lu.proc.LogInfo("- device %s: %5.2f%% done, %s" %

    # if we're done but degraded, let's do a few small retries, to

    # make sure we see a stable and not transient situation; therefore

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

      self.lu.LogInfo("Detaching %s drbd from local storage" % dev.iv_name)

      result.Raise("Can't detach drbd from local storage on node"

                   " %s for device %s" % (self.target_node, dev.iv_name))

      #dev.children = []

          rename_old_to_new.append((to_ren, ren_fn(to_ren, temp_suffix)))

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

      result.Raise("Can't rename old LVs on node %s" % self.target_node)

      # Now we rename the new LVs to the old LVs

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

      rename_new_to_old = [(new, old.physical_id)

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

      result.Raise("Can't rename new LVs on node %s" % self.target_node)

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

      # Now that the new lvs have the old name, we can add them to the device

      self.lu.LogInfo("Adding new mirror component on %s" % self.target_node)

      msg = result.fail_msg

      if msg:

        for new_lv in new_lvs:

          if msg2:

            self.lu.LogWarning("Can't rollback device %s: %s", dev, msg2,

                               hint=("cleanup manually the unused logical"

    # after this, we must manually remove the drbd minors on both the

    # error and the success paths

    self.lu.LogStep(4, steps_total, "Changing drbd configuration")

                                        self.instance.name)

    logging.debug("Allocated minors %r" % (minors,))

    iv_names = {}

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

      # create new devices on new_node; note that we create two IDs:

      # one without port, so the drbd will be activated without

      # networking information on the new node at this stage, and one

      else:

        p_minor = o_minor2

      iv_names[idx] = (dev, dev.children, new_net_id)

      logging.debug("Allocated new_minor: %s, new_logical_id: %s", new_minor,

                                 " soon as possible"))

    self.lu.LogInfo("Detaching primary drbds from the network (=> standalone)")

    msg = result.fail_msg

    if msg:

    # and now perform the drbd attach

    self.lu.LogInfo("Attaching primary drbds to new secondary"

                    " (standalone => connected)")

                                           False)

    for to_node, to_result in result.items():

      msg = to_result.fail_msg

      if msg:

                           hint=("please do a gnt-instance info to see the"

                                 " status of disks"))

class PingQuery(ConfdQuery):

  """An empty confd query.

  """

  def Exec(self, query):

        raise errors.JobQueueError("Can't read/parse the job queue serial file")

      if not must_lock:

        queue_lock.Unlock()

  except:

    @type force: boolean

    @param force: whether to force the reload without checking the mtime

    @rtype: boolean

    """

    try:

    """

    field_to_idx = dict([(field_name, idx)

    lvm_fields = []

    lvm_name_to_idx = dict([(lvm_name, idx)

                           for (idx, lvm_name) in enumerate(lvm_fields)])

    field_to_idx = dict([(field_name, idx)

    data = []

    for raw_data in cmd_result:

    self.assertEqual(utils.MergeTime((1, 500000)), 1.5)

    self.assertEqual(utils.MergeTime((1218448917, 500000)), 1218448917.5)

    self.assertEqual(round(utils.MergeTime((1, 801000)), 3), 1.801)

    self.assertRaises(AssertionError, utils.MergeTime, (0, -1))