Merge branch 'release-v0.9.2' into release

Author: sfackler

Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "postgres"
-version = "0.9.0"
+version = "0.9.2"
 authors = ["Steven Fackler <[email protected]>"]
 license = "MIT"
 description = "A native PostgreSQL driver"
 repository = "https://github.com/sfackler/rust-postgres"
-documentation = "https://sfackler.github.io/rust-postgres/doc/v0.9.0/postgres"
+documentation = "https://sfackler.github.io/rust-postgres/doc/v0.9.2/postgres"
 readme = "README.md"
 keywords = ["database", "sql"]
 build = "build.rs"
@@ -29,7 +29,6 @@ byteorder = "0.3"
 debug-builders = "0.1"
 log = "0.3"
 phf = "0.7"
-rust-crypto = "0.2"
 rustc-serialize = "0.3"
 chrono = { version = "0.2.14", optional = true }
 openssl = { version = "0.6", optional = true }

README.md

@@ -1,15 +1,15 @@
 # Rust-Postgres
 A native PostgreSQL driver for Rust.
 
-Documentation is available at https://sfackler.github.io/rust-postgres/doc/v0.8.9/postgres
+[Documentation](https://sfackler.github.io/rust-postgres/doc/v0.9.2/postgres)
 
 [![Build Status](https://travis-ci.org/sfackler/rust-postgres.png?branch=master)](https://travis-ci.org/sfackler/rust-postgres) [![Latest Version](https://img.shields.io/crates/v/postgres.svg)](https://crates.io/crates/postgres)
 
 You can integrate Rust-Postgres into your project through the [releases on crates.io](https://crates.io/crates/postgres):
 ```toml
 # Cargo.toml
 [dependencies]
-postgres = "0.8"
+postgres = "0.9"
 ```
 
 ## Overview

THIRD_PARTY

@@ -57,3 +57,34 @@ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
 IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
+
+-------------------------------------------------------------------------------
+
+* src/md5.rs has been copied from rust-crypto
+
+Copyright (c) 2006-2009 Graydon Hoare
+Copyright (c) 2009-2013 Mozilla Foundation
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

src/lib.rs

@@ -3,7 +3,6 @@
 //! package.
 //!
 //! ```rust,no_run
-//! # #![allow(unstable)]
 //! extern crate postgres;
 //!
 //! use postgres::{Connection, SslMode};
@@ -42,12 +41,11 @@
 //!     }
 //! }
 //! ```
-#![doc(html_root_url="https://sfackler.github.io/rust-postgres/doc/v0.9.0")]
+#![doc(html_root_url="https://sfackler.github.io/rust-postgres/doc/v0.9.2")]
 #![warn(missing_docs)]
 
 extern crate bufstream;
 extern crate byteorder;
-extern crate crypto;
 #[macro_use]
 extern crate log;
 extern crate phf;
@@ -57,8 +55,7 @@ extern crate unix_socket;
 extern crate debug_builders;
 
 use bufstream::BufStream;
-use crypto::digest::Digest;
-use crypto::md5::Md5;
+use md5::Md5;
 use debug_builders::DebugStruct;
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
@@ -95,6 +92,7 @@ mod url;
 mod util;
 pub mod types;
 pub mod rows;
+mod md5;
 
 const TYPEINFO_QUERY: &'static str = "t";
 
@@ -174,7 +172,7 @@ impl IntoConnectParams for Url {
 
         #[cfg(feature = "unix_socket")]
         fn make_unix(maybe_path: String) -> result::Result<ConnectTarget, ConnectError> {
-            Ok(ConnectTarget::Unix(PathBuf::from(&maybe_path)))
+            Ok(ConnectTarget::Unix(PathBuf::from(maybe_path)))
         }
         #[cfg(not(feature = "unix_socket"))]
         fn make_unix(_: String) -> result::Result<ConnectTarget, ConnectError> {
@@ -289,62 +287,6 @@ impl<'conn> Notifications<'conn> {
             _ => unreachable!()
         }
     }
-
-    /*
-    /// Returns the oldest pending notification
-    ///
-    /// If no notifications are pending, blocks for up to `timeout` time, after
-    /// which `None` is returned.
-    ///
-    /// ## Example
-    ///
-    /// ```rust,no_run
-    /// # #![allow(unstable)]
-    /// use std::old_io::{IoError, IoErrorKind};
-    /// use std::time::Duration;
-    ///
-    /// use postgres::Error;
-    ///
-    /// # let conn = postgres::Connection::connect("", &postgres::SslMode::None).unwrap();
-    /// match conn.notifications().next_block_for(Duration::seconds(2)) {
-    ///     Some(Ok(notification)) => println!("notification: {}", notification.payload),
-    ///     Some(Err(e)) => println!("Error: {:?}", e),
-    ///     None => println!("Wait for notification timed out"),
-    /// }
-    /// ```
-    pub fn next_block_for(&mut self, timeout: Duration) -> Option<Result<Notification>> {
-        if let Some(notification) = self.next() {
-            return Some(Ok(notification));
-        }
-
-        let mut conn = self.conn.conn.borrow_mut();
-        if conn.desynchronized {
-            return Some(Err(Error::StreamDesynchronized));
-        }
-
-        let end = SteadyTime::now() + timeout;
-        loop {
-            let timeout = max(Duration::zero(), end - SteadyTime::now()).num_milliseconds() as u64;
-            conn.stream.set_read_timeout(Some(timeout));
-            match conn.read_one_message() {
-                Ok(Some(NotificationResponse { pid, channel, payload })) => {
-                    return Some(Ok(Notification {
-                        pid: pid,
-                        channel: channel,
-                        payload: payload
-                    }))
-                }
-                Ok(Some(_)) => unreachable!(),
-                Ok(None) => {}
-                Err(IoError { kind: IoErrorKind::TimedOut, .. }) => {
-                    conn.desynchronized = false;
-                    return None;
-                }
-                Err(e) => return Some(Err(Error::IoError(e))),
-            }
-        }
-    }
-    */
 }
 
 /// Contains information necessary to cancel queries for a session.
@@ -467,9 +409,19 @@ pub enum SslMode {
     /// The connection will not use SSL.
     None,
     /// The connection will use SSL if the backend supports it.
-    Prefer(Box<NegotiateSsl>),
+    Prefer(Box<NegotiateSsl+std::marker::Sync+Send>),
     /// The connection must use SSL.
-    Require(Box<NegotiateSsl>),
+    Require(Box<NegotiateSsl+std::marker::Sync+Send>),
+}
+
+impl fmt::Debug for SslMode {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            SslMode::None => fmt.write_str("None"),
+            SslMode::Prefer(..) => fmt.write_str("Prefer"),
+            SslMode::Require(..) => fmt.write_str("Require"),
+        }
+    }
 }
 
 #[derive(Clone)]
@@ -479,10 +431,6 @@ struct CachedStatement {
     columns: Vec<Column>,
 }
 
-trait SessionInfoNew<'a> {
-    fn new(conn: &'a InnerConnection) -> SessionInfo<'a>;
-}
-
 struct InnerConnection {
     stream: BufStream<Box<StreamWrapper>>,
     notice_handler: Box<HandleNotice>,
@@ -597,27 +545,19 @@ impl InnerConnection {
         Ok(try_desync!(self, self.stream.flush()))
     }
 
-    fn read_one_message(&mut self) -> std_io::Result<Option<BackendMessage>> {
-        debug_assert!(!self.desynchronized);
-        match try_desync!(self, self.stream.read_message()) {
-            NoticeResponse { fields } => {
-                if let Ok(err) = DbError::new_raw(fields) {
-                    self.notice_handler.handle_notice(err);
-                }
-                Ok(None)
-            }
-            ParameterStatus { parameter, value } => {
-                self.parameters.insert(parameter, value);
-                Ok(None)
-            }
-            val => Ok(Some(val))
-        }
-    }
-
     fn read_message_with_notification(&mut self) -> std_io::Result<BackendMessage> {
+        debug_assert!(!self.desynchronized);
         loop {
-            if let Some(msg) = try!(self.read_one_message()) {
-                return Ok(msg);
+            match try_desync!(self, self.stream.read_message()) {
+                NoticeResponse { fields } => {
+                    if let Ok(err) = DbError::new_raw(fields) {
+                        self.notice_handler.handle_notice(err);
+                    }
+                }
+                ParameterStatus { parameter, value } => {
+                    self.parameters.insert(parameter, value);
+                }
+                val => return Ok(val)
             }
         }
     }
@@ -982,7 +922,6 @@ impl Connection {
     /// ```
     ///
     /// ```rust,no_run
-    /// # #![allow(unstable)]
     /// # use postgres::{Connection, UserInfo, ConnectParams, SslMode, ConnectTarget};
     /// # #[cfg(feature = "unix_socket")]
     /// # fn f() -> Result<(), ::postgres::error::ConnectError> {
@@ -1630,22 +1569,31 @@ impl<'conn> Statement<'conn> {
 
         let mut buf = vec![];
         loop {
-            match std::io::copy(&mut r.take(16 * 1024), &mut buf) {
+            match r.take(16 * 1024).read_to_end(&mut buf) {
                 Ok(0) => break,
-                Ok(len) => {
+                Ok(_) => {
                     try_desync!(conn, conn.stream.write_message(
-                            &CopyData {
-                                data: &buf[..len as usize],
-                            }));
+                        &CopyData {
+                            data: &buf,
+                        }));
                     buf.clear();
                 }
                 Err(err) => {
-                    // FIXME better to return the error directly
-                    try_desync!(conn, conn.stream.write_message(
-                            &CopyFail {
-                                message: &err.to_string(),
-                            }));
-                    break;
+                    try!(conn.write_messages(&[
+                        CopyFail {
+                            message: "",
+                        },
+                        CopyDone,
+                        Sync]));
+                    match try!(conn.read_message()) {
+                        ErrorResponse { .. } => { /* expected from the CopyFail */ }
+                        _ => {
+                            conn.desynchronized = true;
+                            return Err(Error::IoError(bad_response()));
+                        }
+                    }
+                    try!(conn.wait_for_ready());
+                    return Err(Error::IoError(err));
                 }
             }
         }
@@ -1833,3 +1781,7 @@ trait LazyRowsNew<'trans, 'stmt> {
            finished: bool,
            trans: &'trans Transaction<'trans>) -> LazyRows<'trans, 'stmt>;
 }
+
+trait SessionInfoNew<'a> {
+    fn new(conn: &'a InnerConnection) -> SessionInfo<'a>;
+}