dnet 0.1.4

Message passing infrastructure.
Documentation
#![cfg(not(target_arch = "wasm32"))]

use std::{net::SocketAddr, sync::Arc};

use anyhow::Result;
use dnet::{
    codecs::BincodeCodec,
    rpc::producer::{Configuration, Produce},
    tcp::TcpTransport,
};
use futures::{pin_mut, FutureExt};
use tokio::{
    net::{TcpListener, TcpStream},
    select, spawn,
    sync::RwLock,
};
use tracing::{error, info, Level};

use crate::producer::Producer;

#[derive(Debug, Default)]
struct State {}

pub async fn run(address: &str) -> Result<()> {
    tracing_subscriber::fmt().with_max_level(Level::INFO).init();

    info!("Server running!");
    let state = Arc::new(RwLock::new(State::default()));

    let listener = TcpListener::bind(&address).await?;
    info!("Listening at {}...", address);

    let break_signal = tokio::signal::ctrl_c().fuse();
    pin_mut!(break_signal);
    loop {
        select! {
            listener_result = listener.accept() => {
                let (stream, address) = listener_result?;
                let state = state.clone();
                spawn(async move {
                    tracing::debug!("accepted connection");
                    if let Err(error) = user_connected(stream, address, state).await {
                        error!("Error occurred: {error}");
                    }
                });
            },
            break_result = &mut break_signal => {
                break_result.expect("failed to listen for event");
                break;
            }
        }
    }
    info!("Shutting down...");

    Ok(())
}

async fn user_connected(
    stream: TcpStream,
    address: SocketAddr,
    _state: Arc<RwLock<State>>,
) -> Result<()> {
    let transport = TcpTransport::buffered(stream, BincodeCodec::default());
    let producer = Producer::new();
    info!("Producing for {address}...");
    let configuration = Configuration {
        timeout: Some(std::time::Duration::from_secs(3)),
        ..Default::default()
    };
    let shutdown = producer
        .produce(transport, configuration, Default::default())
        .await?;
    info!("Producing for {address} finished: {:?}.", shutdown);

    Ok(())
}