Merge #1102

1102: Split krate and version functionality into submodules r=carols10cents

This series of commits splits the api endpoints in the `krate` and `version` modules into submodules as an initial step of the refactoring discussed in #912.

## Module structure

### `krate::search::search`

Shared by cargo and the frontend, used for searching crates.

### `krate::publish::publish`

Used by `cargo publish`.  This endpoint updates the index, uploads to S3, and caches crate metadata in the database.

### `{krate,version}/metadata.rs`

Endpoints in these files provide read-only access to data that could largely be recreated by replaying all crate uploads.  The only exception I've seen to this so far is that some responses include download counts.

### `{krate,version}/downloads.rs`

Provide crate and version level download stats (updated in `version::cargo::download`).

### `krate/owners.rs`

All endpoints for the used by cargo and the frontend for maintaining the list of crate owners.

### `krate/follow.rs`

Read/write access to a user populated list of followed crates.

### `version::deprecated`

The `version::deprecated::{index,show}` routes appear to be unused.  We should confirm this and discuss a plan for potential removal.

### `version::yank`

Yank and unyank functionality.

## Code that remains in `mod.rs`

The code that remains in the `mod.rs` files consists primarily of structs for querying, inserting, and serializing.  I'm thinking that these structs could be moved to modules under a `src/models` directory along with: `src/category.rs`, `src/dependency.rs`, `src/download.rs`, `src/owner.rs`.  (The `keyword`, `token` and `user` modules also have model logic which can be extracted.)

## Remaining work

In order to simplify review of this PR, I've only moved code around and haven't done any refactoring of logic.  There are probably bits of code that we can move from the endpoints to the model logic, especially if it returns a QueryResult.  Feel free to let me know if you see any low-hanging fruit there, otherwise we can address that in a future PR.  (Some of the logic still in `mod.rs` returns CargoResult which covers all error types.  We will probably need to put some thought into if the model represents just the database or also includes the index and S3 state.  I think further exploration of this is best tracked under #912.)

/cc @vignesh-sankaran @kureuil

Author: bors-voyager[bot]

src/krate/downloads.rs

@@ -0,0 +1,73 @@
+//! Endpoint for exposing crate download counts
+//!
+//! The enpoints for download a crate and exposing version specific
+//! download counts are located in `krate::downloads`.
+
+use std::cmp;
+
+use conduit::{Request, Response};
+use conduit_router::RequestParams;
+use diesel::prelude::*;
+
+use db::RequestTransaction;
+use download::{EncodableVersionDownload, VersionDownload};
+use schema::*;
+use util::{CargoResult, RequestUtils};
+use Version;
+
+use super::{to_char, Crate};
+
+/// Handles the `GET /crates/:crate_id/downloads` route.
+pub fn downloads(req: &mut Request) -> CargoResult<Response> {
+    use diesel::expression::dsl::*;
+    use diesel::types::BigInt;
+
+    let crate_name = &req.params()["crate_id"];
+    let conn = req.db_conn()?;
+    let krate = Crate::by_name(crate_name).first::<Crate>(&*conn)?;
+
+    let mut versions = Version::belonging_to(&krate).load::<Version>(&*conn)?;
+    versions.sort_by(|a, b| b.num.cmp(&a.num));
+    let (latest_five, rest) = versions.split_at(cmp::min(5, versions.len()));
+
+    let downloads = VersionDownload::belonging_to(latest_five)
+        .filter(version_downloads::date.gt(date(now - 90.days())))
+        .order(version_downloads::date.asc())
+        .load(&*conn)?
+        .into_iter()
+        .map(VersionDownload::encodable)
+        .collect::<Vec<_>>();
+
+    let sum_downloads = sql::<BigInt>("SUM(version_downloads.downloads)");
+    let extra = VersionDownload::belonging_to(rest)
+        .select((
+            to_char(version_downloads::date, "YYYY-MM-DD"),
+            sum_downloads,
+        ))
+        .filter(version_downloads::date.gt(date(now - 90.days())))
+        .group_by(version_downloads::date)
+        .order(version_downloads::date.asc())
+        .load::<ExtraDownload>(&*conn)?;
+
+    #[derive(Serialize, Queryable)]
+    struct ExtraDownload {
+        date: String,
+        downloads: i64,
+    }
+    #[derive(Serialize)]
+    struct R {
+        version_downloads: Vec<EncodableVersionDownload>,
+        meta: Meta,
+    }
+    #[derive(Serialize)]
+    struct Meta {
+        extra_downloads: Vec<ExtraDownload>,
+    }
+    let meta = Meta {
+        extra_downloads: extra,
+    };
+    Ok(req.json(&R {
+        version_downloads: downloads,
+        meta: meta,
+    }))
+}

src/krate/follow.rs

@@ -0,0 +1,68 @@
+//! Endpoints for managing a per user list of followed crates
+
+use conduit::{Request, Response};
+use conduit_router::RequestParams;
+use diesel::associations::Identifiable;
+use diesel::pg::upsert::*;
+use diesel::prelude::*;
+use diesel;
+
+use db::RequestTransaction;
+use schema::*;
+use user::RequestUser;
+use util::{CargoResult, RequestUtils};
+
+use super::{Crate, Follow};
+
+fn follow_target(req: &mut Request) -> 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)?;
+    Ok(Follow {
+        user_id: user.id,
+        crate_id: crate_id,
+    })
+}
+
+/// Handles the `PUT /crates/:crate_id/follow` route.
+pub fn follow(req: &mut Request) -> CargoResult<Response> {
+    let follow = follow_target(req)?;
+    let conn = req.db_conn()?;
+    diesel::insert(&follow.on_conflict_do_nothing())
+        .into(follows::table)
+        .execute(&*conn)?;
+    #[derive(Serialize)]
+    struct R {
+        ok: bool,
+    }
+    Ok(req.json(&R { ok: true }))
+}
+
+/// Handles the `DELETE /crates/:crate_id/follow` route.
+pub fn unfollow(req: &mut Request) -> CargoResult<Response> {
+    let follow = follow_target(req)?;
+    let conn = req.db_conn()?;
+    diesel::delete(&follow).execute(&*conn)?;
+    #[derive(Serialize)]
+    struct R {
+        ok: bool,
+    }
+    Ok(req.json(&R { ok: true }))
+}
+
+/// Handles the `GET /crates/:crate_id/following` route.
+pub fn following(req: &mut Request) -> CargoResult<Response> {
+    use diesel::expression::dsl::exists;
+
+    let follow = follow_target(req)?;
+    let conn = req.db_conn()?;
+    let following = diesel::select(exists(follows::table.find(follow.id()))).get_result(&*conn)?;
+    #[derive(Serialize)]
+    struct R {
+        following: bool,
+    }
+    Ok(req.json(&R {
+        following: following,
+    }))
+}