senstate/

lib.rs

#![doc(html_root_url = "https://docs.rs/senstate/0.0.1")]

use std::sync::mpsc::{channel, Sender};
use std::thread::JoinHandle;

use log::{trace, warn};
use num_traits::Num;
use serde::Serialize;
use serde_repr::Serialize_repr;
use tungstenite::{connect, Message};
use url::Url;
use uuid::Uuid;

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct AppMeta {
    pub app_id: Uuid,
    pub name: String,
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Serialize_repr)]
#[repr(u8)]
/// Different types of data that a watcher can send to Senstate.
pub enum WatchType {
    /// String is a simple string of any kind. It can be send with
    /// [send_string](struct.Watcher.html#method.send_string).
    String,
    /// Number can be any number like integers and floats. It can be send with
    /// [send_number](struct.Watcher.html#method.send_number).
    Number,
    /// Json any instance that is serializable to JSON with serde. It can be send with
    /// [send_json](struct.Watcher.html#method.send_json).
    Json,
    /// Performance is currently equivalent to [`Number`](#variant.Number). It can be send with
    /// [send_performance](struct.Watcher.html#method.send_performance).
    Performance,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct WatcherMeta {
    pub watch_id: Uuid,
    pub tag: String,
    #[serde(rename = "type")]
    pub type_: WatchType,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct WatchData<T> {
    pub watch_id: Uuid,
    pub data: T,
}

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct LogData<T> {
    pub log: T,
}

/// A client is the main connection to the Senstate server and is used to create new
/// [`Watcher`](struct.Watcher.html)s for sending data.
#[derive(Debug)]
pub struct Client {
    handle: JoinHandle<()>,
    tx: Sender<String>,
}

#[derive(Serialize)]
struct Payload<T> {
    event: &'static str,
    data: T,
}

impl Client {
    /// Create a new watcher to report the status of a single value.
    /// The `tag` is a name for this watcher and the `type_` defines which
    /// kind of data can be reported.
    pub fn new_watcher<T>(&self, tag: T, type_: WatchType) -> Watcher
    where
        T: Into<String>,
    {
        let id = Uuid::new_v4();
        Self::add_watcher(
            &self.tx,
            WatcherMeta {
                watch_id: id,
                tag: tag.into(),
                type_,
            },
        );

        Watcher {
            tx: self.tx.clone(),
            id,
            type_,
        }
    }

    /// Send a log message to Senstate. This can be any data that is serializable.
    pub fn log<T>(&self, log: T)
    where
        T: Serialize,
    {
        input_log_event(&self.tx, LogData { log })
    }

    fn connect(url: Url) -> (JoinHandle<()>, Sender<String>) {
        let (mut socket, _) = connect(url).expect("Can't connect");

        let (tx, rx) = channel();
        let handle = std::thread::spawn(move || loop {
            let msg: String = rx.recv().unwrap();

            trace!("--> {}", msg);
            socket.write_message(Message::Text(msg)).unwrap();
        });

        (handle, tx)
    }

    fn add_app(tx: &Sender<String>, meta: AppMeta) {
        send(tx, "addApp", &meta);
    }

    fn add_watcher(tx: &Sender<String>, meta: WatcherMeta) {
        send(tx, "addWatcher", &meta);
    }

    /// Wait for the client to shut down.
    pub fn wait(self) {
        self.handle.join().unwrap();
    }
}

/// A watcher represents the status of a single value. It is bound to a specific type of value
/// and can update that state at any time.
#[derive(Debug, Clone)]
pub struct Watcher {
    tx: Sender<String>,
    id: Uuid,
    type_: WatchType,
}

impl Watcher {
    /// Update the string value of this watcher. This method should only be used if
    /// the watcher type is [`String`](enum.WatchType.html#variant.String).
    pub fn send_string<T>(&self, data: T)
    where
        T: Into<String>,
    {
        if self.type_ != WatchType::String {
            warn!("trying to send string with a {:?} watcher", self.type_);
        }

        input_event(
            &self.tx,
            WatchData {
                watch_id: self.id,
                data: data.into(),
            },
        )
    }

    /// Update the number (integer, float, ...) value of this watcher. This method should
    /// only be used if the watcher type is [`Number`](enum.WatchType.html#variant.Number).
    pub fn send_number<T>(&self, data: T)
    where
        T: Num + Serialize,
    {
        if self.type_ != WatchType::Number {
            warn!("trying to send number with a {:?} watcher", self.type_);
        }

        input_event(
            &self.tx,
            WatchData {
                watch_id: self.id,
                data,
            },
        )
    }

    /// Update the JSON value of this watcher. This method should only be used if the watcher
    /// type is [`Json`](enum.WatchType.html#variant.Json).
    pub fn send_json<T>(&self, data: T)
    where
        T: Serialize,
    {
        if self.type_ != WatchType::Json {
            warn!("trying to send JSON with a {:?} watcher", self.type_);
        }

        input_event(
            &self.tx,
            WatchData {
                watch_id: self.id,
                data,
            },
        )
    }

    /// Update the performance value (same as `send_number` currently) of this watcher. This
    /// method should only be used if the watcher type is
    /// [`Performance`](enum.WatchType.html#variant.Performance).
    pub fn send_performance<T>(&self, data: T)
    where
        T: Num + Serialize,
    {
        if self.type_ != WatchType::Performance {
            warn!("trying to send performance with a {:?} watcher", self.type_);
        }

        input_event(
            &self.tx,
            WatchData {
                watch_id: self.id,
                data,
            },
        )
    }

    /// Send a log message to Senstate. This can be any data that is serializable.
    pub fn log<T>(&self, log: T)
    where
        T: Serialize,
    {
        input_log_event(&self.tx, LogData { log })
    }
}

/// Create a new Senstate client that can create watchers for specific values or
/// send logs to Senstate.
pub fn new<T>(url: Url, name: T) -> Client
where
    T: Into<String>,
{
    let (handle, tx) = Client::connect(url);

    Client::add_app(
        &tx,
        AppMeta {
            app_id: Uuid::new_v4(),
            name: name.into(),
        },
    );

    Client { handle, tx }
}

fn send<T>(tx: &Sender<String>, event: &'static str, data: &T)
where
    T: Serialize,
{
    let data = Payload { event, data };
    let data = serde_json::to_string(&data).unwrap();

    tx.send(data).unwrap();
}

fn input_event<T>(tx: &Sender<String>, event: WatchData<T>)
where
    T: Serialize,
{
    send(tx, "inputEvent", &event);
}

fn input_log_event<T>(tx: &Sender<String>, event: LogData<T>)
where
    T: Serialize,
{
    send(tx, "inputLogEvent", &event);
}