converter.cxx

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#include "EventVisualisationDataConverter/VisualisationEvent.h"
#include "EventVisualisationView/Initializer.h"
#include "EventVisualisationView/Options.h"
#include <EventVisualisationDataConverter/Location.h>
#include <EventVisualisationDataConverter/VisualisationEventJSONSerializer.h>
#include <EventVisualisationDataConverter/VisualisationEventROOTSerializer.h>
#include <EventVisualisationDataConverter/VisualisationEventOpenGLSerializer.h>
#include <EventVisualisationBase/DirectoryLoader.h>
#include <TEveManager.h>
#include <filesystem>
#include <fairlogger/Logger.h>
#include <csignal>
#include <thread>
#include <chrono>
 
#include <boost/program_options.hpp>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/variables_map.hpp>
 
using namespace std::chrono_literals;
 
// source file name, destination (not existing) file name, if limit > 0 then limit EACH type of data
int singleFileConversion(const std::string& src, o2::event_visualisation::Location& dst, const int limit = -1)
{
  LOGF(info, "Translate: %s -> %s", src, dst.fileName());
  o2::event_visualisation::VisualisationEvent vEvent;
 
  auto srcSerializer = o2::event_visualisation::VisualisationEventSerializer::getInstance(
    std::filesystem::path(src).extension());
  auto dstExtension = std::filesystem::path(
                        src)
                        .extension(); // if there is no destination, there will be no extension change
  if (!dst.fileName().empty()) {
    dstExtension = std::filesystem::path(dst.fileName()).extension();
  }
  auto dstSerializer = o2::event_visualisation::VisualisationEventSerializer::getInstance(
    dstExtension);
 
  std::chrono::time_point currentTime = std::chrono::high_resolution_clock::now();
  std::chrono::time_point endTime = std::chrono::high_resolution_clock::now();
 
  srcSerializer->fromFile(vEvent, src);
  endTime = std::chrono::high_resolution_clock::now();
  // LOGF(info, "read took %f", std::chrono::duration_cast<std::chrono::microseconds>(endTime - currentTime).count() * 1e-6);
  if (limit > 0) {
    vEvent = vEvent.limit(limit);
  }
 
  currentTime = std::chrono::high_resolution_clock::now();
  dstSerializer->toFile(vEvent, dst);
  endTime = std::chrono::high_resolution_clock::now();
  // LOGF(info, "write took %f", std::chrono::duration_cast<std::chrono::microseconds>(endTime - currentTime).count() * 1e-6);
  return 0;
}
 
// reads source folder files, find missing files in destination folder and convert them
// source folder (/path-to-folder/.ext1) , destination folder (/path-to-folder/.ext2)
int folderConversion(const std::string& srcFolder, const o2::event_visualisation::Location& dstFolderLocation)
{
  const std::string dstFolder = dstFolderLocation.fileName();
  std::vector<std::string> supported = {".json", ".root", ".eve"};
  auto ext1 = srcFolder.substr(srcFolder.rfind('.'));
  auto ext2 = dstFolder.substr(dstFolder.rfind('.'));
 
  if (supported.end() == std::find(supported.begin(), supported.end(), ext1)) {
    LOGF(error, "source folder should end with source extension:  /path-to-folder/.ext1 ");
    exit(-1);
  }
  if (supported.end() == std::find(supported.begin(), supported.end(), ext2)) {
    LOGF(error, "destination folder should end with destination extension:  /path-to-folder/.ext2 ");
    return -1;
  }
  auto src = srcFolder.substr(0, srcFolder.size() - std::string(ext1).size());
  auto dst = dstFolder.substr(0, dstFolder.size() - std::string(ext2).size());
 
  if (src == dst) {
    LOGF(error, "source folder same as destination folder ");
    return -1;
  }
  if (!std::filesystem::is_directory(src)) {
    LOGF(error, "source folder do not exist ");
    return -1;
  }
  if (!std::filesystem::is_directory(dst)) {
    LOGF(error, "destination folder do not exist ");
    return -1;
  }
  std::vector<std::string> vExt1 = {ext1};
  auto sourceList = o2::event_visualisation::DirectoryLoader::load(src, "_", vExt1);
  std::vector<std::string> vExt2 = {ext2};
  auto destinationList = o2::event_visualisation::DirectoryLoader::load(dst, "_", vExt2);
 
  // first delete destination files which has not corresponding source files
  for (auto& e : destinationList) {
    auto match = e.substr(0, e.size() - ext2.size()) + ext1;
    if (sourceList.end() == std::find(sourceList.begin(), sourceList.end(), match)) {
      auto path = std::filesystem::path(dst + "" + e);
      std::filesystem::remove(path);
    }
  }
 
  // second translate source files which has not corresponding destination files
  for (auto& e : sourceList) {
    auto match = e.substr(0, e.size() - ext1.size()) + ext2;
    if (destinationList.end() == std::find(destinationList.begin(), destinationList.end(), match)) {
      // LOGF(info, "translate %s ->%s", src+e, dst+match);
      o2::event_visualisation::Location location({.fileName = dst + match,
                                                  .port = dstFolderLocation.port(),
                                                  .host = dstFolderLocation.hostName()});
      singleFileConversion(src + e, location);
      ;
      singleFileConversion(src + e, location);
      ;
    }
  }
 
  return 0;
}
 
void my_handler(int s)
{
  printf("Caught signal %d\n", s);
  exit(1);
}
 
namespace po = boost::program_options;
 
using namespace std;
 
int main(int argc, char** argv)
{
  struct sigaction sigIntHandler {
  };
  sigIntHandler.sa_handler = my_handler;
  sigemptyset(&sigIntHandler.sa_mask);
  sigIntHandler.sa_flags = 0;
 
  sigaction(SIGINT, &sigIntHandler, nullptr);
  LOGF(info, "Welcome in O2 event conversion tool");
 
  try {
    int port;
    string host;
    int limit;
    bool folderMode;
    bool continuousMode;
    vector<string> sources;
    po::options_description desc("Allowed options");
    desc.add_options()("help,h", "produce help message")("port", po::value(&port)->default_value(-1), "port number")("host", po::value(&host)->default_value("localhost"), "host name")("sources", po::value(&sources), "sources")("limit,l", po::value(&limit)->default_value(-1), "limit number of elements")("folder,f", po::bool_switch(&folderMode)->default_value(false), "convert folders")("continuous,c", po::bool_switch(&continuousMode)->default_value(false), "continuous folder mode");
 
    po::positional_options_description p;
    p.add("sources", 2);
 
    po::variables_map vm;
    po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
    po::notify(vm);
 
    if (vm.count("help")) {
      cout << desc << "\n";
      return 0;
    }
 
    if (vm.count("sources")) {
      if (vm["sources"].as<vector<string>>().size() != 2) {
        cout << "two positional parameters expected" << "\n";
        return 0;
      }
    }
    o2::event_visualisation::LocationParams locationParams;
    locationParams.fileName = sources[1];
    locationParams.port = port;
    locationParams.host = host;
 
    o2::event_visualisation::Location location(locationParams);
 
    if (folderMode) {
      folderConversion(sources[0], location);
    } else if (continuousMode) {
      while (true) {
        std::this_thread::sleep_for(2000ms);
        folderConversion(sources[0], location);
      }
    } else {
      singleFileConversion(sources[0], location, limit);
      return 0;
    }
  }
 
  catch (exception& e) {
    cerr << "error: " << e.what() << "\n";
    return 1;
  } catch (...) {
    cerr << "Exception of unknown type!\n";
  }
  return -1; // std::quick_exit(-1);
}