Johnfreeman/daq release issue379 renames

CMakeLists.txt

@@ -18,7 +18,7 @@ daq_setup_environment()
 find_package(appfwk REQUIRED)
 find_package(logging REQUIRED)
 find_package(opmonlib REQUIRED)
-find_package(readoutmodules REQUIRED)
+find_package(datahandlinglibs REQUIRED)
 find_package(fdreadoutlibs REQUIRED)
 find_package(fddetdataformats REQUIRED)
 find_package(Boost COMPONENTS unit_test_framework REQUIRED)
@@ -39,8 +39,7 @@ set(FDREADOUTMODULES_DEPENDENCIES
 #tools
   appfwk::appfwk
   logging::logging
-  readoutlibs::readoutlibs
-  readoutmodules::readoutmodules
+  datahandlinglibs::datahandlinglibs
   fdreadoutlibs::fdreadoutlibs
   fddetdataformats::fddetdataformats
 )
@@ -71,13 +70,13 @@ daq_add_python_bindings(*.cpp LINK_LIBRARIES ${PROJECT_NAME} ) # Any additional
 
 # See https://dune-daq-sw.readthedocs.io/en/latest/packages/daq-cmake/#daq_add_plugin
 
-#daq_add_plugin(DataRecorderModule duneDAQModule LINK_LIBRARIES appfwk::appfwk readoutmodules::readoutmodules fdreadoutlibs::fdreadoutlibs)
-#daq_add_plugin(ErroredFrameConsumer duneDAQModule LINK_LIBRARIES appfwk::appfwk readoutmodules::readoutmodules fddetdataformats::fddetdataformats)
-#daq_add_plugin(FragmentConsumer duneDAQModule LINK_LIBRARIES appfwk::appfwk readoutmodules::readoutmodules fddetdataformats::fddetdataformats)
-#daq_add_plugin(TimeSyncConsumer duneDAQModule LINK_LIBRARIES appfwk::appfwk readoutmodules::readoutmodules)
+#daq_add_plugin(DataRecorderModule duneDAQModule LINK_LIBRARIES appfwk::appfwk datahandlinglibs::datahandlinglibs fdreadoutlibs::fdreadoutlibs)
+#daq_add_plugin(ErroredFrameConsumer duneDAQModule LINK_LIBRARIES appfwk::appfwk datahandlinglibs::datahandlinglibs fddetdataformats::fddetdataformats)
+#daq_add_plugin(FragmentConsumer duneDAQModule LINK_LIBRARIES appfwk::appfwk datahandlinglibs::datahandlinglibs fddetdataformats::fddetdataformats)
+#daq_add_plugin(TimeSyncConsumer duneDAQModule LINK_LIBRARIES appfwk::appfwk datahandlinglibs::datahandlinglibs)
 
-daq_add_plugin(FDDataHandlerModule duneDAQModule LINK_LIBRARIES appfwk::appfwk readoutmodules::readoutmodules fdreadoutlibs::fdreadoutlibs)
-daq_add_plugin(FDFakeReaderModule duneDAQModule LINK_LIBRARIES appfwk::appfwk readoutmodules::readoutmodules fdreadoutlibs::fdreadoutlibs)
+daq_add_plugin(FDDataHandlerModule duneDAQModule LINK_LIBRARIES appfwk::appfwk datahandlinglibs::datahandlinglibs fdreadoutlibs::fdreadoutlibs)
+daq_add_plugin(FDFakeReaderModule duneDAQModule LINK_LIBRARIES appfwk::appfwk datahandlinglibs::datahandlinglibs fdreadoutlibs::fdreadoutlibs)
 
 ##############################################################################
 

cmake/fdreadoutmodulesConfig.cmake.in

@@ -9,7 +9,7 @@ include(CMakeFindDependencyMacro)
 find_dependency(appfwk)
 find_dependency(logging)
 find_dependency(opmonlib)
-find_dependency(readoutmodules)
+find_dependency(datahandlinglibs)
 find_dependency(fdreadoutlibs)
 find_dependency(fddetdataformats)
 find_dependency(Boost)

plugins/DataRecorderModule.cpp

@@ -12,24 +12,24 @@
 #include "fdreadoutlibs/DUNEWIBEthTypeAdapter.hpp"
 #include "fdreadoutlibs/TDEFrameTypeAdapter.hpp"
 #include "fdreadoutlibs/DAPHNESuperChunkTypeAdapter.hpp"
-//#include "ndreadoutlibs/NDReadoutPACMANTypeAdapter.hpp"
-//#include "ndreadoutlibs/NDReadoutMPDTypeAdapter.hpp"
+//#include "nddatahandlinglibs/NDReadoutPACMANTypeAdapter.hpp"
+//#include "nddatahandlinglibs/NDReadoutMPDTypeAdapter.hpp"
 
-#include "readoutlibs/ReadoutLogging.hpp"
-#include "readoutlibs/models/RecorderModel.hpp"
-#include "readoutlibs/recorderconfig/Nljs.hpp"
-#include "readoutlibs/recorderconfig/Structs.hpp"
-#include "readoutlibs/recorderinfo/InfoNljs.hpp"
+#include "datahandlinglibs/ReadoutLogging.hpp"
+#include "datahandlinglibs/models/RecorderModel.hpp"
+#include "datahandlinglibs/recorderconfig/Nljs.hpp"
+#include "datahandlinglibs/recorderconfig/Structs.hpp"
+#include "datahandlinglibs/recorderinfo/InfoNljs.hpp"
 
 #include "DataRecorderModule.hpp"
 #include "appfwk/DAQModuleHelper.hpp"
 
 #include "appfwk/cmd/Nljs.hpp"
 #include "logging/Logging.hpp"
-#include "readoutlibs/ReadoutIssues.hpp"
+#include "datahandlinglibs/DataHandlingIssues.hpp"
 #include <string>
 
-using namespace dunedaq::readoutlibs::logging;
+using namespace dunedaq::datahandlinglibs::logging;
 
 namespace dunedaq {
 namespace fdreadoutmodules {
@@ -51,7 +51,7 @@ DataRecorderModule::init(const data_t& args)
     auto ci = appfwk::connection_index(args, {"raw_recording"});
     auto datatypes = dunedaq::iomanager::IOManager::get()->get_datatypes(ci["raw_recording"]);
     if (datatypes.size() != 1) {
-    ers::error(dunedaq::readoutlibs::GenericConfigurationError(ERS_HERE,
+    ers::error(dunedaq::datahandlinglibs::GenericConfigurationError(ERS_HERE,
       "Multiple raw_recording queues specified! Expected only a single raw_dtance!"));
     }
     std::string raw_dt{ *datatypes.begin() };
@@ -61,15 +61,15 @@ DataRecorderModule::init(const data_t& args)
     // IF WIB2
     if (raw_dt.find("WIB2Frame") != std::string::npos) {
       TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating recorder for wib2";
-      recorder.reset(new readoutlibs::RecorderModel<fdreadoutlibs::types::DUNEWIBSuperChunkTypeAdapter>(get_name()));
+      recorder.reset(new datahandlinglibs::RecorderModel<fdreadoutlibs::types::DUNEWIBSuperChunkTypeAdapter>(get_name()));
       recorder->init(args);
       return;
     }
 
     /* IF WIB
     if (raw_dt.find("WIBFrame") != std::string::npos) {
       TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating recorder for wib";
-      recorder.reset(new readoutlibs::RecorderModel<fdreadoutlibs::types::ProtoWIBSuperChunkTypeAdapter>(get_name()));
+      recorder.reset(new datahandlinglibs::RecorderModel<fdreadoutlibs::types::ProtoWIBSuperChunkTypeAdapter>(get_name()));
       recorder->init(args);
       return;
     }
@@ -78,15 +78,15 @@ DataRecorderModule::init(const data_t& args)
     // IF WIBEth
     if (raw_dt.find("WIBEthFrame") != std::string::npos) {
       TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating recorder for wibeth";
-      recorder.reset(new readoutlibs::RecorderModel<fdreadoutlibs::types::DUNEWIBEthTypeAdapter>(get_name()));
+      recorder.reset(new datahandlinglibs::RecorderModel<fdreadoutlibs::types::DUNEWIBEthTypeAdapter>(get_name()));
       recorder->init(args);
       return;
     }
 
     // IF PDS
     if (raw_dt.find("PDSFrame") != std::string::npos) {
       TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating recorder for pds";
-      recorder.reset(new readoutlibs::RecorderModel<fdreadoutlibs::types::DAPHNESuperChunkTypeAdapter>(get_name()));
+      recorder.reset(new datahandlinglibs::RecorderModel<fdreadoutlibs::types::DAPHNESuperChunkTypeAdapter>(get_name()));
       recorder->init(args);
       return;
     }
@@ -95,15 +95,15 @@ DataRecorderModule::init(const data_t& args)
     /*
       if (raw_dt.find("PACMANFrame") != std::string::npos) {
       TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating recorder for pacman";
-      recorder.reset(new readoutlibs::RecorderModel<ndreadoutlibs::types::NDReadoutPACMANTypeAdapter>(get_name()));
+      recorder.reset(new datahandlinglibs::RecorderModel<nddatahandlinglibs::types::NDReadoutPACMANTypeAdapter>(get_name()));
       recorder->init(args);
       return;
     }
 
     // IF MPD
     if (raw_dt.find("MPDFrame") != std::string::npos) {
       TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating recorder for mpd";
-      recorder.reset(new readoutlibs::RecorderModel<ndreadoutlibs::types::NDReadoutMPDTypeAdapter>(get_name()));
+      recorder.reset(new datahandlinglibs::RecorderModel<nddatahandlinglibs::types::NDReadoutMPDTypeAdapter>(get_name()));
       recorder->init(args);
       return;
     }
@@ -112,15 +112,15 @@ DataRecorderModule::init(const data_t& args)
     // IF TDE
     if (raw_dt.find("TDEFrame") != std::string::npos) {
       TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating recorder for tde";
-      recorder.reset(new readoutlibs::RecorderModel<fdreadoutlibs::types::TDEFrameTypeAdapter>(get_name()));
+      recorder.reset(new datahandlinglibs::RecorderModel<fdreadoutlibs::types::TDEFrameTypeAdapter>(get_name()));
       recorder->init(args);
       return;
     }
 
-    throw readoutlibs::DataRecorderConfigurationError(ERS_HERE, "Could not create DataRecorderModule of type " + raw_dt);
+    throw datahandlinglibs::DataRecorderConfigurationError(ERS_HERE, "Could not create DataRecorderModule of type " + raw_dt);
 
   } catch (const ers::Issue& excpt) {
-    throw readoutlibs::DataRecorderModuleResourceQueueError(ERS_HERE, "Could not initialize queue", "raw_recording", "");
+    throw datahandlinglibs::DataRecorderModuleResourceQueueError(ERS_HERE, "Could not initialize queue", "raw_recording", "");
   }
 }
 

plugins/DataRecorderModule.hpp

@@ -12,10 +12,10 @@
 #include "appfwk/DAQModule.hpp"
 #include "utilities/WorkerThread.hpp"
 
-#include "readoutlibs/concepts/RecorderConcept.hpp"
-#include "readoutlibs/recorderconfig/Structs.hpp"
-#include "readoutlibs/utils/BufferedFileWriter.hpp"
-#include "readoutlibs/utils/ReusableThread.hpp"
+#include "datahandlinglibs/concepts/RecorderConcept.hpp"
+#include "datahandlinglibs/recorderconfig/Structs.hpp"
+#include "datahandlinglibs/utils/BufferedFileWriter.hpp"
+#include "datahandlinglibs/utils/ReusableThread.hpp"
 
 #include <atomic>
 #include <fstream>
@@ -46,9 +46,9 @@ class DataRecorderModule : public dunedaq::appfwk::DAQModule
   void do_start(const nlohmann::json& obj);
   void do_stop(const nlohmann::json& obj);
 
-  std::unique_ptr<readoutlibs::RecorderConcept> recorder;
+  std::unique_ptr<datahandlinglibs::RecorderConcept> recorder;
 };
-} // namespace readoutmodules
+} // namespace datahandlinglibs
 } // namespace dunedaq
 
 #endif // FDREADOUTMODULES_PLUGINS_DATARECORDER_HPP_

plugins/DummyConsumer.cpp

@@ -11,8 +11,8 @@
 #include "appfwk/cmd/Nljs.hpp"
 #include "logging/Logging.hpp"
 
-#include "readoutlibs/ReadoutIssues.hpp"
-#include "readoutlibs/ReadoutLogging.hpp"
+#include "datahandlinglibs/DataHandlingIssues.hpp"
+#include "datahandlinglibs/ReadoutLogging.hpp"
 
 #include "fdreadoutmodules/dummyconsumerinfo/InfoNljs.hpp"
 
@@ -40,7 +40,7 @@ DummyConsumer<T>::init(const data_t& args)
     auto qi = appfwk::connection_index(args, { "input_queue" });
     m_data_receiver = get_iom_receiver<T>(qi["input_queue"]);
   } catch (const ers::Issue& excpt) {
-    throw readoutlibs::GenericResourceQueueError(ERS_HERE, "input_queue", get_name(), excpt);
+    throw datahandlinglibs::GenericResourceQueueError(ERS_HERE, "input_queue", get_name(), excpt);
   }
 }
 

plugins/DummyConsumer.hpp

@@ -13,7 +13,7 @@
 #include "iomanager/IOManager.hpp"
 #include "dfmessages/TimeSync.hpp"
 
-#include "readoutlibs/utils/ReusableThread.hpp"
+#include "datahandlinglibs/utils/ReusableThread.hpp"
 
 #include <atomic>
 #include <fstream>
@@ -52,7 +52,7 @@ class DummyConsumer : public dunedaq::appfwk::DAQModule
   std::shared_ptr<source_t> m_data_receiver;
 
   // Threading
-  readoutlibs::ReusableThread m_work_thread;
+  datahandlinglibs::ReusableThread m_work_thread;
   std::atomic<bool> m_run_marker;
 
   // Stats

plugins/ErroredFrameConsumer.cpp

@@ -10,7 +10,7 @@
 #include "DummyConsumer.hpp"
 #include "fddetdataformats/WIBFrame.hpp"
 #include "logging/Logging.hpp"
-#include "readoutlibs/ReadoutLogging.hpp"
+#include "datahandlinglibs/ReadoutLogging.hpp"
 
 #include <bitset>
 

plugins/FDDataHandlerModule.cpp

@@ -14,17 +14,17 @@
 #include "logging/Logging.hpp"
 #include "iomanager/IOManager.hpp"
 
-#include "readoutlibs/ReadoutIssues.hpp"
-#include "readoutlibs/ReadoutLogging.hpp"
-#include "readoutlibs/concepts/ReadoutConcept.hpp"
-#include "readoutlibs/models/BinarySearchQueueModel.hpp"
-#include "readoutlibs/models/DefaultRequestHandlerModel.hpp"
-#include "readoutlibs/models/EmptyFragmentRequestHandlerModel.hpp"
-#include "readoutlibs/models/FixedRateQueueModel.hpp"
-#include "readoutlibs/models/ReadoutModel.hpp"
-#include "readoutlibs/models/ZeroCopyRecordingRequestHandlerModel.hpp"
-#include "readoutlibs/models/DefaultSkipListRequestHandler.hpp"
-#include "readoutlibs/models/SkipListLatencyBufferModel.hpp"
+#include "datahandlinglibs/DataHandlingIssues.hpp"
+#include "datahandlinglibs/ReadoutLogging.hpp"
+#include "datahandlinglibs/concepts/DataHandlingConcept.hpp"
+#include "datahandlinglibs/models/BinarySearchQueueModel.hpp"
+#include "datahandlinglibs/models/DefaultRequestHandlerModel.hpp"
+#include "datahandlinglibs/models/EmptyFragmentRequestHandlerModel.hpp"
+#include "datahandlinglibs/models/FixedRateQueueModel.hpp"
+#include "datahandlinglibs/models/DataHandlingModel.hpp"
+#include "datahandlinglibs/models/ZeroCopyRecordingRequestHandlerModel.hpp"
+#include "datahandlinglibs/models/DefaultSkipListRequestHandler.hpp"
+#include "datahandlinglibs/models/SkipListLatencyBufferModel.hpp"
 
 //#include "fdreadoutlibs/ProtoWIBSuperChunkTypeAdapter.hpp"
 //#include "fdreadoutlibs/DUNEWIBSuperChunkTypeAdapter.hpp"
@@ -49,7 +49,7 @@
 #include <string>
 #include <vector>
 
-using namespace dunedaq::readoutlibs::logging;
+using namespace dunedaq::datahandlinglibs::logging;
 
 namespace dunedaq {
 
@@ -93,23 +93,23 @@ FDDataHandlerModule::get_info(opmonlib::InfoCollector& ci, int level)
   inherited_dlh::get_info(ci, level);
 }
 
-std::unique_ptr<readoutlibs::ReadoutConcept>
+std::unique_ptr<datahandlinglibs::DataHandlingConcept>
 FDDataHandlerModule::create_readout(const appmodel::DataHandlerModule* modconf, std::atomic<bool>& run_marker)
 {
-  namespace rol = dunedaq::readoutlibs;
+  namespace rol = dunedaq::datahandlinglibs;
   namespace fdl = dunedaq::fdreadoutlibs;
   namespace fdt = dunedaq::fdreadoutlibs::types;
 
 
   // Acquire DataType  
   std::string raw_dt = modconf->get_module_configuration()->get_input_data_type();
-  TLOG() << "Choosing specializations for ReadoutModel with data_type:" << raw_dt << ']';
+  TLOG() << "Choosing specializations for DataHandlingModel with data_type:" << raw_dt << ']';
 
   /* IF WIB2
   if (raw_dt.find("WIB2Frame") != std::string::npos) {
     TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating readout for a DUNE-WIB";
     auto readout_model = std::make_unique<
-      rol::ReadoutModel<fdt::DUNEWIBSuperChunkTypeAdapter,
+      rol::DataHandlingModel<fdt::DUNEWIBSuperChunkTypeAdapter,
                         rol::ZeroCopyRecordingRequestHandlerModel<fdt::DUNEWIBSuperChunkTypeAdapter,
                                                         rol::FixedRateQueueModel<fdt::DUNEWIBSuperChunkTypeAdapter>>,
                         rol::FixedRateQueueModel<fdt::DUNEWIBSuperChunkTypeAdapter>,
@@ -122,7 +122,7 @@ FDDataHandlerModule::create_readout(const appmodel::DataHandlerModule* modconf,
   if (raw_dt.find("WIBEthFrame") != std::string::npos) {
     TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating readout for an Ethernet DUNE-WIB";
     auto readout_model = std::make_unique<
-      rol::ReadoutModel<fdt::DUNEWIBEthTypeAdapter,
+      rol::DataHandlingModel<fdt::DUNEWIBEthTypeAdapter,
 			rol::ZeroCopyRecordingRequestHandlerModel<fdt::DUNEWIBEthTypeAdapter,
                                                         rol::FixedRateQueueModel<fdt::DUNEWIBEthTypeAdapter>>,
                         rol::FixedRateQueueModel<fdt::DUNEWIBEthTypeAdapter>,
@@ -135,7 +135,7 @@ FDDataHandlerModule::create_readout(const appmodel::DataHandlerModule* modconf,
   if (raw_dt.find("PDSFrame") != std::string::npos) {
     TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating readout for a PDS DAPHNE using SkipList LB";
     auto readout_model =
-      std::make_unique<rol::ReadoutModel<fdt::DAPHNESuperChunkTypeAdapter,
+      std::make_unique<rol::DataHandlingModel<fdt::DAPHNESuperChunkTypeAdapter,
                                          fdl::DAPHNEListRequestHandler,
                                          rol::SkipListLatencyBufferModel<fdt::DAPHNESuperChunkTypeAdapter>,
                                          fdl::DAPHNEFrameProcessor>>(run_marker);
@@ -147,7 +147,7 @@ FDDataHandlerModule::create_readout(const appmodel::DataHandlerModule* modconf,
   if (raw_dt.find("PDSStreamFrame") != std::string::npos) {
     TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating readout for a PDS DAPHNE stream mode using BinarySearchQueue LB";
     auto readout_model = std::make_unique<
-      rol::ReadoutModel<fdt::DAPHNEStreamSuperChunkTypeAdapter,
+      rol::DataHandlingModel<fdt::DAPHNEStreamSuperChunkTypeAdapter,
                         rol::DefaultRequestHandlerModel<fdt::DAPHNEStreamSuperChunkTypeAdapter,
                                                         rol::BinarySearchQueueModel<fdt::DAPHNEStreamSuperChunkTypeAdapter>>,
                         rol::BinarySearchQueueModel<fdt::DAPHNEStreamSuperChunkTypeAdapter>,
@@ -159,7 +159,7 @@ FDDataHandlerModule::create_readout(const appmodel::DataHandlerModule* modconf,
   // IF SSP
   if (raw_dt.find("SSPFrame") != std::string::npos) {
     TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating readout for a SSPs using BinarySearchQueue LB";
-    auto readout_model = std::make_unique<rol::ReadoutModel<
+    auto readout_model = std::make_unique<rol::DataHandlingModel<
       fdt::SSPFrameTypeAdapter,
       rol::DefaultRequestHandlerModel<fdt::SSPFrameTypeAdapter, rol::BinarySearchQueueModel<fdt::SSPFrameTypeAdapter>>,
       rol::BinarySearchQueueModel<fdt::SSPFrameTypeAdapter>,
@@ -172,7 +172,7 @@ FDDataHandlerModule::create_readout(const appmodel::DataHandlerModule* modconf,
   if (raw_dt.find("TDEFrame") != std::string::npos) {
     TLOG_DEBUG(TLVL_WORK_STEPS) << "Creating readout for TDE";
     auto readout_model = std::make_unique<
-      rol::ReadoutModel<fdt::TDEFrameTypeAdapter,
+      rol::DataHandlingModel<fdt::TDEFrameTypeAdapter,
                         rol::DefaultSkipListRequestHandler<fdt::TDEFrameTypeAdapter>,
                         rol::SkipListLatencyBufferModel<fdt::TDEFrameTypeAdapter>,
                         fdl::TDEFrameProcessor>>(run_marker);

plugins/FDDataHandlerModule.hpp

@@ -13,18 +13,18 @@
 //#include "appfwk/cmd/Structs.hpp"
 #include "appfwk/DAQModule.hpp"
 
-#include "readoutmodules/DataLinkHandlerBase.hpp"
+#include "datahandlinglibs/DataLinkHandlerBase.hpp"
 
 #include <string>
 
 namespace dunedaq {
 namespace fdreadoutmodules {
 
 class FDDataHandlerModule : public dunedaq::appfwk::DAQModule,
-                          public dunedaq::readoutmodules::DataLinkHandlerBase
+                          public dunedaq::datahandlinglibs::DataLinkHandlerBase
 {
 public:
-  using inherited_dlh = dunedaq::readoutmodules::DataLinkHandlerBase;
+  using inherited_dlh = dunedaq::datahandlinglibs::DataLinkHandlerBase;
   using inherited_mod = dunedaq::appfwk::DAQModule;
   /**
    * @brief FDDataHandlerModule Constructor
@@ -40,7 +40,7 @@ class FDDataHandlerModule : public dunedaq::appfwk::DAQModule,
   void init(std::shared_ptr<appfwk::ModuleConfiguration> cfg) override;
   void get_info(opmonlib::InfoCollector& ci, int level) override;
 
-  std::unique_ptr<readoutlibs::ReadoutConcept>
+  std::unique_ptr<datahandlinglibs::DataHandlingConcept>
   create_readout(const appmodel::DataHandlerModule* modconf, std::atomic<bool>& run_marker) override;
 
 };