grpc 0.8.3

Rust implementation of gRPC
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

use futures::future;
use futures::StreamExt;

use crate::Metadata;

use futures::stream;

use crate::ServerResponseSink;
use crate::ServerResponseUnarySink;
use std::future::Future;
use std::task::Context;
use std::task::Poll;
use tokio::runtime::Handle;

/// An object passed to server handlers.
pub struct ServerHandlerContext {
    pub ctx: httpbis::ServerHandlerContext,
    // TODO: move to request
    pub metadata: Metadata,
}

impl ServerHandlerContext {
    /// Tokio event loop handle (can be used to spawn a future for example).
    pub fn loop_remote(&self) -> Handle {
        self.ctx.loop_remote()
    }

    /// Spawn a future, ignore result.
    pub fn spawn<F>(&self, f: F)
    where
        F: Future<Output = crate::Result<()>> + Send + 'static,
    {
        self.loop_remote().spawn(async {
            if let Err(e) = f.await {
                warn!("spaned future returned error: {:?}", e);
            }
        });
    }

    /// Spawn a poll_fn future. Function error is ignored.
    pub fn spawn_poll_fn<F>(&self, f: F)
    where
        F: FnMut(&mut Context<'_>) -> Poll<crate::Result<()>> + Send + 'static,
    {
        self.spawn(future::poll_fn(f))
    }

    /// Spawn a future which polls stream and sends items to [`ServerResponseSink`].
    pub fn pump<Resp, S>(&self, mut stream: S, mut dest: ServerResponseSink<Resp>)
    where
        Resp: Send + 'static,
        S: stream::Stream<Item = crate::Result<Resp>> + Unpin + Send + 'static,
    {
        self.spawn(async move {
            while let Some(m) = stream.next().await {
                dest.send_data(m?)?;
            }
            dest.send_trailers(Metadata::new())
        });
    }

    /// Spawn the provided future in tokio even loop, send result to given sink.
    pub fn pump_future<Resp, F>(&self, future: F, dest: ServerResponseUnarySink<Resp>)
    where
        Resp: Send + 'static,
        F: Future<Output = crate::Result<Resp>> + Unpin + Send + 'static,
    {
        self.spawn(async move {
            let m = future.await?;
            dest.finish(m)
        });
    }
}