Synnefo » snf-ganeti » ganeti-local

from ganeti import utils

from ganeti.cmdlib.base import LogicalUnit, NoHooksLU

from ganeti.cmdlib.common import INSTANCE_ONLINE, INSTANCE_DOWN, \

class LUInstanceStartup(LogicalUnit):

      "FORCE": self.op.force,

      }

    return env

      filled_hvp.update(self.op.hvparams)

      hv_type = hypervisor.GetHypervisorClass(instance.hypervisor)

      hv_type.CheckParameterSyntax(filled_hvp)

    self.primary_offline = self.cfg.GetNodeInfo(instance.primary_node).offline

      if self.op.hvparams or self.op.beparams:

        self.LogWarning("Overridden parameters are ignored")

    else:

      bep = self.cfg.GetClusterInfo().FillBE(instance)

      bep.update(self.op.beparams)

      # check bridges existence

      remote_info = self.rpc.call_instance_info(instance.primary_node,

                                                instance.name,

      remote_info.Raise("Error checking node %s" % instance.primary_node,

                        prereq=True, ecode=errors.ECODE_ENVIRON)

      if not remote_info.payload: # not running already

  def Exec(self, feedback_fn):

    """Start the instance.

    else:

      node_current = instance.primary_node

      result = \

        self.rpc.call_instance_start(node_current,

                                     self.op.startup_paused, reason)

      msg = result.fail_msg

      if msg:

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

    This runs on master, primary and secondary nodes of the instance.

    """

    env["TIMEOUT"] = self.op.timeout

    return env

      "Cannot retrieve locked instance %s" % self.op.instance_name

    if not self.op.force:

    else:

      self.LogWarning("Ignoring offline instance check")

    if self.primary_offline and self.op.ignore_offline_nodes:

      self.LogWarning("Ignoring offline primary node")

    else:

  def Exec(self, feedback_fn):

    """Shutdown the instance.

      if msg:

        self.LogWarning("Could not shutdown instance: %s", msg)

class LUInstanceReinstall(LogicalUnit):

    This runs on master, primary and secondary nodes of the instance.

    """

  def BuildHooksNodes(self):

    """Build hooks nodes.

    instance = self.cfg.GetInstanceInfo(self.op.instance_name)

    assert instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    if instance.disk_template == constants.DT_DISKLESS:

      raise errors.OpPrereqError("Instance '%s' has no disks" %

                                 self.op.instance_name,

                                 errors.ECODE_INVAL)

    if self.op.os_type is not None:

      # OS verification

      instance_os = self.op.os_type

    else:

      instance_os = instance.os

    nodelist = list(instance.all_nodes)

    if self.op.osparams:

      self.os_inst = i_osdict # the new dict (without defaults)

    else:

      self.os_inst = None

      # Write to configuration

      self.cfg.Update(inst, feedback_fn)

    try:

      feedback_fn("Running the instance OS create scripts...")

      # FIXME: pass debug option from opcode to backend

      result.Raise("Could not install OS for instance %s on node %s" %

                   (inst.name, inst.primary_node))

    finally:

class LUInstanceReboot(LogicalUnit):

      "SHUTDOWN_TIMEOUT": self.op.shutdown_timeout,

      }

    return env

    self.instance = instance = self.cfg.GetInstanceInfo(self.op.instance_name)

    assert self.instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

    # check bridges existence

  def Exec(self, feedback_fn):

    """Reboot the instance.

                                                 self.op.shutdown_timeout,

                                                 reason)

        result.Raise("Could not shutdown instance for full reboot")

      else:

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

                     instance.name)

      result = self.rpc.call_instance_start(node_current,

                                            (instance, None, None), False,

                                            reason)

      msg = result.fail_msg

      if msg:

        raise errors.OpExecError("Could not start instance for"

                                 " full reboot: %s" % msg)

    self.cfg.MarkInstanceUp(instance.name)

  """Returns console information for an instance.

  @type cluster: L{objects.Cluster}

  REQ_BGL = False

  def ExpandNames(self):

    self._ExpandAndLockInstance()

  def CheckPrereq(self):

    self.instance = self.cfg.GetInstanceInfo(self.op.instance_name)

    assert self.instance is not None, \

      "Cannot retrieve locked instance %s" % self.op.instance_name

  def Exec(self, feedback_fn):

    """Connect to the console of an instance

    logging.debug("Connecting to console of %s on %s", instance.name, node)