Synnefo » snf-ganeti

  return block_devices

  """Start an instance.

  @type instance: L{objects.Instance}

  @param instance: the instance object

  @type startup_paused: bool

  @param instance: pause instance at startup?

  @rtype: None

  """

    block_devices = _GatherAndLinkBlockDevs(instance)

    hyper = hypervisor.GetHypervisor(instance.hypervisor)

    hyper.StartInstance(instance, block_devices, startup_paused)

  except errors.BlockDeviceError, err:

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

  except errors.HypervisorError, err:

  elif reboot_type == constants.INSTANCE_REBOOT_HARD:

    try:

      InstanceShutdown(instance, shutdown_timeout, reason, store_reason=False)

      _StoreInstReasonTrail(instance.name, reason)

      return result

    except errors.HypervisorError, err:

    """

    instance = self.instance

    force = self.op.force

    if not self.op.no_remember:

      self.cfg.MarkInstanceUp(instance.name)

        self.rpc.call_instance_start(node_current,

                                     (instance, self.op.hvparams,

                                      self.op.beparams),

      msg = result.fail_msg

      if msg:

        _ShutdownInstanceDisks(self, instance)

                     instance.name)

      _StartInstanceDisks(self, instance, ignore_secondaries)

      result = self.rpc.call_instance_start(node_current,

      msg = result.fail_msg

      if msg:

        _ShutdownInstanceDisks(self, instance)

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

      result = self.rpc.call_instance_start(target_node,

      msg = result.fail_msg

      if msg:

        _ShutdownInstanceDisks(self, instance)

      self.feedback_fn("* starting the instance on the target node %s" %

                       target_node)

      result = self.rpc.call_instance_start(target_node, (instance, None, None),

      msg = result.fail_msg

      if msg:

        _ShutdownInstanceDisks(self.lu, instance)

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

      feedback_fn("* starting instance...")

      result = self.rpc.call_instance_start(pnode_name, (iobj, None, None),

      result.Raise("Could not start instance")

    return list(iobj.all_nodes)

          assert not activate_disks

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

          result = self.rpc.call_instance_start(src_node,

          msg = result.fail_msg

          if msg:

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

                             ("/%s/instances/%s/shutdown" %

                              (GANETI_RAPI_VERSION, instance)), query, body)

    """Starts up an instance.

    @type instance: str

    @param dry_run: whether to perform a dry run

    @type no_remember: bool

    @param no_remember: if true, will not record the state change

    @rtype: string

    @return: job id

    query = []

    _AppendDryRunIf(query, dry_run)

    _AppendIf(query, no_remember, ("no_remember", 1))

    return self._SendRequest(HTTP_PUT,

                             ("/%s/instances/%s/startup" %

  ("instance_start", SINGLE, None, constants.RPC_TMO_NORMAL, [

    ("instance_hvp_bep", ED_INST_DICT_HVP_BEP_DP, None),

    ("startup_paused", None, None),

    ], None, None, "Starts an instance"),

  ("instance_os_add", SINGLE, None, constants.RPC_TMO_1DAY, [

    ("instance_osp", ED_INST_DICT_OSP_DP, None),

    """Start an instance.

    """

    instance = objects.Instance.FromDict(instance_name)

  @staticmethod

  def perspective_migration_info(params):

  def testStartupInstance(self):

    self.rapi.AddResponse("27149")

    self.assertEqual(27149, self.client.StartupInstance("bar-instance",

                                                        dry_run=True))

    self.assertHandler(rlib2.R_2_instances_name_startup)

    self.assertItems(["bar-instance"])

    self.assertDryRun()

  def testReinstallInstance(self):

    self.rapi.AddResponse(serializer.DumpJson([]))

    handler = _CreateHandler(rlib2.R_2_instances_name_startup, ["inst31083"], {

      "force": ["1"],

      "no_remember": ["1"],

      }, {}, clfactory)

    job_id = handler.PUT()

    self.assertTrue(op.no_remember)

    self.assertTrue(op.force)

    self.assertFalse(op.dry_run)

    self.assertRaises(IndexError, cl.GetNextSubmittedJob)