oks_get_data.cxx

Go to the documentation of this file.

//
// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS oks_utils source for the DUNE DAQ project.
// Fork baseline commit: c2e7dfc7 (2022-03-30).
// Renamed since fork: yes (from src/bin/oks_get_data.cpp to apps/oks_get_data.cxx).
//
 
#include <iostream>
#include <stdexcept>
#include <unistd.h>
 
#include "CoralBase/Exception.h"
#include "CoralKernel/Context.h"
#include "RelationalAccess/ConnectionService.h"
#include "RelationalAccess/ISessionProxy.h"
#include "RelationalAccess/ITransaction.h"
 
#include "oks/kernel.hpp"
#include "oks/ral.hpp"
 
static void
usage()
{
  std::cout
    << "usage: oks_get_data\n"
       "       -c | --connect-string connect_string\n"
       "       -w | --working-schema schema_name\n"
       "       [-t | --tag data_tag]\n"
       "       [-e | --head-data-version [release-name]]\n"
       "       [-s | --schema-version schema_version]\n"
       "       [-n | --data-version data_version]\n"
       "       [-m | --out-schema-file schema_file]\n"
       "       [-f | --out-data-file data_file]\n"
       "       [-q | --query class oks-query [-r | --reference-level ref-level]]\n"
       "       [-v | --verbose-level verbosity_level]\n"
       "       [-h | --help]\n"
       "\n"
       "Options/Arguments:\n"
       "       -c connect_string    database connection string\n"
       "       -w schema_name       name of working schema\n"
       "       -t data_tag          get data by tag\n"
       "       -e [release-name]    get HEAD data version (cannot be used with -n);\n"
       "                            if there is no -s, then for schema HEAD version of \'" TDAQ_CMT_RELEASE
       "\' or the explicit release\n"
       "       -s schema_version    get data for given schema version (extra -n or -e to get HEAD data version is "
       "required)\n"
       "       -n data_version      get data by version (extra -s is required, but cannot be used with -e)\n"
       "       -m out_schema_file   name for output schema file\n"
       "       -f out_data_file     name for output data file\n"
       "       -q class query       only get objects of given class satisfying query\n"
       "       -r ref-level         also get objects referencing above objects with given recursion level\n"
       "       -v verbosity_level   set verbose output level (0 - silent, 1 - normal, 2 - extended, 3 - debug, ...)\n"
       "       -h                   print this message\n"
       "\n"
       "Description:\n"
       "       The utility creates oks files for given version of data stored in relational database.\n\n";
}
 
static void
no_param(const char* s)
{
  std::cerr << "ERROR: no parameter for " << s << " provided\n\n";
}
 
int
main(int argc, char* argv[])
{
 
  // parse and check command line
 
  int verbose_level = 1;
  std::string connect_string;
  std::string release;
  std::string tag;
  std::string working_schema;
  std::string schema_file;
  std::string data_file;
  std::string query;
  std::string class_name;
  long ref_level = 0;
  int schema_version = -1;
  int data_version = -1;
  bool remove_schema_file = false;
  bool remove_data_file = false;
 
  for (int i = 1; i < argc; i++) {
    const char* cp = argv[i];
 
    if (!strcmp(cp, "-h") || !strcmp(cp, "--help")) {
      usage();
      return (EXIT_SUCCESS);
    } else if (!strcmp(cp, "-v") || !strcmp(cp, "--verbose-level")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        verbose_level = atoi(argv[i]);
      }
    } else if (!strcmp(cp, "-e") || !strcmp(cp, "--head-data-version")) {
      if (data_version > 0) {
        std::cerr << "ERROR: use either explicit data version (parameter -n) or HEAD version for provided release name "
                     "(parameter -e ...)\n";
        usage();
        return EXIT_FAILURE;
      }
      data_version = 0;
      if (argc > (i + 1) && argv[i + 1][0] != '-') {
        ++i;
        release = argv[i];
      }
    } else if (!strcmp(cp, "-t") || !strcmp(cp, "--tag")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        tag = argv[i];
      }
    } else if (!strcmp(cp, "-s") || !strcmp(cp, "--schema-version")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        schema_version = atoi(argv[i]);
      }
    } else if (!strcmp(cp, "-n") || !strcmp(cp, "--data-version")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        if (!release.empty()) {
          std::cerr << "ERROR: use either explicit data version (parameter -n) or HEAD version for provided release "
                       "name (parameter -e ...)\n";
          usage();
          return EXIT_FAILURE;
        }
        data_version = atoi(argv[i]);
      }
    } else if (!strcmp(cp, "-c") || !strcmp(cp, "--connect-string")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        connect_string = argv[i];
      }
    } else if (!strcmp(cp, "-w") || !strcmp(cp, "--working-schema")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        working_schema = argv[i];
      }
    } else if (!strcmp(cp, "-m") || !strcmp(cp, "--out-schema-file")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        schema_file = argv[i];
      }
    } else if (!strcmp(cp, "-f") || !strcmp(cp, "--out-data-file")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        data_file = argv[i];
      }
    } else if (!strcmp(cp, "-q") || !strcmp(cp, "--query")) {
      if (i >= argc - 2) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        class_name = argv[++i];
        query = argv[++i];
      }
    } else if (!strcmp(cp, "-r") || !strcmp(cp, "--reference-level")) {
      if (++i == argc) {
        no_param(cp);
        return (EXIT_FAILURE);
      } else {
        ref_level = atoi(argv[i]);
      }
    } else {
      std::cerr << "ERROR: Unexpected parameter: \"" << cp << "\"\n\n";
      usage();
      return (EXIT_FAILURE);
    }
  }
 
  if (data_version == -1 && tag.empty()) {
    std::cerr << "ERROR: the data version or tag is required\n";
    usage();
    return EXIT_FAILURE;
  } else if (data_version > 0 && schema_version <= 0) {
    std::cerr << "ERROR: an explicit data version cannot be used without schema version\n";
    usage();
    return EXIT_FAILURE;
  } else if (data_version != -1 && !tag.empty()) {
    std::cerr << "ERROR: both schema version and tag are defined; only one can be used\n";
    usage();
    return EXIT_FAILURE;
  }
 
  if (connect_string.empty()) {
    std::cerr << "ERROR: the connect string is required\n";
    usage();
    return EXIT_FAILURE;
  }
 
  if (working_schema.empty()) {
    std::cerr << "ERROR: the working schema is required\n";
    usage();
    return EXIT_FAILURE;
  }
 
  // create oks kernel
 
  VerboseMsg2("Creating OKS kernel...");
  ::OksKernel kernel;
 
  try {
 
    // create oks schema file
 
    if (schema_file.empty()) {
      schema_file = kernel.get_tmp_file("/tmp/unknown.schema.xml");
      VerboseMsg2("The name of output schema file was not provided.\n * use file \'" << schema_file << '\'');
      remove_schema_file = true;
    }
 
    VerboseMsg3("Creating OKS schema file...");
    ::OksFile* fh1 = kernel.new_schema(schema_file);
 
    // create oks data file
 
    if (data_file.empty()) {
      data_file = kernel.get_tmp_file("/tmp/unknown.data.xml");
      VerboseMsg2("The name of output data file was not provided.\n * use file \'" << data_file << '\'');
      remove_data_file = true;
    }
 
    VerboseMsg3("Creating OKS data file...");
    ::OksFile* fh2 = kernel.new_data(data_file);
 
    {
      std::unique_ptr<coral::ConnectionService> connection;
      {
        std::unique_ptr<coral::ISessionProxy> session(
          oks::ral::start_coral_session(connect_string, coral::ReadOnly, connection, verbose_level));
 
        if (!tag.empty() || data_version <= 0 || schema_version < 0) {
          oks::ral::get_data_version(
            session.get(), working_schema, tag, schema_version, data_version, release.c_str(), verbose_level);
          if (data_version <= 0 || schema_version < 0) {
            throw std::runtime_error((data_version == 0) ? "Cannot get head data" : "Cannot get given data");
          }
        }
 
        oks::ral::get_data(kernel, session.get(), working_schema, schema_version, data_version, verbose_level);
 
        VerboseMsg2("Committing...");
        session->transaction().commit();
 
        VerboseMsg2("Ending user session..."); // delete session by unique_ptr<>
      }
 
      VerboseMsg2("Disconnecting..."); // delete connection by unique_ptr<>
    }
 
    if (!query.empty()) {
 
      // compute data, if there is an explicit query
 
      OksObject::FSet objects;
 
      if (OksClass* c = kernel.find_class(class_name)) {
        OksQuery q(c, query);
 
        if (q.good()) {
          OksObject::List* l = c->execute_query(&q);
          if (l && !l->empty()) {
            for (OksObject::List::iterator i = l->begin(); i != l->end(); ++i) {
              objects.insert(*i);
              if (ref_level > 0) {
                (*i)->references(objects, static_cast<unsigned long>(ref_level));
              }
            }
          } else {
            std::cerr << "ERROR: failed to find any object of class \"" << class_name << "\" satisfying query \""
                      << query << "\", exiting...\n";
            unlink(schema_file.c_str());
            unlink(data_file.c_str());
            return (EXIT_FAILURE);
          }
        } else {
          std::cerr << "ERROR: failed to parse query \"" << query << "\" for class class \"" << class_name
                    << "\", exiting...\n";
          unlink(schema_file.c_str());
          unlink(data_file.c_str());
          return (EXIT_FAILURE);
        }
      } else {
        std::cerr << "ERROR: cannot find class \"" << class_name << "\", exiting...\n";
        unlink(schema_file.c_str());
        unlink(data_file.c_str());
        return (EXIT_FAILURE);
      }
 
      if (verbose_level > 2) {
        std::cout << objects.size() << " objects to be saved as defined by query and reference-level parameters:\n";
 
        for (OksObject::FSet::const_iterator i = objects.begin(); i != objects.end(); ++i) {
          std::cout << "  " << *i << std::endl;
        }
      }
 
      std::string trash_data_file = kernel.get_tmp_file("/tmp/trash.data.xml");
      OksFile* fh3 = kernel.new_data(trash_data_file);
 
      if (!fh3) {
        std::cerr << "ERROR: failed to create oks data file \'" << trash_data_file << "\'\n";
        unlink(schema_file.c_str());
        unlink(data_file.c_str());
        return (EXIT_FAILURE);
      }
 
      VerboseMsg3("Filter out objects not satisfying query...");
      for (OksObject::Set::const_iterator i = kernel.objects().begin(); i != kernel.objects().end(); ++i) {
        if (objects.find(*i) == objects.end()) {
          (*i)->set_file(fh3);
          VerboseMsg3(" - filter out object " << *i);
        }
      }
 
      unlink(trash_data_file.c_str());
    }
 
    VerboseMsg5("Dump data:\n" << kernel);
 
    if (remove_schema_file) {
      VerboseMsg2("Removing temporal schema file \'" << schema_file << "\'...");
      unlink(schema_file.c_str());
    } else {
      VerboseMsg2("Saving oks schema...");
      kernel.save_schema(fh1);
      fh2->add_include_file(schema_file);
    }
 
    if (remove_data_file) {
      VerboseMsg2("Removing temporal data file \'" << data_file << "\'...");
      unlink(data_file.c_str());
    } else {
      VerboseMsg2("Saving oks data...");
      kernel.save_data(fh2, true);
    }
 
    VerboseMsg2("Exiting...");
  }
 
  catch (coral::Exception& e) {
    std::cerr << "CORAL exception: " << e.what() << std::endl;
    return 1;
  }
 
  catch (oks::exception& ex) {
    std::cerr << "OKS exception:\n" << ex << std::endl;
    return 2;
  }
 
  catch (std::exception& e) {
    std::cerr << "Standard C++ exception : " << e.what() << std::endl;
    return 3;
  }
 
  catch (...) {
    std::cerr << "Exception caught (...)" << std::endl;
    return 4;
  }
 
  return 0;
}