fix: apply formatting

Author: samparsky

sentry/src/db.rs

@@ -84,7 +84,6 @@ pub async fn setup_migrations(environment: &str) {
 
     let mut migrations = vec![make_migration!("20190806011140_initial-tables")];
 
-
     if environment == "development" {
         // seeds database tables for testing
         migrations.push(make_migration!("20190806011140_initial-tables/seed"));

sentry/src/db/event_aggregate.rs

@@ -5,15 +5,17 @@ use bb8_postgres::tokio_postgres::types::{ToSql, Type};
 use bb8_postgres::tokio_postgres::Error;
 use chrono::{DateTime, Utc};
 use futures::pin_mut;
-use primitives::sentry::{EventAggregate, ApproveStateValidatorMessage, NewStateValidatorMessage, HeartbeatValidatorMessage};
+use primitives::sentry::{
+    ApproveStateValidatorMessage, EventAggregate, HeartbeatValidatorMessage,
+    NewStateValidatorMessage,
+};
 use primitives::BigNum;
-use primitives::{ChannelId, ValidatorId, Channel};
+use primitives::{Channel, ChannelId, ValidatorId};
 use std::ops::Add;
 
-
-pub async fn lastest_approve_state( 
+pub async fn lastest_approve_state(
     pool: &DbPool,
-    channel: &Channel
+    channel: &Channel,
 ) -> Result<Option<ApproveStateValidatorMessage>, RunError<bb8_postgres::tokio_postgres::Error>> {
     pool
         .run(move |connection| {
@@ -53,7 +55,7 @@ pub async fn latest_new_state(
 pub async fn latest_heartbeats(
     pool: &DbPool,
     channel_id: &ChannelId,
-    validator_id: ValidatorId
+    validator_id: ValidatorId,
 ) -> Result<Vec<HeartbeatValidatorMessage>, RunError<bb8_postgres::tokio_postgres::Error>> {
     pool
     .run(move |connection| {

sentry/src/routes/channel.rs

@@ -1,6 +1,6 @@
 use self::channel_list::{ChannelListQuery, LastApprovedQuery};
+use crate::db::event_aggregate::{lastest_approve_state, latest_heartbeats, latest_new_state};
 use crate::db::{get_channel_by_id, insert_channel, insert_validator_messages, list_channels};
-use crate::db::event_aggregate::{ lastest_approve_state, latest_new_state, latest_heartbeats};
 use crate::success_response;
 use crate::Application;
 use crate::ResponseError;
@@ -11,7 +11,7 @@ use hex::FromHex;
 use hyper::{Body, Request, Response};
 use primitives::adapter::Adapter;
 use primitives::channel::SpecValidator;
-use primitives::sentry::{Event, SuccessResponse, LastApprovedResponse, LastApproved};
+use primitives::sentry::{Event, LastApproved, LastApprovedResponse, SuccessResponse};
 use primitives::validator::MessageTypes;
 use primitives::{Channel, ChannelId};
 use slog::error;
@@ -99,43 +99,71 @@ pub async fn last_approved<A: Adapter>(
         .extensions()
         .get::<RouteParams>()
         .expect("request should have route params");
-        
+
     let channel_id = ChannelId::from_hex(route_params.index(0))?;
     let channel = get_channel_by_id(&app.pool, &channel_id).await?.unwrap();
 
     let approve_state = lastest_approve_state(&app.pool, &channel).await?;
     if approve_state.is_none() {
         return Ok(Response::builder()
-        .header("Content-type", "application/json")
-        .body(serde_json::to_string(&LastApprovedResponse{ last_approved: None, heartbeats: None  })?.into())
-        .unwrap())
+            .header("Content-type", "application/json")
+            .body(
+                serde_json::to_string(&LastApprovedResponse {
+                    last_approved: None,
+                    heartbeats: None,
+                })?
+                .into(),
+            )
+            .unwrap());
     }
 
-    let state_root = approve_state.as_ref().expect("value should be present").msg.state_root.clone();
+    let state_root = approve_state
+        .as_ref()
+        .expect("value should be present")
+        .msg
+        .state_root
+        .clone();
     let new_state = latest_new_state(&app.pool, &channel, &state_root).await?;
     if new_state.is_none() {
         return Ok(Response::builder()
-        .header("Content-type", "application/json")
-        .body(serde_json::to_string(&LastApprovedResponse{ last_approved: None, heartbeats: None  })?.into())
-        .unwrap())
+            .header("Content-type", "application/json")
+            .body(
+                serde_json::to_string(&LastApprovedResponse {
+                    last_approved: None,
+                    heartbeats: None,
+                })?
+                .into(),
+            )
+            .unwrap());
     }
 
     let query = serde_urlencoded::from_str::<LastApprovedQuery>(&req.uri().query().unwrap_or(""))?;
-    let validators =  channel.spec.validators;
+    let validators = channel.spec.validators;
     let channel_id = channel.id;
     let heartbeats = if query.with_heartbeat.is_some() {
         let result = try_join_all(
-            validators.into_iter()
-                .map(|validator| latest_heartbeats(&app.pool, &channel_id, validator.id.clone()))
-        ).await?;
+            validators
+                .into_iter()
+                .map(|validator| latest_heartbeats(&app.pool, &channel_id, validator.id.clone())),
+        )
+        .await?;
         Some(result.into_iter().flatten().collect::<Vec<_>>())
     } else {
         None
     };
 
     Ok(Response::builder()
         .header("Content-type", "application/json")
-        .body(serde_json::to_string(&&LastApprovedResponse{ last_approved: Some(LastApproved { new_state, approve_state }), heartbeats })?.into())
+        .body(
+            serde_json::to_string(&&LastApprovedResponse {
+                last_approved: Some(LastApproved {
+                    new_state,
+                    approve_state,
+                }),
+                heartbeats,
+            })?
+            .into(),
+        )
         .unwrap())
 }
 
@@ -239,9 +267,9 @@ mod channel_list {
     #[derive(Debug, Deserialize)]
     #[serde(rename_all = "camelCase")]
     pub(super) struct LastApprovedQuery {
-        pub with_heartbeat: Option<String>
+        pub with_heartbeat: Option<String>,
     }
-    
+
     fn default_page() -> u64 {
         0
     }