tower-http-cache-plus 0.0.2

HTTP response caching middleware with integrated compression
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

use super::super::{configuration::*, hooks::*};

use {
    http::{header::*, *},
    kutil::{http::*, transcoding::*},
};

//
// UpstreamResponse
//

/// Upstream response.
pub trait UpstreamResponse<ResponseBodyT> {
    /// Check if we should skip the cache.
    ///
    /// Also returns the value of `Content-Length` if available.
    ///
    /// If the response passes all our checks then we turn to the hook to give it one last chance
    /// to skip the cache.
    fn should_skip_cache<RequestBodyT, CacheT, CacheKeyT>(
        &self,
        uri: &Uri,
        configuration: &MiddlewareCachingConfiguration<CacheT, CacheKeyT, RequestBodyT>,
    ) -> (bool, Option<usize>);

    /// Validate encoding.
    ///
    /// Checks `content_length`, if provided, against `min_body_size`. And gives the hook one last
    /// chance to skip encoding.
    ///
    /// Will return true if we are forcing a skip.
    fn validate_encoding(
        &self,
        uri: &Uri,
        encoding: Encoding,
        content_length: Option<usize>,
        configuration: &MiddlewareEncodingConfiguration,
    ) -> (Encoding, bool);
}

impl<ResponseBodyT> UpstreamResponse<ResponseBodyT> for Response<ResponseBodyT> {
    fn should_skip_cache<RequestBodyT, CacheT, CacheKeyT>(
        &self,
        uri: &Uri,
        configuration: &MiddlewareCachingConfiguration<CacheT, CacheKeyT, RequestBodyT>,
    ) -> (bool, Option<usize>) {
        let headers = self.headers();
        let status = self.status();

        let mut skip_cache = if !headers.xx_cache(configuration.inner.cacheable_by_default) {
            tracing::debug!("skip ({}=false)", XX_CACHE);
            (true, None)
        } else if !status.is_success() {
            tracing::debug!("skip (status={})", status.as_u16());
            (true, None)
        } else if headers.contains_key(CONTENT_RANGE) {
            tracing::debug!("skip (range)");
            (true, None)
        } else {
            match headers.content_length() {
                Some(content_length) => {
                    if content_length < configuration.inner.min_body_size {
                        tracing::debug!("skip (Content-Length too small)");
                        (true, Some(content_length))
                    } else if content_length > configuration.inner.max_body_size {
                        tracing::debug!("skip (Content-Length too big)");
                        (true, Some(content_length))
                    } else {
                        (false, Some(content_length))
                    }
                }

                None => (false, None),
            }
        };

        if !skip_cache.0
            && let Some(cacheable) = &configuration.cacheable_by_response
            && !cacheable(CacheableHookContext::new(uri, headers))
        {
            tracing::debug!("skip (cacheable_by_response=false)");
            skip_cache.0 = true;
        }

        skip_cache
    }

    fn validate_encoding(
        &self,
        uri: &Uri,
        encoding: Encoding,
        content_length: Option<usize>,
        configuration: &MiddlewareEncodingConfiguration,
    ) -> (Encoding, bool) {
        if encoding == Encoding::Identity {
            (encoding, false)
        } else {
            if let Some(content_length) = content_length {
                let min_body_size = configuration.inner.min_body_size;
                if min_body_size != 0 {
                    if content_length < min_body_size {
                        tracing::debug!("not encoding to {} (too small)", encoding);
                        return (Encoding::Identity, true);
                    }
                }
            }

            match &configuration.encodable_by_response {
                Some(encodable) => {
                    if encodable(EncodableHookContext::new(&encoding, uri, self.headers())) {
                        (encoding, false)
                    } else {
                        tracing::debug!(
                            "not encoding to {} (encodable_by_response=false)",
                            encoding
                        );
                        (Encoding::Identity, true)
                    }
                }

                None => (encoding, false),
            }
        }
    }
}