Struct Orchestrator

pub struct Orchestrator<P, T> {

    settings: Settings,
    instances: Vec<Instance>,
    benchmark_type: PhantomData<T>,
    instance_setup_commands: Vec<String>,
    protocol_commands: P,
    scrape_interval: Duration,
    crash_interval: Duration,
    ssh_manager: SshConnectionManager,
    skip_testbed_update: bool,
    skip_testbed_configuration: bool,
    log_processing: bool,
    dedicated_clients: usize,
    skip_monitoring: bool,
}

An orchestrator to run benchmarks on a testbed.

Fields

settings: Settings

The testbed’s settings.

instances: Vec<Instance>

The state of the testbed (reflecting accurately the state of the machines).

benchmark_type: PhantomData<T>

The type of the benchmark parameters.

instance_setup_commands: Vec<String>

Provider-specific commands to install on the instance.

protocol_commands: P

Protocol-specific commands generator to generate the protocol configuration files, boot clients and nodes, etc.

scrape_interval: Duration

The interval between measurements collection.

crash_interval: Duration

The interval to crash nodes.

ssh_manager: SshConnectionManager

Handle ssh connections to instances.

skip_testbed_update: bool

Whether to skip testbed updates before running benchmarks.

skip_testbed_configuration: bool

Whether to skip testbed configuration before running benchmarks.

log_processing: bool

Whether to downloading and analyze the client and node log files.

dedicated_clients: usize

Number of instances running only load generators (not nodes). If this value is set to zero, the orchestrator runs a load generate collocated with each node.

skip_monitoring: bool

Whether to forgo a grafana and prometheus instance and leave the testbed unmonitored.

Implementations

impl<P, T> Orchestrator<P, T>

const DEFAULT_SCRAPE_INTERVAL: Duration

The default interval between measurements collection.

const DEFAULT_CRASH_INTERVAL: Duration

The default interval to crash nodes.

pub fn new( settings: Settings, instances: Vec<Instance>, instance_setup_commands: Vec<String>, protocol_commands: P, ssh_manager: SshConnectionManager, ) -> Self

Make a new orchestrator.

pub fn with_scrape_interval(self, scrape_interval: Duration) -> Self

Set interval between measurements collection.

pub fn with_crash_interval(self, crash_interval: Duration) -> Self

Set interval with which to crash nodes.

pub fn skip_testbed_updates(self, skip_testbed_update: bool) -> Self

Set whether to skip testbed updates before running benchmarks.

pub fn skip_testbed_configuration( self, skip_testbed_configuration: bool, ) -> Self

Whether to skip testbed configuration before running benchmarks.

pub fn with_log_processing(self, log_processing: bool) -> Self

Set whether to download and analyze the client and node log files.

pub fn with_dedicated_clients(self, dedicated_clients: usize) -> Self

Set the number of instances running exclusively load generators.

pub fn skip_monitoring(self, skip_monitoring: bool) -> Self

Set whether to boot grafana on the local machine to monitor the nodes.

pub fn select_instances( &self, parameters: &BenchmarkParameters<T>, ) -> TestbedResult<(Vec<Instance>, Vec<Instance>, Option<Instance>)>

Select on which instances of the testbed to run the benchmarks. This function returns two vector of instances; the first contains the instances on which to run the load generators and the second contains the instances on which to run the nodes.

impl<P: ProtocolCommands<T> + ProtocolMetrics, T: BenchmarkType> Orchestrator<P, T>

async fn boot_nodes( &self, instances: Vec<Instance>, parameters: &BenchmarkParameters<T>, ) -> TestbedResult<()>

Boot one node per instance.

pub async fn install(&self) -> TestbedResult<()>

Install the codebase and its dependencies on the testbed.

pub async fn start_monitoring( &self, parameters: &BenchmarkParameters<T>, ) -> TestbedResult<()>

Reload prometheus on all instances.

pub async fn update(&self) -> TestbedResult<()>

Update all instances to use the version of the codebase specified in the setting file.

pub async fn configure( &self, parameters: &BenchmarkParameters<T>, ) -> TestbedResult<()>

Configure the instances with the appropriate configuration files.

pub async fn cleanup(&self, cleanup: bool) -> TestbedResult<()>

Cleanup all instances and optionally delete their log files.

pub async fn run_nodes( &self, parameters: &BenchmarkParameters<T>, ) -> TestbedResult<()>

Deploy the nodes.

pub async fn run_clients( &self, parameters: &BenchmarkParameters<T>, ) -> TestbedResult<()>

Deploy the load generators.

pub async fn run( &self, parameters: &BenchmarkParameters<T>, ) -> TestbedResult<MeasurementsCollection<T>>

Collect metrics from the load generators.

pub async fn download_logs( &self, parameters: &BenchmarkParameters<T>, ) -> TestbedResult<LogsAnalyzer>

Download the log files from the nodes and clients.

pub async fn run_benchmarks( &mut self, generator: BenchmarkParametersGenerator<T>, ) -> TestbedResult<()>

Run all the benchmarks specified by the benchmark generator.