cargo fmt

Signed-off-by: Daniel Gerlag <daniel@gerlag.ca>

src/client.rs

@@ -423,10 +423,9 @@ impl DaprInterface for dapr_v1::dapr_client::DaprClient<TonicChannel> {
     }
 
     async fn publish_event(&mut self, request: PublishEventRequest) -> Result<(), Error> {
-        self
-        .publish_event(Request::new(request))
-        .await?
-        .into_inner();
+        self.publish_event(Request::new(request))
+            .await?
+            .into_inner();
         Ok(())
     }
 
@@ -449,10 +448,9 @@ impl DaprInterface for dapr_v1::dapr_client::DaprClient<TonicChannel> {
     }
 
     async fn delete_bulk_state(&mut self, request: DeleteBulkStateRequest) -> Result<(), Error> {
-        self
-        .delete_bulk_state(Request::new(request))
-        .await?
-        .into_inner();
+        self.delete_bulk_state(Request::new(request))
+            .await?
+            .into_inner();
         Ok(())
     }
 

src/lib.rs

@@ -7,4 +7,4 @@ pub mod server;
 pub use client::Client;
 
 extern crate dapr_macros;
-pub use dapr_macros::actor;
+pub use dapr_macros::actor;

src/server/actor/context_client.rs

@@ -20,9 +20,9 @@ impl From<ActorStateOperation> for TransactionalActorStateOperation {
                 operation_type: "upsert".to_string(),
                 key,
                 value: value.map(|v| Any {
-                        type_url: "type.googleapis.com/bytes".to_string(),
-                        value: v,
-                    }),
+                    type_url: "type.googleapis.com/bytes".to_string(),
+                    value: v,
+                }),
                 metadata: HashMap::new(),
             },
             ActorStateOperation::Delete { key } => TransactionalActorStateOperation {
@@ -81,15 +81,14 @@ impl ActorContextClient {
         &mut self,
         operations: Vec<ActorStateOperation>,
     ) -> Result<(), DaprError> {
-        self
-        .client
-        .execute_actor_state_transaction(ExecuteActorStateTransactionRequest {
-            actor_type: self.actor_type.to_string(),
-            actor_id: self.actor_id.to_string(),
-            operations: operations.into_iter().map(|o| o.into()).collect(),
-        })
-        .await?
-        .into_inner();
+        self.client
+            .execute_actor_state_transaction(ExecuteActorStateTransactionRequest {
+                actor_type: self.actor_type.to_string(),
+                actor_id: self.actor_id.to_string(),
+                operations: operations.into_iter().map(|o| o.into()).collect(),
+            })
+            .await?
+            .into_inner();
         Ok(())
     }
 
@@ -112,28 +111,27 @@ impl ActorContextClient {
     where
         I: Into<String>,
     {
-        self
-        .client
-        .register_actor_reminder(RegisterActorReminderRequest {
-            actor_type: self.actor_type.to_string(),
-            actor_id: self.actor_id.to_string(),
-            name: name.into(),
-            due_time: match due_time {
-                None => "".to_string(),
-                Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
-            },
-            period: match period {
-                None => "".to_string(),
-                Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
-            },
-            data,
-            ttl: match ttl {
-                None => "".to_string(),
-                Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
-            },
-        })
-        .await?
-        .into_inner();
+        self.client
+            .register_actor_reminder(RegisterActorReminderRequest {
+                actor_type: self.actor_type.to_string(),
+                actor_id: self.actor_id.to_string(),
+                name: name.into(),
+                due_time: match due_time {
+                    None => "".to_string(),
+                    Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
+                },
+                period: match period {
+                    None => "".to_string(),
+                    Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
+                },
+                data,
+                ttl: match ttl {
+                    None => "".to_string(),
+                    Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
+                },
+            })
+            .await?
+            .into_inner();
         Ok(())
     }
 
@@ -145,15 +143,14 @@ impl ActorContextClient {
     where
         I: Into<String>,
     {
-        self
-        .client
-        .unregister_actor_reminder(UnregisterActorReminderRequest {
-            actor_type: self.actor_type.to_string(),
-            actor_id: self.actor_id.to_string(),
-            name: name.into(),
-        })
-        .await?
-        .into_inner();
+        self.client
+            .unregister_actor_reminder(UnregisterActorReminderRequest {
+                actor_type: self.actor_type.to_string(),
+                actor_id: self.actor_id.to_string(),
+                name: name.into(),
+            })
+            .await?
+            .into_inner();
         Ok(())
     }
 
@@ -178,29 +175,28 @@ impl ActorContextClient {
     where
         I: Into<String>,
     {
-        self
-        .client
-        .register_actor_timer(RegisterActorTimerRequest {
-            actor_type: self.actor_type.to_string(),
-            actor_id: self.actor_id.to_string(),
-            name: name.into(),
-            due_time: match due_time {
-                None => "".to_string(),
-                Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
-            },
-            period: match period {
-                None => "".to_string(),
-                Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
-            },
-            data,
-            callback: callback.unwrap_or_default(),
-            ttl: match ttl {
-                None => "".to_string(),
-                Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
-            },
-        })
-        .await?
-        .into_inner();
+        self.client
+            .register_actor_timer(RegisterActorTimerRequest {
+                actor_type: self.actor_type.to_string(),
+                actor_id: self.actor_id.to_string(),
+                name: name.into(),
+                due_time: match due_time {
+                    None => "".to_string(),
+                    Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
+                },
+                period: match period {
+                    None => "".to_string(),
+                    Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
+                },
+                data,
+                callback: callback.unwrap_or_default(),
+                ttl: match ttl {
+                    None => "".to_string(),
+                    Some(t) => chrono::Duration::from_std(t).unwrap().to_string(),
+                },
+            })
+            .await?
+            .into_inner();
         Ok(())
     }
 
@@ -212,15 +208,14 @@ impl ActorContextClient {
     where
         I: Into<String>,
     {
-        self
-        .client
-        .unregister_actor_timer(UnregisterActorTimerRequest {
-            actor_type: self.actor_type.to_string(),
-            actor_id: self.actor_id.to_string(),
-            name: name.into(),
-        })
-        .await?
-        .into_inner();
+        self.client
+            .unregister_actor_timer(UnregisterActorTimerRequest {
+                actor_type: self.actor_type.to_string(),
+                actor_id: self.actor_id.to_string(),
+                name: name.into(),
+            })
+            .await?
+            .into_inner();
         Ok(())
     }
 }

src/server/actor/runtime/mod.rs

@@ -12,7 +12,8 @@ pub struct ActorState {
     pub runtime: Arc<ActorRuntime>,
 }
 
-type MethodRegistrationMap = HashMap<String, Box<dyn (FnOnce(Router, Arc<ActorRuntime>) -> Router) + Send + Sync>>;
+type MethodRegistrationMap =
+    HashMap<String, Box<dyn (FnOnce(Router, Arc<ActorRuntime>) -> Router) + Send + Sync>>;
 
 /// Describes the registration of an actor type, including the methods that can be invoked on it and the factory to create instances of it.
 /// # Example:
@@ -64,7 +65,7 @@ type MethodRegistrationMap = HashMap<String, Box<dyn (FnOnce(Router, Arc<ActorRu
 /// #         todo!()
 /// #    }
 /// # }
-/// 
+///
 /// # async fn main_async() {
 /// let mut dapr_server = dapr::server::DaprHttpServer::new().await;
 ///
@@ -192,7 +193,7 @@ impl ActorTypeRegistration {
 
     fn create_actor(&self, actor_id: &str, client: TonicClient) -> Arc<dyn Actor> {
         let client = ActorContextClient::new(client, &self.name, actor_id);
-        
+
         (self.factory)(&self.name, actor_id, client) as _
     }
 }

src/server/actor/tests.rs

@@ -4,21 +4,20 @@ use std::{
     sync::Arc,
 };
 
-use dapr::server::{
-        actor::{runtime::ActorTypeRegistration, Actor, ActorError},
-        DaprHttpServer,
-    };
 use async_trait::async_trait;
 use axum::{Json, Router};
 use axum_test::TestServer;
+use dapr::server::{
+    actor::{runtime::ActorTypeRegistration, Actor, ActorError},
+    DaprHttpServer,
+};
 use dapr_macros::actor;
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use tokio::sync::Mutex;
 use uuid::Uuid;
 
-
 #[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct MyResponse {
     pub actor_id: String,

src/server/http.rs

@@ -6,7 +6,7 @@ use axum::{
     Json, Router,
 };
 use futures::{Future, FutureExt};
-use std::{net::SocketAddr, sync::Arc, pin::Pin};
+use std::{net::SocketAddr, pin::Pin, sync::Arc};
 
 use super::super::client::TonicClient;
 use super::actor::runtime::{ActorRuntime, ActorTypeRegistration};
@@ -107,7 +107,8 @@ impl DaprHttpServer {
     }
 
     pub fn with_graceful_shutdown<F>(self, signal: F) -> Self
-        where F: Future<Output = ()> + Send + 'static
+    where
+        F: Future<Output = ()> + Send + 'static,
     {
         DaprHttpServer {
             shutdown_signal: Some(signal.boxed()),
@@ -137,20 +138,19 @@ impl DaprHttpServer {
 
         let addr = SocketAddr::from(([127, 0, 0, 1], port.unwrap_or(default_port)));
 
-        let server = axum::Server::bind(&addr)
-            .serve(app.into_make_service());
-
+        let server = axum::Server::bind(&addr).serve(app.into_make_service());
 
         let final_result = match self.shutdown_signal.take() {
             Some(signal) => {
-                server.with_graceful_shutdown(async move {
-                    signal.await;
-                })
-                .await
+                server
+                    .with_graceful_shutdown(async move {
+                        signal.await;
+                    })
+                    .await
             }
             None => server.await,
         };
-        
+
         self.actor_runtime.deactivate_all().await;
 
         Ok(final_result?)
@@ -182,9 +182,7 @@ impl DaprHttpServer {
                 put(invoke_timer).with_state(rt.clone()),
             );
 
-
-        self
-            .actor_runtime
+        self.actor_runtime
             .configure_method_routes(app, rt.clone())
             .await
     }