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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Event subscriptions.

use std::fmt;
use std::time::Duration;

/// A trait which is provided with information about events in a connection pool.
pub trait HandleEvent: fmt::Debug + Sync + Send {
    /// Called when a new connection is acquired.
    ///
    /// The default implementation does nothing.
    #[allow(unused_variables)]
    fn handle_acquire(&self, event: AcquireEvent) {}

    /// Called when a connection is released.
    ///
    /// The default implementation does nothing.
    #[allow(unused_variables)]
    fn handle_release(&self, event: ReleaseEvent) {}

    /// Called when a connection is checked out from the pool.
    ///
    /// The default implementation does nothing.
    #[allow(unused_variables)]
    fn handle_checkout(&self, event: CheckoutEvent) {}

    /// Called when a checkout attempt times out.
    ///
    /// The default implementation does nothing.
    #[allow(unused_variables)]
    fn handle_timeout(&self, event: TimeoutEvent) {}

    /// Called when a connection is checked back into the pool.
    #[allow(unused_variables)]
    fn handle_checkin(&self, event: CheckinEvent) {}
}

/// A `HandleEvent` implementation which does nothing.
#[derive(Copy, Clone, Debug)]
pub struct NopEventHandler;

impl HandleEvent for NopEventHandler {}

/// Information about an acquire event.
#[derive(Debug)]
pub struct AcquireEvent {
    pub(crate) id: u64,
}

impl AcquireEvent {
    /// Returns the ID of the connection.
    #[inline]
    pub fn connection_id(&self) -> u64 {
        self.id
    }
}

/// Information about a release event.
#[derive(Debug)]
pub struct ReleaseEvent {
    pub(crate) id: u64,
    pub(crate) age: Duration,
}

impl ReleaseEvent {
    /// Returns the ID of the connection.
    #[inline]
    pub fn connection_id(&self) -> u64 {
        self.id
    }

    /// Returns the age of the connection.
    #[inline]
    pub fn age(&self) -> Duration {
        self.age
    }
}

/// Information about a checkout event.
#[derive(Debug)]
pub struct CheckoutEvent {
    pub(crate) id: u64,
    pub(crate) duration: Duration,
}

impl CheckoutEvent {
    /// Returns the ID of the connection.
    #[inline]
    pub fn connection_id(&self) -> u64 {
        self.id
    }

    /// Returns the time taken to check out the connection.
    #[inline]
    pub fn duration(&self) -> Duration {
        self.duration
    }
}

/// Information about a timeout event.
#[derive(Debug)]
pub struct TimeoutEvent {
    pub(crate) timeout: Duration,
}

impl TimeoutEvent {
    /// Returns the timeout of the failed checkout attempt.
    #[inline]
    pub fn timeout(&self) -> Duration {
        self.timeout
    }
}

/// Information about a checkin event.
#[derive(Debug)]
pub struct CheckinEvent {
    pub(crate) id: u64,
    pub(crate) duration: Duration,
}

impl CheckinEvent {
    /// Returns the ID of the connection.
    #[inline]
    pub fn connection_id(&self) -> u64 {
        self.id
    }

    /// Returns the amount of time the connection was checked out.
    #[inline]
    pub fn duration(&self) -> Duration {
        self.duration
    }
}