QuantLauncher - SmartQuant

Overview

QuantLauncher is a service for remote lifecycle management of SmartQuant applications (strategies and infrastructure services) from a single control point. It starts and stops processes, manages application instances and their configurations, tracks health/state, and publishes statuses into the observability layer.

QuantLauncher works together with QuantController: monitoring clients (for example, QuantWeb/QuantMonitor) send commands to the controller, and the controller delegates start/stop and configuration operations to the host where QuantLauncher is installed.

Why QuantLauncher

Single place to start strategies: operators and developers can start required strategy instances without server access via RDP/SSH.
Multiple instances, same binary: the same executable can be started in multiple configurations (different *.appsettings.json).
Predictable lifecycle control: statuses Ready / Started / Stopped / Failed, process PID, and start/stop timestamps are available in monitoring.
Faster CI/CD and environments: quick startup/shutdown of stacks for testing, demos, and production operations.

What QuantLauncher does

Start and stop applications

• starts an application as a separate process with arguments (typically the selected settings file);
• stops an application (process kill) and records the shutdown;
• tracks process exit and automatically updates status.

Application catalog (strategy repository)

QuantLauncher scans the configured applications folder (AppPath) and builds a catalog of available executables and their configurations:

• finds applications by the presence of an executable in subfolders;
• automatically collects configuration files: *.appsettings.json and/or appsettings.json next to the executable;
• exposes this catalog to the UI via QuantController - so you launch from a curated list, not by hand.

Configuration management

• reads the current settings file on request (for inspection/diagnostics);
• writes updated settings (for quick parameter changes);
• copies settings files (fast cloning of strategy instances with different parameters).

Persisted state across restarts

QuantLauncher persists the state of managed applications locally (list and statuses), can restore information about previously started processes, and continues to reflect them correctly in monitoring.

Role in the SmartQuant architecture

In the SmartQuant ecosystem, QuantLauncher is the host-level executor of lifecycle commands:

• QuantController - control plane (commands and a global view of the system);
• QuantLauncher - execution plane (process start/stop and configuration management on a host);
• QuantWeb / QuantMonitor - user interfaces for operations and observability.

This model simplifies operations in distributed setups: control is centralized, execution remains local on each server/node.

Typical scenarios

1) Run multiple instances of the same strategy

One strategy runs in several modes (for example, different markets/instruments/risk parameters): choose different *.appsettings.json; each instance is tracked as a separate app with its own status.

2) Operate a shared environment

Quickly start/stop a set of services (strategies, routers, helper tools) for testing, demos, or regression without manual server actions.

3) Deploy across multiple hosts

Run a QuantLauncher on each server while managing everything from a single QuantController. The result is one control panel for a distributed strategy fleet.

What QuantLauncher delivers

• Lower operational overhead: fewer manual steps, fewer launch mistakes.
• A unified standard for strategy operations: the same start/stop/config workflow for all applications.
• Observability by default: statuses and lifecycle changes are available in real time from monitoring clients.