mongo 2.5.0 → 2.5.1

data/lib/mongo/session/session_pool.rb

@@ -26,30 +26,30 @@ module Mongo
       # Create a SessionPool.
       #
       # @example
-      #   SessionPool.create(client)
+      #   SessionPool.create(cluster)
       #
-      # @param [ Mongo::Client ] client The client that will be associated with this
+      # @param [ Mongo::Cluster ] cluster The cluster that will be associated with this
       #   session pool.
       #
       # @since 2.5.0
-      def self.create(client)
-        pool = new(client)
-        client.instance_variable_set(:@session_pool, pool)
+      def self.create(cluster)
+        pool = new(cluster)
+        cluster.instance_variable_set(:@session_pool, pool)
       end
 
       # Initialize a SessionPool.
       #
       # @example
-      #   SessionPool.new(client)
+      #   SessionPool.new(cluster)
       #
-      # @param [ Mongo::Client ] client The client that will be associated with this
+      # @param [ Mongo::Cluster ] cluster The cluster that will be associated with this
       #   session pool.
       #
       # @since 2.5.0
-      def initialize(client)
+      def initialize(cluster)
         @queue = []
         @mutex = Mutex.new
-        @client = client
+        @cluster = cluster
       end
 
       # Get a formatted string for use in inspection.
@@ -64,24 +64,6 @@ module Mongo
         "#<Mongo::Session::SessionPool:0x#{object_id} current_size=#{@queue.size}>"
       end
 
-      # Checkout a session to be used in the context of a block and return the session back to
-      #   the pool after the block completes.
-      #
-      # @example Checkout, use a session, and return it back to the pool after the block.
-      #   pool.with_session do |session|
-      #     ...
-      #   end
-      #
-      # @yieldparam [ ServerSession ] The server session.
-      #
-      # @since 2.5.0
-      def with_session
-        server_session = checkout
-        yield(server_session)
-      ensure
-        begin; checkin(server_session) if server_session; rescue; end
-      end
-
       # Checkout a server session from the pool.
       #
       # @example Checkout a session.
@@ -130,7 +112,7 @@ module Mongo
       # @since 2.5.0
       def end_sessions
         while !@queue.empty?
-          server = ServerSelector.get(mode: :primary_preferred).select_server(@client.cluster)
+          server = ServerSelector.get(mode: :primary_preferred).select_server(@cluster)
           Operation::Commands::Command.new(
               :selector => {endSessions: @queue.shift(10_000).collect { |s| s.session_id }},
               :db_name => Database::ADMIN).execute(server)
@@ -141,9 +123,9 @@ module Mongo
       private
 
       def about_to_expire?(session)
-        if @client.logical_session_timeout
+        if @cluster.logical_session_timeout
           idle_time_minutes = (Time.now - session.last_use) / 60
-          (idle_time_minutes + 1) >= @client.logical_session_timeout
+          (idle_time_minutes + 1) >= @cluster.logical_session_timeout
         end
       end
 

data/lib/mongo/socket.rb

@@ -190,8 +190,32 @@ module Mongo
       defined?(UNIXSocket) && sock.is_a?(UNIXSocket)
     end
 
+    DEFAULT_TCP_KEEPINTVL = 10
+
+    DEFAULT_TCP_KEEPCNT = 9
+
+    DEFAULT_TCP_KEEPIDLE = 300
+
+    def set_keepalive_opts(sock)
+      sock.setsockopt(SOL_SOCKET, SO_KEEPALIVE, true)
+      set_option(sock, :TCP_KEEPINTVL, DEFAULT_TCP_KEEPINTVL)
+      set_option(sock, :TCP_KEEPCNT, DEFAULT_TCP_KEEPCNT)
+      set_option(sock, :TCP_KEEPIDLE, DEFAULT_TCP_KEEPIDLE)
+    rescue
+    end
+
+    def set_option(sock, option, default)
+      if Socket.const_defined?(option)
+        system_default = sock.getsockopt(IPPROTO_TCP, option).int
+        if system_default > default
+          sock.setsockopt(IPPROTO_TCP, option, default)
+        end
+      end
+    end
+
     def set_socket_options(sock)
       sock.set_encoding(BSON::BINARY)
+      set_keepalive_opts(sock)
     end
 
     def handle_errors

data/lib/mongo/socket/tcp.rb

@@ -43,7 +43,6 @@ module Mongo
       def connect!(connect_timeout = nil)
         Timeout.timeout(connect_timeout, Error::SocketTimeoutError) do
           socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
-          socket.setsockopt(SOL_SOCKET, SO_KEEPALIVE, true)
           handle_errors { socket.connect(::Socket.pack_sockaddr_in(port, host)) }
           self
         end

data/lib/mongo/uri.rb

@@ -84,6 +84,11 @@ module Mongo
     # @since 2.1.0
     UNSAFE = /[\:\/\+\@]/
 
+    # Percent sign that must be encoded in user creds.
+    #
+    # @since 2.5.1
+    PERCENT_CHAR = /\%/
+
     # Unix socket suffix.
     #
     # @since 2.1.0
@@ -334,15 +339,27 @@ module Mongo
 
     def parse_user!(string)
       if (string && user = string.partition(AUTH_USER_PWD_DELIM)[0])
-        raise_invalid_error!(UNESCAPED_USER_PWD) if user =~ UNSAFE
-        decode(user) if user.length > 0
+        if user.length > 0
+          raise_invalid_error!(UNESCAPED_USER_PWD) if user =~ UNSAFE
+          user_decoded = decode(user)
+          if user_decoded =~ PERCENT_CHAR && encode(user_decoded) != user
+            raise_invalid_error!(UNESCAPED_USER_PWD)
+          end
+          user_decoded
+        end
       end
     end
 
     def parse_password!(string)
       if (string && pwd = string.partition(AUTH_USER_PWD_DELIM)[2])
-        raise_invalid_error!(UNESCAPED_USER_PWD) if pwd =~ UNSAFE
-        decode(pwd) if pwd.length > 0
+        if pwd.length > 0
+          raise_invalid_error!(UNESCAPED_USER_PWD) if pwd =~ UNSAFE
+          pwd_decoded = decode(pwd)
+          if pwd_decoded =~ PERCENT_CHAR && encode(pwd_decoded) != pwd
+            raise_invalid_error!(UNESCAPED_USER_PWD)
+          end
+          pwd_decoded
+        end
       end
     end
 
@@ -382,7 +399,11 @@ module Mongo
     end
 
     def decode(value)
-      ::URI::DEFAULT_PARSER.unescape(value)
+      ::URI.decode(value)
+    end
+
+    def encode(value)
+      ::URI.encode(value)
     end
 
     # Hash for storing map of URI option parameters to conversion strategies

data/lib/mongo/version.rb

@@ -17,5 +17,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.5.0'.freeze
+  VERSION = '2.5.1'.freeze
 end

data/spec/mongo/address_spec.rb

@@ -214,13 +214,22 @@ describe Mongo::Address do
       address.host
     end
 
+    let(:addr_info) do
+      family = (host == 'localhost') ? ::Socket::AF_INET : ::Socket::AF_UNSPEC
+      ::Socket.getaddrinfo(host, nil, family, ::Socket::SOCK_STREAM)
+    end
+
+    let(:socket_address_or_host) do
+      (host == 'localhost') ? addr_info.first[3] : host
+    end
+
     context 'when providing a DNS entry that resolves to both IPv6 and IPv4' do
 
       before do
         address.instance_variable_set(:@resolver, nil)
         allow(::Socket).to receive(:getaddrinfo).and_return(
           [ ["AF_INET6", 0, '::1', '::1', ::Socket::AF_INET6, 1, 6],
-            ["AF_INET", 0, host, host, ::Socket::AF_INET, 1, 6]]
+            ["AF_INET", 0, socket_address_or_host, socket_address_or_host, ::Socket::AF_INET, 1, 6]]
         )
       end
 
@@ -237,7 +246,33 @@ describe Mongo::Address do
       end
 
       it 'uses the host, not the IP address' do
-        expect(address.socket(0.0).host).to eq(host)
+        expect(address.socket(0.0).host).to eq(socket_address_or_host)
+      end
+
+      let(:socket) do
+        if running_ssl?
+          address.socket(0.0, SSL_OPTIONS).instance_variable_get(:@tcp_socket)
+        else
+          address.socket(0.0).instance_variable_get(:@socket)
+        end
+      end
+
+      if Socket.const_defined?(:TCP_KEEPINTVL)
+        it 'sets the socket TCP_KEEPINTVL option' do
+          expect(socket.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPINTVL).int).to be <= 10
+        end
+      end
+
+      if Socket.const_defined?(:TCP_KEEPCNT)
+        it 'sets the socket TCP_KEEPCNT option' do
+          expect(socket.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPCNT).int).to be <= 9
+        end
+      end
+
+      if Socket.const_defined?(:TCP_KEEPIDLE)
+        it 'sets the socket TCP_KEEPIDLE option' do
+          expect(socket.getsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPIDLE).int).to be <= 300
+        end
       end
     end
   end

data/spec/mongo/bulk_write_spec.rb

@@ -1889,32 +1889,26 @@ describe Mongo::BulkWrite do
             it_behaves_like 'an operation using a session'
           end
 
-          context 'when retryable writes are supported', if: (sessions_enabled? && (replica_set? || sharded?)) do
+          context 'when retryable writes are supported', if: test_sessions? do
 
             let(:client) do
-              authorized_client.with(heartbeat_frequency: 100, retry_writes: true).tap do |cl|
-                cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-              end
+              authorized_client_with_retry_writes
             end
 
             let(:collection) do
               client[authorized_collection.name]
             end
 
-            let(:subscriber) do
-              EventSubscriber.new
-            end
-
             let!(:result) do
               bulk_write.execute
             end
 
             let(:first_txn_number) do
-              subscriber.started_events[-2].command['txnNumber'].instance_variable_get(:@integer)
+              EventSubscriber.started_events[-2].command['txnNumber'].instance_variable_get(:@integer)
             end
 
             let(:second_txn_number) do
-              subscriber.started_events[-1].command['txnNumber'].instance_variable_get(:@integer)
+              EventSubscriber.started_events[-1].command['txnNumber'].instance_variable_get(:@integer)
             end
 
             it 'inserts the documents' do

data/spec/mongo/change_stream_examples_spec.rb

@@ -147,4 +147,44 @@ describe 'change streams examples in Ruby', if: test_change_streams? do
       resumed_change.each { |key| expect(resumed_change[key]).to eq(next_next_change[key]) }
     end
   end
+
+  context 'example 4 - using a pipeline to filter changes' do
+
+    it 'returns the filtered changes' do
+
+      ops_thread = Thread.new do
+        sleep 2
+        inventory.insert_one(username: 'wallace')
+        inventory.insert_one(username: 'alice')
+        inventory.delete_one(username: 'wallace')
+      end
+
+      stream_thread = Thread.new do
+
+        # Start Changestream Example 4
+
+        pipeline = [ {'$match' => { '$or' => [{ 'fullDocument.username' => 'alice' },
+                                              { 'operationType' => 'delete' }] } }]
+        cursor = inventory.watch(pipeline).to_enum
+        cursor.next
+
+        # End Changestream Example 4
+      end
+
+      ops_thread.value
+      change = stream_thread.value
+
+      expect(change['_id']).not_to be_nil
+      expect(change['_id']['_data']).not_to be_nil
+      expect(change['operationType']).to eq('insert')
+      expect(change['fullDocument']).not_to be_nil
+      expect(change['fullDocument']['_id']).not_to be_nil
+      expect(change['fullDocument']['username']).to eq('alice')
+      expect(change['ns']).not_to be_nil
+      expect(change['ns']['db']).to eq(TEST_DB)
+      expect(change['ns']['coll']).to eq(inventory.name)
+      expect(change['documentKey']).not_to be_nil
+      expect(change['documentKey']['_id']).to eq(change['fullDocument']['_id'])
+    end
+  end
 end

data/spec/mongo/client_spec.rb

@@ -228,6 +228,10 @@ describe Mongo::Client do
           described_class.new([default_address.seed], authorized_client.options.merge(options))
         end
 
+        after do
+          client.close
+        end
+
         it 'sets the option' do
           expect(client.options['retry_writes']).to eq(options[:retry_writes])
         end
@@ -632,7 +636,7 @@ describe Mongo::Client do
 
     context 'when providing a connection string' do
 
-      context 'when the string uses the SRV Protocol' do
+      context 'when the string uses the SRV Protocol', if: test_connecting_externally? do
 
         let!(:uri) do
           'mongodb+srv://test5.test.build.10gen.cc/testdb'
@@ -1356,24 +1360,23 @@ describe Mongo::Client do
       end
 
       let(:client) do
-        # Monitoring subscribers won't be set up when using Client#with, so a new client must be created.
         Mongo::Client.new(ADDRESSES, client_options).tap do |cl|
-          cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+          cl.subscribe(Mongo::Monitoring::COMMAND, EventSubscriber.clear_events!)
         end
       end
 
-      let(:subscriber) do
-        EventSubscriber.new
-      end
-
       let(:command) do
-        subscriber.started_events.find { |c| c.command_name == :listDatabases }.command
+        EventSubscriber.started_events.find { |c| c.command_name == :listDatabases }.command
       end
 
       before do
         client.list_databases({}, true)
       end
 
+      after do
+        client.close
+      end
+
       it 'sends the command with the nameOnly flag set to true' do
         expect(command[:nameOnly]).to be(true)
       end
@@ -1503,7 +1506,7 @@ describe Mongo::Client do
       context 'when options are provided' do
 
         let(:options) do
-          { causally_consistent: true }
+          { causal_consistency: true }
         end
 
         let(:session) do
@@ -1511,14 +1514,14 @@ describe Mongo::Client do
         end
 
         it 'sets the options on the session' do
-          expect(session.options).to eq(options)
+          expect(session.options[:causal_consistency]).to eq(options[:causal_consistency])
         end
       end
 
       context 'when options are not provided' do
 
         it 'does not set options on the session' do
-          expect(session.options).to be_empty
+          expect(session.options).to eq({ implicit: false })
         end
       end
 
@@ -1567,7 +1570,7 @@ describe Mongo::Client do
         end
 
         let(:pool) do
-          authorized_client.instance_variable_get(:@session_pool)
+          authorized_client.cluster.session_pool
         end
 
         let!(:before_last_use) do
@@ -1581,6 +1584,38 @@ describe Mongo::Client do
       end
     end
 
+    context 'when two clients have the same cluster', if: test_sessions? do
+
+      let(:client) do
+        authorized_client.with(read: { mode: :secondary })
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      it 'allows the session to be used across the clients' do
+        client[TEST_COLL].insert_one({ a: 1 }, session: session)
+      end
+    end
+
+    context 'when two clients have different clusters', if: test_sessions? do
+
+      let(:client) do
+        authorized_client_with_retry_writes
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      it 'raises an exception' do
+        expect {
+          client[TEST_COLL].insert_one({ a: 1 }, session: session)
+        }.to raise_exception(Mongo::Error::InvalidSession)
+      end
+    end
+
     context 'when sessions are not supported', unless: sessions_enabled? do
 
       it 'raises an exception' do