Abscissa is a microframework for building Rust applications (either CLI tools or network services), aiming to provide a large number of features with a minimal number of dependencies, and with a strong focus on security.
- command-line option parsing: simple declarative option parser built on top of the gumdrop crate.
- configuration: TOML configuration file parsing on application-defined configuration structures which can be dynamically updated at runtime.
- error handling: unified error-handling subsystem with generic errors.
- tracing: uses the
tracingcrate to provide async-aware application- level tracing.
- secrets management: the (optional)
secretsmodule includes a
Secrettype which derives serde's
Deserializeand can be used to represent secret values parsed from configuration files or elsewhere (e.g. credentials loaded from the environment or network requests)
- terminal interactions: support for colored terminal output (with color support autodetection). Useful for Cargo-like status messages with easy-to-use macros.
The following commands will generate an Abscissa application skeleton:
$ cargo install abscissa $ abscissa new my_cool_app
The resulting app is a Cargo project. The following files are particularly noteworthy:
src/application.rs: Abscissa application type for your app
src/commands*: application entrypoint and subcommands. Make sure to check out the
hello.rsexample of how to make a subcommand.
src/config.rs: application configuration
src/error.rs: error types
Abscissa applications are implemented as Rust libraries, but have a
src/bin subdirectory where the binary entrypoint lives. This means you
can run the following within your newly generated application:
$ cargo run -- hello world
This will invoke the
hello subcommand of your application (you'll
probably want to rename that in a real app) which will print the following:
You can also run the following to print basic help information:
$ cargo run -- --help
Command-line options are parsed using the gumdrop crate.
Please see the documentation for the
// Print a Cargo-like justified status to STDOUT status_ok!("Loaded", "app loaded successfully"); // Print an error message status_err!("something bad happened"); // Print an indented attribute to STDOUT status_attr_ok!("good", "yep"); // Print an error attribute to STDERR status_attr_err!("error", "yep");
Trait for representing an Abscissa application and it's lifecycle
Application (sub)command(s), i.e. app entry points
Application components: extensions/plugins for Abscissa applications.
Support for managing global configuration, as well as loading it from TOML
Error types used by this crate
Paths for resources used by the application.
Core prelude: imported in every application's
Unix signal handling
Terminal handling (TTY interactions, colors, etc)
Acceptance testing for Abscissa applications.
Thread wrapper types.
Ensure a condition holds, returning an error if it doesn't (ala assert)
Create and return an error with a formatted message
Terminate the application with a fatal error, running Abscissa's shutdown hooks.
Create a new error (of a given kind) with a formatted message
Print a tab-delimited status attribute (in red if colors are enabled)
Print a tab-delimited status attribute (in green if colors are enabled)
Print an error message (in red if colors are enabled)
Print an informational status message (in cyan if colors are enabled)
Print a success status message (in green if colors are enabled)
Print a warning status message (in yellow if colors are enabled)
Toplevel entrypoint command.
Help command which prints usage information.
Wrapper type for values that contains secrets, which attempts to limit accidental exposure and ensure secrets are wiped from memory when dropped. (e.g. passwords, cryptographic keys, access tokens or other credentials)
Represents a version number conforming to the semantic versioning scheme.
Types of shutdown recognized by Abscissa
Command type with which a configuration file is associated
Implements a set of options parsed from command line arguments.