nonparallel

Crates.iononparallel
lib.rsnonparallel
version0.1.1
sourcesrc
created_at2019-10-09 17:08:04.179873
updated_at2023-07-17 07:27:28.23858
descriptionRust macro for ensuring non-parallel execution of functions. (Deprecated, use `serial_test` instead.)
homepage
repositoryhttps://github.com/dbrgn/nonparallel/
max_upload_size
id171262
size21,290
Danilo Bargen (dbrgn)

documentation

https://docs.rs/nonparallel/

README

nonparallel

CircleCI Crates.io Version Crates.io Downloads License

:warning: Note: This crate is deprecated and unmaintained. You should use serial_test instead, which is more powerful than nonparallel.

A procedural macro for Rust that allows you to ensure that functions are not running at the same time. This is especially useful for integration tests, where tests that are writing to the same database table should not run in parallel.

The goal of mutual exclusion is achieved by acquiring a mutex at the beginning of the annotated function. So in essence this macro is syntactical sugar for writing MUT.lock().unwrap() at the beginning of every function.

Different functions can synchronize on different mutexes. That's why a static mutex reference must be passed to the nonparallel annotation.

Usage

use std::sync::Mutex;
use lazy_static::lazy_static;
use nonparallel::nonparallel;

// Create two locks
lazy_static! { static ref MUT_A: Mutex<()> = Mutex::new(()); }
lazy_static! { static ref MUT_B: Mutex<()> = Mutex::new(()); }

// Mutually exclude parallel runs of functions using those two locks

#[nonparallel(MUT_A)]
fn function_a1() {
    // This will not run in parallel to function_a2
}

#[nonparallel(MUT_A)]
fn function_a2() {
    // This will not run in parallel to function_a1
}

#[nonparallel(MUT_B)]
fn function_b() {
    // This may run in parallel to function_a*
}

License

Licensed under either of

at your option.

Commit count: 10

cargo fmt