mongo 2.4.3 → 2.5.0.beta

data/lib/mongo/protocol/reply.rb

@@ -55,11 +55,14 @@ module Mongo
       # @example Return the event payload.
       #   message.payload
       #
-      # @return [ Hash ] The event payload.
+      # @return [ BSON::Document ] The event payload.
       #
       # @since 2.1.0
       def payload
-        { reply: upconverter.command, request_id: request_id }
+        BSON::Document.new(
+          reply: upconverter.command,
+          request_id: request_id
+        )
       end
 
       private
@@ -70,9 +73,9 @@ module Mongo
 
       # The operation code required to specify a Reply message.
       # @return [Fixnum] the operation code.
-      def op_code
-        1
-      end
+      #
+      # @since 2.5.0
+      OP_CODE = 1
 
       # Available flags for a Reply message.
       FLAGS = [
@@ -194,6 +197,8 @@ module Mongo
           documents.first
         end
       end
+
+      Registry.register(OP_CODE, self)
     end
   end
 end

data/lib/mongo/protocol/serializers.rb

@@ -147,6 +147,169 @@ module Mongo
         end
       end
 
+      # MongoDB wire protocol serialization strategy for a Section of OP_MSG.
+      #
+      # Serializes and de-serializes a list of Sections.
+      #
+      # @since 2.5.0
+      module Sections
+
+        # Serializes the sections of an OP_MSG, payload type 0 or 1.
+        #
+        # @param [ BSON::ByteBuffer ] buffer Buffer to receive the serialized Sections.
+        # @param [ Array<Hash, BSON::Document> ] value The sections to be serialized.
+        # @param [ Fixnum ] max_bson_size The max bson size of documents in the sections.
+        # @param [ true, false ] validating_keys Whether to validate document keys.
+        #
+        # @return [ BSON::ByteBuffer ] Buffer with serialized value.
+        #
+        # @since 2.5.0
+        def self.serialize(buffer, value, max_bson_size = nil, validating_keys = BSON::Config.validating_keys?)
+          value.each do |section|
+            case section[:type]
+            when PayloadZero::TYPE
+              PayloadZero.serialize(buffer, section[:payload], max_bson_size, false)
+            when nil
+              PayloadZero.serialize(buffer, section[:payload], max_bson_size, false)
+            when PayloadOne::TYPE
+              PayloadOne.serialize(buffer, section[:payload], max_bson_size, validating_keys)
+            else
+              raise Error::UnknownPayloadType.new(section[:type])
+            end
+          end
+        end
+
+        # Deserializes a section of an OP_MSG from the IO stream.
+        #
+        # @param [ BSON::ByteBuffer ] buffer Buffer containing the sections.
+        #
+        # @return [ Array<BSON::Document> ] Deserialized sections.
+        #
+        # @since 2.5.0
+        def self.deserialize(buffer)
+          end_length = (@flag_bits & Msg::FLAGS.index(:checksum_present)) == 1 ? 32 : 0
+          sections = []
+          until buffer.length == end_length
+            case byte = buffer.get_byte
+            when PayloadZero::TYPE_BYTE
+              sections << PayloadZero.deserialize(buffer)
+            when PayloadOne::TYPE_BYTE
+              sections += PayloadOne.deserialize(buffer)
+            else
+              raise Error::UnknownPayloadType.new(byte)
+            end
+          end
+          sections
+        end
+
+        # Whether there can be a size limit on this type after serialization.
+        #
+        # @return [ true ] Documents can be size limited upon serialization.
+        #
+        # @since 2.5.0
+        def self.size_limited?
+          true
+        end
+
+        # MongoDB wire protocol serialization strategy for a payload 0 type Section of OP_MSG.
+        #
+        # @since 2.5.0
+        module PayloadZero
+
+          # The byte identifier for this payload type.
+          #
+          # @since 2.5.0
+          TYPE = 0x0
+
+          # The byte corresponding to this payload type.
+          #
+          # @since 2.5.0
+          TYPE_BYTE = TYPE.chr.force_encoding(BSON::BINARY).freeze
+
+          # Serializes a section of an OP_MSG, payload type 0.
+          #
+          # @param [ BSON::ByteBuffer ] buffer Buffer to receive the serialized Sections.
+          # @param [ BSON::Document, Hash ] value The object to serialize.
+          # @param [ Fixnum ] max_bson_size The max bson size of documents in the section.
+          # @param [ true, false ] validating_keys Whether to validate document keys.
+          #
+          # @return [ BSON::ByteBuffer ] Buffer with serialized value.
+          #
+          # @since 2.5.0
+          def self.serialize(buffer, value, max_bson_size = nil, validating_keys = BSON::Config.validating_keys?)
+            buffer.put_byte(TYPE_BYTE)
+            Serializers::Document.serialize(buffer, value, max_bson_size, validating_keys)
+          end
+
+          # Deserializes a section of payload type 0 of an OP_MSG from the IO stream.
+          #
+          # @param [ BSON::ByteBuffer ] buffer Buffer containing the sections.
+          #
+          # @return [ Array<BSON::Document> ] Deserialized section.
+          #
+          # @since 2.5.0
+          def self.deserialize(buffer)
+            BSON::Document.from_bson(buffer)
+          end
+        end
+
+        # MongoDB wire protocol serialization strategy for a payload 1 type Section of OP_MSG.
+        #
+        # @since 2.5.0
+        module PayloadOne
+
+          # The byte identifier for this payload type.
+          #
+          # @since 2.5.0
+          TYPE = 0x1
+
+          # The byte corresponding to this payload type.
+          #
+          # @since 2.5.0
+          TYPE_BYTE = TYPE.chr.force_encoding(BSON::BINARY).freeze
+
+          # Serializes a section of an OP_MSG, payload type 1.
+          #
+          # @param [ BSON::ByteBuffer ] buffer Buffer to receive the serialized Sections.
+          # @param [ BSON::Document, Hash ] value The object to serialize.
+          # @param [ Fixnum ] max_bson_size The max bson size of documents in the section.
+          # @param [ true, false ] validating_keys Whether to validate document keys.
+          #
+          # @return [ BSON::ByteBuffer ] Buffer with serialized value.
+          #
+          # @since 2.5.0
+          def self.serialize(buffer, value, max_bson_size = nil, validating_keys = BSON::Config.validating_keys?)
+            buffer.put_byte(TYPE_BYTE)
+            start = buffer.length
+            buffer.put_int32(0) # hold for size
+            buffer.put_cstring(value[:identifier])
+            value[:sequence].each do |document|
+              Document.serialize(buffer, document, max_bson_size, validating_keys)
+            end
+            buffer.replace_int32(start, buffer.length - start)
+          end
+
+          # Deserializes a section of payload type 1 of an OP_MSG from the IO stream.
+          #
+          # @param [ BSON::ByteBuffer ] buffer Buffer containing the sections.
+          #
+          # @return [ Array<BSON::Document> ] Deserialized section.
+          #
+          # @since 2.5.0
+          def self.deserialize(buffer)
+            start_size = buffer.length
+            section_size = buffer.get_int32 # get the size
+            end_size = start_size - section_size
+            buffer.get_cstring # get the identifier
+            documents = []
+            until buffer.length == end_size
+              documents << BSON::Document.from_bson(buffer)
+            end
+            documents
+          end
+        end
+      end
+
       # MongoDB wire protocol serialization strategy for a BSON Document.
       #
       # Serializes and de-serializes a single document.
@@ -184,6 +347,67 @@ module Mongo
           true
         end
       end
+
+      # MongoDB wire protocol serialization strategy for a single byte.
+      #
+      # Writes and fetches a single byte from the byte buffer.
+      module Byte
+
+        # 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.
+        #
+        # @return [ BSON::ByteBuffer ] Buffer with serialized value.
+        #
+        # @since 2.5.0
+        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+          buffer.put_byte(value)
+        end
+
+        # Deserializes a byte from the byte buffer.
+        #
+        # @param [ BSON::ByteBuffer ] buffer Buffer containing the value to read.
+        #
+        # @return [ String ] The byte.
+        #
+        # @since 2.5.0
+        def self.deserialize(buffer)
+          buffer.get_byte
+        end
+      end
+
+      # MongoDB wire protocol serialization strategy for n bytes.
+      #
+      # Writes and fetches bytes from the byte buffer.
+      module Bytes
+
+        # 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.
+        #
+        # @return [ BSON::ByteBuffer ] Buffer with serialized value.
+        #
+        # @since 2.5.0
+        def self.serialize(buffer, value, validating_keys = BSON::Config.validating_keys?)
+          buffer.put_bytes(value)
+        end
+
+        # 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.
+        #
+        # @return [ String ] The bytes.
+        #
+        # @since 2.5.0
+        def self.deserialize(buffer, num_bytes = nil)
+          buffer.get_bytes(num_bytes || buffer.length)
+        end
+      end
     end
   end
 end

data/lib/mongo/protocol/update.rb

@@ -67,16 +67,16 @@ module Mongo
       # @example Return the event payload.
       #   message.payload
       #
-      # @return [ Hash ] The event payload.
+      # @return [ BSON::Document ] The event payload.
       #
       # @since 2.1.0
       def payload
-        {
+        BSON::Document.new(
           command_name: 'update',
           database_name: @database,
           command: upconverter.command,
           request_id: request_id
-        }
+        )
       end
 
       protected
@@ -87,9 +87,9 @@ module Mongo
 
       # The operation code required to specify an Update message.
       # @return [Fixnum] the operation code.
-      def op_code
-        2001
-      end
+      #
+      # @since 2.5.0
+      OP_CODE = 2001
 
       # Available flags for an Update message.
       FLAGS = [:upsert, :multi_update]
@@ -200,6 +200,8 @@ module Mongo
           document
         end
       end
+
+      Registry.register(OP_CODE, self)
     end
   end
 end

data/lib/mongo/retryable.rb

@@ -33,6 +33,8 @@ module Mongo
     # @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.
+    #
     # @return [ Result ] The result of the operation.
     #
     # @since 2.1.0
@@ -97,11 +99,11 @@ module Mongo
     # @return [ Result ] The result of the operation.
     #
     # @since 2.1.0
-    def write_with_retry
+    def write_with_retry(session, server_selector)
       attempt = 0
       begin
         attempt += 1
-        yield
+        yield(server_selector.call)
       rescue Error::OperationFailure => e
         raise(e) if attempt > Cluster::MAX_WRITE_RETRIES
         if e.write_retryable?

data/lib/mongo/server.rb

@@ -50,7 +50,7 @@ module Mongo
     CONNECT_TIMEOUT = 10.freeze
 
     # Get the description from the monitor and scan on monitor.
-    def_delegators :monitor, :description, :scan!, :heartbeat_frequency, :last_scan
+    def_delegators :monitor, :description, :scan!, :heartbeat_frequency, :last_scan, :compressor
     alias :heartbeat_frequency_seconds :heartbeat_frequency
 
     # Delegate convenience methods to the monitor description.
@@ -72,11 +72,14 @@ module Mongo
                    :standalone?,
                    :unknown?,
                    :unknown!,
-                   :last_write_date
+                   :last_write_date,
+                   :logical_session_timeout
 
     # Get the app metadata from the cluster.
     def_delegators :cluster,
-                   :app_metadata
+                   :app_metadata,
+                   :cluster_time,
+                   :update_cluster_time
 
     # Is this server equal to another?
     #

data/lib/mongo/server/connectable.rb

@@ -99,7 +99,7 @@ module Mongo
 
       def read(request_id = nil)
         ensure_connected do |socket|
-          Protocol::Reply.deserialize(socket, max_message_size, request_id)
+          Protocol::Message.deserialize(socket, max_message_size, request_id)
         end
       end
     end

data/lib/mongo/server/connection.rb

@@ -29,22 +29,40 @@ module Mongo
       # @since 2.1.0
       PING = { :ping => 1 }.freeze
 
+      # The ping command for an OP_MSG (server versions >= 3.6).
+      #
+      # @since 2.5.0
+      PING_OP_MSG = { :ping => 1, '$db' => Database::ADMIN }.freeze
+
       # Ping message.
       #
       # @since 2.1.0
       PING_MESSAGE = Protocol::Query.new(Database::ADMIN, Database::COMMAND, PING, :limit => -1)
 
+      # Ping message as an OP_MSG (server versions >= 3.6).
+      #
+      # @since 2.5.0
+      PING_OP_MSG_MESSAGE = Protocol::Msg.new([:none], {}, PING_OP_MSG)
+
       # The ping message as raw bytes.
       #
       # @since 2.1.0
       PING_BYTES = PING_MESSAGE.serialize.to_s.freeze
 
+      # The ping OP_MSG message as raw bytes (server versions >= 3.6).
+      #
+      # @since 2.5.0
+      PING_OP_MSG_BYTES = PING_OP_MSG_MESSAGE.serialize.to_s.freeze
+
       def_delegators :@server,
                      :features,
                      :max_bson_object_size,
                      :max_message_size,
                      :mongos?,
-                     :app_metadata
+                     :app_metadata,
+                     :compressor,
+                     :cluster_time,
+                     :update_cluster_time
 
       # Tell the underlying socket to establish a connection to the host.
       #
@@ -99,7 +117,7 @@ module Mongo
       # @param [ Array<Message> ] messages The messages to dispatch.
       # @param [ Integer ] operation_id The operation id to link messages.
       #
-      # @return [ Protocol::Reply ] The reply if needed.
+      # @return [ Protocol::Message ] The reply if needed.
       #
       # @since 2.0.0
       def dispatch(messages, operation_id = nil)
@@ -149,9 +167,10 @@ module Mongo
       #
       # @since 2.1.0
       def ping
+        bytes = features.op_msg_enabled? ? PING_OP_MSG_BYTES : PING_BYTES
         ensure_connected do |socket|
-          socket.write(PING_BYTES)
-          reply = Protocol::Reply.deserialize(socket, max_message_size)
+          socket.write(bytes)
+          reply = Protocol::Message.deserialize(socket, max_message_size)
           reply.documents[0][Operation::Result::OK] == 1
         end
       end
@@ -180,7 +199,7 @@ module Mongo
       def handshake!
         if socket && socket.connectable?
           socket.write(app_metadata.ismaster_bytes)
-          response = Protocol::Reply.deserialize(socket, max_message_size).documents[0]
+          response = Protocol::Message.deserialize(socket, max_message_size).documents[0]
           min_wire_version = response[Description::MIN_WIRE_VERSION] || Description::LEGACY_WIRE_VERSION
           max_wire_version = response[Description::MAX_WIRE_VERSION] || Description::LEGACY_WIRE_VERSION
           features = Description::Features.new(min_wire_version..max_wire_version)
@@ -190,9 +209,12 @@ module Mongo
 
       def authenticate!
         if options[:user] || options[:auth_mech]
-          user = Auth::User.new(Options::Redacted.new(:auth_mech => default_mechanism).merge(options))
+          user = Auth::User.new(Options::Redacted.new(:auth_mech => default_mechanism, :client_key => @client_key).merge(options))
+ 
           @server.handle_auth_failure! do
-            Auth.get(user).login(self)
+            reply = Auth.get(user).login(self)
+            @client_key ||= user.send(:client_key) if user.mechanism == :scram
+            reply
           end
         end
       end
@@ -204,7 +226,7 @@ module Mongo
       def write(messages, buffer = BSON::ByteBuffer.new)
         start_size = 0
         messages.each do |message|
-          message.serialize(buffer, max_bson_object_size)
+          message.compress!(compressor, options[:zlib_compression_level]).serialize(buffer, max_bson_object_size)
           if max_message_size &&
             (buffer.length - start_size) > max_message_size
             raise Error::MaxMessageSize.new(max_message_size)