Synnefo » snf-ganeti

  ]))

  """Expand an item name.

  @param name: requested item name

  @param kind: text description ('Node' or 'Instance')

  @raise errors.OpPrereqError: if the item is not found

  """

  if full_name is None:

    raise errors.OpPrereqError("%s '%s' not known" % (kind, name),

                               errors.ECODE_NOENT)

  return _ExpandItemName(cfg.ExpandInstanceName, name, "Instance")

def ShareAll():

  return wanted_instances

  """Returns list of checked and expanded node names.

  @type lu: L{LogicalUnit}

  @param lu: the logical unit on whose behalf we execute

  @raise errors.ProgrammerError: if the nodes parameter is wrong type

  """

def GetWantedInstances(lu, instances):

  """

  hm = lu.proc.BuildHooksManager(lu)

  try:

  except Exception, err: # pylint: disable=W0703

    lu.LogWarning("Errors occurred running hooks on %s: %s",

                  node_name, err)

  """Distribute additional files which are part of the cluster configuration.

  ConfigWriter takes care of distributing the config and ssconf files, but

  there are more files which should be distributed to all nodes. This function

  makes sure those are copied.

  """

  # Gather target nodes

  cluster = lu.cfg.GetClusterInfo()

  master_info = lu.cfg.GetNodeInfo(lu.cfg.GetMasterNode())

  # Never distribute to master node

  # Gather file lists

  (files_all, _, files_mc, files_vm) = \

  assert not files_mc, "Master candidates not handled in this function"

  filemap = [

    ]

  # Upload the files

    for fname in files:

def ComputeAncillaryFiles(cluster, redist):

  return (files_all, files_opt, files_mc, files_vm)

  """Helper for uploading a file and showing warnings.

  """

  if os.path.exists(fname):

      msg = to_result.fail_msg

      if msg:

        msg = ("Copy of file %s to node %s failed: %s" %

        lu.LogWarning(msg)

  return None

  """OS parameters validation.

  @type lu: L{LogicalUnit}

  @type required: boolean

  @param required: whether the validation should fail if the OS is not

      found

  @type osname: string

  @param osname: the name of the hypervisor we should use

  @type osparams: dict

  @raise errors.OpPrereqError: if the parameters are not valid

  """

                                   [constants.OS_VALIDATE_PARAMETERS],

                                   osparams)

    # we don't check for offline cases since this should be run only

    # against the master node and/or an instance's nodes

    if not nres.payload:

      lu.LogInfo("OS %s not found on node %s, validation skipped",

  """Hypervisor parameter validation.

  This function abstract the hypervisor parameter validation to be

  @type lu: L{LogicalUnit}

  @param lu: the logical unit for which we check

  @type hvname: string

  @param hvname: the name of the hypervisor we should use

  @type hvparams: dict

  @raise errors.OpPrereqError: if the parameters are not valid

  """

  cluster = lu.cfg.GetClusterInfo()

  hvfull = objects.FillDict(cluster.hvparams.get(hvname, {}), hvparams)

    if info.offline:

      continue

def AdjustCandidatePool(lu, exceptions):

  if mod_list:

    lu.LogInfo("Promoted nodes to master candidate role: %s",

               utils.CommaJoin(node.name for node in mod_list))

  mc_now, mc_max, _ = lu.cfg.GetMasterCandidateStats(exceptions)

  if mc_now > mc_max:

    lu.LogInfo("Note: more nodes are candidates (%d) than desired (%d)" %

  be_full = cfg.GetClusterInfo().FillBE(instance)

  mem_size = be_full[constants.BE_MAXMEM]

  cpu_count = be_full[constants.BE_VCPUS]

  if any(es_flags.values()):

    # With exclusive storage use the actual spindles

    try:

  return ret

  """Filters out non-vm_capable nodes from a list.

  @type lu: L{LogicalUnit}

  @param lu: the logical unit for which we check

  @rtype: list

  @return: the list of vm-capable nodes

  """

  vm_nodes = frozenset(lu.cfg.GetNonVmCapableNodeList())

def GetDefaultIAllocator(cfg, ialloc):

  return ialloc

                             cur_group_uuid):

  """Checks if node groups for locked instances are still correct.

  @param instances: Dictionary, instance name as key, instance object as value

  @type owned_groups: iterable of string

  @param owned_groups: List of owned groups

  @type cur_group_uuid: string or None

  @param cur_group_uuid: Optional group UUID to check against instance's groups

  """

  for (name, inst) in instances.items():

      "Instance %s's nodes changed while we kept the lock" % name

    inst_groups = CheckInstanceNodeGroups(cfg, name, owned_groups)

  if moved:

    lu.LogInfo("Instances to be moved: %s",

  return [map(compat.partial(_SetOpEarlyRelease, early_release),

              map(opcodes.OpCode.LoadOpCode, ops))

          for ops in jobs]

  """Returns group or nodes depending on caller's choice.

  """

  if use_nodes:

  else:

    return group

  """Creates a map from (node, volume) to instance name.

  @type instances: list of L{objects.Instance}

  """

              for inst in instances

              for vol in vols)

                               errors.ECODE_STATE)

  if constants.ADMINST_UP not in req_states:

      all_hvparams = lu.cfg.GetClusterInfo().hvparams

                  prereq=True, ecode=errors.ECODE_ENVIRON)

      if instance.name in ins_l.payload:

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

                                 " iallocator", errors.ECODE_INVAL)

  faulty = []

  for dev in instance.disks:

               prereq=prereq, ecode=errors.ECODE_ENVIRON)

  for idx, bdev_status in enumerate(result.payload):

  return faulty

  """Ensure that a given node is online.

  @param lu: the LU on behalf of which we make the check

  @param msg: if passed, should be a message to replace the default one

  @raise errors.OpPrereqError: if the node is offline

  """

  if msg is None:

    msg = "Can't use offline node"