Synnefo » snf-ganeti » ganeti-local

    # memory check on primary node

    #TODO(dynmem): use MINMEM for checking

    if self.op.start:

      CheckNodeFreeMemory(self, self.pnode.name,

                          "creating instance %s" % self.op.instance_name,

                          self.be_full[constants.BE_MAXMEM],

    self.dry_run_result = list(nodenames)

    if instance.admin_state == constants.ADMINST_UP:

      # check memory requirements on the secondary node

    else:

      self.LogInfo("Not checking memory on the secondary node as"

                   " instance will not be started")

  return [(op, idx, params, fn()) for (op, idx, params) in mods]

  """Checks if nodes have enough physical CPUs

  This function checks if all given nodes have the needed number of

  @param nodenames: the list of node names to check

  @type requested: C{int}

  @param requested: the minimum acceptable number of physical CPUs

  @raise errors.OpPrereqError: if the node doesn't have enough CPUs,

      or we cannot check the node

  """

  for node in nodenames:

    info = nodeinfo[node]

    info.Raise("Cannot get current information from node %s" % node,

        max_requested_cpu = max(map(max, cpu_list))

        # Check that all of the instance's nodes have enough physical CPUs to

        # satisfy the requested CPU mask

        _CheckNodesPhysicalCPUs(self, instance.all_nodes,

    # osparams processing

    if self.op.osparams:

      if be_new[constants.BE_AUTO_BALANCE]:

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

        mem_check_list.extend(instance.secondary_nodes)

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

      pninfo = nodeinfo[pnode]

      msg = pninfo.fail_msg

      if msg:

      delta = self.op.runtime_mem - current_memory

      if delta > 0:

    def _PrepareNicCreate(_, params, private):

      self._PrepareNicModification(params, private, None, None,

    # check memory requirements on the secondary node

    if (not self.cleanup and

         (not self.failover or instance.admin_state == constants.ADMINST_UP)):

    else:

      self.lu.LogInfo("Not checking memory on the secondary node as"

                      " instance will not be started")

    source_node = self.source_node

    # Check for hypervisor version mismatch and warn the user.

    nodeinfo = self.rpc.call_node_info([source_node, target_node],

    for ninfo in nodeinfo.values():

      ninfo.Raise("Unable to retrieve node information from node '%s'" %

                  ninfo.node)

      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.

  return "originstname+%s" % instance.name

  """Checks if a node has enough free memory.

  This function checks if a given node has the needed amount of free

  @param reason: string to use in the error message

  @type requested: C{int}

  @param requested: the amount of memory in MiB to check for

  @rtype: integer

  @return: node current free memory

  @raise errors.OpPrereqError: if the node doesn't have enough memory, or

      we cannot check the node

  """

  nodeinfo[node].Raise("Can't get data from node %s" % node,

                       prereq=True, ecode=errors.ECODE_ENVIRON)

  (_, _, (hv_info, )) = nodeinfo[node].payload

      # FIXME: This currently maps everything to lvm, this should be more

      # flexible

      vg_req = rpc.BuildVgInfoQuery(lu.cfg)

      node_data = lu.rpc.call_node_info(toquery_nodes, vg_req,

      live_data = dict((name, rpc.MakeLegacyNodeInfo(nresult.payload))

                       for (name, nresult) in node_data.items()

                       if not nresult.fail_msg and nresult.payload)

    es_flags = rpc.GetExclusiveStorageForNodeNames(cfg, node_list)

    vg_req = rpc.BuildVgInfoQuery(cfg)

    has_lvm = bool(vg_req)

    node_data = self.rpc.call_node_info(node_list, vg_req,

    node_iinfo = \

      self.rpc.call_all_instances_info(node_list,

                                       cluster_info.enabled_hypervisors)