oks_check_schema.cxx File Reference

#include "CLI/CLI.hpp"
#include "logging/Logging.hpp"
#include "oks/class.hpp"
#include "oks/file.hpp"
#include "oks/kernel.hpp"
#include "oks/relationship.hpp"
#include <fmt/core.h>
#include <set>
#include <string>

Include dependency graph for oks_check_schema.cxx:

Go to the source code of this file.

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

Detailed Description

Program to do some simple integrity checks on a schema file

This is part of the DUNE DAQ Application Framework, copyright 2025. Licensing/copyright details are in the COPYING file that you should have received with this code.

Definition in file oks_check_schema.cxx.

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 26 of file oks_check_schema.cxx.

                                {
  enum Exitcode : int {SUCCESS, BADCMD, NOFILE, LOADFAIL,
    BADRELATIONSHIP, UNRESOLVED,
    MISSING_INCLUDE};
 
  CLI::App app{"Check consistency of OKS schema file\n"+
    fmt::format("Return codes: {} Success, file is OK\n", Exitcode::SUCCESS)+
    fmt::format("              {} Bad command line\n", Exitcode::BADCMD)+
    fmt::format("              {} Failed to find file\n", Exitcode::NOFILE)+
    fmt::format("              {} Failed to load file -- invalid schema\n", Exitcode::LOADFAIL)+
    fmt::format("              {} File contains relationship to non loaded class\n", Exitcode::BADRELATIONSHIP)+
    fmt::format("              {} File contains object with relationship to non loaded class/object\n", Exitcode::UNRESOLVED)+
    fmt::format("              {} File refers to class in file not directly included\n", Exitcode::MISSING_INCLUDE)
  };
 
  std::string filename;
  app.add_option("-f,--file", filename, "Schema file")
    ->required();
 
  CLI11_PARSE(app, argc, argv);
 
  OksKernel kernel;
  OksFile* file{nullptr};
  try {
    file = kernel.load_file(filename);
  }
  catch (FailedLoadFile& fail) {
    TLOG() << fail.what() << "\n";
    return Exitcode::LOADFAIL;
  }
  catch (CanNotOpenFile& fail) {
    TLOG() << fail.what() << "\n";
    return Exitcode::NOFILE;
  }
  catch (std::exception& exc) {
    TLOG() << exc.what() << "\n";
    return Exitcode::LOADFAIL;
  }
 
  if (file == nullptr) {
    TLOG() << "Failed to load " << filename;
    return Exitcode::LOADFAIL;
  }
 
  std::set<std::string> includes;
  for (const auto& ifile : file->get_include_files()) {
    includes.insert(ifile);
    TLOG_DEBUG(2) << "direct inserting " << ifile << "\n";
  }
 
  Exitcode result=Exitcode::SUCCESS;
 
  if (filename.ends_with(".schema.xml")) {
    // Check classes defined in this schema file
    for (auto [name, oks_class] : kernel.classes()) {
 
      if (file->get_full_file_name() != oks_class->get_file()->get_full_file_name()) {
        // Class not defined in this file
        continue;
      }
 
      auto cfile = oks_class->get_file()->get_short_file_name();
      if (cfile != file->get_short_file_name() && !includes.contains(cfile)) {
        TLOG() << "Error " << filename << " misses include of " << cfile << " required by " << name;
        if (result==Exitcode::SUCCESS) {
          result =  Exitcode::MISSING_INCLUDE;
        }
      }
      auto relationships = oks_class->direct_relationships();
      if (relationships != nullptr) {
        for (auto rel: *relationships) {
          auto rel_class = rel->get_class_type();
          if (rel_class == nullptr) {
            TLOG() << "Error class '" << name
                   << "' has relationship '" << rel->get_name()
                   << "' to a class '" << rel->get_type()
                   << "' that is not loaded\n";
            if (result==Exitcode::SUCCESS) {
              result =  Exitcode::BADRELATIONSHIP;
            }
          }
 
        }
      }
      // Could check super-classes but we wouldn't have got past the
      // load if they referred to a missing class.
    }
  } else if (filename.ends_with(".data.xml")) {
 
    auto check_relationship = [&](OksData* data) {
      auto relobj = data->data.OBJECT;
      if (relobj == nullptr) {
        return;
      }
      auto ofile_name = relobj->get_file()->get_short_file_name();
      if (file->get_short_file_name() != ofile_name && !includes.contains(ofile_name)) {
        TLOG() << "Error " << filename << " misses include of " << ofile_name
               << " required by " << relobj->GetId();
        if (result==Exitcode::SUCCESS) {
          result =  Exitcode::MISSING_INCLUDE;
        }
      }
    };
 
    auto data_objs = kernel.create_list_of_data_objects(file);
    for (auto obj : *data_objs) {
      // Check that any objects defined in this data file have their
      // corresponding schema file included directly in this file
      auto oks_class = obj->GetClass();
      auto cfile = oks_class->get_file()->get_short_file_name();
      if (!includes.contains(cfile)) {
        TLOG() << "Error " << filename << " misses include of " << cfile
               << " required by " << obj->GetId()
               << " of class " << oks_class->get_name();
        if (result==Exitcode::SUCCESS) {
          result =  Exitcode::MISSING_INCLUDE;
        }
      }
 
      // Check that any objects referenced by objects in this file are
      // either defined in this file or one that is directly included
      auto relationships = oks_class->all_relationships();
      if (relationships != nullptr) {
        for (auto rel: *relationships) {
          auto relval = obj->GetRelationshipValue(rel->get_name());
          if (relval == nullptr) {
            continue;
          }
          if (rel->get_high_cardinality_constraint() == OksRelationship::Many) {
            for(OksData::List::iterator iter = relval->data.LIST->begin();
                iter != relval->data.LIST->end(); ++iter) {
              check_relationship(*iter);
            }
          } else {
            check_relationship(relval);
          }
        }
      }
    }
    delete data_objs;
  }
 
  auto status = kernel.get_bind_objects_status();
  if (!status.empty()) {
    if (result==Exitcode::SUCCESS) {
      result = Exitcode::UNRESOLVED;
    }
  }
 
  return result;
}