Struct goose::GooseState

pub struct GooseState { /* fields omitted */ }

Internal global state for load test.

Implementations

impl GooseState

Goose's internal global state.

pub fn initialize() -> GooseState

Load configuration from command line and initialize a GooseState.

Example

    use goose::GooseState;

    let mut goose_state = GooseState::initialize();

pub fn initialize_with_config(config: GooseConfiguration) -> GooseState

Initialize a GooseState with an already loaded configuration. This should only be called by worker instances.

Example

    use goose::{GooseState, GooseConfiguration};
    use structopt::StructOpt;

    let configuration = GooseConfiguration::from_args();
    let mut goose_state = GooseState::initialize_with_config(configuration);

pub fn setup(self) -> Self

pub fn register_taskset(self, taskset: GooseTaskSet) -> Self

A load test must contain one or more GooseTaskSets. Each task set must be registered into Goose's global state with this method for it to run.

Example

    use goose::GooseState;
    use goose::goose::{GooseTaskSet, GooseTask, GooseClient};

    GooseState::initialize()
        .register_taskset(GooseTaskSet::new("ExampleTasks")
            .register_task(GooseTask::new(example_task))
        )
        .register_taskset(GooseTaskSet::new("OtherTasks")
            .register_task(GooseTask::new(other_task))
        );

    fn example_task(client: &mut GooseClient) {
      let _response = client.get("/foo");
    }

    fn other_task(client: &mut GooseClient) {
      let _response = client.get("/bar");
    }

pub fn set_host(self, host: &str) -> Self

Optionally configure a default host for the load test. This is used if no per-GooseTaskSet host is defined, no --host CLI option is configurared, and if the GooseTask itself doesn't hard-code the host in its request. The host is prepended on all requests.

For example, your load test may default to running against your local development container, and the --host option could be used to override host to run the load test against production.

Example

    use goose::GooseState;

    GooseState::initialize()
        .set_host("local.dev");

pub fn execute(self)

Execute the load test.

Example

    use goose::GooseState;
    use goose::goose::{GooseTaskSet, GooseTask, GooseClient};

    GooseState::initialize()
        .register_taskset(GooseTaskSet::new("ExampleTasks")
            .register_task(GooseTask::new(example_task).set_weight(2))
            .register_task(GooseTask::new(another_example_task).set_weight(3))
        )
        .execute();

    fn example_task(client: &mut GooseClient) {
      let _response = client.get("/foo");
    }

    fn another_example_task(client: &mut GooseClient) {
      let _response = client.get("/bar");
    }

pub fn launch_clients(
    self,
    started: Instant,
    sleep_duration: Duration,
    socket: Option<Socket>
) -> GooseState

Called internally in local-mode and gaggle-mode.

Trait Implementations

impl Clone for GooseState

fn clone(&self) -> GooseState

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.