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

Refactor limited requester 

The requester does not need to be instantiated anymore, which makes things easier to read imo.
This commit is contained in:
bitfl0wer 2023-06-12 18:51:54 +02:00
parent 22a957a64f
commit 44224cb478
6 changed files with 71 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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,14 +24,13 @@ 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(
request_builder,
LimitType::AuthRegister,
&mut self.limits,
&mut cloned_limits,
)
.await;
let response = LimitedRequester::send_request(
request_builder,
LimitType::AuthRegister,
&mut self.limits,
&mut cloned_limits,
)
.await;
if response.is_err() {
return Err(ChorusLibError::NoResponse);
}

16
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,14 +31,13 @@ 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(
request_builder,
LimitType::AuthRegister,
&mut self.limits,
&mut cloned_limits,
)
.await;
let response = LimitedRequester::send_request(
request_builder,
LimitType::AuthRegister,
&mut self.limits,
&mut cloned_limits,
)
.await;
if response.is_err() {
return Err(ChorusLibError::NoResponse);
}

16
src/api/common.rs
View File

@ -13,15 +13,13 @@ 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(
request,
limit_type,
&mut belongs_to.limits,
&mut user.limits,
)
.await
match LimitedRequester::send_request(
request,
limit_type,
&mut belongs_to.limits,
&mut user.limits,
)
.await
{
Ok(response) => return Ok(response),
Err(e) => return Err(e),

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

@ -180,15 +180,13 @@ impl Guild {
let request = Client::new()
.get(format!("{}/guilds/{}/", url_api, guild_id))
.bearer_auth(token);
let response = match LimitedRequester::new()
.await
.send_request(
request,
crate::api::limits::LimitType::Guild,
limits_instance,
limits_user,
)
.await
let response = match LimitedRequester::send_request(
request,
crate::api::limits::LimitType::Guild,
limits_instance,
limits_user,
)
.await
{
Ok(response) => response,
Err(e) => return Err(e),
@ -242,15 +240,13 @@ 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(
request,
crate::api::limits::LimitType::Guild,
limits_instance,
limits_user,
)
.await
let result = match LimitedRequester::send_request(
request,
crate::api::limits::LimitType::Guild,
limits_instance,
limits_user,
)
.await
{
Ok(result) => result,
Err(e) => return Err(e),

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

@ -110,16 +110,14 @@ 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(
request,
crate::api::limits::LimitType::Ip,
limits_instance,
&mut cloned_limits,
)
.await
match LimitedRequester::send_request(
request,
crate::api::limits::LimitType::Ip,
limits_instance,
&mut cloned_limits,
)
.await
{
Ok(result) => {
let result_text = result.text().await.unwrap();
@ -138,15 +136,13 @@ 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(
request,
crate::api::limits::LimitType::Ip,
instance_limits,
&mut cloned_limits,
)
.await
match LimitedRequester::send_request(
request,
crate::api::limits::LimitType::Ip,
instance_limits,
&mut cloned_limits,
)
.await
{
Ok(result) => Ok(serde_json::from_str(&result.text().await.unwrap()).unwrap()),
Err(e) => Err(e),

79
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,23 +269,21 @@ 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(
request_builder,
LimitType::Channel,
&mut instance_rate_limits,
&mut user_rate_limits,
)
.await,
LimitedRequester::send_request(
request_builder,
LimitType::Channel,
&mut instance_rate_limits,
&mut user_rate_limits,
)
.await,
);
}
if request.is_some() {
@ -341,17 +305,16 @@ 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(
request_builder,
LimitType::Channel,
&mut instance_rate_limits,
&mut user_rate_limits,
)
.await;
let request_builder = Client::new().get(request_path);
let request = LimitedRequester::send_request(
request_builder,
LimitType::Channel,
&mut instance_rate_limits,
&mut user_rate_limits,
)
.await;
let result = match request {
Ok(result) => result,
Err(_) => panic!("Request failed"),