Remove duplicate calls to db_conn in a single endpoint

These endpoints are obtaining two separate connections for each
request.  If there is a backlog of requests, then these endpoints will
wait in line multiple times for a database connection.

Any request with an auth token or cookie will also obtain and drop a
connection in the `CurrentUser` middleware.  We could consider caching
and reusing this database connection as well.

Author: jtgeibel

src/controllers/krate/follow.rs

@@ -3,16 +3,16 @@
 use diesel::associations::Identifiable;
 
 use crate::controllers::prelude::*;
+use crate::db::DieselPooledConn;
 use crate::models::{Crate, Follow};
 use crate::schema::*;
 
-fn follow_target(req: &mut dyn Request) -> CargoResult<Follow> {
+fn follow_target(req: &dyn Request, conn: &DieselPooledConn<'_>) -> CargoResult<Follow> {
     let user = req.user()?;
-    let conn = req.db_conn()?;
     let crate_name = &req.params()["crate_id"];
     let crate_id = Crate::by_name(crate_name)
         .select(crates::id)
-        .first(&*conn)?;
+        .first(&**conn)?;
     Ok(Follow {
         user_id: user.id,
         crate_id,
@@ -21,8 +21,8 @@ fn follow_target(req: &mut dyn Request) -> CargoResult<Follow> {
 
 /// Handles the `PUT /crates/:crate_id/follow` route.
 pub fn follow(req: &mut dyn Request) -> CargoResult<Response> {
-    let follow = follow_target(req)?;
     let conn = req.db_conn()?;
+    let follow = follow_target(req, &conn)?;
     diesel::insert_into(follows::table)
         .values(&follow)
         .on_conflict_do_nothing()
@@ -33,8 +33,8 @@ pub fn follow(req: &mut dyn Request) -> CargoResult<Response> {
 
 /// Handles the `DELETE /crates/:crate_id/follow` route.
 pub fn unfollow(req: &mut dyn Request) -> CargoResult<Response> {
-    let follow = follow_target(req)?;
     let conn = req.db_conn()?;
+    let follow = follow_target(req, &conn)?;
     diesel::delete(&follow).execute(&*conn)?;
 
     ok_true()
@@ -44,8 +44,8 @@ pub fn unfollow(req: &mut dyn Request) -> CargoResult<Response> {
 pub fn following(req: &mut dyn Request) -> CargoResult<Response> {
     use diesel::dsl::exists;
 
-    let follow = follow_target(req)?;
     let conn = req.db_conn()?;
+    let follow = follow_target(req, &conn)?;
     let following = diesel::select(exists(follows::table.find(follow.id()))).get_result(&*conn)?;
 
     #[derive(Serialize)]

src/controllers/token.rs

@@ -65,19 +65,20 @@ pub fn new(req: &mut dyn Request) -> CargoResult<Response> {
     }
 
     let user = req.user()?;
+    let conn = req.db_conn()?;
 
     let max_token_per_user = 500;
     let count = ApiToken::belonging_to(user)
         .count()
-        .get_result::<i64>(&*req.db_conn()?)?;
+        .get_result::<i64>(&*conn)?;
     if count >= max_token_per_user {
         return Err(bad_request(&format!(
             "maximum tokens per user is: {}",
             max_token_per_user
         )));
     }
 
-    let api_token = ApiToken::insert(&*req.db_conn()?, user.id, name)?;
+    let api_token = ApiToken::insert(&*conn, user.id, name)?;
 
     #[derive(Serialize)]
     struct R {