mongo 2.18.2 → 2.19.0

data/lib/mongo/server/app_metadata.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# encoding: utf-8
 
 # Copyright (C) 2016-2020 MongoDB Inc.
 #
@@ -15,46 +14,33 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'mongo/server/app_metadata/environment'
+require 'mongo/server/app_metadata/platform'
+require 'mongo/server/app_metadata/truncator'
+
 module Mongo
   class Server
     # Application metadata that is sent to the server during a handshake,
     #   when a new connection is established.
     #
     # @api private
-    #
-    # @since 2.4.0
     class AppMetadata
       extend Forwardable
 
-      # The max application metadata document byte size.
-      #
-      # @since 2.4.0
-      MAX_DOCUMENT_SIZE = 512.freeze
-
       # The max application name byte size.
-      #
-      # @since 2.4.0
-      MAX_APP_NAME_SIZE = 128.freeze
+      MAX_APP_NAME_SIZE = 128
 
       # The driver name.
-      #
-      # @since 2.4.0
       DRIVER_NAME = 'mongo-ruby-driver'
 
       # Option keys that affect auth mechanism negotiation.
-      #
-      # @api private
-      AUTH_OPTION_KEYS = [:user, :auth_source, :auth_mech].freeze
+      AUTH_OPTION_KEYS = %i[ user auth_source auth_mech].freeze
 
       # Possible connection purposes.
-      #
-      # @api private
-      PURPOSES = %i(application monitor push_monitor).freeze
+      PURPOSES = %i[ application monitor push_monitor ].freeze
 
       # Instantiate the new AppMetadata object.
       #
-      # @api private
-      #
       # @example Instantiate the app metadata.
       #   Mongo::Server::AppMetadata.new(options)
       #
@@ -88,35 +74,33 @@ module Mongo
       def initialize(options = {})
         @app_name = options[:app_name].to_s if options[:app_name]
         @platform = options[:platform]
-        if @purpose = options[:purpose]
-          unless PURPOSES.include?(@purpose)
-            raise ArgumentError, "Invalid purpose: #{@purpose}"
-          end
-        end
+
+        @purpose = check_purpose!(options[:purpose])
+
         @compressors = options[:compressors] || []
         @wrapping_libraries = options[:wrapping_libraries]
         @server_api = options[:server_api]
 
-        if options[:user] && !options[:auth_mech]
-          auth_db = options[:auth_source] || 'admin'
-          @request_auth_mech = "#{auth_db}.#{options[:user]}"
-        end
+        return unless options[:user] && !options[:auth_mech]
+
+        auth_db = options[:auth_source] || 'admin'
+        @request_auth_mech = "#{auth_db}.#{options[:user]}"
       end
 
       # @return [ Symbol ] The purpose of the connection for which this
       #   app metadata is created.
-      #
-      # @api private
       attr_reader :purpose
 
+      # @return [ String ] The platform information given when the object was
+      #   instantiated.
+      attr_reader :platform
+
       # @return [ Hash | nil ] The requested server API version.
       #
       #   Thes hash can have the following items:
       #   - *:version* -- string
       #   - *:strict* -- boolean
       #   - *:deprecation_errors* -- boolean
-      #
-      # @api private
       attr_reader :server_api
 
       # @return [ Array<Hash> | nil ] Information about libraries wrapping
@@ -132,13 +116,26 @@ module Mongo
       # @return [BSON::Document] Valid document for connection's handshake.
       #
       # @raise [ Error::InvalidApplicationName ] When the metadata are invalid.
-      #
-      # @api private
       def validated_document
         validate!
         document
       end
 
+      # Get BSON::Document to be used as value for `client` key in
+      # handshake document.
+      #
+      # @return [BSON::Document] Document describing client for handshake.
+      def client_document
+        @client_document ||=
+          BSON::Document.new.tap do |doc|
+            doc[:application] = { name: @app_name } if @app_name
+            doc[:driver] = driver_doc
+            doc[:os] = os_doc
+            doc[:platform] = platform_string
+            env_doc.tap { |env| doc[:env] = env if env }
+          end
+      end
+
       private
 
       # Check whether it is possible to build a valid app metadata document
@@ -149,23 +146,10 @@ module Mongo
         if @app_name && @app_name.bytesize > MAX_APP_NAME_SIZE
           raise Error::InvalidApplicationName.new(@app_name, MAX_APP_NAME_SIZE)
         end
-        true
-      end
 
-      # Get BSON::Document to be used as value for `client` key in
-      # handshake document.
-      #
-      # @return [BSON::Document] Document describing client for handshake.
-      def full_client_document
-        BSON::Document.new.tap do |doc|
-          doc[:application] = { name: @app_name } if @app_name
-          doc[:driver] = driver_doc
-          doc[:os] = os_doc
-          doc[:platform] = platform
-        end
+        true
       end
 
-
       # Get the metadata as BSON::Document to be sent to
       # as part of the handshake. The document should
       # be appended to a suitable handshake command.
@@ -173,42 +157,22 @@ module Mongo
       # @return [BSON::Document] Document for connection's handshake.
       def document
         @document ||= begin
-          client_document = full_client_document
-          while client_document.to_bson.to_s.size > MAX_DOCUMENT_SIZE do
-            if client_document[:os][:name] || client_document[:os][:architecture]
-              client_document[:os].delete(:name)
-              client_document[:os].delete(:architecture)
-            elsif client_document[:platform]
-              client_document.delete(:platform)
-            else
-              client_document = nil
-            end
+          client = Truncator.new(client_document).document
+          BSON::Document.new(compression: @compressors, client: client).tap do |doc|
+            doc[:saslSupportedMechs] = @request_auth_mech if @request_auth_mech
+            doc.update(Utils.transform_server_api(@server_api)) if @server_api
           end
-          document = BSON::Document.new(
-            {
-              compression: @compressors,
-              client: client_document,
-            }
-          )
-          document[:saslSupportedMechs] = @request_auth_mech if @request_auth_mech
-          if @server_api
-            document.update(
-              Utils.transform_server_api(@server_api)
-            )
-          end
-          document
         end
       end
 
       def driver_doc
-        names = [DRIVER_NAME]
-        versions = [Mongo::VERSION]
-        if wrapping_libraries
-          wrapping_libraries.each do |library|
-            names << library[:name] || ''
-            versions << library[:version] || ''
-          end
+        names = [ DRIVER_NAME ]
+        versions = [ Mongo::VERSION ]
+        wrapping_libraries&.each do |library|
+          names << (library[:name] || '')
+          versions << (library[:version] || '')
         end
+
         {
           name: names.join('|'),
           version: versions.join('|'),
@@ -219,13 +183,25 @@ module Mongo
         {
           type: type,
           name: name,
-          architecture: architecture
+          architecture: architecture,
         }
       end
 
+      # Returns the environment doc describing the current FaaS environment.
+      #
+      # @return [ Hash | nil ] the environment doc (or nil if not in a FaaS
+      #   environment).
+      def env_doc
+        env = Environment.new
+        env.faas? ? env.to_h : nil
+      end
+
       def type
-        (RbConfig::CONFIG && RbConfig::CONFIG['host_os']) ?
-          RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase : 'unknown'
+        if RbConfig::CONFIG && RbConfig::CONFIG['host_os']
+          RbConfig::CONFIG['host_os'].split('_').first[/[a-z]+/i].downcase
+        else
+          'unknown'
+        end
       end
 
       def name
@@ -236,31 +212,22 @@ module Mongo
         RbConfig::CONFIG['target_cpu']
       end
 
-      def platform
-        if BSON::Environment.jruby?
-          ruby_versions = ["JRuby #{JRUBY_VERSION}", "like Ruby #{RUBY_VERSION}"]
-          platforms = [RUBY_PLATFORM, "JVM #{java.lang.System.get_property('java.version')}"]
-        else
-          ruby_versions = ["Ruby #{RUBY_VERSION}"]
-          platforms = [RUBY_PLATFORM]
-        end
-        platforms = [
-          @platform,
-          *ruby_versions,
-          *platforms,
-          RbConfig::CONFIG['build'],
-        ]
-        if @purpose
-          platforms << @purpose.to_s[0].upcase
-        end
-        platform = platforms.compact.join(', ')
-        platforms = [platform]
-        if wrapping_libraries
-          wrapping_libraries.each do |library|
-            platforms << library[:platform] || ''
-          end
-        end
-        platforms.join('|')
+      def platform_string
+        Platform.new(self).to_s
+      end
+
+      # Verifies that the given purpose is either nil, or is one of the
+      # allowed purposes.
+      #
+      # @param [ String | nil ] purpose The purpose to validate
+      #
+      # @return [ String | nil ] the {{purpose}} argument
+      #
+      # @raise [ ArgumentError ] if the purpose is invalid
+      def check_purpose!(purpose)
+        return purpose unless purpose && !PURPOSES.include?(purpose)
+
+        raise ArgumentError, "Invalid purpose: #{purpose}"
       end
     end
   end

data/lib/mongo/server/connection.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 # Copyright (C) 2014-2020 MongoDB Inc.
 #
@@ -87,6 +87,9 @@ module Mongo
       # @param [ Mongo::Server ] server The server the connection is for.
       # @param [ Hash ] options The connection options.
       #
+      # @option options :pipe [ IO ] The file descriptor for the read end of the
+      #   pipe to listen on during the select system call when reading from the
+      #   socket.
       # @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
@@ -144,6 +147,14 @@ module Mongo
         options[:connection_pool]
       end
 
+      # Whether the connection was connected and was not interrupted, closed,
+      # or had an error raised.
+      #
+      # @return [ true | false ] if the connection was connected.
+      def connected?
+        !closed? && !error? && !interrupted? && !!@socket
+      end
+
       # Whether the connection was closed.
       #
       # Closed connections should no longer be used. Instead obtain a new
@@ -156,6 +167,21 @@ module Mongo
         !!@closed
       end
 
+      # Whether the connection was interrupted.
+      #
+      # Interrupted connections were already removed from the pool and should
+      # not be checked back into the pool.
+      #
+      # @return [ true | false ] Whether connection was interrupted.
+      def interrupted?
+        !!@interrupted
+      end
+
+      # Mark the connection as interrupted.
+      def interrupted!
+        @interrupted = true
+      end
+
       # @api private
       def error?
         !!@error
@@ -201,18 +227,11 @@ module Mongo
       #
       # @since 2.0.0
       def connect!
-        if error?
-          raise Error::ConnectionPerished, "Connection #{generation}:#{id} for #{address.seed} is perished. Reconnecting closed or errored connections is no longer supported"
-        end
-
-        if closed?
-          raise Error::ConnectionPerished, "Connection #{generation}:#{id} for #{address.seed} is closed. Reconnecting closed or errored connections is no longer supported"
-        end
+        raise_if_closed!
 
         unless @socket
-          # When @socket is assigned, the socket should have handshaken and
-          # authenticated and be usable.
-          @socket, @description, @compressor = do_connect
+          @socket = create_socket
+          @description, @compressor = do_connect
 
           if server.load_balancer?
             if Lint.enabled?
@@ -232,27 +251,36 @@ module Mongo
         true
       end
 
-      # Separate method to permit easier mocking in the test suite.
+      # Creates the socket. The method is separate from do_connect, so that
+      # pending connections can be closed if they are interrupted during hello.
       #
-      # @return [ Array<Socket, Server::Description> ] Connected socket and
-      #   a server description instance from the hello response of the
-      #   returned socket.
-      private def do_connect
-        socket = add_server_diagnostics do
+      #
+      # @return [ Socket ] The created socket.
+      private def create_socket
+        add_server_diagnostics do
           address.socket(socket_timeout, ssl_options.merge(
-            connection_address: address, connection_generation: generation))
+            connection_address: address, connection_generation: generation, pipe: options[:pipe]))
         end
+      end
 
+      # Separate method to permit easier mocking in the test suite.
+      #
+      # @return [ Array<Server::Description, String | Symbol> ] A server
+      #   description instance from the hello response of the returned socket
+      #   and the compressor to use.
+      private def do_connect
+        raise_if_closed!
         begin
           pending_connection = PendingConnection.new(
             socket, @server, monitoring, options.merge(id: id))
           pending_connection.handshake_and_authenticate!
         rescue Exception
-          socket.close
+          socket&.close
+          @socket = nil
           raise
         end
 
-        [socket, pending_connection.description, pending_connection.compressor]
+        [pending_connection.description, pending_connection.compressor]
       end
 
       # Disconnect the connection.
@@ -268,6 +296,8 @@ module Mongo
       #
       # @option options [ Symbol ] :reason The reason why the connection is
       #   being closed.
+      # @option options [ true | false ] :interrupted Whether or not the
+      #   connection was interrupted.
       #
       # @return [ true ] If the disconnect succeeded.
       #
@@ -282,6 +312,7 @@ module Mongo
           @socket = nil
         end
         @closed = true
+        interrupted! if options && options[:interrupted]
 
         # To satisfy CMAP spec tests, publish close events even if the
         # socket was never connected (and thus the ready event was never
@@ -376,6 +407,16 @@ module Mongo
           raise
         end
       end
+
+      def raise_if_closed!
+        if error?
+          raise Error::ConnectionPerished, "Connection #{generation}:#{id} for #{address.seed} is perished. Reconnecting closed or errored connections is no longer supported"
+        end
+
+        if closed?
+          raise Error::ConnectionPerished, "Connection #{generation}:#{id} for #{address.seed} is closed. Reconnecting closed or errored connections is no longer supported"
+        end
+      end
     end
   end
 end

data/lib/mongo/server/connection_base.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 # Copyright (C) 2019-2020 MongoDB Inc.
 #

data/lib/mongo/server/connection_common.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 # Copyright (C) 2020 MongoDB Inc.
 #

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 # Copyright (C) 2021 MongoDB Inc.
 #
@@ -24,31 +24,52 @@ module Mongo
 
         def initialize(server:)
           @map = Hash.new { |hash, key| hash[key] = 1 }
+          @pipe_fds = Hash.new { |hash, key| hash[key] = { 1 => IO.pipe } }
           @server = server
           @lock = Mutex.new
+          @scheduled_for_close = []
         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
+          validate_service_id!(service_id)
+
           @lock.synchronize do
             @map[service_id]
           end
         end
 
+        def generation_unlocked(service_id: nil)
+          validate_service_id!(service_id)
+
+          @map[service_id]
+        end
+
+        def pipe_fds(service_id: nil)
+          @pipe_fds[service_id][@map[service_id]]
+        end
+
+        def remove_pipe_fds(generation, service_id: nil)
+          validate_service_id!(service_id)
+
+          r, w = @pipe_fds[service_id].delete(generation)
+          w.close
+          # Schedule the read end of the pipe to be closed. We cannot close it
+          # immediately since we need to wait for any Kernel#select calls to
+          # notice that part of the pipe is closed, and check the socket. This
+          # all happens when attempting to read from the socket and waiting for
+          # it to become ready again.
+          @scheduled_for_close << r
+        end
+
         def bump(service_id: nil)
           @lock.synchronize do
+            close_all_scheduled
             if service_id
-              @map[service_id] += 1
+              gen = @map[service_id] += 1
+              @pipe_fds[service_id] ||= {}
+              @pipe_fds[service_id][gen] = IO.pipe
             else
               # When service id is not supplied, one of two things may be
               # happening;
@@ -60,11 +81,34 @@ module Mongo
               #
               # Incrementing everything in the map accomplishes both tasks.
               @map.each do |k, v|
-                @map[k] += 1
+                gen = @map[k] += 1
+                @pipe_fds[service_id] ||= {}
+                @pipe_fds[service_id][gen] = IO.pipe
               end
             end
           end
         end
+
+        private
+
+        def validate_service_id!(service_id)
+          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
+        end
+
+        # Close all fds scheduled for closing.
+        def close_all_scheduled
+          while pipe = @scheduled_for_close.pop
+            pipe.close
+          end
+        end
       end
     end
   end

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# encoding: utf-8
+# rubocop:todo all
 
 # Copyright (C) 2019-2020 MongoDB Inc.
 #
@@ -17,43 +17,45 @@
 
 module Mongo
   class Server
-    # A manager that maintains the invariant that the
-    # size of a connection pool is at least minPoolSize.
-    #
-    # @api private
-    class Populator
-      include BackgroundThread
-
-      # @param [ Server::ConnectionPool ] pool The connection pool.
-      # @param [ Hash ] options The options.
+    class ConnectionPool
+      # A manager that maintains the invariant that the
+      # size of a connection pool is at least minPoolSize.
       #
-      # @option options [ Logger ] :logger A custom logger to use.
-      def initialize(pool, options = {})
-        @pool = pool
-        @thread = nil
-        @options = options
-      end
+      # @api private
+      class Populator
+        include BackgroundThread
+
+        # @param [ Server::ConnectionPool ] pool The connection pool.
+        # @param [ Hash ] options The options.
+        #
+        # @option options [ Logger ] :logger A custom logger to use.
+        def initialize(pool, options = {})
+          @pool = pool
+          @thread = nil
+          @options = options
+        end
 
-      attr_reader :options
+        attr_reader :options
 
-      def pre_stop
-        @pool.populate_semaphore.signal
-      end
+        def pre_stop
+          @pool.populate_semaphore.signal
+        end
 
-      private
+        private
 
-      def do_work
-        throw(:done) if @pool.closed?
+        def do_work
+          throw(:done) if @pool.closed?
 
-        begin
-          unless @pool.populate
-            @pool.populate_semaphore.wait
+          begin
+            unless @pool.populate
+              @pool.populate_semaphore.wait
+            end
+          rescue Error::AuthError, Error => e
+            # Errors encountered when trying to add connections to
+            # pool; try again later
+            log_warn("Populator failed to connect a connection for #{@pool.address}: #{e.class}: #{e}.")
+            @pool.populate_semaphore.wait(5)
           end
-        rescue Error::AuthError, Error => e
-          # Errors encountered when trying to add connections to
-          # pool; try again later
-          log_warn("Populator failed to connect a connection for #{@pool.address}: #{e.class}: #{e}.")
-          @pool.populate_semaphore.wait(5)
         end
       end
     end