kozabrada123/chorus
kozabrada123
/
chorus
mirror of https://github.com/polyphony-chat/chorus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #105 from polyphony-chat/refactor/limited-requester 

Refactor/limited requester
This commit is contained in:
Flori 2023-06-12 19:02:36 +02:00 committed by GitHub
parent 75da26a7a3 8de2d3b5c3
commit 77c1b2052e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 72 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/api/auth/login.rs
View File

@ -15,7 +15,6 @@ impl Instance {
&mut self,
login_schema: &LoginSchema,
) -> Result<UserMeta, ChorusLibError> {
let mut requester = LimitedRequester::new().await;
let json_schema = json!(login_schema);
let client = Client::new();
let endpoint_url = self.urls.get_api().to_string() + "/auth/login";
@ -24,8 +23,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,

4
src/api/auth/register.rs
View File

@ -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,

1
src/api/channels/permissions.rs
View File

@ -5,7 +5,6 @@ use crate::{
api::handle_request,
errors::ChorusLibError,
instance::UserMeta,
limit::LimitedRequester,
types::{self, PermissionOverwrite},
};

4
src/api/common.rs
View File

@ -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,

8
src/api/guilds/guilds.rs
View File

@ -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,

2
src/api/guilds/member.rs
View File

@ -1,11 +1,9 @@
use reqwest::Client;
use serde_json::from_str;
use crate::{
api::{deserialize_response, handle_request_as_option},
errors::ChorusLibError,
instance::UserMeta,
limit::LimitedRequester,
types,
};

3
src/api/guilds/roles.rs
View File

@ -1,11 +1,10 @@
use reqwest::Client;
use serde_json::{from_str, to_string};
use serde_json::to_string;
use crate::{
api::deserialize_response,
errors::ChorusLibError,
instance::UserMeta,
limit::LimitedRequester,
types::{self, RoleCreateModifySchema, RoleObject},
};

10
src/api/users/users.rs
View File

@ -1,5 +1,5 @@
use reqwest::Client;
use serde_json::{from_str, to_string};
use serde_json::to_string;
use crate::{
api::{deserialize_response, handle_request_as_option, limits::Limits},
@ -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
View File

@ -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 _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,