Crate actyx_sdk[−][src]

Expand description

Actyx SDK

Actyx is a decentralized event database, streaming and processing engine that allows you to easily build local-first cooperative apps. It makes it easy to run distributed applications on multiple nodes. It is a piece of software that allows you to run your own apps on one or more edge devices and have these apps seamlessly communicate and share data with each other.

This crate defines the data types needed for communicating with Actyx and provides Rust bindings for the Actyx APIs. It also provides serialization instances for processing the events with differential-dataflow under the "dataflow" feature flag.

Examples

Below you find a full example using the EventService client that retrieves some events. Please adapt the queried tags to match your stored events in order to see output.

Note: this example needs the client feature to compile.

use actyx_sdk::{
  app_id, AppManifest, HttpClient,
  service::{EventService, Order, QueryRequest, QueryResponse},
};
use futures::stream::StreamExt;
use url::Url;

#[tokio::main]
pub async fn main() -> anyhow::Result<()> {
  // add your app manifest, for brevity we will use one in trial mode
  let app_manifest = AppManifest::new(
      app_id!("com.example.my-awesome-app"),
      "display name".into(),
      "0.1.0".into(),
      None,
  );

  // Url of the locally running Actyx node
  let url = Url::parse("http://localhost:4454")?;
  // create client for it
  let service = HttpClient::new(url, app_manifest).await?;

  // all events matching the given subscription
  // sorted backwards, i.e. youngest to oldest
  let mut events = service
      .query(QueryRequest {
          lower_bound: None,
          upper_bound: None,
          query: "FROM 'MyFish'".parse()?,
          order: Order::Desc,
      })
      .await?;

  // print out the payload of each event
  // (cf. Payload::extract for more options)
  while let Some(QueryResponse::Event(event)) = events.next().await {
      println!("{}", event.payload.json_value());
  }
  Ok(())
}

Feature flags

The default is to provide only the data types with serialization and deserialization support for serde. The following features can be enabled in addition:

client: include HTTP client bindings using the reqwest crate
dataflow: provide Abomonation instances for use with tools like Differential Dataflow
arb: provide quickcheck::Arbitrary instances for common data types. This is useful for testing.

Modules

Types that you may want to use in describing the event payload data

Macros

app_id

Macro for constructing an AppId literal.

arcval_scalar

Helper macro to create interned string types

fish_name

Macro for constructing a FishName literal.

semantics

Macro for constructing a Semantics literal.

source_id

Macro for constructing a SourceId literal.

tag

Macro for constructing a Tag literal.

Structs

AppId

The app ID denotes a specific app (sans versioning)

AppManifest

App manifest used for requesting a bearer token via the API. For more information see the docs.

Event

Events are delivered in this envelope together with their metadata

EventKey

The sort key of an event

HttpClient

LamportTimestamp

A logical timestamp taken from a Lamport clock

Metadata

Metadata attached to an event that can be used for filtering.

NodeId

The Actyx node identifier

Offset

Event offset within a stream

OffsetMap

Multi-dimensional cursor for event streams: an OffsetMap describes the set of events given by the event streams of each included source up to the associated Offset.

OffsetOrMin

Event offset within a SourceId’s stream or MIN value

Opaque

A ref-counted slice of memory holding a compact binary representation of an event payload

Payload

Compact binary storage of events created when they are received

StreamId

The unique identifier of a single event stream emitted by an Actyx node

StreamNr

Stream number. Newtype alias for u64

Tag

A Tag that semantically characterises an event.