Convenient Linux services

use std::{
    path::PathBuf,
    sync::atomic::{AtomicU64, Ordering},
};

use log::{info, LevelFilter};
use tokio::{self};

use krossbar_bus_common::DEFAULT_HUB_SOCKET_PATH;
use krossbar_bus_lib::service::Service;

#[tokio::main]
async fn main() {
    pretty_env_logger::formatted_builder()
        .filter_level(LevelFilter::Info)
        .init();

    // Making a new Krossbar service
    let mut service = Service::new(
        "com.examples.demo_server",
        &PathBuf::from(DEFAULT_HUB_SOCKET_PATH),
    )
    .await
    .unwrap();

    // Register a state which holds each 10th client
    let mut state = service
        .register_state("10th_client", (0u64, String::new()))
        .unwrap();

    // Register a signal which emits when we've a new method call
    let signal = service.register_signal("client_count").unwrap();

    let client_counter = AtomicU64::from(0);

    // Register a method to greet clients
    service
        .register_async_method("greet", move |service_name, name: String| {
            info!("A call from \"{service_name}\": \"{name}\"");

            let client_count = client_counter.fetch_add(1, Ordering::Relaxed);

            // Note: `signal` and `state` methods to broadcast values don't
            // capture `self`, which allows moving the result futures
            // into async block below
            let signal_sender = signal.clone().emit(client_count);
            let state_sender = if client_count % 10 == 0 {
                Some(state.set((client_count, name.clone())))
            } else {
                None
            };

            async move {
                signal_sender.await.unwrap();
                if let Some(state_sender) = state_sender {
                    state_sender.await.unwrap();
                }

                format!("Hello, {name}")
            }
        })
        .unwrap();

    // Register a method to receive one-way messages
    service
        .register_method("messages", move |service_name, name: String| {
            info!("A message from \"{service_name}\": \"{name}\"");
        })
        .unwrap();

    // Spawn a task to poll incoming data
    tokio::spawn(service.run());
    let _ = tokio::signal::ctrl_c().await;
}

use std::{path::PathBuf, time::Duration};

use futures::StreamExt;
use log::{LevelFilter, *};
use tokio::{self, select};

use krossbar_bus_common::DEFAULT_HUB_SOCKET_PATH;
use krossbar_bus_lib::service::Service;

#[tokio::main(flavor = "current_thread")]
async fn main() {
    pretty_env_logger::formatted_builder()
        .filter_level(LevelFilter::Info)
        .init();

    // Register new Krossbar service
    let mut service = Service::new(
        "com.examples.demo_client",
        &PathBuf::from(DEFAULT_HUB_SOCKET_PATH),
    )
    .await
    .unwrap();

    // Connect to a demo server
    let server_connection = service
        .connect_await("com.examples.demo_server")
        .await
        .unwrap();

    // Spawn a task to poll incoming messages
    // Note: you can move service handle into the task and continue using
    // `Client` handle
    tokio::spawn(service.run());

    // Subscribe to call counter
    let mut subscription = server_connection
        .subscribe::<u64>("client_count")
        .await
        .unwrap();

    // Subscribe for each 10th client info
    let mut state_subscription = server_connection
        .subscribe::<(u64, String)>("10th_client")
        .await
        .unwrap();

    let mut counter = 0u64;
    'outer: loop {
        let client_name = format!("Client-{counter}");

        // Make a regular call
        let response: String = server_connection.call("greet", &client_name)
            .await
            .unwrap();
        info!("Call response \"{response}\"");

        // Random frequence here
        if counter % 3 == 0 {
            // Get last 10th client
            let response: (u64, String) = server_connection.get("10th_client")
                .await
                .unwrap();
            info!("10th client call \"{response:?}\"");
        }

        // Random frequence here too
        if counter % 7 == 0 {
            let message = format!("Message from {client_name}");

            // One-way message
            server_connection
                .message("messages", &message)
                .await
                .unwrap();
        }

        loop {
            select! {
                value = subscription.next() => {
                    info!("Client count: {value:?}");
                },
                value = state_subscription.next() => {
                    info!("10th client: {value:?}");
                },
                _ = tokio::time::sleep(Duration::from_secs(1)) => {
                    break;
                }
                _ = tokio::signal::ctrl_c() => {
                    break 'outer;
                }
            };
        }

        counter += 1;
    }
}

use std::time::Duration;

use log::*;

use krossbar_log_lib::init_logger;

#[tokio::main]
async fn main() {
    let logger = init_logger("com.examples.logging", LevelFilter::Trace, true).await;

    tokio::spawn(logger.run());

    loop {
        error!("Error message");
        warn!("Warning message");
        info!("Info message");
        debug!("Debug message");
        trace!("Trace message");

        tokio::time::sleep(Duration::from_secs(1)).await;
    }
}

use serde::{Deserialize, Serialize};

use krossbar_settings_lib::Settings;

#[derive(Serialize, Deserialize)]
struct ComplexStructure {
    integer: i32,
    string: String,
    vec: Vec<bool>,
}

fn main() {
    let storage = Settings::init("krossbar.viewer.example").unwrap();

    storage.read_or_insert("int", 42).unwrap();

    storage
        .read_or_insert("string", "Hello, world!".to_owned())
        .unwrap();

    storage
        .read_or_insert(
            "struct",
            ComplexStructure {
                integer: 42,
                string: "Test".into(),
                vec: vec![true, false],
            },
        )
        .unwrap();
}