Astarte Device SDK Rust  

Warning: this SDK is experimental, correctness and API stability are currently not guaranteed

The Astarte Device SDK for Rust is a ready to use library that provides communication and pairing primitives to an Astarte Cluster.

See the Astarte documentation for more information regarding Astarte and the available SDKs.

Basic usage

use std::error::Error as StdError;

use astarte_device_sdk::{
    store::sqlite::SqliteStore,
    options::AstarteOptions,
    error::Error,
    AstarteDeviceSdk
};

async fn run_astarte_device() -> Result<(), Box<dyn StdError>> {

    let realm = "realm_name";
    let device_id = "device_id";
    let credentials_secret = "device_credentials_secret";
    let pairing_url = "astarte_cluster_pairing_url";

    // Initializing an instance of a device can be performed as shown in the following three steps.

    // 1. (optional) Initialize a database to store the properties
    let db = SqliteStore::new("sqlite::memory:").await?;

    // 2. Initialize device options (the ".database(db)" is not needed if 1 was skipped)
    let sdk_options = AstarteOptions::new(&realm, &device_id, &credentials_secret, &pairing_url)
        .interface_directory("./examples/interfaces")?
        .store(db);

    // 3. Create the device instance
    let (mut device, mut rx_events) = AstarteDeviceSdk::new(sdk_options).await.unwrap();

    // Publishing new values can be performed using the send and send_object functions.

    // Send individual datastream or set individual property
    let data: i32 = 12;
    device.send("interface.name", "/endpoint/path", data).await.unwrap();

    // Send aggregated object datastream
    use astarte_device_sdk::AstarteAggregate;
    // If the derive feature is not enabled
    #[cfg(not(feature = "derive"))]
    use astarte_device_sdk_derive::AstarteAggregate;

    #[derive(Debug, AstarteAggregate)]
    struct MyAggObj {
        endpoint1: f64,
        endpoint2: i32
    }

    let data = MyAggObj {endpoint1: 1.34, endpoint2: 22};
    device.send_object("interface.name", "/common/endpoint/path", data).await.unwrap();


    // Receive a server publish from the event channel
    tokio::spawn(async move {
        while let Some(event) = rx_events.recv().await {
          match event {
              Ok(data) => (), // Handle data
              Err(err) => (), // Handle errors
          }
        }
    });

    // Blocking call for the device event loop
    device.handle_events().await?;

    Ok(())
}

Building the library

You can build the library using:

cargo build

Examples

Check out how to start with the SDK using one of the included examples.