Synnefo » snf-ganeti

  nodeinfo = lu.rpc.call_node_info(node_uuids, None, hypervisor_specs)

                                         hvspecs)

                 [self.source_node_uuid, self.target_node_uuid], None, hvspecs)

  lvm_storage_units = [(constants.ST_LVM_VG, vg)]

  storage_units = rpc.PrepareStorageUnitsForNodes(lu.cfg, lvm_storage_units,

                                                  node_uuids)

  nodeinfo = lu.rpc.call_node_info(node_uuids, storage_units,

                                   [(hvname, hvparams[hvname])])

  nodeinfo = lu.rpc.call_node_info([node_uuid], None, [(hvname, hvparams)])

      # FIXME: this per default asks for storage space information for all

      # enabled disk templates. Fix this by making it possible to specify

      # space report fields for specific disk templates.

      raw_storage_units = utils.storage.GetStorageUnitsOfCluster(

          lu.cfg, include_spindles=True)

      storage_units = rpc.PrepareStorageUnitsForNodes(

          lu.cfg, raw_storage_units, toquery_node_uuids)

                                        hvspecs)

    storage_units_raw = utils.storage.GetStorageUnitsOfCluster(

    storage_units = rpc.PrepareStorageUnitsForNodes(self.cfg, storage_units_raw,

                                                    node_list)

    return self.rpc.call_node_info(node_list, storage_units, hvspecs)

def _GetExclusiveStorageFlag(cfg, node_uuid):

def _AddExclusiveStorageFlagToLvmStorageUnits(storage_units, es_flag):

  """Adds the exclusive storage flag to lvm units.

  This function creates a copy of the storage_units lists, with the

  es_flag being added to all lvm storage units.

  @type storage_units: list of pairs (string, string)

  @param storage_units: list of 'raw' storage units, consisting only of

    (storage_type, storage_key)

  @type es_flag: boolean

  @param es_flag: exclusive storage flag

  @rtype: list of tuples (string, string, list)

  @return: list of storage units (storage_type, storage_key, params) with

    the params containing the es_flag for lvm-vg storage units

  """

  result = []

  for (storage_type, storage_key) in storage_units:

    if storage_type == constants.ST_LVM_VG:

      result.append((storage_type, storage_key, es_flag))

    else:

      result.append((storage_type, storage_key, []))

  return result

  @return: mapping from node uuids to exclusive storage flags

  getflag = lambda n: _GetExclusiveStorageFlag(cfg, n)

def PrepareStorageUnitsForNodes(cfg, storage_units, node_uuids):

  """Return the lvm storage unit for all the given nodes.

  Main purpose of this function is to map the exclusive storage flag, which

  can be different for each node, to the default LVM storage unit.

  @type cfg: L{config.ConfigWriter}

  @param cfg: cluster configuration

  @type storage_units: list of pairs (string, string)

  @param storage_units: list of 'raw' storage units, e.g. pairs of

    (storage_type, storage_key)

  @type node_uuids: list or tuple

  @param node_uuids: node UUIDs for which to read the flag

  @rtype: dict

  @return: mapping from node uuids to a list of storage units which include

    the exclusive storage flag for lvm storage

  @raise errors.OpPrereqError: if any given node name has no corresponding

  node

  """

  getunit = lambda n: _AddExclusiveStorageFlagToLvmStorageUnits(

      storage_units, _GetExclusiveStorageFlag(cfg, n))

  flags = map(getunit, node_uuids)

  return dict(zip(node_uuids, flags))

  """Prepare the storage_units argument for node_info calls."""

  assert len(args) == 2

  # The storage_units argument is either a dictionary with one value for each

  # node, or a fixed value to be used for all the nodes

  if type(args[0]) is dict:

    return [args[0][node], args[1]]

     "List of tuples '<storage_type>,<key>,[<param>]' to ask for disk space"

     " information; the parameter list varies depending on the storage_type"),