mongo 2.15.1 → 2.16.0.alpha1

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

@@ -32,13 +32,16 @@ module Mongo
         include BypassDocumentValidation
         include ExecutableNoValidate
         include PolymorphicResult
+        include Validatable
 
         private
 
         def selector(connection)
-          { update: coll_name,
-            updates: send(IDENTIFIER),
-            ordered: ordered? }
+          {
+            update: coll_name,
+            updates: validate_updates(connection, send(IDENTIFIER)),
+            ordered: ordered?,
+          }
         end
 
         def message(connection)

data/lib/mongo/operation/update/legacy.rb

@@ -30,24 +30,32 @@ module Mongo
         include Specifiable
         include Executable
         include PolymorphicResult
+        include Validatable
 
         private
 
-        def selector
-          send(IDENTIFIER).first
+        def selector(connection)
+          # This returns the first update.
+          # The driver only puts one update into the list normally, so this
+          # doesn't discard operations.
+          send(IDENTIFIER).first.tap do |selector|
+            validate_find_options(connection, selector)
+          end
         end
 
         def message(connection)
+          selector = selector(connection)
+
           flags = []
           flags << :multi_update if selector[Operation::MULTI]
           flags << :upsert if selector[Operation::UPSERT]
 
           Protocol::Update.new(
-              db_name,
-              coll_name,
-              selector[Operation::Q],
-              selector[Operation::U],
-              flags.empty? ? {} : { flags: flags }
+            db_name,
+            coll_name,
+            selector[Operation::Q],
+            selector[Operation::U],
+            flags.empty? ? {} : { flags: flags },
           )
         end
 
@@ -55,10 +63,10 @@ module Mongo
           wc = write_concern ||  WriteConcern.get(WriteConcern::DEFAULT)
           if gle_message = wc.get_last_error
             Protocol::Query.new(
-                db_name,
-                Database::COMMAND,
-                gle_message,
-                options.merge(limit: -1)
+              db_name,
+              Database::COMMAND,
+              gle_message,
+              options.merge(limit: -1),
             )
           end
         end

data/lib/mongo/operation/update/op_msg.rb

@@ -29,17 +29,20 @@ module Mongo
         include ExecutableNoValidate
         include ExecutableTransactionLabel
         include PolymorphicResult
+        include Validatable
 
         private
 
         def selector(connection)
-          { update: coll_name,
-            Protocol::Msg::DATABASE_IDENTIFIER => db_name,
-            ordered: ordered? }
+          {
+            update: coll_name,
+            ordered: ordered?,
+          }
         end
 
         def message(connection)
-          section = Protocol::Msg::Section1.new(IDENTIFIER, send(IDENTIFIER))
+          updates = validate_updates(connection, send(IDENTIFIER))
+          section = Protocol::Msg::Section1.new(IDENTIFIER, updates)
           Protocol::Msg.new(flags, {}, command(connection), section)
         end
       end

data/lib/mongo/operation/write_command/command.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2021 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
+  module Operation
+    class WriteCommand
+
+      # A MongoDB write command operation sent as a command message.
+      #
+      # @api private
+      class Command
+        include Specifiable
+        include Executable
+        include Limited
+        include ReadPreferenceSupported
+        include Validatable
+
+        private
+
+        def selector(connection)
+          super.tap do |selector|
+            if selector.key?(:findAndModify)
+              validate_find_options(connection, selector)
+            end
+            if wc = spec[:write_concern]
+              selector[:writeConcern] = wc.options
+            end
+          end
+        end
+
+        def message(connection)
+          Protocol::Query.new(db_name, Database::COMMAND, command(connection), options(connection))
+        end
+      end
+    end
+  end
+end

data/lib/mongo/operation/write_command/op_msg.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2021 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
+  module Operation
+    class WriteCommand
+
+      # A MongoDB write command operation sent as an op message.
+      #
+      # @api private
+      class OpMsg < OpMsgBase
+        include Validatable
+
+        private
+
+        def selector(connection)
+          super.tap do |selector|
+            if selector.key?(:findAndModify)
+              validate_find_options(connection, selector)
+            end
+            if wc = spec[:write_concern]
+              selector[:writeConcern] = wc.options
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/operation/write_command.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2021 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.
+
+require 'mongo/operation/write_command/command'
+require 'mongo/operation/write_command/op_msg'
+
+module Mongo
+  module Operation
+
+    # A MongoDB general command operation.
+    #
+    # @api private
+    class WriteCommand
+      include Specifiable
+      include OpMsgOrCommand
+    end
+  end
+end

data/lib/mongo/operation.rb

@@ -20,12 +20,14 @@ require 'mongo/operation/shared/causal_consistency_supported'
 require 'mongo/operation/shared/write'
 require 'mongo/operation/shared/idable'
 require 'mongo/operation/shared/specifiable'
+require 'mongo/operation/shared/validatable'
 require 'mongo/operation/shared/object_id_generator'
 require 'mongo/operation/shared/op_msg_or_command'
 require 'mongo/operation/shared/op_msg_or_find_command'
 
 require 'mongo/operation/op_msg_base'
 require 'mongo/operation/command'
+require 'mongo/operation/write_command'
 require 'mongo/operation/aggregate'
 require 'mongo/operation/result'
 require 'mongo/operation/collections_info'
@@ -54,6 +56,14 @@ require 'mongo/operation/drop_index'
 
 module Mongo
 
+  # This module encapsulates all of the operation classes defined by the driver.
+  #
+  # The operation classes take Ruby options as constructor parameters.
+  # For example, :read contains read preference and :read_concern contains read
+  # concern, whereas server commands use readConcern field for the read
+  # concern and read preference is passed as $readPreference or secondaryOk
+  # wire protocol flag bit.
+  #
   # @api private
   module Operation
 

data/lib/mongo/protocol/query.rb

@@ -64,13 +64,21 @@ module Mongo
       def initialize(database, collection, selector, options = {})
         @database = database
         @namespace = "#{database}.#{collection}"
+        if selector.nil?
+          raise ArgumentError, 'Selector cannot be nil'
+        end
         @selector = selector
         @options = options
         @project = options[:project]
         @limit = determine_limit
         @skip = options[:skip]  || 0
         @flags = options[:flags] || []
-        @upconverter = Upconverter.new(collection, selector, options, flags)
+        @upconverter = Upconverter.new(
+          collection,
+          BSON::Document.new(selector),
+          BSON::Document.new(options),
+          flags,
+        )
         super
       end
 
@@ -224,7 +232,7 @@ module Mongo
         }.freeze
 
         SPECIAL_FIELD_MAPPINGS = {
-          :$readPreference => 'readPreference',
+          :$readPreference => '$readPreference',
           :$orderby => 'sort',
           :$hint => 'hint',
           :$comment => 'comment',
@@ -249,16 +257,6 @@ module Mongo
           :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
 
@@ -283,6 +281,15 @@ module Mongo
         #
         # @since 2.1.0
         def initialize(collection, filter, options, flags)
+          # Although the docstring claims both hashes and BSON::Documents
+          # are acceptable, this class expects the filter and options to
+          # contain symbol keys which isn't what the operation layer produces.
+          unless BSON::Document === filter
+            raise ArgumentError, 'Filter must provide indifferent access'
+          end
+          unless BSON::Document === options
+            raise ArgumentError, 'Options must provide indifferent access'
+          end
           @collection = collection
           @filter = filter
           @options = options
@@ -311,7 +318,7 @@ module Mongo
         #
         # @since 2.1.0
         def command_name
-          ((filter[:$query] || !command?) ? FIND : filter.keys.first).to_s
+          ((filter[:$query] || !command?) ? :find : filter.keys.first).to_s
         end
 
         private
@@ -333,15 +340,25 @@ module Mongo
         end
 
         def find_command
-          document = BSON::Document.new
-          document.store(FIND, collection)
-          document.store(FILTER, query_filter)
+          document = BSON::Document.new(
+            find: collection,
+            filter: query_filter,
+          )
           OPTION_MAPPINGS.each do |legacy, option|
             document.store(option, options[legacy]) unless options[legacy].nil?
           end
-          Mongo::Lint.validate_camel_case_read_preference(filter['readPreference'])
+          if Lint.enabled?
+            filter.each do |k, v|
+              unless String === k
+                raise Error::LintError, "All keys in filter must be strings: #{filter.inspect}"
+              end
+            end
+          end
+          Lint.validate_camel_case_read_preference(filter['readPreference'])
           SPECIAL_FIELD_MAPPINGS.each do |special, normal|
-            document.store(normal, filter[special]) unless filter[special].nil?
+            unless (v = filter[special]).nil?
+              document.store(normal, v)
+            end
           end
           FLAG_MAPPINGS.each do |legacy, flag|
             document.store(flag, true) if flags.include?(legacy)

data/lib/mongo/server/connection.rb

@@ -86,8 +86,12 @@ module Mongo
       # @param [ Mongo::Server ] server The server the connection is for.
       # @param [ Hash ] options The connection options.
       #
-      # @option options [ Integer ] :generation Connection pool's generation
-      #   for this connection.
+      # @option options [ Integer ] :generation The generation of this
+      #   connection. The generation should only be specified in this option
+      #   when not in load-balancing mode, and it should be the generation
+      #   of the connection pool when the connection is created. In
+      #   load-balancing mode, the generation is set on the connection
+      #   after the handshake completes.
       # @option options [ Hash ] :server_api The requested server API version.
       #   This hash can have the following items:
       #   - *:version* -- string
@@ -96,6 +100,10 @@ module Mongo
       #
       # @since 2.0.0
       def initialize(server, options = {})
+        if server.load_balancer? && options[:generation]
+          raise ArgumentError, "Generation cannot be set when server is a load balancer"
+        end
+
         @id = server.next_connection_id
         @monitoring = server.monitoring
         @options = options.freeze
@@ -173,6 +181,15 @@ module Mongo
           # authenticated and be usable.
           @socket, @description, @compressor = do_connect
 
+          if server.load_balancer?
+            if Lint.enabled?
+              unless service_id
+                raise Error::InternalDriverError, "The connection is to a load balancer and it must have service_id set here, but does not"
+              end
+            end
+            @generation = connection_pool.generation_manager.generation(service_id: service_id)
+          end
+
           publish_cmap_event(
             Monitoring::Event::Cmap::ConnectionReady.new(address, id)
           )
@@ -314,7 +331,12 @@ module Mongo
           yield
         rescue Error::SocketError => e
           @error = e
-          @server.unknown!(generation: e.generation, stop_push_monitor: true)
+          @server.unknown!(
+            generation: e.generation,
+            # or description.service_id?
+            service_id: e.service_id,
+            stop_push_monitor: true,
+          )
           raise
         rescue Error::SocketTimeoutError => e
           @error = e

data/lib/mongo/server/connection_base.rb

@@ -88,12 +88,20 @@ module Mongo
         :max_message_size,
         :mongos?
 
+      # @return [ nil | Object ] The service id, if any.
+      def service_id
+        description&.service_id
+      end
+
       # Connection pool generation from which this connection was created.
       # May be nil.
       #
       # @return [ Integer | nil ] Connection pool generation.
       def generation
-        options[:generation]
+        # If the connection is to a load balancer, @generation is set
+        # after handshake completes. If the connection is to another server
+        # type, generation is specified during connection creation.
+        @generation || options[:generation]
       end
 
       def app_metadata
@@ -167,6 +175,7 @@ module Mongo
             socket_object_id: socket.object_id, connection_id: id,
             connection_generation: generation,
             server_connection_id: description.server_connection_id,
+            service_id: description.service_id,
           )
           start = Utils.monotonic_time
           result = nil
@@ -184,6 +193,7 @@ module Mongo
             command_failed(nil, address, operation_id, message.payload,
               e.message, total_duration,
               started_event: started_event,
+              service_id: description.service_id,
             )
             raise
           else
@@ -191,6 +201,7 @@ module Mongo
             command_completed(result, address, operation_id, message.payload,
               total_duration,
               started_event: started_event,
+              service_id: description.service_id,
             )
           end
           if result && context.decrypt?

data/lib/mongo/server/connection_common.rb

@@ -57,13 +57,15 @@ module Mongo
       # @param [ Server::AppMetadata ] app_metadata Application metadata
       # @param [ BSON::Document ] speculative_auth_doc The speculative
       #   authentication document, if any.
+      # @param [ true | false ] load_balancer Whether the connection is to
+      #   a load balancer.
       # @param server_api [ Hash | nil ] server_api Server API version.
       #
       # @return [BSON::Document] Document that should be sent to a server
       #     for handshake purposes.
       #
       # @api private
-      def handshake_document(app_metadata, speculative_auth_doc: nil, server_api: nil)
+      def handshake_document(app_metadata, speculative_auth_doc: nil, load_balancer: false, server_api: nil)
         serv_api = app_metadata.server_api || server_api
         document = if serv_api
                      HELLO_DOC.merge(Utils.transform_server_api(serv_api))
@@ -74,6 +76,33 @@ module Mongo
           if speculative_auth_doc
             doc.update(speculativeAuthenticate: speculative_auth_doc)
           end
+          if load_balancer
+            doc.update(loadBalanced: true)
+          end
+        end
+      end
+
+      # Build a command that should be used for connection handshake.
+      #
+      # @param [ BSON::Document ] handshake_document Document that should be
+      #   sent to a server for handshake purpose.
+      #
+      # @return [ Protocol::Message ] Command that should be sent to a server
+      #   for handshake purposes.
+      #
+      # @api private
+      def handshake_command(handshake_document)
+        if handshake_document['apiVersion']
+          Protocol::Msg.new(
+            [], {}, handshake_document.merge({'$db' => Database::ADMIN})
+          )
+        else
+          Protocol::Query.new(
+            Database::ADMIN,
+            Database::COMMAND,
+            handshake_document,
+            :limit => -1
+          )
         end
       end
 
@@ -125,10 +154,18 @@ module Mongo
         if respond_to?(:id)
           note << ", connection #{generation}:#{id}"
         end
+        # Non-monitoring connections have service id.
+        # Monitoring connections do not.
+        if respond_to?(:service_id) && service_id
+          note << ", service id #{service_id}"
+        end
         e.add_note(note)
         if respond_to?(:generation)
           # Non-monitoring connections
           e.generation = generation
+          if respond_to?(:description)
+            e.service_id = service_id
+          end
         end
         raise e
       end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2021 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
+  class Server
+    class ConnectionPool
+
+      # @api private
+      class GenerationManager
+
+        def initialize(server:)
+          @map = Hash.new { |hash, key| hash[key] = 1 }
+          @server = server
+          @lock = Mutex.new
+        end
+
+        attr_reader :server
+
+        def generation(service_id: nil)
+          if service_id
+            unless server.load_balancer?
+              raise ArgumentError, "Generation scoping to services is only available in load-balanced mode, but the server at #{server.address} is not a load balancer"
+            end
+          else
+            if server.load_balancer?
+              raise ArgumentError, "The server at #{server.address} is a load balancer and therefore does not have a single global generation"
+            end
+          end
+          @lock.synchronize do
+            @map[service_id]
+          end
+        end
+
+        def bump(service_id: nil)
+          @lock.synchronize do
+            if service_id
+              @map[service_id] += 1
+            else
+              # When service id is not supplied, one of two things may be
+              # happening;
+              #
+              # 1. The pool is not to a load balancer, in which case we only
+              #    need to increment the generation for the nil service_id.
+              # 2. The pool is to a load balancer, in which case we need to
+              #    increment the generation for each service.
+              #
+              # Incrementing everything in the map accomplishes both tasks.
+              @map.each do |k, v|
+                @map[k] += 1
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end