mongo 2.4.3 → 2.5.0.beta

data/lib/mongo/auth/x509.rb

@@ -50,12 +50,14 @@ module Mongo
       # @param [ Mongo::Connection ] connection The connection to log into.
       #   on.
       #
-      # @return [ Protocol::Reply ] The authentication response.
+      # @return [ Protocol::Message ] The authentication response.
       #
       # @since 2.0.0
       def login(connection)
         conversation = Conversation.new(user)
-        conversation.finalize(connection.dispatch([ conversation.start ]))
+        reply = connection.dispatch([ conversation.start(connection) ])
+        connection.update_cluster_time(Operation::Result.new(reply))
+        conversation.finalize(reply)
       end
     end
   end

data/lib/mongo/auth/x509/conversation.rb

@@ -27,7 +27,7 @@ module Mongo
         # @since 2.0.0
         LOGIN = { authenticate: 1 }.freeze
 
-        # @return [ Protocol::Reply ] reply The current reply in the
+        # @return [ Protocol::Message ] reply The current reply in the
         #   conversation.
         attr_reader :reply
 
@@ -40,7 +40,7 @@ module Mongo
         # @example Finalize the conversation.
         #   conversation.finalize(reply)
         #
-        # @param [ Protocol::Reply ] reply The reply of the previous
+        # @param [ Protocol::Message ] reply The reply of the previous
         #   message.
         #
         # @return [ Protocol::Query ] The next message to send.
@@ -56,18 +56,28 @@ module Mongo
         # @example Start the conversation.
         #   conversation.start
         #
+        # @param [ Mongo::Server::Connection ] connection The connection being authenticated.
+        #
         # @return [ Protocol::Query ] The first x.509 conversation message.
         #
         # @since 2.0.0
-        def start
+        def start(connection = nil)
           login = LOGIN.merge(mechanism: X509::MECHANISM)
           login[:user] = user.name if user.name
-          Protocol::Query.new(
-            Auth::EXTERNAL,
-            Database::COMMAND,
-            login,
-            limit: -1
-          )
+          if connection && connection.features.op_msg_enabled?
+            selector = login
+            selector[Protocol::Msg::DATABASE_IDENTIFIER] = user.auth_source
+            cluster_time = connection.mongos? && connection.cluster_time
+            selector[Operation::CLUSTER_TIME] = cluster_time if cluster_time
+            Protocol::Msg.new([:none], {}, selector)
+          else
+            Protocol::Query.new(
+              Auth::EXTERNAL,
+              Database::COMMAND,
+              login,
+              limit: -1
+            )
+          end
         end
 
         # Create the new conversation.

data/lib/mongo/bulk_write.rb

@@ -53,18 +53,23 @@ module Mongo
     def execute
       operation_id = Monitoring.next_operation_id
       result_combiner = ResultCombiner.new
-      write_with_retry do
-        operations = op_combiner.combine
-        server = next_primary
-        raise Error::UnsupportedCollation.new if op_combiner.has_collation && !server.features.collation_enabled?
-        operations.each do |operation|
-          execute_operation(
-            operation.keys.first,
-            operation.values.first,
-            server,
-            operation_id,
-            result_combiner
-          )
+
+      client.send(:with_session, @options) do |session|
+        write_with_retry(session, Proc.new { next_primary }) do |server|
+          operations = op_combiner.combine
+          raise Error::UnsupportedCollation.new if op_combiner.has_collation && !server.features.collation_enabled?
+          raise Error::UnsupportedArrayFilters.new if op_combiner.has_array_filters && !server.features.array_filters_enabled?
+
+          operations.each do |operation|
+            execute_operation(
+                operation.keys.first,
+                operation.values.first,
+                server,
+                operation_id,
+                result_combiner,
+                session
+            )
+          end
         end
       end
       result_combiner.result
@@ -132,7 +137,7 @@ module Mongo
 
     private
 
-    def base_spec(operation_id)
+    def base_spec(operation_id, session)
       {
         :db_name => database.name,
         :coll_name => collection.name,
@@ -141,20 +146,21 @@ module Mongo
         :operation_id => operation_id,
         :bypass_document_validation => !!options[:bypass_document_validation],
         :options => options,
-        :id_generator => client.options[:id_generator]
+        :id_generator => client.options[:id_generator],
+        :session => session
       }
     end
 
-    def execute_operation(name, values, server, operation_id, combiner)
+    def execute_operation(name, values, server, operation_id, combiner, session)
       begin
         if values.size > server.max_write_batch_size
-          split_execute(name, values, server, operation_id, combiner)
+          split_execute(name, values, server, operation_id, combiner, session)
         else
-          combiner.combine!(send(name, values, server, operation_id), values.size)
+          combiner.combine!(send(name, values, server, operation_id, session), values.size)
         end
       rescue Error::MaxBSONSize, Error::MaxMessageSize => e
         raise e if values.size <= 1
-        split_execute(name, values, server, operation_id, combiner)
+        split_execute(name, values, server, operation_id, combiner, session)
       end
     end
 
@@ -162,29 +168,29 @@ module Mongo
       @op_combiner ||= ordered? ? OrderedCombiner.new(requests) : UnorderedCombiner.new(requests)
     end
 
-    def split_execute(name, values, server, operation_id, combiner)
-      execute_operation(name, values.shift(values.size / 2), server, operation_id, combiner)
-      execute_operation(name, values, server, operation_id, combiner)
+    def split_execute(name, values, server, operation_id, combiner, session)
+      execute_operation(name, values.shift(values.size / 2), server, operation_id, combiner, session)
+      execute_operation(name, values, server, operation_id, combiner, session)
     end
 
-    def delete(documents, server, operation_id)
+    def delete(documents, server, operation_id, session)
       Operation::Write::Bulk::Delete.new(
-        base_spec(operation_id).merge(:deletes => documents)
+        base_spec(operation_id, session).merge(:deletes => documents)
       ).execute(server)
     end
 
     alias :delete_one :delete
     alias :delete_many :delete
 
-    def insert_one(documents, server, operation_id)
+    def insert_one(documents, server, operation_id, session)
       Operation::Write::Bulk::Insert.new(
-        base_spec(operation_id).merge(:documents => documents)
+        base_spec(operation_id, session).merge(:documents => documents)
       ).execute(server)
     end
 
-    def update(documents, server, operation_id)
+    def update(documents, server, operation_id, session)
       Operation::Write::Bulk::Update.new(
-        base_spec(operation_id).merge(:updates => documents)
+        base_spec(operation_id, session).merge(:updates => documents)
       ).execute(server)
     end
 

data/lib/mongo/bulk_write/combineable.rb

@@ -28,6 +28,10 @@ module Mongo
       # @return [ true, false ] has_collation Whether one or more operations has a collation defined.
       attr_reader :has_collation
 
+      # @return [ true, false ] has_array_filters Whether one or more operations specifies an array
+      # filters option.
+      attr_reader :has_array_filters
+
       # Create the ordered combiner.
       #
       # @api private
@@ -41,6 +45,7 @@ module Mongo
       def initialize(requests)
         @requests = requests
         @has_collation = false
+        @has_array_filters = false
       end
 
       private

data/lib/mongo/bulk_write/transformable.rb

@@ -104,6 +104,7 @@ module Mongo
           Operation::UPSERT => doc.fetch(:upsert, false)
         }.tap do |d|
           d[Operation::COLLATION] = doc[:collation] if doc[:collation]
+          d[Operation::ARRAY_FILTERS] = doc[:array_filters] if doc[:array_filters]
         end
       }
 
@@ -118,6 +119,7 @@ module Mongo
           Operation::UPSERT => doc.fetch(:upsert, false)
         }.tap do |d|
           d[Operation::COLLATION] = doc[:collation] if doc[:collation]
+          d[Operation::ARRAY_FILTERS] = doc[:array_filters] if doc[:array_filters]
         end
       }
 

data/lib/mongo/bulk_write/validatable.rb

@@ -43,6 +43,10 @@ module Mongo
         if document.respond_to?(:keys) && (document[:collation] || document[Operation::COLLATION])
           @has_collation = true
         end
+
+        if document.respond_to?(:keys) && document[:array_filters]
+          @has_array_filters = true
+        end
       end
 
       private

data/lib/mongo/client.rb

@@ -38,6 +38,7 @@ module Mongo
       :auth_source,
       :connect,
       :connect_timeout,
+      :compressors,
       :database,
       :heartbeat_frequency,
       :id_generator,
@@ -69,9 +70,15 @@ module Mongo
       :truncate_logs,
       :user,
       :wait_queue_timeout,
-      :write
+      :write,
+      :zlib_compression_level
     ].freeze
 
+    # The compression algorithms supported by the driver.
+    #
+    # @since 2.5.0
+    VALID_COMPRESSORS = [ Mongo::Protocol::Compressed::ZLIB ].freeze
+
     # @return [ Mongo::Cluster ] cluster The cluster of servers for the client.
     attr_reader :cluster
 
@@ -87,6 +94,8 @@ module Mongo
     # Delegate subscription to monitoring.
     def_delegators :@monitoring, :subscribe, :unsubscribe
 
+    def_delegators :@cluster, :logical_session_timeout
+
     # Determine if this client is equivalent to another object.
     #
     # @example Check client equality.
@@ -165,6 +174,8 @@ module Mongo
     #   seconds, in the connection pool for a connection to be checked in.
     # @option options [ Float ] :connect_timeout The timeout, in seconds, to
     #   attempt a connection.
+    # @option options [ Array<String> ] :compressors The compressor to use. Currently the driver
+    #   only supports zlib.
     # @option options [ Hash ] :read The read preference options. They consist of a
     #   mode specified as a symbol, an array of hashes known as tag_sets,
     #   and local_threshold.
@@ -229,14 +240,32 @@ module Mongo
     # @since 2.0.0
     def initialize(addresses_or_uri, options = Options::Redacted.new)
       @monitoring = Monitoring.new(options)
+      Session::SessionPool.create(self)
       if addresses_or_uri.is_a?(::String)
         create_from_uri(addresses_or_uri, validate_options!(options))
       else
         create_from_addresses(addresses_or_uri, validate_options!(options))
       end
+      ObjectSpace.define_finalizer(self, self.class.finalize(@session_pool))
       yield(self) if block_given?
     end
 
+    # Finalize the client for garbage collection. Ends all sessions in the session pool.
+    #
+    # @example Finalize the client.
+    #   Client.finalize(session_pool)
+    #
+    # @param [ Session::SessionPool ] session_pool The session pool.
+    #
+    # @return [ Proc ] The Finalizer.
+    #
+    # @since 2.5.0
+    def self.finalize(session_pool)
+      proc do
+        begin; session_pool.end_sessions; rescue; end
+      end
+    end
+
     # Get an inspection of the client as a string.
     #
     # @example Inspect the client.
@@ -249,17 +278,30 @@ module Mongo
       "#<Mongo::Client:0x#{object_id} cluster=#{cluster.addresses.join(', ')}>"
     end
 
+    # Get the server selector. It either uses the read preference defined in the client options
+    #   or defaults to a Primary server selector.
+    #
+    # @example Get the server selector.
+    #   client.server_selector
+    #
+    # @return [ Mongo::ServerSelector ] The server selector using the user-defined read preference
+    #  or a Primary server selector default.
+    #
+    # @since 2.5.0
+    def server_selector
+      @server_selector ||= ServerSelector.get(read_preference || ServerSelector::PRIMARY)
+    end
+
     # Get the read preference from the options passed to the client.
     #
     # @example Get the read preference.
     #   client.read_preference
     #
-    # @return [ Object ] The appropriate read preference or primary if none
-    #   was provided to the client.
+    # @return [ BSON::Document ] The user-defined read preference.
     #
     # @since 2.0.0
     def read_preference
-      @read_preference ||= ServerSelector.get(options[:read] || ServerSelector::PRIMARY)
+      @read_preference ||= options[:read]
     end
 
     # Use the database with the provided name. This will switch the current
@@ -294,6 +336,7 @@ module Mongo
         opts = validate_options!(new_options)
         client.options.update(opts)
         Database.create(client)
+        Session::SessionPool.create(client)
         # We can't use the same cluster if some options that would affect it
         # have changed.
         if cluster_modifying?(opts)
@@ -363,8 +406,58 @@ module Mongo
       use(Database::ADMIN).command(listDatabases: 1).first[Database::DATABASES]
     end
 
+    # Start a session.
+    #
+    # @example Start a session.
+    #   client.start_session
+    #
+    # @param [ Hash ] options The session options.
+    #
+    # @note A Session cannot be used by multiple threads at once; session objects are not
+    #   thread-safe.
+    #
+    # @return [ Session ] The session.
+    #
+    # @since 2.5.0
+    def start_session(options = {})
+      if !sessions_supported?
+        raise Error::InvalidSession.new(Session::SESSIONS_NOT_SUPPORTED)
+      end
+      Session.new(@session_pool.checkout, self, options)
+    end
+
     private
 
+    def get_session(options = {})
+      if options[:session]
+        options[:session].validate!(self)
+        options[:session]
+      elsif sessions_supported?
+        Session.new(@session_pool.checkout, self, options.merge(implicit: true))
+      end
+    end
+
+    def with_session(options = {})
+      if options[:session]
+        options[:session].validate!(self)
+        yield(options[:session])
+      elsif sessions_supported?
+        @session_pool.with_session do |server_session|
+          yield(Session.new(server_session, self, options))
+        end
+      else
+        yield
+      end
+    end
+
+    def sessions_supported?
+      if cluster.servers.empty?
+        ServerSelector.get(mode: :primary_preferred).select_server(cluster)
+      end
+      !!logical_session_timeout
+    rescue Error::NoServerAvailable
+    end
+
     def create_from_addresses(addresses, opts = Options::Redacted.new)
       @options = Database::DEFAULT_OPTIONS.merge(opts).freeze
       @cluster = Cluster.new(addresses, @monitoring, options)
@@ -373,8 +466,7 @@ module Mongo
 
     def create_from_uri(connection_string, opts = Options::Redacted.new)
       uri = URI.new(connection_string, opts)
-      @options = Database::DEFAULT_OPTIONS.merge(uri.client_options.merge(opts)).freeze
-      validate_options!(@options)
+      @options = validate_options!(Database::DEFAULT_OPTIONS.merge(uri.client_options.merge(opts))).freeze
       @cluster = Cluster.new(uri.servers, @monitoring, options)
       @database = Database.new(self, options[:database], options)
     end
@@ -398,18 +490,37 @@ module Mongo
 
     def validate_options!(opts = Options::Redacted.new)
       return Options::Redacted.new unless opts
-      Options::Redacted.new(opts.select do |o|
-        if VALID_OPTIONS.include?(o.to_sym)
-          validate_max_min_pool_size!(o.to_sym, opts) and true
+      opts.each.inject(Options::Redacted.new) do |_options, (k, v)|
+        key = k.to_sym
+        if VALID_OPTIONS.include?(key)
+          validate_max_min_pool_size!(key, opts)
+          if key == :compressors
+            compressors = valid_compressors(v)
+            _options[key] = compressors unless compressors.empty?
+          else
+            _options[key] = v
+          end
         else
-          log_warn("Unsupported client option '#{o}'. It will be ignored.")
+          log_warn("Unsupported client option '#{k}'. It will be ignored.")
+        end
+        _options
+      end
+    end
+
+    def valid_compressors(compressors)
+      compressors.select do |compressor|
+        if !VALID_COMPRESSORS.include?(compressor)
+          log_warn("Unsupported compressor '#{compressor}' in list '#{compressors}'. " +
+                       "This compressor will not be used.")
           false
+        else
+          true
         end
-      end)
+      end
     end
 
     def validate_max_min_pool_size!(option, opts)
-      if option == :min_pool_size
+      if option == :min_pool_size && opts[:min_pool_size]
         max = opts[:max_pool_size] || Server::ConnectionPool::Queue::MAX_SIZE
         raise Error::InvalidMinPoolSize.new(opts[:min_pool_size], max) unless opts[:min_pool_size] <= max
       end