mongo 2.1.0.beta → 2.2.0

data/lib/mongo/protocol/update.rb

@@ -53,10 +53,12 @@ module Mongo
       #   Supported flags: +:upsert+, +:multi_update+
       def initialize(database, collection, selector, update, options = {})
         @database    = database
+        @collection  = collection
         @namespace   = "#{database}.#{collection}"
         @selector    = selector
         @update      = update
         @flags       = options[:flags] || []
+        @upconverter = Upconverter.new(collection, selector, update, flags)
       end
 
       # Return the event payload for monitoring.
@@ -71,13 +73,15 @@ module Mongo
         {
           command_name: 'update',
           database_name: @database,
-          command: { filter: selector, update: update },
+          command: upconverter.command,
           request_id: request_id
         }
       end
 
       private
 
+      attr_reader :upconverter
+
       # The operation code required to specify an Update message.
       # @return [Fixnum] the operation code.
       def op_code
@@ -105,6 +109,94 @@ module Mongo
       # @!attribute
       # @return [Hash] The update for this Delete message.
       field :update, Document
+
+      # Converts legacy update messages to the appropriare OP_COMMAND style
+      # message.
+      #
+      # @since 2.1.0
+      class Upconverter
+
+        # The multi constant.
+        #
+        # @since 2.2.0
+        MULTI = 'multi'.freeze
+
+        # The u constant.
+        #
+        # @since 2.2.0
+        U = 'u'.freeze
+
+        # The update constant.
+        #
+        # @since 2.2.0
+        UPDATE = 'update'.freeze
+
+        # The updates constant.
+        #
+        # @since 2.2.0
+        UPDATES = 'updates'.freeze
+
+        # The upsert constant.
+        #
+        # @since 2.2.0
+        UPSERT = 'upsert'.freeze
+
+        # @return [ String ] collection The name of the collection.
+        attr_reader :collection
+
+        # @return [ Hash ] filter The filter.
+        attr_reader :filter
+
+        # @return [ Hash ] update The update.
+        attr_reader :update
+
+        # @return [ Array<Symbol> ] flags The flags.
+        attr_reader :flags
+
+        # Instantiate the upconverter.
+        #
+        # @example Instantiate the upconverter.
+        #   Upconverter.new(
+        #     'users',
+        #     { name: 'test' },
+        #     { '$set' => { 'name' => 't' }},
+        #     []
+        #   )
+        #
+        # @param [ String ] collection The name of the collection.
+        # @param [ Hash ] filter The filter.
+        # @param [ Hash ] update The update.
+        # @param [ Array<Symbol> ] flags The flags.
+        #
+        # @since 2.1.0
+        def initialize(collection, filter, update, flags)
+          @collection = collection
+          @filter = filter
+          @update = update
+          @flags = flags
+        end
+
+        # Get the upconverted command.
+        #
+        # @example Get the command.
+        #   upconverter.command
+        #
+        # @return [ BSON::Document ] The upconverted command.
+        #
+        # @since 2.1.0
+        def command
+          document = BSON::Document.new
+          updates = BSON::Document.new
+          updates.store(Message::Q, filter)
+          updates.store(U, update)
+          updates.store(MULTI, flags.include?(:multi_update))
+          updates.store(UPSERT, flags.include?(:upsert))
+          document.store(UPDATE, collection)
+          document.store(Message::ORDERED, true)
+          document.store(UPDATES, [ updates ])
+          document
+        end
+      end
     end
   end
 end

data/lib/mongo/retryable.rb

@@ -0,0 +1,101 @@
+# Copyright (C) 2015 MongoDB, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+
+  # Defines basic behaviour around retrying operations.
+  #
+  # @since 2.1.0
+  module Retryable
+
+    # The not master error message.
+    #
+    # @since 2.1.0
+    NOT_MASTER = 'not master'.freeze
+
+    # Execute a read operation with a retry.
+    #
+    # @api private
+    #
+    # @example Execute the read.
+    #   read_with_retry do
+    #     ...
+    #   end
+    #
+    # @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.
+    #
+    # @return [ Result ] The result of the operation.
+    #
+    # @since 2.1.0
+    def read_with_retry(attempt = 0, &block)
+      begin
+        block.call
+      rescue Error::SocketError, Error::SocketTimeoutError
+        retry_operation(&block)
+      rescue Error::OperationFailure => e
+        if cluster.sharded? && e.retryable?
+          if attempt < cluster.max_read_retries
+            # We don't scan the cluster in this case as Mongos always returns
+            # ready after a ping no matter what the state behind it is.
+            sleep(cluster.read_retry_interval)
+            read_with_retry(attempt + 1, &block)
+          else
+            raise e
+          end
+        else
+          raise e
+        end
+      end
+    end
+
+    # Execute a write operation with a retry.
+    #
+    # @api private
+    #
+    # @example Execute the write.
+    #   write_with_retry do
+    #     ...
+    #   end
+    #
+    # @note This only retries operations on not master failures, since it is
+    #   the only case we can be sure a partial write did not already occur.
+    #
+    # @param [ Proc ] block The block to execute.
+    #
+    # @return [ Result ] The result of the operation.
+    #
+    # @since 2.1.0
+    def write_with_retry(&block)
+      begin
+        block.call
+      rescue Error::OperationFailure => e
+        if e.message.include?(NOT_MASTER)
+          retry_operation(&block)
+        else
+          raise e
+        end
+      end
+    end
+
+    private
+
+    def retry_operation(&block)
+      cluster.scan!
+      block.call
+    end
+  end
+end

data/lib/mongo/server/connectable.rb

@@ -20,7 +20,12 @@ module Mongo
     # @since 2.0.0
     module Connectable
 
-      # The default time in seconds to timeout a connection attempt.
+      # The ssl option prefix.
+      #
+      # @since 2.1.0
+      SSL = 'ssl'.freeze
+
+      # The default time in seconds to timeout an operation executed on a socket.
       #
       # @since 2.0.0
       TIMEOUT = 5.freeze
@@ -34,6 +39,19 @@ module Mongo
       # @return [ Integer ] pid The process id when the connection was created.
       attr_reader :pid
 
+      # Determine if the server is connectable. This will check not only if the
+      # connection exists, but if messages can send to it successfully.
+      #
+      # @example Is the server connectable?
+      #   connection.connectable?
+      #
+      # @return [ true, false ] If the connection is connectable.
+      #
+      # @since 2.1.0
+      def connectable?
+        begin; ping; rescue; false; end
+      end
+
       # Determine if the connection is currently connected.
       #
       # @example Is the connection connected?
@@ -41,17 +59,17 @@ module Mongo
       #
       # @return [ true, false ] If connected.
       #
-      # @since 2.0.0
+      # @deprecated Use #connectable? instead
       def connected?
         !!@socket && @socket.alive?
       end
 
-      # Get the connection timeout.
+      # Get the timeout to execute an operation on a socket.
       #
-      # @example Get the connection timeout.
+      # @example Get the timeout to execute an operation on a socket.
       #   connection.timeout
       #
-      # @return [ Float ] The connection timeout in seconds.
+      # @return [ Float ] The operation timeout in seconds.
       #
       # @since 2.0.0
       def timeout
@@ -68,10 +86,10 @@ module Mongo
 
       def ensure_connected
         ensure_same_process!
-        connect! if socket.nil? || !socket.alive?
+        connect!
         begin
           yield socket
-        rescue Error::SocketError, Error::SocketTimeoutError => e
+        rescue Exception => e
           disconnect!
           raise e
         end
@@ -85,7 +103,9 @@ module Mongo
       end
 
       def read
-        ensure_connected{ |socket| Protocol::Reply.deserialize(socket) }
+        ensure_connected do |socket|
+          Protocol::Reply.deserialize(socket)
+        end
       end
     end
   end

data/lib/mongo/server/connection.rb

@@ -23,6 +23,21 @@ module Mongo
       include Monitoring::Publishable
       extend Forwardable
 
+      # The ping command.
+      #
+      # @since 2.1.0
+      PING = { :ping => 1 }.freeze
+
+      # Ping message.
+      #
+      # @since 2.1.0
+      PING_MESSAGE = Protocol::Query.new(Database::ADMIN, Database::COMMAND, PING, :limit => -1)
+
+      # The ping message as raw bytes.
+      #
+      # @since 2.1.0
+      PING_BYTES = PING_MESSAGE.serialize.to_s.freeze
+
       # @return [ Mongo::Auth::CR, Mongo::Auth::X509, Mongo::Auth:LDAP, Mongo::Auth::SCRAM ]
       #   authenticator The authentication strategy.
       attr_reader :authenticator
@@ -60,7 +75,7 @@ module Mongo
       def connect!
         unless socket
           @socket = address.socket(timeout, ssl_options)
-          @socket.connect!
+          socket.connect!
           if authenticator
             authenticator.login(self)
             @authenticated = true
@@ -105,9 +120,12 @@ module Mongo
       #
       # @since 2.0.0
       def dispatch(messages, operation_id = nil)
-        publish_command(messages, operation_id || Monitoring.next_operation_id) do |msgs|
-          write(msgs)
-          msgs.last.replyable? ? read : nil
+        if monitoring.subscribers?(Monitoring::COMMAND)
+          publish_command(messages, operation_id || Monitoring.next_operation_id) do |msgs|
+            deliver(msgs)
+          end
+        else
+          deliver(messages)
         end
       end
 
@@ -130,33 +148,57 @@ module Mongo
         @monitoring = server.monitoring
         @options = options.freeze
         @server = server
-        @ssl_options = options.reject { |k, v| !k.to_s.start_with?('ssl') }
+        @ssl_options = options.reject { |k, v| !k.to_s.start_with?(SSL) }
         @socket = nil
         @pid = Process.pid
         setup_authentication!
       end
 
+      # Ping the connection to see if the server is responding to commands.
+      # This is non-blocking on the server side.
+      #
+      # @example Ping the connection.
+      #   connection.ping
+      #
+      # @note This uses a pre-serialized ping message for optimization.
+      #
+      # @return [ true, false ] If the server is accepting connections.
+      #
+      # @since 2.1.0
+      def ping
+        ensure_connected do |socket|
+          socket.write(PING_BYTES)
+          reply = Protocol::Reply.deserialize(socket)
+          reply.documents[0][Operation::Result::OK] == 1
+        end
+      end
+
       private
 
+      def deliver(messages)
+        write(messages)
+        messages.last.replyable? ? read : nil
+      end
+
       def setup_authentication!
         if options[:user]
           default_mechanism = @server.features.scram_sha_1_enabled? ? :scram : :mongodb_cr
-          user = Auth::User.new({ :auth_mech => default_mechanism }.merge(options))
+          user = Auth::User.new(Options::Redacted.new(:auth_mech => default_mechanism).merge(options))
           @authenticator = Auth.get(user)
         end
       end
 
-      def write(messages, buffer = '')
+      def write(messages, buffer = BSON::ByteBuffer.new)
         start_size = 0
         messages.each do |message|
           message.serialize(buffer, max_bson_object_size)
           if max_message_size &&
-            (buffer.size - start_size) > max_message_size
+            (buffer.length - start_size) > max_message_size
             raise Error::MaxMessageSize.new(max_message_size)
-            start_size = buffer.size
+            start_size = buffer.length
           end
         end
-        ensure_connected{ |socket| socket.write(buffer) }
+        ensure_connected{ |socket| socket.write(buffer.to_s) }
       end
     end
   end

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

@@ -63,6 +63,21 @@ module Mongo
           end
         end
 
+        # Disconnect all connections in the queue.
+        #
+        # @example Disconnect all connections.
+        #   queue.disconnect!
+        #
+        # @return [ true ] Always true.
+        #
+        # @since 2.1.0
+        def disconnect!
+          mutex.synchronize do
+            queue.each{ |connection| connection.disconnect! }
+            true
+          end
+        end
+
         # Enqueue a connection in the queue.
         #
         # @example Enqueue a connection.

data/lib/mongo/server/connection_pool.rb

@@ -23,9 +23,6 @@ module Mongo
     class ConnectionPool
       include Loggable
 
-      # Used for synchronization of pools access.
-      MUTEX = Mutex.new
-
       # @return [ Hash ] options The pool options.
       attr_reader :options
 
@@ -54,6 +51,18 @@ module Mongo
         queue.dequeue
       end
 
+      # Disconnect the connection pool.
+      #
+      # @example Disconnect the connection pool.
+      #   pool.disconnect!
+      #
+      # @return [ true ] true.
+      #
+      # @since 2.1.0
+      def disconnect!
+        queue.disconnect!
+      end
+
       # Create the new connection pool.
       #
       # @example Create the new connection pool.
@@ -119,22 +128,10 @@ module Mongo
         #
         # @since 2.0.0
         def get(server)
-          MUTEX.synchronize do
-            pools[server.address] ||= create_pool(server)
-          end
-        end
-
-        private
-
-        def create_pool(server)
           ConnectionPool.new(server.options) do
             Connection.new(server, server.options)
           end
         end
-
-        def pools
-          @pools ||= {}
-        end
       end
     end
   end

data/lib/mongo/server/description/features.rb

@@ -25,16 +25,18 @@ module Mongo
         #
         # @since 2.0.0
         MAPPINGS = {
+          :find_command => 4,
           :list_collections => 3,
           :list_indexes => 3,
           :scram_sha_1 => 3,
-          :write_command => 2
+          :write_command => 2,
+          :users_info => 2
         }.freeze
 
         # The wire protocol versions that this version of the driver supports.
         #
         # @since 2.0.0
-        DRIVER_WIRE_VERSIONS = (0..3).freeze
+        DRIVER_WIRE_VERSIONS = (0..4).freeze
 
         # Create the methods for each mapping to tell if they are supported.
         #

data/lib/mongo/server/description.rb

@@ -84,6 +84,11 @@ module Mongo
       # @since 2.0.0
       MAX_WRITE_BATCH_SIZE = 'maxWriteBatchSize'.freeze
 
+      # Constant for reading the me field.
+      #
+      # @since 2.1.0
+      ME = 'me'.freeze
+
       # Default max write batch size.
       #
       # @since 2.0.0
@@ -137,7 +142,7 @@ module Mongo
       # Fields to exclude when comparing two descriptions.
       #
       # @since 2.0.6
-      EXCLUDE_FOR_COMPARISON = [ LOCAL_TIME, ELECTION_ID ]
+      EXCLUDE_FOR_COMPARISON = [ LOCAL_TIME, ELECTION_ID ].freeze
 
       # @return [ Address ] address The server's address.
       attr_reader :address
@@ -302,6 +307,18 @@ module Mongo
         config[MIN_WIRE_VERSION] || LEGACY_WIRE_VERSION
       end
 
+      # Get the me field value.
+      #
+      # @example Get the me field value.
+      #   description.me
+      #
+      # @return [ String ] The me field.
+      #
+      # @since 2.1.0
+      def me
+        config[ME]
+      end
+
       # Get the tags configured for the server.
       #
       # @example Get the tags.
@@ -347,7 +364,8 @@ module Mongo
       #
       # @since 2.0.0
       def other?
-        !primary? && !secondary? && !passive? && !arbiter?
+        (!primary? && !secondary? && !passive? && !arbiter?) ||
+          (hidden? && !replica_set_name.nil?)
       end
 
       # Will return true if the server is passive.
@@ -511,6 +529,18 @@ module Mongo
         !(standalone? || mongos?)
       end
 
+      # Check if there is a mismatch between the address host and the me field.
+      #
+      # @example Check if there is a mismatch.
+      #   description.me_mismatch?
+      #
+      # @return [ true, false ] If there is a mismatch between the me field and the address host.
+      #
+      # @since 2.0.6
+      def me_mismatch?
+        !!(address.to_s != me if me)
+      end
+
       # Check equality of two descriptions.
       #
       # @example Check description equality.
@@ -524,11 +554,17 @@ module Mongo
       def ==(other)
         return false if self.class != other.class
         return true if config == other.config
+        compare_config(other)
+      end
+      alias_method :eql?, :==
+
+      private
+
+      def compare_config(other)
         !config.keys.empty? && config.keys.all? do |k|
           config[k] == other.config[k] || EXCLUDE_FOR_COMPARISON.include?(k)
         end
       end
-      alias_method :eql?, :==
     end
   end
 end

data/lib/mongo/server/monitor/connection.rb

@@ -22,6 +22,53 @@ module Mongo
       class Connection
         include Connectable
 
+        # The command used for determining server status.
+        #
+        # @since 2.2.0
+        ISMASTER = { :ismaster => 1 }.freeze
+
+        # The constant for the ismaster command.
+        #
+        # @since 2.2.0
+        ISMASTER_MESSAGE = Protocol::Query.new(Database::ADMIN, Database::COMMAND, ISMASTER, :limit => -1)
+
+        # The raw bytes for the ismaster message.
+        #
+        # @since 2.2.0
+        ISMASTER_BYTES = ISMASTER_MESSAGE.serialize.to_s.freeze
+
+        # The default time in seconds to timeout a connection attempt.
+        #
+        # @since 2.1.2
+        CONNECT_TIMEOUT = 10.freeze
+
+        # Send the preserialized ismaster call.
+        #
+        # @example Send a preserialized ismaster message.
+        #   connection.ismaster
+        #
+        # @return [ BSON::Document ] The ismaster result.
+        #
+        # @since 2.2.0
+        def ismaster
+          ensure_connected do |socket|
+            socket.write(ISMASTER_BYTES)
+            Protocol::Reply.deserialize(socket).documents[0]
+          end
+        end
+
+        # Get the connection timeout.
+        #
+        # @example Get the connection timeout.
+        #   connection.timeout
+        #
+        # @return [ Float ] The connection timeout in seconds.
+        #
+        # @since 2.0.0
+        def timeout
+          @timeout ||= options[:connect_timeout] || CONNECT_TIMEOUT
+        end
+
         # Tell the underlying socket to establish a connection to the host.
         #
         # @example Connect to the host.
@@ -36,7 +83,7 @@ module Mongo
         def connect!
           unless socket
             @socket = address.socket(timeout, ssl_options)
-            @socket.connect!
+            socket.connect!
           end
           true
         end
@@ -60,25 +107,6 @@ module Mongo
           true
         end
 
-        # Dispatch the provided messages to the connection. If the last message
-        # requires a response a reply will be returned.
-        #
-        # @example Dispatch the messages.
-        #   connection.dispatch([ insert, command ])
-        #
-        # @note This method is named dispatch since 'send' is a core Ruby method on
-        #   all objects.
-        #
-        # @param [ Array<Message> ] messages The messages to dispatch.
-        #
-        # @return [ Protocol::Reply ] The reply if needed.
-        #
-        # @since 2.0.0
-        def dispatch(messages)
-          write(messages)
-          messages.last.replyable? ? read : nil
-        end
-
         # Initialize a new socket connection from the client to the server.
         #
         # @api private
@@ -96,17 +124,10 @@ module Mongo
         def initialize(address, options = {})
           @address = address
           @options = options.freeze
-          @ssl_options = options.reject { |k, v| !k.to_s.start_with?('ssl') }
+          @ssl_options = options.reject { |k, v| !k.to_s.start_with?(SSL) }
           @socket = nil
           @pid = Process.pid
         end
-
-        private
-
-        def write(messages, buffer = '')
-          messages.each{ |message| message.serialize(buffer) }
-          ensure_connected{ |socket| socket.write(buffer) }
-        end
       end
     end
   end