check_data_dependencies.cc File Reference

#include "art/Framework/Core/detail/ModuleConfigInfo.h"
#include "art/Framework/Core/detail/ModuleGraph.h"
#include "art/Framework/Core/detail/ModuleGraphInfoMap.h"
#include "art/Framework/Core/detail/consumed_products.h"
#include "art/Framework/Core/detail/graph_algorithms.h"
#include "art/Framework/Principal/ConsumesInfo.h"
#include "art/Persistency/Provenance/ModuleDescription.h"
#include "art/test/Framework/Core/data-dependencies/Configs.h"
#include "boost/graph/graph_utility.hpp"
#include "canvas/Utilities/Exception.h"
#include "fhiclcpp/ParameterSet.h"
#include "fhiclcpp/types/OptionalAtom.h"
#include "fhiclcpp/types/OptionalDelegatedParameter.h"
#include "fhiclcpp/types/OptionalSequence.h"
#include "fhiclcpp/types/OptionalTable.h"
#include "fhiclcpp/types/Table.h"
#include "fhiclcpp/types/TupleAs.h"
#include <cassert>
#include <fstream>
#include <iostream>
#include <regex>

Go to the source code of this file.

Functions
int	main (int argc, char **argv)

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 366 of file check_data_dependencies.cc.

                                {
  if (argc != 2)
    return 1;

  string const filename{argv[1]};
  cet::filepath_maker maker{};
  auto const pset = fhicl::ParameterSet::make(filename, maker);
  Table<art::test::TopLevelTable> table{pset};
  auto const& process_name = table().process_name();
  auto const& test_properties = table().test_properties();

  ParameterSet physics;
  if (!table().physics.get_if_present(physics)) {
    return 0;
  }

  // Form the paths
  auto module_configs = get_module_configs(pset);
  auto paths_to_modules = get_paths_to_modules(physics, module_configs);
  auto const trigger_paths =
    select_paths(pset, tables_with_modifiers, paths_to_modules);
  auto end_paths = paths_to_modules;

  auto const end_path = merge_end_paths(end_paths);

  // Get modules
  art::detail::collection_map_t modules{};

  auto& source_info = modules["input_source"];
  if (!trigger_paths.empty()) {
    source_info.paths = path_names(trigger_paths);
  } else if (!end_path.empty()) {
    source_info.paths = {"end_path"};
  }

  // Assemble all the information for products to be produced.
  std::map<std::string, std::set<art::ProductInfo>> produced_products{};
  for (auto const& path : trigger_paths) {
    fillProducesInfo(pset,
                     process_name,
                     path.first.name,
                     path.second,
                     produced_products,
                     modules);
  }

  // Now go through and assemble the rest of the graph info objects,
  // based on the consumes clauses.  The reason this is separate from
  // the filling of the produces information is that we want to allow
  // users to specify consumes dependencies at this stage, checking
  // for correct types, etc. *before* checking if the workflow is
  // well-formed (i.e. no interpath dependencies, or intrapath
  // circularities).  This pattern mimics what is done in
  // art::PathManager, where all produces information is filled first,
  // and then the graph is assembled afterward.
  std::string err_msg;
  bool graph_failure{false};
  try {
    for (auto const& path : trigger_paths) {
      fillModifierInfo(pset,
                       process_name,
                       path.first.name,
                       path.second,
                       produced_products,
                       modules);
    }

    if (!trigger_paths.empty()) {
      modules["TriggerResults"] = ModuleGraphInfo{art::ModuleType::producer};
    }

    fillObserverInfo(
      pset, process_name, "end_path", end_path, produced_products, modules);
  }
  catch (cet::exception const& e) {
    err_msg += e.what();
    graph_failure = true;
  }

  // Build the graph only if there was no error in constructing the
  // information it needs.
  if (err_msg.empty()) {
    ModuleGraphInfoMap const modInfos{modules};
    auto const module_graph =
      art::detail::make_module_graph(modInfos, trigger_paths, end_path);
    auto const& err = module_graph.second;
    if (!err.empty()) {
      err_msg += err;
      graph_failure = true;
    }

    auto const pos = filename.find(".fcl");
    string const basename =
      (pos != string::npos) ? filename.substr(0, pos) : filename;
    std::ofstream ofs{basename + ".dot"};
    print_module_graph(ofs, modInfos, module_graph.first);
  }

  // Check if test properties have been satisfied
  int rc{};
  bool const graph_failure_expected = test_properties.graph_failure_expected();
  if (graph_failure && !graph_failure_expected) {
    std::cerr << "Unexpected graph-construction failure.\n"
              << "Error message:\n"
              << err_msg << '\n';
    rc = 1;
  } else if (!graph_failure && graph_failure_expected) {
    std::cerr << "Unexpected graph-construction success.\n";
    rc = 1;
  }
  string expected_msg;
  if (test_properties.error_message(expected_msg)) {
    std::regex const re{expected_msg};
    if (!std::regex_search(err_msg, re)) {
      std::cerr << " The error message does not match what was expected:\n"
                << "   Actual: [" << err_msg << "]\n"
                << "   Expected: [" << expected_msg << "]\n";
      rc = 3;
    }
  }
  return rc;
}
catch (detail::validationException const& v) {
  std::cerr << v.what();
  return 1;
}
catch (std::exception const& e) {
  std::cerr << e.what() << '\n';
  return 1;
}
catch (...) {
  std::cerr << "Job failed.\n";
  return 1;
}