leyline-http 0.1.1

HTTP client that mimics browsers on the wire
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::sync::Arc;

use super::{BodyEnd, Connect, Dns, Done, Head, Sent, Summary, Tls, Trace};

#[derive(Clone, Default)]
pub struct Fanout {
    hooks: Vec<Arc<dyn Trace>>,
}

impl std::fmt::Debug for Fanout {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Fanout")
            .field("hooks", &self.hooks.len())
            .finish()
    }
}

impl Fanout {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with(mut self, hook: impl Trace) -> Self {
        self.hooks.push(Arc::new(hook));
        self
    }

    fn each(&self, emit: impl Fn(&dyn Trace)) {
        for hook in &self.hooks {
            emit(hook.as_ref());
        }
    }
}

impl Trace for Fanout {
    fn dns(&self, ev: &Dns<'_>) {
        self.each(|hook| hook.dns(ev));
    }

    fn connect(&self, ev: &Connect<'_>) {
        self.each(|hook| hook.connect(ev));
    }

    fn tls(&self, ev: &Tls<'_>) {
        self.each(|hook| hook.tls(ev));
    }

    fn sent(&self, ev: &Sent<'_>) {
        self.each(|hook| hook.sent(ev));
    }

    fn head(&self, ev: &Head<'_>) {
        self.each(|hook| hook.head(ev));
    }

    fn done(&self, ev: &Done<'_>) {
        self.each(|hook| hook.done(ev));
    }

    fn summary(&self, ev: &Summary<'_>) {
        self.each(|hook| hook.summary(ev));
    }

    fn body(&self, ev: &BodyEnd<'_>) {
        self.each(|hook| hook.body(ev));
    }
}