• Stars
    star
    333
  • Rank 126,599 (Top 3 %)
  • Language
    Rust
  • License
    Apache License 2.0
  • Created about 7 years ago
  • Updated 3 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Fail points for rust

fail-rs

CI Crates.io

Documentation.

A fail point implementation for Rust.

Fail points are code instrumentations that allow errors and other behavior to be injected dynamically at runtime, primarily for testing purposes. Fail points are flexible and can be configured to exhibit a variety of behavior, including panics, early returns, and sleeping. They can be controlled both programmatically and via the environment, and can be triggered conditionally and probabilistically.

This crate is inspired by FreeBSD's failpoints.

Usage

First, add this to your Cargo.toml:

[dependencies]
fail = "0.5"

Now you can import the fail_point! macro from the fail crate and use it to inject dynamic failures. Fail points generation by this macro is disabled by default, and can be enabled where relevant with the failpoints Cargo feature.

As an example, here's a simple program that uses a fail point to simulate an I/O panic:

use fail::{fail_point, FailScenario};

fn do_fallible_work() {
    fail_point!("read-dir");
    let _dir: Vec<_> = std::fs::read_dir(".").unwrap().collect();
    // ... do some work on the directory ...
}

fn main() {
    let scenario = FailScenario::setup();
    do_fallible_work();
    scenario.teardown();
    println!("done");
}

Here, the program calls unwrap on the result of read_dir, a function that returns a Result. In other words, this particular program expects this call to read_dir to always succeed. And in practice it almost always will, which makes the behavior of this program when read_dir fails difficult to test. By instrumenting the program with a fail point we can pretend that read_dir failed, causing the subsequent unwrap to panic, and allowing us to observe the program's behavior under failure conditions.

When the program is run normally it just prints "done":

$ cargo run --features fail/failpoints
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/debug/failpointtest`
done

But now, by setting the FAILPOINTS variable we can see what happens if the read_dir fails:

FAILPOINTS=read-dir=panic cargo run --features fail/failpoints
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
     Running `target/debug/failpointtest`
thread 'main' panicked at 'failpoint read-dir panic', /home/ubuntu/.cargo/registry/src/github.com-1ecc6299db9ec823/fail-0.2.0/src/lib.rs:286:25
note: Run with `RUST_BACKTRACE=1` for a backtrace.

For further information see the API documentation.

TODO

Triggering a fail point via the HTTP API is planned but not implemented yet.

More Repositories

1

tikv

Distributed transactional key-value database, originally created to complement TiDB
Rust
15,068
star
2

raft-rs

Raft distributed consensus algorithm implemented in Rust.
Rust
2,916
star
3

grpc-rs

The gRPC library for Rust built on C Core library and futures
Rust
1,801
star
4

pprof-rs

A Rust CPU profiler implemented with the help of backtrace-rs
Rust
1,299
star
5

rust-prometheus

Prometheus instrumentation library for Rust applications
Rust
1,056
star
6

pd

Placement driver for TiKV
Go
1,041
star
7

agatedb

A persistent key-value storage in rust.
Rust
829
star
8

minitrace-rust

Extremely fast tracing library for Rust
Rust
731
star
9

raft-engine

A persistent storage engine for Multi-Raft log
Rust
547
star
10

titan

A RocksDB plugin for key-value separation, inspired by WiscKey.
C++
485
star
11

client-rust

Rust Client for TiKV.
Rust
388
star
12

client-go

Go client for TiKV
Go
279
star
13

minstant

Performant time measuring in Rust
Rust
170
star
14

yatp

Yet another thread pool in rust for both callbacks or futures.
Rust
134
star
15

client-java

TiKV Java Client
Java
111
star
16

deep-dive-tikv

How do we build a distributed, transactional key-value database - TiKV?
HTML
97
star
17

rfcs

RFCs for changes to TiKV and its ecosystem
78
star
18

auto-tikv

Tool to tune TiKV with ML method
Python
67
star
19

sig-transaction

Resources for the transaction SIG
63
star
20

async-speed-limit

Asynchronously speed-limiting multiple byte streams
Rust
57
star
21

minitrace-go

A high-performance timeline tracing library for Golang, used by TiDB
Go
45
star
22

crc64fast

SIMD accelerated CRC-64-ECMA computation
Rust
43
star
23

community

TiKV community content
43
star
24

client-c

The C++ TiKV client used by TiFlash.
C++
40
star
25

migration

Migration tools for TiKV, e.g. online bulk load.
Go
35
star
26

tikv-dev-guide

The TiKV development/contribution guide
34
star
27

client-py

Rust
27
star
28

importer

tikv-importer is a front-end to help ingesting large number of KV pairs into a TiKV cluster
Rust
20
star
29

website

Website for tikv.org
HTML
19
star
30

tikv-operator

Go
19
star
31

protobuf-build

Rust
17
star
32

client-cpp

TiKV Client for C++
Rust
14
star
33

client-node

Rust
11
star
34

mur3

Rust implementation of MurmurHash3.
Rust
11
star
35

copr-test

Go
10
star
36

mock-tikv

A mocked TiKV server for testing clients that written in different languages.
Go
6
star
37

jepsen-test

Clojure
6
star
38

slog-global

Global loggers for slog-rs. Similar to slog-scope but more simple.
Rust
5
star
39

match-template

match-template is a procedural macro that generates repeated match arms by pattern.
Rust
5
star
40

terraform-tikv-bench

An Orcestrated TiKV benchmark. Not for production deployment.
HCL
4
star
41

skiplist-rs

Rust
4
star
42

client-validator

Provide functional checks for tikv client implementations in different languages.
Go
3
star
43

tracing-active-tree

Rust
3
star
44

tlaplus-specs

TiKV TLA+ specifications
TLA
3
star