Remove limited argument from Instance

src/instance.rs

@@ -12,7 +12,9 @@ use crate::errors::ChorusResult;
 use crate::gateway::{Gateway, GatewayHandle};
 use crate::ratelimiter::ChorusRequest;
 use crate::types::types::subconfigs::limits::rates::RateLimits;
-use crate::types::{GeneralConfiguration, Limit, LimitType, User, UserSettings};
+use crate::types::{
+    GeneralConfiguration, Limit, LimitType, LimitsConfiguration, User, UserSettings,
+};
 use crate::UrlBundle;
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
@@ -71,23 +73,24 @@ impl PartialEq for LimitsInformation {
 
 impl Instance {
     /// Creates a new [`Instance`] from the [relevant instance urls](UrlBundle), where `limited` is whether Chorus will track and enforce rate limits for this instance.
-    pub async fn new(urls: UrlBundle, limited: bool) -> ChorusResult<Instance> {
-        let limits_information;
-        if limited {
-            let limits_configuration = ChorusRequest::get_limits_config(&urls.api).await?.rate;
-            let limits = ChorusRequest::limits_config_to_hashmap(&limits_configuration);
-            limits_information = Some(LimitsInformation {
+    pub async fn new(urls: UrlBundle) -> ChorusResult<Instance> {
+        let is_limited: Option<LimitsConfiguration> = Instance::is_limited(&urls.api).await?;
+        let limit_information;
+
+        if let Some(limits_configuration) = is_limited {
+            let limits = ChorusRequest::limits_config_to_hashmap(&limits_configuration.rate);
+            limit_information = Some(LimitsInformation {
                 ratelimits: limits,
-                configuration: limits_configuration,
+                configuration: limits_configuration.rate,
             });
         } else {
-            limits_information = None;
+            limit_information = None
         }
         let mut instance = Instance {
             urls: urls.clone(),
             // Will be overwritten in the next step
             instance_info: GeneralConfiguration::default(),
-            limits_information,
+            limits_information: limit_information,
             client: Client::new(),
         };
         instance.instance_info = match instance.general_configuration_schema().await {
@@ -111,9 +114,26 @@ impl Instance {
     /// Shorthand for `Instance::new(UrlBundle::from_root_domain(root_domain).await?)`.
     ///
     /// If `limited` is `true`, then Chorus will track and enforce rate limits for this instance.
-    pub async fn from_root_url(root_url: &str, limited: bool) -> ChorusResult<Instance> {
+    pub async fn from_root_url(root_url: &str) -> ChorusResult<Instance> {
         let urls = UrlBundle::from_root_url(root_url).await?;
-        Instance::new(urls, limited).await
+        Instance::new(urls).await
+    }
+
+    pub async fn is_limited(api_url: &str) -> ChorusResult<Option<LimitsConfiguration>> {
+        let api_url = UrlBundle::parse_url(api_url.to_string());
+        let client = Client::new();
+        let request = client
+            .get(format!("{}/policies/instance/limits", &api_url))
+            .header(http::header::ACCEPT, "application/json")
+            .build()?;
+        let resp = match client.execute(request).await {
+            Ok(response) => response,
+            Err(_) => return Ok(None),
+        };
+        match resp.json::<LimitsConfiguration>().await {
+            Ok(limits) => Ok(Some(limits)),
+            Err(_) => Ok(None),
+        }
     }
 }