Refactor limited requester
The requester does not need to be instantiated anymore, which makes things easier to read imo.
This commit is contained in:
parent
75da26a7a3
commit
98a043ab30
|
@ -15,7 +15,7 @@ impl Instance {
|
|||
&mut self,
|
||||
login_schema: &LoginSchema,
|
||||
) -> Result<UserMeta, ChorusLibError> {
|
||||
let mut requester = LimitedRequester::new().await;
|
||||
let mut requester = LimitedRequester;
|
||||
let json_schema = json!(login_schema);
|
||||
let client = Client::new();
|
||||
let endpoint_url = self.urls.get_api().to_string() + "/auth/login";
|
||||
|
@ -24,8 +24,7 @@ impl Instance {
|
|||
// request (since login is an instance wide limit), which is why we are just cloning the
|
||||
// instances' limits to pass them on as user_rate_limits later.
|
||||
let mut cloned_limits = self.limits.clone();
|
||||
let response = requester
|
||||
.send_request(
|
||||
let response = LimitedRequester::send_request(
|
||||
request_builder,
|
||||
LimitType::AuthRegister,
|
||||
&mut self.limits,
|
||||
|
|
|
@ -24,7 +24,6 @@ impl Instance {
|
|||
register_schema: &RegisterSchema,
|
||||
) -> Result<UserMeta, ChorusLibError> {
|
||||
let json_schema = json!(register_schema);
|
||||
let mut limited_requester = LimitedRequester::new().await;
|
||||
let client = Client::new();
|
||||
let endpoint_url = self.urls.get_api().to_string() + "/auth/register";
|
||||
let request_builder = client.post(endpoint_url).body(json_schema.to_string());
|
||||
|
@ -32,8 +31,7 @@ impl Instance {
|
|||
// request (since register is an instance wide limit), which is why we are just cloning
|
||||
// the instances' limits to pass them on as user_rate_limits later.
|
||||
let mut cloned_limits = self.limits.clone();
|
||||
let response = limited_requester
|
||||
.send_request(
|
||||
let response = LimitedRequester::send_request(
|
||||
request_builder,
|
||||
LimitType::AuthRegister,
|
||||
&mut self.limits,
|
||||
|
|
|
@ -13,9 +13,7 @@ pub async fn handle_request(
|
|||
limit_type: LimitType,
|
||||
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
|
||||
let mut belongs_to = user.belongs_to.borrow_mut();
|
||||
match LimitedRequester::new()
|
||||
.await
|
||||
.send_request(
|
||||
match LimitedRequester::send_request(
|
||||
request,
|
||||
limit_type,
|
||||
&mut belongs_to.limits,
|
||||
|
|
|
@ -180,9 +180,7 @@ impl Guild {
|
|||
let request = Client::new()
|
||||
.get(format!("{}/guilds/{}/", url_api, guild_id))
|
||||
.bearer_auth(token);
|
||||
let response = match LimitedRequester::new()
|
||||
.await
|
||||
.send_request(
|
||||
let response = match LimitedRequester::send_request(
|
||||
request,
|
||||
crate::api::limits::LimitType::Guild,
|
||||
limits_instance,
|
||||
|
@ -242,9 +240,7 @@ impl Channel {
|
|||
.post(format!("{}/guilds/{}/channels/", url_api, guild_id))
|
||||
.bearer_auth(token)
|
||||
.body(to_string(&schema).unwrap());
|
||||
let mut requester = LimitedRequester::new().await;
|
||||
let result = match requester
|
||||
.send_request(
|
||||
let result = match LimitedRequester::send_request(
|
||||
request,
|
||||
crate::api::limits::LimitType::Guild,
|
||||
limits_instance,
|
||||
|
|
|
@ -110,10 +110,8 @@ impl User {
|
|||
url = format!("{}/users/{}", url_api, id.unwrap());
|
||||
}
|
||||
let request = reqwest::Client::new().get(url).bearer_auth(token);
|
||||
let mut requester = crate::limit::LimitedRequester::new().await;
|
||||
let mut cloned_limits = limits_instance.clone();
|
||||
match requester
|
||||
.send_request(
|
||||
match LimitedRequester::send_request(
|
||||
request,
|
||||
crate::api::limits::LimitType::Ip,
|
||||
limits_instance,
|
||||
|
@ -138,9 +136,7 @@ impl User {
|
|||
.get(format!("{}/users/@me/settings/", url_api))
|
||||
.bearer_auth(token);
|
||||
let mut cloned_limits = instance_limits.clone();
|
||||
let mut requester = crate::limit::LimitedRequester::new().await;
|
||||
match requester
|
||||
.send_request(
|
||||
match LimitedRequester::send_request(
|
||||
request,
|
||||
crate::api::limits::LimitType::Ip,
|
||||
instance_limits,
|
||||
|
|
55
src/limit.rs
55
src/limit.rs
|
@ -1,5 +1,3 @@
|
|||
use std::collections::VecDeque;
|
||||
|
||||
use reqwest::{Client, RequestBuilder, Response};
|
||||
|
||||
use crate::{
|
||||
|
@ -18,24 +16,9 @@ pub struct TypedRequest {
|
|||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct LimitedRequester {
|
||||
http: Client,
|
||||
requests: VecDeque<TypedRequest>,
|
||||
}
|
||||
pub struct LimitedRequester;
|
||||
|
||||
impl LimitedRequester {
|
||||
/// Create a new `LimitedRequester`. `LimitedRequester`s use a `VecDeque` to store requests and
|
||||
/// send them to the server using a `Client`. It keeps track of the remaining requests that can
|
||||
/// be send within the `Limit` of an external API Ratelimiter, and looks at the returned request
|
||||
/// headers to see if it can find Ratelimit info to update itself.
|
||||
#[allow(dead_code)]
|
||||
pub async fn new() -> Self {
|
||||
LimitedRequester {
|
||||
http: Client::new(),
|
||||
requests: VecDeque::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
# send_request
|
||||
Checks, if a request can be sent without hitting API rate limits and sends it, if true.
|
||||
|
@ -67,13 +50,12 @@ impl LimitedRequester {
|
|||
methods' Errors section for more information.
|
||||
*/
|
||||
pub async fn send_request(
|
||||
&mut self,
|
||||
request: RequestBuilder,
|
||||
limit_type: LimitType,
|
||||
instance_rate_limits: &mut Limits,
|
||||
user_rate_limits: &mut Limits,
|
||||
) -> Result<Response, ChorusLibError> {
|
||||
if self.can_send_request(limit_type, instance_rate_limits, user_rate_limits) {
|
||||
if LimitedRequester::can_send_request(limit_type, instance_rate_limits, user_rate_limits) {
|
||||
let built_request = match request.build() {
|
||||
Ok(request) => request,
|
||||
Err(e) => {
|
||||
|
@ -83,7 +65,7 @@ impl LimitedRequester {
|
|||
});
|
||||
}
|
||||
};
|
||||
let result = self.http.execute(built_request).await;
|
||||
let result = Client::new().execute(built_request).await;
|
||||
let response = match result {
|
||||
Ok(is_response) => is_response,
|
||||
Err(e) => {
|
||||
|
@ -92,7 +74,7 @@ impl LimitedRequester {
|
|||
});
|
||||
}
|
||||
};
|
||||
self.update_limits(
|
||||
LimitedRequester::update_limits(
|
||||
&response,
|
||||
limit_type,
|
||||
instance_rate_limits,
|
||||
|
@ -112,10 +94,6 @@ impl LimitedRequester {
|
|||
Ok(response)
|
||||
}
|
||||
} else {
|
||||
self.requests.push_back(TypedRequest {
|
||||
request,
|
||||
limit_type,
|
||||
});
|
||||
Err(ChorusLibError::RateLimited {
|
||||
bucket: limit_type.to_string(),
|
||||
})
|
||||
|
@ -134,7 +112,6 @@ impl LimitedRequester {
|
|||
}
|
||||
|
||||
fn can_send_request(
|
||||
&mut self,
|
||||
limit_type: LimitType,
|
||||
instance_rate_limits: &Limits,
|
||||
user_rate_limits: &Limits,
|
||||
|
@ -185,7 +162,6 @@ impl LimitedRequester {
|
|||
}
|
||||
|
||||
fn update_limits(
|
||||
&mut self,
|
||||
response: &Response,
|
||||
limit_type: LimitType,
|
||||
instance_rate_limits: &mut Limits,
|
||||
|
@ -286,16 +262,6 @@ mod rate_limit {
|
|||
|
||||
use super::*;
|
||||
|
||||
#[tokio::test]
|
||||
async fn create_limited_requester() {
|
||||
let _urls = URLBundle::new(
|
||||
String::from("http://localhost:3001/api/"),
|
||||
String::from("wss://localhost:3001/"),
|
||||
String::from("http://localhost:3001/cdn"),
|
||||
);
|
||||
let _requester = LimitedRequester::new().await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn run_into_limit() {
|
||||
let urls = URLBundle::new(
|
||||
|
@ -303,17 +269,15 @@ mod rate_limit {
|
|||
String::from("wss://localhost:3001/"),
|
||||
String::from("http://localhost:3001/cdn"),
|
||||
);
|
||||
let mut requester = LimitedRequester::new().await;
|
||||
let mut request: Option<Result<Response, ChorusLibError>> = None;
|
||||
let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await;
|
||||
let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await;
|
||||
|
||||
for _ in 0..=50 {
|
||||
let request_path = urls.api.clone() + "/some/random/nonexisting/path";
|
||||
let request_builder = requester.http.get(request_path);
|
||||
let request_builder = Client::new().get(request_path);
|
||||
request = Some(
|
||||
requester
|
||||
.send_request(
|
||||
LimitedRequester::send_request(
|
||||
request_builder,
|
||||
LimitType::Channel,
|
||||
&mut instance_rate_limits,
|
||||
|
@ -341,11 +305,10 @@ mod rate_limit {
|
|||
);
|
||||
let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await;
|
||||
let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await;
|
||||
let mut requester = LimitedRequester::new().await;
|
||||
let mut requester = LimitedRequester;
|
||||
let request_path = urls.api.clone() + "/policies/instance/limits";
|
||||
let request_builder = requester.http.get(request_path);
|
||||
let request = requester
|
||||
.send_request(
|
||||
let request_builder = Client::new().get(request_path);
|
||||
let request = LimitedRequester::send_request(
|
||||
request_builder,
|
||||
LimitType::Channel,
|
||||
&mut instance_rate_limits,
|
||||
|
|
Loading…
Reference in New Issue