mongo 2.11.2 → 2.13.0.beta1

data/lib/mongo/client_encryption.rb

@@ -0,0 +1,103 @@
+# Copyright (C) 2019-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
+  # ClientEncryption encapsulates explicit operations on a key vault
+  # collection that cannot be done directly on a MongoClient. It
+  # provides an API for explicitly encrypting and decrypting values,
+  # and creating data keys.
+  class ClientEncryption
+    # Create a new ClientEncryption object with the provided options.
+    #
+    # @param [ Mongo::Client ] key_vault_client A Mongo::Client
+    #   that is connected to the MongoDB instance where the key vault
+    #   collection is stored.
+    # @param [ Hash ] options The ClientEncryption options.
+    #
+    # @option options [ String ] :key_vault_namespace The name of the
+    #   key vault collection in the format "database.collection".
+    # @option options [ Hash ] :kms_providers A hash of key management service
+    #   configuration information. Valid hash keys are :local or :aws. There
+    #   may be more than one KMS provider specified.
+    def initialize(key_vault_client, options={})
+      @encrypter = Crypt::ExplicitEncrypter.new(
+        key_vault_client,
+        options[:key_vault_namespace],
+        options[:kms_providers]
+      )
+    end
+
+    # Generates a data key used for encryption/decryption and stores
+    # that key in the KMS collection. The generated key is encrypted with
+    # the KMS master key.
+    #
+    # @param [ String ] kms_provider The KMS provider to use. Valid values are
+    #   "aws" and "local".
+    # @param [ Hash ] options
+    #
+    # @option options [ Hash ] :master_key Information about the AWS master key.
+    #   Required if kms_provider is "aws".
+    #   - :region [ String ] The The AWS region of the master key (required).
+    #   - :key [ String ] The Amazon Resource Name (ARN) of the master key (required).
+    #   - :endpoint [ String ] An alternate host to send KMS requests to (optional).
+    #     endpoint should be a host name with an optional port number separated
+    #     by a colon (e.g. "kms.us-east-1.amazonaws.com" or
+    #     "kms.us-east-1.amazonaws.com:443"). An endpoint in any other format
+    #     will not be properly parsed.
+    # @option options [ Array<String> ] :key_alt_names An optional array of
+    #   strings specifying alternate names for the new data key.
+    #
+    # @return [ BSON::Binary ] The 16-byte UUID of the new data key as a
+    #   BSON::Binary object with type :uuid.
+    def create_data_key(kms_provider, options={})
+      @encrypter.create_and_insert_data_key(
+        kms_provider,
+        options
+      )
+    end
+
+    # Encrypts a value using the specified encryption key and algorithm.
+    #
+    # @param [ Object ] value The value to encrypt.
+    # @param [ Hash ] options
+    #
+    # @option options [ BSON::Binary ] :key_id A BSON::Binary object of type :uuid
+    #   representing the UUID of the encryption key as it is stored in the key
+    #   vault collection.
+    # @option options [ String ] :key_alt_name The alternate name for the
+    #   encryption key.
+    # @option options [ String ] :algorithm The algorithm used to encrypt the value.
+    #   Valid algorithms are "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
+    #   or "AEAD_AES_256_CBC_HMAC_SHA_512-Random".
+    #
+    # @note The :key_id and :key_alt_name options are mutually exclusive. Only
+    #   one is required to perform explicit encryption.
+    #
+    # @return [ BSON::Binary ] A BSON Binary object of subtype 6 (ciphertext)
+    #   representing the encrypted value.
+    def encrypt(value, options={})
+      @encrypter.encrypt(value, options)
+    end
+
+    # Decrypts a value that has already been encrypted.
+    #
+    # @param [ BSON::Binary ] value A BSON Binary object of subtype 6 (ciphertext)
+    #   that will be decrypted.
+    #
+    # @return [ Object ] The decrypted value.
+    def decrypt(value)
+      @encrypter.decrypt(value)
+    end
+  end
+end

data/lib/mongo/cluster.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.
@@ -76,6 +76,16 @@ module Mongo
     # @param [ Hash ] options Options. Client constructor forwards its
     #   options to Cluster constructor, although Cluster recognizes
     #   only a subset of the options recognized by Client.
+    #
+    # @option options [ true | false ] :direct_connection Whether to connect
+    #   directly to the specified seed, bypassing topology discovery. Exactly
+    #   one seed must be provided.
+    # @option options [ Symbol ] :connect Deprecated - use :direct_connection
+    #   option instead of this option. The connection method to use. This
+    #   forces the cluster to behave in the specified way instead of
+    #   auto-discovering. One of :direct, :replica_set, :sharded
+    # @option options [ Symbol ] :replica_set The name of the replica set to
+    #   connect to. Servers not in this replica set will be ignored.
     # @option options [ true | false ] :scan Whether to scan all seeds
     #   in constructor. The default in driver version 2.x is to do so;
     #   driver version 3.x will not scan seeds in constructor. Opt in to the
@@ -104,23 +114,39 @@ module Mongo
         raise ArgumentError, 'Seeds cannot be nil'
       end
 
+      options = options.dup
       if options[:monitoring_io] == false && !options.key?(:cleanup)
-        options = options.dup
         options[:cleanup] = false
       end
+      @options = options.freeze
 
+      # @update_lock covers @servers, @connecting, @connected, @topology and
+      # @sessions_supported. Generally instance variables that do not have a
+      # designated for them lock should only be modified under the update lock.
+      # Note that topology change is locked by @update_lock and not by
+      # @sdam_flow_lock.
+      @update_lock = Mutex.new
       @servers = []
       @monitoring = monitoring
       @event_listeners = Event::Listeners.new
-      @options = options.freeze
       @app_metadata = Server::AppMetadata.new(@options)
-      @update_lock = Mutex.new
-      @sdam_flow_lock = Mutex.new
-      @cluster_time = nil
       @cluster_time_lock = Mutex.new
+      @cluster_time = nil
       @srv_monitor_lock = Mutex.new
+      @srv_monitor = nil
       @server_selection_semaphore = Semaphore.new
       @topology = Topology.initial(self, monitoring, options)
+      # State change lock is similar to the sdam flow lock, but is designed
+      # to serialize state changes initated by consumers of Cluster
+      # (e.g. application connecting or disconnecting the cluster), so that
+      # e.g. an application calling disconnect-connect-disconnect rapidly
+      # does not put the cluster into an inconsistent state.
+      # Monitoring updates performed internally by the driver do not take
+      # the state change lock.
+      @state_change_lock = Mutex.new
+      # @sdam_flow_lock covers just the sdam flow. Note it does not apply
+      # to @topology replacements which are done under @update_lock.
+      @sdam_flow_lock = Mutex.new
       Session::SessionPool.create(self)
 
       # The opening topology is always unknown with no servers.
@@ -132,7 +158,7 @@ module Mongo
         Monitoring::Event::TopologyOpening.new(opening_topology)
       )
 
-      @seeds = seeds
+      @seeds = seeds = seeds.uniq
       servers = seeds.map do |seed|
         # Server opening events must be sent after topology change events.
         # Therefore separate server addition, done here before topoolgy change
@@ -256,8 +282,8 @@ module Mongo
     # @return [ Object ] The cluster topology.
     attr_reader :topology
 
-    # @return [ Mongo::Server::AppMetadata ] The application metadata, used for connection
-    #   handshakes.
+    # @return [ Mongo::Server::AppMetadata ] The application metadata, used for
+    #   connection handshakes.
     #
     # @since 2.4.0
     attr_reader :app_metadata
@@ -333,7 +359,18 @@ module Mongo
     # @since 2.10.0
     # @api private
     def heartbeat_interval
-      options[:heartbeat_frequency] || Server::Monitor::HEARTBEAT_FREQUENCY
+      options[:heartbeat_frequency] || Server::Monitor::DEFAULT_HEARTBEAT_INTERVAL
+    end
+
+    # Whether the cluster object is in the process of connecting to its cluster.
+    #
+    # @return [ true|false ] Whether the cluster is connecting.
+    #
+    # @api private
+    def connecting?
+      @update_lock.synchronize do
+        !!@connecting
+      end
     end
 
     # Whether the cluster object is connected to its cluster.
@@ -343,7 +380,9 @@ module Mongo
     # @api private
     # @since 2.7.0
     def connected?
-      !!@connected
+      @update_lock.synchronize do
+        !!@connected
+      end
     end
 
     # Get a list of server candidates from the cluster that can have operations
@@ -368,7 +407,7 @@ module Mongo
     #
     # @since 2.0.6
     def addresses
-      servers_list.map(&:address).dup
+      servers_list.map(&:address)
     end
 
     # The logical session timeout value in minutes.
@@ -439,32 +478,36 @@ module Mongo
     #
     # @since 2.1.0
     def disconnect!
-      unless @connecting || @connected
-        return true
-      end
-      if options[:cleanup] != false
-        session_pool.end_sessions
-        @periodic_executor.stop!
-      end
-      @srv_monitor_lock.synchronize do
-        if @srv_monitor
-          @srv_monitor.stop!
+      @state_change_lock.synchronize do
+        unless connecting? || connected?
+          return true
         end
-      end
-      @servers.each do |server|
-        if server.connected?
-          server.disconnect!
-          publish_sdam_event(
-            Monitoring::SERVER_CLOSED,
-            Monitoring::Event::ServerClosed.new(server.address, topology)
-          )
+        if options[:cleanup] != false
+          session_pool.end_sessions
+          @periodic_executor.stop!
+        end
+        @srv_monitor_lock.synchronize do
+          if @srv_monitor
+            @srv_monitor.stop!
+          end
+        end
+        @servers.each do |server|
+          if server.connected?
+            server.disconnect!
+            publish_sdam_event(
+              Monitoring::SERVER_CLOSED,
+              Monitoring::Event::ServerClosed.new(server.address, topology)
+            )
+          end
+        end
+        publish_sdam_event(
+          Monitoring::TOPOLOGY_CLOSED,
+          Monitoring::Event::TopologyClosed.new(topology)
+        )
+        @update_lock.synchronize do
+          @connecting = @connected = false
         end
       end
-      publish_sdam_event(
-        Monitoring::TOPOLOGY_CLOSED,
-        Monitoring::Event::TopologyClosed.new(topology)
-      )
-      @connecting = @connected = false
       true
     end
 
@@ -479,14 +522,25 @@ module Mongo
     # @deprecated Use Client#reconnect to reconnect to the cluster instead of
     #   calling this method. This method does not send SDAM events.
     def reconnect!
-      @connecting = true
-      scan!
-      servers.each do |server|
-        server.reconnect!
+      @state_change_lock.synchronize do
+        @update_lock.synchronize do
+          @connecting = true
+        end
+        scan!
+        servers.each do |server|
+          server.reconnect!
+        end
+        @periodic_executor.restart!
+        @srv_monitor_lock.synchronize do
+          if @srv_monitor
+            @srv_monitor.run!
+          end
+        end
+        @update_lock.synchronize do
+          @connecting = false
+          @connected = true
+        end
       end
-      @periodic_executor.restart!
-      @connecting = false
-      @connected = true
     end
 
     # Force a scan of all known servers in the cluster.
@@ -729,7 +783,14 @@ module Mongo
       if !addresses.include?(address)
         server = Server.new(address, self, @monitoring, event_listeners, options.merge(
           monitor: false))
-        @update_lock.synchronize { @servers.push(server) }
+        @update_lock.synchronize do
+          # Need to recheck whether server is present in @servers, because
+          # the previous check was not under a lock.
+          # Since we are under the update lock here, we cannot call servers_list.
+          return if @servers.map(&:address).include?(address)
+
+          @servers.push(server)
+        end
         if add_options.nil? || add_options[:monitor] != false
           server.start_monitoring
         end
@@ -758,8 +819,16 @@ module Mongo
     # @since 2.0.0
     def remove(host, disconnect: true)
       address = Address.new(host)
-      removed_servers = @servers.select { |s| s.address == address }
-      @update_lock.synchronize { @servers = @servers - removed_servers }
+      removed_servers = []
+      @update_lock.synchronize do
+        @servers.delete_if do |server|
+          (server.address == address).tap do |delete|
+            if delete
+              removed_servers << server
+            end
+          end
+        end
+      end
       if disconnect != false
         removed_servers.each do |server|
           disconnect_server_if_connected(server)
@@ -774,8 +843,11 @@ module Mongo
 
     # @api private
     def update_topology(new_topology)
-      old_topology = topology
-      @topology = new_topology
+      old_topology = nil
+      @update_lock.synchronize do
+        old_topology = topology
+        @topology = new_topology
+      end
 
       # If new topology has data bearing servers, we know for sure whether
       # sessions are supported - update our cached value.
@@ -784,7 +856,10 @@ module Mongo
       # to try to determine session support accurately, falling back to the
       # last known value.
       if topology.data_bearing_servers?
-        @sessions_supported = !!topology.logical_session_timeout
+        sessions_supported = !!topology.logical_session_timeout
+        @update_lock.synchronize do
+          @sessions_supported = sessions_supported
+        end
       end
 
       publish_sdam_event(
@@ -795,7 +870,9 @@ module Mongo
 
     # @api private
     def servers_list
-      @update_lock.synchronize { @servers.dup }
+      @update_lock.synchronize do
+        @servers.dup
+      end
     end
 
     # @api private
@@ -835,7 +912,9 @@ module Mongo
       rescue Error::NoServerAvailable
         # We haven't been able to contact any servers - use last known
         # value for esssion support.
-        @sessions_supported || false
+        @update_lock.synchronize do
+          @sessions_supported || false
+        end
       end
     end
 
@@ -853,7 +932,7 @@ module Mongo
           unless @srv_monitor
             monitor_options = options.merge(
               timeout: options[:connect_timeout] || Server::CONNECT_TIMEOUT)
-            @srv_monitor = _srv_monitor = SrvMonitor.new(self, monitor_options)
+            @srv_monitor = _srv_monitor = Srv::Monitor.new(self, monitor_options)
             finalizer = lambda do
               _srv_monitor.stop!
             end
@@ -877,4 +956,3 @@ module Mongo
 end
 
 require 'mongo/cluster/sdam_flow'
-require 'mongo/cluster/srv_monitor'

data/lib/mongo/cluster/periodic_executor.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.

data/lib/mongo/cluster/reapers/cursor_reaper.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2015 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.
@@ -76,10 +76,15 @@ module Mongo
       #
       # @since 2.3.0
       def register_cursor(id)
-        if id && id > 0
-          @mutex.synchronize do
-            @active_cursors << id
-          end
+        if id.nil?
+          raise ArgumentError, 'register_cursor called with nil cursor_id'
+        end
+        if id == 0
+          raise ArgumentError, 'register_cursor called with cursor_id=0'
+        end
+
+        @mutex.synchronize do
+          @active_cursors << id
         end
       end
 
@@ -94,6 +99,13 @@ module Mongo
       #
       # @since 2.3.0
       def unregister_cursor(id)
+        if id.nil?
+          raise ArgumentError, 'unregister_cursor called with nil cursor_id'
+        end
+        if id == 0
+          raise ArgumentError, 'unregister_cursor called with cursor_id=0'
+        end
+
         @mutex.synchronize do
           @active_cursors.delete(id)
         end
@@ -122,12 +134,12 @@ module Mongo
             if server.features.find_command_enabled?
               Cursor::Builder::KillCursorsCommand.update_cursors(op_spec, active_cursors_copy.to_a)
               if Cursor::Builder::KillCursorsCommand.get_cursors_list(op_spec).size > 0
-                Operation::KillCursors.new(op_spec).execute(server)
+                Operation::KillCursors.new(op_spec).execute(server, client: nil)
               end
             else
               Cursor::Builder::OpKillCursors.update_cursors(op_spec, active_cursors_copy.to_a)
               if Cursor::Builder::OpKillCursors.get_cursors_list(op_spec).size > 0
-                Operation::KillCursors.new(op_spec).execute(server)
+                Operation::KillCursors.new(op_spec).execute(server, client: nil)
               end
             end
           end