update to latest bson version (#191)

Author: saghm

Cargo.toml

@@ -20,7 +20,7 @@ sync = ["async-std-runtime"]
 async-trait = "0.1.24"
 base64 = "0.11.0"
 bitflags = "1.1.0"
-bson = "0.14.1"
+bson = "0.15.0"
 chrono = "0.4.7"
 derivative = "2.1.1"
 err-derive = "0.2.3"

src/bson_util/async_encoding.rs

@@ -1,7 +1,7 @@
-use bson::Document;
 use futures::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 
 use crate::{
+    bson::Document,
     error::Result,
     runtime::{AsyncLittleEndianRead, AsyncLittleEndianWrite},
 };
@@ -19,7 +19,7 @@ pub(crate) async fn decode_document<R: AsyncRead + Unpin + Send>(
         .read_to_end(&mut bytes)
         .await?;
 
-    let document = bson::decode_document(&mut bytes.as_slice())?;
+    let document = Document::from_reader(&mut bytes.as_slice())?;
     Ok(document)
 }
 
@@ -29,7 +29,7 @@ pub(crate) async fn encode_document<W: AsyncWrite + Unpin + Send>(
 ) -> Result<()> {
     let mut bytes = Vec::new();
 
-    bson::encode_document(&mut bytes, document)?;
+    document.to_writer(&mut bytes)?;
 
     writer.write_all(&bytes).await?;
 

src/bson_util/mod.rs

@@ -2,25 +2,27 @@ pub(crate) mod async_encoding;
 
 use std::time::Duration;
 
-use bson::{doc, oid::ObjectId, Bson, Document};
 use serde::{ser, Deserialize, Deserializer, Serialize, Serializer};
 
-use crate::error::{ErrorKind, Result};
+use crate::{
+    bson::{doc, oid::ObjectId, Binary, Bson, Document, JavaScriptCodeWithScope, Regex},
+    error::{ErrorKind, Result},
+};
 
 /// Coerce numeric types into an `i64` if it would be lossless to do so. If this Bson is not numeric
 /// or the conversion would be lossy (e.g. 1.5 -> 1), this returns `None`.
 pub(crate) fn get_int(val: &Bson) -> Option<i64> {
     match *val {
-        Bson::I32(i) => Some(i64::from(i)),
-        Bson::I64(i) => Some(i),
-        Bson::FloatingPoint(f) if f == f as i64 as f64 => Some(f as i64),
+        Bson::Int32(i) => Some(i64::from(i)),
+        Bson::Int64(i) => Some(i),
+        Bson::Double(f) if f == f as i64 as f64 => Some(f as i64),
         _ => None,
     }
 }
 
 pub(crate) fn add_id(doc: &mut Document) {
     doc.entry("_id".to_string())
-        .or_insert_with(|| Bson::ObjectId(ObjectId::new().unwrap()));
+        .or_insert_with(|| Bson::ObjectId(ObjectId::new()));
 }
 
 pub(crate) fn to_bson_array(docs: &[Document]) -> Bson {
@@ -61,12 +63,15 @@ pub(crate) fn update_document_check(update: &Document) -> Result<()> {
     }
 }
 
-pub(crate) fn serialize_duration_as_i64_millis<S: Serializer>(
+pub(crate) fn serialize_duration_as_int_millis<S: Serializer>(
     val: &Option<Duration>,
     serializer: S,
 ) -> std::result::Result<S::Ok, S::Error> {
     match val {
-        Some(duration) => serializer.serialize_i64(duration.as_millis() as i64),
+        Some(duration) if duration.as_millis() > i32::MAX as u128 => {
+            serializer.serialize_i64(duration.as_millis() as i64)
+        }
+        Some(duration) => serializer.serialize_i32(duration.as_millis() as i32),
         None => serializer.serialize_none(),
     }
 }
@@ -128,7 +133,7 @@ pub fn doc_size_bytes(doc: &Document) -> usize {
 
 pub fn size_bytes(val: &Bson) -> usize {
     match val {
-        Bson::FloatingPoint(_) => 8,
+        Bson::Double(_) => 8,
         // 
         // * length prefix (4 bytes)
         // * number of UTF-8 bytes
@@ -158,7 +163,9 @@ pub fn size_bytes(val: &Bson) -> usize {
         // for $pattern and $opts:
         //   * number of UTF-8 bytes
         //   * null terminator (1 byte)
-        Bson::RegExp(pattern, opts) => pattern.len() + 1 + opts.len() + 1,
+        Bson::RegularExpression(Regex { pattern, options }) => {
+            pattern.len() + 1 + options.len() + 1
+        }
         // 
         // * length prefix (4 bytes)
         // * number of UTF-8 bytes
@@ -170,24 +177,37 @@ pub fn size_bytes(val: &Bson) -> usize {
         // * number of UTF-8 bytes in code
         // * null terminator for code (1 byte)
         // * length of document
-        Bson::JavaScriptCodeWithScope(code, scope) => {
+        Bson::JavaScriptCodeWithScope(JavaScriptCodeWithScope { code, scope }) => {
             4 + 4 + code.len() + 1 + doc_size_bytes(scope)
         }
-        Bson::I32(_) => 4,
-        Bson::I64(_) => 8,
-        Bson::TimeStamp(_) => 8,
+        Bson::Int32(_) => 4,
+        Bson::Int64(_) => 8,
+        Bson::Timestamp(_) => 8,
         // 
         // * i32 length prefix (4 bytes)
         // * subtype (1 byte)
         // * number of bytes
-        Bson::Binary(_, bytes) => 4 + 1 + bytes.len(),
+        Bson::Binary(Binary { bytes, .. }) => 4 + 1 + bytes.len(),
         Bson::ObjectId(_) => 12,
-        Bson::UtcDatetime(_) => 8,
+        Bson::DateTime(_) => 8,
         // 
         // * i32 length prefix (4 bytes)
         // * subtype (1 byte)
         // * number of UTF-8 bytes
         Bson::Symbol(s) => 4 + 1 + s.len(),
+        Bson::Decimal128(..) => 128 / 8,
+        Bson::Undefined | Bson::MaxKey | Bson::MinKey => 0,
+        // DbPointer doesn't have public details exposed by the BSON library, but it comprises of a
+        // namespace and an ObjectId. Since our methods to calculate the size of BSON values are
+        // only used to estimate the cutoff for batches when making a large insert, we can just
+        // assume the largest possible size for a namespace, which is 120 bytes. Therefore, the size
+        // is:
+        //
+        // * i32 length prefix (4 bytes)
+        // * namespace (120 bytes)
+        // * null terminator (1 byte)
+        // * objectid (12 bytes)
+        Bson::DbPointer(..) => 4 + 120 + 1 + 12,
     }
 }
 
@@ -209,7 +229,16 @@ fn num_decimal_digits(n: usize) -> usize {
 
 #[cfg(test)]
 mod test {
-    use bson::{doc, oid::ObjectId, spec::BinarySubtype, Bson};
+    use crate::bson::{
+        doc,
+        oid::ObjectId,
+        spec::BinarySubtype,
+        Binary,
+        Bson,
+        JavaScriptCodeWithScope,
+        Regex,
+        Timestamp,
+    };
     use chrono::{DateTime, NaiveDateTime, Utc};
 
     use super::doc_size_bytes;
@@ -220,23 +249,23 @@ mod test {
         let doc = doc! {
             "double": -12.3,
             "string": "foo",
-            "array": ["foobar", -7, Bson::Null, Bson::TimeStamp(1278), false],
+            "array": ["foobar", -7, Bson::Null, Bson::Timestamp(Timestamp { time: 12345, increment: 67890 }), false],
             "document": {
                 "x": 1,
                 "yyz": "Rush is one of the greatest bands of all time",
             },
             "bool": true,
             "null": Bson::Null,
-            "regex": Bson::RegExp("foobar".into(), "i".into()),
+            "regex": Bson::RegularExpression(Regex { pattern: "foobar".into(), options: "i".into() }),
             "code": Bson::JavaScriptCode("foo(x) { return x + 1; }".into()),
-            "code with scope": Bson::JavaScriptCodeWithScope(
-                "foo(x) { return x + y; }".into(),
-                doc! { "y": -17 },
-            ),
+            "code with scope": Bson::JavaScriptCodeWithScope(JavaScriptCodeWithScope {
+                code: "foo(x) { return x + y; }".into(),
+                scope: doc! { "y": -17 },
+            }),
             "i32": 12i32,
             "i64": -126i64,
-            "timestamp": Bson::TimeStamp(1223334444),
-            "binary": Bson::Binary(BinarySubtype::Generic, vec![3, 222, 11]),
+            "timestamp": Bson::Timestamp(Timestamp { time: 12233, increment: 34444 }),
+            "binary": Bson::Binary(Binary{ subtype: BinarySubtype::Generic, bytes: vec![3, 222, 11] }),
             "objectid": ObjectId::with_bytes([1; 12]),
             "datetime": DateTime::from_utc(
                 NaiveDateTime::from_timestamp(4444333221, 0),
@@ -248,7 +277,7 @@ mod test {
         let size_bytes = doc_size_bytes(&doc);
 
         let mut serialized_bytes = Vec::new();
-        bson::encode_document(&mut serialized_bytes, &doc).unwrap();
+        doc.to_writer(&mut serialized_bytes).unwrap();
 
         assert_eq!(size_bytes, serialized_bytes.len());
     }

src/client/auth/mod.rs

@@ -7,12 +7,12 @@ mod test;
 
 use std::{borrow::Cow, str::FromStr};
 
-use bson::Document;
 use rand::Rng;
 use typed_builder::TypedBuilder;
 
 use self::scram::ScramVersion;
 use crate::{
+    bson::Document,
     cmap::{Connection, StreamDescription},
     error::{Error, ErrorKind, Result},
 };
@@ -206,7 +206,7 @@ pub struct Credential {
 impl Credential {
     #[cfg(test)]
     pub(crate) fn into_document(mut self) -> Document {
-        use bson::Bson;
+        use crate::bson::Bson;
 
         let mut doc = Document::new();
 

src/client/auth/scram.rs

@@ -7,14 +7,14 @@ use std::{
     sync::RwLock,
 };
 
-use bson::{doc, spec::BinarySubtype, Bson, Document};
 use hmac::{Hmac, Mac};
 use lazy_static::lazy_static;
 use md5::Md5;
 use sha1::{Digest, Sha1};
 use sha2::Sha256;
 
 use crate::{
+    bson::{doc, spec::BinarySubtype, Binary, Bson, Document},
     bson_util,
     client::auth::{self, Credential},
     cmap::{Command, Connection},
@@ -145,7 +145,7 @@ impl ScramVersion {
         let noop = doc! {
             "saslContinue": 1,
             "conversationId": server_final.conversation_id().clone(),
-            "payload": Bson::Binary(BinarySubtype::Generic, Vec::new())
+            "payload": Bson::Binary(Binary { subtype: BinarySubtype::Generic, bytes: Vec::new() })
         };
         let command = Command::new("saslContinue".into(), source.into(), noop);
 
@@ -366,7 +366,7 @@ impl ClientFirst {
         doc! {
             "saslStart": 1,
             "mechanism": scram.to_string(),
-            "payload": Bson::Binary(BinarySubtype::Generic, self.message().as_bytes().to_vec())
+            "payload": Bson::Binary(Binary { subtype: BinarySubtype::Generic, bytes: self.message().as_bytes().to_vec() })
         }
     }
 }
@@ -517,7 +517,10 @@ impl ClientFinal {
     }
 
     fn payload(&self) -> Bson {
-        Bson::Binary(BinarySubtype::Generic, self.message().as_bytes().to_vec())
+        Bson::Binary(Binary {
+            subtype: BinarySubtype::Generic,
+            bytes: self.message().as_bytes().to_vec(),
+        })
     }
 
     fn message(&self) -> &str {
@@ -633,7 +636,7 @@ impl ServerFinal {
 
 #[cfg(test)]
 mod tests {
-    use bson::Bson;
+    use crate::bson::Bson;
 
     use super::ServerFirst;
 

src/client/executor.rs

@@ -2,11 +2,11 @@ use super::{Client, ClientSession};
 
 use std::{collections::HashSet, sync::Arc};
 
-use bson::Document;
 use lazy_static::lazy_static;
 use time::PreciseTime;
 
 use crate::{
+    bson::Document,
     cmap::Connection,
     error::{ErrorKind, Result},
     event::command::{CommandFailedEvent, CommandStartedEvent, CommandSucceededEvent},

src/client/mod.rs

@@ -5,13 +5,13 @@ mod session;
 
 use std::{sync::Arc, time::Duration};
 
-use bson::{Bson, Document};
 use derivative::Derivative;
 use time::PreciseTime;
 
 #[cfg(test)]
 use crate::options::StreamAddress;
 use crate::{
+    bson::{Bson, Document},
     concern::{ReadConcern, WriteConcern},
     db::Database,
     error::{ErrorKind, Result},

src/client/options/mod.rs

@@ -12,7 +12,6 @@ use std::{
     time::Duration,
 };
 
-use bson::{Bson, Document};
 use derivative::Derivative;
 use lazy_static::lazy_static;
 use rustls::{
@@ -28,6 +27,7 @@ use typed_builder::TypedBuilder;
 use webpki_roots::TLS_SERVER_ROOTS;
 
 use crate::{
+    bson::{Bson, Document},
     client::auth::{AuthMechanism, Credential},
     concern::{Acknowledgment, ReadConcern, WriteConcern},
     error::{ErrorKind, Result},
@@ -170,7 +170,7 @@ impl StreamAddress {
         doc.insert("host", &self.hostname);
 
         if let Some(i) = self.port.take() {
-            doc.insert("port", i64::from(i));
+            doc.insert("port", i32::from(i));
         } else {
             doc.insert("port", Bson::Null);
         }