mongo 2.12.1 → 2.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3445c61a01ced5590fabff016e17fb745789b0bca07628c653272ea5f1ba9c22
-  data.tar.gz: 6a945cc89db62d7bb613ef03c262407f56820e4aedfc5c2aa25fe813a02a7b51
+  metadata.gz: 32b9c6615d4d33e980ab07cba7c01992f0d370e9ee8c671fd01f9310c56c0cf2
+  data.tar.gz: a8344cf96ce4c9f69a92b5a8dc25ad38a70f8145d48ecf4c1eb89609a014ef06
 SHA512:
-  metadata.gz: 207218c0f2715f90d877d697f24aa2dce851032ef8affd8e8fa222d608f886f0bb9e3a1f7763e57070bc0214952285d1ad7c54454d90772be4c8bbe2d274d6b8
-  data.tar.gz: d95ad222012c17207208e6d2bf32e33a744823ceaee1695cc794c89fb672c7a186eaba3c7aeae8b68dcfe4b0b03543b7474bd5420271f571513b6fdab29478d4
+  metadata.gz: 97cc2df80dce9acaaf2fcc5b1b55ffc9f1d6dc37d4903f522f4dcc2366a487ae9daafdd66a81c8e399f561c105e40377a2cc16ac03471dbb2a3ecab0054a2713
+  data.tar.gz: 758df1949b5f9018270fe11812580a91bf8fd55f56990cdd45b16127520919097ed9aeabc1a04ec1e32c393f41ec336228bbf82c5a9abd304b56b8793206a5ec

data/lib/mongo/address.rb

@@ -180,42 +180,44 @@ module Mongo
     # @return [ Mongo::Socket::SSL | Mongo::Socket::TCP | Mongo::Socket::Unix ]
     #   The socket.
     #
-    # @raise [ Exception ] If network connection failed.
+    # @raise [ Mongo::Error ] If network connection failed.
     #
     # @since 2.0.0
     def socket(socket_timeout, ssl_options = {}, options = {})
-      if seed.downcase =~ Unix::MATCH
-        specific_address = Unix.new(seed.downcase)
-        return specific_address.socket(socket_timeout, ssl_options, options)
-      end
+      map_exceptions do
+        if seed.downcase =~ Unix::MATCH
+          specific_address = Unix.new(seed.downcase)
+          return specific_address.socket(socket_timeout, ssl_options, options)
+        end
+
+        options = {
+          connect_timeout: Server::CONNECT_TIMEOUT,
+        }.update(options)
 
-      options = {
-        connect_timeout: Server::CONNECT_TIMEOUT,
-      }.update(options)
-
-      # When the driver connects to "localhost", it only attempts IPv4
-      # connections. When the driver connects to other hosts, it will
-      # attempt both IPv4 and IPv6 connections.
-      family = (host == LOCALHOST) ? ::Socket::AF_INET : ::Socket::AF_UNSPEC
-      error = nil
-      # Sometimes Socket#getaddrinfo returns the same info more than once
-      # (multiple identical items in the returned array). It does not make
-      # sense to try to connect to the same address more than once, thus
-      # eliminate duplicates here.
-      infos = ::Socket.getaddrinfo(host, nil, family, ::Socket::SOCK_STREAM)
-      results = infos.map do |info|
-        [info[4], info[3]]
-      end.uniq
-      results.each do |family, address_str|
-        begin
-          specific_address = FAMILY_MAP[family].new(address_str, port, host)
-          socket = specific_address.socket(socket_timeout, ssl_options, options)
-          return socket
-        rescue IOError, SystemCallError, Error::SocketTimeoutError, Error::SocketError => e
-          error = e
+        # When the driver connects to "localhost", it only attempts IPv4
+        # connections. When the driver connects to other hosts, it will
+        # attempt both IPv4 and IPv6 connections.
+        family = (host == LOCALHOST) ? ::Socket::AF_INET : ::Socket::AF_UNSPEC
+        error = nil
+        # Sometimes Socket#getaddrinfo returns the same info more than once
+        # (multiple identical items in the returned array). It does not make
+        # sense to try to connect to the same address more than once, thus
+        # eliminate duplicates here.
+        infos = ::Socket.getaddrinfo(host, nil, family, ::Socket::SOCK_STREAM)
+        results = infos.map do |info|
+          [info[4], info[3]]
+        end.uniq
+        results.each do |family, address_str|
+          begin
+            specific_address = FAMILY_MAP[family].new(address_str, port, host)
+            socket = specific_address.socket(socket_timeout, ssl_options, options)
+            return socket
+          rescue IOError, SystemCallError, Error::SocketTimeoutError, Error::SocketError => e
+            error = e
+          end
         end
+        raise error
       end
-      raise error
     end
 
     # Get the address as a string.
@@ -248,5 +250,17 @@ module Mongo
         else IPv4.parse(address)
       end
     end
+
+    def map_exceptions
+      begin
+        yield
+      rescue Errno::ETIMEDOUT => e
+        raise Error::SocketTimeoutError, "#{e.class}: #{e} (for #{self})"
+      rescue IOError, SystemCallError => e
+        raise Error::SocketError, "#{e.class}: #{e} (for #{self})"
+      rescue OpenSSL::SSL::SSLError => e
+        raise Error::SocketError, "#{e.class}: #{e} (for #{self}) (#{SSL_ERROR})"
+      end
+    end
   end
 end

data/lib/mongo/collection/view/readable.rb

@@ -185,7 +185,9 @@ module Mongo
           pipeline << { :'$limit' => opts[:limit] } if opts[:limit]
           pipeline << { :'$group' => { _id: 1, n: { :'$sum' => 1 } } }
 
-          opts.select! { |k, _| [:hint, :max_time_ms, :read, :collation, :session].include?(k) }
+          opts = opts.select { |k, _| [:hint, :max_time_ms, :read, :collation, :session].include?(k) }
+          opts[:collation] ||= collation
+
           first = aggregate(pipeline, opts).first
           return 0 unless first
           first['n'].to_i

data/lib/mongo/grid/file.rb

@@ -104,6 +104,11 @@ module Mongo
       #   chunk objects and assemble the data. If we have an IO object, then
       #   it's the original file data and we must split it into chunks and set
       #   the original data itself.
+      #
+      # @param [ IO, String, Array<BSON::Document> ] value The file object,
+      #   file contents or chunk documents.
+      #
+      # @return [ Array<Grid::File::Chunk> ] Array of chunks.
       def initialize_chunks!(value)
         if value.is_a?(Array)
           @chunks = value.map{ |doc| Chunk.new(doc) }

data/lib/mongo/grid/file/chunk.rb

@@ -151,6 +151,7 @@ module Mongo
           # @return [ String ] The assembled data.
           #
           # @since 2.0.0
+          # @api private
           def assemble(chunks)
             chunks.reduce(''){ |data, chunk| data << chunk.data.data }
           end
@@ -167,6 +168,7 @@ module Mongo
           # @return [ Array<Chunk> ] The chunks of the data.
           #
           # @since 2.0.0
+          # @api private
           def split(io, file_info, offset = 0)
             io = StringIO.new(io) if io.is_a?(String)
             parts = Enumerator.new { |y| y << io.read(file_info.chunk_size) until io.eof? }

data/lib/mongo/grid/fs_bucket.rb

@@ -177,7 +177,7 @@ module Mongo
       #
       # @since 2.0.0
       def prefix
-        @options[:fs_name] || @options[:bucket_name]|| DEFAULT_ROOT
+        @options[:fs_name] || @options[:bucket_name] || DEFAULT_ROOT
       end
 
       # Remove a single file from the GridFS.
@@ -230,7 +230,8 @@ module Mongo
       #
       # @since 2.1.0
       def open_download_stream(id, options = nil)
-        read_stream(id, options).tap do |stream|
+        options = Hash[(options || {}).map { |k, v| [k.to_sym, v] }]
+        read_stream(id, **options).tap do |stream|
           if block_given?
             begin
               yield stream
@@ -348,15 +349,15 @@ module Mongo
         download_to_stream(open_download_stream_by_name(filename, opts).file_id, io)
       end
 
-      # Opens an upload stream to GridFS to which the contents of a user file came be written.
+      # Opens an upload stream to GridFS to which the contents of a file or
+      # blob can be written.
       #
-      # @example Open a stream to which the contents of a file came be written.
-      #   fs.open_upload_stream('a-file.txt')
-      #
-      # @param [ String ] filename The filename of the file to upload.
+      # @param [ String ] filename The name of the file in GridFS.
       # @param [ Hash ] opts The options for the write stream.
       #
-      # @option opts [ Object ] :file_id An optional unique file id. An ObjectId is generated otherwise.
+      # @option opts [ Object ] :file_id An optional unique file id.
+      #   A BSON::ObjectId is automatically generated if a file id is not
+      #   provided.
       # @option opts [ Integer ] :chunk_size Override the default chunk size.
       # @option opts [ Hash ] :metadata User data for the 'metadata' field of the files
       #   collection document.
@@ -375,7 +376,8 @@ module Mongo
       #
       # @since 2.1.0
       def open_upload_stream(filename, opts = {})
-        write_stream(filename, opts).tap do |stream|
+        opts = Hash[opts.map { |k, v| [k.to_sym, v] }]
+        write_stream(filename, **opts).tap do |stream|
           if block_given?
             begin
               yield stream
@@ -462,12 +464,12 @@ module Mongo
       #
       # @option opts [ BSON::Document ] :file_info_doc For internal
       #   driver use only. A BSON document to use as file information.
-      def read_stream(id, opts = nil)
-        Stream.get(self, Stream::READ_MODE, { file_id: id }.update(options).update(opts || {}))
+      def read_stream(id, **opts)
+        Stream.get(self, Stream::READ_MODE, { file_id: id }.update(options).update(opts))
       end
 
-      def write_stream(filename, opts)
-        Stream.get(self, Stream::WRITE_MODE, { filename: filename }.merge!(options).merge!(opts))
+      def write_stream(filename, **opts)
+        Stream.get(self, Stream::WRITE_MODE, { filename: filename }.update(options).update(opts))
       end
 
       def chunks_name

data/lib/mongo/grid/stream/write.rb

@@ -82,12 +82,12 @@ module Mongo
             @open = true
           end
 
-          # Write to the GridFS bucket from the source stream.
+          # Write to the GridFS bucket from the source stream or a string.
           #
           # @example Write to GridFS.
           #   stream.write(io)
           #
-          # @param [ IO ] io The source io stream to upload from.
+          # @param [ String | IO ] io The string or IO object to upload from.
           #
           # @return [ Stream::Write ] self The write stream itself.
           #
@@ -95,7 +95,13 @@ module Mongo
           def write(io)
             ensure_open!
             @indexes ||= ensure_indexes!
-            @length += io.size
+            @length += if io.respond_to?(:bytesize)
+              # String objects
+              io.bytesize
+            else
+              # IO objects
+              io.size
+            end
             chunks = File::Chunk.split(io, file_info, @n)
             @n += chunks.size
             chunks_collection.insert_many(chunks) unless chunks.empty?

data/lib/mongo/protocol/message.rb

@@ -374,7 +374,7 @@ module Mongo
       #   each of the elements in this array using BSON types wherever possible.
       #
       # @return [Message] Message with deserialized array.
-      def self.deserialize_array(message, io, field, options)
+      def self.deserialize_array(message, io, field, options = {})
         elements = []
         count = message.instance_variable_get(field[:multi])
         count.times { elements << field[:type].deserialize(io, options) }
@@ -392,7 +392,7 @@ module Mongo
       #   this field using BSON types wherever possible.
       #
       # @return [Message] Message with deserialized field.
-      def self.deserialize_field(message, io, field, options)
+      def self.deserialize_field(message, io, field, options = {})
         message.instance_variable_set(
           field[:name],
           field[:type].deserialize(io, options)

data/lib/mongo/protocol/serializers.rb

@@ -440,12 +440,15 @@ module Mongo
         # Deserializes bytes from the byte buffer.
         #
         # @param [ BSON::ByteBuffer ] buffer Buffer containing the value to read.
-        # @param [ Integer ] num_bytes Number of bytes to read.
+        # @param [ Hash ] options The method options.
+        #
+        # @option options [ Integer ] num_bytes Number of bytes to read.
         #
         # @return [ String ] The bytes.
         #
         # @since 2.5.0
-        def self.deserialize(buffer, num_bytes = nil)
+        def self.deserialize(buffer, options = {})
+          num_bytes = options[:num_bytes]
           buffer.get_bytes(num_bytes || buffer.length)
         end
       end

data/lib/mongo/version.rb

@@ -17,5 +17,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.12.1'.freeze
+  VERSION = '2.12.2'.freeze
 end

data/spec/integration/grid_fs_bucket_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'GridFS bucket integration' do
+  let(:fs) do
+    authorized_client.database.fs
+  end
+
+  describe 'UTF-8 string write' do
+    let(:data) { "hello\u2210" }
+
+    before do
+      data.length.should_not == data.bytesize
+    end
+
+    shared_examples 'round-trips' do
+      it 'round-trips' do
+        stream = fs.open_upload_stream('test') do |stream|
+          stream.write(data_to_write)
+        end
+
+        actual = nil
+        fs.open_download_stream(stream.file_id) do |stream|
+          actual = stream.read
+        end
+
+        actual.encoding.name.should == 'ASCII-8BIT'
+        actual.should == data.dup.force_encoding('binary')
+      end
+    end
+
+    context 'in binary encoding' do
+      let(:data_to_write) do
+        data.force_encoding('binary').freeze
+      end
+
+      it_behaves_like 'round-trips'
+    end
+
+    context 'in UTF-8 encoding' do
+      let(:data_to_write) do
+        data.encoding.name.should == 'UTF-8'
+        data.freeze
+      end
+
+      it_behaves_like 'round-trips'
+    end
+  end
+end

data/spec/integration/size_limit_spec.rb

@@ -81,6 +81,10 @@ describe 'BSON & command size limits' do
   end
 
   it 'allows bulk writes of multiple documents of exactly 16 MiB each' do
+    if SpecConfig.instance.compressors
+      pending "RUBY-2234"
+    end
+
     documents = []
     1.upto(3) do |index|
       document = { key: 'a' * (max_document_size - 28), _id: "in#{index}" }

data/spec/integration/size_limit_spec.rb~12e1e9c4f... RUBY-2242 Fix zlib compression (#2021)

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe 'BSON & command size limits' do
+  let(:max_document_size) { 16*1024*1024 }
+
+  before do
+    authorized_collection.delete_many
+  end
+
+  # This test uses a large document that is significantly smaller than the
+  # size limit. It is a basic sanity check.
+  it 'allows user-provided documents to be 15MiB' do
+    document = { key: 'a' * 15*1024*1024, _id: 'foo' }
+
+    authorized_collection.insert_one(document)
+  end
+
+  # This test uses a large document that is significantly larger than the
+  # size limit. It is a basic sanity check.
+  it 'fails single write of oversized documents' do
+    document = { key: 'a' * 17*1024*1024, _id: 'foo' }
+
+    lambda do
+      authorized_collection.insert_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
+
+  # This test checks our bulk write splitting when documents are not close
+  # to the limit, but where splitting is definitely required.
+  it 'allows split bulk write of medium sized documents' do
+    # 8 documents of 4 MiB each = 32 MiB total data, should be split over
+    # either 2 or 3 bulk writes depending on how well the driver splits
+    documents = []
+    1.upto(8) do |index|
+      documents << { key: 'a' * 4*1024*1024, _id: "in#{index}" }
+    end
+
+    authorized_collection.insert_many(documents)
+    authorized_collection.count_documents({}).should == 8
+  end
+
+  # This test ensures that document which are too big definitely fail insertion.
+  it 'fails bulk write of oversized documents' do
+    documents = []
+    1.upto(3) do |index|
+      documents << { key: 'a' * 17*1024*1024, _id: "in#{index}" }
+    end
+
+    lambda do
+      authorized_collection.insert_many(documents)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+    authorized_collection.count_documents({}).should == 0
+  end
+
+  it 'allows user-provided documents to be exactly 16MiB' do
+    # The document must contain the _id field, otherwise the server will
+    # add it which will increase the size of the document as persisted by
+    # the server.
+    document = { key: 'a' * (max_document_size - 28), _id: 'foo' }
+    expect(document.to_bson.length).to eq(max_document_size)
+
+    authorized_collection.insert_one(document)
+  end
+
+  it 'fails on the server when a document larger than 16MiB is inserted' do
+    document = { key: 'a' * (max_document_size - 27), _id: 'foo' }
+    expect(document.to_bson.length).to eq(max_document_size+1)
+
+    lambda do
+      authorized_collection.insert_one(document)
+    end.should raise_error(Mongo::Error::OperationFailure, /object to insert too large/)
+  end
+
+  it 'fails in the driver when a document larger than 16MiB+16KiB is inserted' do
+    document = { key: 'a' * (max_document_size - 27 + 16*1024), _id: 'foo' }
+    expect(document.to_bson.length).to eq(max_document_size+16*1024+1)
+
+    lambda do
+      authorized_collection.insert_one(document)
+    end.should raise_error(Mongo::Error::MaxBSONSize, /The document exceeds maximum allowed BSON object size after serialization/)
+  end
+
+  it 'allows bulk writes of multiple documents of exactly 16 MiB each' do
+    if SpecConfig.instance.compressors
+      pending "RUBY-2234"
+    end
+
+    documents = []
+    1.upto(3) do |index|
+      document = { key: 'a' * (max_document_size - 28), _id: "in#{index}" }
+      expect(document.to_bson.length).to eq(max_document_size)
+      documents << document
+    end
+
+    authorized_collection.insert_many(documents)
+    authorized_collection.count_documents({}).should == 3
+  end
+end