Synnefo » snf-ganeti » ganeti-local

  return block_devices

  """Start an instance.

  @type instance: L{objects.Instance}

  @param instance: the instance object

  @rtype: None

  """

  try:

    block_devices = _GatherAndLinkBlockDevs(instance)

    hyper = hypervisor.GetHypervisor(instance.hypervisor)

  except errors.BlockDeviceError, err:

    _Fail("Block device error: %s", err, exc=True)

  except errors.HypervisorError, err:

  "SRC_DIR_OPT",

  "SRC_NODE_OPT",

  "SUBMIT_OPT",

  "STATIC_OPT",

  "SYNC_OPT",

  "TAG_ADD_OPT",

                                     " disk templates, e.g. %s)" %

                                     utils.CommaJoin(constants.DTS_INT_MIRROR))

#: Options provided by all commands

COMMON_OPTS = [DEBUG_OPT]

  op = opcodes.OpInstanceStartup(instance_name=name,

                                 force=opts.force,

                                 ignore_offline_nodes=opts.ignore_offline,

  # do not add these parameters to the opcode unless they're defined

  if opts.hvparams:

    op.hvparams = opts.hvparams

     m_node_tags_opt, m_pri_node_tags_opt, m_sec_node_tags_opt,

     m_inst_tags_opt, m_clust_opt, m_inst_opt, SUBMIT_OPT, HVOPTS_OPT,

     BACKEND_OPT, DRY_RUN_OPT, PRIORITY_OPT, IGNORE_OFFLINE_OPT,

    "<instance>", "Starts an instance"),

  'reboot': (

    GenericManyOps("reboot", _RebootInstance), [ArgInstance()],

      _StartInstanceDisks(self, instance, force)

      result = self.rpc.call_instance_start(node_current, instance,

      msg = result.fail_msg

      if msg:

        _ShutdownInstanceDisks(self, instance)

        self.LogInfo("Instance %s was already stopped, starting now",

                     instance.name)

      _StartInstanceDisks(self, instance, ignore_secondaries)

      msg = result.fail_msg

      if msg:

        _ShutdownInstanceDisks(self, instance)

        _ShutdownInstanceDisks(self, instance)

        raise errors.OpExecError("Can't activate the instance's disks")

      msg = result.fail_msg

      if msg:

        _ShutdownInstanceDisks(self, instance)

      self.cfg.Update(iobj, feedback_fn)

      logging.info("Starting instance %s on node %s", instance, pnode_name)

      feedback_fn("* starting instance...")

      result.Raise("Could not start instance")

    return list(iobj.all_nodes)

            not self.op.remove_instance):

          assert not activate_disks

          feedback_fn("Starting instance %s" % instance.name)

          msg = result.fail_msg

          if msg:

            feedback_fn("Failed to start instance: %s" % msg)

  def __init__(self):

    pass

    """Start an instance."""

    raise NotImplementedError

        data.append((file_name, 0, 0, 0, 0, 0))

    return data

    """Start an instance.

    For the chroot manager, we try to mount the block device and

    file_name = self._InstanceFile(instance_name)

    utils.RemoveFile(file_name)

    """Start an instance.

    For the fake hypervisor, it just creates a file in the base dir,

        data.append(info)

    return data

    """Generate KVM information to start an instance.

    """

    kvm_cmd.extend(['-daemonize'])

    if not instance.hvparams[constants.HV_ACPI]:

      kvm_cmd.extend(['-no-acpi'])

    hvp = instance.hvparams

    boot_disk = hvp[constants.HV_BOOT_ORDER] == constants.HT_BO_DISK

    for filename in temp_files:

      utils.RemoveFile(filename)

    """Start an instance.

    """

    self._CheckDown(instance.name)

    self._SaveKVMRuntime(instance, kvm_runtime)

    self._ExecuteKVMRuntime(instance, kvm_runtime)

    return "\n".join(out) + "\n"

    """Start an instance.

    For LCX, we try to mount the block device and execute 'lxc-start'.

    xm_list = self._GetXMList(False)

    return xm_list

    """Start an instance.

    """

    self._WriteConfigFile(instance, block_devices)

    if result.failed:

      raise errors.HypervisorError("Failed to start instance %s: %s (%s)" %

_PMigrationTargetNode = ("target_node", None, ht.TMaybeString,

                         "Target node for shared-storage instances")

#: OP_ID conversion regular expression

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

     "Temporary hypervisor parameters, hypervisor-dependent"),

    ("beparams", ht.EmptyDict, ht.TDict, "Temporary backend parameters"),

    _PNoRemember,

    ]

    return self._SingleNodeCall(node, "bridges_exist", [bridges_list])

  @_RpcTimeout(_TMO_NORMAL)

    """Starts an instance.

    This is a single-node call.

    """

    idict = self._InstDict(instance, hvp=hvp, bep=bep)

  @_RpcTimeout(_TMO_NORMAL)

  def call_instance_shutdown(self, node, instance, timeout):

    """Start an instance.

    """

  @staticmethod

  def perspective_migration_info(params):

| --tags \| --node-tags \| --pri-node-tags \| --sec-node-tags]

| [{-H|--hypervisor-parameters} ``key=value...``]

| [{-B|--backend-parameters} ``key=value...``]

| {*name*...}

Starts one or more instances, depending on the following options.  The

    will start all instances in the cluster on secondary nodes with the

    tags given as arguments

Note that although you can pass more than one selection option, the

last one wins, so in order to guarantee the desired result, don't pass

more than one such option.

completion. The job ID will be shown so that it can be examined via

**gnt-job info**.

Example::

    # gnt-instance start instance1.example.com

HVM instance, use a VNC client with the connection info from the

**info** command.

Example::

    # gnt-instance console instance1.example.com