mongo 2.18.2 → 2.19.3

data/lib/mongo/server/app_metadata/truncator.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2016-2023 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 AppMetadata
+      # Implements the metadata truncation logic described in the handshake
+      # spec.
+      #
+      # @api private
+      class Truncator
+        # @return [ BSON::Document ] the document being truncated.
+        attr_reader :document
+
+        # The max application metadata document byte size.
+        MAX_DOCUMENT_SIZE = 512
+
+        # Creates a new Truncator instance and tries enforcing the maximum
+        # document size on the given document.
+        #
+        # @param [ BSON::Document] document The document to (potentially)
+        #   truncate.
+        #
+        # @note The document is modified in-place; if you wish to keep the
+        #   original unchanged, you must deep-clone it prior to sending it to
+        #   a truncator.
+        def initialize(document)
+          @document = document
+          try_truncate!
+        end
+
+        # The current size of the document, in bytes, as a serialized BSON
+        # document.
+        #
+        # @return [ Integer ] the size of the document
+        def size
+          @document.to_bson.to_s.length
+        end
+
+        # Whether the document fits within the required maximum document size.
+        #
+        # @return [ true | false ] if the document is okay or not.
+        def ok?
+          size <= MAX_DOCUMENT_SIZE
+        end
+
+        private
+
+        # How many extra bytes must be trimmed before the document may be
+        # considered #ok?.
+        #
+        # @return [ Integer ] how many bytes larger the document is than the
+        #   maximum document size.
+        def excess
+          size - MAX_DOCUMENT_SIZE
+        end
+
+        # Attempt to truncate the document using the documented metadata
+        # priorities (see the handshake specification).
+        def try_truncate!
+          %i[ env_fields os_fields env platform ].each do |target|
+            break if ok?
+
+            send(:"try_truncate_#{target}!")
+          end
+        end
+
+        # Attempt to truncate or remove the {{:platform}} key from the
+        # document.
+        def try_truncate_platform!
+          @document.delete(:platform) unless try_truncate_string(@document[:platform])
+        end
+
+        # Attempt to truncate the keys in the {{:env}} subdocument.
+        def try_truncate_env_fields!
+          try_truncate_hash(@document[:env], reserved: %w[ name ])
+        end
+
+        # Attempt to truncate the keys in the {{:os}} subdocument.
+        def try_truncate_os_fields!
+          try_truncate_hash(@document[:os], reserved: %w[ type ])
+        end
+
+        # Remove the {{:env}} key from the document.
+        def try_truncate_env!
+          @document.delete(:env)
+        end
+
+        # A helper method for truncating a string (in-place) by whatever
+        # {{#excess}} is required.
+        #
+        # @param [ String ] string the string value to truncate.
+        #
+        # @note the parameter is modified in-place.
+        def try_truncate_string(string)
+          length = string&.length || 0
+
+          return false if excess > length
+
+          string[(length - excess)..-1] = ''
+        end
+
+        # A helper method for removing the keys of a Hash (in-place) until
+        # the document is the necessary size. The keys are considered in order
+        # (using the Hash's native key ordering), and each will be removed from
+        # the hash in turn, until the document is the necessary size.
+        #
+        # Any keys in the {{reserved}} list will be ignored.
+        #
+        # @param [ Hash | nil ] hash the Hash instance to consider.
+        # @param [ Array ] reserved the list of keys to ignore in the hash.
+        #
+        # @note the hash parameter is modified in-place.
+        def try_truncate_hash(hash, reserved: [])
+          return false unless hash
+
+          keys = hash.keys - reserved
+          keys.each do |key|
+            hash.delete(key)
+
+            return true if ok?
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

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.
 #