Struct goose::goose::GooseTaskSet [−][src]
pub struct GooseTaskSet { pub name: String, pub task_sets_index: usize, pub weight: usize, pub min_wait: usize, pub max_wait: usize, pub tasks: Vec<GooseTask>, pub weighted_tasks: Vec<(usize, String)>, pub weighted_on_start_tasks: Vec<(usize, String)>, pub weighted_on_stop_tasks: Vec<(usize, String)>, pub host: Option<String>, }
Expand description
An individual task set.
Fields
name: String
The name of the task set.
task_sets_index: usize
An integer reflecting where this task set lives in the internal
GooseAttack
.task_sets
vector.
weight: usize
An integer value that controls the frequency that this task set will be assigned to a user.
min_wait: usize
An integer value indicating the minimum number of seconds a user will sleep after running a task.
max_wait: usize
An integer value indicating the maximum number of seconds a user will sleep after running a task.
tasks: Vec<GooseTask>
A vector containing one copy of each GooseTask
that will
run by users running this task set.
weighted_tasks: Vec<(usize, String)>
weighted_on_start_tasks: Vec<(usize, String)>
A vector of vectors of integers, controlling the sequence and order
on_start
GooseTask
s are run when the user first starts.
weighted_on_stop_tasks: Vec<(usize, String)>
A vector of vectors of integers, controlling the sequence and order
on_stop
GooseTask
s are run when the user first starts.
host: Option<String>
An optional default host to run this GooseTaskSet
against.
Implementations
Creates a new GooseTaskSet
. Once created, a
GooseTask
must be assigned to it, and finally it must
be registered with the GooseAttack
object. The
returned object must be stored in a mutable value.
Example
use goose::prelude::*; let mut example_tasks = taskset!("ExampleTasks");
Registers a GooseTask
with a
GooseTaskSet
, where it is stored in the
GooseTaskSet
.tasks
vector. The function
associated with the task will be run during the load test.
Example
use goose::prelude::*; let mut example_tasks = taskset!("ExampleTasks"); example_tasks.register_task(task!(a_task_function)); /// A very simple task that loads the "a" page. async fn a_task_function(user: &GooseUser) -> GooseTaskResult { let _goose = user.get("/a/").await?; Ok(()) }
Sets a weight on a task set. The larger the value of weight, the more often the task set will be assigned to users. For example, if you have task set foo with a weight of 3, and task set bar with a weight of 1, and you spin up a load test with 8 users, 6 of them will be running the foo task set, and 2 will be running the bar task set.
Example
use goose::prelude::*; fn main() -> Result<(), GooseError> { let mut example_tasks = taskset!("ExampleTasks").set_weight(3)?; Ok(()) }
Set a default host for the task set. If no --host
flag is set when running the load test, this
host will be pre-pended on all requests. For example, this can configure your load test to run
against your local development environment by default, and the --host
option could be used to
override host when running the load test against production.
Example
use goose::prelude::*; let mut example_tasks = taskset!("ExampleTasks").set_host("http://10.1.1.42");
Configure a task_set to to pause after running each task. The length of the pause will be randomly
selected from min_weight
to max_wait
inclusively. For example, if min_wait
is 0
and
max_weight
is 2
, the user will randomly sleep for 0, 1 or 2 seconds after each task completes.
Example
use goose::prelude::*; fn main() -> Result<(), GooseError> { taskset!("ExampleTasks").set_wait_time(0, 1)?; Ok(()) }
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for GooseTaskSet
impl Send for GooseTaskSet
impl Sync for GooseTaskSet
impl Unpin for GooseTaskSet
impl !UnwindSafe for GooseTaskSet
Blanket Implementations
Mutably borrows from an owned value. Read more
Instruments this type with the provided Span
, returning an
Instrumented
wrapper. Read more
type Output = T
type Output = T
Should always be Self