ScenarioManager::Exec Namespace Reference

Namespaces
namespace	ProcessUtil

Classes
class	ApplicationLifecycle
	Owns every start and stop of one application - nothing else may launch or signal it. More...
class	ApplicationStarter
class	ApplicationStopper
	Interface for classes that handle how application get stopped and killed. More...
class	ByNameStopperLinux
	Stops or kills applications on Linux based on their name. More...
class	Executor
	Starts, stops and restarts applications and scenarios. More...
class	IceStatusReader
class	Kill
class	LinuxStarter
	Starts applications in Linux. More...
class	PidStopperLinux
	Stops or kills applications on Linux based on their pid. More...
class	StarterFactory
	Abstract base class for factory classes that create ApplicationStarter. More...
class	StarterFactoryLinux
	Creates an ApplicationStarter for Linux. More...
class	Stop
	Simply stops the application, using the given ApplicationStopper. More...
class	StopAndKill
	First tries to stop, then kills an application, using the given ApplicationStopper. More...
class	StopperFactory
	Abstract base class for factory classes that create ApplicationStopper. More...
class	StopperFactoryLinux
	Creates different ApplicationStopper for Linux. More...
class	StopStrategy
	Interface for classes that define how an application get stopped. More...
class	StopStrategyFactory
	Creates different instances of StopStrategy. More...

Typedefs
using	ApplicationLifecyclePtr = std::shared_ptr<ApplicationLifecycle>
using	ApplicationStarterPtr = std::shared_ptr<ApplicationStarter>
using	ApplicationStopperPtr = std::shared_ptr<ApplicationStopper>
using	ExecutorPtr = std::shared_ptr<Executor>
using	StarterFactoryPtr = std::shared_ptr<ScenarioManager::Exec::StarterFactory>
using	StopperFactoryPtr = std::shared_ptr<ScenarioManager::Exec::StopperFactory>
using	StopStrategyPtr = std::shared_ptr<StopStrategy>

Functions
std::shared_mutex &	GlobalOperationMutex ()
	Held shared by every application operation, and exclusively by global operations that act on all armarx processes at once, such as armarx killAll.
std::mutex &	LaunchMutex ()
	Serializes the actual spawning of applications.

Typedef Documentation

ApplicationLifecyclePtr

typedef std::shared_ptr< ApplicationLifecycle > ApplicationLifecyclePtr = std::shared_ptr<ApplicationLifecycle>

ApplicationStarterPtr

using ApplicationStarterPtr = std::shared_ptr<ApplicationStarter>

ApplicationStopperPtr

typedef std::shared_ptr< ApplicationStopper > ApplicationStopperPtr = std::shared_ptr<ApplicationStopper>

ExecutorPtr

using ExecutorPtr = std::shared_ptr<Executor>

StarterFactoryPtr

using StarterFactoryPtr = std::shared_ptr<ScenarioManager::Exec::StarterFactory>

StopperFactoryPtr

using StopperFactoryPtr = std::shared_ptr<ScenarioManager::Exec::StopperFactory>

StopStrategyPtr

typedef std::shared_ptr< StopStrategy > StopStrategyPtr = std::shared_ptr<StopStrategy>

Function Documentation

GlobalOperationMutex()

std::shared_mutex & GlobalOperationMutex

(

)

Held shared by every application operation, and exclusively by global operations that act on all armarx processes at once, such as armarx killAll.

This is what gives "kill everything" a defined outcome: a start requested while a kill-all is running waits for it and then runs, rather than racing it and leaving an application alive that was supposed to be killed.

LaunchMutex()

std::mutex & LaunchMutex

(

)

Serializes the actual spawning of applications.

Every launch forks this process, and forking a GUI with Qt, Ice and the whole scenario model mapped is expensive. Starting a scenario asks every one of its applications to start at the same time, so without this the process would fork N times concurrently and stall - including the GUI thread. Held only around the spawn itself, never around a wait.