list_apps.cxx

Go to the documentation of this file.

#include "logging/Logging.hpp"
 
#include "conffwk/Configuration.hpp"
 
#include "confmodel/DaqApplication.hpp"
#include "confmodel/DaqModule.hpp"
#include "confmodel/ExcludableEntitySet.hpp"
#include "confmodel/Segment.hpp"
#include "confmodel/Session.hpp"
 
#include <iostream>
// #include <set>
#include <string>
 
using namespace dunedaq;
using namespace dunedaq::confmodel;
 
void
process_segment(const Session* session,
                const Segment* segment,
                const std::set<std::string>& excluded_objects,
                std::string spacer)
{
  std::cout << spacer << "Segment " << segment->UID();
  bool segment_excluded = segment->is_excluded(*session);
  std::string reason = "";
  if (segment_excluded) {
    std::cout << " excluded";
    reason = "segment";
  }
  std::cout << "\n";
  for (auto subseg : segment->get_segments()) {
    process_segment(session, subseg, excluded_objects, spacer + "  ");
  }
 
  for (auto app : segment->get_applications()) {
    bool excluded = segment_excluded;
    std::cout << spacer << "  Application: " << app->UID();
    if (!excluded) {
      auto rset = app->cast<ExcludableEntitySet>();
      if (rset) {
        if (rset->is_excluded(*session)) {
          excluded = true;
          if (excluded_objects.find(app->UID()) != excluded_objects.end()) {
            reason = "directly";
          } else {
            reason = "due to state of related objects";
          }
        }
        std::cout << " contains: {";
        std::string seperator = "";
        for (auto mod : rset->contained_excludable_entities()) {
          std::cout << seperator << mod->UID();
          if (mod->is_excluded(*session)) {
            std::cout << "<excluded ";
            if (excluded_objects.find(mod->UID()) == excluded_objects.end()) {
              std::cout << "in";
            }
            std::cout << "directly>";
          }
          seperator = ", ";
        }
        std::cout << "}";
      }
    }
    if (excluded) {
      std::cout << " <excluded " << reason << ">";
    }
    auto daqApp = app->cast<DaqApplication>();
    if (daqApp) {
      std::cout << " Modules:";
      for (auto mod : daqApp->get_modules()) {
        std::cout << " " << mod->UID();
      }
    }
 
    std::cout << std::endl;
  }
}
 
int
main(int argc, char* argv[])
{
 
  if (argc < 2) {
    std::cout << "Usage: " << argv[0] << " [session] database-file\n";
    return 0;
  }
 
  int filearg = 1;
  if (argc == 3) {
    filearg = 2;
  }
  std::string confimpl = "oksconflibs:" + std::string(argv[filearg]);
  auto confdb = new conffwk::Configuration(confimpl);
 
  std::vector<std::string> sessionList;
  if (argc == 3) {
    sessionList.emplace_back(std::string(argv[1]));
  } else {
    std::vector<conffwk::ConfigObject> session_obj;
    confdb->get("Session", session_obj);
    if (session_obj.size() == 0) {
      std::cerr << "Can't find any Sessions in database\n";
      return -1;
    }
    for (auto obj : session_obj) {
      sessionList.push_back(obj.UID());
    }
  }
  dunedaq::logging::Logging::setup(sessionList[0], "list-apps");
 
  std::string separator{};
  for (const auto& sessionName : sessionList) {
    const Session* session;
    session = confdb->get<Session>(sessionName);
    if (session == nullptr) {
      std::cerr << "Session " << sessionName << " not found in database\n";
      return -1;
    }
 
    std::cout << separator << "      Applications in Session: " << sessionName << "\n";
    std::set<std::string> excluded_objects;
    for (auto object : session->get_excluded()) {
      TLOG_DEBUG(11) << object->UID() << " is in excluded list of Session";
      excluded_objects.insert(object->UID());
    }
 
    process_segment(session, session->get_segment(), excluded_objects, "");
    separator = "\n   ----------------------------------------------\n\n";
  }
  delete confdb;
}