Synnefo » snf-ganeti » ganeti-local

    """

    instance = objects.Instance.FromDict(params[0])

  @staticmethod

  def perspective_migration_info(params):

    """

    instance = objects.Instance.FromDict(params[0])

    reboot_type = params[1]

  @staticmethod

  def perspective_instance_info(params):

    """Encapsulates the start of an instance.

    """

    cli.SubmitOpCode(op, cl=client)

  def ActivateDisks(self):

  return block_devices

  """Start an instance.

  @type instance: L{objects.Instance}

  try:

    block_devices = _GatherAndLinkBlockDevs(instance)

    hyper = hypervisor.GetHypervisor(instance.hypervisor)

  except errors.BlockDeviceError, err:

    logging.exception("Failed to start instance")

    return (False, "Block device error: %s" % str(err))

  return (True, "Instance has been shutdown successfully")

  """Reboot an instance.

  @type instance: L{objects.Instance}

      stop_result = InstanceShutdown(instance)

      if not stop_result[0]:

        return stop_result

    except errors.HypervisorError, err:

      msg = "Failed to hard reboot instance %s: %s" % (instance.name, err)

      logging.error(msg)

    """

    instance = self.instance

    force = self.op.force

    self.cfg.MarkInstanceUp(instance.name)

    _StartInstanceDisks(self, instance, force)

    msg = result.RemoteFailMsg()

    if msg:

      _ShutdownInstanceDisks(self, instance)

    instance = self.instance

    ignore_secondaries = self.op.ignore_secondaries

    reboot_type = self.op.reboot_type

    node_current = instance.primary_node

      for disk in instance.disks:

        self.cfg.SetDiskID(disk, node_current)

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

      msg = result.RemoteFailMsg()

      if msg:

        raise errors.OpExecError("Could not reboot instance: %s" % msg)

                                 " full reboot: %s" % msg)

      _ShutdownInstanceDisks(self, instance)

      _StartInstanceDisks(self, instance, ignore_secondaries)

      msg = result.RemoteFailMsg()

      if msg:

        _ShutdownInstanceDisks(self, instance)

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

      feedback_fn("* starting the instance on the target node")

      msg = result.RemoteFailMsg()

      if msg:

        _ShutdownInstanceDisks(self, instance)

      self.cfg.Update(iobj)

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

      feedback_fn("* starting instance...")

      msg = result.RemoteFailMsg()

      if msg:

        raise errors.OpExecError("Could not start instance: %s" % msg)

    finally:

      if self.op.shutdown and instance.admin_up:

        msg = result.RemoteFailMsg()

        if msg:

          _ShutdownInstanceDisks(self, instance)

  def __init__(self):

    pass

    """Start an instance."""

    raise NotImplementedError

        raise errors.HypervisorError("Failed to list instances: %s" % err)

    return data

    """Start an instance.

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

    constants.HV_KERNEL_PATH,

    constants.HV_INITRD_PATH,

    constants.HV_ROOT_PATH,

    constants.HV_ACPI,

    constants.HV_SERIAL_CONSOLE,

    constants.HV_VNC_BIND_ADDRESS,

    return data

    """Generate KVM information to start an instance.

    """

      initrd_path = hvp[constants.HV_INITRD_PATH]

      if initrd_path:

        kvm_cmd.extend(['-initrd', initrd_path])

    mouse_type = hvp[constants.HV_USB_MOUSE]

    if mouse_type:

    for filename in temp_files:

      utils.RemoveFile(filename)

    """Start an instance.

    """

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

                                   (instance.name, "already running"))

    self._SaveKVMRuntime(instance, kvm_runtime)

    self._ExecuteKVMRuntime(instance, kvm_runtime)

  """

  @classmethod

    """Write the Xen config file for the instance.

    """

    xm_list = self._GetXMList(False)

    return xm_list

    """Start an instance.

    """

    result = utils.RunCmd(["xm", "create", instance.name])

    if result.failed:

    constants.HV_KERNEL_PATH,

    constants.HV_INITRD_PATH,

    constants.HV_ROOT_PATH,

    ]

  @classmethod

                                   " not a file" % initrd_path)

  @classmethod

    """Write the Xen config file for the instance.

    """

                 cls._GetConfigFileDiskData(instance.disk_template,

                                            block_devices)))

    config.write("on_poweroff = 'destroy'\n")

    config.write("on_reboot = 'restart'\n")

    config.write("on_crash = 'restart'\n")

    # just in case it exists

    utils.RemoveFile("/etc/xen/auto/%s" % instance.name)

    try:

                                   iso_path)

  @classmethod

    """Create a Xen 3.1 HVM config file.

    """

    config.write("on_poweroff = 'destroy'\n")

    config.write("on_reboot = 'restart'\n")

    config.write("on_crash = 'restart'\n")

    # just in case it exists

    utils.RemoveFile("/etc/xen/auto/%s" % instance.name)

    try:

  """Startup an instance."""

  OP_ID = "OP_INSTANCE_STARTUP"

  OP_DSC_FIELD = "instance_name"

class OpShutdownInstance(OpCode):

  """Reboot an instance."""

  OP_ID = "OP_INSTANCE_REBOOT"

  OP_DSC_FIELD = "instance_name"

class OpReplaceDisks(OpCode):

    """

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

    """Starts an instance.

    This is a single-node call.

    """

    return self._SingleNodeCall(node, "instance_start",

  def call_instance_shutdown(self, node, instance):

    """Stops an instance.

    return self._SingleNodeCall(node, "instance_migrate",

                                [self._InstDict(instance), target, live])

    """Reboots an instance.

    This is a single-node call.

    """

    return self._SingleNodeCall(node, "instance_reboot",

  def call_instance_os_add(self, node, inst):

    """Installs an OS on the given instance.

            </varlistentry>

            <varlistentry>

              <term>initrd_path</term>

              <listitem>

                <simpara>Valid for the Xen PVM and KVM hypervisors.</simpara>

        <cmdsynopsis>

          <command>startup</command>

          <sbr>

          <arg>--force</arg>

          <sbr>

          <arg>--force-multiple</arg>

        </para>

        <para>

          Use <option>--force</option> to start even if secondary disks are

          failing.

        </para>

          Example:

          <screen>

# gnt-instance start instance1.example.com

# gnt-instance start --node node1.example.com node2.example.com

# gnt-instance start --all

          </screen>

        <cmdsynopsis>

          <command>reboot</command>

          <sbr>

          <arg>--type=<replaceable>REBOOT-TYPE</replaceable></arg>

          <sbr>

          <arg>--ignore-secondaries</arg>

  jex = cli.JobExecutor(verbose=multi_on, cl=cl)

  for name in inames:

    op = opcodes.OpStartupInstance(instance_name=name,

    jex.QueueJob(name, op)

  jex.WaitOrShow(not opts.submit_only)

  return 0

               "<instance>", "Stops an instance"),

  'startup': (StartupInstance, ARGS_ANY,

              [DEBUG_OPT, FORCE_OPT, m_force_multi,

               m_node_opt, m_pri_node_opt, m_sec_node_opt,

               m_clust_opt, m_inst_opt,

               SUBMIT_OPT,

  'reboot': (RebootInstance, ARGS_ANY,

              [DEBUG_OPT, m_force_multi,

               make_option("-t", "--type", dest="reboot_type",

                           help="Type of reboot: soft/hard/full",

                           default=constants.INSTANCE_REBOOT_HARD,