re_server 0.31.0-rc.1

A Rerun server implementation backed by an in-memory store
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

use std::time::Duration;
use tokio::time::sleep;

/// Add artificial latency to each request, to simulate talking to a remote server.
#[derive(Clone)]
pub struct LatencyLayer {
    rtt: Duration,
}

impl LatencyLayer {
    /// Create a new latency layer with the given round-trip time in milliseconds.
    pub fn new(rtt: Duration) -> Self {
        Self { rtt }
    }
}

impl<S> tower::Layer<S> for LatencyLayer {
    type Service = LatencyService<S>;

    fn layer(&self, service: S) -> Self::Service {
        LatencyService {
            inner: service,
            rtt: self.rtt,
        }
    }
}

#[derive(Clone)]
pub struct LatencyService<S> {
    inner: S,
    rtt: Duration,
}

impl<S, Request> tower::Service<Request> for LatencyService<S>
where
    S: tower::Service<Request> + Clone + Send + 'static,
    S::Future: Send,
    S::Response: Send,
    S::Error: Send,
    Request: Send + 'static,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future =
        std::pin::Pin<Box<dyn std::future::Future<Output = Result<S::Response, S::Error>> + Send>>;

    fn poll_ready(
        &mut self,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, req: Request) -> Self::Future {
        let Self { mut inner, rtt } = self.clone();
        Box::pin(async move {
            let resp = inner.call(req).await;
            if rtt != Duration::ZERO {
                sleep(rtt).await;
            }
            resp
        })
    }
}