Pull github interaction out of http module into a github module

Author: jtgeibel

src/github.rs

@@ -0,0 +1,94 @@
+use curl;
+use curl::easy::{Easy, List};
+
+use oauth2::*;
+
+use serde_json;
+use serde::Deserialize;
+
+use std::str;
+
+use app::App;
+use util::{human, internal, CargoResult, ChainError};
+
+/// Does all the nonsense for sending a GET to Github. Doesn't handle parsing
+/// because custom error-code handling may be desirable. Use
+/// `parse_github_response` to handle the "common" processing of responses.
+pub fn github(app: &App, url: &str, auth: &Token) -> Result<(Easy, Vec<u8>), curl::Error> {
+    let url = format!("{}://api.github.com{}", app.config.api_protocol, url);
+    info!("GITHUB HTTP: {}", url);
+
+    let mut headers = List::new();
+    headers
+        .append("Accept: application/vnd.github.v3+json")
+        .unwrap();
+    headers.append("User-Agent: hello!").unwrap();
+    headers
+        .append(&format!("Authorization: token {}", auth.access_token))
+        .unwrap();
+
+    let mut handle = app.handle();
+    handle.url(&url).unwrap();
+    handle.get(true).unwrap();
+    handle.http_headers(headers).unwrap();
+
+    let mut data = Vec::new();
+    {
+        let mut transfer = handle.transfer();
+        transfer
+            .write_function(|buf| {
+                data.extend_from_slice(buf);
+                Ok(buf.len())
+            })
+            .unwrap();
+        transfer.perform()?;
+    }
+    Ok((handle, data))
+}
+
+/// Checks for normal responses
+pub fn parse_github_response<'de, 'a: 'de, T: Deserialize<'de>>(
+    mut resp: Easy,
+    data: &'a [u8],
+) -> CargoResult<T> {
+    match resp.response_code().unwrap() {
+        200 => {}
+        // Ok!
+        403 => {
+            return Err(human(
+                "It looks like you don't have permission \
+                 to query a necessary property from Github \
+                 to complete this request. \
+                 You may need to re-authenticate on \
+                 crates.io to grant permission to read \
+                 github org memberships. Just go to \
+                 https://crates.io/login",
+            ));
+        }
+        n => {
+            let resp = String::from_utf8_lossy(data);
+            return Err(internal(&format_args!(
+                "didn't get a 200 result from \
+                 github, got {} with: {}",
+                n,
+                resp
+            )));
+        }
+    }
+
+    let json = str::from_utf8(data)
+        .ok()
+        .chain_error(|| internal("github didn't send a utf8-response"))?;
+
+    serde_json::from_str(json).chain_error(|| internal("github didn't send a valid json response"))
+}
+
+/// Gets a token with the given string as the access token, but all
+/// other info null'd out. Generally, just to be fed to the `github` fn.
+pub fn token(token: String) -> Token {
+    Token {
+        access_token: token,
+        scopes: Vec::new(),
+        token_type: String::new(),
+    }
+}

src/http.rs

@@ -1,104 +1,11 @@
 use conduit::{Request, Response};
 use conduit_middleware::Middleware;
 
-use curl;
-use curl::easy::{Easy, List};
-
-use oauth2::*;
-
-use serde_json;
-use serde::Deserialize;
-
-use std::str;
 use std::error::Error;
 use std::collections::HashMap;
 
-use app::App;
-use util::{human, internal, CargoResult, ChainError};
 use Uploader;
 
-/// Does all the nonsense for sending a GET to Github. Doesn't handle parsing
-/// because custom error-code handling may be desirable. Use
-/// `parse_github_response` to handle the "common" processing of responses.
-pub fn github(app: &App, url: &str, auth: &Token) -> Result<(Easy, Vec<u8>), curl::Error> {
-    let url = format!("{}://api.github.com{}", app.config.api_protocol, url);
-    info!("GITHUB HTTP: {}", url);
-
-    let mut headers = List::new();
-    headers
-        .append("Accept: application/vnd.github.v3+json")
-        .unwrap();
-    headers.append("User-Agent: hello!").unwrap();
-    headers
-        .append(&format!("Authorization: token {}", auth.access_token))
-        .unwrap();
-
-    let mut handle = app.handle();
-    handle.url(&url).unwrap();
-    handle.get(true).unwrap();
-    handle.http_headers(headers).unwrap();
-
-    let mut data = Vec::new();
-    {
-        let mut transfer = handle.transfer();
-        transfer
-            .write_function(|buf| {
-                data.extend_from_slice(buf);
-                Ok(buf.len())
-            })
-            .unwrap();
-        transfer.perform()?;
-    }
-    Ok((handle, data))
-}
-
-/// Checks for normal responses
-pub fn parse_github_response<'de, 'a: 'de, T: Deserialize<'de>>(
-    mut resp: Easy,
-    data: &'a [u8],
-) -> CargoResult<T> {
-    match resp.response_code().unwrap() {
-        200 => {}
-        // Ok!
-        403 => {
-            return Err(human(
-                "It looks like you don't have permission \
-                 to query a necessary property from Github \
-                 to complete this request. \
-                 You may need to re-authenticate on \
-                 crates.io to grant permission to read \
-                 github org memberships. Just go to \
-                 https://crates.io/login",
-            ));
-        }
-        n => {
-            let resp = String::from_utf8_lossy(data);
-            return Err(internal(&format_args!(
-                "didn't get a 200 result from \
-                 github, got {} with: {}",
-                n,
-                resp
-            )));
-        }
-    }
-
-    let json = str::from_utf8(data)
-        .ok()
-        .chain_error(|| internal("github didn't send a utf8-response"))?;
-
-    serde_json::from_str(json).chain_error(|| internal("github didn't send a valid json response"))
-}
-
-/// Gets a token with the given string as the access token, but all
-/// other info null'd out. Generally, just to be fed to the `github` fn.
-pub fn token(token: String) -> Token {
-    Token {
-        access_token: token,
-        scopes: Vec::new(),
-        token_type: String::new(),
-    }
-}
-
 #[derive(Clone, Debug)]
 pub struct SecurityHeadersMiddleware {
     headers: HashMap<String, Vec<String>>,

src/lib.rs

@@ -84,6 +84,7 @@ pub mod dependency;
 pub mod dist;
 pub mod download;
 pub mod git;
+pub mod github;
 pub mod http;
 pub mod keyword;
 pub mod krate;

src/owner.rs

@@ -1,7 +1,7 @@
 use diesel::prelude::*;
 
 use app::App;
-use http;
+use github;
 use schema::*;
 use util::{human, CargoResult};
 use {Crate, User};
@@ -184,9 +184,9 @@ impl Team {
         // FIXME: we just set per_page=100 and don't bother chasing pagination
         // links. A hundred teams should be enough for any org, right?
         let url = format!("/orgs/{}/teams?per_page=100", org_name);
-        let token = http::token(req_user.gh_access_token.clone());
-        let (handle, data) = http::github(app, &url, &token)?;
-        let teams: Vec<GithubTeam> = http::parse_github_response(handle, &data)?;
+        let token = github::token(req_user.gh_access_token.clone());
+        let (handle, data) = github::github(app, &url, &token)?;
+        let teams: Vec<GithubTeam> = github::parse_github_response(handle, &data)?;
 
         let team = teams
             .into_iter()
@@ -209,8 +209,8 @@ impl Team {
         }
 
         let url = format!("/orgs/{}", org_name);
-        let (handle, resp) = http::github(app, &url, &token)?;
-        let org: Org = http::parse_github_response(handle, &resp)?;
+        let (handle, resp) = github::github(app, &url, &token)?;
+        let org: Org = github::parse_github_response(handle, &resp)?;
 
         NewTeam::new(login, team.id, team.name, org.avatar_url).create_or_update(conn)
     }
@@ -276,15 +276,15 @@ fn team_with_gh_id_contains_user(app: &App, github_id: i32, user: &User) -> Carg
     }
 
     let url = format!("/teams/{}/memberships/{}", &github_id, &user.gh_login);
-    let token = http::token(user.gh_access_token.clone());
-    let (mut handle, resp) = http::github(app, &url, &token)?;
+    let token = github::token(user.gh_access_token.clone());
+    let (mut handle, resp) = github::github(app, &url, &token)?;
 
     // Officially how `false` is returned
     if handle.response_code().unwrap() == 404 {
         return Ok(false);
     }
 
-    let membership: Membership = http::parse_github_response(handle, &resp)?;
+    let membership: Membership = github::parse_github_response(handle, &resp)?;
 
     // There is also `state: pending` for which we could possibly give
     // some feedback, but it's not obvious how that should work.

src/user/mod.rs

@@ -14,7 +14,7 @@ use pagination::Paginate;
 use schema::*;
 use util::{bad_request, human, CargoResult, RequestUtils};
 use version::EncodableVersion;
-use {http, Version};
+use {github, Version};
 use owner::{CrateOwner, Owner, OwnerKind};
 use krate::Crate;
 use email;
@@ -375,8 +375,8 @@ pub fn github_access_token(req: &mut Request) -> CargoResult<Response> {
         .exchange(code.clone())
         .map_err(|s| human(&s))?;
 
-    let (handle, resp) = http::github(req.app(), "/user", &token)?;
-    let ghuser: GithubUser = http::parse_github_response(handle, &resp)?;
+    let (handle, resp) = github::github(req.app(), "/user", &token)?;
+    let ghuser: GithubUser = github::parse_github_response(handle, &resp)?;
 
     let user = NewUser::new(
         ghuser.id,