mongo 2.5.0.beta → 2.5.0

data/lib/mongo/operation/write/bulk/mergable.rb

@@ -34,6 +34,7 @@ module Mongo
           #
           # @since 2.0.0
           def aggregate_write_errors(count)
+            return unless @replies
             @replies.reduce(nil) do |errors, reply|
               if write_errors = reply.documents.first[Error::WRITE_ERRORS]
                 wes = write_errors.collect do |we|
@@ -55,6 +56,7 @@ module Mongo
           #
           # @since 2.0.0
           def aggregate_write_concern_errors(count)
+            return unless @replies
             @replies.each_with_index.reduce(nil) do |errors, (reply, _)|
               if write_concern_errors = reply.documents.first[Error::WRITE_CONCERN_ERRORS]
                 (errors || []) << write_concern_errors.reduce(nil) do |errs, wce|

data/lib/mongo/operation/write/command/create_index.rb

@@ -33,6 +33,25 @@ module Mongo
           include TakesWriteConcern
           include UsesCommandOpMsg
 
+          # Execute the operation.
+          #
+          # @example Execute the operation.
+          #   operation.execute(server)
+          #
+          # @param [ Mongo::Server ] server The server to send this operation to.
+          #
+          # @return [ Result ] The operation response, if there is one.
+          #
+          # @since 2.5.0
+          def execute(server)
+            result = Result.new(server.with_connection do |connection|
+              connection.dispatch([ message(server) ], operation_id)
+            end)
+            server.update_cluster_time(result)
+            session.process(result) if session
+            result.validate!
+          end
+
           private
 
           # The query selector for this ensure index command operation.

data/lib/mongo/operation/write/command/create_user.rb

@@ -25,6 +25,25 @@ module Mongo
           include Specifiable
           include Writable
 
+          # Execute the operation.
+          #
+          # @example Execute the operation.
+          #   operation.execute(server)
+          #
+          # @param [ Mongo::Server ] server The server to send this operation to.
+          #
+          # @return [ Result ] The operation response, if there is one.
+          #
+          # @since 2.5.0
+          def execute(server)
+            result = Result.new(server.with_connection do |connection|
+              connection.dispatch([ message(server) ], operation_id)
+            end)
+            server.update_cluster_time(result)
+            session.process(result) if session
+            result.validate!
+          end
+
           private
 
           # The query selector for this create user command operation.

data/lib/mongo/operation/write/command/delete.rb

@@ -52,8 +52,7 @@ module Mongo
             global_args = { delete: coll_name,
                             Protocol::Msg::DATABASE_IDENTIFIER => db_name
                           }.merge!(command_options)
-            add_cluster_time!(global_args, server)
-            session.add_id!(global_args) if session
+            update_selector_for_session!(global_args, server)
 
             section = { type: 1, payload: { identifier: IDENTIFIER, sequence: deletes } }
             flags = unacknowledged_write? ? [:more_to_come] : [:none]

data/lib/mongo/operation/write/command/drop_index.rb

@@ -34,6 +34,25 @@ module Mongo
           include TakesWriteConcern
           include UsesCommandOpMsg
 
+          # Execute the operation.
+          #
+          # @example Execute the operation.
+          #   operation.execute(server)
+          #
+          # @param [ Mongo::Server ] server The server to send this operation to.
+          #
+          # @return [ Result ] The operation response, if there is one.
+          #
+          # @since 2.5.0
+          def execute(server)
+            result = Result.new(server.with_connection do |connection|
+              connection.dispatch([ message(server) ], operation_id)
+            end)
+            server.update_cluster_time(result)
+            session.process(result) if session
+            result.validate!
+          end
+
           private
 
           # The query selector for this drop index command operation.

data/lib/mongo/operation/write/command/insert.rb

@@ -46,8 +46,7 @@ module Mongo
             global_args = { insert: coll_name,
                             Protocol::Msg::DATABASE_IDENTIFIER => db_name
                           }.merge!(command_options)
-            add_cluster_time!(global_args, server)
-            session.add_id!(global_args) if session
+            update_selector_for_session!(global_args, server)
 
             section = { type: 1, payload: { identifier: IDENTIFIER, sequence: documents } }
             flags = unacknowledged_write? ? [:more_to_come] : [:none]

data/lib/mongo/operation/write/command/remove_user.rb

@@ -24,6 +24,25 @@ module Mongo
           include Specifiable
           include Writable
 
+          # Execute the operation.
+          #
+          # @example Execute the operation.
+          #   operation.execute(server)
+          #
+          # @param [ Mongo::Server ] server The server to send this operation to.
+          #
+          # @return [ Result ] The operation response, if there is one.
+          #
+          # @since 2.5.0
+          def execute(server)
+            result = Result.new(server.with_connection do |connection|
+              connection.dispatch([ message(server) ], operation_id)
+            end)
+            server.update_cluster_time(result)
+            session.process(result) if session
+            result.validate!
+          end
+
           private
 
           # The query selector for this drop user command operation.

data/lib/mongo/operation/write/command/update.rb

@@ -55,8 +55,7 @@ module Mongo
             global_args = { update: coll_name,
                             Protocol::Msg::DATABASE_IDENTIFIER => db_name
                           }.merge!(command_options)
-            add_cluster_time!(global_args, server)
-            session.add_id!(global_args) if session
+            update_selector_for_session!(global_args, server)
 
             section = { type: 1, payload: { identifier: IDENTIFIER, sequence: updates } }
             flags = unacknowledged_write? ? [:more_to_come] : [:none]

data/lib/mongo/operation/write/command/update_user.rb

@@ -25,6 +25,25 @@ module Mongo
           include Specifiable
           include Writable
 
+          # Execute the operation.
+          #
+          # @example Execute the operation.
+          #   operation.execute(server)
+          #
+          # @param [ Mongo::Server ] server The server to send this operation to.
+          #
+          # @return [ Result ] The operation response, if there is one.
+          #
+          # @since 2.5.0
+          def execute(server)
+            result = Result.new(server.with_connection do |connection|
+              connection.dispatch([ message(server) ], operation_id)
+            end)
+            server.update_cluster_time(result)
+            session.process(result) if session
+            result.validate!
+          end
+
           private
 
           # The query selector for this update user command operation.

data/lib/mongo/operation/write/write_command_enabled.rb

@@ -39,9 +39,7 @@ module Mongo
             raise Error::UnsupportedArrayFilters.new(Error::UnsupportedArrayFilters::UNACKNOWLEDGED_WRITES_MESSAGE) if has_array_filters?
           end
 
-          if !server.features.write_command_enabled? # version < 2.4
-            execute_message(server)
-          elsif server.features.op_msg_enabled? # version 3.6
+          if server.features.op_msg_enabled? # version 3.6
             execute_write_command(server)
           else # server version is 2.6 through 3.4
             if unacknowledged_write?

data/lib/mongo/protocol/compressed.rb

@@ -48,7 +48,8 @@ module Mongo
       #
       # @param [ Mongo::Protocol::Message ] message The original message.
       # @param [ String, Symbol ] compressor The compression algorithm to use.
-      # @param [ Integer ] level The zlib compression level to use. -1 and nil imply default.
+      # @param [ Integer ] zlib_compression_level The zlib compression level to use.
+      #   -1 and nil imply default.
       #
       # @since 2.5.0
       def initialize(message, compressor, zlib_compression_level = nil)

data/lib/mongo/protocol/serializers.rb

@@ -355,9 +355,9 @@ module Mongo
 
         # Writes a byte into the buffer.
         #
-        # @param buffer [ BSON::ByteBuffer ] buffer Buffer to receive the single byte.
-        # @param value [ String ] value The byte to write to the buffer.
-        # @param value [ true, false ] validating_keys Whether to validate keys.
+        # @param [ BSON::ByteBuffer ] buffer Buffer to receive the single byte.
+        # @param [ String ] value The byte to write to the buffer.
+        # @param [ true, false ] validating_keys Whether to validate keys.
         #
         # @return [ BSON::ByteBuffer ] Buffer with serialized value.
         #
@@ -385,9 +385,9 @@ module Mongo
 
         # Writes bytes into the buffer.
         #
-        # @param buffer [ BSON::ByteBuffer ] buffer Buffer to receive the bytes.
-        # @param value [ String ] value The bytes to write to the buffer.
-        # @param value [ true, false ] validating_keys Whether to validate keys.
+        # @param [ BSON::ByteBuffer ] buffer Buffer to receive the bytes.
+        # @param [ String ] value The bytes to write to the buffer.
+        # @param [ true, false ] validating_keys Whether to validate keys.
         #
         # @return [ BSON::ByteBuffer ] Buffer with serialized value.
         #

data/lib/mongo/retryable.rb

@@ -30,7 +30,6 @@ module Mongo
     #
     # @note This only retries read operations on socket errors.
     #
-    # @param [ Integer ] attempt The retry attempt count - for internal use.
     # @param [ Proc ] block The block to execute.
     #
     # @yieldparam [ Server ] server The server to which the write should be sent.
@@ -99,12 +98,58 @@ module Mongo
     # @return [ Result ] The result of the operation.
     #
     # @since 2.1.0
-    def write_with_retry(session, server_selector)
+    def write_with_retry(session, write_concern, &block)
+      unless retry_write_allowed?(session, write_concern)
+        return legacy_write_with_retry(&block)
+      end
+
+      server = cluster.next_primary
+      unless server.retry_writes?
+        return legacy_write_with_retry(server, &block)
+      end
+
+      begin
+        txn_num = session.next_txn_num
+        yield(server, txn_num)
+      rescue Error::SocketError, Error::SocketTimeoutError => e
+        retry_write(e, txn_num, &block)
+      rescue Error::OperationFailure => e
+        raise e unless e.write_retryable?
+        retry_write(e, txn_num, &block)
+      end
+    end
+
+    private
+
+    def retry_write_allowed?(session, write_concern)
+      session && session.retry_writes? &&
+          (write_concern.nil? || write_concern.acknowledged?)
+    end
+
+    def retry_write(original_error, txn_num, &block)
+      cluster.scan!
+      server = cluster.next_primary
+      raise original_error unless (server.retry_writes? && txn_num)
+      log_retry(original_error)
+      yield(server, txn_num)
+    rescue Error::SocketError, Error::SocketTimeoutError => e
+      cluster.scan!
+      raise e
+    rescue Error::OperationFailure => e
+      raise original_error unless e.write_retryable?
+      cluster.scan!
+      raise e
+    rescue
+      raise original_error
+    end
+
+    def legacy_write_with_retry(server = nil)
       attempt = 0
       begin
         attempt += 1
-        yield(server_selector.call)
+        yield(server || cluster.next_primary)
       rescue Error::OperationFailure => e
+        server = nil
         raise(e) if attempt > Cluster::MAX_WRITE_RETRIES
         if e.write_retryable?
           log_retry(e)
@@ -116,8 +161,6 @@ module Mongo
       end
     end
 
-    private
-
     # Log a warning so that any application slow down is immediately obvious.
     def log_retry(e)
       Logger.logger.warn "Retry due to: #{e.class.name} #{e.message}"

data/lib/mongo/server.rb

@@ -268,5 +268,20 @@ module Mongo
       unknown!
       raise
     end
+
+    # Will writes sent to this server be retried.
+    #
+    # @example Will writes be retried.
+    #   server.retry_writes?
+    #
+    # @return [ true, false ] If writes will be retried.
+    #
+    # @note Retryable writes are only available on server versions 3.6+ and with
+    #   sharded clusters or replica sets.
+    #
+    # @since 2.5.0
+    def retry_writes?
+      !!(features.sessions_enabled? && logical_session_timeout && !standalone?)
+    end
   end
 end

data/lib/mongo/server/connection.rb

@@ -54,6 +54,11 @@ module Mongo
       # @since 2.5.0
       PING_OP_MSG_BYTES = PING_OP_MSG_MESSAGE.serialize.to_s.freeze
 
+      # The last time the connection was checked back into a pool.
+      #
+      # @since 2.5.0
+      attr_reader :last_checkin
+
       def_delegators :@server,
                      :features,
                      :max_bson_object_size,
@@ -97,9 +102,10 @@ module Mongo
       #
       # @since 2.0.0
       def disconnect!
+        @auth_mechanism = nil
+        @last_checkin = nil
         if socket
           socket.close
-          @auth_mechanism = nil
           @socket = nil
         end
         true
@@ -151,6 +157,7 @@ module Mongo
         @server = server
         @ssl_options = options.reject { |k, v| !k.to_s.start_with?(SSL) }
         @socket = nil
+        @last_checkin = nil
         @auth_mechanism = nil
         @pid = Process.pid
       end
@@ -189,6 +196,19 @@ module Mongo
       # @deprecated Please use :socket_timeout instead. Will be removed in 3.0.0
       alias :timeout :socket_timeout
 
+      # Record the last checkin time.
+      #
+      # @example Record the checkin time on this connection.
+      #   connection.record_checkin!
+      #
+      # @return [ self ]
+      #
+      # @since 2.5.0
+      def record_checkin!
+        @last_checkin = Time.now
+        self
+      end
+
       private
 
       def deliver(messages)

data/lib/mongo/server/connection_pool.rb

@@ -22,10 +22,13 @@ module Mongo
     # @since 2.0.0
     class ConnectionPool
       include Loggable
+      extend Forwardable
 
       # @return [ Hash ] options The pool options.
       attr_reader :options
 
+      def_delegators :queue, :close_stale_sockets!
+
       # Check a connection back into the pool. Will pull the connection from a
       # thread local stack that should contain it after it was checked out.
       #

data/lib/mongo/server/connection_pool/queue.rb

@@ -16,9 +16,8 @@ module Mongo
   class Server
     class ConnectionPool
 
-      # A FIFO queue of connections to be used by the connection pool. This is
-      # based on mperham's connection pool, implemented with a queue instead of a
-      # stack.
+      # A LIFO queue of connections to be used by the connection pool. This is
+      # based on mperham's connection pool.
       #
       # @since 2.0.0
       class Queue
@@ -88,7 +87,7 @@ module Mongo
         # @since 2.0.0
         def enqueue(connection)
           mutex.synchronize do
-            queue.unshift(connection)
+            queue.unshift(connection.record_checkin!)
             resource.broadcast
           end
         end
@@ -165,12 +164,58 @@ module Mongo
           @wait_timeout ||= options[:wait_queue_timeout] || WAIT_TIMEOUT
         end
 
+        # The maximum seconds a socket can remain idle since it has been checked in to the pool.
+        #
+        # @example Get the max idle time.
+        #   queue.max_idle_time
+        #
+        # @return [ Float ] The max socket idle time in seconds.
+        #
+        # @since 2.5.0
+        def max_idle_time
+          @max_idle_time ||= options[:max_idle_time]
+        end
+
+        # Close sockets that have been open for longer than the max idle time, if the
+        #   option is set.
+        #
+        # @example Close the stale sockets
+        #   queue.close_stale_sockets!
+        #
+        # @since 2.5.0
+        def close_stale_sockets!
+          return unless max_idle_time
+
+          to_refresh = []
+          queue.each do |connection|
+            if last_checkin = connection.last_checkin
+              if (Time.now - last_checkin) > max_idle_time
+                to_refresh << connection
+              end
+            end
+          end
+
+          mutex.synchronize do
+            num_checked_out = @connections - queue.size
+            min_size_delta = [(min_size - num_checked_out), 0].max
+
+            to_refresh.each do |connection|
+              if queue.include?(connection)
+                connection.disconnect!
+                if queue.index(connection) < min_size_delta
+                  begin; connection.connect!; rescue; end
+                end
+              end
+            end
+          end
+        end
+
         private
 
         def dequeue_connection
           deadline = Time.now + wait_timeout
           loop do
-            return queue.pop unless queue.empty?
+            return queue.shift unless queue.empty?
             connection = create_connection
             return connection if connection
             wait_for_next!(deadline)