art::FileCatalogOptionsHandler Class Reference

#include <FileCatalogOptionsHandler.h>

Inheritance diagram for art::FileCatalogOptionsHandler:

Public Member Functions
	FileCatalogOptionsHandler (bpo::options_description &desc)
Public Member Functions inherited from art::OptionsHandler
virtual	~OptionsHandler ()=default
int	checkOptions (bpo::variables_map const &vm)
int	processOptions (bpo::variables_map const &vm, fhicl::intermediate_table &raw_config)

Private Member Functions
int	doCheckOptions (bpo::variables_map const &vm) override
int	doProcessOptions (bpo::variables_map const &vm, fhicl::intermediate_table &raw_config) override

Private Attributes
std::string	appFamily_ {}
std::string	appVersion_ {}

Detailed Description

Definition at line 14 of file FileCatalogOptionsHandler.h.

Constructor & Destructor Documentation

art::FileCatalogOptionsHandler::FileCatalogOptionsHandler ( bpo::options_description &  desc )

explicit

Definition at line 174 of file FileCatalogOptionsHandler.cc.

{
  bpo::options_description sam_options{"SAM options"};
  // clang-format off
  sam_options.add_options()
    ("sam-web-uri", bpo::value<string>(), "URI for SAM web service.")
    ("sam-process-id", bpo::value<string>(), "SAM process ID.")
    ("sam-application-family",
       bpo::value<string>(&appFamily_), "SAM application family.")
    ("sam-app-family",
       bpo::value<string>(&appFamily_), "SAM application family.")
    ("sam-application-version",
       bpo::value<string>(&appVersion_), "SAM application version.")
    ("sam-app-version",
       bpo::value<string>(&appVersion_), "SAM application version.")
    ("sam-group", bpo::value<string>(), "SAM group.")
    ("sam-file-type", bpo::value<string>(), "File type for SAM metadata.")
    ("sam-data-tier",
       bpo::value<vector<string>>(),
       "SAM data tier (<spec-label>:<tier-spec>).")
    ("sam-run-type", bpo::value<string>(), "Global run-type for SAM metadata.")
    ("sam-stream-name",
       bpo::value<vector<string>>(),
       "SAM stream name (<module-label>:<stream-name>).")
    ("sam-inherit-metadata", "Input file provides the file type and run type.")
    ("sam-inherit-file-type", "Input file provides the file type.")
    ("sam-inherit-run-type", "Input file provides the run type.");
  // clang-format on
  desc.add(sam_options);
}

Member Function Documentation

int art::FileCatalogOptionsHandler::doCheckOptions ( bpo::variables_map const &  vm )

overrideprivatevirtual

Implements art::OptionsHandler.

Definition at line 207 of file FileCatalogOptionsHandler.cc.

{
  // Checks can't be done until after post-processing.
  return 0;
}

int art::FileCatalogOptionsHandler::doProcessOptions ( bpo::variables_map const &  vm, fhicl::intermediate_table &  raw_config  )

overrideprivatevirtual

Implements art::OptionsHandler.

Definition at line 214 of file FileCatalogOptionsHandler.cc.

{
  std::string const services{"services"};
  auto const& ciLocation = fhicl_key(services, "CatalogInterface");
  auto const& ftLocation = fhicl_key(services, "FileTransfer");
  auto const& fcmdLocation = fhicl_key(services, "FileCatalogMetadata");

  ////////////////////////////////////////////////////////////////////////
  // Load up the configuration with command-line options.
  //
  // sam-web-uri and sam-process-id.
  if (vm.count("sam-web-uri") > 0) {
    raw_config.put(fhicl_key(ciLocation, "webURI"),
                   vm["sam-web-uri"].as<string>());
  }
  if (vm.count("sam-process-id") > 0) {
    // Sequence.
    raw_config.put("source.fileNames",
                   vector<string>{vm["sam-process-id"].as<string>()});
    // Atom.
    raw_config.put(fhicl_key(fcmdLocation, "processID"),
                   vm["sam-process-id"].as<string>());
  }
  if (exists_outside_prolog(raw_config, fhicl_key(ciLocation, "webURI")) !=
      exists_outside_prolog(
        raw_config, fhicl_key(fcmdLocation, "processID"))) { // Inconsistent.
    throw Exception(errors::Configuration)
      << "configurations " << fhicl_key(ciLocation, "webURI")
      << " (--sam-web-uri) and\n"
      << fhicl_key(fcmdLocation, "processID")
      << " (--sam-process-id) must be specified\n"
      << "together or not at all.\n";
  }
  bool const wantSAMweb{
    exists_outside_prolog(raw_config, fhicl_key(ciLocation, "webURI")) &&
    exists_outside_prolog(raw_config, "source.fileNames")};
  // Other metadata items.
  if (!appFamily_.empty()) {
    raw_config.put(fhicl_key(fcmdLocation, "applicationFamily"), appFamily_);
  }
  if (vm.count("sam-group") > 0) {
    raw_config.put(fhicl_key(fcmdLocation, "group"),
                   vm["sam-group"].as<string>());
  }
  if (!appVersion_.empty()) {
    raw_config.put(fhicl_key(fcmdLocation, "applicationVersion"), appVersion_);
  }

  check_metadata_options(vm);

  string const mdFromInput{"metadataFromInput"};
  bool specifyDataTier{false}; // The output module needs a
                               // 'dataTier' if "fileType" is
                               // provided either by the input file
                               // or as a configuration parameter.
  if (vm.count("sam-inherit-metadata") > 0) {
    raw_config.put(fhicl_key(fcmdLocation, mdFromInput),
                   vector<string>{"fileType", "runType"});
    specifyDataTier = true;
    raw_config.erase(fhicl_key(fcmdLocation, "fileType"));
    raw_config.erase(fhicl_key(fcmdLocation, "runType"));
  } else {
    vector<string> md;
    if (vm.count("sam-inherit-file-type") > 0) {
      md.emplace_back("file_type");
      specifyDataTier = true;
      raw_config.erase(fhicl_key(fcmdLocation, "fileType"));
    }
    if (vm.count("sam-inherit-run-type") > 0) {
      // 'run_type' is not supported by SAM as a top-level field; we
      // thus preface it with 'art.'
      md.emplace_back("art.run_type");
      raw_config.erase(fhicl_key(fcmdLocation, "runType"));
    }
    if (!md.empty()) {
      raw_config.put(fhicl_key(fcmdLocation, mdFromInput), md);
    }
  }

  if (vm.count("sam-run-type") > 0) {
    raw_config.put(fhicl_key(fcmdLocation, "runType"),
                   vm["sam-run-type"].as<string>());
  }
  if (vm.count("sam-file-type") > 0) {
    raw_config.put(fhicl_key(fcmdLocation, "fileType"),
                   vm["sam-file-type"].as<string>());
  }
  bool const requireMetadata =
    have_outputs(raw_config) &&
    (wantSAMweb ||
     exists_outside_prolog(raw_config,
                           fhicl_key(fcmdLocation, "applicationFamily")) ||
     exists_outside_prolog(raw_config,
                           fhicl_key(fcmdLocation, "applicationVersion")) ||
     exists_outside_prolog(raw_config, fhicl_key(fcmdLocation, "group")) ||
     exists_outside_prolog(raw_config, fhicl_key(fcmdLocation, "fileType")) ||
     specifyDataTier);

  if (requireMetadata) {
    fill_tiers_streams(vm, raw_config);
    maybeThrowOnMissingMetadata(raw_config);
  }

  string process_name;
  if (exists_outside_prolog(raw_config, "process_name")) {
    process_name = raw_config.get<string>("process_name");
  }
  if (requireMetadata && process_name.empty()) {
    throw Exception(errors::Configuration)
      << "Non-empty / default process_name required for SAM metadata.\n";
  }
  if (wantSAMweb) {
    raw_config.put(fhicl_key(ciLocation, "service_provider"),
                   "IFCatalogInterface");
    raw_config.put(fhicl_key(ftLocation, "service_provider"), "IFFileTransfer");
    art::ensureTable(raw_config, fhicl_key(services, "IFDH"));
  }
  return 0;
}

Member Data Documentation

std::string art::FileCatalogOptionsHandler::appFamily_ {}

private

Definition at line 25 of file FileCatalogOptionsHandler.h.

std::string art::FileCatalogOptionsHandler::appVersion_ {}

private

Definition at line 26 of file FileCatalogOptionsHandler.h.

---

The documentation for this class was generated from the following files:

• art/art/Framework/Art/FileCatalogOptionsHandler.h
• art/art/Framework/Art/FileCatalogOptionsHandler.cc