mongo 2.12.1 → 2.13.0

data/lib/mongo/session/server_session.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2017-2019 MongoDB, Inc.
+# Copyright (C) 2017-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.

data/lib/mongo/session/session_pool.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2017-2019 MongoDB, Inc.
+# Copyright (C) 2017-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.

data/lib/mongo/socket.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# 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.
@@ -21,6 +21,7 @@ module Mongo
   # Provides additional data around sockets for the driver's use.
   #
   # @since 2.0.0
+  # @api private
   class Socket
     include ::Socket::Constants
 
@@ -45,6 +46,25 @@ module Mongo
     # @api private
     WRITE_CHUNK_SIZE = 65536
 
+    # Initializes common socket attributes.
+    #
+    # @param [ Float ] timeout The socket timeout value.
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ Float ] :connect_timeout Connect timeout.
+    # @option options [ Address ] :connection_address Address of the
+    #   connection that created this socket.
+    # @option options [ Integer ] :connection_generation Generation of the
+    #   connection (for non-monitoring connections) that created this socket.
+    # @option options [ true | false ] :monitor Whether this socket was
+    #   created by a monitoring connection.
+    #
+    # @api private
+    def initialize(timeout, options)
+      @timeout = timeout
+      @options = options
+    end
+
     # @return [ Integer ] family The type of host family.
     attr_reader :family
 
@@ -57,6 +77,46 @@ module Mongo
     # @return [ Float ] timeout The socket timeout.
     attr_reader :timeout
 
+    # @return [ Address ] Address of the connection that created this socket.
+    #
+    # @api private
+    def connection_address
+      options[:connection_address]
+    end
+
+    # @return [ Integer ] Generation of the connection (for non-monitoring
+    #   connections) that created this socket.
+    #
+    # @api private
+    def connection_generation
+      options[:connection_generation]
+    end
+
+    # @return [ true | false ] Whether this socket was created by a monitoring
+    #   connection.
+    #
+    # @api private
+    def monitor?
+      !!options[:monitor]
+    end
+
+    # @return [ String ] Human-readable summary of the socket for debugging.
+    #
+    # @api private
+    def summary
+      fileno = @socket&.fileno rescue '<no socket>' || '<no socket>'
+      if monitor?
+        indicator = if options[:push]
+          'pm'
+        else
+          'm'
+        end
+        "#{connection_address};#{indicator};fd=#{fileno}"
+      else
+        "#{connection_address};c:#{connection_generation};fd=#{fileno}"
+      end
+    end
+
     # Is the socket connection alive?
     #
     # @example Is the socket alive?
@@ -107,7 +167,9 @@ module Mongo
     #
     # @since 2.0.0
     def gets(*args)
-      handle_errors { @socket.gets(*args) }
+      map_exceptions do
+        @socket.gets(*args)
+      end
     end
 
     # Will read all data from the socket for the provided number of bytes.
@@ -117,20 +179,21 @@ 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.
     #
     # @raise [ Mongo::SocketError ] If not all data is returned.
     #
     # @return [ Object ] The data from the socket.
     #
     # @since 2.0.0
-    def read(length)
-      handle_errors do
-        data = read_from_socket(length)
+    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)
+          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
@@ -149,42 +212,21 @@ module Mongo
     #
     # @since 2.0.0
     def readbyte
-      handle_errors { @socket.readbyte }
+      map_exceptions do
+        @socket.readbyte
+      end
     end
 
     # Writes data to the socket instance.
     #
-    # @example Write to the socket.
-    #   socket.write(data)
-    #
     # @param [ Array<Object> ] args The data to be written.
     #
     # @return [ Integer ] The length of bytes written to the socket.
     #
     # @since 2.0.0
     def write(*args)
-      handle_errors do
-        # This method used to forward arguments to @socket.write in a
-        # single call like so:
-        #
-        # @socket.write(*args)
-        #
-        # Turns out, when each buffer to be written is large (e.g. 32 MiB),
-        # this write call would take an extremely long time (20+ seconds)
-        # while using 100% CPU. Splitting the writes into chunks produced
-        # massively better performance (0.05 seconds to write the 32 MiB of
-        # data on the same hardware). Unfortunately splitting the data,
-        # one would assume, results in it being copied, but this seems to be
-        # a much more minor issue compared to CPU cost of writing large buffers.
-        args.each do |buf|
-          buf = buf.to_s
-          i = 0
-          while i < buf.length
-            chunk = buf[i...i+WRITE_CHUNK_SIZE]
-            @socket.write(chunk)
-            i += WRITE_CHUNK_SIZE
-          end
-        end
+      map_exceptions do
+        do_write(*args)
       end
     end
 
@@ -208,14 +250,19 @@ module Mongo
 
     private
 
-    def read_from_socket(length)
+    def read_from_socket(length, timeout: nil)
       # Just in case
       if length == 0
         return ''.force_encoding('BINARY')
       end
 
-      if _timeout = self.timeout
-        deadline = Time.now + _timeout
+      _timeout = timeout || self.timeout
+      if _timeout
+        if _timeout > 0
+          deadline = Time.now + _timeout
+        elsif _timeout < 0
+          raise Errno::ETIMEDOUT, "Negative timeout #{_timeout} given to socket"
+        end
       end
 
       # We want to have a fixed and reasonably small size buffer for reads
@@ -300,6 +347,39 @@ module Mongo
       65536
     end
 
+    # Writes data to the socket instance.
+    #
+    # This is a separate method from +write+ for ease of mocking in the tests.
+    # This method should not perform any exception mapping, upstream code
+    # sholud map exceptions.
+    #
+    # @param [ Array<Object> ] args The data to be written.
+    #
+    # @return [ Integer ] The length of bytes written to the socket.
+    def do_write(*args)
+      # This method used to forward arguments to @socket.write in a
+      # single call like so:
+      #
+      # @socket.write(*args)
+      #
+      # Turns out, when each buffer to be written is large (e.g. 32 MiB),
+      # this write call would take an extremely long time (20+ seconds)
+      # while using 100% CPU. Splitting the writes into chunks produced
+      # massively better performance (0.05 seconds to write the 32 MiB of
+      # data on the same hardware). Unfortunately splitting the data,
+      # one would assume, results in it being copied, but this seems to be
+      # a much more minor issue compared to CPU cost of writing large buffers.
+      args.each do |buf|
+        buf = buf.to_s
+        i = 0
+        while i < buf.length
+          chunk = buf[i...i+WRITE_CHUNK_SIZE]
+          @socket.write(chunk)
+          i += WRITE_CHUNK_SIZE
+        end
+      end
+    end
+
     def unix_socket?(sock)
       defined?(UNIXSocket) && sock.is_a?(UNIXSocket)
     end
@@ -308,7 +388,7 @@ module Mongo
 
     DEFAULT_TCP_KEEPCNT = 9
 
-    DEFAULT_TCP_KEEPIDLE = 300
+    DEFAULT_TCP_KEEPIDLE = 120
 
     def set_keepalive_opts(sock)
       sock.setsockopt(SOL_SOCKET, SO_KEEPALIVE, true)
@@ -332,19 +412,19 @@ module Mongo
       set_keepalive_opts(sock)
     end
 
-    def handle_errors
+    def map_exceptions
       begin
         yield
       rescue Errno::ETIMEDOUT => e
-        raise Error::SocketTimeoutError, "#{e.class}: #{e} (for #{address})"
+        raise Error::SocketTimeoutError, "#{e.class}: #{e} (for #{human_address})"
       rescue IOError, SystemCallError => e
-        raise Error::SocketError, "#{e.class}: #{e} (for #{address})"
+        raise Error::SocketError, "#{e.class}: #{e} (for #{human_address})"
       rescue OpenSSL::SSL::SSLError => e
-        raise Error::SocketError, "#{e.class}: #{e} (for #{address}) (#{SSL_ERROR})"
+        raise Error::SocketError, "#{e.class}: #{e} (for #{human_address}) (#{SSL_ERROR})"
       end
     end
 
-    def address
+    def human_address
       raise NotImplementedError
     end
   end

data/lib/mongo/socket/ssl.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2019 MongoDB, Inc.
+# 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.
@@ -21,6 +21,98 @@ module Mongo
     class SSL < Socket
       include OpenSSL
 
+      # Initializes a new SSL socket.
+      #
+      # @example Create the SSL socket.
+      #   SSL.new('::1', 27017, 30)
+      #
+      # @param [ String ] host The hostname or IP address.
+      # @param [ Integer ] port The port number.
+      # @param [ Float ] timeout The socket timeout value.
+      # @param [ Integer ] family The socket family.
+      # @param [ Hash ] options The options.
+      #
+      # @option options [ Float ] :connect_timeout Connect timeout.
+      # @option options [ Address ] :connection_address Address of the
+      #   connection that created this socket.
+      # @option options [ Integer ] :connection_generation Generation of the
+      #   connection (for non-monitoring connections) that created this socket.
+      # @option options [ true | false ] :monitor Whether this socket was
+      #   created by a monitoring connection.
+      # @option options [ String ] :ssl_ca_cert The file containing concatenated
+      #   certificate authority certificates used to validate certs passed from the
+      #   other end of the connection. Intermediate certificates should NOT be
+      #   specified in files referenced by this option. One of :ssl_ca_cert,
+      #   :ssl_ca_cert_string or :ssl_ca_cert_object (in order of priority) is
+      #   required when using :ssl_verify.
+      # @option options [ Array<OpenSSL::X509::Certificate> ] :ssl_ca_cert_object
+      #   An array of OpenSSL::X509::Certificate objects representing the
+      #   certificate authority certificates used to validate certs passed from
+      #   the other end of the connection. Intermediate certificates should NOT
+      #   be specified in files referenced by this option. One of :ssl_ca_cert,
+      #   :ssl_ca_cert_string or :ssl_ca_cert_object (in order of priority)
+      #   is required when using :ssl_verify.
+      # @option options [ String ] :ssl_ca_cert_string A string containing
+      #   certificate authority certificate used to validate certs passed from the
+      #   other end of the connection. This option allows passing only one CA
+      #   certificate to the driver. Intermediate certificates should NOT
+      #   be specified in files referenced by this option. One of :ssl_ca_cert,
+      #   :ssl_ca_cert_string or :ssl_ca_cert_object (in order of priority) is
+      #   required when using :ssl_verify.
+      # @option options [ String ] :ssl_cert The certificate file used to identify
+      #   the connection against MongoDB. A certificate chain may be passed by
+      #   specifying the client certificate first followed by any intermediate
+      #   certificates up to the CA certificate. The file may also contain the
+      #   certificate's private key, which will be ignored. This option, if present,
+      #   takes precedence over the values of :ssl_cert_string and :ssl_cert_object
+      # @option options [ OpenSSL::X509::Certificate ] :ssl_cert_object The OpenSSL::X509::Certificate
+      #   used to identify the connection against MongoDB. Only one certificate
+      #   may be passed through this option.
+      # @option options [ String ] :ssl_cert_string A string containing the PEM-encoded
+      #   certificate used to identify the connection against MongoDB. A certificate
+      #   chain may be passed by specifying the client certificate first followed
+      #   by any intermediate certificates up to the CA certificate. The string
+      #   may also contain the certificate's private key, which will be ignored,
+      #   This option, if present, takes precedence over the value of :ssl_cert_object
+      # @option options [ String ] :ssl_key The private keyfile used to identify the
+      #   connection against MongoDB. Note that even if the key is stored in the same
+      #   file as the certificate, both need to be explicitly specified. This option,
+      #   if present, takes precedence over the values of :ssl_key_string and :ssl_key_object
+      # @option options [ OpenSSL::PKey ] :ssl_key_object The private key used to identify the
+      #   connection against MongoDB
+      # @option options [ String ] :ssl_key_pass_phrase A passphrase for the private key.
+      # @option options [ String ] :ssl_key_string A string containing the PEM-encoded private key
+      #   used to identify the connection against MongoDB. This parameter, if present,
+      #   takes precedence over the value of option :ssl_key_object
+      # @option options [ true, false ] :ssl_verify Whether to perform peer certificate validation and
+      #   hostname verification. Note that the decision of whether to validate certificates will be
+      #   overridden if :ssl_verify_certificate is set, and the decision of whether to validate
+      #   hostnames will be overridden if :ssl_verify_hostname is set.
+      # @option options [ true, false ] :ssl_verify_certificate Whether to perform peer certificate
+      #   validation. This setting overrides :ssl_verify with respect to whether certificate
+      #   validation is performed.
+      # @option options [ true, false ] :ssl_verify_hostname Whether to perform peer hostname
+      #   validation. This setting overrides :ssl_verify with respect to whether hostname validation
+      #   is performed.
+      #
+      # @since 2.0.0
+      # @api private
+      def initialize(host, port, host_name, timeout, family, options = {})
+        super(timeout, options)
+        @host, @port, @host_name = host, port, host_name
+        @context = create_context(options)
+        @family = family
+        @tcp_socket = ::Socket.new(family, SOCK_STREAM, 0)
+        begin
+          @tcp_socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
+          set_socket_options(@tcp_socket)
+          connect!
+        rescue
+          @tcp_socket.close
+          raise
+        end
+      end
+
       # @return [ SSLContext ] context The ssl context.
       attr_reader :context
 
@@ -45,15 +137,15 @@ module Mongo
       #
       # @since 2.0.0
       def connect!
-        Timeout.timeout(options[:connect_timeout], Error::SocketTimeoutError) do
-          handle_errors do
+        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
-            handle_errors do
+            map_exceptions do
               @socket.connect
             end
             verify_certificate!(@socket)
@@ -67,35 +159,6 @@ module Mongo
       end
       private :connect!
 
-      # Initializes a new SSL socket.
-      #
-      # @example Create the SSL socket.
-      #   SSL.new('::1', 27017, 30)
-      #
-      # @param [ String ] host The hostname or IP address.
-      # @param [ Integer ] port The port number.
-      # @param [ Float ] timeout The socket timeout value.
-      # @param [ Integer ] family The socket family.
-      # @param [ Hash ] options The options.
-      #
-      # @option options [ Float ] :connect_timeout Connect timeout.
-      #
-      # @since 2.0.0
-      def initialize(host, port, host_name, timeout, family, options = {})
-        @host, @port, @host_name, @timeout, @options = host, port, host_name, timeout, options
-        @context = create_context(options)
-        @family = family
-        @tcp_socket = ::Socket.new(family, SOCK_STREAM, 0)
-        begin
-          @tcp_socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
-          set_socket_options(@tcp_socket)
-          connect!
-        rescue
-          @tcp_socket.close
-          raise
-        end
-      end
-
       # Read a single byte from the socket.
       #
       # @example Read a single byte.
@@ -105,7 +168,7 @@ module Mongo
       #
       # @since 2.0.0
       def readbyte
-        handle_errors do
+        map_exceptions do
           byte = socket.read(1).bytes.to_a[0]
           byte.nil? ? raise(EOFError) : byte
         end
@@ -292,7 +355,7 @@ module Mongo
         16384
       end
 
-      def address
+      def human_address
         "#{host}:#{port} (#{host_name}:#{port}, TLS)"
       end
     end