pelikan-net 0.1.0

Pelikan project's networking abstractions for non-blocking event loops
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
97
98
99
100
101
102
103
104
105

// Copyright 2022 Twitter, Inc.
// Licensed under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0

use crate::*;

pub struct Listener {
    inner: ListenerType,
}

enum ListenerType {
    Plain(TcpListener),
    Tls((TcpListener, TlsTcpAcceptor)),
}

impl From<TcpListener> for Listener {
    fn from(other: TcpListener) -> Self {
        Self {
            inner: ListenerType::Plain(other),
        }
    }
}

impl From<(TcpListener, TlsTcpAcceptor)> for Listener {
    fn from(other: (TcpListener, TlsTcpAcceptor)) -> Self {
        Self {
            inner: ListenerType::Tls(other),
        }
    }
}

impl Listener {
    /// Accepts a new `Stream`.
    ///
    /// An error `e` with `e.kind()` of `ErrorKind::WouldBlock` indicates that
    /// the operation should be retried again in the future.
    ///
    /// All other errors should be treated as failures.
    pub fn accept(&self) -> Result<Stream> {
        STREAM_ACCEPT.increment();
        let result = self._accept();
        if result.is_err() {
            STREAM_ACCEPT_EX.increment();
        }
        result
    }

    fn _accept(&self) -> Result<Stream> {
        match &self.inner {
            ListenerType::Plain(listener) => {
                let (stream, _addr) = listener.accept()?;
                Ok(Stream::from(stream))
            }
            ListenerType::Tls((listener, acceptor)) => {
                let (stream, _addr) = listener.accept()?;
                let stream = acceptor.accept(stream)?;
                Ok(Stream::from(stream))
            }
        }
    }

    pub fn local_addr(&self) -> Result<SocketAddr> {
        match &self.inner {
            ListenerType::Plain(listener) => listener.local_addr(),
            ListenerType::Tls((listener, _acceptor)) => listener.local_addr(),
        }
    }
}

impl event::Source for Listener {
    fn register(
        &mut self,
        registry: &mio::Registry,
        token: mio::Token,
        interests: mio::Interest,
    ) -> Result<()> {
        match &mut self.inner {
            ListenerType::Plain(listener) => listener.register(registry, token, interests),
            ListenerType::Tls((listener, _acceptor)) => {
                listener.register(registry, token, interests)
            }
        }
    }

    fn reregister(
        &mut self,
        registry: &mio::Registry,
        token: mio::Token,
        interests: mio::Interest,
    ) -> Result<()> {
        match &mut self.inner {
            ListenerType::Plain(listener) => listener.reregister(registry, token, interests),
            ListenerType::Tls((listener, _acceptor)) => {
                listener.reregister(registry, token, interests)
            }
        }
    }

    fn deregister(&mut self, registry: &mio::Registry) -> Result<()> {
        match &mut self.inner {
            ListenerType::Plain(listener) => listener.deregister(registry),
            ListenerType::Tls((listener, _acceptor)) => listener.deregister(registry),
        }
    }
}