oks_dump.cxx

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS oks source for the DUNE DAQ project.
// Fork baseline commit: oks-08-03-04 (2022-04-14).
// Renamed since fork: yes (from bin/oks_dump.cpp to apps/oks_dump.cxx).

 
#include "oks/exceptions.hpp"
#include "oks/kernel.hpp"
#include "oks/query.hpp"
 
#include <iostream>
#include <vector>
 
#include <stdlib.h>
#include <string.h>
 
using namespace dunedaq::oks;
 
enum __OksDumpExitStatus__
{
  __Success__ = 0,
  __BadCommandLine__,
  __BadOksFile__,
  __BadQuery__,
  __NoSuchClass__,
  __FoundDanglingReferences__,
  __ExceptionCaught__
};
 
static void
printUsage(std::ostream& s)
{
  s << "Usage: oks_dump\n"
       "    [--files-only | --files-stat-only | --schema-files-only | --schema-files-stat-only | --data-files-only | "
       "--data-files-stat-only]\n"
       "    [--class name-of-class [--query query [--print-references recursion-depth [class-name*] [--]] "
       "[--print-referenced_by [name] [--]]]]\n"
       "    [--path object-from object-to query]\n"
       "    [--allow-duplicated-objects-via-inheritance]\n"
       "    [--version]\n"
       "    [--help]\n"
       "    [--input-from-files] database-file [database-file(s)]\n"
       "\n"
       "Options:\n"
       "    -f | --files-only                                 print list of oks files names\n"
       "    -F | --files-stat-only                            print list of oks files with statistic details (size, "
       "number of items\n"
       "    -s | --schema-files-only                          print list of schema oks files names\n"
       "    -S | --schema-files-stat-only                     print list of oks schema files with statistic details\n"
       "    -d | --data-files-only                            print list of data oks files names\n"
       "    -D | --data-files-stat-only                       print list of oks data files with statistic details\n"
       "    -c | --class class_name                           dump given class (all objects or matching some query)\n"
       "    -q | --query query                                print objects matching query (can only be used with "
       "class)\n"
       "    -r | --print-references N C1 C2 ... CX            print objects referenced by found objects (can only be "
       "used with query), where:\n"
       "                                                       * the parameter N defines recursion depth for "
       "referenced objects (> 0)\n"
       "                                                       * the optional set of names {C1 .. CX} defines "
       "[sub-]classes for above objects\n"
       "    -b | --print-referenced_by [name]                 print objects referencing found objects (can only be "
       "used with query), where:\n"
       "                                                       * the optional parameter name defines name of "
       "relationship\n"
       "    -p | --path obj query                             print path from object \'obj\' to object of query "
       "expression\n"
       "    -i | --input-from-files                           read oks files to be loaded from file(s) instead of "
       "command line\n"
       "                                                      (to avoid problems with long command line, when there is "
       "huge number of files)\n"
       "    -a | --allow-duplicated-objects-via-inheritance   do not stop if there are duplicated object via "
       "inheritance hierarchy\n"
       "    -v | --version                                    print version\n"
       "    -h | --help                                       print this text\n"
       "\n"
       "Description:\n"
       "    Dumps contents of the OKS database.\n"
       "\n"
       "Return Status:\n"
       "    0 - no problems found\n"
       "    1 - bad command line parameter\n"
       "    2 - bad oks file(s)\n"
       "    3 - bad query passed via -q or -p options\n"
       "    4 - cannot find class passed via -c option\n"
       "    5 - loaded objects have dangling references\n"
       "    6 - caught an exception\n"
       "\n";
}
 
static void
no_param(const char* s)
{
  Oks::error_msg("oks_dump") << "no parameter(s) for command line argument \'" << s << "\' provided\n\n";
  exit(EXIT_FAILURE);
}
 
OksObject*
find_object(char* s, OksKernel& k)
{
  char* id = s;
 
  if ((s = strchr(id, '@')) == 0)
    return 0;
 
  *s = '\0';
  s++;
 
  if (OksClass* c = k.find_class(s)) {
    if (OksObject* o = c->get_object(id)) {
      return o;
    } else {
      Oks::error_msg("oks_dump::find_object()") << "cannot find object \"" << id << '@' << s << "\"\n";
    }
  } else {
    Oks::error_msg("oks_dump::find_object()") << "cannot find class \"" << s << "\"\n";
  }
 
  return 0;
}
 
int
main(int argc, char** argv)
{
  if (argc == 1) {
    printUsage(std::cerr);
    return __BadCommandLine__;
  }
 
  OksKernel kernel;
  kernel.set_test_duplicated_objects_via_inheritance_mode(true);
 
  try {
 
    int dump_files_only = 0; // 0 - none, 12 - data, 1 - schema, 2 - schema & data
    const char* class_name = 0;
    const char* query = 0;
    const char* object_from = 0;
    const char* path_query = 0;
    long recursion_depth = 0;
    bool print_referenced_by = false;
    const char* ref_by_rel_name = "*";
    std::vector<std::string> ref_classes;
    bool input_from_files = false;
    bool print_files_stat = false;
 
    for (int i = 1; i < argc; i++) {
      const char* cp = argv[i];
 
      if (!strcmp(cp, "-h") || !strcmp(cp, "--help")) {
        printUsage(std::cout);
        return __Success__;
      } else if (!strcmp(cp, "-v") || !strcmp(cp, "--version")) {
        std::cout << "OKS kernel version " << OksKernel::GetVersion() << std::endl;
        return __Success__;
      } else if (!strcmp(cp, "-a") || !strcmp(cp, "--allow-duplicated-objects-via-inheritance")) {
        kernel.set_test_duplicated_objects_via_inheritance_mode(false);
      } else if (!strcmp(cp, "-f") || !strcmp(cp, "--files-only")) {
        dump_files_only = 2;
      } else if (!strcmp(cp, "-F") || !strcmp(cp, "--files-stat-only")) {
        dump_files_only = 2;
        print_files_stat = true;
      } else if (!strcmp(cp, "-s") || !strcmp(cp, "--schema-files-only")) {
        dump_files_only = 1;
      } else if (!strcmp(cp, "-S") || !strcmp(cp, "--schema-files-stat-only")) {
        dump_files_only = 1;
        print_files_stat = true;
      } else if (!strcmp(cp, "-d") || !strcmp(cp, "--data-files-only")) {
        dump_files_only = 12;
      } else if (!strcmp(cp, "-D") || !strcmp(cp, "--data-files-stat-only")) {
        dump_files_only = 12;
        print_files_stat = true;
      } else if (!strcmp(cp, "-c") || !strcmp(cp, "--class")) {
        if (++i == argc) {
          no_param(cp);
        } else {
          class_name = argv[i];
        }
      } else if (!strcmp(cp, "-q") || !strcmp(cp, "--query")) {
        if (++i == argc) {
          no_param(cp);
        } else {
          query = argv[i];
        }
      } else if (!strcmp(cp, "-i") || !strcmp(cp, "--input-from-files")) {
        input_from_files = true;
      } else if (!strcmp(cp, "-r") || !strcmp(cp, "--print-references")) {
        if (++i == argc) {
          no_param(cp);
        } else {
          recursion_depth = atol(argv[i]);
        }
        int j = 0;
        for (; j < argc - i - 1; ++j) {
          if (argv[i + 1 + j][0] != '-') {
            ref_classes.push_back(argv[i + 1 + j]);
          } else {
            break;
          }
        }
        i += j;
      } else if (!strcmp(cp, "-b") || !strcmp(cp, "--print-referenced_by")) {
        print_referenced_by = true;
        if ((i + 1) < argc && argv[i + 1][0] != '-') {
          ref_by_rel_name = argv[++i];
        }
      } else if (!strcmp(cp, "-p") || !strcmp(cp, "--path")) {
        if (++i > argc - 1) {
          no_param(cp);
        } else {
          object_from = argv[i];
          path_query = argv[++i];
        }
      } else if (strcmp(cp, "--")) {
        if (input_from_files) {
          std::ifstream f(cp);
          if (f.good()) {
            while (f.good() && !f.eof()) {
              std::string file_name;
              std::getline(f, file_name);
              if (!file_name.empty() && kernel.load_file(file_name) == 0) {
                Oks::error_msg("oks_dump") << "\tCan not load file \"" << file_name << "\", exiting...\n";
                return __BadOksFile__;
              }
            }
          } else {
            Oks::error_msg("oks_dump") << "\tCan not open file \"" << cp << "\" for reading, exiting...\n";
            return __BadCommandLine__;
          }
        } else {
          if (kernel.load_file(cp) == 0) {
            Oks::error_msg("oks_dump") << "\tCan not load file \"" << cp << "\", exiting...\n";
            return __BadOksFile__;
          }
        }
      }
    }
 
    if (kernel.schema_files().empty()) {
      Oks::error_msg("oks_dump") << "\tAt least one oks file have to be provided, exiting...\n";
      return __BadCommandLine__;
    }
 
    if (query && !class_name) {
      Oks::error_msg("oks_dump")
        << "\tQuery can only be executed when class name is provided (use -c option), exiting...\n";
      return __BadCommandLine__;
    }
 
    if (dump_files_only) {
      long total_size = 0;
      long total_items = 0;
      const OksFile::Map* files[2] = { &kernel.schema_files(), &kernel.data_files() };
      for (int j = (dump_files_only / 10); j < (dump_files_only % 10); ++j) {
        if (!files[j]->empty()) {
          for (OksFile::Map::const_iterator i = files[j]->begin(); i != files[j]->end(); ++i) {
            if (print_files_stat) {
              total_size += i->second->get_size();
              total_items += i->second->get_number_of_items();
              std::cout << *(i->first) << " (" << i->second->get_number_of_items() << " items, "
                        << i->second->get_size() << " bytes)" << std::endl;
            } else {
              std::cout << *(i->first) << std::endl;
            }
          }
        }
      }
 
      if (print_files_stat) {
        std::cout << "Total number of items: " << total_items
                  << "\n"
                     "Total size of files: "
                  << total_size << " bytes" << std::endl;
      }
    } else if (class_name && *class_name) {
      if (OksClass* c = kernel.find_class(class_name)) {
        if (query && *query) {
          OksQuery* q = new OksQuery(c, query);
          if (q->good()) {
            OksObject::List* objs = c->execute_query(q);
            size_t num = (objs ? objs->size() : 0);
            std::cout << "Found " << num << " matching query \"" << query << "\" in class \"" << class_name << "\"";
            if (num) {
              std::cout << ':' << std::endl;
              while (!objs->empty()) {
                OksObject* o = objs->front();
                objs->pop_front();
 
                if (recursion_depth > 0 || print_referenced_by) {
                  if (recursion_depth) {
                    ClassSet all_ref_classes;
                    kernel.get_all_classes(ref_classes, all_ref_classes);
                    OksObject::FSet refs;
                    o->references(refs, recursion_depth, false, &all_ref_classes);
                    std::cout << o << " references " << refs.size() << " object(s)" << std::endl;
                    for (OksObject::FSet::const_iterator i = refs.begin(); i != refs.end(); ++i) {
                      std::cout << " - " << *i << std::endl;
                    }
                  }
                  if (print_referenced_by) {
                    if (OksObject::FList* ref_by_objs = o->get_all_rels(ref_by_rel_name)) {
                      std::cout << o << " is referenced by " << ref_by_objs->size() << " object(s) via relationship \""
                                << ref_by_rel_name << "\":" << std::endl;
 
                      for (OksObject::FList::const_iterator i = ref_by_objs->begin(); i != ref_by_objs->end(); ++i) {
                        std::cout << " - " << *i << std::endl;
                      }
 
                      delete ref_by_objs;
                    } else {
                      std::cout << o << " is not referenced by any object via relationship \"" << ref_by_rel_name
                                << '\"' << std::endl;
                    }
                  }
                } else {
                  std::cout << *o << std::endl;
                }
              }
              delete objs;
            } else {
              std::cout << std::endl;
            }
          } else {
            Oks::error_msg("oks_dump") << "\tFailed to parse query \"" << query << "\" in class \"" << class_name
                                       << "\"\n";
            return __BadQuery__;
          }
          delete q;
        } else {
          std::cout << *c << std::endl;
        }
      } else {
        Oks::error_msg("oks_dump") << "\tCan not find class \"" << class_name << "\"\n";
        return __NoSuchClass__;
      }
    } else if (object_from && *object_from && path_query && *path_query) {
      OksObject* obj_from = find_object((char*)object_from, kernel);
      try {
        QueryPath q(path_query, kernel);
        OksObject::List* objs = obj_from->find_path(q);
 
        size_t num = (objs ? objs->size() : 0);
        std::cout << "Found " << num << " objects in the path \"" << q << "\" from object " << obj_from << ":"
                  << std::endl;
 
        if (num) {
          while (!objs->empty()) {
            OksObject* o = objs->front();
            objs->pop_front();
            std::cout << *o << std::endl;
          }
          delete objs;
        }
      } catch (bad_query_syntax& e) {
        Oks::error_msg("oks_dump") << "\tFailed to parse query: " << e.what() << std::endl;
        return __BadQuery__;
      }
    } else {
      std::cout << kernel;
    }
 
    if (!kernel.get_bind_classes_status().empty()) {
      Oks::error_msg("oks_dump") << "The schema contains dangling references to non-loaded classes:\n"
                                 << kernel.get_bind_classes_status();
    }
 
    if (!kernel.get_bind_objects_status().empty()) {
      Oks::error_msg("oks_dump") << "\tThe data contain dangling references to non-loaded objects\n";
    }
 
    if (!kernel.get_bind_classes_status().empty() || !kernel.get_bind_objects_status().empty()) {
      return __FoundDanglingReferences__;
    }
  } catch (exception& ex) {
    std::cerr << "Caught oks exception:\n" << ex << std::endl;
    return __ExceptionCaught__;
  } catch (std::exception& e) {
    std::cerr << "Caught standard C++ exception: " << e.what() << std::endl;
    return __ExceptionCaught__;
  } catch (...) {
    std::cerr << "Caught unknown exception" << std::endl;
    return __ExceptionCaught__;
  }
 
  return __Success__;
}