t2_bus 0.1.0

An inter- or intra-process message bus supporting publish/subscribe and request/response.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

use crate::{
    client::Client, err::BusResult, prelude::Stopper, protocol::{ProtocolClient, ProtocolServer}, server::listen::{listen_and_serve, Listener}
};
use std::path::PathBuf;
use tokio::net::UnixStream;

use super::{cbor_codec::CborCodec, Transport};

/// Start a bus server using the TCP socket transport. You can then connect to
/// and use the bus from within a separate host.
/// ```rust
/// # use t2_bus::prelude::*;
/// # async fn test() -> BusResult<()> {
///    let stopper = t2_bus::transport::tcp::serve("localhost:4242").await?;
///
///    // Then connect a client to the bus:
///    let client = t2_bus::transport::tcp::connect("localhost:4242").await?;
/// #
/// #     Ok(())
/// # }
/// ```
pub fn serve(addr: &PathBuf) -> BusResult<impl Stopper> {
    let listener = UnixListener::new(addr)?;
    listen_and_serve(listener)
}

pub async fn connect(
    addr: &PathBuf,
) -> BusResult<Client> {
    let socket = UnixStream::connect(addr).await?;
    let transport = tokio_util::codec::Framed::new(socket, CborCodec::new());
    let client = Client::new(transport)?;
    Ok(client)
}

pub(crate) struct UnixListener(tokio::net::UnixListener);

impl UnixListener{
    pub(crate) fn new(addr: &PathBuf) -> BusResult<Self>{
        let _ = std::fs::remove_file(addr);
        let listener = tokio::net::UnixListener::bind(addr)?;
        Ok(
            Self(listener)
        )
    }
}

impl Listener for UnixListener{
    async fn accept(&mut self) -> BusResult<impl Transport<ProtocolServer, ProtocolClient>> {
        let (socket, _) = self.0.accept().await?;
        let transport = tokio_util::codec::Framed::new(socket, CborCodec::new());
        Ok(transport)
    }
}