feattle
Featture toggles for Rust (called "feattles", for short), extensible and with background synchronization and administration UI.
Features
- Feature toggles that synchronize automatically with a backing storage
- Feature toggles can be as simple
bool
, but can also be lists, maps and arbitrary tpes ( (through the [FeattleValue
] trait). - Web UI with documentation, change history, validation
- JSON API to read and set the toggles
- Modular and extensible: use as much or as little of the bundled features as you want. Want to use a different Web UI? A different storage layer? No problem.
Example
use S3Client;
use Region;
use *;
use Arc;
/// A struct with your feature toggles: you can use primitive types (like `bool`, `i32`, etc),
/// standard collections (like `Vec`, `BTreeSet`, etc) or any arbitrary type that implements
/// the required trait.
feattles!
// Store their values and history in AWS' S3
let s3_client = new;
let persistence = S3 new;
// Create a new instance
let my_feattles = new;
// Poll the storage in the background
new.spawn;
// Start the admin UI with `warp`
let admin_panel = new;
spawn;
// Read values (note the use of `*`)
assert_eq!;
assert_eq!;
assert_eq!;
You can run a full example locally with: cargo run --example full --features='s3 uuid warp'
.
With this code, you'll get an Web Admin UI like:
You can use the UI to edit the current values and see their change history. For example, this
is what you can expect when editing an enum
:
It also supports complex types with a JSON editor and helpful error diagnostics:
How it works
The macro will generate a struct with the given name and visibility modifier (assuming private
by default). The generated struct implements [Feattles
] and also exposes one method for each
feattle.
The methods created for each feattle allow reading their current value. For example, for a
feattle is_cool: bool
, there will be a method like
pub fn is_cool(&self) -> MappedRwLockReadGuard<bool>
. Note the use of
[parking_lot::MappedRwLockReadGuard
] because the interior of the struct is stored behind a RwLock
to
control concurrent access.
A feattle is created with the syntax $key: $type [= $default]
. You can use doc coments (
starting with ///
) to describe nicely what they do in your system. You can use any type that
implements [FeattleValue
] and optionally provide a default. If not provided, the default
will be created with Default::default()
.
Minimum supported Rust version
As of this release, the MSRV is 1.51.0, as tested in the CI. A patch release will never require a newer MSRV.
Optional features
You can easily declare feattles with your custom types, use another persistance storage logic or Web Framework (or any at all). For some out-of-the-box functionality, you can activate these cargo features:
- uuid: will add support for [
uuid::Uuid
]. - s3: provides [
S3
] to integrate with AWS' S3 - warp: provides [
run_warp_server
] for a read-to-use integration with [warp
]
Crate's organization
This crate is a simple re-export of these three components:
Having them separate allows for leaner lower-level integration. If you're creating a crate to
provide a different storage or admin, you just need feattle-core
.
License
Licensed under either of
- Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
- MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)
at your option.
Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
See CONTRIBUTING.md.