src/lib.rs - master - Kuj1/ds_point

pub mod bot;
pub mod config;
pub mod errors;

use bot::{MsgForSend, MsgForSendBuilder};
use errors::{ReceiveMessageResult, ReceiveMsgError};
use serde::Serialize;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::sync::broadcast::Receiver;
use tracing::error;

use crate::errors::{ReceiveDataError, ReceiveDataResult, SendDataResult};

pub async fn send_data<S: Serialize>(data: S, writer: &mut TcpStream) -> SendDataResult {
    let encoded_data = bincode::serialize(&data).unwrap();
    let bytes = encoded_data;
    let len = bytes.len() as u32;
    let len_bytes = len.to_be_bytes();
    writer.write_all(&len_bytes).await?;
    writer.write_all(&bytes).await?;
    Ok(())
}

pub async fn receive_command(stream: &mut TcpStream) -> ReceiveDataResult {
    let mut buf = [0; 4];
    stream.read_exact(&mut buf).await?;
    let len = u32::from_be_bytes(buf);
    let mut buf = vec![0; len as _];
    stream.read_exact(&mut buf).await?;
    String::from_utf8(buf).map_err(|error| {
        error!("{}", error);
        ReceiveDataError::BadEncoding
    })
}

pub async fn get_msg(mut receiver: Receiver<MsgForSend>) -> ReceiveMessageResult {
    if !receiver.is_empty() {
        match receiver.recv().await {
            Ok(data) => Ok(data),
            Err(error) => Err(ReceiveMsgError::ReceiveMsg(error)),
        }
    } else {
        Ok(MsgForSendBuilder::default().build())
    }
}