mongo 2.19.2 → 2.20.0

data/lib/mongo/session/server_session/dirtyable.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2024 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 Session
+    class ServerSession
+      # Functionality for manipulating and querying a session's
+      # "dirty" state, per the last paragraph at
+      # https://github.com/mongodb/specifications/blob/master/source/sessions/driver-sessions.rst#server-session-pool
+      #
+      #   If a driver has a server session pool and a network error is
+      #   encountered when executing any command with a ClientSession, the
+      #   driver MUST mark the associated ServerSession as dirty. Dirty server
+      #   sessions are discarded when returned to the server session pool. It is
+      #   valid for a dirty session to be used for subsequent commands (e.g. an
+      #   implicit retry attempt, a later command in a bulk write, or a later
+      #   operation on an explicit session), however, it MUST remain dirty for
+      #   the remainder of its lifetime regardless if later commands succeed.
+      #
+      # @api private
+      module Dirtyable
+        # Query whether the server session has been marked dirty or not.
+        #
+        # @return [ true | false ] the server session's dirty state
+        def dirty?
+          @dirty
+        end
+
+        # Mark the server session as dirty (the default) or clean.
+        #
+        # @param [ true | false ] mark whether the mark the server session
+        #   dirty or not.
+        def dirty!(mark = true)
+          @dirty = mark
+        end
+      end
+    end
+  end
+end

data/lib/mongo/session/server_session.rb

@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'mongo/session/server_session/dirtyable'
+
 module Mongo
 
   class Session
@@ -25,6 +27,7 @@ module Mongo
     #
     # @since 2.5.0
     class ServerSession
+      include Dirtyable
 
       # Regex for removing dashes from the UUID string.
       #

data/lib/mongo/session/session_pool.rb

@@ -25,21 +25,6 @@ module Mongo
     #
     # @since 2.5.0
     class SessionPool
-
-      # Create a SessionPool.
-      #
-      # @example
-      #   SessionPool.create(cluster)
-      #
-      # @param [ Mongo::Cluster ] cluster The cluster that will be associated with this
-      #   session pool.
-      #
-      # @since 2.5.0
-      def self.create(cluster)
-        pool = new(cluster)
-        cluster.instance_variable_set(:@session_pool, pool)
-      end
-
       # Initialize a SessionPool.
       #
       # @example
@@ -105,9 +90,7 @@ module Mongo
 
         @mutex.synchronize do
           prune!
-          unless about_to_expire?(session)
-            @queue.unshift(session)
-          end
+          @queue.unshift(session) if return_to_queue?(session)
         end
       end
 
@@ -136,6 +119,17 @@ module Mongo
 
       private
 
+      # Query whether the given session is okay to return to the
+      # pool's queue.
+      #
+      # @param [ Session::ServerSession ] session the session to query
+      #
+      # @return [ true | false ] whether to return the session to the
+      #   queue.
+      def return_to_queue?(session)
+        !session.dirty? && !about_to_expire?(session)
+      end
+
       def about_to_expire?(session)
         if session.nil?
           raise ArgumentError, 'session cannot be nil'

data/lib/mongo/session.rb

@@ -123,6 +123,23 @@ module Mongo
     # @since 2.5.0
     attr_reader :operation_time
 
+    # Sets the dirty state to the given value for the underlying server
+    # session. If there is no server session, this does nothing.
+    #
+    # @param [ true | false ] mark whether to mark the server session as
+    #   dirty, or not.
+    def dirty!(mark = true)
+      @server_session&.dirty!(mark)
+    end
+
+    # @return [ true | false | nil ] whether the underlying server session is
+    #   dirty. If no server session exists for this session, returns nil.
+    #
+    # @api private
+    def dirty?
+      @server_session&.dirty?
+    end
+
     # @return [ Hash ] The options for the transaction currently being executed
     # on this session.
     #
@@ -538,6 +555,8 @@ module Mongo
     #
     # @since 2.6.0
     def start_transaction(options = nil)
+      check_transactions_supported!
+
       if options
         Lint.validate_read_concern_option(options[:read_concern])
 
@@ -1185,5 +1204,18 @@ module Mongo
         raise Mongo::Error::InvalidSession.new(MISMATCHED_CLUSTER_ERROR_MSG)
       end
     end
+
+    def check_transactions_supported!
+      raise Mongo::Error::TransactionsNotSupported, "standalone topology" if cluster.single?
+
+      cluster.next_primary.with_connection do |conn|
+        if cluster.replica_set? && !conn.features.transactions_enabled?
+          raise Mongo::Error::TransactionsNotSupported, "server version is < 4.0"
+        end
+        if cluster.sharded? && !conn.features.sharded_transactions_enabled?
+          raise Mongo::Error::TransactionsNotSupported, "sharded transactions require server version >= 4.2"
+        end
+      end
+    end
   end
 end

data/lib/mongo/uri.rb

@@ -377,10 +377,6 @@ module Mongo
         raise_invalid_error!("Options contain an unescaped question mark (?), or the database name contains a question mark and was not escaped")
       end
 
-      if options && !hosts_and_db.index('/')
-        raise_invalid_error!("MongoDB URI must have a slash (/) after the hosts if options are given")
-      end
-
       hosts, db = hosts_and_db.split('/', 2)
       if db && db.index('/')
         raise_invalid_error!("Database name contains an unescaped slash (/): #{db}")

data/lib/mongo/version.rb

@@ -20,5 +20,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.19.2'.freeze
+  VERSION = '2.20.0'.freeze
 end

data/lib/mongo.rb

@@ -64,6 +64,7 @@ require 'mongo/client_encryption'
 require 'mongo/dbref'
 require 'mongo/grid'
 require 'mongo/index'
+require 'mongo/search_index/view'
 require 'mongo/lint'
 require 'mongo/query_cache'
 require 'mongo/server'

data/mongo.gemspec

@@ -41,11 +41,5 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = ">= 2.5"
 
-  # For testing driver against bson master we need to depend on bson < 6.0.0
-  # but in release version we want to depend on bson < 5.0.0.
-  if %w(1 yes true).include?(ENV['MONGO_RUBY_DRIVER_BSON_MASTER'])
-    s.add_dependency 'bson', '>=4.13.0', '<6.0.0'
-  else
-    s.add_dependency 'bson', '>=4.14.1', '<5.0.0'
-  end
+  s.add_dependency 'bson', '>=4.14.1', '<6.0.0'
 end

data/spec/atlas/atlas_connectivity_spec.rb

@@ -7,21 +7,17 @@ describe 'Atlas connectivity' do
   let(:uri) { ENV['ATLAS_URI'] }
   let(:client) { Mongo::Client.new(uri) }
 
-  before do
-    if uri.nil?
-      skip "ATLAS_URI not set in environment"
-    end
-  end
+  require_atlas
 
   describe 'connection to Atlas' do
     it 'runs ismaster successfully' do
-      result = client.database.command(:ismaster => 1)
-      expect(result.documents.first['ismaster']).to be true
+      expect { client.database.command(:hello => 1) }
+        .not_to raise_error
     end
 
     it 'runs findOne successfully' do
-      result = client.use(:test)['test'].find.to_a
-      expect(result).to be_a(Array)
+      expect { client.use(:test)['test'].find.to_a }
+        .not_to raise_error
     end
   end
 end

data/spec/atlas/operations_spec.rb

@@ -7,11 +7,7 @@ describe 'Operations' do
   let(:uri) { ENV['ATLAS_URI'] }
   let(:client) { Mongo::Client.new(uri) }
 
-  before do
-    if uri.nil?
-      skip "ATLAS_URI not set in environment"
-    end
-  end
+  require_atlas
 
   describe 'ping' do
     it 'works' do

data/spec/faas/ruby-sam-app/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gem "httparty"
+gem "mongo"
+
+group :test do
+  gem "test-unit"
+  gem "mocha"
+end

data/spec/faas/ruby-sam-app/mongodb/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gem "httparty"
+gem "mongo"

data/spec/faas/ruby-sam-app/mongodb/app.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'mongo'
+require 'json'
+
+class StatsAggregator
+
+  def initialize
+    @open_connections = 0
+    @heartbeats_count = 0
+    @total_heartbeat_time = 0
+    @commands_count = 0
+    @total_command_time = 0
+  end
+
+  def add_command(duration)
+    @commands_count += 1
+    @total_command_time += duration
+  end
+
+  def add_heartbeat(duration)
+    @heartbeats_count += 1
+    @total_heartbeat_time += duration
+  end
+
+  def add_connection
+    @open_connections += 1
+  end
+
+  def remove_connection
+    @open_connections -= 1
+  end
+
+  def average_heartbeat_time
+    if @heartbeats_count == 0
+      0
+    else
+      @total_heartbeat_time / @heartbeats_count
+    end
+  end
+
+  def average_command_time
+    if @commands_count == 0
+      0
+    else
+      @total_command_time / @commands_count
+    end
+  end
+
+  def reset
+    @open_connections = 0
+    @heartbeats_count = 0
+    @total_heartbeat_time = 0
+    @commands_count = 0
+    @total_command_time = 0
+  end
+
+  def result
+    {
+      average_heartbeat_time: average_heartbeat_time,
+      average_command_time: average_command_time,
+      heartbeats_count: @heartbeats_count,
+      open_connections: @open_connections,
+    }
+  end
+end
+
+class CommandMonitor
+
+  def initialize(stats_aggregator)
+    @stats_aggregator = stats_aggregator
+  end
+
+  def started(event); end
+
+  def failed(event)
+    @stats_aggregator.add_command(event.duration)
+  end
+
+  def succeeded(event)
+    @stats_aggregator.add_command(event.duration)
+  end
+end
+
+class HeartbeatMonitor
+
+  def initialize(stats_aggregator)
+    @stats_aggregator = stats_aggregator
+  end
+
+  def started(event); end
+
+  def succeeded(event)
+    @stats_aggregator.add_heartbeat(event.duration)
+  end
+
+  def failed(event)
+    @stats_aggregator.add_heartbeat(event.duration)
+  end
+end
+
+class PoolMonitor
+
+  def initialize(stats_aggregator)
+    @stats_aggregator = stats_aggregator
+  end
+
+  def published(event)
+    case event
+    when Mongo::Monitoring::Event::Cmap::ConnectionCreated
+      @stats_aggregator.add_connection
+    when Mongo::Monitoring::Event::Cmap::ConnectionClosed
+      @stats_aggregator.remove_connection
+    end
+  end
+end
+
+$stats_aggregator = StatsAggregator.new
+
+command_monitor = CommandMonitor.new($stats_aggregator)
+heartbeat_monitor = HeartbeatMonitor.new($stats_aggregator)
+pool_monitor = PoolMonitor.new($stats_aggregator)
+
+sdam_proc = proc do |client|
+  client.subscribe(Mongo::Monitoring::COMMAND, command_monitor)
+  client.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, heartbeat_monitor)
+  client.subscribe(Mongo::Monitoring::CONNECTION_POOL, pool_monitor)
+end
+
+puts 'Connecting'
+$client = Mongo::Client.new(ENV['MONGODB_URI'], sdam_proc: sdam_proc)
+# Populate the connection pool
+$client.use('lambda_test').database.list_collections
+puts 'Connected'
+
+def lambda_handler(event:, context:)
+  db = $client.use('lambda_test')
+  collection = db[:test_collection]
+  result = collection.insert_one({ name: 'test' })
+  collection.delete_one({ _id: result.inserted_id })
+  response = $stats_aggregator.result.to_json
+  $stats_aggregator.reset
+  puts "Response: #{response}"
+
+  {
+    statusCode: 200,
+    body: response
+  }
+end

data/spec/faas/ruby-sam-app/template.yaml

@@ -0,0 +1,48 @@
+AWSTemplateFormatVersion: '2010-09-09'
+Transform: AWS::Serverless-2016-10-31
+Description: >
+  Sample SAM Template for ruby-sam-app
+
+# More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
+Globals:
+  Function:
+    Timeout: 30
+    MemorySize: 128
+
+Parameters:
+  MongoDbUri:
+    Type: String
+    Description: The MongoDB connection string.
+
+Resources:
+  MongoDBFunction:
+    Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
+    Properties:
+      CodeUri: mongodb/
+      Environment:
+        Variables:
+          MONGODB_URI: !Ref MongoDbUri
+      Handler: app.lambda_handler
+      Runtime: ruby3.2
+      Architectures:
+        - x86_64
+      Events:
+        MongoDB:
+          Type: Api # More info about API Event Source: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
+          Properties:
+            Path: /mongodb
+            Method: get
+
+Outputs:
+  # ServerlessRestApi is an implicit API created out of Events key under Serverless::Function
+  # Find out more about other implicit resources you can reference within SAM
+  # https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api
+  MongoDBApi:
+    Description: "API Gateway endpoint URL for Prod stage for MongoDB function"
+    Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/mongodb/"
+  MongoDBFunction:
+    Description: "MongoDB Lambda Function ARN"
+    Value: !GetAtt MongoDBFunction.Arn
+  MongoDBFunctionIamRole:
+    Description: "Implicit IAM Role created for MongoDB function"
+    Value: !GetAtt MongoDBFunctionRole.Arn

data/spec/integration/client_side_encryption/corpus_spec.rb

@@ -188,6 +188,15 @@ describe 'Client-Side Encryption' do
       key_vault_collection.insert_one(kmip_data_key)
     end
 
+    # This method compensates for an API change between BSON 4 and
+    # BSON 5.
+    def normalize_cse_value(a)
+      case a
+      when BSON::Decimal128 then a.to_d
+      else a
+      end
+    end
+
     shared_context 'with jsonSchema collection validator' do
       let(:local_schema_map) { nil }
 
@@ -228,12 +237,11 @@ describe 'Client-Side Encryption' do
           .find(_id: corpus_encrypted_id)
           .first
 
-
         corpus_encrypted_actual.each do |key, value|
           # If it was deterministically encrypted, test the encrypted values
           # for equality.
           if value['algo'] == 'det'
-            expect(value['value']).to eq(corpus_encrypted_expected[key]['value'])
+            expect(normalize_cse_value(value['value'])).to eq(normalize_cse_value(corpus_encrypted_expected[key]['value']))
           else
             # If the document was randomly encrypted, the two encrypted values
             # will not be equal. Ensure that they are equal when decrypted.

data/spec/integration/retryable_reads_errors_spec.rb

@@ -20,14 +20,14 @@ describe 'Retryable reads errors tests' do
 
     let(:failpoint) do
       {
-          configureFailPoint: "failCommand",
-          mode: { times: 1 },
-          data: {
-              failCommands: [ "find" ],
-              errorCode: 91,
-              blockConnection: true,
-              blockTimeMS: 1000
-          }
+        configureFailPoint: "failCommand",
+        mode: { times: 1 },
+        data: {
+          failCommands: [ "find" ],
+          errorCode: 91,
+          blockConnection: true,
+          blockTimeMS: 1000
+        }
       }
     end
 
@@ -107,4 +107,157 @@ describe 'Retryable reads errors tests' do
       })
     end
   end
+
+  context 'Retries in a sharded cluster' do
+    require_topology :sharded
+    min_server_version '4.2'
+    require_no_auth
+
+    let(:subscriber) { Mrss::EventSubscriber.new }
+
+    let(:find_started_events) do
+      subscriber.started_events.select { |e| e.command_name == "find" }
+    end
+
+    let(:find_failed_events) do
+      subscriber.failed_events.select { |e| e.command_name == "find" }
+    end
+
+    let(:find_succeeded_events) do
+      subscriber.succeeded_events.select { |e| e.command_name == "find" }
+    end
+
+    context 'when another mongos is available' do
+
+      let(:first_mongos) do
+        Mongo::Client.new(
+          [SpecConfig.instance.addresses.first],
+          direct_connection: true,
+          database: 'admin'
+        )
+      end
+
+      let(:second_mongos) do
+        Mongo::Client.new(
+          [SpecConfig.instance.addresses.last],
+          direct_connection: false,
+          database: 'admin'
+        )
+      end
+
+      let(:client) do
+        new_local_client(
+          [
+            SpecConfig.instance.addresses.first,
+            SpecConfig.instance.addresses.last,
+          ],
+          SpecConfig.instance.test_options.merge(retry_reads: true)
+        )
+      end
+
+      let(:expected_servers) do
+        [
+          SpecConfig.instance.addresses.first.to_s,
+          SpecConfig.instance.addresses.last.to_s
+        ].sort
+      end
+
+      before do
+        skip 'This test requires at least two mongos' if SpecConfig.instance.addresses.length < 2
+
+        first_mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: %w(find),
+            closeConnection: false,
+            errorCode: 6
+          }
+        )
+
+        second_mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: %w(find),
+            closeConnection: false,
+            errorCode: 6
+          }
+        )
+      end
+
+      after do
+        [first_mongos, second_mongos].each do |admin_client|
+          admin_client.database.command(
+            configureFailPoint: 'failCommand',
+            mode: 'off'
+          )
+          admin_client.close
+        end
+        client.close
+      end
+
+      it 'retries on different mongos' do
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        expect { collection.find.first }.to raise_error(Mongo::Error::OperationFailure)
+        expect(find_started_events.map { |e| e.address.to_s }.sort).to eq(expected_servers)
+        expect(find_failed_events.map { |e| e.address.to_s }.sort).to eq(expected_servers)
+      end
+    end
+
+    context 'when no other mongos is available' do
+      let(:mongos) do
+        Mongo::Client.new(
+          [SpecConfig.instance.addresses.first],
+          direct_connection: true,
+          database: 'admin'
+        )
+      end
+
+      let(:client) do
+        new_local_client(
+          [
+            SpecConfig.instance.addresses.first
+          ],
+          SpecConfig.instance.test_options.merge(retry_reads: true)
+        )
+      end
+
+      before do
+        mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: %w(find),
+            closeConnection: false,
+            errorCode: 6
+          }
+        )
+      end
+
+      after do
+        mongos.database.command(
+          configureFailPoint: 'failCommand',
+          mode: 'off'
+        )
+        mongos.close
+        client.close
+      end
+
+      it 'retries on the same mongos' do
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+        expect { collection.find.first }.not_to raise_error
+        expect(find_started_events.map { |e| e.address.to_s }.sort).to eq([
+          SpecConfig.instance.addresses.first.to_s,
+          SpecConfig.instance.addresses.first.to_s
+        ])
+        expect(find_failed_events.map { |e| e.address.to_s }.sort).to eq([
+          SpecConfig.instance.addresses.first.to_s
+        ])
+        expect(find_succeeded_events.map { |e| e.address.to_s }.sort).to eq([
+          SpecConfig.instance.addresses.first.to_s
+        ])
+      end
+    end
+  end
 end