webaves 0.1.0

Web archiving software suite
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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! RPC helper utilities

use std::{marker::PhantomData, net::SocketAddr};

use serde::{Deserialize, Serialize};
use tarpc::{
    serde_transport::Transport,
    server::{BaseChannel, Channel, Serve},
};
use tokio::io::{AsyncRead, AsyncWrite};
use tokio_serde::formats::Bincode;
use tokio_util::codec::{Framed, LengthDelimitedCodec};
use tracing::Instrument;

use crate::error::Error;

use super::conn::Listen;

/// Helper to run a Tarpc service.
pub struct ServerRunner<Serv, Req, Lis, Stream>
where
    Serv: Serve<Req>,
    Lis: Listen<Stream>,
    Stream: AsyncRead + AsyncWrite,
{
    server: Serv,
    listener: Lis,

    _req: PhantomData<Req>,
    _stream: PhantomData<Stream>,
}

impl<Serv, Req, Lis, Stream> ServerRunner<Serv, Req, Lis, Stream>
where
    Serv: Serve<Req> + Send + Clone + 'static,
    Serv::Fut: Send,
    Req: for<'de> Deserialize<'de> + Send + 'static,
    Serv::Resp: Serialize + Send + 'static,
    Lis: Listen<Stream>,
    Stream: AsyncRead + AsyncWrite + Send + 'static,
{
    /// Create a `ServerRunner` with the given service handler and listener.
    pub fn new(server: Serv, listener: Lis) -> Self {
        Self {
            server,
            listener,
            _req: PhantomData,
            _stream: PhantomData,
        }
    }

    /// Set the connection to listen for incoming connections.
    pub fn listen(&mut self) -> Result<Option<SocketAddr>, Error> {
        let local_address = self.listener.listen()?;

        match local_address {
            Some(local_address) => tracing::info!(?local_address, "server listening"),
            None => tracing::info!("server listening"),
        }

        Ok(local_address)
    }

    /// Start a loop to accept connections and process RPC requests.
    pub async fn accept_loop(&mut self) -> Result<(), Error> {
        loop {
            let (stream, remote_address) = self.listener.accept().await?;
            let server = self.server.clone();

            tokio::spawn(
                async move {
                    tracing::info!("connected");
                    let transport = create_transport(stream);
                    BaseChannel::with_defaults(transport).execute(server).await;
                    tracing::info!("disconnected");
                }
                .instrument(tracing::info_span!("client", ?remote_address)),
            );
        }
    }
}

/// Create a Tarpc Transport compatible with Webaves services.
pub fn create_transport<S, Item, SinkItem>(
    stream: S,
) -> Transport<S, Item, SinkItem, Bincode<Item, SinkItem>>
where
    S: AsyncWrite + AsyncRead,
    Item: for<'de> Deserialize<'de>,
    SinkItem: Serialize,
{
    let framed = Framed::new(stream, LengthDelimitedCodec::new());
    let codec = Bincode::default();

    tarpc::serde_transport::new(framed, codec)
}