8 #include <boost/algorithm/string.hpp>
9 #include <boost/exception/all.hpp>
10 #include <boost/filesystem.hpp>
11 #include <boost/throw_exception.hpp>
12 #include <boost/tokenizer.hpp>
14 #include "fhiclcpp/ParameterSet.h"
16 #include "artdaq/DAQdata/Globals.hh"
17 #define TRACE_NAME (app_name + "_DispatcherCore").c_str()
19 #include "artdaq-core/Core/SimpleMemoryReader.hh"
20 #include "artdaq-core/Data/RawEvent.hh"
22 #include "artdaq/Application/DispatcherCore.hh"
23 #include "artdaq/TransferPlugins/MakeTransferPlugin.hh"
31 TLOG(TLVL_DEBUG) <<
"Destructor";
36 TLOG(TLVL_DEBUG) <<
"initialize method called with DAQ "
37 <<
"ParameterSet = \"" << pset.to_string() <<
"\".";
41 if (pset_.has_key(
"art"))
43 pset_ = pset_.get<fhicl::ParameterSet>(
"art");
45 pset_.erase(
"outputs");
46 pset_.erase(
"physics");
49 TLOG(TLVL_DEBUG) <<
"Pieces of the input pset that are saved for later: \"" << pset_.to_string() <<
"\".";
52 fhicl::ParameterSet daq_pset;
55 daq_pset = pset.get<fhicl::ParameterSet>(
"daq");
60 <<
"Unable to find the DAQ parameters in the initialization "
61 <<
"ParameterSet: \"" + pset.to_string() +
"\".";
64 fhicl::ParameterSet agg_pset;
67 agg_pset = daq_pset.get<fhicl::ParameterSet>(
"dispatcher", daq_pset.get<fhicl::ParameterSet>(
"aggregator"));
72 <<
"Unable to find the Dispatcher parameters in the DAQ "
73 <<
"initialization ParameterSet: \"" + daq_pset.to_string() +
"\".";
77 broadcast_mode_ = agg_pset.get<
bool>(
"broadcast_mode",
true);
78 if (broadcast_mode_ && !agg_pset.has_key(
"broadcast_mode"))
80 agg_pset.put<
bool>(
"broadcast_mode",
true);
83 agg_pset.erase(
"restart_crashed_art_processes");
84 agg_pset.put<
bool>(
"restart_crashed_art_processes",
false);
86 agg_pset.erase(
"art_analyzer_count");
87 agg_pset.put<
int>(
"art_analyzer_count", 0);
90 fhicl::ParameterSet metric_pset;
94 metric_pset = daq_pset.get<fhicl::ParameterSet>(
"metrics");
99 return initializeDataReceiver(pset, agg_pset, metric_pset);
104 TLOG(TLVL_DEBUG) <<
"DispatcherCore::register_monitor called with argument \"" << pset.to_string() <<
"\"";
105 std::lock_guard<std::mutex> lock(dispatcher_transfers_mutex_);
110 TLOG(TLVL_DEBUG) <<
"Getting unique_label from input ParameterSet";
111 auto label = pset.get<std::string>(
"unique_label");
112 TLOG(TLVL_DEBUG) <<
"Unique label is " << label;
113 if (registered_monitors_.count(label))
115 throw cet::exception(
"DispatcherCore") <<
"Unique label already exists!";
118 registered_monitors_[label] = pset;
119 if (event_store_ptr_ !=
nullptr)
123 fhicl::ParameterSet ps = merge_parameter_sets_(pset_, label, pset);
124 TLOG(TLVL_DEBUG) <<
"Starting art process with received fhicl";
125 registered_monitor_pids_[label] = event_store_ptr_->StartArtProcess(ps);
129 TLOG(TLVL_DEBUG) <<
"Generating new fhicl and reconfiguring art";
130 event_store_ptr_->ReconfigureArt(generate_filter_fhicl_());
135 TLOG(TLVL_ERROR) <<
"Unable to add monitor as there is no SharedMemoryEventManager instance!";
138 catch (
const cet::exception& e)
140 std::stringstream errmsg;
141 errmsg <<
"Unable to create a Transfer plugin with the FHiCL code \"" << pset.to_string() <<
"\", a new monitor has not been registered" << std::endl;
142 errmsg <<
"Exception: " << e.what();
143 TLOG(TLVL_ERROR) << errmsg.str();
146 catch (
const boost::exception& e)
148 std::stringstream errmsg;
149 errmsg <<
"Unable to create a Transfer plugin with the FHiCL code \"" << pset.to_string() <<
"\", a new monitor has not been registered" << std::endl;
150 errmsg <<
"Exception: " << boost::diagnostic_information(e);
151 TLOG(TLVL_ERROR) << errmsg.str();
154 catch (
const std::exception& e)
156 std::stringstream errmsg;
157 errmsg <<
"Unable to create a Transfer plugin with the FHiCL code \"" << pset.to_string() <<
"\", a new monitor has not been registered" << std::endl;
158 errmsg <<
"Exception: " << e.what();
159 TLOG(TLVL_ERROR) << errmsg.str();
164 std::stringstream errmsg;
165 errmsg <<
"Unable to create a Transfer plugin with the FHiCL code \"" << pset.to_string() <<
"\", a new monitor has not been registered";
166 TLOG(TLVL_ERROR) << errmsg.str();
175 TLOG(TLVL_DEBUG) <<
"DispatcherCore::unregister_monitor called with argument \"" << label <<
"\"";
176 std::lock_guard<std::mutex> lock(dispatcher_transfers_mutex_);
181 if (registered_monitors_.count(label) == 0)
183 std::stringstream errmsg;
184 errmsg <<
"Warning in DispatcherCore::unregister_monitor: unable to find requested transfer plugin with "
185 <<
"label \"" << label <<
"\"";
186 TLOG(TLVL_WARNING) << errmsg.str();
190 registered_monitors_.erase(label);
191 if (event_store_ptr_ !=
nullptr)
195 std::set<pid_t> pids;
196 pids.insert(registered_monitor_pids_[label]);
197 event_store_ptr_->ShutdownArtProcesses(pids);
198 registered_monitor_pids_.erase(label);
202 event_store_ptr_->ReconfigureArt(generate_filter_fhicl_());
208 std::stringstream errmsg;
209 errmsg <<
"Unable to unregister transfer plugin with label \"" << label <<
"\"";
216 fhicl::ParameterSet artdaq::DispatcherCore::merge_parameter_sets_(fhicl::ParameterSet skel, std::string label, fhicl::ParameterSet pset)
218 fhicl::ParameterSet generated_pset = skel;
219 fhicl::ParameterSet generated_outputs;
220 fhicl::ParameterSet generated_physics;
221 fhicl::ParameterSet generated_physics_analyzers;
222 fhicl::ParameterSet generated_physics_producers;
223 fhicl::ParameterSet generated_physics_filters;
224 std::unordered_map<std::string, std::vector<std::string>> generated_physics_filter_paths;
226 TLOG(TLVL_DEBUG) <<
"merge_parameter_sets_: Generating fhicl for monitor " << label;
230 auto path = pset.get<std::vector<std::string>>(
"path");
232 auto filters = pset.get<std::vector<fhicl::ParameterSet>>(
"filter_paths", std::vector<fhicl::ParameterSet>());
233 for (
auto& filter : filters)
237 auto name = filter.get<std::string>(
"name");
238 auto path = filter.get<std::vector<std::string>>(
"path");
239 if (generated_physics_filter_paths.count(name))
241 bool matched = generated_physics_filter_paths[name].size() == path.size();
242 for (
size_t ii = 0; matched && ii < generated_physics_filter_paths[name].size(); ++ii)
244 matched = matched && path[ii] == generated_physics_filter_paths[name][ii];
254 auto newname = label + name;
255 generated_physics_filter_paths[newname] = path;
260 generated_physics_filter_paths[name] = path;
269 auto outputs = pset.get<fhicl::ParameterSet>(
"outputs");
270 if (outputs.get_pset_names().size() > 1 || outputs.get_pset_names().size() == 0)
274 auto output_name = outputs.get_pset_names()[0];
275 auto output_pset = outputs.get<fhicl::ParameterSet>(output_name);
276 generated_outputs.put(label + output_name, output_pset);
277 bool outputInPath =
false;
278 for (
size_t ii = 0; ii < path.size(); ++ii)
280 if (path[ii] == output_name)
282 path[ii] = label + output_name;
288 path.push_back(label + output_name);
292 auto physics_pset = pset.get<fhicl::ParameterSet>(
"physics");
294 if (physics_pset.has_key(
"analyzers"))
296 auto analyzers = physics_pset.get<fhicl::ParameterSet>(
"analyzers");
297 for (
auto key : analyzers.get_pset_names())
299 if (generated_physics_analyzers.has_key(key) && analyzers.get<fhicl::ParameterSet>(key) == generated_physics_analyzers.get<fhicl::ParameterSet>(key))
304 else if (generated_physics_analyzers.has_key(key))
307 auto newkey = label + key;
308 generated_physics_analyzers.put<fhicl::ParameterSet>(newkey, analyzers.get<fhicl::ParameterSet>(key));
309 for (
size_t ii = 0; ii < path.size(); ++ii)
319 generated_physics_analyzers.put<fhicl::ParameterSet>(key, analyzers.get<fhicl::ParameterSet>(key));
323 if (physics_pset.has_key(
"producers"))
325 auto producers = physics_pset.get<fhicl::ParameterSet>(
"producers");
326 for (
auto key : producers.get_pset_names())
328 if (generated_physics_producers.has_key(key) && producers.get<fhicl::ParameterSet>(key) == generated_physics_producers.get<fhicl::ParameterSet>(key))
333 else if (generated_physics_producers.has_key(key))
336 auto newkey = label + key;
337 generated_physics_producers.put<fhicl::ParameterSet>(newkey, producers.get<fhicl::ParameterSet>(key));
338 for (
size_t ii = 0; ii < path.size(); ++ii)
348 generated_physics_producers.put<fhicl::ParameterSet>(key, producers.get<fhicl::ParameterSet>(key));
352 if (physics_pset.has_key(
"filters"))
354 auto filters = physics_pset.get<fhicl::ParameterSet>(
"filters");
355 for (
auto key : filters.get_pset_names())
357 if (generated_physics_filters.has_key(key) && filters.get<fhicl::ParameterSet>(key) == generated_physics_filters.get<fhicl::ParameterSet>(key))
362 else if (generated_physics_filters.has_key(key))
365 auto newkey = label + key;
366 generated_physics_filters.put<fhicl::ParameterSet>(newkey, filters.get<fhicl::ParameterSet>(key));
367 for (
size_t ii = 0; ii < path.size(); ++ii)
377 generated_physics_filters.put<fhicl::ParameterSet>(key, filters.get<fhicl::ParameterSet>(key));
381 generated_physics.put<std::vector<std::string>>(label, path);
383 catch (cet::exception& e)
386 TLOG(TLVL_ERROR) <<
"merge_parameter_sets_: Error processing input fhicl: " << e.what();
389 TLOG(TLVL_DEBUG) <<
"merge_parameter_sets_: Building final ParameterSet";
390 generated_pset.put(
"outputs", generated_outputs);
392 generated_physics.put(
"analyzers", generated_physics_analyzers);
393 generated_physics.put(
"producers", generated_physics_producers);
394 generated_physics.put(
"filters", generated_physics_filters);
396 for (
auto& path : generated_physics_filter_paths)
398 generated_physics.put(path.first, path.second);
401 generated_pset.put(
"physics", generated_physics);
403 return generated_pset;
406 fhicl::ParameterSet artdaq::DispatcherCore::generate_filter_fhicl_()
408 TLOG(TLVL_DEBUG) <<
"generate_filter_fhicl_ BEGIN";
409 fhicl::ParameterSet generated_pset = pset_;
411 for (
auto& monitor : registered_monitors_)
413 auto label = monitor.first;
414 auto pset = monitor.second;
415 generated_pset = merge_parameter_sets_(generated_pset, label, pset);
418 TLOG(TLVL_DEBUG) <<
"generate_filter_fhicl_ returning ParameterSet: " << generated_pset.to_string();
419 return generated_pset;
422 void artdaq::DispatcherCore::check_filters_()
424 auto it = registered_monitors_.begin();
425 while (it != registered_monitors_.end())
427 if (!event_store_ptr_)
429 registered_monitor_pids_.erase(it->first);
430 it = registered_monitors_.erase(it);
434 auto pid = registered_monitor_pids_[it->first];
435 auto sts = kill(pid, 0);
438 registered_monitor_pids_.erase(it->first);
439 it = registered_monitors_.erase(it);
DataReceiverCore implements the state machine for the DataReceiver artdaq application. DataReceiverCore receives Fragment objects from the DataReceiverManager, and sends them to the EventStore.
std::string unregister_monitor(std::string const &label)
Delete the TransferInterface having the given unique label.
std::string register_monitor(fhicl::ParameterSet const &pset)
Create a new TransferInterface instance using the given configuration.
DispatcherCore()
DispatcherCore Constructor.
bool initialize(fhicl::ParameterSet const &pset) override
Processes the initialize request.