Crate rship_sdk

Example Executor

use rship_sdk::{ActionArgs, EmitterArgs, InstanceArgs, SdkClient, TargetArgs};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct MyActionData {
    pub data: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct MyEmitterType {
    pub data: String,
}

pub async fn start_client() {
    // Initialize logger
    env_logger::init();
     
    // Load the environment variables
    let address = std::env::var("RSHIP_ADDRESS").unwrap_or_else(|_| "dev.rship.io".to_string());
    let port = std::env::var("RSHIP_PORT").unwrap_or_else(|_| "5155".to_string());
    let url = format!("ws://{}:{}/myko", address, port);
    log::info!("Connecting to: {}", url);

    // Create a new sdk client
    let sdk = SdkClient::init();
    sdk.set_address(Some(url));

    // Wait for the client to connect
    sdk.await_connection().await;

    // Create an instance
    let instance = sdk
        .add_instance(InstanceArgs {
            name: "Rust SDK Example".into(),
            short_id: "rust-sdk-example".into(),
            code: "rust-sdk-example".into(),
            service_id: "rust-sdk-service".into(),
            cluster_id: None,
            color: "#FF6B35".into(),
            machine_id: "rust-sdk-machine".into(),
            message: Some("Hello from Rust SDK!".into()),
            status: rship_sdk::InstanceStatus::Available,
        })
        .await;

    // Create a target
    let mut target = instance
        .add_target(TargetArgs {
            name: "SDK Example Target".into(),
            short_id: "sdk-example-target".into(),
            category: "examples".into(),
            parent_targets: None,
        })
        .await;

    // Add an action to the target
    target
        .add_action(
            ActionArgs::<MyActionData>::new("Print Log".into(), "print-log".into()),
            |action, data| {
                println!("{}", data.data);
            },
        )
        .await;

    // Add an emitter to the target
    let emitter = target
        .add_emitter(EmitterArgs::<MyEmitterType>::new(
            "Example Emitter".into(),
            "example-emitter".into(),
        ))
        .await;

    // Pulse the emitter
    let mut counter = 0;
    loop {
        emitter.pulse(MyEmitterType { data: format!("{}", counter) }).await.expect("Failed to pulse emitter");
        counter += 1;
        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    }
}

#[tokio::main]
async fn main() {
    start_client().await;
}

Structs

ActionArgs

ActionProxy

BooleanKeyframeData

EmitterArgs

EmitterProxy

EventTrackArgs

EventTrackLayerArgs

EventTrackLayerProxy

EventTrackProxy

InstanceArgs

InstanceProxy

IntegerKeyframeData

KeyframeArgs

NullKeyframeData

NumberKeyframeData

SdkClient

StringKeyframeData

TargetArgs

TargetProxy

Enums

ConcreteSchemaType

EventTrackTimeMode

InstanceStatus

Traits

JsonSchema

A type which can be described as a JSON Schema document.

Derive Macros

JsonSchema