cargo fmt

src/api/folders.rs

@@ -34,7 +34,6 @@ pub struct FolderAttributes {
     /// Additional attributes that can be used to categorize hosts. every tag is part of a tag_group
     /// NOTE that checkmk always returns taggroups prefixed with "tag_"
     pub tags: HashMap<String, String>,
-
     // TODO: to be implemented
     // #[serde(flatten, default)]
     // pub networkscan: NetworkScan,
@@ -116,16 +115,11 @@ pub struct FolderCreationRequest {
     pub name: String,
     pub title: String,
     pub parent: String,
-    pub attributes: FolderAttributes
+    pub attributes: FolderAttributes,
 }
 
 impl FolderCreationRequest {
-    pub fn new(
+    pub fn new(name: String, title: String, parent: String, attributes: FolderAttributes) -> Self {
-        name: String,
-        title: String,
-        parent: String,
-        attributes: FolderAttributes
-    ) -> Self {
         Self {
             name,
             title,
@@ -154,7 +148,7 @@ impl FolderUpdateRequest {
             title,
             attributes: Some(attributes),
             update_attributes: None,
-            remove_attributes: None
+            remove_attributes: None,
         }
     }
     pub fn update(title: String, attributes: FolderAttributes) -> Self {
@@ -162,7 +156,7 @@ impl FolderUpdateRequest {
             title,
             attributes: None,
             update_attributes: Some(attributes),
-            remove_attributes: None
+            remove_attributes: None,
         }
     }
     pub fn remove(title: String, attributes: FolderAttributes) -> Self {
@@ -170,14 +164,14 @@ impl FolderUpdateRequest {
             title,
             attributes: None,
             update_attributes: None,
-            remove_attributes: Some(attributes)
+            remove_attributes: Some(attributes),
         }
     }
 }
 
 #[derive(Debug, Serialize)]
 pub struct FolderDeleteQuery {
-    pub delete_mode: FolderDeleteMode
+    pub delete_mode: FolderDeleteMode,
 }
 
 impl FolderDeleteQuery {
@@ -190,5 +184,5 @@ impl FolderDeleteQuery {
 #[serde(rename_all = "snake_case")]
 pub enum FolderDeleteMode {
     Recursive,
-    AbotyOnNonEmpty
+    AbotyOnNonEmpty,
 }

src/api/mod.rs

@@ -29,7 +29,6 @@ impl fmt::Display for DomainType {
     }
 }
 
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[serde(rename_all = "UPPERCASE")]
 pub enum HttpMethod {

src/api/rules/contactgroups.rs

@@ -6,5 +6,5 @@ pub struct HostContactGroups {
     r#use: bool,
     use_for_services: bool,
     recuse_use: bool,
-    recuse_perms: bool
+    recuse_perms: bool,
 }

src/client.rs

@@ -4,20 +4,22 @@ use std::net::{IpAddr, SocketAddr};
 use std::sync::Arc;
 
 use log::trace;
-use reqwest::{Certificate, Request};
 use reqwest::header::{HeaderName, HeaderValue};
+use reqwest::{Certificate, Request};
 use serde::de::DeserializeOwned;
 use tokio::sync::Semaphore;
 
-use crate::api::{BulkCreateDomainExtention, BulkDeleteDomainExtention, BulkReadDomainExtention, BulkUpdateDomainExtention, DomainCollection, DomainExtention, DomainObject, DomainType};
+use crate::api::{
+    BulkCreateDomainExtention, BulkDeleteDomainExtention, BulkReadDomainExtention,
+    BulkUpdateDomainExtention, DomainCollection, DomainExtention, DomainObject, DomainType,
+};
 use crate::{Error, Result};
 
-
 pub struct Client(Arc<InnerClient>);
 struct InnerClient {
     http: reqwest::Client,
     url: String,
-    semaphore: Semaphore
+    semaphore: Semaphore,
 }
 
 #[derive(Default, PartialEq, Eq)]
@@ -25,7 +27,8 @@ enum SslStrategy {
     NoSll,
     IngoreHostname,
     IgnoreCertificate,
-    #[default] Strict
+    #[default]
+    Strict,
 }
 
 #[derive(Default)]
@@ -45,7 +48,7 @@ pub struct ClientBuilder<T> {
     resolve: Option<SocketAddr>,
     port: u16,
 
-    _marker: PhantomData<T>
+    _marker: PhantomData<T>,
 }
 
 impl<T> ClientBuilder<T> {
@@ -55,20 +58,30 @@ impl <T> ClientBuilder<T> {
 }
 
 impl ClientBuilder<RequiresLocation> {
-    pub fn on_host_and_site(self, hostname: String, sitename: String) -> ClientBuilder<RequiresCredentials> {
+    pub fn on_host_and_site(
+        self,
+        hostname: String,
+        sitename: String,
+    ) -> ClientBuilder<RequiresCredentials> {
         ClientBuilder::<RequiresCredentials> {
-            hostname, sitename,
+            hostname,
+            sitename,
             ..Default::default()
         }
     }
 }
 
 impl ClientBuilder<RequiresCredentials> {
-    pub fn with_credentials(self, username: String, password: String) -> ClientBuilder<RequiresNothing> {
+    pub fn with_credentials(
+        self,
+        username: String,
+        password: String,
+    ) -> ClientBuilder<RequiresNothing> {
         ClientBuilder {
             hostname: self.hostname,
             sitename: self.sitename,
-            username, password,
+            username,
+            password,
             ..Default::default()
         }
     }
@@ -80,8 +93,10 @@ type ClientBuildResult<T> = std::result::Result<T, ClientBuildError>;
 pub enum ClientBuildError {
     #[error("failed to build client: {0}")]
     BuildClient(#[from] reqwest::Error),
-    #[error("invalid credentials. thise can only consist of visibly ASCII characters (ie. (32-127))")]
+    #[error(
-    InvalidCredentials(#[from] reqwest::header::InvalidHeaderValue)
+        "invalid credentials. thise can only consist of visibly ASCII characters (ie. (32-127))"
+    )]
+    InvalidCredentials(#[from] reqwest::header::InvalidHeaderValue),
 }
 
 impl ClientBuilder<RequiresNothing> {
@@ -148,7 +163,8 @@ impl ClientBuilder<RequiresNothing> {
                 builder = builder.add_root_certificate(certificate);
             }
 
-            builder.build()
+            builder
+                .build()
                 .map_err(ClientBuildError::BuildClient)
                 .map_err(Error::BuildClient)?
         };
@@ -157,7 +173,11 @@ impl ClientBuilder<RequiresNothing> {
         // not sure if this has been inproved since 2.2
         let semaphore = Semaphore::new(10);
 
-        Ok(Client(Arc::new(InnerClient { http, url, semaphore })))
+        Ok(Client(Arc::new(InnerClient {
+            http,
+            url,
+            semaphore,
+        })))
     }
 }
 
@@ -166,7 +186,7 @@ impl Client {
         Self(Arc::new(InnerClient {
             http: client,
             semaphore: Semaphore::new(10),
-            url
+            url,
         }))
     }
     pub fn builder() -> ClientBuilder<RequiresLocation> {
@@ -182,26 +202,27 @@ impl InnerClient {
         format!("{}/domain-types/{}/collections/all", self.url, domain_type)
     }
     pub(crate) fn bulk_action_url(&self, domain_type: DomainType, action: BulkAction) -> String {
-        format!("{}/domain-types/{}/actions/bulk-{}/invoke",self.url, domain_type, action)
+        format!(
+            "{}/domain-types/{}/actions/bulk-{}/invoke",
+            self.url, domain_type, action
+        )
     }
 
     pub(crate) async fn handle_request(&self, request: Request) -> Result<String> {
         trace!("sending {}-request to {}", request.method(), request.url());
-        let response = self.http
+        let response = self
+            .http
             .execute(request)
             .await
             .map_err(Error::SendRequest)?;
 
         let status = response.status();
-        let body = response.text()
+        let body = response.text().await.map_err(Error::ReceiveBody)?;
-            .await
-            .map_err(Error::ReceiveBody)?;
 
         if status.is_success() {
             Ok(body)
         } else {
-            let cmkerror = serde_json::from_str(&body)
+            let cmkerror = serde_json::from_str(&body).map_err(Error::DeserializeResponse)?;
-                .map_err(Error::DeserializeResponse)?;
             Err(Error::CheckmkError(cmkerror))
         }
     }
@@ -215,22 +236,21 @@ impl InnerClient {
     }
 
     pub(crate) async fn get_etag(&self, object_url: &str) -> Result<HeaderValue> {
-        let mut response = self.http
+        let mut response = self
+            .http
             .head(object_url)
             .send()
             .await
             .map_err(Error::SendRequest)?;
 
         if response.status().is_success() {
-            response.headers_mut()
+            response
+                .headers_mut()
                 .remove("ETag")
                 .ok_or(Error::MissingHeader("ETag"))
         } else {
-            let body = response.text()
+            let body = response.text().await.map_err(Error::ReceiveBody)?;
-                .await
+            let cmkerror = serde_json::from_str(&body).map_err(Error::DeserializeResponse)?;
-                .map_err(Error::ReceiveBody)?;
-            let cmkerror = serde_json::from_str(&body)
-                .map_err(Error::DeserializeResponse)?;
             Err(Error::CheckmkError(cmkerror))
         }
     }
@@ -238,9 +258,10 @@ impl InnerClient {
     pub(crate) async fn create_domain_object<E: DomainExtention>(
         &self,
         body: &E::CreationRequest,
-        query: &E::CreationQuery
+        query: &E::CreationQuery,
     ) -> Result<()> {
-        let request = self.http
+        let request = self
+            .http
             .post(self.collection_url(E::DOMAIN_TYPE))
             .json(body)
             .query(query)
@@ -252,9 +273,10 @@ impl InnerClient {
     pub(crate) async fn read_domain_object<E: DomainExtention>(
         &self,
         id: impl Display,
-        query: &E::ReadQuery
+        query: &E::ReadQuery,
     ) -> Result<DomainObject<E>> {
-        let request = self.http
+        let request = self
+            .http
             .get(self.object_url(E::DOMAIN_TYPE, id))
             .query(query)
             .build()
@@ -269,7 +291,8 @@ impl InnerClient {
     ) -> Result<()> {
         let url = self.object_url(E::DOMAIN_TYPE, id);
         let etag = self.get_etag(&url).await?;
-        let request = self.http
+        let request = self
+            .http
             .put(url)
             .json(&request)
             .header(reqwest::header::IF_MATCH, etag)
@@ -283,7 +306,8 @@ impl InnerClient {
         id: impl Display,
         query: &E::DeleteQuery,
     ) -> Result<()> {
-        let request = self.http
+        let request = self
+            .http
             .delete(self.object_url(E::DOMAIN_TYPE, id))
             .query(&query)
             .build()
@@ -295,9 +319,10 @@ impl InnerClient {
     pub(crate) async fn bulk_create_domain_objects<E: BulkCreateDomainExtention>(
         &self,
         request: &[E::CreationRequest],
-        query: &E::CreationQuery
+        query: &E::CreationQuery,
     ) -> Result<()> {
-        let request = self.http
+        let request = self
+            .http
             .post(self.bulk_action_url(E::DOMAIN_TYPE, BulkAction::Create))
             .json(request)
             .query(query)
@@ -310,7 +335,8 @@ impl InnerClient {
         &self,
         query: &E::ReadQuery,
     ) -> Result<Vec<DomainObject<E>>> {
-        let request = self.http
+        let request = self
+            .http
             .get(self.collection_url(E::DOMAIN_TYPE))
             .query(query)
             .build()
@@ -323,7 +349,8 @@ impl InnerClient {
         &self,
         body: &[E::BulkUpdateRequest],
     ) -> Result<()> {
-        let request = self.http
+        let request = self
+            .http
             .put(self.bulk_action_url(E::DOMAIN_TYPE, BulkAction::Update))
             .json(body)
             .build()
@@ -335,7 +362,8 @@ impl InnerClient {
         &self,
         ids: &[String],
     ) -> Result<()> {
-        let request = self.http
+        let request = self
+            .http
             .post(self.bulk_action_url(E::DOMAIN_TYPE, BulkAction::Delete))
             .json(&ids)
             .build()
@@ -365,44 +393,28 @@ impl Display for BulkAction {
 
 pub struct ApiClient<D: DomainExtention> {
     inner: Arc<InnerClient>,
-    _marker: PhantomData<D>
+    _marker: PhantomData<D>,
 }
 
 impl<D: DomainExtention> ApiClient<D> {
     pub async fn create(
         &self,
         request: &D::CreationRequest,
-        query: &D::CreationQuery
+        query: &D::CreationQuery,
     ) -> Result<()> {
         self.inner.create_domain_object::<D>(request, query).await
     }
-    pub async fn read(
+    pub async fn read(&self, id: impl Display, query: &D::ReadQuery) -> Result<D> {
-        &self,
-        id: impl Display,
-        query: &D::ReadQuery
-    ) -> Result<D> {
         self.inner
             .read_domain_object(id, query)
             .await
             .map(|obj| obj.extensions)
     }
-    pub async fn update(
+    pub async fn update(&self, id: impl Display, request: &D::UpdateRequest) -> Result<()> {
-        &self,
+        self.inner.update_domain_object::<D>(id, request).await
-        id: impl Display,
-        request: &D::UpdateRequest
-    ) -> Result<()> {
-        self.inner
-            .update_domain_object::<D>(id, request)
-            .await
     }
-    pub async fn delete(
+    pub async fn delete(&self, id: impl Display, query: &D::DeleteQuery) -> Result<()> {
-        &self,
+        self.inner.delete_domain_object::<D>(id, query).await
-        id: impl Display,
-        query: &D::DeleteQuery
-    ) -> Result<()> {
-        self.inner
-            .delete_domain_object::<D>(id, query)
-            .await
     }
 }
 
@@ -419,38 +431,21 @@ impl <D: BulkCreateDomainExtention> ApiClient<D> {
 }
 
 impl<D: BulkReadDomainExtention> ApiClient<D> {
-    pub async fn bulk_read(
+    pub async fn bulk_read(&self, query: &D::ReadQuery) -> Result<Vec<D>> {
-        &self,
+        let objs = self.inner.bulk_read_domain_objects::<D>(query).await?;
-        query: &D::ReadQuery,
+        let exts = objs.into_iter().map(|obj| obj.extensions).collect();
-    ) -> Result<Vec<D>> {
-        let objs = self.inner
-            .bulk_read_domain_objects::<D>(query)
-            .await?;
-        let exts = objs.into_iter()
-            .map(|obj| obj.extensions)
-            .collect();
         Ok(exts)
     }
 }
 
 impl<D: BulkUpdateDomainExtention> ApiClient<D> {
-    pub async fn bulk_update(
+    pub async fn bulk_update(&self, request: &[D::BulkUpdateRequest]) -> Result<()> {
-        &self,
+        self.inner.bulk_update_domain_objects::<D>(request).await
-        request: &[D::BulkUpdateRequest],
-    ) -> Result<()> {
-        self.inner
-            .bulk_update_domain_objects::<D>(request)
-            .await
     }
 }
 
 impl<D: BulkDeleteDomainExtention> ApiClient<D> {
-    pub async fn bulk_delete(
+    pub async fn bulk_delete(&self, ids: &[String]) -> Result<()> {
-        &self,
+        self.inner.bulk_delete_domain_objects::<D>(ids).await
-        ids: &[String],
-    ) -> Result<()> {
-        self.inner
-            .bulk_delete_domain_objects::<D>(ids)
-            .await
     }
 }

src/lib.rs

@@ -1,5 +1,5 @@
+pub mod api;
 mod client;
 mod error;
-pub mod api;
 
 pub use error::{Error, Result};