Tweaks and cleanup

elpiel · elpiel · commit e7f9d8073753 · 2020-02-28T14:19:06.000+02:00
diff --git a/primitives/src/validator.rs b/primitives/src/validator.rs
@@ -81,17 +81,13 @@ impl AsRef<[u8]> for ValidatorId {
 impl TryFrom<&str> for ValidatorId {
     type Error = DomainError;
     fn try_from(value: &str) -> Result<Self, Self::Error> {
-        let hex_value = if value.len() == 42 {
-            &value[2..]
-        } else {
-            value
-        };
-
-        if hex_value.len() != 40 {
-            return Err(DomainError::InvalidArgument(
+        let hex_value = match value {
+            value if value.len() == 42 => Ok(&value[2..]),
+            value if value.len() == 40 => Ok(value),
+            _ => Err(DomainError::InvalidArgument(
                 "invalid validator id length".to_string(),
-            ));
-        }
+            )),
+        }?;
 
         let result = hex::decode(hex_value).map_err(|_| {
             DomainError::InvalidArgument("Failed to deserialize validator id".to_string())
diff --git a/sentry/src/access.rs b/sentry/src/access.rs
@@ -256,7 +256,7 @@ mod test {
     async fn session_uid_rate_limit() {
         let (config, redis) = setup().await;
 
-        let session = &Session {
+        let session = Session {
             era: 0,
             uid: IDS["follower"].clone(),
             ip: Default::default(),
@@ -276,7 +276,7 @@ mod test {
 
         let response = check_access(
             &redis,
-            Some(session),
+            Some(&session),
             &config.ip_rate_limit,
             &channel,
             &events,
@@ -286,7 +286,7 @@ mod test {
 
         let err_response = check_access(
             &redis,
-            Some(session),
+            Some(&session),
             &config.ip_rate_limit,
             &channel,
             &events,
diff --git a/sentry/src/routes/channel.rs b/sentry/src/routes/channel.rs
@@ -58,15 +58,9 @@ pub async fn create_channel<A: Adapter>(
         Err(error) => {
             error!(&app.logger, "{}", &error; "module" => "create_channel");
             match error {
-                RunError::User(e) => {
-                    if e.code() == Some(&error::SqlState::UNIQUE_VIOLATION) {
-                        Err(ResponseError::Conflict(
-                            "channel already exists".to_string(),
-                        ))
-                    } else {
-                        Err(error_response)
-                    }
-                }
+                RunError::User(e) if e.code() == Some(&error::SqlState::UNIQUE_VIOLATION) => Err(
+                    ResponseError::Conflict("channel already exists".to_string()),
+                ),
                 _ => Err(error_response),
             }
         }
@@ -189,29 +183,25 @@ pub async fn insert_events<A: Adapter + 'static>(
     req: Request<Body>,
     app: &Application<A>,
 ) -> Result<Response<Body>, ResponseError> {
-    let session = req
-        .extensions()
-        .get::<Session>()
-        .map(ToOwned::to_owned)
-        .to_owned();
+    let (req_head, req_body) = req.into_parts();
+    let session = req_head.extensions.get::<Session>();
 
-    let route_params = req
-        .extensions()
+    let route_params = req_head
+        .extensions
         .get::<RouteParams>()
         .expect("request should have route params");
 
     let channel_id = ChannelId::from_hex(route_params.index(0))?;
 
-    let into_body = req.into_body();
-    let body = hyper::body::to_bytes(into_body).await?;
-    let request_body = serde_json::from_slice::<HashMap<String, Vec<Event>>>(&body)?;
+    let body_bytes = hyper::body::to_bytes(req_body).await?;
+    let request_body = serde_json::from_slice::<HashMap<String, Vec<Event>>>(&body_bytes)?;
 
     let events = request_body
         .get("events")
         .ok_or_else(|| ResponseError::BadRequest("invalid request".to_string()))?;
 
     app.event_aggregator
-        .record(app, &channel_id, session.as_ref(), &events)
+        .record(app, &channel_id, session, &events)
         .await?;
 
     Ok(Response::builder()
