6 #pragma GCC diagnostic push
7 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
8 #define _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES 1
9 #include <xmlrpc-c/base.hpp>
10 #include <xmlrpc-c/registry.hpp>
11 #include <xmlrpc-c/server_abyss.hpp>
12 #include <xmlrpc-c/girerr.hpp>
13 #include <xmlrpc-c/client_simple.hpp>
14 #undef _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
15 #pragma GCC diagnostic pop
21 #define TRACE_NAME (app_name + "_xmlrpc_commander").c_str()
22 #include "artdaq/DAQdata/Globals.hh"
25 #include "artdaq-core/Utilities/ExceptionHandler.hh"
26 #include <sys/socket.h>
27 #include <netinet/in.h>
32 #include "canvas/Persistency/Provenance/RunID.h"
33 #include "fhiclcpp/make_ParameterSet.h"
35 #include "artdaq/ExternalComms/xmlrpc_commander.hh"
44 env_wrap() { xmlrpc_env_init(&this->env_c); };
45 ~
env_wrap() { xmlrpc_env_clean(&this->env_c); };
49 static xmlrpc_c::paramList
50 pListFromXmlrpcArray(xmlrpc_value *
const arrayP)
53 XMLRPC_ASSERT_ARRAY_OK(arrayP);
54 unsigned int const arraySize = xmlrpc_array_size(&env.env_c, arrayP);
55 assert(!env.env_c.fault_occurred);
56 xmlrpc_c::paramList paramList(arraySize);
57 for (
unsigned int i = 0; i < arraySize; ++i) {
58 xmlrpc_value * arrayItemP;
59 xmlrpc_array_read_item(&env.env_c, arrayP, i, &arrayItemP);
60 assert(!env.env_c.fault_occurred);
61 paramList.add(xmlrpc_c::value(arrayItemP));
62 xmlrpc_DECREF(arrayItemP);
67 c_executeMethod(xmlrpc_env *
const envP,
68 xmlrpc_value *
const paramArrayP,
69 void *
const methodPtr,
70 void *
const callInfoPtr)
72 xmlrpc_c::method *
const methodP(static_cast<xmlrpc_c::method *>(methodPtr));
73 xmlrpc_c::paramList
const paramList(pListFromXmlrpcArray(paramArrayP));
74 xmlrpc_c::callInfo *
const callInfoP(static_cast<xmlrpc_c::callInfo *>(callInfoPtr));
75 xmlrpc_value * retval;
78 xmlrpc_c::value result;
80 xmlrpc_c::method2 *
const method2P(dynamic_cast<xmlrpc_c::method2 *>(methodP));
82 method2P->execute(paramList, callInfoP, &result);
84 methodP->execute(paramList, &result);
86 catch (xmlrpc_c::fault
const& fault) {
87 xmlrpc_env_set_fault(envP, fault.getCode(),
88 fault.getDescription().c_str());
90 if (!envP->fault_occurred) {
91 if (result.isInstantiated())
92 retval = result.cValue();
94 girerr::throwf(
"Xmlrpc-c user's xmlrpc_c::method object's "
95 "'execute method' failed to set the RPC result "
99 catch (std::exception
const& e) {
100 xmlrpc_faultf(envP,
"Unexpected error executing code for "
101 "particular method, detected by Xmlrpc-c "
102 "method registry code. Method did not "
103 "fail; rather, it did not complete at all. %s",
107 xmlrpc_env_set_fault(envP, XMLRPC_INTERNAL_ERROR,
108 "Unexpected error executing code for "
109 "particular method, detected by Xmlrpc-c "
110 "method registry code. Method did not "
111 "fail; rather, it did not complete at all.");
127 const std::string& helpText =
"execute request")
129 std::string msg(
"Exception when trying to ");
130 msg.append(helpText);
132 msg.append(er.what());
133 if (msg[msg.size() - 1] ==
'\n') msg.erase(msg.size() - 1);
144 const std::string& helpText)
146 std::string msg(
"Exception when trying to ");
147 msg.append(helpText);
149 msg.append(er.what());
150 if (msg[msg.size() - 1] ==
'\n') msg.erase(msg.size() - 1);
161 const std::string& helpText)
163 std::string msg(
"Exception when trying to ");
164 msg.append(helpText);
166 msg.append(er.what());
167 if (msg[msg.size() - 1] ==
'\n') msg.erase(msg.size() - 1);
178 const std::string& helpText)
180 std::string msg(
"Exception when trying to ");
181 msg.append(helpText);
184 if (msg[msg.size() - 1] ==
'\n') msg.erase(msg.size() - 1);
206 class cmd_ :
public xmlrpc_c::method
219 _signature = signature;
228 void execute(
const xmlrpc_c::paramList& paramList, xmlrpc_c::value*
const retvalP)
final;
239 virtual bool execute_(
const xmlrpc_c::paramList&, xmlrpc_c::value*
const retvalP) = 0;
250 template <
typename T>
251 T
getParam(
const xmlrpc_c::paramList& paramList,
int index);
276 template <
typename T>
277 T
getParam(
const xmlrpc_c::paramList& paramList,
int index, T default_value);
283 template <
typename T>
286 throw cet::exception(
"cmd_") <<
"Error in cmd_::getParam(): value type not supported" << std::endl;
298 uint64_t cmd_::getParam<uint64_t>(
const xmlrpc_c::paramList& paramList,
int index)
300 TLOG(TLVL_TRACE) <<
"Getting parameter " << index <<
" from list as uint64_t.";
301 TLOG(TLVL_TRACE) <<
"Param value: " << paramList.getString(index);
302 return boost::lexical_cast<uint64_t>(paramList.getString(index));
314 std::string cmd_::getParam<std::string>(
const xmlrpc_c::paramList& paramList,
int index)
316 TLOG(TLVL_TRACE) <<
"Getting parameter " << index <<
" from list as string.";
317 TLOG(TLVL_TRACE) <<
"Param value: " << paramList.getString(index);
318 return static_cast<std::string
>(paramList.getString(index));
330 art::RunID cmd_::getParam<art::RunID>(
const xmlrpc_c::paramList& paramList,
int index)
332 TLOG(TLVL_TRACE) <<
"Getting parameter " << index <<
" from list as Run Number.";
333 TLOG(TLVL_TRACE) <<
"Param value: " << paramList.getString(index);
334 std::string run_number_string = paramList.getString(index);
335 art::RunNumber_t run_number =
336 boost::lexical_cast<art::RunNumber_t>(run_number_string);
337 art::RunID run_id(run_number);
351 fhicl::ParameterSet cmd_::getParam<fhicl::ParameterSet>(
const xmlrpc_c::paramList& paramList,
int index)
353 TLOG(TLVL_TRACE) <<
"Getting parameter " << index <<
" from list as ParameterSet.";
354 TLOG(TLVL_TRACE) <<
"Param value: " << paramList.getString(index);
355 std::string configString = std::string(paramList.getString(index).c_str());
356 TLOG(TLVL_DEBUG) <<
"Loading Parameter Set from string: " << configString << std::endl;
357 fhicl::ParameterSet pset;
361 fhicl::make_ParameterSet(configString, pset);
363 catch (fhicl::exception e)
365 if (getenv(
"FHICL_FILE_PATH") ==
nullptr)
367 std::cerr <<
"INFO: environment variable FHICL_FILE_PATH was not set. Using \".\"\n";
368 setenv(
"FHICL_FILE_PATH",
".", 0);
370 cet::filepath_lookup_after1 lookup_policy(
"FHICL_FILE_PATH");
371 fhicl::make_ParameterSet(configString, lookup_policy, pset);
374 TLOG(TLVL_INFO) <<
"Parameter Set Loaded." << std::endl;
378 template <
typename T>
382 T val = default_value;
386 val = getParam<T>(paramList, index);
388 catch (
const cet::exception& exception)
397 void cmd_::execute(
const xmlrpc_c::paramList& paramList, xmlrpc_c::value*
const retvalP)
399 std::unique_lock<std::timed_mutex> lk(
_c.
mutex_, std::chrono::milliseconds(250));
416 if (!retvalP->isInstantiated())
418 *retvalP = xmlrpc_c::value_string(
"Success");
424 *retvalP = xmlrpc_c::value_string(problemReport);
427 catch (std::runtime_error& er)
430 *retvalP = xmlrpc_c::value_string(msg);
431 TLOG(TLVL_ERROR) << msg;
433 catch (art::Exception& er)
436 *retvalP = xmlrpc_c::value_string(msg);
437 TLOG(TLVL_ERROR) << msg;
439 catch (cet::exception& er)
442 *retvalP = xmlrpc_c::value_string(msg);
443 TLOG(TLVL_ERROR) << msg;
448 *retvalP = xmlrpc_c::value_string(msg);
449 TLOG(TLVL_ERROR) << msg;
454 *retvalP = xmlrpc_c::value_string(
"busy");
467 #define GENERATE_INIT_TRANSITION(NAME, CALL, DESCRIPTION) \
469 class NAME ## _: public cmd_ { \
475 explicit NAME ## _(xmlrpc_commander& c): \
476 cmd_(c, "s:sii", DESCRIPTION) {} \
479 static const uint64_t defaultTimeout = 45; \
481 static const uint64_t defaultTimestamp = std::numeric_limits<const uint64_t>::max(); \
484 bool execute_(const xmlrpc_c::paramList& paramList, xmlrpc_c::value* const retvalP ) { \
485 fhicl::ParameterSet ps; \
487 ps = getParam<fhicl::ParameterSet>(paramList, 0); \
489 *retvalP = xmlrpc_c::value_string ("The "#NAME" message requires a single argument that is a string containing the initialization ParameterSet"); \
493 return _c._commandable.CALL(ps, \
494 getParam<uint64_t>(paramList, 1, defaultTimeout), \
495 getParam<uint64_t>(paramList, 2, defaultTimestamp) \
500 GENERATE_INIT_TRANSITION(init, initialize,
"initialize the program")
502 GENERATE_INIT_TRANSITION(soft_init, soft_initialize, "initialize software components in the program")
504 GENERATE_INIT_TRANSITION(reinit, reinitialize, "re-initialize the program")
506 #undef GENERATE_INIT_TRANSITION
521 cmd_(c,
"s:iii",
"start the run")
531 bool execute_(xmlrpc_c::paramList
const& paramList, xmlrpc_c::value*
const retvalP)
override
535 getParam<art::RunID>(paramList, 0);
539 *retvalP = xmlrpc_c::value_string(
"The start message requires the run number as an argument.");
559 #define GENERATE_TIMEOUT_TIMESTAMP_TRANSITION(NAME, CALL, DESCRIPTION, TIMEOUT) \
561 class NAME ## _: public cmd_ { \
566 NAME ## _(xmlrpc_commander& c): \
567 cmd_(c, "s:ii", DESCRIPTION) {} \
570 static const uint64_t defaultTimeout = TIMEOUT ; \
572 static const uint64_t defaultTimestamp = std::numeric_limits<const uint64_t>::max(); \
576 bool execute_ (const xmlrpc_c::paramList& paramList , xmlrpc_c::value* const ) { \
578 return _c._commandable.CALL( getParam<uint64_t>(paramList, 0, defaultTimeout), \
579 getParam<uint64_t>(paramList, 1, defaultTimestamp) \
584 GENERATE_TIMEOUT_TIMESTAMP_TRANSITION(pause, pause,
"pause the program", 45)
586 GENERATE_TIMEOUT_TIMESTAMP_TRANSITION(resume, resume, "resume the program", 45)
588 GENERATE_TIMEOUT_TIMESTAMP_TRANSITION(stop, stop, "stop the program", 45)
590 #undef GENERATE_TIMEOUT_TIMESTAMP_TRANSITION
604 cmd_(c,
"s:i",
"shutdown the program")
612 bool execute_(
const xmlrpc_c::paramList& paramList, xmlrpc_c::value*
const)
636 cmd_(c,
"s:n",
"report the current state")
641 bool execute_(xmlrpc_c::paramList
const&, xmlrpc_c::value*
const retvalP)
660 cmd_(c,
"s:s",
"report statistics")
664 bool execute_(xmlrpc_c::paramList
const& paramList, xmlrpc_c::value*
const retvalP)
668 getParam<std::string>(paramList, 0);
672 *retvalP = xmlrpc_c::value_string(
"The report message requires a single argument that selects the type of statistics to be reported.");
692 cmd_(c,
"s:n",
"return the currently legal commands")
696 bool execute_(xmlrpc_c::paramList
const&, xmlrpc_c::value*
const retvalP)
699 std::string resultString;
701 for (
auto& cmd : cmdList)
703 resultString.append(cmd +
" ");
704 if (cmd ==
"shutdown")
706 resultString.append(
" reset");
709 *retvalP = xmlrpc_c::value_string(resultString);
726 cmd_(c,
"s:s",
"Get notified of a new monitor")
730 bool execute_(xmlrpc_c::paramList
const& paramList, xmlrpc_c::value*
const retvalP)
734 getParam<fhicl::ParameterSet>(paramList, 0);
738 *retvalP = xmlrpc_c::value_string(
"The register_monitor command expects a string representing the FHiCL definition of a Transfer plugin");
758 cmd_(c,
"s:s",
"Remove a monitor")
762 bool execute_(xmlrpc_c::paramList
const& paramList, xmlrpc_c::value*
const retvalP)
766 getParam<std::string>(paramList, 0);
770 *retvalP = xmlrpc_c::value_string(
"The unregister_monitor command expects a string representing the label of the monitor to be removed");
791 cmd_(c,
"s:ssi",
"Set TRACE mask")
795 bool execute_(xmlrpc_c::paramList
const& paramList, xmlrpc_c::value*
const retvalP)
799 getParam<std::string>(paramList, 0);
800 getParam<std::string>(paramList, 1);
801 getParam<uint64_t>(paramList, 2);
805 *retvalP = xmlrpc_c::value_string(
"The trace_set command expects a mask type (M, S , or T), a name (ALL for all) and a mask");
809 return _c.
_commandable.
do_trace_set(getParam<std::string>(paramList, 0), getParam<std::string>(paramList, 1), getParam<uint64_t>(paramList, 2));
824 cmd_(c,
"s:s",
"Get TRACE mask")
828 bool execute_(xmlrpc_c::paramList
const& paramList, xmlrpc_c::value*
const retvalP)
832 getParam<std::string>(paramList, 0);
836 *retvalP = xmlrpc_c::value_string(
"The trace_msgfacility_set command expects a name (ALL for all)");
856 cmd_(c,
"s:ss",
"Run custom command")
860 bool execute_(xmlrpc_c::paramList
const& paramList, xmlrpc_c::value*
const retvalP)
864 getParam<std::string>(paramList, 0);
865 getParam<std::string>(paramList, 1);
869 *retvalP = xmlrpc_c::value_string(
"The meta_command command expects a string command and a string argument");
888 cmd_(c,
"s:ii",
"create a new subrun")
896 bool execute_(
const xmlrpc_c::paramList& paramList, xmlrpc_c::value*
const)
914 cmd_(c,
"s:ss",
"Add an entry to the configuration archive list")
918 bool execute_(xmlrpc_c::paramList
const& paramList, xmlrpc_c::value*
const retvalP)
922 getParam<std::string>(paramList, 0);
923 getParam<std::string>(paramList, 1);
927 *retvalP = xmlrpc_c::value_string(
"The add_config_archive_entry command expects a string key and a string value");
946 cmd_(c,
"s:n",
"Clear the configuration archive list")
950 bool execute_(xmlrpc_c::paramList
const&, xmlrpc_c::value*
const)
962 class shutdown_ :
public xmlrpc_c::registry::shutdown
965 shutdown_(xmlrpc_c::serverAbyss *server) : _server(server) {}
967 virtual void doit(
const std::string& paramString,
void*)
const
969 TLOG(TLVL_INFO) <<
"A shutdown command was sent "
971 << paramString <<
"\"";
972 _server->terminate();
975 xmlrpc_c::serverAbyss *_server;
983 , port_(ps.get<int>(
"id", 0))
984 , serverUrl_(ps.get<std::string>(
"server_url",
""))
987 TLOG(TLVL_INFO) <<
"XMLRPC COMMANDER CONSTRUCTOR: Port: " << port_ <<
", Server Url: " << serverUrl_;
988 if (serverUrl_.find(
"http") == std::string::npos)
990 serverUrl_ =
"http://" + serverUrl_;
992 if (serverUrl_.find(std::to_string(port_)) == std::string::npos && serverUrl_.find(
':', 7) == std::string::npos)
994 serverUrl_ = serverUrl_ +
":" + std::to_string(port_);
996 if (serverUrl_.find(
"RPC2") == std::string::npos)
998 serverUrl_ = serverUrl_ +
"/RPC2";
1000 TLOG(TLVL_INFO) <<
"XMLRPC COMMANDER CONSTRUCTOR: Port: " << port_ <<
", Server Url: " << serverUrl_;
1007 xmlrpc_c::registry registry;
1008 struct xmlrpc_method_info3 methodInfo;
1009 memset(&methodInfo, 0,
sizeof(methodInfo));
1014 #define register_method(m) register_method2(m,0x400000)
1017 xmlrpc_registry ***c_registryPPP;
1018 c_registryPPP = (xmlrpc_registry ***)(((
char*)®istry) +
sizeof(girmem::autoObject));
1020 #define register_method2(m,ss) \
1021 xmlrpc_c::method* ptr_ ## m(dynamic_cast<xmlrpc_c::method*>(new m ## _(*this))); \
1022 std::string m##signature = ptr_ ## m->signature(), m##help = ptr_ ## m->help(); \
1023 methodInfo.methodName = "daq." #m; \
1024 methodInfo.methodFunction = &c_executeMethod; \
1025 methodInfo.serverInfo = ptr_ ## m; \
1026 methodInfo.stackSize = ss; \
1027 methodInfo.signatureString = &m##signature[0]; \
1028 methodInfo.help = &m##help[0]; \
1029 xmlrpc_env_init(&env); \
1030 xmlrpc_registry_add_method3(&env,**c_registryPPP,&methodInfo); \
1031 if(env.fault_occurred)throw(girerr::error(env.fault_string)); \
1032 xmlrpc_env_clean(&env)
1034 register_method2(init, 0x200000);
1035 register_method(soft_init);
1036 register_method(reinit);
1037 register_method(start);
1038 register_method(status);
1039 register_method(report);
1040 register_method(stop);
1041 register_method(pause);
1042 register_method(resume);
1043 register_method(register_monitor);
1044 register_method(unregister_monitor);
1045 register_method(legal_commands);
1046 register_method(trace_set);
1047 register_method(trace_get);
1048 register_method(meta_command);
1049 register_method(rollover_subrun);
1053 register_method(shutdown);
1056 xmlrpc_c::methodPtr
const ptr_reset(
new shutdown_(*
this));
1057 registry.addMethod(
"daq.reset", ptr_reset);
1059 #undef register_method
1076 XMLRPC_SOCKET socket_file_descriptor = socket(PF_INET, SOCK_STREAM, 0);
1078 if (socket_file_descriptor < 0)
1080 throw cet::exception(
"xmlrpc_commander::run") <<
1081 "Problem with the socket() call; C-style errno == " <<
1082 errno <<
" (" << strerror(errno) <<
")";
1086 int retval = setsockopt(socket_file_descriptor,
1087 SOL_SOCKET, SO_REUSEADDR,
1088 &enable,
sizeof(
int));
1092 throw cet::exception(
"xmlrpc_commander::run") <<
1093 "Problem with the call to setsockopt(); C-style errno == " <<
1094 errno <<
" (" << strerror(errno) <<
")";
1097 struct sockaddr_in sockAddr;
1099 sockAddr.sin_family = AF_INET;
1100 sockAddr.sin_port = htons(port_);
1101 sockAddr.sin_addr.s_addr = 0;
1103 retval = bind(socket_file_descriptor,
1104 reinterpret_cast<struct sockaddr*>(&sockAddr),
1109 close(socket_file_descriptor);
1110 throw cet::exception(
"xmlrpc_commander::run") <<
1111 "Problem with the bind() call; C-style errno == " <<
1112 errno <<
" (" << strerror(errno) <<
")";
1115 server.reset(
new xmlrpc_c::serverAbyss(xmlrpc_c::serverAbyss::constrOpt().registryP(®istry).socketFd(socket_file_descriptor)));
1118 xmlrpc_c::serverAbyss::shutdown shutdown_obj(&
server);
1119 registry.setShutdown(&shutdown_obj);
1122 TLOG(TLVL_DEBUG) <<
"running server";
1138 TLOG(TLVL_WARNING) <<
"server threw an exception; closing the socket and rethrowing";
1140 close(socket_file_descriptor);
1144 close(socket_file_descriptor);
1145 TLOG(TLVL_DEBUG) <<
"server terminated";
1152 std::string xmlrpc_commander::send_command_(std::string command)
1154 if (serverUrl_ ==
"")
1156 std::stringstream errmsg;
1157 errmsg <<
"Problem attempting " << command <<
" XML-RPC call: No server URL set!";
1158 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1161 xmlrpc_c::clientSimple myClient;
1162 xmlrpc_c::value result;
1166 myClient.call(serverUrl_,
"daq." + command,
"", &result);
1170 std::stringstream errmsg;
1171 errmsg <<
"Problem attempting " << command <<
" XML-RPC call on host " << serverUrl_
1172 <<
"; possible causes are malformed FHiCL or nonexistent process at requested port";
1173 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1176 return xmlrpc_c::value_string(result);
1179 std::string xmlrpc_commander::send_command_(std::string command, std::string arg)
1181 if (serverUrl_ ==
"")
1183 std::stringstream errmsg;
1184 errmsg <<
"Problem attempting " << command <<
" XML-RPC call: No server URL set!";
1185 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1188 xmlrpc_c::clientSimple myClient;
1189 xmlrpc_c::value result;
1193 myClient.call(serverUrl_,
"daq." + command,
"s", &result, arg.c_str());
1197 std::stringstream errmsg;
1198 errmsg <<
"Problem attempting " << command <<
" XML-RPC call on host " << serverUrl_
1199 <<
"; possible causes are malformed FHiCL or nonexistent process at requested port";
1200 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1203 return xmlrpc_c::value_string(result);
1206 std::string xmlrpc_commander::send_command_(std::string command, fhicl::ParameterSet pset, uint64_t timestamp, uint64_t timeout)
1208 if (serverUrl_ ==
"")
1210 std::stringstream errmsg;
1211 errmsg <<
"Problem attempting " << command <<
" XML-RPC call: No server URL set!";
1212 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1215 xmlrpc_c::clientSimple myClient;
1216 xmlrpc_c::value result;
1220 myClient.call(serverUrl_,
"daq." + command,
"sii", &result, pset.to_string().c_str(), timestamp, timeout);
1224 std::stringstream errmsg;
1225 errmsg <<
"Problem attempting " << command <<
" XML-RPC call on host " << serverUrl_
1226 <<
"; possible causes are malformed FHiCL or nonexistent process at requested port";
1227 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1230 return xmlrpc_c::value_string(result);
1233 std::string artdaq::xmlrpc_commander::send_command_(std::string command, uint64_t a, uint64_t b)
1235 if (serverUrl_ ==
"")
1237 std::stringstream errmsg;
1238 errmsg <<
"Problem attempting " << command <<
" XML-RPC call: No server URL set!";
1239 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1242 xmlrpc_c::clientSimple myClient;
1243 xmlrpc_c::value result;
1247 myClient.call(serverUrl_,
"daq." + command,
"ii", &result, a,b);
1251 std::stringstream errmsg;
1252 errmsg <<
"Problem attempting " << command <<
" XML-RPC call on host " << serverUrl_
1253 <<
"; possible causes are malformed FHiCL or nonexistent process at requested port";
1254 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1257 return xmlrpc_c::value_string(result);
1260 std::string artdaq::xmlrpc_commander::send_command_(std::string command, art::RunID r, uint64_t a, uint64_t b)
1262 if (serverUrl_ ==
"")
1264 std::stringstream errmsg;
1265 errmsg <<
"Problem attempting " << command <<
" XML-RPC call: No server URL set!";
1266 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1269 xmlrpc_c::clientSimple myClient;
1270 xmlrpc_c::value result;
1274 myClient.call(serverUrl_,
"daq." + command,
"iii", &result, r, a, b);
1278 std::stringstream errmsg;
1279 errmsg <<
"Problem attempting " << command <<
" XML-RPC call on host " << serverUrl_
1280 <<
"; possible causes are malformed FHiCL or nonexistent process at requested port";
1281 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1284 return xmlrpc_c::value_string(result);
1287 std::string artdaq::xmlrpc_commander::send_command_(std::string command, uint64_t arg1)
1289 if (serverUrl_ ==
"")
1291 std::stringstream errmsg;
1292 errmsg <<
"Problem attempting " << command <<
" XML-RPC call: No server URL set!";
1293 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1296 xmlrpc_c::clientSimple myClient;
1297 xmlrpc_c::value result;
1301 myClient.call(serverUrl_,
"daq." + command,
"i", &result, arg1);
1305 std::stringstream errmsg;
1306 errmsg <<
"Problem attempting " << command <<
" XML-RPC call on host " << serverUrl_
1307 <<
"; possible causes are malformed FHiCL or nonexistent process at requested port";
1308 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1311 return xmlrpc_c::value_string(result);
1314 std::string artdaq::xmlrpc_commander::send_command_(std::string command, std::string arg1, std::string arg2)
1316 if (serverUrl_ ==
"")
1318 std::stringstream errmsg;
1319 errmsg <<
"Problem attempting " << command <<
" XML-RPC call: No server URL set!";
1320 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1323 xmlrpc_c::clientSimple myClient;
1324 xmlrpc_c::value result;
1328 myClient.call(serverUrl_,
"daq." + command,
"ss", &result, arg1.c_str(), arg2.c_str());
1332 std::stringstream errmsg;
1333 errmsg <<
"Problem attempting " << command <<
" XML-RPC call on host " << serverUrl_
1334 <<
"; possible causes are malformed FHiCL or nonexistent process at requested port";
1335 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1338 return xmlrpc_c::value_string(result);
1341 std::string artdaq::xmlrpc_commander::send_command_(std::string command, std::string arg1, std::string arg2, uint64_t arg3)
1343 if (serverUrl_ ==
"")
1345 std::stringstream errmsg;
1346 errmsg <<
"Problem attempting " << command <<
" XML-RPC call: No server URL set!";
1347 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1350 xmlrpc_c::clientSimple myClient;
1351 xmlrpc_c::value result;
1355 myClient.call(serverUrl_,
"daq." + command,
"ssi", &result, arg1.c_str(), arg2.c_str(), arg3);
1359 std::stringstream errmsg;
1360 errmsg <<
"Problem attempting " << command <<
" XML-RPC call on host " << serverUrl_
1361 <<
"; possible causes are malformed FHiCL or nonexistent process at requested port";
1362 ExceptionHandler(ExceptionHandlerRethrow::yes, errmsg.str());
1365 return xmlrpc_c::value_string(result);
1370 return send_command_(
"register_monitor", monitor_fhicl);
1374 return send_command_(
"unregister_monitor", monitor_label);
1378 return send_command_(
"init", ps, a, b);
1382 return send_command_(
"soft_init", ps, a, b);
1386 return send_command_(
"reinit", ps, a, b);
1390 return send_command_(
"start", r, a, b);
1394 return send_command_(
"pause", a, b);
1398 return send_command_(
"resume", a, b);
1402 return send_command_(
"stop", a, b);
1406 return send_command_(
"shutdown", a);
1410 return send_command_(
"status");
1414 return send_command_(
"report", what);
1418 return send_command_(
"legal_commands");
1422 return send_command_(
"trace_get", name);
1426 return send_command_(
"trace_set", name, which, mask);
1430 return send_command_(
"meta_command", command, arg);
1434 return send_command_(
"rollover_subrun", when, sr);
virtual bool do_add_config_archive_entry(std::string const &, std::string const &)
Add the specified key-value pair to the configuration archive list.
std::string send_stop(uint64_t, uint64_t) override
Send a stop command over XMLRPC
std::string send_shutdown(uint64_t) override
Send a shutdown command over XMLRPC
This interface defines the functions used to transfer data between artdaq applications.
cmd_(xmlrpc_commander &c, const std::string &signature, const std::string &description)
cmd_ Constructor
static const uint64_t defaultTimeout
std::string send_unregister_monitor(std::string monitor_label) override
Send an unregister_monitor command over XMLRPC
std::string send_register_monitor(std::string monitor_fhicl) override
Send a register_monitor command over XMLRPC
virtual std::string report(std::string const &) const
Default report implementation returns current report_string.
Commandable is the base class for all artdaq components which implement the artdaq state machine...
legal_commands_(xmlrpc_commander &c)
legal_commands_ Constructor
virtual bool do_clear_config_archive()
Clears the configuration archive list.
xmlrpc_commander(fhicl::ParameterSet ps, artdaq::Commandable &commandable)
xmlrpc_commander Constructor
Command class representing a start transition.
rollover_subrun_(xmlrpc_commander &c)
shutdown_ Constructor
std::string send_soft_init(fhicl::ParameterSet, uint64_t, uint64_t) override
Send a soft_init command over XMLRPC
std::string send_pause(uint64_t, uint64_t) override
Send a pause command over XMLRPC
virtual std::string clear_config_archive()
Using the transport mechanism, send a clear_config_archive command
virtual std::string unregister_monitor(std::string const &)
Perform the unregister_monitor action.
std::string send_status() override
Send a status command over XMLRPC
std::string send_legal_commands() override
Send a legal_commands command over XMLRPC
The xmlrpc_commander class serves as the XMLRPC server run in each artdaq application.
static const uint64_t defaultTimestamp
static const uint32_t defaultSubrunNumber
Default subrun number for command.
The "cmd_" class serves as the base class for all artdaq's XML-RPC commands.
trace_set_(xmlrpc_commander &c)
unregister_monitor_ Constructor
std::string send_report(std::string) override
Send a report command over XMLRPC
void run_server() override
Run the XMLRPC server.
std::string send_meta_command(std::string, std::string) override
Send an send_meta_command command over XMLRPC
std::unique_ptr< xmlrpc_c::serverAbyss > server
XMLRPC server.
std::string status() const
Returns the current state of the Commandable.
std::string exception_msg(const std::runtime_error &er, const std::string &helpText="execute request")
Write an exception message.
virtual bool do_trace_set(std::string const &type, std::string const &name, uint64_t mask)
Set the given TRACE mask for the given TRACE name.
static const uint64_t defaultSequenceID
Default Sequence ID for command.
add_config_archive_entry_(xmlrpc_commander &c)
add_config_archive_entry_ Constructor
virtual std::string register_monitor(fhicl::ParameterSet const &)
Perform the register_monitor action.
virtual bool do_meta_command(std::string const &command, std::string const &args)
Run a module-defined command with the given parameter string.
register_monitor_ Command class
add_config_archive_entry_ Command class
legal_commands_ Command class
artdaq::Commandable & _commandable
Reference to the Commandable that this Commander Commands.
std::string send_trace_get(std::string) override
Send an send_trace_get command over XMLRPC
std::string send_reinit(fhicl::ParameterSet, uint64_t, uint64_t) override
Send a reinit command over XMLRPC
xmlrpc_commander & _c
The xmlrpc_commander instance that the command will be sent to.
clear_config_archive_ Command class
std::string send_resume(uint64_t, uint64_t) override
Send a resume command over XMLRPC
status_(xmlrpc_commander &c)
status_ Constructor
clear_config_archive_(xmlrpc_commander &c)
clear_config_archive_ Constructor
virtual bool execute_(const xmlrpc_c::paramList &, xmlrpc_c::value *const retvalP)=0
"execute_" is a wrapper function around the call to the commandable object's function ...
Wrapper for XMLRPC environment construction/destruction
std::timed_mutex mutex_
XMLRPC mutex.
register_monitor_(xmlrpc_commander &c)
register_monitor_ Constructor
static const uint64_t defaultTimeout
unregister_monitor_(xmlrpc_commander &c)
unregister_monitor_ Constructor
void execute(const xmlrpc_c::paramList ¶mList, xmlrpc_c::value *const retvalP) final
Execute trhe command with the given parameters.
shutdown_(xmlrpc_commander &c)
shutdown_ Constructor
std::string send_rollover_subrun(uint64_t, uint32_t) override
Send a send_rollover_subrun command over XMLRPC
std::vector< std::string > legal_commands() const
Get the legal transition commands from the current state.
std::string send_start(art::RunID, uint64_t, uint64_t) override
Send a start command over XMLRPC
rollover_subrun_ Command class
bool start(art::RunID id, uint64_t timeout, uint64_t timestamp)
Processes the start transition.
report_(xmlrpc_commander &c)
report_ Constructor
start_(xmlrpc_commander &c)
start_ Command (cmd_ derived class) Constructor
virtual std::string add_config_archive_entry(std::string, std::string)
Using the transport mechanism, send an add_config_archive_entry command
virtual std::string do_trace_get(std::string const &name)
Get the TRACE mask for the given TRACE name If name is "ALL", then all TRACE masks will be printed...
std::string send_init(fhicl::ParameterSet, uint64_t, uint64_t) override
Send an init command over XMLRPC
trace_get_(xmlrpc_commander &c)
trace_msgfacility_set_ Constructor
std::string send_trace_set(std::string, std::string, uint64_t) override
Send an send_trace_msgfacility_set command over XMLRPC
std::atomic< bool > running_
Whether the server is running and able to respond to requests.
virtual bool do_rollover_subrun(uint64_t eventNum, uint32_t subrunNum)
Perform the rollover_subrun transition.
unregister_monitor_ Command class
T getParam(const xmlrpc_c::paramList ¶mList, int index)
Get a parameter from the parameter list.
bool shutdown(uint64_t timeout)
Processes the shutdown transition.