mongo 1.10.0.rc1 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 280fdca0cfd2705bb339614159fa2a9ac3a6646f
-  data.tar.gz: 1656445245aa6d3c58729875b7f2229416a7cc48
+  metadata.gz: a4f4eaa561f3080eb698ae91915d4dfed3688a66
+  data.tar.gz: 4d7a8a0c5bb407d5433e641206b579bf44baee13
 SHA512:
-  metadata.gz: a5833530677b1c66c31d06ce0999b1aab3a0541a6cea1b5c15b71c3bc0a09c0b8adbe8585294c4095ac992eea171b401cdfc70c8d9505dda4a8bbccb29727794
-  data.tar.gz: 3a44a8940281e6fc17a3862883881ab37f35b588079afecc47b5fb07ede6a30298fa91e6052bac1d53d386fad9b843edbaecefac7c62d326c1146edd30ef8337
+  metadata.gz: 63f4d172c84188ac600cf15b2a6c2336eb960d08b695725ab9a99234d2bb1023e32c10b56a38a9e907c790b6ec213f317551dfadca0cd2d2e9f2830d40b8e51e
+  data.tar.gz: 8f7b36deea7ccdd8a72f43864cc15e6bfc0f6f74a01322b506940029a93dad5bb78ff3c7090c72fd473f5dc4430a95e6808a5d3f753b42aa3e87e363f0a5134c

data/README.md

@@ -7,13 +7,17 @@ Installation
 
 **Gem Installation**<br>
 The Ruby driver is released and distributed through RubyGems and it can be installed with the following command:
+
 ```bash
 gem install mongo
 ```
+
 For a significant performance boost, you'll want to install the C-extension:
+
 ```bash
 gem install bson_ext
 ```
+
 **Github Installation**<br>
 For development and test environments (not recommended for production) you can also install the Ruby driver directly from source:
 
@@ -36,6 +40,7 @@ rake install
 Usage
 -----
 Here is a quick example of basic usage for the Ruby driver:
+
 ```ruby
 require 'mongo'
 include Mongo

data/VERSION

@@ -1 +1 @@
-1.10.0.rc1
+1.10.0

data/lib/mongo.rb

@@ -50,6 +50,7 @@ module Mongo
     OP_QUERY_NO_CURSOR_TIMEOUT = 2 ** 4
     OP_QUERY_AWAIT_DATA        = 2 ** 5
     OP_QUERY_EXHAUST           = 2 ** 6
+    OP_QUERY_PARTIAL           = 2 ** 7
 
     REPLY_CURSOR_NOT_FOUND     = 2 ** 0
     REPLY_QUERY_FAILURE        = 2 ** 1

data/lib/mongo/bulk_write_collection_view.rb

@@ -220,14 +220,14 @@ module Mongo
       write_concern = get_write_concern(opts, @collection)
       @ops.each_with_index{|op, index| op.last.merge!(:ord => index)} # infuse ordinal here to avoid issues with upsert
       if @collection.db.connection.use_write_command?(write_concern)
-        errors, exchanges = @collection.command_writer.bulk_execute(@ops, @options, opts)
+        errors, write_concern_errors, exchanges = @collection.command_writer.bulk_execute(@ops, @options, opts)
       else
-        errors, exchanges = @collection.operation_writer.bulk_execute(@ops, @options, opts)
+        errors, write_concern_errors, exchanges = @collection.operation_writer.bulk_execute(@ops, @options, opts)
       end
       @ops = []
       return true if errors.empty? && (exchanges.empty? || exchanges.first[:response] == true) # w 0 without GLE
-      result = merge_result(errors, exchanges)
-      raise BulkWriteError.new(MULTIPLE_ERRORS_MSG, Mongo::ErrorCode::MULTIPLE_ERRORS_OCCURRED, result) if !errors.empty? || result["writeConcernError"]
+      result = merge_result(errors + write_concern_errors, exchanges)
+      raise BulkWriteError.new(MULTIPLE_ERRORS_MSG, Mongo::ErrorCode::MULTIPLE_ERRORS_OCCURRED, result) if !errors.empty? || !write_concern_errors.empty?
       result
     end
 
@@ -274,7 +274,7 @@ module Mongo
       ok = 0
       result = {"ok" => 0, "n" => 0}
       unless errors.empty?
-        unless (writeErrors = errors.select { |error| error.class != Mongo::OperationFailure }).empty? # assignment
+        unless (writeErrors = errors.select { |error| error.class != Mongo::OperationFailure && error.class != WriteConcernError }).empty? # assignment
           concat(result, "writeErrors",
                  writeErrors.collect { |error|
                    {"index" => error.result[:ord], "code" => error.error_code, "errmsg" => error.result[:error].message}
@@ -305,26 +305,26 @@ module Mongo
           tally(result, "nRemoved", n)
         end
         result["n"] += n
-        writeConcernError = nil
+        write_concern_error = nil
         errmsg = response["errmsg"] || response["err"] # top level
         if (writeErrors = response["writeErrors"] || response["errDetails"]) # assignment
           concat(result, "writeErrors", merge_indexes(writeErrors, exchange))
         elsif response["err"] == "timeout" # errmsg == "timed out waiting for slaves" # OP_*
-          writeConcernError = {"errmsg" => errmsg, "code" => Mongo::ErrorCode::WRITE_CONCERN_FAILED,
+          write_concern_error = {"errmsg" => errmsg, "code" => Mongo::ErrorCode::WRITE_CONCERN_FAILED,
                                "errInfo" => {"wtimeout" => response["wtimeout"]}} # OP_* does not have "code"
         elsif errmsg == "norepl" # OP_*
-          writeConcernError = {"errmsg" => errmsg, "code" => Mongo::ErrorCode::WRITE_CONCERN_FAILED} # OP_* does not have "code"
+          write_concern_error = {"errmsg" => errmsg, "code" => Mongo::ErrorCode::WRITE_CONCERN_FAILED} # OP_* does not have "code"
         elsif errmsg # OP_INSERT, OP_UPDATE have "err"
           append(result, "writeErrors", merge_index({"errmsg" => errmsg, "code" => response["code"]}, exchange))
         end
         if response["writeConcernError"]
-          writeConcernError = response["writeConcernError"]
+          write_concern_error = response["writeConcernError"]
         elsif (wnote = response["wnote"]) # assignment - OP_*
-          writeConcernError = {"errmsg" => wnote, "code" => Mongo::ErrorCode::WRITE_CONCERN_FAILED} # OP_* does not have "code"
+          write_concern_error = {"errmsg" => wnote, "code" => Mongo::ErrorCode::WRITE_CONCERN_FAILED} # OP_* does not have "code"
         elsif (jnote = response["jnote"]) # assignment - OP_*
-          writeConcernError = {"errmsg" => jnote, "code" => Mongo::ErrorCode::BAD_VALUE} # OP_* does not have "code"
+          write_concern_error = {"errmsg" => jnote, "code" => Mongo::ErrorCode::BAD_VALUE} # OP_* does not have "code"
         end
-        append(result, "writeConcernError", merge_index(writeConcernError, exchange)) if writeConcernError
+        append(result, "writeConcernError", merge_index(write_concern_error, exchange)) if write_concern_error
       end
       result.delete("nModified") if result.has_key?("nModified") && !result["nModified"]
       result.merge!("ok" => [ok + result["n"], 1].min)

data/lib/mongo/collection.rb

@@ -159,7 +159,7 @@ module Mongo
     end
 
     # Set a hint field using a named index.
-    # @param [String] hinted index name
+    # @param [String] hint index name
     def named_hint=(hint=nil)
       @hint = hint
       self
@@ -408,7 +408,8 @@ module Mongo
     def insert(doc_or_docs, opts={})
       if doc_or_docs.respond_to?(:collect!)
         doc_or_docs.collect! { |doc| @pk_factory.create_pk(doc) }
-        error_docs, errors, rest_ignored = batch_write(:insert, doc_or_docs, true, opts)
+        error_docs, errors, write_concern_errors, rest_ignored = batch_write(:insert, doc_or_docs, true, opts)
+        errors = write_concern_errors + errors
         raise errors.last if !opts[:collect_on_error] && !errors.empty?
         inserted_docs = doc_or_docs - error_docs
         inserted_ids = inserted_docs.collect {|o| o[:_id] || o['_id']}

data/lib/mongo/collection_writer.rb

@@ -48,6 +48,7 @@ module Mongo
       collect_on_error = !!opts[:collect_on_error] || ordered == false
       error_docs = [] # docs with serialization errors
       errors = []
+      write_concern_errors = []
       exchanges = []
       serialized_doc = nil
       message = BSON::ByteBuffer.new("", max_message_size)
@@ -80,6 +81,9 @@ module Mongo
           begin
             response = batch_message_send(message, op_type, batch_docs, write_concern, continue_on_error) if batch_docs.size > 0
             exchanges << {:op_type => op_type, :batch => batch_docs, :opts => opts, :response => response}
+          rescue Mongo::WriteConcernError => ex
+            write_concern_errors << ex
+            exchanges << {:op_type => op_type, :batch => batch_docs, :opts => opts, :response => ex.result}
           rescue Mongo::OperationFailure => ex
             errors << ex
             exchanges << {:op_type => op_type, :batch => batch_docs, :opts => opts, :response => ex.result}
@@ -87,7 +91,7 @@ module Mongo
           end
         end
       end
-      [error_docs, errors, exchanges]
+      [error_docs, errors, write_concern_errors, exchanges]
     end
 
     def batch_write_partition(op_type, documents, check_keys, opts)
@@ -98,6 +102,7 @@ module Mongo
       collect_on_error = !!opts[:collect_on_error] # collect_on_error default false
       error_docs = [] # docs with serialization errors
       errors = []
+      write_concern_errors = []
       exchanges = []
       @max_write_batch_size = @collection.db.connection.max_write_batch_size
       @write_batch_size = [documents.size, @max_write_batch_size].min
@@ -128,6 +133,10 @@ module Mongo
           next if collect_on_error
           errors << ex
           break unless continue_on_error
+        rescue Mongo::WriteConcernError => ex
+          write_concern_errors << ex
+          exchanges << {:op_type => op_type, :batch => batch_docs, :opts => opts, :response => ex.result}
+          docs = docs.drop(batch.size)
         rescue Mongo::OperationFailure => ex
           errors << ex
           exchanges << {:op_type => op_type, :batch => batch, :opts => opts, :response => ex.result}
@@ -135,7 +144,7 @@ module Mongo
           break if !continue_on_error && !collect_on_error
         end
       end
-      [error_docs, errors, exchanges]
+      [error_docs, errors, write_concern_errors, exchanges]
     end
 
     alias :batch_write :batch_write_incremental
@@ -225,6 +234,7 @@ module Mongo
     def bulk_execute(ops, options, opts = {})
       write_concern = get_write_concern(opts, @collection)
       errors = []
+      write_concern_errors = []
       exchanges = []
       ops.each do |op_type, doc|
         doc = {:d => @collection.pk_factory.create_pk(doc[:d]), :ord => doc[:ord]} if op_type == :insert
@@ -241,13 +251,16 @@ module Mongo
                                   {:op_type => op_type, :serialize => doc, :ord => doc[:ord], :error => ex})
           errors << ex
           break if options[:ordered]
+        rescue Mongo::WriteConcernError => ex
+          write_concern_errors << ex
+          exchanges << {:op_type => op_type, :batch => [doc], :opts => opts, :response => ex.result}
         rescue Mongo::OperationFailure => ex
           errors << ex
           exchanges << {:op_type => op_type, :batch => [doc], :opts => opts, :response => ex.result}
           break if options[:ordered] && ex.result["err"] != "norepl"
         end
       end
-      [errors, exchanges]
+      [errors, write_concern_errors, exchanges]
     end
 
     private
@@ -304,17 +317,19 @@ module Mongo
 
     def bulk_execute(ops, options, opts = {})
       errors = []
+      write_concern_errors = []
       exchanges = []
       ops = (options[:ordered] == false) ? sort_by_first_sym(ops) : ops # sort by write-type
       ordered_group_by_first(ops).each do |op_type, documents|
         documents.collect! {|doc| {:d => @collection.pk_factory.create_pk(doc[:d]), :ord => doc[:ord]} } if op_type == :insert
-        error_docs, batch_errors, batch_exchanges =
+        error_docs, batch_errors, batch_write_concern_errors, batch_exchanges =
             batch_write(op_type, documents, check_keys = false, opts.merge(:ordered => options[:ordered]))
         errors += batch_errors
+        write_concern_errors += batch_write_concern_errors
         exchanges += batch_exchanges
         break if options[:ordered] && !batch_errors.empty?
       end
-      [errors, exchanges]
+      [errors, write_concern_errors, exchanges]
     end
 
     private

data/lib/mongo/connection/pool_manager.rb

@@ -17,14 +17,9 @@ module Mongo
     include ThreadLocalVariableManager
 
     attr_reader :client,
-                :arbiters,
                 :primary,
-                :secondaries,
                 :primary_pool,
-                :secondary_pools,
-                :hosts,
                 :seeds,
-                :pools,
                 :max_bson_size,
                 :max_message_size,
                 :max_wire_version,
@@ -145,6 +140,47 @@ module Mongo
       read_pool.host_port
     end
 
+    def hosts
+      @connect_mutex.synchronize do
+        @hosts.nil? ? nil : @hosts.clone
+      end
+    end
+
+    def pools
+      @connect_mutex.synchronize do
+        @pools.nil? ? nil : @pools.clone
+      end
+    end
+
+    def secondaries
+      @connect_mutex.synchronize do
+        @secondaries.nil? ? nil : @secondaries.clone
+      end
+    end
+
+    def secondary_pools
+      @connect_mutex.synchronize do
+        @secondary_pools.nil? ? nil : @secondary_pools.clone
+      end
+    end
+
+    def arbiters
+      @connect_mutex.synchronize do
+        @arbiters.nil? ? nil : @arbiters.clone
+      end
+    end
+
+    def state_snapshot
+      @connect_mutex.synchronize do
+        { :pools           => @pools.nil?           ? nil : @pools.clone,
+          :secondaries     => @secondaries.nil?     ? nil : @secondaries.clone,
+          :secondary_pools => @secondary_pools.nil? ? nil : @secondary_pools.clone,
+          :hosts           => @hosts.nil?           ? nil : @hosts.clone,
+          :arbiters        => @arbiters.nil?        ? nil : @arbiters.clone
+        }
+      end
+    end
+
     private
 
     def update_max_sizes

data/lib/mongo/connection/socket/ssl_socket.rb

@@ -38,7 +38,11 @@ module Mongo
       end
 
       if opts[:key]
-        @context.key = OpenSSL::PKey::RSA.new(File.open(opts[:key]))
+        if opts[:key_pass_phrase]
+          @context.key = OpenSSL::PKey::RSA.new(File.open(opts[:key]), opts[:key_pass_phrase])
+        else
+          @context.key = OpenSSL::PKey::RSA.new(File.open(opts[:key]))
+        end
       end
 
       if opts[:verify]

data/lib/mongo/cursor.rb

@@ -155,8 +155,8 @@ module Mongo
         end
 
         raise OperationFailure.new(err, code, doc)
-      elsif doc && (writeConcernError = doc['writeConcernError']) && writeConcernError['errInfo'] == {"wtimeout" => true} # assignment
-        raise OperationFailure.new('timeout ' + writeConcernError['errmsg'], writeConcernError['code'], doc)
+      elsif doc && (write_concern_error = doc['writeConcernError']) # assignment
+        raise WriteConcernError.new(write_concern_error['errmsg'], write_concern_error['code'], doc)
       end
 
       if @transformer.nil?
@@ -189,7 +189,7 @@ module Mongo
 
     # Get the size of the result set for this query.
     #
-    # @param [Boolean] whether of not to take notice of skip and limit
+    # @param [Boolean] skip_and_limit whether or not to take skip or limit into account.
     #
     # @return [Integer] the number of objects in the result set for this query.
     #

data/lib/mongo/db.rb

@@ -556,7 +556,7 @@ module Mongo
         result = Cursor.new(system_command_collection, command).next_document
       rescue OperationFailure => ex
         if check_response
-          raise OperationFailure.new("Database command '#{selector.keys.first}' failed: #{ex.message}", ex.error_code, ex.result)
+          raise ex.class.new("Database command '#{selector.keys.first}' failed: #{ex.message}", ex.error_code, ex.result)
         else
           result = ex.result
         end

data/lib/mongo/exception.rb

@@ -68,6 +68,9 @@ module Mongo
   # Raised when a database operation exceeds maximum specified time.
   class ExecutionTimeout < OperationFailure; end
 
+  # Raised when a database operation has a write concern error.
+  class WriteConcernError < OperationFailure; end
+
   # Raised when a socket read operation times out.
   class OperationTimeout < SocketError; end
 

data/lib/mongo/functional/authentication.rb

@@ -296,7 +296,7 @@ module Mongo
 
     # Helper to fetch a nonce value from a given database instance.
     #
-    # @param db [Mongo::DB] The DB instance to use for issue the nonce command.
+    # @param database [Mongo::DB] The DB instance to use for issue the nonce command.
     # @param opts [Hash] Hash of optional settings and configuration values.
     #
     # @option opts [Socket] socket (nil) Optional socket instance to use.

data/lib/mongo/functional/sasl_java.rb

@@ -16,7 +16,7 @@ require 'jruby'
 
 include Java
 
-jar_dir = File.join(File.dirname(__FILE__), '../../../ext/jsasl')
+jar_dir = File.expand_path(File.join(File.dirname(__FILE__), '../../../ext/jsasl'))
 require File.join(jar_dir, 'target/jsasl.jar')
 
 module Mongo

data/lib/mongo/functional/uri_parser.rb

@@ -153,8 +153,6 @@ module Mongo
     # @note Passwords can contain any character except for ','
     #
     # @param [String] uri The MongoDB URI string.
-    # @param [Hash,nil] extra_opts Extra options. Will override anything
-    #   already specified in the URI.
     def initialize(uri)
       if uri.start_with?('mongodb://')
         uri = uri[10..-1]
@@ -234,12 +232,12 @@ module Mongo
         warn "Using wtimeout in a URI is deprecated, please use wtimeoutMS. It will be removed in v2.0."
         opts[:wtimeout] = @wtimeout
       end
-      opts[:wtimeout] = @wtimeoutms
+      opts[:wtimeout] = @wtimeoutms if @wtimeoutms
 
       opts[:w]     = 1 if @safe
       opts[:w]     = @w if @w
-      opts[:j]     = @journal
-      opts[:fsync] = @fsync
+      opts[:j]     = @journal if @journal
+      opts[:fsync] = @fsync if @fsync
 
       opts[:connect_timeout] = @connecttimeoutms if @connecttimeoutms
       opts[:op_timeout]      = @sockettimeoutms if @sockettimeoutms
@@ -260,7 +258,7 @@ module Mongo
 
       opts[:db_name] = @db_name if @db_name
       opts[:auths]   = @auths if @auths
-      opts[:ssl]     = @ssl
+      opts[:ssl]     = @ssl if @ssl
       opts[:connect] = connect?
 
       opts

data/lib/mongo/functional/write_concern.rb

@@ -14,6 +14,8 @@
 
 module Mongo
   module WriteConcern
+    VALID_KEYS = [:w, :j, :fsync, :wtimeout]
+    DEFAULT_WRITE_CONCERN = {:w => 1}
 
     attr_reader :legacy_write_concern
 
@@ -44,14 +46,9 @@ module Mongo
     # todo: throw exception for conflicting write concern options
     def get_write_concern(opts, parent=nil)
       write_concern_from_legacy(opts) if opts.key?(:safe) || legacy_write_concern
-      write_concern = {
-        :w        => 1,
-        :j        => false,
-        :fsync    => false,
-        :wtimeout => nil
-      }
+      write_concern = DEFAULT_WRITE_CONCERN.dup
       write_concern.merge!(parent.write_concern) if parent
-      write_concern.merge!(opts.reject {|k,v| !write_concern.keys.include?(k)})
+      write_concern.merge!(opts.reject {|k,v| !VALID_KEYS.include?(k)})
       write_concern[:w] = write_concern[:w].to_s if write_concern[:w].is_a?(Symbol)
       write_concern
     end

data/lib/mongo/gridfs/grid.rb

@@ -54,7 +54,7 @@ module Mongo
     # @option opts [String] :content_type ('binary/octet-stream') If no content type is specified,
     #   the content type will may be inferred from the filename extension if the mime-types gem can be
     #   loaded. Otherwise, the content type 'binary/octet-stream' will be used.
-    # @option opts [Integer] (262144) :chunk_size size of file chunks in bytes.
+    # @option opts [Integer] (261120) :chunk_size size of file chunks in bytes.
     # @option opts [String, Integer, Symbol] :w (1) Set write concern
     #
     #   Notes on write concern:
@@ -81,7 +81,7 @@ module Mongo
 
     # Read a file from the file store.
     #
-    # @param [] id the file's unique id.
+    # @param id the file's unique id.
     #
     # @return [Mongo::GridIO]
     def get(id)
@@ -95,7 +95,7 @@ module Mongo
     # is attempting to read a file while it's being deleted. While the odds for this
     # kind of race condition are small, it's important to be aware of.
     #
-    # @param [] id
+    # @param id
     #
     # @return [Boolean]
     def delete(id)