diff --git a/src/api/auth/login.rs b/src/api/auth/login.rs index aeafec2..e72278f 100644 --- a/src/api/auth/login.rs +++ b/src/api/auth/login.rs @@ -15,7 +15,7 @@ impl Instance { &mut self, login_schema: &LoginSchema, ) -> Result { - 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); } diff --git a/src/api/auth/register.rs b/src/api/auth/register.rs index d8c4847..80485eb 100644 --- a/src/api/auth/register.rs +++ b/src/api/auth/register.rs @@ -24,7 +24,6 @@ impl Instance { register_schema: &RegisterSchema, ) -> Result { 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); } diff --git a/src/api/common.rs b/src/api/common.rs index 849bf13..0ca9063 100644 --- a/src/api/common.rs +++ b/src/api/common.rs @@ -13,15 +13,13 @@ pub async fn handle_request( limit_type: LimitType, ) -> Result { 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), diff --git a/src/api/guilds/guilds.rs b/src/api/guilds/guilds.rs index 65101e0..8259c0e 100644 --- a/src/api/guilds/guilds.rs +++ b/src/api/guilds/guilds.rs @@ -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), diff --git a/src/api/users/users.rs b/src/api/users/users.rs index 698fb42..d9d3cd5 100644 --- a/src/api/users/users.rs +++ b/src/api/users/users.rs @@ -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), diff --git a/src/limit.rs b/src/limit.rs index ce0ba4e..3ab7454 100644 --- a/src/limit.rs +++ b/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, -} +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 { - 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> = 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"),