openwire-core 0.1.0

Shared primitives, policies, bodies, and transport traits for OpenWire
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::sync::Arc;

use http::{Method, StatusCode, Uri};

use crate::WireError;

pub trait RetryPolicy: Send + Sync + 'static {
    fn should_retry(&self, ctx: &RetryContext<'_>) -> Option<&'static str>;
}

impl<T> RetryPolicy for Arc<T>
where
    T: RetryPolicy + ?Sized,
{
    fn should_retry(&self, ctx: &RetryContext<'_>) -> Option<&'static str> {
        (**self).should_retry(ctx)
    }
}

pub struct RetryContext<'a> {
    error: &'a WireError,
    attempt: u32,
    is_body_replayable: bool,
    request_method: &'a Method,
}

impl<'a> RetryContext<'a> {
    pub fn new(
        error: &'a WireError,
        attempt: u32,
        is_body_replayable: bool,
        request_method: &'a Method,
    ) -> Self {
        Self {
            error,
            attempt,
            is_body_replayable,
            request_method,
        }
    }

    pub fn error(&self) -> &'a WireError {
        self.error
    }

    pub fn attempt(&self) -> u32 {
        self.attempt
    }

    pub fn is_body_replayable(&self) -> bool {
        self.is_body_replayable
    }

    pub fn request_method(&self) -> &'a Method {
        self.request_method
    }
}

pub trait RedirectPolicy: Send + Sync + 'static {
    fn should_redirect(&self, ctx: &RedirectContext<'_>) -> RedirectDecision;
}

impl<T> RedirectPolicy for Arc<T>
where
    T: RedirectPolicy + ?Sized,
{
    fn should_redirect(&self, ctx: &RedirectContext<'_>) -> RedirectDecision {
        (**self).should_redirect(ctx)
    }
}

pub struct RedirectContext<'a> {
    request_method: &'a Method,
    request_uri: &'a Uri,
    response_status: StatusCode,
    location: &'a Uri,
    redirect_count: u32,
    is_body_replayable: bool,
}

impl<'a> RedirectContext<'a> {
    pub fn new(
        request_method: &'a Method,
        request_uri: &'a Uri,
        response_status: StatusCode,
        location: &'a Uri,
        redirect_count: u32,
        is_body_replayable: bool,
    ) -> Self {
        Self {
            request_method,
            request_uri,
            response_status,
            location,
            redirect_count,
            is_body_replayable,
        }
    }

    pub fn request_method(&self) -> &'a Method {
        self.request_method
    }

    pub fn request_uri(&self) -> &'a Uri {
        self.request_uri
    }

    pub fn response_status(&self) -> StatusCode {
        self.response_status
    }

    pub fn location(&self) -> &'a Uri {
        self.location
    }

    pub fn redirect_count(&self) -> u32 {
        self.redirect_count
    }

    pub fn is_body_replayable(&self) -> bool {
        self.is_body_replayable
    }
}

pub enum RedirectDecision {
    Follow,
    Stop,
    Error(WireError),
}