Synnefo » snf-ganeti

  "YES_DOIT_OPT",

  "DISK_STATE_OPT",

  "HV_STATE_OPT",

  # Generic functions for CLI programs

  "ConfirmOperation",

  "GenericMain",

                                " format hypervisor:option=value,..."),

                          type="identkeyval")

#: Options provided by all commands

COMMON_OPTS = [DEBUG_OPT]

                                  ignore_consistency=opts.ignore_consistency,

                                  shutdown_timeout=opts.shutdown_timeout,

                                  iallocator=iallocator,

  SubmitOrSend(op, opts, cl=cl)

  return 0

  "failover": (

    FailoverInstance, ARGS_ONE_INSTANCE,

    [FORCE_OPT, IGNORE_CONSIST_OPT, SUBMIT_OPT, SHUTDOWN_TIMEOUT_OPT,

    "[-f] <instance>", "Stops the instance, changes its primary node and"

    " (if it was originally running) starts it on the new node"

    " (the secondary for mirrored instances or any node"

                                       cleanup=False,

                                       failover=True,

                                       ignore_consistency=ignore_consistency,

    self.tasklets = [self._migrater]

  def DeclareLocks(self, level):

                            and target node

  @type shutdown_timeout: int

  @ivar shutdown_timeout: In case of failover timeout of the shutdown

  """

  def __init__(self, lu, instance_name, cleanup=False,

               failover=False, fallback=False,

               ignore_consistency=False,

    """Initializes this class.

    """

    self.fallback = fallback

    self.ignore_consistency = ignore_consistency

    self.shutdown_timeout = shutdown_timeout

  def CheckPrereq(self):

    """Check prerequisites.

    instance = self.cfg.GetInstanceInfo(instance_name)

    assert instance is not None

    self.instance = instance

    if (not self.cleanup and

        not instance.admin_state == constants.ADMINST_UP and

        # BuildHooksEnv

        self.target_node = self.lu.op.target_node

      # self.target_node is already populated, either directly or by the

      # iallocator run

      target_node = self.target_node

                                   " node can be passed)" %

                                   (instance.disk_template, text),

                                   errors.ECODE_INVAL)

    # check memory requirements on the secondary node

    if not self.failover or instance.admin_state == constants.ADMINST_UP:

        self.lu.op.live = None

      elif self.lu.op.mode is None:

        # read the default value from the hypervisor

        self.lu.op.mode = i_hv[constants.HV_MIGRATION_MODE]

      self.live = self.lu.op.mode == constants.HT_MIGRATION_LIVE

    """Run the allocator based on input opcode.

    """

    ial = IAllocator(self.cfg, self.rpc,

                     mode=constants.IALLOCATOR_MODE_RELOC,

                     name=self.instance_name,

_PHvState = ("hv_state", None, ht.TMaybeDict, "Set hypervisor states")

_PDiskState = ("disk_state", None, ht.TMaybeDict, "Set disk states")

#: OP_ID conversion regular expression

_OPID_RE = re.compile("([a-z])([A-Z])")

    _PShutdownTimeout,

    _PIgnoreConsistency,

    _PMigrationTargetNode,

    ("iallocator", None, ht.TMaybeString,

     "Iallocator for deciding the target node for shared-storage instances"),

    ]

^^^^^^^^

**failover** [-f] [--ignore-consistency] [--shutdown-timeout=*N*]

Failover will stop the instance (if running), change its primary node,

and if it was originally running it will start it again (on the new

but not wait for its completion. The job ID will be shown so that it

can be examined via **gnt-job info**.

Example::

    # gnt-instance failover instance1.example.com