http2 0.5.16

An HTTP/2 client and server
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

mod buffer;
mod counts;
mod flow_control;
mod prioritize;
mod recv;
mod send;
mod state;
mod store;
mod stream;
#[allow(clippy::module_inception)]
mod streams;
mod sync;

pub(crate) use self::prioritize::Prioritized;
pub(crate) use self::recv::Open;
pub(crate) use self::send::PollReset;
pub(crate) use self::streams::{DynStreams, OpaqueStreamRef, StreamRef, Streams};

use self::buffer::Buffer;
use self::counts::Counts;
use self::flow_control::FlowControl;
use self::prioritize::Prioritize;
use self::recv::Recv;
use self::send::Send;
use self::state::State;
use self::store::Store;
use self::stream::Stream;

use crate::frame::{Priorities, PseudoOrder, StreamDependency, StreamId, StreamIdOverflow};
use crate::proto::*;

use bytes::Bytes;
use std::time::Duration;

#[derive(Debug)]
pub struct Config {
    /// Initial maximum number of locally initiated streams.
    /// After receiving a Settings frame from the remote peer,
    /// the connection will overwrite this value with the
    /// MAX_CONCURRENT_STREAMS specified in the frame.
    pub initial_max_send_streams: usize,

    /// Max amount of DATA bytes to buffer per stream.
    pub local_max_buffer_size: usize,

    /// The stream ID to start the next local stream with
    pub local_next_stream_id: StreamId,

    /// If the local peer is willing to receive push promises
    pub local_push_enabled: bool,

    /// If extended connect protocol is enabled.
    pub extended_connect_protocol_enabled: bool,

    /// How long a locally reset stream should ignore frames
    pub local_reset_duration: Duration,

    /// Maximum number of locally reset streams to keep at a time
    pub local_reset_max: usize,

    /// Maximum number of remotely reset "pending accept" streams to keep at a
    /// time. Going over this number results in a connection error.
    pub remote_reset_max: usize,

    /// Initial window size of remote initiated streams
    pub remote_init_window_sz: WindowSize,

    /// Maximum number of remote initiated streams
    pub remote_max_initiated: Option<usize>,

    /// Maximum number of locally reset streams due to protocol error across
    /// the lifetime of the connection.
    ///
    /// When this gets exceeded, we issue GOAWAYs.
    pub local_max_error_reset_streams: Option<usize>,

    /// Priority of the headers stream
    pub headers_stream_dependency: Option<StreamDependency>,

    /// Pseudo order of the headers stream
    pub headers_pseudo_order: Option<PseudoOrder>,

    /// Priorities stream
    pub priorities: Option<Priorities>,
}

trait DebugStructExt<'a, 'b> {
    // h2_ prefixes to protect against possible future name collisions
    fn h2_field_if(&mut self, name: &str, val: &bool) -> &mut std::fmt::DebugStruct<'a, 'b>;

    fn h2_field_if_then<T: std::fmt::Debug>(
        &mut self,
        name: &str,
        cond: bool,
        val: &T,
    ) -> &mut std::fmt::DebugStruct<'a, 'b>;

    fn h2_field_some<T: std::fmt::Debug>(
        &mut self,
        name: &str,
        val: &Option<T>,
    ) -> &mut std::fmt::DebugStruct<'a, 'b>;
}

impl<'a, 'b> DebugStructExt<'a, 'b> for std::fmt::DebugStruct<'a, 'b> {
    fn h2_field_if(&mut self, name: &str, val: &bool) -> &mut std::fmt::DebugStruct<'a, 'b> {
        if *val {
            self.field(name, val)
        } else {
            self
        }
    }

    fn h2_field_if_then<T: std::fmt::Debug>(
        &mut self,
        name: &str,
        cond: bool,
        val: &T,
    ) -> &mut std::fmt::DebugStruct<'a, 'b> {
        if cond {
            self.field(name, val)
        } else {
            self
        }
    }

    fn h2_field_some<T: std::fmt::Debug>(
        &mut self,
        name: &str,
        val: &Option<T>,
    ) -> &mut std::fmt::DebugStruct<'a, 'b> {
        if val.is_some() {
            self.field(name, val)
        } else {
            self
        }
    }
}