Struct goose::goose::GooseTask

pub struct GooseTask {
    pub tasks_index: usize,
    pub name: String,
    pub weight: usize,
    pub sequence: usize,
    pub on_start: bool,
    pub on_stop: bool,
    pub function: GooseTaskFunction,
}

An individual task within a GooseTaskSet.

Fields

tasks_index: usize

An index into GooseTaskSet.task, indicating which task this is.

name: String

An optional name for the task, used when displaying metrics about requests made.

weight: usize

An integer value that controls the frequency that this task will be run.

sequence: usize

An integer value that controls when this task runs compared to other tasks in the same GooseTaskSet.

on_start: bool

A flag indicating that this task runs when the user starts.

on_stop: bool

A flag indicating that this task runs when the user stops.

function: GooseTaskFunction

A required function that is executed each time this task runs.

Implementations

impl GooseTask

pub fn new(function: GooseTaskFunction) -> Self

pub fn set_name(self, name: &str) -> Self

Set an optional name for the task, used when displaying metrics about requests made by the task.

Individual requests can also be named using GooseRequestBuilder, or for GET requests with the GooseUser::get_named helper.

Example

use goose::prelude::*;

task!(my_task_function).set_name("foo");

async fn my_task_function(user: &mut GooseUser) -> GooseTaskResult {
    let _goose = user.get("").await?;

    Ok(())
}

pub fn set_on_start(self) -> Self

Set an optional flag indicating that this task should be run when a user first starts. This could be used to log the user in, and so all subsequent tasks are done as a logged in user. A task with this flag set will only run at start time (and optionally at stop time as well, if that flag is also set).

On-start tasks can be sequenced and weighted. Sequences allow multiple on-start tasks to run in a controlled order. Weights allow on-start tasks to run multiple times when a user starts.

Example

use goose::prelude::*;

task!(my_on_start_function).set_on_start();

async fn my_on_start_function(user: &mut GooseUser) -> GooseTaskResult {
    let _goose = user.get("").await?;

    Ok(())
}

pub fn set_on_stop(self) -> Self

Set an optional flag indicating that this task should be run when a user stops. This could be used to log a user out when the user finishes its load test. A task with this flag set will only run at stop time (and optionally at start time as well, if that flag is also set).

On-stop tasks can be sequenced and weighted. Sequences allow multiple on-stop tasks to run in a controlled order. Weights allow on-stop tasks to run multiple times when a user stops.

Example

use goose::prelude::*;

task!(my_on_stop_function).set_on_stop();

async fn my_on_stop_function(user: &mut GooseUser) -> GooseTaskResult {
    let _goose = user.get("").await?;

    Ok(())
}

pub fn set_weight(self, weight: usize) -> Result<Self, GooseError>

Sets a weight on an individual task. The larger the value of weight, the more often it will be run in the TaskSet. For example, if one task has a weight of 3 and another task has a weight of 1, the first task will run 3 times as often.

Example

use goose::prelude::*;

#[tokio::main]
async fn main() -> Result<(), GooseError> {
    task!(task_function).set_weight(3)?;

    Ok(())
}

async fn task_function(user: &mut GooseUser) -> GooseTaskResult {
    let _goose = user.get("").await?;

    Ok(())
}

pub fn set_sequence(self, sequence: usize) -> Self

Defines the sequence value of an individual tasks. Tasks are run in order of their sequence value, so a task with a sequence value of 1 will run before a task with a sequence value of 2. Tasks with no sequence value (or a sequence value of 0) will run last, after all tasks with positive sequence values.

All tasks with the same sequence value will run in a random order. Tasks can be assigned both squence values and weights.

Examples

In this first example, the variable names indicate the order the tasks will be run in:

use goose::prelude::*;

let runs_first = task!(first_task_function).set_sequence(3);
let runs_second = task!(second_task_function).set_sequence(5835);
let runs_last = task!(third_task_function);

async fn first_task_function(user: &mut GooseUser) -> GooseTaskResult {
    let _goose = user.get("1").await?;

    Ok(())
}

async fn second_task_function(user: &mut GooseUser) -> GooseTaskResult {
    let _goose = user.get("2").await?;

    Ok(())
}

async fn third_task_function(user: &mut GooseUser) -> GooseTaskResult {
    let _goose = user.get("3").await?;

    Ok(())
}

In the following example, the runs_first task runs two times, then one instance of runs_second and two instances of also_runs_second are all three run. The user will do this over and over the entire time it runs, with runs_first always running first, then the other tasks being run in a random and weighted order:

use goose::prelude::*;

#[tokio::main]
async fn main() -> Result<(), GooseError> {
    let runs_first = task!(first_task_function).set_sequence(1).set_weight(2)?;
    let runs_second = task!(second_task_function_a).set_sequence(2);
    let also_runs_second = task!(second_task_function_b).set_sequence(2).set_weight(2)?;

    Ok(())
}

async fn first_task_function(user: &mut GooseUser) -> GooseTaskResult {
    let _goose = user.get("1").await?;

    Ok(())
}

async fn second_task_function_a(user: &mut GooseUser) -> GooseTaskResult {
    let _goose = user.get("2a").await?;

    Ok(())
}

    async fn second_task_function_b(user: &mut GooseUser) -> GooseTaskResult {
      let _goose = user.get("2b").await?;

      Ok(())
    }

Trait Implementations

impl Clone for GooseTask

fn clone(&self) -> GooseTask

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Hash for GooseTask

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.