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> |
Definition at line 37 of file ApplicationLifecycle.h.
◆ ApplicationStarterPtr
| using ApplicationStarterPtr = std::shared_ptr<ApplicationStarter> |
Definition at line 72 of file ApplicationStarter.h.
◆ ApplicationStopperPtr
| typedef std::shared_ptr< ApplicationStopper > ApplicationStopperPtr = std::shared_ptr<ApplicationStopper> |
Definition at line 57 of file ApplicationStopper.h.
◆ ExecutorPtr
| using ExecutorPtr = std::shared_ptr<Executor> |
Definition at line 210 of file Executor.h.
◆ StarterFactoryPtr
| using StarterFactoryPtr = std::shared_ptr<ScenarioManager::Exec::StarterFactory> |
Definition at line 58 of file StarterFactory.h.
◆ StopperFactoryPtr
| using StopperFactoryPtr = std::shared_ptr<ScenarioManager::Exec::StopperFactory> |
Definition at line 65 of file StopperFactory.h.
◆ StopStrategyPtr
| typedef std::shared_ptr< StopStrategy > StopStrategyPtr = std::shared_ptr<StopStrategy> |
Definition at line 48 of file Executor.h.
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.
Definition at line 45 of file ApplicationLifecycle.cpp.
Here is the caller graph for this function:◆ 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.
Definition at line 38 of file ApplicationLifecycle.cpp.
