Synnefo » snf-ganeti

USAGE = ("\tburnin -o OS_NAME [options...] instance_name ...")

MAX_RETRIES = 3

class InstanceDown(Exception):

  """The checked instance was not up"""

  sys.exit(2)

  """Simple function that prints out its argument.

  """

  sys.stdout.write("%*s%s%s\n" % (2*indent, "",

  sys.stdout.flush()

def Err(msg, exit_code=1):

  """Simple error logging that prints to stderr.

    try:

      val = fn(*args)

      if retry_count > 0 and retry_count < MAX_RETRIES:

      return val

    except Exception, err: # pylint: disable-msg=W0703

      if retry_count == 0:

        raise

      elif retry_count == 1:

        raise

      else:

        self.MaybeRetry(retry_count - 1, msg, fn, *args)

  def _SetDebug(self, ops):

    """

    self.ClearFeedbackBuf()

    job_ids = [cli.SendJob(row[0], cl=self.cl) for row in jobs]

    results = []

    for jid, (_, iname) in zip(job_ids, jobs):

      try:

        results.append(cli.PollJob(jid, cl=self.cl, feedback_fn=self.Feedback))

      except Exception, err: # pylint: disable-msg=W0703

    if len(results) != len(jobs):

      raise BurninFailure()

    return results

    Log("Creating instances")

    for pnode, snode, instance in mytor:

      if self.opts.iallocator:

        pnode = snode = None

        msg = "with iallocator %s" % self.opts.iallocator

    """Grow both the os and the swap disks by the requested amount, if any."""

    Log("Growing disks")

    for instance in self.instances:

      for idx, growth in enumerate(self.disk_growth):

        if growth > 0:

          op = opcodes.OpGrowDisk(instance_name=instance, disk=idx,

                                  amount=growth, wait_for_sync=True)

          self.ExecOrQueue(instance, op)

  @_DoBatch(True)

    """Replace disks on primary and secondary for drbd8."""

    Log("Replacing disks on the same nodes")

    for instance in self.instances:

      ops = []

      for mode in constants.REPLACE_DISK_SEC, constants.REPLACE_DISK_PRI:

        op = opcodes.OpReplaceDisks(instance_name=instance,

                                    mode=mode,

                                    disks=[i for i in range(self.disk_count)],

                                    early_release=self.opts.early_release)

        ops.append(op)

      self.ExecOrQueue(instance, *ops) # pylint: disable-msg=W0142

    mytor = izip(islice(cycle(self.nodes), 2, None),

                 self.instances)

    for tnode, instance in mytor:

      if self.opts.iallocator:

        tnode = None

        msg = "with iallocator %s" % self.opts.iallocator

                                  iallocator=self.opts.iallocator,

                                  disks=[],

                                  early_release=self.opts.early_release)

      self.ExecOrQueue(instance, op)

  @_DoCheckInstances

    """Failover the instances."""

    Log("Failing over instances")

    for instance in self.instances:

      op = opcodes.OpFailoverInstance(instance_name=instance,

                                      ignore_consistency=False)

      self.ExecOrQueue(instance, op)

    mytor = izip(islice(cycle(self.nodes), 1, None),

                 self.instances)

    for tnode, instance in mytor:

      op = opcodes.OpMoveInstance(instance_name=instance,

                                  target_node=tnode)

      self.ExecOrQueue(instance, op)

    """Migrate the instances."""

    Log("Migrating instances")

    for instance in self.instances:

      op1 = opcodes.OpMigrateInstance(instance_name=instance, live=True,

                                      cleanup=False)

                 self.instances)

    for pnode, snode, enode, instance in mytor:

      # read the full name of the instance

      nam_op = opcodes.OpQueryInstances(output_fields=["name"],

                                        names=[instance], use_locking=True)

      erem_op = opcodes.OpRemoveExport(instance_name=instance)

      Log("remove instance", indent=2)

      Log(import_log_msg, indent=2)

      Log("remove export", indent=2)

    """Stop/start the instances."""

    Log("Stopping and starting instances")

    for instance in self.instances:

      op1 = self.StopInstanceOp(instance)

      op2 = self.StartInstanceOp(instance)

      self.ExecOrQueue(instance, op1, op2)

    """Remove the instances."""

    Log("Removing instances")

    for instance in self.to_rem:

      op = opcodes.OpRemoveInstance(instance_name=instance,

                                    ignore_failures=True)

      self.ExecOrQueue(instance, op)

    Log("Renaming instances")

    rename = self.opts.rename

    for instance in self.instances:

      op_stop1 = self.StopInstanceOp(instance)

      op_stop2 = self.StopInstanceOp(rename)

      op_rename1 = self.RenameInstanceOp(instance, rename)

    """Reinstall the instances."""

    Log("Reinstalling instances")

    for instance in self.instances:

      op1 = self.StopInstanceOp(instance)

      op2 = opcodes.OpReinstallInstance(instance_name=instance)

      Log("reinstall without passing the OS", indent=2)

    """Reboot the instances."""

    Log("Rebooting instances")

    for instance in self.instances:

      ops = []

      for reboot_type in constants.REBOOT_TYPES:

        op = opcodes.OpRebootInstance(instance_name=instance,

                                      reboot_type=reboot_type,

                                      ignore_secondaries=False)

        ops.append(op)

      self.ExecOrQueue(instance, *ops) # pylint: disable-msg=W0142

    """Activate and deactivate disks of the instances."""

    Log("Activating/deactivating disks")

    for instance in self.instances:

      op_start = self.StartInstanceOp(instance)

      op_act = opcodes.OpActivateInstanceDisks(instance_name=instance)

      op_deact = opcodes.OpDeactivateInstanceDisks(instance_name=instance)

    """Add and remove an extra disk for the instances."""

    Log("Adding and removing disks")

    for instance in self.instances:

      op_add = opcodes.OpSetInstanceParams(\

        instance_name=instance,

        disks=[(constants.DDM_ADD, {"size": self.disk_size[0]})])

    """Add and remove an extra NIC for the instances."""

    Log("Adding and removing NICs")

    for instance in self.instances:

      op_add = opcodes.OpSetInstanceParams(\

        instance_name=instance, nics=[(constants.DDM_ADD, {})])

      op_rem = opcodes.OpSetInstanceParams(\

        except Exception, err:  # pylint: disable-msg=W0703

          if has_err: # already detected errors, so errors in removal

                      # are quite expected

          else: # non-expected error

            raise