tk-pool 0.5.3

Generic connection pool for tokio
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

//! ErrorLog trait and default implementations
//!
use std::fmt;
use std::net::SocketAddr;
use std::marker::PhantomData;

use config::{NewErrorLog};

/// A reason connection pool being shut down
///
/// This value is passed to ``ErrorLog::pool_shutting_down`` method.
#[derive(Debug)]
pub enum ShutdownReason {
    /// Request stream is shutting down
    ///
    /// This usually means that all clones of ``queue::Pool`` object are
    /// destroyed
    RequestStreamClosed,
    /// Address stream is closed
    ///
    /// Shutting down address stream is commonly used to force shut down
    /// connection pool, even if there are users. Users will get an error
    /// on the next `start_send`.
    AddressStreamClosed,
    #[doc(hidden)]
    __Nonexhaustive,
}


/// The thrait that has appropriate hooks for logging different events
///
/// There is a default ``WarnLogger``, but the idea is that you may give
/// connection pool a name, change logging levels, and do other interesting
/// stuff in your own error log handler.
pub trait ErrorLog {
    /// Connection error type that is returned by connect/hanshake function
    type ConnectionError;
    /// Error when sending request returned by Sink
    type SinkError;
    /// Error when establishing a new connection
    fn connection_error(&self, _addr: SocketAddr, _e: Self::ConnectionError) {}
    /// Error when sending a request
    ///
    /// This also means connection is closed
    fn sink_error(&self, _addr: SocketAddr, _e: Self::SinkError) {}
    /// Pool is started to shut down for the specified reason
    fn pool_shutting_down(&self, _reason: ShutdownReason) {}
    /// Pool is fully closed at this moment
    fn pool_closed(&self) {}
}


/// A constructor for a default error logger
pub struct WarnLogger;

/// An instance of default error logger
pub struct WarnLoggerInstance<C, S>(PhantomData<* const (C, S)>);

impl<C, S> Clone for WarnLoggerInstance<C, S> {
    fn clone(&self) -> Self {
        WarnLoggerInstance(PhantomData)
    }
}

impl<C: fmt::Display, S: fmt::Display> NewErrorLog<C, S> for WarnLogger {
    type ErrorLog = WarnLoggerInstance<C, S>;
    fn construct(self) -> Self::ErrorLog {
        WarnLoggerInstance(PhantomData)
    }
}

impl<C, S> ErrorLog for WarnLoggerInstance<C, S>
    where C: fmt::Display,
          S: fmt::Display,
{
    type ConnectionError = C;
    type SinkError = S;
    fn connection_error(&self, addr: SocketAddr, e: Self::ConnectionError) {
        warn!("Connecting to {} failed: {}", addr, e);
    }
    fn sink_error(&self, addr: SocketAddr, e: Self::SinkError) {
        warn!("Connection to {} errored: {}", addr, e);
    }
    /// Starting to shut down pool
    fn pool_shutting_down(&self, reason: ShutdownReason) {
        warn!("Shutting down connection pool: {}", reason);
    }
    /// This is triggered when pool done all the work and shut down entirely
    fn pool_closed(&self) {
    }
}

impl fmt::Display for ShutdownReason {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use self::ShutdownReason::*;
        f.write_str(match *self {
            RequestStreamClosed => "request stream closed",
            AddressStreamClosed => "address stream closed",
            __Nonexhaustive => unreachable!(),
        })
    }
}