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,