Update deps, primarily postgres

Author: alexcrichton

Cargo.lock

@@ -47,7 +47,7 @@ git2 = "0.2"
 flate2 = "0.2"
 semver = "0.1.3"
 url = "0.2.0"
-postgres = { version = "0.9", features = ["time"] }
+postgres = { version = "0.10", features = ["time"] }
 r2d2 = "0.6.0"
 r2d2_postgres = "0.9"
 openssl = "0.6"

Cargo.toml

@@ -4,7 +4,7 @@ use std::mem;
 use std::sync::Arc;
 
 use pg;
-use pg::types::ToSql;
+use pg::GenericConnection;
 use r2d2;
 use r2d2_postgres;
 use r2d2_postgres::PostgresConnectionManager as PCM;
@@ -59,7 +59,7 @@ impl Transaction {
         Ok(&**self.slot.borrow().unwrap())
     }
 
-    fn tx<'a>(&'a self) -> CargoResult<&'a (Connection + 'a)> {
+    fn tx<'a>(&'a self) -> CargoResult<&'a (GenericConnection + 'a)> {
         // Similar to above, the transaction for this request is actually tied
         // to the connection in the request itself, not 'static. We transmute it
         // to static as its paired with the inner connection to achieve the
@@ -116,7 +116,7 @@ pub trait RequestTransaction {
     ///
     /// The transaction will live for the duration of the request, and it will
     /// only be set to commit() if a successful response code of 200 is seen.
-    fn tx(&self) -> CargoResult<&Connection>;
+    fn tx(&self) -> CargoResult<&GenericConnection>;
 
     /// Flag the transaction to not be committed
     fn rollback(&self);
@@ -131,7 +131,7 @@ impl<'a> RequestTransaction for Request + 'a {
             .conn()
     }
 
-    fn tx(&self) -> CargoResult<&Connection> {
+    fn tx(&self) -> CargoResult<&GenericConnection> {
         self.extensions().find::<Transaction>()
             .expect("Transaction not present in request")
             .tx()
@@ -149,28 +149,3 @@ impl<'a> RequestTransaction for Request + 'a {
             .commit()
     }
 }
-
-pub trait Connection {
-    fn prepare(&self, query: &str) -> pg::Result<pg::Statement>;
-    fn execute(&self, query: &str, params: &[&ToSql]) -> pg::Result<u64>;
-}
-
-impl Connection for pg::Connection {
-    fn prepare(&self, query: &str) -> pg::Result<pg::Statement> {
-        self.prepare(query)
-    }
-    fn execute(&self, query: &str, params: &[&ToSql]) -> pg::Result<u64> {
-        self.execute(query, params)
-    }
-}
-
-impl<'a> Connection for pg::Transaction<'a> {
-    fn prepare(&self, query: &str) -> pg::Result<pg::Statement> {
-        trace!("prepare: {}", query);
-        self.prepare(query)
-    }
-    fn execute(&self, query: &str, params: &[&ToSql]) -> pg::Result<u64> {
-        trace!("execute: {}", query);
-        self.execute(query, params)
-    }
-}

src/db.rs

@@ -1,9 +1,9 @@
+use pg::GenericConnection;
+use pg::rows::Row;
 use semver;
 
-use pg::rows::Row;
 use Model;
 use git;
-use db::Connection;
 use util::{CargoResult};
 
 pub struct Dependency {
@@ -43,7 +43,7 @@ pub enum Kind {
 }
 
 impl Dependency {
-    pub fn insert(conn: &Connection, version_id: i32, crate_id: i32,
+    pub fn insert(conn: &GenericConnection, version_id: i32, crate_id: i32,
                   req: &semver::VersionReq, kind: Kind,
                   optional: bool, default_features: bool,
                   features: &[String], target: &Option<String>)

src/dependency.rs

@@ -1,8 +1,8 @@
+use pg::GenericConnection;
+use pg::rows::Row;
 use time::Timespec;
 
-use pg::rows::Row;
 use Model;
-use db::Connection;
 use util::CargoResult;
 
 pub struct VersionDownload {
@@ -22,7 +22,8 @@ pub struct EncodableVersionDownload {
 }
 
 impl VersionDownload {
-    pub fn find(conn: &Connection, id: i32) -> CargoResult<VersionDownload> {
+    pub fn find(conn: &GenericConnection,
+                id: i32) -> CargoResult<VersionDownload> {
         Model::find(conn, id)
     }
 
@@ -60,7 +61,7 @@ pub struct CrateDownload {
 }
 
 impl CrateDownload {
-    pub fn find(conn: &Connection, id: i32) -> CargoResult<CrateDownload> {
+    pub fn find(conn: &GenericConnection, id: i32) -> CargoResult<CrateDownload> {
         Model::find(conn, id)
     }
 }

src/download.rs

@@ -4,11 +4,12 @@ use time::Timespec;
 
 use conduit::{Request, Response};
 use conduit_router::RequestParams;
+use pg::GenericConnection;
 use pg::rows::Row;
 use pg::types::Slice;
 
 use {Model, Crate};
-use db::{Connection, RequestTransaction};
+use db::RequestTransaction;
 use util::{RequestUtils, CargoResult, ChainError, internal};
 use util::errors::NotFound;
 
@@ -29,19 +30,19 @@ pub struct EncodableKeyword {
 }
 
 impl Keyword {
-    pub fn find(conn: &Connection, id: i32) -> CargoResult<Keyword> {
+    pub fn find(conn: &GenericConnection, id: i32) -> CargoResult<Keyword> {
         Model::find(conn, id)
     }
 
-    pub fn find_by_keyword(conn: &Connection, name: &str)
+    pub fn find_by_keyword(conn: &GenericConnection, name: &str)
                            -> CargoResult<Option<Keyword>> {
         let stmt = try!(conn.prepare("SELECT * FROM keywords \
                                       WHERE keyword = $1"));
         let rows = try!(stmt.query(&[&name]));
         Ok(rows.iter().next().map(|r| Model::from_row(&r)))
     }
 
-    pub fn find_or_insert(conn: &Connection, name: &str)
+    pub fn find_or_insert(conn: &GenericConnection, name: &str)
                           -> CargoResult<Keyword> {
         // TODO: racy (the select then insert is not atomic)
         let stmt = try!(conn.prepare("SELECT * FROM keywords
@@ -78,7 +79,8 @@ impl Keyword {
         }
     }
 
-    pub fn update_crate(conn: &Connection, krate: &Crate,
+    pub fn update_crate(conn: &GenericConnection,
+                        krate: &Crate,
                         keywords: &[String]) -> CargoResult<()> {
         let old_kws = try!(krate.keywords(conn));
         let old_kws = old_kws.iter().map(|kw| {

src/keyword.rs

@@ -11,6 +11,7 @@ use conduit::{Request, Response};
 use conduit_router::RequestParams;
 use curl::http;
 use license_exprs;
+use pg::GenericConnection;
 use pg::rows::Row;
 use pg::types::{ToSql, Slice};
 use pg;
@@ -22,7 +23,7 @@ use url::{self, Url};
 
 use {Model, User, Keyword, Version};
 use app::{App, RequestApp};
-use db::{Connection, RequestTransaction};
+use db::RequestTransaction;
 use dependency::{Dependency, EncodableDependency};
 use download::{VersionDownload, EncodableVersionDownload};
 use git;
@@ -80,11 +81,12 @@ pub struct CrateLinks {
 }
 
 impl Crate {
-    pub fn find(conn: &Connection, id: i32) -> CargoResult<Crate> {
+    pub fn find(conn: &GenericConnection, id: i32) -> CargoResult<Crate> {
         Model::find(conn, id)
     }
 
-    pub fn find_by_name(conn: &Connection, name: &str) -> CargoResult<Crate> {
+    pub fn find_by_name(conn: &GenericConnection,
+                        name: &str) -> CargoResult<Crate> {
         let stmt = try!(conn.prepare("SELECT * FROM crates \
                                       WHERE canon_crate_name(name) =
                                             canon_crate_name($1) LIMIT 1"));
@@ -93,7 +95,8 @@ impl Crate {
         Ok(Model::from_row(&row))
     }
 
-    pub fn find_or_insert(conn: &Connection, name: &str,
+    pub fn find_or_insert(conn: &GenericConnection,
+                          name: &str,
                           user_id: i32,
                           description: &Option<String>,
                           homepage: &Option<String>,
@@ -271,7 +274,7 @@ impl Crate {
         }
     }
 
-    pub fn versions(&self, conn: &Connection) -> CargoResult<Vec<Version>> {
+    pub fn versions(&self, conn: &GenericConnection) -> CargoResult<Vec<Version>> {
         let stmt = try!(conn.prepare("SELECT * FROM versions \
                                       WHERE crate_id = $1"));
         let rows = try!(stmt.query(&[&self.id]));
@@ -282,7 +285,7 @@ impl Crate {
         Ok(ret)
     }
 
-    pub fn owners(&self, conn: &Connection) -> CargoResult<Vec<Owner>> {
+    pub fn owners(&self, conn: &GenericConnection) -> CargoResult<Vec<Owner>> {
         let stmt = try!(conn.prepare("SELECT * FROM users
                                       INNER JOIN crate_owners
                                          ON crate_owners.owner_id = users.id
@@ -305,7 +308,7 @@ impl Crate {
         Ok(owners)
     }
 
-    pub fn owner_add(&self, app: &App, conn: &Connection, req_user: &User,
+    pub fn owner_add(&self, app: &App, conn: &GenericConnection, req_user: &User,
                      login: &str) -> CargoResult<()> {
         let owner = match Owner::find_by_login(conn, login) {
             Ok(owner @ Owner::User(_)) => { owner }
@@ -343,7 +346,9 @@ impl Crate {
         Ok(())
     }
 
-    pub fn owner_remove(&self, conn: &Connection, _req_user: &User,
+    pub fn owner_remove(&self,
+                        conn: &GenericConnection,
+                        _req_user: &User,
                         login: &str) -> CargoResult<()> {
         let owner = try!(Owner::find_by_login(conn, login).map_err(|_| {
             human(format!("could not find owner with login `{}`", login))
@@ -360,7 +365,9 @@ impl Crate {
         format!("/crates/{}/{}-{}.crate", self.name, self.name, version)
     }
 
-    pub fn add_version(&mut self, conn: &Connection, ver: &semver::Version,
+    pub fn add_version(&mut self,
+                       conn: &GenericConnection,
+                       ver: &semver::Version,
                        features: &HashMap<String, Vec<String>>,
                        authors: &[String])
                        -> CargoResult<Version> {
@@ -383,7 +390,7 @@ impl Crate {
         Version::insert(conn, self.id, ver, features, authors)
     }
 
-    pub fn keywords(&self, conn: &Connection) -> CargoResult<Vec<Keyword>> {
+    pub fn keywords(&self, conn: &GenericConnection) -> CargoResult<Vec<Keyword>> {
         let stmt = try!(conn.prepare("SELECT keywords.* FROM keywords
                                       LEFT JOIN crates_keywords
                                       ON keywords.id = crates_keywords.keyword_id
@@ -393,7 +400,10 @@ impl Crate {
     }
 
     /// Returns (dependency, dependent crate name)
-    pub fn reverse_dependencies(&self, conn: &Connection, offset: i64, limit: i64)
+    pub fn reverse_dependencies(&self,
+                                conn: &GenericConnection,
+                                offset: i64,
+                                limit: i64)
                                 -> CargoResult<(Vec<(Dependency, String)>, i64)> {
         let select_sql = "
               FROM dependencies
@@ -589,7 +599,7 @@ pub fn summary(req: &mut Request) -> CargoResult<Response> {
         rows.iter().next().unwrap().get("total_downloads")
     };
 
-    let to_crates = |stmt: pg::Statement| -> CargoResult<Vec<EncodableCrate>> {
+    let to_crates = |stmt: pg::stmt::Statement| -> CargoResult<Vec<_>> {
         let rows = try!(stmt.query(&[]));
         Ok(rows.iter().map(|r| {
             let krate: Crate = Model::from_row(&r);

src/krate.rs

@@ -8,4 +8,4 @@ name = "migrate"
 path = "lib.rs"
 
 [dependencies]
-postgres = "0.9"
+postgres = "0.10"

src/migrate/Cargo.toml

@@ -1,13 +1,14 @@
 use pg::rows::Row;
-use db::Connection;
+use pg::GenericConnection;
+
 use util::{CargoResult, ChainError};
 use util::errors::NotFound;
 
 pub trait Model: Sized {
     fn from_row(row: &Row) -> Self;
     fn table_name(_: Option<Self>) -> &'static str;
 
-    fn find(conn: &Connection, id: i32) -> CargoResult<Self> {
+    fn find(conn: &GenericConnection, id: i32) -> CargoResult<Self> {
         let sql = format!("SELECT * FROM {} WHERE id = $1",
                           Model::table_name(None::<Self>));
         let stmt = try!(conn.prepare(&sql));

src/model.rs

@@ -1,7 +1,8 @@
+use pg::GenericConnection;
+use pg::rows::Row;
+
 use {Model, User};
 use util::{RequestUtils, CargoResult, ChainError, human};
-use db::Connection;
-use pg::rows::Row;
 use util::errors::NotFound;
 use http;
 use app::App;
@@ -58,7 +59,8 @@ pub enum Rights {
 
 impl Team {
     /// Just gets the Team from the database by name.
-    pub fn find_by_login(conn: &Connection, login: &str) -> CargoResult<Self> {
+    pub fn find_by_login(conn: &GenericConnection,
+                         login: &str) -> CargoResult<Self> {
         let stmt = try!(conn.prepare("SELECT * FROM teams
                                       WHERE login = $1"));
         let rows = try!(stmt.query(&[&login]));
@@ -69,8 +71,11 @@ impl Team {
     }
 
     /// Tries to create the Team in the DB (assumes a `:` has already been found).
-    pub fn create(app: &App, conn: &Connection, login: &str, req_user: &User)
-                                                    -> CargoResult<Self> {
+    pub fn create(app: &App,
+                  conn: &GenericConnection,
+                  login: &str,
+                  req_user: &User)
+                  -> CargoResult<Self> {
         // must look like system:xxxxxxx
         let mut chunks = login.split(":");
         match chunks.next().unwrap() {
@@ -94,7 +99,7 @@ impl Team {
     /// Tries to create a Github Team from scratch. Assumes `org` and `team` are
     /// correctly parsed out of the full `name`. `name` is passed as a
     /// convenience to avoid rebuilding it.
-    pub fn create_github_team(app: &App, conn: &Connection, login: &str,
+    pub fn create_github_team(app: &App, conn: &GenericConnection, login: &str,
                               org_name: &str, team_name: &str, req_user: &User)
                               -> CargoResult<Self> {
         // GET orgs/:org/teams
@@ -150,7 +155,7 @@ impl Team {
         Team::insert(conn, login, team.id, team.name, org.avatar_url)
     }
 
-    pub fn insert(conn: &Connection,
+    pub fn insert(conn: &GenericConnection,
                   login: &str,
                   github_id: i32,
                   name: Option<String>,
@@ -219,7 +224,8 @@ impl Owner {
     /// Finds the owner by name, failing out if it doesn't exist.
     /// May be a user's GH login, or a full team name. This is case
     /// sensitive.
-    pub fn find_by_login(conn: &Connection, name: &str) -> CargoResult<Owner> {
+    pub fn find_by_login(conn: &GenericConnection,
+                         name: &str) -> CargoResult<Owner> {
         let owner = if name.contains(":") {
             Owner::Team(try!(Team::find_by_login(conn, name).map_err(|_|
                 human(format!("could not find team with name {}", name))