https://github.com/mitsuhiko/rust-execution-context

Implements a .NET inspired execution context for Rust
https://github.com/mitsuhiko/rust-execution-context

Last synced: 2 months ago
JSON representation

Implements a .NET inspired execution context for Rust

• Host: GitHub
• URL: https://github.com/mitsuhiko/rust-execution-context
• Owner: mitsuhiko
• Created: 2018-06-08T22:56:07.000Z (over 6 years ago)
• Default Branch: master
• Last Pushed: 2018-06-13T09:57:46.000Z (over 6 years ago)
• Last Synced: 2024-10-13T01:34:34.461Z (3 months ago)
• Language: Rust
• Size: 15.6 KB
• Stars: 38
• Watchers: 3
• Forks: 1
• Open Issues: 1
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# Execution Context for Rust

This implements a .NET inspired execution context.  The idea is that something like

this could become a core language concept if it can be shown to be reasonably performant.

## What are Execution Contexts?

An execution context is a container for a logical call flow.  The idea is that any code

that follows the same flow of execution can access flow-local data.  An example where

this is useful is security relevant data that code might want to carry from operation

to operation without accidentally dropping it.

This gives you the most trivial example:

```rust

flow_local!(static TEST: u32 = 42);

assert_eq!(*TEST.get(), 42);

let ec = ExecutionContext::capture();

TEST.set(23);

assert_eq!(*TEST.get(), 23);

ec.run(|| {

    assert_eq!(*TEST.get(), 42);

});

```

Execution contexts can be forwarded to other threads and an API is provided to

temporarily or permanently suppress the flow propagation.

## Why Are Execution Contexts?

It's pretty clear that implicit data propagation is a hotly contended topic.  For a

very long time the author of this crate was convinced that implicit data passing

through either thread locals or to have global variables is a severe case of code

smell.  However my experience has shown that there are many situations where it's

hard to avoid having a system like this.

*   Systems like distributed tracing, during-production debug tools like Sentry and

    many more require the ability to figure out at runtime what belongs together.

*   many APIs use thread locality which are becoming a problem when async/await

    are used in the language.

*   security and auditing code can be written in a safer way if security relevant

    context information is not accidentally dropped.

While obviously explicitly passing information is generally preferred in a lot of

situations, implicit data passing along the logical thread of execution is a very

potent tool.