mongo 2.20.2 → 2.21.0

data/lib/mongo/socket/ssl.rb

@@ -23,7 +23,6 @@ module Mongo
     # @since 2.0.0
     class SSL < Socket
       include OpenSSL
-      include Loggable
 
       # Initializes a new TLS socket.
       #
@@ -143,26 +142,37 @@ module Mongo
       #
       # @since 2.0.0
       def connect!
-        Timeout.timeout(options[:connect_timeout], Error::SocketTimeoutError, "The socket took over #{options[:connect_timeout]} seconds to connect") do
-          map_exceptions do
-            @tcp_socket.connect(::Socket.pack_sockaddr_in(port, host))
-          end
-          @socket = OpenSSL::SSL::SSLSocket.new(@tcp_socket, context)
-          begin
-            @socket.hostname = @host_name
-            @socket.sync_close = true
-            map_exceptions do
-              @socket.connect
+        sockaddr = ::Socket.pack_sockaddr_in(port, host)
+        connect_timeout = options[:connect_timeout]
+        map_exceptions do
+          if connect_timeout && connect_timeout != 0
+            deadline = Utils.monotonic_time + connect_timeout
+            if BSON::Environment.jruby?
+              # We encounter some strange problems with connect_nonblock for
+              # ssl sockets on JRuby. Therefore, we use the old +Timeout.timeout+
+              # solution, even though it is known to be not very reliable.
+              raise Error::SocketTimeoutError, 'connect_timeout expired' if connect_timeout < 0
+
+              Timeout.timeout(connect_timeout, Error::SocketTimeoutError, "The socket took over #{options[:connect_timeout]} seconds to connect") do
+                connect_without_timeout(sockaddr)
+              end
+            else
+              connect_with_timeout(sockaddr, connect_timeout)
             end
+            remaining_timeout = deadline - Utils.monotonic_time
+            verify_certificate!(@socket)
+            verify_ocsp_endpoint!(@socket, remaining_timeout)
+          else
+            connect_without_timeout(sockaddr)
             verify_certificate!(@socket)
             verify_ocsp_endpoint!(@socket)
-          rescue
-            @socket.close
-            @socket = nil
-            raise
           end
-          self
         end
+        self
+      rescue
+        @socket&.close
+        @socket = nil
+        raise
       end
       private :connect!
 
@@ -183,6 +193,87 @@ module Mongo
 
       private
 
+      # Connects the socket without a timeout provided.
+      #
+      # @param [ String ] sockaddr Address to connect to.
+      def connect_without_timeout(sockaddr)
+        @tcp_socket.connect(sockaddr)
+        @socket = OpenSSL::SSL::SSLSocket.new(@tcp_socket, context)
+        @socket.hostname = @host_name
+        @socket.sync_close = true
+        @socket.connect
+      end
+
+      # Connects the socket with the connect timeout. The timeout applies to
+      # connecting both ssl socket and the underlying tcp socket.
+      #
+      # @param [ String ] sockaddr Address to connect to.
+      def connect_with_timeout(sockaddr, connect_timeout)
+        if connect_timeout <= 0
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+
+        deadline = Utils.monotonic_time + connect_timeout
+        connect_tcp_socket_with_timeout(sockaddr, deadline, connect_timeout)
+        connnect_ssl_socket_with_timeout(deadline, connect_timeout)
+      end
+
+      def connect_tcp_socket_with_timeout(sockaddr, deadline, connect_timeout)
+        if deadline <= Utils.monotonic_time
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+        begin
+          @tcp_socket.connect_nonblock(sockaddr)
+        rescue IO::WaitWritable
+          with_select_timeout(deadline, connect_timeout) do |select_timeout|
+            IO.select(nil, [@tcp_socket], nil, select_timeout)
+          end
+          retry
+        rescue Errno::EISCONN
+          # Socket is connected, nothing to do.
+        end
+      end
+
+      def connnect_ssl_socket_with_timeout(deadline, connect_timeout)
+        if deadline <= Utils.monotonic_time
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+        @socket = OpenSSL::SSL::SSLSocket.new(@tcp_socket, context)
+        @socket.hostname = @host_name
+        @socket.sync_close = true
+
+        # We still have time, connecting ssl socket.
+        begin
+          @socket.connect_nonblock
+        rescue IO::WaitReadable, OpenSSL::SSL::SSLErrorWaitReadable
+          with_select_timeout(deadline, connect_timeout) do |select_timeout|
+            IO.select([@socket], nil, nil, select_timeout)
+          end
+          retry
+        rescue IO::WaitWritable, OpenSSL::SSL::SSLErrorWaitWritable
+          with_select_timeout(deadline, connect_timeout) do |select_timeout|
+            IO.select(nil, [@socket], nil, select_timeout)
+          end
+          retry
+        rescue Errno::EISCONN
+          # Socket is connected, nothing to do
+        end
+      end
+
+      # Raises +Error::SocketTimeoutError+ exception if deadline reached or the
+      # block returns nil. The block should call +IO.select+ with the
+      # +connect_timeout+ value. It returns nil if the +connect_timeout+ expires.
+      def with_select_timeout(deadline, connect_timeout, &block)
+        select_timeout = deadline - Utils.monotonic_time
+        if select_timeout <= 0
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+        rv = block.call(select_timeout)
+        if rv.nil?
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+      end
+
       def verify_certificate?
         # If ssl_verify_certificate is not present, disable only if
         # ssl_verify is explicitly set to false.
@@ -363,19 +454,16 @@ module Mongo
         end
       end
 
-      def verify_ocsp_endpoint!(socket)
-        return unless verify_ocsp_endpoint?
-
-        cert = socket.peer_cert
-        ca_cert = find_issuer(cert, socket.peer_cert_chain)
-
-        unless ca_cert
-          log_warn("TLS certificate of '#{host_name}' could not be definitively verified via OCSP: issuer certificate not found in the chain.")
+      def verify_ocsp_endpoint!(socket, timeout = nil)
+        unless verify_ocsp_endpoint?
           return
         end
 
+        cert = socket.peer_cert
+        ca_cert = socket.peer_cert_chain.last
+
         verifier = OcspVerifier.new(@host_name, cert, ca_cert, context.cert_store,
-          **Utils.shallow_symbolize_keys(options))
+          **Utils.shallow_symbolize_keys(options).merge(timeout: timeout))
         verifier.verify_with_cache
       end
 
@@ -415,11 +503,6 @@ module Mongo
           end
         end
       end
-
-      # Find the issuer certificate in the chain.
-      def find_issuer(cert, cert_chain)
-        cert_chain.find { |c| c.subject == cert.issuer }
-      end
     end
   end
 end

data/lib/mongo/socket/tcp.rb

@@ -79,16 +79,50 @@ module Mongo
       # @return [ TCP ] The connected socket instance.
       #
       # @since 2.0.0
+      # @api private
       def connect!
-        Timeout.timeout(options[:connect_timeout], Error::SocketTimeoutError, "The socket took over #{options[:connect_timeout]} seconds to connect") do
-          socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
-          map_exceptions do
-            socket.connect(::Socket.pack_sockaddr_in(port, host))
+        socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
+        sockaddr = ::Socket.pack_sockaddr_in(port, host)
+        connect_timeout = options[:connect_timeout]
+        map_exceptions do
+          if connect_timeout && connect_timeout != 0
+            connect_with_timeout(sockaddr, connect_timeout)
+          else
+            connect_without_timeout(sockaddr)
+          end
+        end
+        self
+      end
+
+      # @api private
+      def connect_without_timeout(sockaddr)
+        socket.connect(sockaddr)
+      end
+
+      # @api private
+      def connect_with_timeout(sockaddr, connect_timeout)
+        if connect_timeout <= 0
+          raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+        end
+
+        deadline = Utils.monotonic_time + connect_timeout
+        begin
+          socket.connect_nonblock(sockaddr)
+        rescue IO::WaitWritable
+          select_timeout = deadline - Utils.monotonic_time
+          if select_timeout <= 0
+            raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
+          end
+          if IO.select(nil, [socket], nil, select_timeout)
+            retry
+          else
+            socket.close
+            raise Error::SocketTimeoutError, "The socket took over #{connect_timeout} seconds to connect"
           end
-          self
+        rescue Errno::EISCONN
+          # Socket is connected, nothing more to do
         end
       end
-      private :connect!
 
       private
 

data/lib/mongo/socket.rb

@@ -192,27 +192,24 @@ module Mongo
     #   socket.read(4096)
     #
     # @param [ Integer ] length The number of bytes to read.
-    # @param [ Numeric ] timeout The timeout to use for each chunk read.
+    # @param [ Numeric ] socket_timeout The timeout to use for each chunk read,
+    #   mutually exclusive to +timeout+.
+    # @param [ Numeric ] timeout The total timeout to the whole read operation,
+    #   mutually exclusive to +socket_timeout+.
     #
     # @raise [ Mongo::SocketError ] If not all data is returned.
     #
     # @return [ Object ] The data from the socket.
     #
     # @since 2.0.0
-    def read(length, timeout: nil)
-      map_exceptions do
-        data = read_from_socket(length, timeout: timeout)
-        unless (data.length > 0 || length == 0)
-          raise IOError, "Expected to read > 0 bytes but read 0 bytes"
-        end
-        while data.length < length
-          chunk = read_from_socket(length - data.length, timeout: timeout)
-          unless (chunk.length > 0 || length == 0)
-            raise IOError, "Expected to read > 0 bytes but read 0 bytes"
-          end
-          data << chunk
-        end
-        data
+    def read(length, socket_timeout: nil, timeout: nil)
+      if !socket_timeout.nil? && !timeout.nil?
+        raise ArgumentError, 'Both timeout and socket_timeout cannot be set'
+      end
+      if !socket_timeout.nil? || timeout.nil?
+        read_without_timeout(length, socket_timeout)
+      else
+        read_with_timeout(length, timeout)
       end
     end
 
@@ -233,15 +230,16 @@ module Mongo
     # Writes data to the socket instance.
     #
     # @param [ Array<Object> ] args The data to be written.
+    # @param [ Numeric ] timeout The total timeout to the whole write operation.
     #
     # @return [ Integer ] The length of bytes written to the socket.
     #
     # @raise [ Error::SocketError | Error::SocketTimeoutError ] When there is a network error during the write.
     #
     # @since 2.0.0
-    def write(*args)
+    def write(*args, timeout: nil)
       map_exceptions do
-        do_write(*args)
+        do_write(*args, timeout: timeout)
       end
     end
 
@@ -254,7 +252,7 @@ module Mongo
       true
     end
 
-    # For backwards compatibilty only, do not use.
+    # For backwards compatibility only, do not use.
     #
     # @return [ true ] Always true.
     #
@@ -265,18 +263,76 @@ module Mongo
 
     private
 
-    def read_from_socket(length, timeout: nil)
+    # Reads the +length+ bytes from the socket, the read operation duration is
+    # limited to +timeout+ second.
+    #
+    # @param [ Integer ] length The number of bytes to read.
+    # @param [ Numeric ] timeout The total timeout to the whole read operation.
+    #
+    # @return [ Object ] The data from the socket.
+    def read_with_timeout(length, timeout)
+      deadline = Utils.monotonic_time + timeout
+      map_exceptions do
+        String.new.tap do |data|
+          while data.length < length
+            socket_timeout = deadline - Utils.monotonic_time
+            if socket_timeout <= 0
+              raise Mongo::Error::TimeoutError
+            end
+            chunk = read_from_socket(length - data.length, socket_timeout: socket_timeout, csot: true)
+            unless chunk.length > 0
+              raise IOError, "Expected to read > 0 bytes but read 0 bytes"
+            end
+            data << chunk
+          end
+        end
+      end
+    end
+
+    # Reads the +length+ bytes from the socket. The read operation may involve
+    # multiple socket reads, each read is limited to +timeout+ second,
+    # if the parameter is provided.
+    #
+    # @param [ Integer ] length The number of bytes to read.
+    # @param [ Numeric ] socket_timeout The timeout to use for each chunk read.
+    #
+    # @return [ Object ] The data from the socket.
+    def read_without_timeout(length, socket_timeout = nil)
+      map_exceptions do
+        String.new.tap do |data|
+          while data.length < length
+            chunk = read_from_socket(length - data.length, socket_timeout: socket_timeout)
+            unless chunk.length > 0
+              raise IOError, "Expected to read > 0 bytes but read 0 bytes"
+            end
+            data << chunk
+          end
+        end
+      end
+    end
+
+
+    # Reads the +length+ bytes from the socket. The read operation may involve
+    # multiple socket reads, each read is limited to +timeout+ second,
+    # if the parameter is provided.
+    #
+    # @param [ Integer ] length The number of bytes to read.
+    # @param [ Numeric ] :socket_timeout The timeout to use for each chunk read.
+    # @param [ true | false ] :csot Whether the CSOT timeout is set for the operation.
+    #
+    # @return [ Object ] The data from the socket.
+    def read_from_socket(length, socket_timeout: nil, csot: false)
       # Just in case
       if length == 0
         return ''.force_encoding('BINARY')
       end
 
-      _timeout = timeout || self.timeout
+      _timeout = socket_timeout || self.timeout
       if _timeout
         if _timeout > 0
           deadline = Utils.monotonic_time + _timeout
         elsif _timeout < 0
-          raise Errno::ETIMEDOUT, "Negative timeout #{_timeout} given to socket"
+          raise_timeout_error!("Negative timeout #{_timeout} given to socket", csot)
         end
       end
 
@@ -331,7 +387,7 @@ module Mongo
         if deadline
           select_timeout = deadline - Utils.monotonic_time
           if select_timeout <= 0
-            raise Errno::ETIMEDOUT, "Took more than #{_timeout} seconds to receive data"
+            raise_timeout_error!("Took more than #{_timeout} seconds to receive data", csot)
           end
         end
         pipe = options[:pipe]
@@ -373,11 +429,11 @@ module Mongo
           if deadline
             select_timeout = deadline - Utils.monotonic_time
             if select_timeout <= 0
-              raise Errno::ETIMEDOUT, "Took more than #{_timeout} seconds to receive data"
+              raise_timeout_error!("Took more than #{_timeout} seconds to receive data", csot)
             end
           end
         elsif rv.nil?
-          raise Errno::ETIMEDOUT, "Took more than #{_timeout} seconds to receive data (select call timed out)"
+          raise_timeout_error!("Took more than #{_timeout} seconds to receive data (select call timed out)", csot)
         end
         retry
       end
@@ -402,9 +458,23 @@ module Mongo
     # sholud map exceptions.
     #
     # @param [ Array<Object> ] args The data to be written.
+    # @param [ Numeric ] :timeout The total timeout to the whole write operation.
+    #
+    # @return [ Integer ] The length of bytes written to the socket.
+    def do_write(*args, timeout: nil)
+      if timeout.nil?
+        write_without_timeout(*args)
+      else
+        write_with_timeout(*args, timeout: timeout)
+      end
+    end
+
+    # Writes data to to the socket.
+    #
+    # @param [ Array<Object> ] args The data to be written.
     #
     # @return [ Integer ] The length of bytes written to the socket.
-    def do_write(*args)
+    def write_without_timeout(*args)
       # This method used to forward arguments to @socket.write in a
       # single call like so:
       #
@@ -428,6 +498,57 @@ module Mongo
       end
     end
 
+    # Writes data to to the socket, the write duration is limited to +timeout+.
+    #
+    # @param [ Array<Object> ] args The data to be written.
+    # @param [ Numeric ] :timeout The total timeout to the whole write operation.
+    #
+    # @return [ Integer ] The length of bytes written to the socket.
+    def write_with_timeout(*args, timeout:)
+      raise ArgumentError, 'timeout cannot be nil' if timeout.nil?
+      raise_timeout_error!("Negative timeout #{timeout} given to socket", true) if timeout < 0
+
+      written = 0
+      args.each do |buf|
+        buf = buf.to_s
+        i = 0
+        while i < buf.length
+          chunk = buf[i...(i + WRITE_CHUNK_SIZE)]
+          written += write_chunk(chunk, timeout)
+          i += WRITE_CHUNK_SIZE
+        end
+      end
+      written
+    end
+
+    def write_chunk(chunk, timeout)
+      deadline = Utils.monotonic_time + timeout
+      written = 0
+      begin
+        written += @socket.write_nonblock(chunk[written..-1])
+      rescue IO::WaitWritable, Errno::EINTR
+        select_timeout = deadline - Utils.monotonic_time
+        rv = Kernel.select(nil, [@socket], nil, select_timeout)
+        if BSON::Environment.jruby?
+          # Ignore the return value of Kernel.select.
+          # On JRuby, select appears to return nil prior to timeout expiration
+          # (apparently due to a EAGAIN) which then causes us to fail the read
+          # even though we could have retried it.
+          # Check the deadline ourselves.
+          if deadline
+            select_timeout = deadline - Utils.monotonic_time
+            if select_timeout <= 0
+              raise_timeout_error!("Took more than #{timeout} seconds to receive data", true)
+            end
+          end
+        elsif rv.nil?
+          raise_timeout_error!("Took more than #{timeout} seconds to receive data (select call timed out)", true)
+        end
+        retry
+      end
+      written
+    end
+
     def unix_socket?(sock)
       defined?(UNIXSocket) && sock.is_a?(UNIXSocket)
     end
@@ -482,5 +603,13 @@ module Mongo
     def human_address
       raise NotImplementedError
     end
+
+    def raise_timeout_error!(message = nil, csot = false)
+      if csot
+        raise Mongo::Error::TimeoutError
+      else
+        raise Errno::ETIMEDOUT, message
+      end
+    end
   end
 end

data/lib/mongo/uri/options_mapper.rb

@@ -272,6 +272,7 @@ module Mongo
       uri_option 'localThresholdMS', :local_threshold, type: :ms
       uri_option 'heartbeatFrequencyMS', :heartbeat_frequency, type: :ms
       uri_option 'maxIdleTimeMS', :max_idle_time, type: :ms
+      uri_option 'timeoutMS', :timeout_ms, type: :integer
 
       # Write Options
       uri_option 'w', :w, group: :write_concern, type: :w

data/lib/mongo/version.rb

@@ -1,9 +1,20 @@
 # frozen_string_literal: true
 
+# Copyright (C) 2014-2020 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
   # The current version of the driver.
-  #
-  # Note that this file is automatically updated via `rake candidate:create`.
-  # Manual changes to this file will be overwritten by that rake task.
-  VERSION = '2.20.2'
+  VERSION = '2.21.0'
 end

data/lib/mongo.rb

@@ -39,6 +39,7 @@ require 'mongo/bson'
 require 'mongo/semaphore'
 require 'mongo/distinguishing_semaphore'
 require 'mongo/condition_variable'
+require 'mongo/csot_timeout_holder'
 require 'mongo/options'
 require 'mongo/loggable'
 require 'mongo/cluster_time'

data/spec/atlas/atlas_connectivity_spec.rb

@@ -10,6 +10,10 @@ describe 'Atlas connectivity' do
   require_atlas
 
   describe 'connection to Atlas' do
+    after do
+      client.close
+    end
+
     it 'runs ismaster successfully' do
       expect { client.database.command(:hello => 1) }
         .not_to raise_error

data/spec/atlas/operations_spec.rb

@@ -10,6 +10,10 @@ describe 'Operations' do
   require_atlas
 
   describe 'ping' do
+    after do
+      client.close
+    end
+
     it 'works' do
       expect do
         client.database.command(ping: 1)

data/spec/integration/client_side_encryption/auto_encryption_mongocryptd_spawn_spec.rb

@@ -57,7 +57,8 @@ describe 'Auto Encryption' do
             'jsonSchema' => kind_of(Hash),
             'isRemoteSchema' => false,
           ),
-          { execution_options: { deserialize_as_bson: true } },
+          { execution_options: { deserialize_as_bson: true }, timeout_ms: nil },
+
         )
         .and_raise(Mongo::Error::NoServerAvailable.new(server_selector, cluster))
     end