#include <memory>
#include <stdexcept>
#include "Framework/BoostOptionsRetriever.h"
#include "Framework/BacktraceHelpers.h"
#include "Framework/CallbacksPolicy.h"
#include "Framework/ChannelConfigurationPolicy.h"
#include "Framework/ChannelMatching.h"
#include "Framework/ConfigParamsHelper.h"
#include "Framework/ConfigParamSpec.h"
#include "Framework/ConfigContext.h"
#include "Framework/ComputingQuotaEvaluator.h"
#include "CommonDriverServices.h"
#include "Framework/DataProcessingDevice.h"
#include "Framework/DataProcessingContext.h"
#include "Framework/DataProcessorSpec.h"
#include "Framework/PluginManager.h"
#include "Framework/DeviceControl.h"
#include "Framework/DeviceExecution.h"
#include "Framework/DeviceInfo.h"
#include "Framework/DeviceMetricsInfo.h"
#include "Framework/DeviceMetricsHelper.h"
#include "Framework/DeviceConfigInfo.h"
#include "Framework/DeviceSpec.h"
#include "Framework/DeviceState.h"
#include "Framework/DeviceConfig.h"
#include "DeviceStateHelpers.h"
#include "Framework/ServiceRegistryHelpers.h"
#include "Framework/DevicesManager.h"
#include "Framework/DebugGUI.h"
#include "Framework/LocalRootFileService.h"
#include "Framework/LogParsingHelpers.h"
#include "Framework/Logger.h"
#include "Framework/ParallelContext.h"
#include "Framework/RawDeviceService.h"
#include "Framework/SimpleRawDeviceService.h"
#include "Framework/Signpost.h"
#include "Framework/ControlService.h"
#include "Framework/CallbackService.h"
#include "Framework/WorkflowSpec.h"
#include "Framework/Monitoring.h"
#include "Framework/DataProcessorInfo.h"
#include "Framework/DriverInfo.h"
#include "Framework/DriverConfig.h"
#include "Framework/DriverControl.h"
#include "Framework/DataTakingContext.h"
#include "Framework/CommandInfo.h"
#include "Framework/RunningWorkflowInfo.h"
#include "Framework/TopologyPolicy.h"
#include "Framework/WorkflowSpecNode.h"
#include "Framework/GuiCallbackContext.h"
#include "Framework/DeviceContext.h"
#include "Framework/ServiceMetricsInfo.h"
#include "Framework/CommonServices.h"
#include "Framework/DefaultsHelpers.h"
#include "ProcessingPoliciesHelpers.h"
#include "DriverServerContext.h"
#include "HTTPParser.h"
#include "DPLWebSocket.h"
#include "ArrowSupport.h"
#include "Framework/ConfigParamDiscovery.h"
#include "ComputingResourceHelpers.h"
#include "DataProcessingStatus.h"
#include "DDSConfigHelpers.h"
#include "O2ControlHelpers.h"
#include "DeviceSpecHelpers.h"
#include "GraphvizHelpers.h"
#include "MermaidHelpers.h"
#include "PropertyTreeHelpers.h"
#include "SimpleResourceManager.h"
#include "WorkflowSerializationHelpers.h"
#include <Configuration/ConfigurationInterface.h>
#include <Configuration/ConfigurationFactory.h>
#include <Monitoring/MonitoringFactory.h>
#include "ResourcesMonitoringHelper.h"
#include <fairmq/Device.h>
#include <fairmq/DeviceRunner.h>
#include <fairmq/shmem/Monitor.h>
#include <fairmq/ProgOptions.h>
#include <boost/program_options.hpp>
#include <boost/program_options/options_description.hpp>
#include <boost/program_options/variables_map.hpp>
#include <boost/exception/diagnostic_information.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <uv.h>
#include <TEnv.h>
#include <TSystem.h>
#include <cinttypes>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <csignal>
#include <iostream>
#include <map>
#include <regex>
#include <set>
#include <string>
#include <type_traits>
#include <tuple>
#include <chrono>
#include <utility>
#include <numeric>
#include <functional>
#include <fcntl.h>
#include <netinet/ip.h>
#include <sys/resource.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <unistd.h>
#include <execinfo.h>
#include <cfenv>

Classes
struct	DeviceLogContext

struct	StreamConfigContext

struct	DeviceRef

struct	DeviceStdioContext

struct	WorkflowInfo

Macros
#define	BOOST_BIND_GLOBAL_PLACEHOLDERS

Typedefs
using	DataProcessorInfos = std::vector< DataProcessorInfo >

using	DeviceExecutions = std::vector< DeviceExecution >

using	DeviceSpecs = std::vector< DeviceSpec >

using	DeviceInfos = std::vector< DeviceInfo >

using	DataProcessingStatesInfos = std::vector< DataProcessingStates >

using	DeviceControls = std::vector< DeviceControl >

using	DataProcessorSpecs = std::vector< DataProcessorSpec >

Functions
bpo::options_description	gHiddenDeviceOptions ("Hidden child options")

	O2_DECLARE_DYNAMIC_LOG (driver)

	O2_DECLARE_DYNAMIC_LOG (gui)

void	doBoostException (boost::exception &e, const char *)

void	doDPLException (o2::framework::RuntimeErrorRef &ref, char const *)

void	doUnknownException (std::string const &s, char const *)

char *	getIdString (int argc, char **argv)

int	callMain (int argc, char *argv, int(mainNoCatch)(int, char **))

void	getChildData (int infd, DeviceInfo &outinfo)

bool	checkIfCanExit (std::vector< DeviceInfo > const &infos)

void	killChildren (std::vector< DeviceInfo > &infos, int sig)

bool	areAllChildrenGone (std::vector< DeviceInfo > &infos)
	Check the state of the children.

void	createPipes (int *pipes)

void	cleanupSHM (std::string const &uniqueWorkflowId)
	Helper to invoke shared memory cleanup.

void	spawnRemoteDevice (uv_loop_t *loop, std::string const &, DeviceSpec const &spec, DeviceControl &, DeviceExecution &, DeviceInfos &deviceInfos, DataProcessingStatesInfos &allStates)

void	log_callback (uv_poll_t *handle, int status, int events)

void	close_websocket (uv_handle_t *handle)

void	websocket_callback (uv_stream_t stream, ssize_t nread, const uv_buf_t buf)

void	ws_connect_callback (uv_stream_t *server, int status)
	A callback for the rest engine.

void	stream_config (uv_work_t *req)

void	handleSignals ()

void	handleChildrenStdio (DriverServerContext serverContext, std::string const &forwardedStdin, std::vector< DeviceStdioContext > &childFds, std::vector< uv_poll_t > &handles)

void	handle_crash (int sig)

void	spawnDevice (uv_loop_t *loop, DeviceRef ref, std::vector< DeviceSpec > const &specs, DriverInfo &driverInfo, std::vector< DeviceControl > &, std::vector< DeviceExecution > &executions, std::vector< DeviceInfo > &deviceInfos, std::vector< DataProcessingStates > &allStates, ServiceRegistryRef serviceRegistry, boost::program_options::variables_map &varmap, std::vector< DeviceStdioContext > &childFds, unsigned parentCPU, unsigned parentNode)

void	processChildrenOutput (uv_loop_t *loop, DriverInfo &driverInfo, DeviceInfos &infos, DeviceSpecs const &specs, DeviceControls &controls)

bool	processSigChild (DeviceInfos &infos, DeviceSpecs &specs)

AlgorithmSpec	dryRun (DeviceSpec const &spec)

void	doDefaultWorkflowTerminationHook ()

int	doChild (int argc, char *argv, ServiceRegistry &serviceRegistry, RunningWorkflowInfo const &runningWorkflow, RunningDeviceRef ref, DriverConfig const &driverConfig, ProcessingPolicies processingPolicies, std::string const &defaultDriverClient, uv_loop_t loop)

void	gui_callback (uv_timer_s *ctx)

void	single_step_callback (uv_timer_s *ctx)
	Force single stepping of the children.

void	force_exit_callback (uv_timer_s *ctx)

std::vector< std::regex >	getDumpableMetrics ()

void	dumpMetricsCallback (uv_timer_t *handle)

void	dumpRunSummary (DriverServerContext &context, DriverInfo const &driverInfo, DeviceInfos const &infos, DeviceSpecs const &specs)

int	runStateMachine (DataProcessorSpecs const &workflow, WorkflowInfo const &workflowInfo, DataProcessorInfos const &previousDataProcessorInfos, CommandInfo const &commandInfo, DriverControl &driverControl, DriverInfo &driverInfo, DriverConfig &driverConfig, std::vector< DeviceMetricsInfo > &metricsInfos, std::vector< ConfigParamSpec > const &detectedParams, boost::program_options::variables_map &varmap, std::vector< ServiceSpec > &driverServices, std::string frameworkId)

void	printHelp (bpo::variables_map const &varmap, bpo::options_description const &executorOptions, std::vector< DataProcessorSpec > const &physicalWorkflow, std::vector< ConfigParamSpec > const &currentWorkflowOptions)

bool	isOutputToPipe ()

bool	isInputConfig ()

void	overrideCloning (ConfigContext &ctx, WorkflowSpec &workflow)

void	overridePipeline (ConfigContext &ctx, WorkflowSpec &workflow)

void	overrideLabels (ConfigContext &ctx, WorkflowSpec &workflow)

void	initialiseDriverControl (bpo::variables_map const &varmap, DriverInfo &driverInfo, DriverControl &control)
	Helper function to initialise the controller from the command line options.

void	conflicting_options (const boost::program_options::variables_map &vm, const std::string &opt1, const std::string &opt2)
	Helper to to detect conflicting options.

template<typename T >
void	apply_permutation (std::vector< T > &v, std::vector< int > &indices)

void	checkNonResiliency (std::vector< DataProcessorSpec > const &specs, std::vector< std::pair< int, int > > const &edges)

std::string	debugTopoInfo (std::vector< DataProcessorSpec > const &specs, std::vector< TopoIndexInfo > const &infos, std::vector< std::pair< int, int > > const &edges)

void	enableSignposts (std::string const &signpostsToEnable)

void	overrideAll (o2::framework::ConfigContext &ctx, std::vector< o2::framework::DataProcessorSpec > &workflow)

o2::framework::ConfigContext	createConfigContext (std::unique_ptr< ConfigParamRegistry > &workflowOptionsRegistry, o2::framework::ServiceRegistry &configRegistry, std::vector< o2::framework::ConfigParamSpec > &workflowOptions, std::vector< o2::framework::ConfigParamSpec > &extraOptions, int argc, char **argv)

std::unique_ptr< o2::framework::ServiceRegistry >	createRegistry ()

int	doMain (int argc, char **argv, o2::framework::WorkflowSpec const &workflow, std::vector< ChannelConfigurationPolicy > const &channelPolicies, std::vector< CompletionPolicy > const &completionPolicies, std::vector< DispatchPolicy > const &dispatchPolicies, std::vector< ResourcePolicy > const &resourcePolicies, std::vector< CallbacksPolicy > const &callbacksPolicies, std::vector< SendingPolicy > const &sendingPolicies, std::vector< ConfigParamSpec > const &currentWorkflowOptions, std::vector< ConfigParamSpec > const &detectedParams, o2::framework::ConfigContext &configContext)

Variables
std::vector< DeviceMetricsInfo >	gDeviceMetricsInfos

volatile sig_atomic_t	graceful_exit = false

volatile sig_atomic_t	forceful_exit = false

volatile sig_atomic_t	sigchld_requested = false

volatile sig_atomic_t	double_sigint = false

auto	bindGUIPort

Macro Definition Documentation

◆ BOOST_BIND_GLOBAL_PLACEHOLDERS

#define BOOST_BIND_GLOBAL_PLACEHOLDERS

Definition at line 12 of file runDataProcessing.cxx.

Typedef Documentation

◆ DataProcessingStatesInfos

using DataProcessingStatesInfos = std::vector<DataProcessingStates>

Definition at line 167 of file runDataProcessing.cxx.

◆ DataProcessorInfos

using DataProcessorInfos = std::vector<DataProcessorInfo>

Definition at line 163 of file runDataProcessing.cxx.

◆ DataProcessorSpecs

using DataProcessorSpecs = std::vector<DataProcessorSpec>

Definition at line 169 of file runDataProcessing.cxx.

◆ DeviceControls

using DeviceControls = std::vector<DeviceControl>

Definition at line 168 of file runDataProcessing.cxx.

◆ DeviceExecutions

using DeviceExecutions = std::vector<DeviceExecution>

Definition at line 164 of file runDataProcessing.cxx.

◆ DeviceInfos

using DeviceInfos = std::vector<DeviceInfo>

Definition at line 166 of file runDataProcessing.cxx.

◆ DeviceSpecs

using DeviceSpecs = std::vector<DeviceSpec>

Definition at line 165 of file runDataProcessing.cxx.

Function Documentation

◆ apply_permutation()

template<typename T >

void apply_permutation	(	std::vector< T > &	v,
		std::vector< int > &	indices
	)

Definition at line 2686 of file runDataProcessing.cxx.

◆ areAllChildrenGone()

bool areAllChildrenGone ( std::vector< DeviceInfo > & infos )

Check the state of the children.

Definition at line 289 of file runDataProcessing.cxx.

◆ callMain()

int callMain	(	int	argc,
		char **	argv,
		int()(int, char *)	mainNoCatch
	)

Definition at line 195 of file runDataProcessing.cxx.

◆ checkIfCanExit()

bool checkIfCanExit ( std::vector< DeviceInfo > const & infos )

Return true if all the DeviceInfo in infos are ready to quit. false otherwise. FIXME: move to an helper class

Definition at line 264 of file runDataProcessing.cxx.

◆ checkNonResiliency()

void checkNonResiliency	(	std::vector< DataProcessorSpec > const &	specs,
		std::vector< std::pair< int, int > > const &	edges
	)

Definition at line 2704 of file runDataProcessing.cxx.

◆ cleanupSHM()

void cleanupSHM ( std::string const & uniqueWorkflowId )

Helper to invoke shared memory cleanup.

Definition at line 382 of file runDataProcessing.cxx.

◆ close_websocket()

void close_websocket ( uv_handle_t * handle )

Definition at line 451 of file runDataProcessing.cxx.

◆ conflicting_options()

void conflicting_options	(	const boost::program_options::variables_map &	vm,
		const std::string &	opt1,
		const std::string &	opt2
	)

Helper to to detect conflicting options.

Definition at line 2675 of file runDataProcessing.cxx.

◆ createConfigContext()

o2::framework::ConfigContext createConfigContext	(	std::unique_ptr< ConfigParamRegistry > &	workflowOptionsRegistry,
		o2::framework::ServiceRegistry &	configRegistry,
		std::vector< o2::framework::ConfigParamSpec > &	workflowOptions,
		std::vector< o2::framework::ConfigParamSpec > &	extraOptions,
		int	argc,
		char **	argv
	)

Definition at line 2809 of file runDataProcessing.cxx.

◆ createPipes()

void createPipes ( int * pipes )

Definition at line 333 of file runDataProcessing.cxx.

◆ createRegistry()

std::unique_ptr< o2::framework::ServiceRegistry > createRegistry ( )

Definition at line 2829 of file runDataProcessing.cxx.

◆ debugTopoInfo()

std::string debugTopoInfo	(	std::vector< DataProcessorSpec > const &	specs,
		std::vector< TopoIndexInfo > const &	infos,
		std::vector< std::pair< int, int > > const &	edges
	)

Definition at line 2727 of file runDataProcessing.cxx.

◆ doBoostException()

void doBoostException	(	boost::exception &	e,
		const char *	processName
	)

Definition at line 3264 of file runDataProcessing.cxx.

◆ doChild()

int doChild	(	int	argc,
		char **	argv,
		ServiceRegistry &	serviceRegistry,
		RunningWorkflowInfo const &	runningWorkflow,
		RunningDeviceRef	ref,
		DriverConfig const &	driverConfig,
		ProcessingPolicies	processingPolicies,
		std::string const &	defaultDriverClient,
		uv_loop_t *	loop
	)

Create all the requested services and initialise them

Definition at line 1013 of file runDataProcessing.cxx.

◆ doDefaultWorkflowTerminationHook()

void doDefaultWorkflowTerminationHook ( )

Definition at line 1008 of file runDataProcessing.cxx.

◆ doDPLException()

void doDPLException	(	o2::framework::RuntimeErrorRef &	ref,
		char const *	processName
	)

Definition at line 968 of file runDataProcessing.cxx.

◆ doMain()

int doMain	(	int	argc,
		char **	argv,
		o2::framework::WorkflowSpec const &	workflow,
		std::vector< ChannelConfigurationPolicy > const &	channelPolicies,
		std::vector< CompletionPolicy > const &	completionPolicies,
		std::vector< DispatchPolicy > const &	dispatchPolicies,
		std::vector< ResourcePolicy > const &	resourcePolicies,
		std::vector< CallbacksPolicy > const &	callbacksPolicies,
		std::vector< SendingPolicy > const &	sendingPolicies,
		std::vector< ConfigParamSpec > const &	currentWorkflowOptions,
		std::vector< ConfigParamSpec > const &	detectedParams,
		o2::framework::ConfigContext &	configContext
	)

Iterate over the physicalWorkflow, any DataProcessorSpec that has a expendable label should have all the timeframe lifetime outputs changed to sporadic, because there is no guarantee that the device will be alive, so we should not expect its data to always arrive.

This is the earlies the services are actually needed

Set the fair::Logger severity to the one specified in the command line We do it by hand here, because FairMQ device is not initialsed until much later and we need the logger before that.

Definition at line 2843 of file runDataProcessing.cxx.

◆ doUnknownException()

void doUnknownException	(	std::string const &	s,
		char const *	processName
	)

Definition at line 987 of file runDataProcessing.cxx.

◆ dryRun()

AlgorithmSpec dryRun ( DeviceSpec const & spec )

Definition at line 996 of file runDataProcessing.cxx.

◆ dumpMetricsCallback()

void dumpMetricsCallback ( uv_timer_t * handle )

Definition at line 1240 of file runDataProcessing.cxx.

◆ dumpRunSummary()

void dumpRunSummary	(	DriverServerContext &	context,
		DriverInfo const &	driverInfo,
		DeviceInfos const &	infos,
		DeviceSpecs const &	specs
	)

Definition at line 1249 of file runDataProcessing.cxx.

◆ enableSignposts()

void enableSignposts ( std::string const & signpostsToEnable )

Definition at line 2756 of file runDataProcessing.cxx.

◆ force_exit_callback()

void force_exit_callback ( uv_timer_s * ctx )

Definition at line 1216 of file runDataProcessing.cxx.

◆ getChildData()

void getChildData	(	int	infd,
		DeviceInfo &	outinfo
	)

Definition at line 235 of file runDataProcessing.cxx.

◆ getDumpableMetrics()

std::vector< std::regex > getDumpableMetrics ( )

Definition at line 1222 of file runDataProcessing.cxx.

◆ getIdString()

char * getIdString	(	int	argc,
		char **	argv
	)

Definition at line 185 of file runDataProcessing.cxx.

◆ gHiddenDeviceOptions()

bpo::options_description gHiddenDeviceOptions ( "Hidden child options" )

◆ gui_callback()

void gui_callback ( uv_timer_s * ctx )

Definition at line 1128 of file runDataProcessing.cxx.

◆ handle_crash()

void handle_crash ( int sig )

Definition at line 638 of file runDataProcessing.cxx.

◆ handleChildrenStdio()

void handleChildrenStdio	(	DriverServerContext *	serverContext,
		std::string const &	forwardedStdin,
		std::vector< DeviceStdioContext > &	childFds,
		std::vector< uv_poll_t * > &	handles
	)

Add pollers for stdout and stderr

Definition at line 601 of file runDataProcessing.cxx.

◆ handleSignals()

void handleSignals ( )

Definition at line 581 of file runDataProcessing.cxx.

◆ initialiseDriverControl()

void initialiseDriverControl	(	bpo::variables_map const &	varmap,
		DriverInfo &	driverInfo,
		DriverControl &	control
	)

Helper function to initialise the controller from the command line options.

Definition at line 2526 of file runDataProcessing.cxx.

◆ isInputConfig()

bool isInputConfig ( )

Definition at line 2357 of file runDataProcessing.cxx.

◆ isOutputToPipe()

bool isOutputToPipe ( )

Definition at line 2350 of file runDataProcessing.cxx.

◆ killChildren()

void killChildren	(	std::vector< DeviceInfo > &	infos,
		int	sig
	)

Definition at line 279 of file runDataProcessing.cxx.

◆ log_callback()

void log_callback	(	uv_poll_t *	handle,
		int	status,
		int	events
	)

Definition at line 426 of file runDataProcessing.cxx.

◆ O2_DECLARE_DYNAMIC_LOG() [1/2]

O2_DECLARE_DYNAMIC_LOG ( driver )

◆ O2_DECLARE_DYNAMIC_LOG() [2/2]

O2_DECLARE_DYNAMIC_LOG ( gui )

◆ overrideAll()

void overrideAll	(	o2::framework::ConfigContext &	ctx,
		std::vector< o2::framework::DataProcessorSpec > &	workflow
	)

Definition at line 2802 of file runDataProcessing.cxx.

◆ overrideCloning()

void overrideCloning	(	ConfigContext &	ctx,
		WorkflowSpec &	workflow
	)

Definition at line 2370 of file runDataProcessing.cxx.

◆ overrideLabels()

void overrideLabels	(	ConfigContext &	ctx,
		WorkflowSpec &	workflow
	)

Definition at line 2460 of file runDataProcessing.cxx.

◆ overridePipeline()

void overridePipeline	(	ConfigContext &	ctx,
		WorkflowSpec &	workflow
	)

Definition at line 2420 of file runDataProcessing.cxx.

◆ printHelp()

void printHelp	(	bpo::variables_map const &	varmap,
		bpo::options_description const &	executorOptions,
		std::vector< DataProcessorSpec > const &	physicalWorkflow,
		std::vector< ConfigParamSpec > const &	currentWorkflowOptions
	)

Definition at line 2313 of file runDataProcessing.cxx.

◆ processChildrenOutput()

void processChildrenOutput	(	uv_loop_t *	loop,
		DriverInfo &	driverInfo,
		DeviceInfos &	infos,
		DeviceSpecs const &	specs,
		DeviceControls &	controls
	)

Definition at line 836 of file runDataProcessing.cxx.

◆ processSigChild()

bool processSigChild	(	DeviceInfos &	infos,
		DeviceSpecs &	specs
	)

Definition at line 919 of file runDataProcessing.cxx.

◆ runStateMachine()

int runStateMachine	(	DataProcessorSpecs const &	workflow,
		WorkflowInfo const &	workflowInfo,
		DataProcessorInfos const &	previousDataProcessorInfos,
		CommandInfo const &	commandInfo,
		DriverControl &	driverControl,
		DriverInfo &	driverInfo,
		DriverConfig &	driverConfig,
		std::vector< DeviceMetricsInfo > &	metricsInfos,
		std::vector< ConfigParamSpec > const &	detectedParams,
		boost::program_options::variables_map &	varmap,
		std::vector< ServiceSpec > &	driverServices,
		std::string	frameworkId
	)

Cleanup the shared memory for the uniqueWorkflowId, in case we are unlucky and an old one is already present.

After INIT we go into RUNNING and eventually to SCHEDULE from there and back into running. This is because the general case would be that we start an application and then we wait for resource offers from DDS or whatever resource manager we use.

extract and apply process switches prune device inputs

FIXME: use commandline arguments as alternative

Set the default value for tracingFlags of each control to the command line value –dpl-tracing-flags

Set the value for the severity of displayed logs to the command line value –severity

Definition at line 1349 of file runDataProcessing.cxx.

◆ single_step_callback()

void single_step_callback ( uv_timer_s * ctx )

Force single stepping of the children.

Definition at line 1210 of file runDataProcessing.cxx.

◆ spawnDevice()

void spawnDevice	(	uv_loop_t *	loop,
		DeviceRef	ref,
		std::vector< DeviceSpec > const &	specs,
		DriverInfo &	driverInfo,
		std::vector< DeviceControl > &	,
		std::vector< DeviceExecution > &	executions,
		std::vector< DeviceInfo > &	deviceInfos,
		std::vector< DataProcessingStates > &	allStates,
		ServiceRegistryRef	serviceRegistry,
		boost::program_options::variables_map &	varmap,
		std::vector< DeviceStdioContext > &	childFds,
		unsigned	parentCPU,
		unsigned	parentNode
	)

This will start a new device by forking and executing a new child

Definition at line 674 of file runDataProcessing.cxx.

◆ spawnRemoteDevice()

void spawnRemoteDevice	(	uv_loop_t *	loop,
		std::string const &	,
		DeviceSpec const &	spec,
		DeviceControl &	,
		DeviceExecution &	,
		DeviceInfos &	deviceInfos,
		DataProcessingStatesInfos &	allStates
	)

Definition at line 390 of file runDataProcessing.cxx.

◆ stream_config()

void stream_config ( uv_work_t * req )

Definition at line 530 of file runDataProcessing.cxx.

◆ websocket_callback()

void websocket_callback	(	uv_stream_t *	stream,
		ssize_t	nread,
		const uv_buf_t *	buf
	)

Definition at line 458 of file runDataProcessing.cxx.

◆ ws_connect_callback()

void ws_connect_callback	(	uv_stream_t *	server,
		int	status
	)

A callback for the rest engine.

Definition at line 504 of file runDataProcessing.cxx.

Variable Documentation

◆ bindGUIPort

auto bindGUIPort

Definition at line 1276 of file runDataProcessing.cxx.

◆ double_sigint

volatile sig_atomic_t double_sigint = false

Definition at line 363 of file runDataProcessing.cxx.

◆ forceful_exit

volatile sig_atomic_t forceful_exit = false

Definition at line 361 of file runDataProcessing.cxx.

◆ gDeviceMetricsInfos

std::vector<DeviceMetricsInfo> gDeviceMetricsInfos

Definition at line 171 of file runDataProcessing.cxx.

◆ graceful_exit

volatile sig_atomic_t graceful_exit = false

Definition at line 360 of file runDataProcessing.cxx.

◆ sigchld_requested

volatile sig_atomic_t sigchld_requested = false

Definition at line 362 of file runDataProcessing.cxx.

Classes

Macros

Typedefs

Functions

Variables