hyper-client-pool 0.6.0

Pooled Hyper Async Clients
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

use std::io;

use crate::deliverable::Deliverable;
use crate::transaction::Transaction;

/// Error when spawning and configuring the thread that the [`hyper::Client`]s run on.
#[derive(Debug)]
pub enum SpawnError {
    ThreadSpawn(io::Error),
    HttpsConnector(native_tls::Error),
}

impl PartialEq for SpawnError {
    fn eq(&self, other: &SpawnError) -> bool {
        match self {
            SpawnError::ThreadSpawn(_err) => match other {
                SpawnError::ThreadSpawn(_oerr) => true,
                _ => false,
            },
            SpawnError::HttpsConnector(_err) => match other {
                SpawnError::HttpsConnector(_oerr) => true,
                _ => false,
            },
        }
    }
}

impl From<native_tls::Error> for SpawnError {
    fn from(err: native_tls::Error) -> SpawnError {
        SpawnError::HttpsConnector(err)
    }
}

/// An error returned when requesting a Transaction.
#[derive(Debug)]
pub struct Error<D: Deliverable> {
    pub kind: ErrorKind,
    transaction: Transaction<D>,
}

impl<D: Deliverable> Error<D> {
    pub(crate) fn new(kind: ErrorKind, transaction: Transaction<D>) -> Error<D> {
        Error { kind, transaction }
    }

    pub fn into_inner(self) -> Transaction<D> {
        self.transaction
    }
}

/// Types of errors that can occur when requesting.
/// A [`SpawnError`] can occur when requesting a Transaction as a new thread may need
/// spawned if a previous one was lost / invalidated.
#[derive(Debug, PartialEq)]
pub enum ErrorKind {
    /// An error occurred when spawning and configuring a new thread for a hyper::Client
    Spawn(SpawnError),
    /// There is no room for another transaction right now, the pool is full.
    PoolFull,
}

/// Type of errors that can occur when attempting to send a [`Transaction`]
/// to an [`Executor`].
pub(crate) enum RequestError<D: Deliverable> {
    PoolFull(Transaction<D>),
    FailedSend(Transaction<D>),
}