mongo 2.1.0.rc0 → 2.1.0

data/lib/mongo/protocol/insert.rb

@@ -104,6 +104,26 @@ module Mongo
       # @since 2.1.0
       class Upconverter
 
+        # Insert field constant.
+        #
+        # @since 2.1.0
+        INSERT = 'insert'.freeze
+
+        # Documents field constant.
+        #
+        # @since 2.1.0
+        DOCUMENTS = 'documents'.freeze
+
+        # Ordered field constant.
+        #
+        # @since 2.1.0
+        ORDERED = 'ordered'.freeze
+
+        # Write concern field constant.
+        #
+        # @since 2.1.0
+        WRITE_CONCERN = 'writeConcern'.freeze
+
         # @return [ String ] collection The name of the collection.
         attr_reader :collection
 
@@ -138,12 +158,11 @@ module Mongo
         #
         # @since 2.1.0
         def command
-          document = BSON::Document.new(
-            insert: collection,
-            documents: documents,
-            ordered: options.fetch(:ordered, true)
-          )
-          document.merge!(writeConcern: options[:write_concern].options) if options[:write_concern]
+          document = BSON::Document.new
+          document.store(INSERT, collection)
+          document.store(DOCUMENTS, documents)
+          document.store(ORDERED, options.fetch(:ordered, true))
+          document.merge!(WRITE_CONCERN => options[:write_concern].options) if options[:write_concern]
           document
         end
       end

data/lib/mongo/protocol/query.rb

@@ -158,37 +158,47 @@ module Mongo
         #
         # @since 2.1.0
         OPTION_MAPPINGS = {
-          :project => :projection,
-          :skip => :skip,
-          :limit => :limit,
-          :batch_size => :batchSize
-        }
+          :project => 'projection',
+          :skip => 'skip',
+          :limit => 'limit',
+          :batch_size => 'batchSize'
+        }.freeze
 
         SPECIAL_FIELD_MAPPINGS = {
-          :$readPreference => :readPreference,
-          :$orderby => :sort,
-          :$hint => :hint,
-          :$comment => :comment,
-          :$returnKey => :returnKey,
-          :$snapshot => :snapshot,
-          :$maxScan => :maxScan,
-          :$max => :max,
-          :$min => :min,
-          :$maxTimeMS => :maxTimeMS,
-          :$showDiskLoc => :showRecordId,
-          :$explain => :explain
-        }
+          :$readPreference => 'readPreference',
+          :$orderby => 'sort',
+          :$hint => 'hint',
+          :$comment => 'comment',
+          :$returnKey => 'returnKey',
+          :$snapshot => 'snapshot',
+          :$maxScan => 'maxScan',
+          :$max => 'max',
+          :$min => 'min',
+          :$maxTimeMS => 'maxTimeMS',
+          :$showDiskLoc => 'showRecordId',
+          :$explain => 'explain'
+        }.freeze
 
         # Mapping of flags to find command options.
         #
         # @since 2.1.0
         FLAG_MAPPINGS = {
-          :tailable_cursor => :tailable,
-          :oplog_replay => :oplogReplay,
-          :no_cursor_timeout => :noCursorTimeout,
-          :await_data => :awaitData,
-          :partial => :allowPartialResults
-        }
+          :tailable_cursor => 'tailable',
+          :oplog_replay => 'oplogReplay',
+          :no_cursor_timeout => 'noCursorTimeout',
+          :await_data => 'awaitData',
+          :partial => 'allowPartialResults'
+        }.freeze
+
+        # Find command constant.
+        #
+        # @since 2.1.0
+        FIND = 'find'.freeze
+
+        # Filter attribute constant.
+        #
+        # @since 2.1.0
+        FILTER = 'filter'.freeze
 
         # @return [ String ] collection The name of the collection.
         attr_reader :collection
@@ -242,7 +252,7 @@ module Mongo
         #
         # @since 2.1.0
         def command_name
-          command? ? filter.keys.first : 'find'
+          command? ? filter.keys.first : FIND
         end
 
         private
@@ -252,21 +262,25 @@ module Mongo
         end
 
         def op_command
-          BSON::Document.new(filter)
+          document = BSON::Document.new
+          filter.each do |field, value|
+            document.store(field.to_s, value)
+          end
+          document
         end
 
         def find_command
           document = BSON::Document.new
-          document[:find] = collection
-          document[:filter] = filter[:$query] ? filter[:$query] : filter
+          document.store(FIND, collection)
+          document.store(FILTER, filter[:$query] ? filter[:$query] : filter)
           OPTION_MAPPINGS.each do |legacy, option|
-            document[option] = options[legacy] unless options[legacy].nil?
+            document.store(option, options[legacy]) unless options[legacy].nil?
           end
           SPECIAL_FIELD_MAPPINGS.each do |special, normal|
-            document[normal] = filter[special] unless filter[special].nil?
+            document.store(normal, filter[special]) unless filter[special].nil?
           end
           FLAG_MAPPINGS.each do |legacy, flag|
-            document[flag] = true if flags.include?(legacy)
+            document.store(flag, true) if flags.include?(legacy)
           end
           document
         end

data/lib/mongo/protocol/reply.rb

@@ -101,6 +101,26 @@ module Mongo
       # @since 2.1.0
       class Upconverter
 
+        # Next batch constant.
+        #
+        # @since 2.1.0
+        NEXT_BATCH = 'nextBatch'.freeze
+
+        # First batch constant.
+        #
+        # @since 2.1.0
+        FIRST_BATCH = 'firstBatch'.freeze
+
+        # Cursor field constant.
+        #
+        # @since 2.1.0
+        CURSOR = 'cursor'.freeze
+
+        # Id field constant.
+        #
+        # @since 2.1.0
+        ID = 'id'.freeze
+
         # @return [ Array<BSON::Document> ] documents The documents.
         attr_reader :documents
 
@@ -141,18 +161,21 @@ module Mongo
         private
 
         def batch_field
-          starting_from > 0 ? :nextBatch : :firstBatch
+          starting_from > 0 ? NEXT_BATCH : FIRST_BATCH
         end
 
         def command?
-          !documents.empty? && documents.first.key?('ok')
+          !documents.empty? && documents.first.key?(Operation::Result::OK)
         end
 
         def find_command
-          BSON::Document.new(
-            ok: 1,
-            cursor: BSON::Document.new(id: cursor_id, batch_field => documents)
-          )
+          document = BSON::Document.new
+          cursor_document = BSON::Document.new
+          cursor_document.store(ID, cursor_id)
+          cursor_document.store(batch_field, documents)
+          document.store(Operation::Result::OK, 1)
+          document.store(CURSOR, cursor_document)
+          document
         end
 
         def op_command

data/lib/mongo/protocol/serializers.rb

@@ -74,7 +74,7 @@ module Mongo
         # @param value [String] The string to be serialized.
         # @return [String] Buffer with serialized value.
         def self.serialize(buffer, value)
-          buffer << value
+          buffer << value.force_encoding(BSON::BINARY)
           buffer << NULL
         end
       end

data/lib/mongo/retryable.rb

@@ -0,0 +1,83 @@
+# 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.
+    #
+    # @example Execute the read.
+    #   read_with_retry do
+    #     ...
+    #   end
+    #
+    # @note This only retries read operations on socket errors.
+    #
+    # @param [ Proc ] block The block to execute.
+    #
+    # @return [ Result ] The result of the operation.
+    #
+    # @since 2.1.0
+    def read_with_retry(&block)
+      begin
+        block.call
+      rescue Error::SocketError, Error::SocketTimeoutError
+        retry_operation(&block)
+      end
+    end
+
+    # Execute a write operation with a retry.
+    #
+    # @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.rb

@@ -92,6 +92,21 @@ module Mongo
       Context.new(self)
     end
 
+    # Determine if a connection to the server is able to be established and
+    # messages can be sent to it.
+    #
+    # @example Is the server connectable?
+    #   server.connectable?
+    #
+    # @return [ true, false ] If the server is connectable.
+    #
+    # @since 2.1.0
+    def connectable?
+      context.with_connection do |connection|
+        connection.connectable?
+      end
+    end
+
     # Disconnect the server from the connection.
     #
     # @example Disconnect the server.
@@ -101,9 +116,7 @@ module Mongo
     #
     # @since 2.0.0
     def disconnect!
-      context.with_connection do |connection|
-        connection.disconnect!
-      end
+      pool.disconnect!
       monitor.stop! and true
     end
 

data/lib/mongo/server/connectable.rb

@@ -20,6 +20,11 @@ module Mongo
     # @since 2.0.0
     module Connectable
 
+      # The ssl option prefix.
+      #
+      # @since 2.1.0
+      SSL = 'ssl'.freeze
+
       # The default time in seconds to timeout a connection attempt.
       #
       # @since 2.0.0
@@ -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,7 +59,7 @@ module Mongo
       #
       # @return [ true, false ] If connected.
       #
-      # @since 2.0.0
+      # @deprecated Use #connectable? instead
       def connected?
         !!@socket && @socket.alive?
       end
@@ -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

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.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
@@ -133,12 +148,31 @@ 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)
@@ -149,12 +183,12 @@ module Mongo
       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 = ''.force_encoding(BSON::BINARY))
         start_size = 0
         messages.each do |message|
           message.serialize(buffer, max_bson_object_size)