Crate kompact

The Kompact message-passing framework provides a hybrid approach between the Kompics component model and the Actor model for writing distributed systems.

To get all Kompact related things into scope import use kompact::prelude::*; instead of use kompact::*;.

Hello World Example

use kompact::prelude::*;

#[derive(ComponentDefinition, Actor)]
struct HelloWorldComponent {
    ctx: ComponentContext<Self>
}
impl HelloWorldComponent {
    pub fn new() -> HelloWorldComponent {
        HelloWorldComponent {
            ctx: ComponentContext::uninitialised()
        }
    }
}
impl ComponentLifecycle for HelloWorldComponent {
    fn on_start(&mut self) -> Handled {
        info!(self.ctx.log(), "Hello World!");
        self.ctx().system().shutdown_async();
        Handled::Ok
    }
}

let system = KompactConfig::default().build().expect("system");
let component = system.create(HelloWorldComponent::new);
system.start(&component);
system.await_termination();

Crate Feature Flags

The following crate feature flags are available. They are configured in your Cargo.toml.

• silent_logging
  • Reduces logging to INFO in debug builds and ERROR in release builds
  • Must be used with --no-default-features
• low_latency
  • Prevents thread pool threads from going to sleep when using the default pool.
  • This can improve reaction time to incoming network events, at the cost of much higher CPU utilisation.
• ser_id_64 (default), ser_id_32, ser_id_16, ser_id_8
  • Selects the bit-width of serialisation identifiers.
  • Trying to use a serialisation id that is too large for the selected width will result in a compile-time error.
  • All values are mutually exclusive and all but the default of ser_id_64 must be used with --no-default-features.
• thread_pinning
  • Enables support for pinning pool threads to CPU cores (or rather processing units).
  • This flag has no effect if the runtime OS does not support thread pinning.
  • Enabling this will cause as many threads as there are PUs to be pinned by default.
  • Assignments can be customised by providing a custom scheduler with the desired settings.
  • See executors crate for more details.
• serde_support (default)
  • Build with support for Serde serialisers.
• type_erasure (nightly-only)
  • Build with an experimental API for dyn type-erased components.
• use_local_executor (default)
  • Use thread-local executors to avoid cloning the handle to the system scheduler for every component scheduling.
  • Not all scheduler implementations support this feature, so you might have to disable it via --no-default-features if you are using a custom scheduler.
• implicit_routes (default)
  • Allow default broadcast and select actor paths on any node in the tree, not just where explicitly set via set_routing_policy.
  • While this feature is convenient, it may open up your system to DoS attacks via broadcast on high-level nodes (e.g. tcp://1.2.3.4:8000/*).
  • If you are concered about this security risk, you can disable this feature by using --no-default-features.

Re-exports

pub use executors;

Modules

component	Traits and structs for component API and internals
constants	Useful Kompact constants are re-exported in this module
default_components	Default implementations for system components
doctest_helpers	Helper structs and functions for doctests.
lookup	Data structures for looking up the dispatch/routing table.
messaging	Facilities and utilities for dealing with network messages Messaging types for sending and receiving messages between remote actors.
net	Default networking implementation
prelude	To get all kompact related things into scope import as use kompact::prelude::*.
prelude_bench	A module containing helper functions for benchmarking
prelude_test	A module containing helper functions for (unit) testing
routing	Facilities for routing messages
runtime	Kompact system runtime facilities, such as configuration and schedulers
serde_serialisers	Provides serialisation support for Serde
timer	Reusable timer facility internals

Macros

ignore_control	Deprecated A macro that provides an empty implementation of ComponentLifecycle for the given component
ignore_indications	A macro that provides an empty implementation of the required handler for the given $port on the given $component
ignore_lifecycle	A macro that provides an empty implementation of ComponentLifecycle for the given component
ignore_requests	A macro that provides an empty implementation of the provided handler for the given $port on the given $component
info_lifecycle	A macro that provides an implementation of ComponentLifecycle for the given component that logs the lifecycle stages at INFO log level.
let_irrefutable	A macro that provides a shorthand for an irrefutable let binding, that the compiler cannot determine on its own
match_deser	A macro to make matching serialisation ids and deserialising easier

Type Definitions

JoinHandle	A type of future returned from the spawn and spawn_off functions to await the completion of the spawned future.
KompactLogger	A simple type alias Kompact's slog Logger type signature.
Never	A more readable placeholder for a stable Never (!) type.