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) -> HandlerResult {
        info!(self.ctx.log(), "Hello World!");
        self.ctx().system().shutdown_async();
        Handled::OK
    }
}

let system = KompactConfig::default().build().wait().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, ser_id_32, ser_id_16, ser_id_8
  • Selects the bit-width of serialisation identifiers for serialised or distributed messaging.
  • 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. If none of these feature flags is selected, Kompact uses u64 serialisation ids.
• 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
  • Build with support for Serde serialisers.
• type_erasure
  • 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
  • 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/*).
  • This is only meaningful together with the distributed feature.
• distributed
  • Enables the distributed dispatching surface, such as actor paths, registration, aliasing, and routing.
  • Plain default kompact is local-only. Enable this feature explicitly when you want path-based dispatching without the provided network backend from kompact-net.

Re-exports

pub use executors;

Modules

component

Traits and structs for component API and internals

config

Utilities for working with Kompact configuration keys and values

config_keys

All Kompact configuration keys

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

test_support

Test support utilities Test support utilities for Kompact systems.

timer

Reusable timer facility internals

Macros

ignore_controlDeprecated

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.

kompact_config

Macro to create config entries.

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 Aliases

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.