Synnefo » snf-ganeti » ganeti-local

  ECLUSTERFILECHECK = (TCLUSTER, "ECLUSTERFILECHECK")

  @classmethod

  def _VerifyFiles(cls, errorif, nodeinfo, master_node, all_nvinfo,

                   (files_all, files_all_opt, files_mc, files_vm)):

    """Verifies file checksums collected from all nodes.

    @param errorif: Callback for reporting errors

    @param nodeinfo: List of L{objects.Node} objects

    @param master_node: Name of master node

    @param all_nvinfo: RPC results

    node_names = frozenset(node.name for node in nodeinfo)

    assert master_node in node_names

    assert (len(files_all | files_all_opt | files_mc | files_vm) ==

            sum(map(len, [files_all, files_all_opt, files_mc, files_vm]))), \

           "Found file listed in more than one file list"

    # Define functions determining which nodes to consider for a file

    file2nodefn = dict([(filename, fn)

      for (files, fn) in [(files_all, None),

                          (files_all_opt, None),

                          (files_mc, lambda node: (node.master_candidate or

                                                   node.name == master_node)),

                          (files_vm, lambda node: node.vm_capable)]

      for filename in files])

    fileinfo = dict((filename, {}) for filename in file2nodefn.keys())

    for node in nodeinfo:

      nresult = all_nvinfo[node.name]

      if nresult.fail_msg or not nresult.payload:

        node_files = None

      else:

        node_files = nresult.payload.get(constants.NV_FILELIST, None)

      test = not (node_files and isinstance(node_files, dict))

      errorif(test, cls.ENODEFILECHECK, node.name,

              "Node did not return file checksum data")

      if test:

        continue

      for (filename, checksum) in node_files.items():

        # Check if the file should be considered for a node

        fn = file2nodefn[filename]

        if fn is None or fn(node):

          fileinfo[filename].setdefault(checksum, set()).add(node.name)

    for (filename, checksums) in fileinfo.items():

      assert compat.all(len(i) > 10 for i in checksums), "Invalid checksum"

      # Nodes having the file

      with_file = frozenset(node_name

                            for nodes in fileinfo[filename].values()

                            for node_name in nodes)

      # Nodes missing file

      missing_file = node_names - with_file

      if filename in files_all_opt:

        # All or no nodes

        errorif(missing_file and missing_file != node_names,

                cls.ECLUSTERFILECHECK, None,

                "File %s is optional, but it must exist on all or no nodes (not"

                " found on %s)",

                filename, utils.CommaJoin(utils.NiceSort(missing_file)))

      else:

        errorif(missing_file, cls.ECLUSTERFILECHECK, None,

                "File %s is missing from node(s) %s", filename,

                utils.CommaJoin(utils.NiceSort(missing_file)))

      # See if there are multiple versions of the file

      test = len(checksums) > 1

      if test:

        variants = ["variant %s on %s" %

                    (idx + 1, utils.CommaJoin(utils.NiceSort(nodes)))

                    for (idx, (checksum, nodes)) in

                      enumerate(sorted(checksums.items()))]

      else:

        variants = []

      errorif(test, cls.ECLUSTERFILECHECK, None,

              "File %s found with %s different checksums (%s)",

              filename, len(checksums), "; ".join(variants))

    # File verification

    filemap = _ComputeAncillaryFiles(cluster, False)

      constants.NV_FILELIST:

        utils.UniqueSequence(filename

                             for files in filemap

                             for filename in files),

    feedback_fn("* Verifying configuration file consistency")

    self._VerifyFiles(_ErrorIf, nodeinfo, master_node, all_nvinfo, filemap)