Synnefo » snf-ganeti

  return results

  """Gives back the information about an instance as a dictionary.

  @type instance: string

  @param instance: the instance name

  @type hname: string

  @param hname: the hypervisor type of the instance

  @rtype: dict

  @return: dictionary with the following keys:

  """

  output = {}

  if iinfo is not None:

    output["memory"] = iinfo[2]

    output["vcpus"] = iinfo[3]

    if (self.op.pnode is not None and self.op.pnode != pnode and

        not self.op.force):

      # verify that the instance is not up

      if instance_info.fail_msg:

        self.warn.append("Can't get instance runtime information: %s" %

                         instance_info.fail_msg)

        # either we changed auto_balance to yes or it was from before

        mem_check_list.extend(instance.secondary_nodes)

      instance_info = self.rpc.call_instance_info(

      hvspecs = [(instance.hypervisor, cluster.hvparams[instance.hypervisor])]

      nodeinfo = self.rpc.call_node_info(mem_check_list, None,

                                         hvspecs, False)

                                       errors.ECODE_STATE)

    if self.op.runtime_mem:

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

      if not remote_info.payload: # not running already

        raise errors.OpPrereqError("Instance %s is not running" %

      self.live = False

    if not (self.failover or self.cleanup):

      remote_info.Raise("Error checking instance on node %s" %

                        instance.primary_node)

      instance_running = bool(remote_info.payload)

    assert self.instance is not None, \

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

    # extra hvparams

    if self.op.hvparams:

      # check hypervisor parameter syntax (locally)

      utils.ForceDictType(self.op.hvparams, constants.HVS_PARAMETER_TYPES)

      filled_hvp = cluster.FillHV(instance)

      filled_hvp.update(self.op.hvparams)

      # check bridges existence

      CheckInstanceBridgesExist(self, instance)

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

                        prereq=True, ecode=errors.ECODE_ENVIRON)

      if not remote_info.payload: # not running already

    reboot_type = self.op.reboot_type

    reason = self.op.reason

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

    instance_running = bool(remote_info.payload)

                          " information only for instance %s" %

                          (pnode.name, instance.name))

      else:

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

        remote_info = remote_info.payload

        if remote_info and "state" in remote_info:

    """Get the list of running instances."""

    raise NotImplementedError

    """Get instance properties.

    @type instance_name: string

    @param instance_name: the instance name

    @return: tuple (name, id, memory, vcpus, state, times)

    """

    raise NotImplementedError

    """Get the correct startup memory for an instance

    This function calculates how much memory an instance should be started

    @return: memory the instance should be started with

    """

    max_start_mem = min(instance.beparams[constants.BE_MAXMEM], free_memory)

    start_mem = max(instance.beparams[constants.BE_MINMEM], max_start_mem)

    return start_mem

    return [name for name in os.listdir(self._ROOT_DIR)

            if self._IsDirLive(utils.PathJoin(self._ROOT_DIR, name))]

    """Get instance properties.

    @type instance_name: string

    @param instance_name: the instance name

    @return: (name, id, memory, vcpus, stat, times)

    """

    return os.listdir(self._ROOT_DIR)

    """Get instance properties.

    @param instance_name: the instance name

    @return: tuple of (name, id, memory, vcpus, stat, times)

        result.append(name)

    return result

    """Get instance properties.

    @type instance_name: string

    @param instance_name: the instance name

    @rtype: tuple of strings

    @return: (name, id, memory, vcpus, stat, times)

    """

    return [iinfo[0] for iinfo in self.GetAllInstancesInfo()]

    """Get instance properties.

    @type instance_name: string

    @param instance_name: the instance name

    @rtype: tuple of strings

    @return: (name, id, memory, vcpus, stat, times)

    names = [info[0] for info in instance_list]

    return names

    """Get instance properties.

    @param instance_name: the instance name

    @return: tuple (name, id, memory, vcpus, stat, times)

    """

    result = None

    for data in instance_list:

      if data[0] == instance_name:

    """Start an instance.

    """

    self._MakeConfigFile(instance, startup_memory, block_devices)

    """Reboot an instance.

    """

    if ini_info is None:

      raise errors.HypervisorError("Failed to reboot instance %s,"

                                    result.output))

    def _CheckInstance():

      # check if the domain ID has changed or the run time has decreased

      if (new_info is not None and

  ("instance_info", SINGLE, None, constants.RPC_TMO_URGENT, [

    ("instance", None, "Instance name"),

    ("hname", None, "Hypervisor type"),

    ], None, None, "Returns information about a single instance"),

  ("all_instances_info", MULTI, None, constants.RPC_TMO_URGENT, [

    ("hypervisor_list", None, "Hypervisors to query for instances"),

    """Query instance information.

    """

  @staticmethod

  def perspective_instance_migratable(params):