art::FileCatalogOptionsHandler Class Reference

#include "FileCatalogOptionsHandler.h"

Inheritance diagram for art::FileCatalogOptionsHandler:

Public Member Functions
	FileCatalogOptionsHandler (bpo::options_description &desc)
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 179 of file FileCatalogOptionsHandler.cc.

References art::add_opt(), appFamily_, appVersion_, and fhicl::detail::atom::value().

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

Member Function Documentation

int art::OptionsHandler::checkOptions ( bpo::variables_map const &  vm )

inherited

Definition at line 51 of file OptionsHandler.cc.

{
  std::string const thisClass(cet::demangle_symbol(typeid(*this).name()));
  return exceptionCatcher([&vm, this] { return doCheckOptions(vm); },
                          thisClass + "::doCheckOptions()",
                          89);
}

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

overrideprivatevirtual

Implements art::OptionsHandler.

Definition at line 231 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 238 of file FileCatalogOptionsHandler.cc.

References appFamily_, appVersion_, art::errors::Configuration, art::ensureTable(), fhicl::intermediate_table::erase(), art::detail::exists_outside_prolog(), art::detail::fhicl_key(), fhicl::intermediate_table::get(), and fhicl::intermediate_table::put().

{
  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("fileType");
      specifyDataTier = true;
      raw_config.erase(fhicl_key(fcmdLocation, "fileType"));
    }
    if (vm.count("sam-inherit-run-type") > 0) {
      md.emplace_back("runType");
      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;
}

int art::OptionsHandler::processOptions ( bpo::variables_map const &  vm, fhicl::intermediate_table &  raw_config  )

inherited

Definition at line 60 of file OptionsHandler.cc.

Referenced by art::run_art_string_config().

{
  std::string const thisClass(cet::demangle_symbol(typeid(*this).name()));
  return exceptionCatcher(
    [&, this] { return doProcessOptions(vm, raw_config); },
    thisClass + "::doProcessOptions()",
    90);
}

Member Data Documentation

std::string art::FileCatalogOptionsHandler::appFamily_

private

Definition at line 26 of file FileCatalogOptionsHandler.h.

Referenced by doProcessOptions(), and FileCatalogOptionsHandler().

std::string art::FileCatalogOptionsHandler::appVersion_

private

Definition at line 27 of file FileCatalogOptionsHandler.h.

Referenced by doProcessOptions(), and FileCatalogOptionsHandler().

---

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

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