JsonConfigManagerPrograms.cpp

Go to the documentation of this file.

std::string executableBasename(const std::string &path) {
  const auto separator = path.find_last_of("/\\");
  if (separator == std::string::npos)
    return path;
  return path.substr(separator + 1);
}
 
MoFEMErrorCode selectProgramConfig(const JsonObject &root_object,
                                   const std::string &file_name,
                                   boost::json::value &selected_config) {
  MoFEMFunctionBegin;
  if (!root_object.if_contains("programs")) {
    selected_config = root_object;
  } else {
    for (const auto &item : root_object) {
      const auto key = toStdString(item.key());
      if (key == "$schema" || key == "version" || key == "programs")
        continue;
      CHKERR failConfig(file_name, makeContext("root", key),
                        "cannot be used together with root.programs; move it "
                        "into a program entry");
    }
 
    const auto &programs =
        requireArray(root_object.at("programs"), file_name, "root.programs");
    char program_name[PETSC_MAX_PATH_LEN] = "";
    CHKERR PetscGetProgramName(program_name, sizeof(program_name));
    const auto current_executable = executableBasename(program_name);
    if (current_executable.empty()) {
      CHKERR failConfig(file_name, "root.programs",
                        "unable to determine current executable name");
    }
 
    const JsonObject *matching_program = nullptr;
    std::string matching_context;
    for (size_t program_index = 0; program_index != programs.size();
         ++program_index) {
      const auto context =
          "root.programs[" +
          boost::lexical_cast<std::string>(program_index) + "]";
      const auto &program =
          requireObject(programs[program_index], file_name, context);
      const auto executable_it = program.find("executable");
      if (executable_it == program.end()) {
        CHKERR failConfig(file_name, makeContext(context, "executable"),
                          "missing required executable field");
      }
 
      const auto executable = requireString(
          executable_it->value(), file_name, makeContext(context, "executable"));
      if (executable != current_executable &&
          executableBasename(executable) != current_executable) {
        continue;
      }
      if (matching_program) {
        CHKERR failConfig(file_name, context,
                          "multiple program entries match executable '" +
                              current_executable + "'");
      }
      matching_program = &program;
      matching_context = context;
    }
 
    if (!matching_program) {
      CHKERR failConfig(file_name, "root.programs",
                        "no program entry matches executable '" +
                            current_executable + "'");
    }
 
    boost::json::object config_object;
    if (const auto version_it = root_object.find("version");
        version_it != root_object.end()) {
      config_object["version"] = version_it->value();
    }
    for (const auto &item : *matching_program) {
      const auto key = toStdString(item.key());
      if (key == "executable" || key == "working_directory" ||
          key == "parameters" ||
          key == "$schema" || key == "version") {
        continue;
      }
      config_object[item.key()] = item.value();
    }
    selected_config = std::move(config_object);
 
    MOFEM_LOG("WORLD", Sev::inform)
        << file_name << ": selected JSON program config " << matching_context
        << " for executable '" << current_executable << "'";
  }
 
  MoFEMFunctionReturn(0);
}