asknothingx2-util 0.5.0

asknothing
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use reqwest::{redirect::Policy, tls};

/// **Default Security Profile (strict_1_2):**
/// - Cookies: Not saved, Referer: Not sent
/// - TLS: 1.2+ minimum required
/// - Redirects: Up to 3 allowed
#[derive(Debug)]
pub struct SecurityProfile {
    pub save_cookies: bool,
    pub send_referer: bool,
    pub min_tls_version: Option<tls::Version>,
    pub redirect: Policy,
}

impl SecurityProfile {
    /// - Cookies: Not saved, Referer: Not sent
    /// - TLS: 1.3+ minimum
    /// - Redirects: Up to 3 allowed
    pub fn strict_1_3() -> Self {
        Self {
            save_cookies: false,
            send_referer: false,
            min_tls_version: Some(tls::Version::TLS_1_3),
            redirect: Policy::limited(3),
        }
    }

    /// - Cookies: Not saved, Referer: Not sent
    /// - TLS: 1.2+ minimum
    /// - Redirects: Up to 3 allowed
    pub fn strict_1_2() -> Self {
        Self {
            save_cookies: false,
            send_referer: false,
            min_tls_version: Some(tls::Version::TLS_1_2),
            redirect: Policy::limited(3),
        }
    }

    /// - Cookies: Saved, Referer: Sent
    /// - TLS: 1.2+ minimum
    /// - Redirects: Up to 10 allowed
    pub fn permissive() -> Self {
        Self {
            save_cookies: true,
            send_referer: true,
            min_tls_version: Some(tls::Version::TLS_1_2),
            redirect: Policy::limited(10),
        }
    }

    /// - Cookies: Not saved, Referer: Not sent
    /// - TLS: No minimum version
    /// - Redirects: Up to 3 allowed
    pub fn test() -> Self {
        Self {
            save_cookies: false,
            send_referer: false,
            min_tls_version: None,
            redirect: Policy::limited(3),
        }
    }

    /// - Cookies: Saved, Referer: Sent
    /// - TLS: No minimum version
    /// - Redirects: Up to 15 allowed
    pub fn debug() -> Self {
        Self {
            save_cookies: true,
            send_referer: true,
            min_tls_version: None,
            redirect: Policy::limited(15),
        }
    }

    pub fn redirect(mut self, policy: Policy) -> Self {
        self.redirect = policy;
        self
    }
}

impl Default for SecurityProfile {
    fn default() -> Self {
        Self::strict_1_2()
    }
}

/// HTTP/2 protocol tuning parameters for performance optimization.
///
/// Controls flow control windows, frame sizes, and adaptive algorithms to optimize
/// HTTP/2 performance for different use cases from low-latency real-time applications
/// to high-throughput batch processing.
///
/// **Default Configuration:**
/// - Stream window: 64KB (good for most use cases)
/// - Connection window: 1MB (allows multiple concurrent streams)
/// - Frame size: 16KB (HTTP/2 default)
/// - Adaptive window: Enabled (automatically tunes flow control)
///
/// # Performance Profiles
///
/// - **Low latency**: Small windows, disabled adaptive algorithms
/// - **High throughput**: Large windows, enabled adaptive algorithms  
/// - **Real-time**: Minimal buffering, predictable flow control
/// - **Batch processing**: Maximum windows for bulk transfers
///
#[derive(Debug)]
pub struct Http2Settings {
    pub initial_stream_window_size: u32,
    pub initial_connection_window_size: u32,
    pub max_frame_size: u32,
    pub adaptive_window: bool,
}

impl Default for Http2Settings {
    fn default() -> Self {
        Self {
            initial_stream_window_size: 65_536,
            initial_connection_window_size: 1_048_576,
            max_frame_size: 16_384,
            adaptive_window: true,
        }
    }
}

impl Http2Settings {
    /// Create custom HTTP/2 tuning parameters.
    ///
    /// # Parameters
    ///
    /// - `initial_stream_window_size`: Per-stream buffer size (bytes)
    /// - `initial_connection_window_size`: Total connection buffer size (bytes)
    /// - `max_frame_size`: Maximum frame size (bytes, 16KB to 16MB)
    /// - `adaptive_window`: Enable automatic window size adjustment
    ///
    pub fn new(
        initial_stream_window_size: u32,
        initial_connection_window_size: u32,
        max_frame_size: u32,
        adaptive_window: bool,
    ) -> Self {
        Self {
            initial_stream_window_size,
            initial_connection_window_size,
            max_frame_size,
            adaptive_window,
        }
    }
}