dalMethods.cpp

Go to the documentation of this file.

 
#include "confmodel/Application.hpp"
#include "confmodel/confmodelIssues.hpp"
#include "confmodel/DaqApplication.hpp"
#include "confmodel/DaqModule.hpp"
#include "confmodel/DetDataSender.hpp"
#include "confmodel/DetDataReceiver.hpp"
#include "confmodel/DetectorToDaqConnection.hpp"
#include "confmodel/DetectorStream.hpp"
#include "confmodel/Jsonable.hpp"
#include "confmodel/OpMonURI.hpp"
#include "confmodel/PhysicalHost.hpp"
#include "confmodel/RCApplication.hpp"
#include "confmodel/Resource.hpp"
#include "confmodel/ResourceSet.hpp"
#include "confmodel/Segment.hpp"
#include "confmodel/Session.hpp"
#include "confmodel/Service.hpp"
#include "confmodel/VirtualHost.hpp"
 
#include "confmodel/test_circular_dependency.hpp"
 
#include "nlohmann/json.hpp"
#include "conffwk/ConfigObject.hpp"
#include "conffwk/Configuration.hpp"
#include "conffwk/Schema.hpp"
 
#include <list>
#include <set>
#include <iostream>
 
using namespace dunedaq::conffwk;
 
 
// Stolen from ATLAS dal package
namespace {
void
make_parents_list(
    const ConfigObjectImpl * child,
    const dunedaq::confmodel::ResourceSet * resource_set,
    std::vector<const dunedaq::confmodel::Resource *> & p_list,
    std::list< std::vector<const dunedaq::confmodel::Resource *> >& out,
    dunedaq::confmodel::TestCircularDependency& cd_fuse)
{
  dunedaq::confmodel::AddTestOnCircularDependency add_fuse_test(cd_fuse, resource_set);
 
  // add the resource set to the path
  p_list.push_back(resource_set);
 
  // check if the application is in the resource relationship, i.e. is a resource or belongs to resource set(s)
  for (const auto& i : resource_set->contained_resources()) {
    if (i->config_object().implementation() == child) {
      out.push_back(p_list);
    }
    else if (const dunedaq::confmodel::ResourceSet * rs = i->cast<dunedaq::confmodel::ResourceSet>()) {
      make_parents_list(child, rs, p_list, out, cd_fuse);
    }
  }
 
  // remove the resource set from the path
  p_list.pop_back();
}
 
void
make_parents_list(
    const dunedaq::conffwk::ConfigObjectImpl * child,
    const dunedaq::confmodel::Segment * segment,
    std::vector<const dunedaq::confmodel::Resource *> & p_list,
    std::list<std::vector<const dunedaq::confmodel::Resource *> >& out,
    bool is_segment,
    dunedaq::confmodel::TestCircularDependency& cd_fuse)
{
  dunedaq::confmodel::AddTestOnCircularDependency add_fuse_test(cd_fuse, segment);
 
  // add the segment to the path
  p_list.push_back(segment);
 
  // check if the application is in the nested segment
  for (const auto& seg : segment->get_segments()) {
    if (seg->config_object().implementation() == child)
      out.push_back(p_list);
    else
      make_parents_list(child, seg, p_list, out, is_segment, cd_fuse);
  }
  if (!is_segment) {
    for (const auto& app : segment->get_applications()) {
      if (app->config_object().implementation() == child)
        out.push_back(p_list);
      else if (const auto resource_set = app->cast<dunedaq::confmodel::ResourceSet>())
        make_parents_list(child, resource_set, p_list, out, cd_fuse);
    }
  }
 
  // remove the segment from the path
 
  p_list.pop_back();
}
 
 
void
check_segment(
    std::list< std::vector<const dunedaq::confmodel::Resource *> >& out,
    const dunedaq::confmodel::Segment * segment,
    const dunedaq::conffwk::ConfigObjectImpl * child,
    bool is_segment,
    dunedaq::confmodel::TestCircularDependency& cd_fuse)
{
  dunedaq::confmodel::AddTestOnCircularDependency add_fuse_test(cd_fuse, segment);
 
  std::vector<const dunedaq::confmodel::Resource *> compList;
 
  if (segment->config_object().implementation() == child) {
    out.push_back(compList);
  }
  make_parents_list(child, segment, compList, out, is_segment, cd_fuse);
}
} // namespace
 
 
namespace dunedaq::confmodel {
 
void
Resource::parents(
  const Session& session,
  std::list<std::vector<const Resource *>>& parents) const
{
  const ConfigObjectImpl * obj_impl = config_object().implementation();
 
  const bool is_segment = castable(Segment::s_class_name);
 
  try {
    TestCircularDependency cd_fuse("component parents", &session);
 
    // check session's segment
    check_segment(parents, session.get_segment(), obj_impl, is_segment,
                  cd_fuse);
 
 
    if (parents.empty()) {
      TLOG_DEBUG(1) <<  "cannot find segment/resource path(s) between Resource " << this << " and session " << &session << " objects (check this object is linked with the session as a segment or a resource)" ;
    }
  }
  catch (ers::Issue & ex) {
    ers::error(CannotGetParents(ERS_HERE, full_name(), ex));
  }
}
 
// ========================================================================
 
std::vector<const Application*>
Session::getSegmentApps(const Segment* segment,
                        bool enabled_only) const {
  std::vector<const Application*> apps;
  auto segapps = segment->get_applications();
  if (enabled_only) {
    for (auto app : segapps) {
      auto comp = app->cast<Resource>();
      if (comp == nullptr || !comp->is_disabled(*this)) {
        apps.insert(apps.end(), app);
      }
    }
  }
  else {
    apps.swap(segapps);
  }
  for (auto seg : segment->get_segments()) {
    if (!enabled_only || !seg->is_disabled(*this)) {
      auto segapps = getSegmentApps(seg, enabled_only);
      apps.insert(apps.end(), segapps.begin(),segapps.end());
    }
  }
  return apps;
}
 
std::vector<const Application*>
Session::all_applications() const {
  std::vector<const Application*> apps;
  auto segapps = getSegmentApps(get_segment(), false);
  apps.insert(apps.end(), segapps.begin(),segapps.end());
  return apps;
}
 
std::vector<const Application*>
Session::enabled_applications() const {
  std::vector<const Application*> apps;
  auto segapps = getSegmentApps(get_segment(), true);
  apps.insert(apps.end(), segapps.begin(),segapps.end());
  return apps;
}
 
 
// ========================================================================
 
std::set<const HostComponent*>
DaqApplication::get_used_hostresources() const {
  std::set<const HostComponent*> res;
  for (auto module :  get_modules()) {
    for (auto hostresource : module->get_used_resources()) {
      res.insert(hostresource);
    }
  }
  return res;
}
 
namespace {
nlohmann::json get_json_config(conffwk::Configuration& confdb,
                               const std::string& class_name,
                               const std::string& uid,
                               bool direct_only,
                               bool skip_object_name) {
  using nlohmann::json;
  using namespace conffwk;
  TLOG_DBG(9) << "Getting attributes for " << uid << " of class " << class_name;
  json attributes;
  auto class_info = confdb.get_class_info(class_name);
  ConfigObject obj;
  confdb.get(class_name, uid, obj);
  for (auto attr : class_info.p_attributes) {
    if (attr.p_type == type_t::u8_type) {
      add_json_value<uint8_t>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
    else if (attr.p_type == type_t::u16_type) {
      add_json_value<uint16_t>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
    else if (attr.p_type == type_t::u32_type) {
      add_json_value<uint32_t>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
    else if (attr.p_type == type_t::u64_type) {
      add_json_value<uint64_t>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
    else if (attr.p_type == type_t::s8_type) {
      add_json_value<int8_t>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
    else if (attr.p_type == type_t::s16_type) {
      add_json_value<int16_t>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
    else if (attr.p_type == type_t::s32_type ||
             attr.p_type == type_t::s16_type) {
      add_json_value<int32_t>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
    else if (attr.p_type == type_t::s64_type) {
      add_json_value<int64_t>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
    else if (attr.p_type == type_t::float_type) {
      add_json_value<float>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
    else if (attr.p_type == type_t::double_type) {
      add_json_value<double>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
    else if (attr.p_type == type_t::bool_type) {
      add_json_value<bool>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
    else if ((attr.p_type == type_t::string_type) ||
             (attr.p_type == type_t::enum_type) ||
             (attr.p_type == type_t::date_type) ||
             (attr.p_type == type_t::time_type)) {
      add_json_value<std::string>(obj, attr.p_name, attr.p_is_multi_value, attributes);
    }
  }
  if (!direct_only) {
    TLOG_DBG(9) << "Processing  relationships";
    for (auto iter: class_info.p_relationships) {
      std::string rel_name = iter.p_name;
      if (iter.p_cardinality == cardinality_t::zero_or_one ||
          iter.p_cardinality == cardinality_t::only_one) {
        ConfigObject rel_obj;
        obj.get(rel_name, rel_obj);
        if (!rel_obj.is_null()) {
          TLOG_DBG(9) << "Getting attibute of relationship " << rel_name;
          attributes[rel_name] = get_json_config(confdb, rel_obj.class_name(),
                                                 rel_obj.UID(),
                                                 direct_only,
                                                 skip_object_name);
        }
        else {
          TLOG_DBG(9) << "Relationship " << rel_name << " not set";
        }
      }
      else {
        TLOG_DBG(9) << "Relationship " << rel_name << " is multi value. "
                    << "Getting attibutes for relationship.";
        std::vector<ConfigObject> rel_vec;
        obj.get(rel_name, rel_vec);
        std::vector<json> configs;
        for (auto rel_obj : rel_vec) {
          TLOG_DBG(9) << "Getting attibute of relationship " << rel_obj.UID();
          auto rel_conf = get_json_config(confdb, rel_obj.class_name(), rel_obj.UID(),
                                          direct_only, skip_object_name);
          configs.push_back(rel_conf);
        }
        attributes[rel_name] = configs;
      }
    }
  }
 
  if (skip_object_name) {
    return attributes;
  }
  json json_config;
  json_config[uid] = attributes;
  return json_config;
}
} // namespace
 
nlohmann::json Jsonable::to_json(bool direct_only,
                                 bool skip_object_name) const {
  return get_json_config(p_registry.configuration(), class_name(), UID(), direct_only,
                         skip_object_name);
}
 
const std::vector<std::string> DaqApplication::construct_commandline_parameters(
  const conffwk::Configuration& confdb,
  const dunedaq::confmodel::Session* session) const {
 
    return construct_commandline_parameters_appfwk<dunedaq::confmodel::DaqApplication>(this, confdb, session);
}
 
const std::vector<std::string> RCApplication::construct_commandline_parameters(
  const conffwk::Configuration& confdb,
  const dunedaq::confmodel::Session* session) const {
 
    const std::string configuration_uri = confdb.get_impl_spec();
    const dunedaq::confmodel::Service* control_service = nullptr;
 
    const std::string controller_log_level = session->get_controller_log_level();
 
    for (auto const *as : get_exposes_service()) {
      if (as->UID().ends_with("_control")) {
        if (control_service)
          throw DuplicatedControlService(ERS_HERE, as->UID());
        control_service = as;
      }
    }
 
    if (control_service == nullptr)
      throw NoControlServiceDefined(ERS_HERE, UID());
 
    const std::string control_uri =
      control_service->get_protocol()
      + "://"
      + get_runs_on()->get_runs_on()->UID()
      + ":"
      + std::to_string(control_service->get_port());
 
    std::vector<std::string> ret = { "-l", controller_log_level };
    ret.push_back(configuration_uri);
    ret.push_back(control_uri);
    ret.push_back(UID());
    ret.push_back(session->UID());
    return ret;
}
 
 
 
std::vector<const confmodel::DetectorStream*>
DetectorToDaqConnection::streams() const {
  std::vector<const confmodel::DetectorStream*> all_streams;
  // Loop over senders
  for (auto sender : this->senders()) {
    auto sender_streams = sender->get_streams();
    all_streams.insert(all_streams.end(), sender_streams.begin(), sender_streams.end());
  }
  return all_streams;
}
 
std::string OpMonURI::get_URI( const std::string & /* app */) const {
 
  auto type = get_type();
  if ( type == "file" ) {
    return type + "://" + get_path();
  }
 
  if ( type == "stream" ) {
    return type + "://" + get_path();
  }
 
  return "stdout://";
}
 
bool Resource::is_disabled(const dunedaq::confmodel::ResourceTree& holder) const {
  return (!holder.disabled_components().is_enabled(this));
}
bool Resource::compute_disabled_state(const std::set<std::string>& disabled_resources) const {
  TLOG_DEBUG(6) << "No compute_disabled_state method defined for Resource " << class_name();
  if (disabled_resources.contains(UID())) {
    return true;
  }
  return false;
}
 
std::vector<const Resource*> DetDataSender::contained_resources() const {
  return to_resources(get_streams());
}
 
std::vector<const Resource*> DetectorToDaqConnection::contained_resources() const {
  auto res = to_resources(senders());
  res.push_back(receiver());
  return res;
}
 
 
bool
DetectorToDaqConnection::compute_disabled_state(const std::set<std::string>& disabled_resources) const {
  if (disabled_resources.contains(UID())) {
    return true;
  }
  bool send_disabled = true;
  for (auto sender: senders()) {
    if (!sender->compute_disabled_state(disabled_resources)) {
      send_disabled = false;
      break;
    }
  }
  TLOG_DBG(6) << "receiver disabled=" << receiver()->compute_disabled_state(disabled_resources)
              << " senders disabled=" << send_disabled;
  if (receiver()->compute_disabled_state(disabled_resources) || send_disabled) {
    return true;
  }
  return false;
}
 
std::vector<const Resource*>
Segment::contained_resources() const {
  // All our contained segments are resources
  std::vector<const Resource*> resources = to_resources(get_segments());
 
  // Only a subset of our applications might be resources so check individually
  for (auto app: get_applications()) {
    TLOG_DBG(6) << "Checking " << app->UID();
    auto res=app->cast<const Resource>();
    if (res != nullptr) {
      TLOG_DBG(6) << "Adding " << app->UID();
      resources.push_back(res);
    }
  }
  TLOG_DBG(6) << "Returning vector of " << resources.size() << " resources";
  return resources;
}
 
bool
Segment::compute_disabled_state(const std::set<std::string>& disabled) const {
  if (disabled.contains(UID())) {
    return true;
  }
  for (auto app: get_applications()) {
    auto res=app->cast<const Resource>();
    if (res == nullptr) {
      return false;
    }
  }
  for (auto res: contained_resources()) {
    if (!res->compute_disabled_state(disabled)) {
      return false;
    }
  }
  return true;
}
 
} // namespace dunedaq::confmodel