-
Notifications
You must be signed in to change notification settings - Fork 562
/
ratelimiting.rs
250 lines (222 loc) · 8.26 KB
/
ratelimiting.rs
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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
//! Routes are used for ratelimiting. These are to differentiate between the
//! different _types_ of routes - such as getting the current user's channels -
//! for the most part, with the exception being major parameters.
//!
//! [Taken from] the Discord docs, major parameters are:
//!
//! > Additionally, rate limits take into account major parameters in the URL.
//! > For example, `/channels/:channel_id` and
//! > `/channels/:channel_id/messages/:message_id` both take `channel_id` into
//! > account when generating rate limits since it's the major parameter. The
//! only current major parameters are `channel_id` and `guild_id`.
//!
//! This results in the two URIs of `GET /channels/4/messages/7` and
//! `GET /channels/5/messages/8` being rate limited _separately_. However, the
//! two URIs of `GET /channels/10/messages/11` and
//! `GET /channels/10/messages/12` will count towards the "same ratelimit", as
//! the major parameter - `10` is equivalent in both URIs' format.
//!
//! # Examples
//!
//! First: taking the first two URIs - `GET /channels/4/messages/7` and
//! `GET /channels/5/messages/8` - and assuming both buckets have a `limit` of
//! `10`, requesting the first URI will result in the response containing a
//! `remaining` of `9`. Immediately after - prior to buckets resetting -
//! performing a request to the _second_ URI will also contain a `remaining` of
//! `9` in the response, as the major parameter - `channel_id` - is different
//! in the two requests (`4` and `5`).
//!
//! Second: take for example the last two URIs. Assuming the bucket's `limit` is
//! `10`, requesting the first URI will return a `remaining` of `9` in the
//! response. Immediately after - prior to buckets resetting - performing a
//! request to the _second_ URI will return a `remaining` of `8` in the
//! response, as the major parameter - `channel_id` - is equivalent for the two
//! requests (`10`).
//!
//!
//! With the examples out of the way: major parameters are why some variants
//! (i.e. all of the channel/guild variants) have an associated u64 as data.
//! This is the Id of the parameter, differentiating between different
//! ratelimits.
use hyper::client::{RequestBuilder, Response};
use hyper::header::Headers;
use hyper::status::StatusCode;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::Duration;
use std::{str, thread};
use time;
use ::internal::prelude::*;
lazy_static! {
static ref GLOBAL: Arc<Mutex<()>> = Arc::new(Mutex::new(()));
static ref ROUTES: Arc<Mutex<HashMap<Route, RateLimit>>> = Arc::new(Mutex::new(HashMap::default()));
}
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum Route {
ChannelsId(u64),
ChannelsIdInvites(u64),
ChannelsIdMessages(u64),
ChannelsIdMessagesBulkDelete(u64),
ChannelsIdMessagesId(u64),
ChannelsIdMessagesIdAck(u64),
ChannelsIdMessagesIdReactions(u64),
ChannelsIdMessagesIdReactionsUserIdType(u64),
ChannelsIdMessagesSearch(u64),
ChannelsIdPermissionsOverwriteId(u64),
ChannelsIdPins(u64),
ChannelsIdPinsMessageId(u64),
ChannelsIdTyping(u64),
ChannelsIdWebhooks(u64),
Gateway,
GatewayBot,
Guilds,
GuildsId(u64),
GuildsIdBans(u64),
GuildsIdBansUserId(u64),
GuildsIdChannels(u64),
GuildsIdEmbed(u64),
GuildsIdEmojis(u64),
GuildsIdEmojisId(u64),
GuildsIdIntegrations(u64),
GuildsIdIntegrationsId(u64),
GuildsIdIntegrationsIdSync(u64),
GuildsIdInvites(u64),
GuildsIdMembers(u64),
GuildsIdMembersId(u64),
GuildsIdMembersIdRolesId(u64),
GuildsIdMembersMeNick(u64),
GuildsIdMessagesSearch(u64),
GuildsIdPrune(u64),
GuildsIdRegions(u64),
GuildsIdRoles(u64),
GuildsIdRolesId(u64),
GuildsIdWebhooks(u64),
InvitesCode,
UsersId,
UsersMe,
UsersMeChannels,
UsersMeConnections,
UsersMeGuilds,
UsersMeGuildsId,
VoiceRegions,
WebhooksId,
None,
}
pub fn perform<'a, F>(route: Route, f: F) -> Result<Response>
where F: Fn() -> RequestBuilder<'a> {
loop {
{
// This will block if another thread already has the global
// unlocked already (due to receiving an x-ratelimit-global).
let mut _global = GLOBAL.lock().expect("global route lock poisoned");
}
// Perform pre-checking here:
//
// - get the route's relevant rate
// - sleep if that route's already rate-limited until the end of the
// 'reset' time;
// - get the global rate;
// - sleep if there is 0 remaining
// - then, perform the request
if route != Route::None {
if let Some(route) = ROUTES.lock().expect("routes poisoned").get_mut(&route) {
route.pre_hook();
}
}
let response = super::retry(&f)?;
// Check if the request got ratelimited by checking for status 429,
// and if so, sleep for the value of the header 'retry-after' -
// which is in milliseconds - and then `continue` to try again
//
// If it didn't ratelimit, subtract one from the RateLimit's
// 'remaining'
//
// Update the 'reset' with the value of the 'x-ratelimit-reset'
// header
//
// It _may_ be possible for the limit to be raised at any time,
// so check if it did from the value of the 'x-ratelimit-limit'
// header. If the limit was 5 and is now 7, add 2 to the 'remaining'
if route != Route::None {
let redo = if response.headers.get_raw("x-ratelimit-global").is_some() {
let _ = GLOBAL.lock().expect("global route lock poisoned");
Ok(if let Some(retry_after) = get_header(&response.headers, "retry-after")? {
debug!("Ratelimited: {:?}ms", retry_after);
thread::sleep(Duration::from_millis(retry_after as u64));
true
} else {
false
})
} else {
ROUTES.lock()
.expect("routes poisoned")
.entry(route)
.or_insert_with(RateLimit::default)
.post_hook(&response)
};
if redo.unwrap_or(false) {
continue;
}
}
return Ok(response);
}
}
#[derive(Clone, Debug, Default)]
pub struct RateLimit {
limit: i64,
remaining: i64,
reset: i64,
}
impl RateLimit {
pub fn pre_hook(&mut self) {
if self.limit == 0 {
return;
}
let current_time = time::get_time().sec;
// The reset was in the past, so we're probably good.
if current_time > self.reset {
self.remaining = self.limit;
return;
}
let diff = (self.reset - current_time) as u64;
if self.remaining == 0 {
let delay = (diff * 1000) + 500;
debug!("Pre-emptive ratelimit for {:?}ms", delay);
thread::sleep(Duration::from_millis(delay));
return;
}
self.remaining -= 1;
}
pub fn post_hook(&mut self, response: &Response) -> Result<bool> {
if let Some(limit) = get_header(&response.headers, "x-ratelimit-limit")? {
self.limit = limit;
}
if let Some(remaining) = get_header(&response.headers, "x-ratelimit-remaining")? {
self.remaining = remaining;
}
if let Some(reset) = get_header(&response.headers, "x-ratelimit-reset")? {
self.reset = reset;
}
Ok(if response.status != StatusCode::TooManyRequests {
false
} else if let Some(retry_after) = get_header(&response.headers, "retry-after")? {
debug!("Ratelimited: {:?}ms", retry_after);
thread::sleep(Duration::from_millis(retry_after as u64));
true
} else {
false
})
}
}
fn get_header(headers: &Headers, header: &str) -> Result<Option<i64>> {
match headers.get_raw(header) {
Some(header) => match str::from_utf8(&header[0]) {
Ok(v) => match v.parse::<i64>() {
Ok(v) => Ok(Some(v)),
Err(_) => Err(Error::Client(ClientError::RateLimitI64)),
},
Err(_) => Err(Error::Client(ClientError::RateLimitUtf8)),
},
None => Ok(None),
}
}