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 branch 'main' into feature/webrtc

This commit is contained in:
kozabrada123 2023-06-21 14:28:05 +02:00
parent 517a916b60 82573a58b1
commit 7cb968c588
8 changed files with 89 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -26,7 +26,7 @@ impl Instance {
let response = LimitedRequester::send_request(
request_builder,
LimitType::AuthRegister,
&mut self.limits,
self,
&mut cloned_limits,
)
.await;

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

@ -12,13 +12,15 @@ use crate::{
};
impl Instance {
/**
Registers a new user on the Spacebar server.
# Arguments
* `register_schema` - The [`RegisterSchema`] that contains all the information that is needed to register a new user.
# Errors
* [`ChorusLibError`] - If the server does not respond.
*/
/// Registers a new user on the Spacebar server.
///
/// # Arguments
///
/// * `register_schema` - The [`RegisterSchema`] that contains all the information that is needed to register a new user.
///
/// # Errors
///
/// * [`ChorusLibError`] - If the server does not respond.
pub async fn register_account(
&mut self,
register_schema: &RegisterSchema,
@ -34,7 +36,7 @@ impl Instance {
let response = LimitedRequester::send_request(
request_builder,
LimitType::AuthRegister,
&mut self.limits,
self,
&mut cloned_limits,
)
.await;
@ -59,7 +61,7 @@ impl Instance {
return Err(ChorusLibError::InvalidFormBodyError { error_type, error });
}
let user_object = self.get_user(token.clone(), None).await.unwrap();
let settings = UserMeta::get_settings(&token, &self.urls.api, &mut self.limits)
let settings = UserMeta::get_settings(&token, &self.urls.api.clone(), self)
.await
.unwrap();
let user = UserMeta::new(

2
src/api/common.rs
View File

@ -15,7 +15,7 @@ pub async fn handle_request(
LimitedRequester::send_request(
request,
limit_type,
&mut user.belongs_to.borrow_mut().limits,
&mut user.belongs_to.borrow_mut(),
&mut user.limits,
)
.await

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

@ -7,6 +7,7 @@ use crate::api::handle_request;
use crate::api::handle_request_as_result;
use crate::api::limits::Limits;
use crate::errors::ChorusLibError;
use crate::instance::Instance;
use crate::instance::UserMeta;
use crate::limit::LimitedRequester;
use crate::types::{Channel, ChannelCreateSchema, Guild, GuildCreateSchema};
@ -101,7 +102,7 @@ impl Guild {
&self.id.to_string(),
schema,
&mut user.limits,
&mut belongs_to.limits,
&mut belongs_to,
)
.await
}
@ -161,7 +162,7 @@ impl Guild {
guild_id,
&user.token,
&mut user.limits,
&mut belongs_to.limits,
&mut belongs_to,
)
.await
}
@ -173,7 +174,7 @@ impl Guild {
guild_id: &str,
token: &str,
limits_user: &mut Limits,
limits_instance: &mut Limits,
instance: &mut Instance,
) -> Result<Guild, ChorusLibError> {
let request = Client::new()
.get(format!("{}/guilds/{}/", url_api, guild_id))
@ -181,7 +182,7 @@ impl Guild {
let response = match LimitedRequester::send_request(
request,
crate::api::limits::LimitType::Guild,
limits_instance,
instance,
limits_user,
)
.await
@ -221,7 +222,7 @@ impl Channel {
guild_id,
schema,
&mut user.limits,
&mut belongs_to.limits,
&mut belongs_to,
)
.await
}
@ -232,7 +233,7 @@ impl Channel {
guild_id: &str,
schema: ChannelCreateSchema,
limits_user: &mut Limits,
limits_instance: &mut Limits,
instance: &mut Instance,
) -> Result<Channel, ChorusLibError> {
let request = Client::new()
.post(format!("{}/guilds/{}/channels/", url_api, guild_id))
@ -241,7 +242,7 @@ impl Channel {
let result = match LimitedRequester::send_request(
request,
crate::api::limits::LimitType::Guild,
limits_instance,
instance,
limits_user,
)
.await

8
src/api/policies/instance/instance.rs
View File

@ -6,11 +6,9 @@ use crate::instance::Instance;
use crate::types::GeneralConfiguration;
impl Instance {
/**
Gets the instance policies schema.
# Errors
[`ChorusLibError`] - If the request fails.
*/
/// Gets the instance policies schema.
/// # Errors
/// [`ChorusLibError`] - If the request fails.
pub async fn general_configuration_schema(
&self,
) -> Result<GeneralConfiguration, ChorusLibError> {

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

@ -10,16 +10,18 @@ use crate::{
};
impl UserMeta {
/**
Get a user object by id, or get the current user.
# Arguments
* `token` - A valid access token for the API.
* `url_api` - The URL to the API.
* `id` - The id of the user that will be retrieved. If this is None, the current user will be retrieved.
* `instance_limits` - The [`Limits`] of the instance.
# Errors
* [`ChorusLibError`] - If the request fails.
*/
/// Get a user object by id, or get the current user.
///
/// # Arguments
///
/// * `token` - A valid access token for the API.
/// * `url_api` - The URL to the API.
/// * `id` - The id of the user that will be retrieved. If this is None, the current user will be retrieved.
/// * `instance_limits` - The [`Limits`] of the instance.
///
/// # Errors
///
/// * [`ChorusLibError`] - If the request fails.
pub async fn get(user: &mut UserMeta, id: Option<&String>) -> Result<User, ChorusLibError> {
User::get(user, id).await
}
@ -27,9 +29,9 @@ impl UserMeta {
pub async fn get_settings(
token: &String,
url_api: &String,
instance_limits: &mut Limits,
instance: &mut Instance,
) -> Result<UserSettings, ChorusLibError> {
User::get_settings(token, url_api, instance_limits).await
User::get_settings(token, url_api, instance).await
}
/// Modify the current user's `UserObject`.
@ -89,7 +91,7 @@ impl User {
User::_get(
&user.token(),
&format!("{}", belongs_to.urls.api),
&mut belongs_to.limits,
&mut belongs_to,
id,
)
.await
@ -98,7 +100,7 @@ impl User {
async fn _get(
token: &str,
url_api: &str,
limits_instance: &mut Limits,
instance: &mut Instance,
id: Option<&String>,
) -> Result<User, ChorusLibError> {
let url = if id.is_none() {
@ -107,11 +109,11 @@ impl User {
format!("{}/users/{}", url_api, id.unwrap())
};
let request = reqwest::Client::new().get(url).bearer_auth(token);
let mut cloned_limits = limits_instance.clone();
let mut cloned_limits = instance.limits.clone();
match LimitedRequester::send_request(
request,
crate::api::limits::LimitType::Ip,
limits_instance,
instance,
&mut cloned_limits,
)
.await
@ -127,16 +129,16 @@ impl User {
pub async fn get_settings(
token: &String,
url_api: &String,
instance_limits: &mut Limits,
instance: &mut Instance,
) -> Result<UserSettings, ChorusLibError> {
let request: reqwest::RequestBuilder = Client::new()
.get(format!("{}/users/@me/settings/", url_api))
.bearer_auth(token);
let mut cloned_limits = instance_limits.clone();
let mut cloned_limits = instance.limits.clone();
match LimitedRequester::send_request(
request,
crate::api::limits::LimitType::Ip,
instance_limits,
instance,
&mut cloned_limits,
)
.await
@ -163,6 +165,6 @@ impl Instance {
token: String,
id: Option<&String>,
) -> Result<User, ChorusLibError> {
User::_get(&token, &self.urls.api, &mut self.limits, id).await
User::_get(&token, &self.urls.api.clone(), self, id).await
}
}

3
src/instance.rs
View File

@ -2,6 +2,7 @@ use std::cell::RefCell;
use std::fmt;
use std::rc::Rc;
use reqwest::Client;
use serde::{Deserialize, Serialize};
use crate::api::limits::Limits;
@ -17,6 +18,7 @@ pub struct Instance {
pub urls: UrlBundle,
pub instance_info: GeneralConfiguration,
pub limits: Limits,
pub client: Client,
}
impl Instance {
@ -32,6 +34,7 @@ impl Instance {
// Will be overwritten in the next step
instance_info: GeneralConfiguration::default(),
limits: Limits::check_limits(urls.api).await,
client: Client::new(),
};
instance.instance_info = match instance.general_configuration_schema().await {
Ok(schema) => schema,

51
src/limit.rs
View File

@ -1,21 +1,50 @@
use reqwest::{Client, RequestBuilder, Response};
use reqwest::{RequestBuilder, Response};
use crate::{
api::limits::{Limit, LimitType, Limits, LimitsMutRef},
errors::ChorusLibError,
instance::Instance,
};
#[derive(Debug)]
pub struct LimitedRequester;
impl LimitedRequester {
/// Checks if a request can be sent without hitting API rate limits and sends it, if true.
/// Will automatically update the rate limits of the LimitedRequester the request has been
/// sent with.
///
/// # Arguments
///
/// * `request`: A `RequestBuilder` that contains a request ready to be sent. Unfinished or
/// invalid requests will result in the method panicing.
/// * `limit_type`: Because this library does not yet implement a way to check for which rate
/// limit will be used when the request gets send, you will have to specify this manually using
/// a `LimitType` enum.
///
/// # Returns
///
/// * `Response`: The `Response` gotten from sending the request to the server. This will be
/// returned if the Request was built and send successfully. Is wrapped in an `Option`.
/// * `None`: `None` will be returned if the rate limit has been hit, and the request could
/// therefore not have been sent.
///
/// # Errors
///
/// This method will error if:
///
/// * The request does not return a success status code (200-299)
/// * The supplied `RequestBuilder` contains invalid or incomplete information
/// * There has been an error with processing (unwrapping) the `Response`
/// * The call to `update_limits` yielded errors. Read the methods' Errors section for more
/// information.
pub async fn send_request(
request: RequestBuilder,
limit_type: LimitType,
instance_rate_limits: &mut Limits,
instance: &mut Instance,
user_rate_limits: &mut Limits,
) -> Result<Response, ChorusLibError> {
if LimitedRequester::can_send_request(limit_type, instance_rate_limits, user_rate_limits) {
if LimitedRequester::can_send_request(limit_type, &instance.limits, user_rate_limits) {
let built_request = match request.build() {
Ok(request) => request,
Err(e) => {
@ -25,7 +54,7 @@ impl LimitedRequester {
});
}
};
let result = Client::new().execute(built_request).await;
let result = instance.client.execute(built_request).await;
let response = match result {
Ok(is_response) => is_response,
Err(e) => {
@ -37,7 +66,7 @@ impl LimitedRequester {
LimitedRequester::update_limits(
&response,
limit_type,
instance_rate_limits,
&mut instance.limits,
user_rate_limits,
);
if !response.status().is_success() {
@ -228,17 +257,17 @@ mod rate_limit {
String::from("http://localhost:3001/cdn"),
);
let mut request: Option<Result<Response, ChorusLibError>> = None;
let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await;
let mut instance = Instance::new(urls.clone()).await.unwrap();
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 = Client::new().get(request_path);
let request_builder = instance.client.get(request_path);
request = Some(
LimitedRequester::send_request(
request_builder,
LimitType::Channel,
&mut instance_rate_limits,
&mut instance,
&mut user_rate_limits,
)
.await,
@ -254,15 +283,15 @@ mod rate_limit {
String::from("wss://localhost:3001/"),
String::from("http://localhost:3001/cdn"),
);
let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await;
let mut instance = Instance::new(urls.clone()).await.unwrap();
let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await;
let _requester = LimitedRequester;
let request_path = urls.api.clone() + "/policies/instance/limits";
let request_builder = Client::new().get(request_path);
let request_builder = instance.client.get(request_path);
let request = LimitedRequester::send_request(
request_builder,
LimitType::Channel,
&mut instance_rate_limits,
&mut instance,
&mut user_rate_limits,
)
.await;