mongo 2.4.3 → 2.5.0.beta

data/lib/mongo/session/server_session.rb

@@ -0,0 +1,73 @@
+# Copyright (C) 2017 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
+
+    # An object representing the server-side session.
+    #
+    # @api private
+    #
+    # @since 2.5.0
+    class ServerSession
+
+      # Regex for removing dashes from the UUID string.
+      #
+      # @since 2.5.0
+      DASH_REGEX = /\-/.freeze
+
+      # Pack directive for the UUID.
+      #
+      # @since 2.5.0
+      UUID_PACK = 'H*'.freeze
+
+      # The last time the server session was used.
+      #
+      # @since 2.5.0
+      attr_reader :last_use
+
+      # Initialize a ServerSession.
+      #
+      # @example
+      #   ServerSession.new
+      #
+      # @since 2.5.0
+      def initialize
+        set_last_use!
+      end
+
+      # Update the last_use attribute of the server session to now.
+      #
+      # @example Set the last use field to now.
+      #   server_session.set_last_use!
+      #
+      # @since 2.5.0
+      def set_last_use!
+        @last_use = Time.now
+      end
+
+      # The session id of this server session.
+      #
+      # @example Get the session id.
+      #   server_session.session_id
+      #
+      # @since 2.5.0
+      def session_id
+        @session_id ||= (bytes = [SecureRandom.uuid.gsub(DASH_REGEX, '')].pack(UUID_PACK)
+                          BSON::Document.new(id: BSON::Binary.new(bytes, :uuid)))
+      end
+    end
+  end
+end

data/lib/mongo/session/session_pool.rb

@@ -0,0 +1,161 @@
+# Copyright (C) 2017 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
+
+    # A pool of server sessions.
+    #
+    # @api private
+    #
+    # @since 2.5.0
+    class SessionPool
+
+      # The command sent to the server to end a session.
+      #
+      # @since 2.5.0
+      END_SESSION = { :endSessions => 1 }.freeze
+
+      # Create a SessionPool.
+      #
+      # @example
+      #   SessionPool.create(client)
+      #
+      # @param [ Mongo::Client ] client The client 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)
+      end
+
+      # Initialize a SessionPool.
+      #
+      # @example
+      #   SessionPool.new(client)
+      #
+      # @param [ Mongo::Client ] client The client that will be associated with this
+      #   session pool.
+      #
+      # @since 2.5.0
+      def initialize(client)
+        @queue = []
+        @mutex = Mutex.new
+        @client = client
+      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
+        result = yield(server_session)
+        result
+      ensure
+        begin; checkin(server_session) if server_session; rescue; end
+      end
+
+      # Checkout a server session from the pool.
+      #
+      # @example Checkout a session.
+      #   pool.checkout
+      #
+      # @return [ ServerSession ] The server session.
+      #
+      # @since 2.5.0
+      def checkout
+        @mutex.synchronize do
+          loop do
+            if @queue.empty?
+              return ServerSession.new
+            else
+              session = @queue.shift
+              unless about_to_expire?(session)
+                return session
+              end
+            end
+          end
+        end
+      end
+
+      # Checkin a server session to the pool.
+      #
+      # @example Checkin a session.
+      #   pool.checkin(session)
+      #
+      # @param [ Session::ServerSession ] The session to checkin.
+      #
+      # @since 2.5.0
+      def checkin(session)
+        @mutex.synchronize do
+          prune!
+          unless about_to_expire?(session)
+            @queue.unshift(session)
+          end
+        end
+      end
+
+      # End all sessions in the pool by sending the endSessions command to the server.
+      #
+      # @example End all sessions.
+      #   pool.end_sessions
+      #
+      # @since 2.5.0
+      def end_sessions
+        if @client
+          ids = @queue.collect { |s| s.session_id }
+
+          while !ids.empty?
+            begin
+              Operation::Commands::Command.new({
+                                                 :selector => END_SESSION.merge(ids: ids.shift(10_000)),
+                                                 :db_name => Database::ADMIN
+                                               }).execute(@client.cluster.next_primary)
+            rescue
+            end
+          end
+        end
+      end
+
+      private
+
+      def about_to_expire?(session)
+        if @client.logical_session_timeout
+          idle_time_minutes = (Time.now - session.last_use) / 60
+          (idle_time_minutes + 1) >= @client.logical_session_timeout
+        end
+      end
+
+      def prune!
+        while !@queue.empty?
+          if about_to_expire?(@queue[-1])
+            @queue.pop
+          else
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/uri.rb

@@ -395,6 +395,8 @@ module Mongo
 
     # Client Options
     uri_option 'appname', :app_name
+    uri_option 'compressors', :compressors, :type => :array
+    uri_option 'zlibcompressionlevel', :zlib_compression_level
 
     # Casts option values that do not have a specifically provided
     # transformation to the appropriate type.
@@ -572,5 +574,14 @@ module Mongo
         set.merge(decode(k).downcase.to_sym => decode(v))
       end
     end
+
+    # Extract values from the string and put them into an array.
+    #
+    # @param [ String ] value The string to build an array from.
+    #
+    # @return [ Array ] The array built from the string.
+    def array(value)
+      value.split(',')
+    end
   end
 end

data/lib/mongo/version.rb

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

data/mongo.gemspec

@@ -29,5 +29,6 @@ Gem::Specification.new do |s|
   s.require_paths     = ['lib']
   s.bindir            = 'bin'
 
-  s.add_dependency 'bson', '>=4.2.1', '<5.0.0'
+  #s.add_dependency 'bson', '>=4.3.0', '<5.0.0'
+  s.add_dependency 'bson', '4.3.0.beta'
 end

data/spec/mongo/auth/cr_spec.rb

@@ -18,6 +18,8 @@ describe Mongo::Auth::CR do
     double('cluster').tap do |cl|
       allow(cl).to receive(:topology).and_return(topology)
       allow(cl).to receive(:app_metadata).and_return(app_metadata)
+      allow(cl).to receive(:cluster_time).and_return(nil)
+      allow(cl).to receive(:update_cluster_time)
     end
   end
 
@@ -58,6 +60,16 @@ describe Mongo::Auth::CR do
           cr.login(connection)
         }.to raise_error(Mongo::Auth::Unauthorized)
       end
+
+      context 'when compression is used', if: testing_compression? do
+
+        it 'does not compress the message' do
+          expect(Mongo::Protocol::Compressed).not_to receive(:new)
+          expect {
+            cr.login(connection)
+          }.to raise_error(Mongo::Auth::Unauthorized)
+        end
+      end
     end
   end
 

data/spec/mongo/auth/ldap_spec.rb

@@ -18,6 +18,8 @@ describe Mongo::Auth::LDAP do
     double('cluster').tap do |cl|
       allow(cl).to receive(:topology).and_return(topology)
       allow(cl).to receive(:app_metadata).and_return(app_metadata)
+      allow(cl).to receive(:cluster_time).and_return(nil)
+      allow(cl).to receive(:update_cluster_time)
     end
   end
 

data/spec/mongo/auth/scram/conversation_spec.rb

@@ -48,7 +48,7 @@ describe Mongo::Auth::SCRAM::Conversation do
   describe '#continue' do
 
     let(:reply) do
-      Mongo::Protocol::Reply.new
+      Mongo::Protocol::Message.new
     end
 
     let(:documents) do
@@ -62,7 +62,7 @@ describe Mongo::Auth::SCRAM::Conversation do
 
     before do
       expect(SecureRandom).to receive(:base64).once.and_return('NDA2NzU3MDY3MDYwMTgy')
-      reply.instance_variable_set(:@documents, documents)
+      allow(reply).to receive(:documents).and_return(documents)
     end
 
     context 'when the server rnonce starts with the nonce' do
@@ -115,7 +115,7 @@ describe Mongo::Auth::SCRAM::Conversation do
   describe '#finalize' do
 
     let(:continue_reply) do
-      Mongo::Protocol::Reply.new
+      Mongo::Protocol::Message.new
     end
 
     let(:continue_documents) do
@@ -134,7 +134,7 @@ describe Mongo::Auth::SCRAM::Conversation do
     end
 
     let(:reply) do
-      Mongo::Protocol::Reply.new
+      Mongo::Protocol::Message.new
     end
 
     let(:documents) do
@@ -148,8 +148,8 @@ describe Mongo::Auth::SCRAM::Conversation do
 
     before do
       expect(SecureRandom).to receive(:base64).once.and_return('NDA2NzU3MDY3MDYwMTgy')
-      continue_reply.instance_variable_set(:@documents, continue_documents)
-      reply.instance_variable_set(:@documents, documents)
+      allow(continue_reply).to receive(:documents).and_return(continue_documents)
+      allow(reply).to receive(:documents).and_return(documents)
     end
 
     context 'when the verifier matches the server signature' do

data/spec/mongo/auth/scram_spec.rb

@@ -18,6 +18,8 @@ describe Mongo::Auth::SCRAM do
     double('cluster').tap do |cl|
       allow(cl).to receive(:topology).and_return(topology)
       allow(cl).to receive(:app_metadata).and_return(app_metadata)
+      allow(cl).to receive(:cluster_time).and_return(nil)
+      allow(cl).to receive(:update_cluster_time)
     end
   end
 
@@ -54,6 +56,16 @@ describe Mongo::Auth::SCRAM do
           cr.login(connection)
         }.to raise_error(Mongo::Auth::Unauthorized)
       end
+
+      context 'when compression is used', if: testing_compression? do
+
+        it 'does not compress the message' do
+          expect(Mongo::Protocol::Compressed).not_to receive(:new)
+          expect {
+            cr.login(connection)
+          }.to raise_error(Mongo::Auth::Unauthorized)
+        end
+      end
     end
   end
 
@@ -67,8 +79,20 @@ describe Mongo::Auth::SCRAM do
       cr.login(connection).documents[0]
     end
 
-    it 'logs the user into the connection', if: list_command_enabled? do
+    after do
+      root_user.instance_variable_set(:@client_key, nil)
+    end
+
+    it 'logs the user into the connection and caches the client key', if: list_command_enabled? do
       expect(login['ok']).to eq(1)
+      expect(root_user.send(:client_key)).not_to be_nil
+    end
+
+    it 'raises an exception when an incorrect client key is set', if: list_command_enabled? do
+      root_user.instance_variable_set(:@client_key, "incorrect client key")
+      expect {
+        cr.login(connection)
+      }.to raise_error(Mongo::Auth::Unauthorized)
     end
   end
 end

data/spec/mongo/auth/user/view_spec.rb

@@ -6,33 +6,67 @@ describe Mongo::Auth::User::View do
     described_class.new(root_authorized_client.database)
   end
 
+  after do
+    begin; view.remove('durran'); rescue; end
+  end
+
   describe '#create' do
 
-    let!(:response) do
-      view.create(
-        'durran',
-        password: 'password', roles: [ Mongo::Auth::Roles::READ_WRITE ]
-      )
-    end
+    context 'when a session is not used' do
 
-    after do
-      view.remove('durran')
-    end
+      let!(:response) do
+        view.create(
+            'durran',
+            password: 'password', roles: [Mongo::Auth::Roles::READ_WRITE]
+        )
+      end
 
-    context 'when user creation was successful' do
+      context 'when user creation was successful' do
 
-      it 'saves the user in the database' do
-        expect(response).to be_successful
+        it 'saves the user in the database' do
+          expect(response).to be_successful
+        end
+
+        context 'when compression is used', if: testing_compression? do
+
+          it 'does not compress the message' do
+            # The dropUser command message will be compressed, so expect instantiation once.
+            expect(Mongo::Protocol::Compressed).to receive(:new).once.and_call_original
+            expect(response).to be_successful
+          end
+        end
+      end
+
+      context 'when creation was not successful' do
+
+        it 'raises an exception' do
+          expect {
+            view.create('durran', password: 'password')
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
       end
     end
 
-    context 'when creation was not successful' do
+    context 'when a session is used' do
+
+      let(:operation) do
+        view.create(
+            'durran',
+            password: 'password',
+            roles: [Mongo::Auth::Roles::READ_WRITE],
+            session: session
+        )
+      end
 
-      it 'raises an exception' do
-        expect {
-          view.create('durran', password: 'password')
-        }.to raise_error(Mongo::Error::OperationFailure)
+      let(:session) do
+        client.start_session
       end
+
+      let(:client) do
+        root_authorized_client
+      end
+
+      it_behaves_like 'an operation using a session'
     end
   end
 
@@ -41,114 +75,272 @@ describe Mongo::Auth::User::View do
     before do
       view.create(
           'durran',
-          password: 'password', roles: [ Mongo::Auth::Roles::READ_WRITE ]
+          password: 'password', roles: [Mongo::Auth::Roles::READ_WRITE]
       )
     end
 
-    after do
-      view.remove('durran')
-    end
-
     context 'when a user password is updated' do
 
-      let!(:response) do
-        view.update(
-            'durran',
-            password: '123', roles: [ Mongo::Auth::Roles::READ_WRITE ]
-        )
+      context 'when a session is not used' do
+
+        let!(:response) do
+          view.update(
+              'durran',
+              password: '123', roles: [ Mongo::Auth::Roles::READ_WRITE ]
+          )
+        end
+
+        it 'updates the password' do
+          expect(response).to be_successful
+        end
+
+        context 'when compression is used', if: testing_compression? do
+
+          it 'does not compress the message' do
+            # The dropUser command message will be compressed, so expect instantiation once.
+            expect(Mongo::Protocol::Compressed).to receive(:new).once.and_call_original
+            expect(response).to be_successful
+          end
+        end
       end
 
-      it 'updates the password' do
-        expect(response).to be_successful
+      context 'when a session is used' do
+
+        let(:operation) do
+          view.update(
+              'durran',
+              password: '123',
+              roles: [ Mongo::Auth::Roles::READ_WRITE ],
+              session: session
+          )
+        end
+
+        let(:session) do
+          client.start_session
+        end
+
+        let(:client) do
+          root_authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
       end
     end
 
     context 'when the roles of a user are updated' do
 
-      let!(:response) do
-        view.update(
-            'durran',
-            password: 'password', roles: [ Mongo::Auth::Roles::READ ]
-        )
+      context 'when a session is not used' do
+
+        let!(:response) do
+          view.update(
+              'durran',
+              password: 'password', roles: [ Mongo::Auth::Roles::READ ]
+          )
+        end
+
+        it 'updates the roles' do
+          expect(response).to be_successful
+        end
+
+        context 'when compression is used', if: testing_compression? do
+
+          it 'does not compress the message' do
+            # The dropUser command message will be compressed, so expect instantiation once.
+            expect(Mongo::Protocol::Compressed).to receive(:new).once.and_call_original
+            expect(response).to be_successful
+          end
+        end
       end
 
-      it 'updates the roles' do
-        expect(response).to be_successful
+      context 'when a session is used' do
+
+        let(:operation) do
+          view.update(
+              'durran',
+              password: 'password',
+              roles: [ Mongo::Auth::Roles::READ ],
+              session: session
+          )
+        end
+
+        let(:session) do
+          client.start_session
+        end
+
+        let(:client) do
+          root_authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
       end
     end
   end
 
   describe '#remove' do
 
-    context 'when user removal was successful' do
+    context 'when a session is not used' do
 
-      before do
-        view.create(
-          'durran',
-          password: 'password', roles: [ Mongo::Auth::Roles::READ_WRITE ]
-        )
-      end
+      context 'when user removal was successful' do
 
-      let(:response) do
-        view.remove('durran')
+        before do
+          view.create(
+              'durran',
+              password: 'password', roles: [ Mongo::Auth::Roles::READ_WRITE ]
+          )
+        end
+
+        let(:response) do
+          view.remove('durran')
+        end
+
+        it 'saves the user in the database' do
+          expect(response).to be_successful
+        end
       end
 
-      it 'saves the user in the database' do
-        expect(response).to be_successful
+      context 'when removal was not successful' do
+
+        it 'raises an exception', if: write_command_enabled? do
+          expect {
+            view.remove('notauser')
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
+
+        it 'does not raise an exception', unless: write_command_enabled? do
+          expect(view.remove('notauser').written_count).to eq(0)
+        end
       end
     end
 
-    context 'when removal was not successful' do
+    context 'when a session is used' do
+
+      context 'when user removal was successful' do
 
-      it 'raises an exception', if: write_command_enabled? do
-        expect {
-          view.remove('notauser')
-        }.to raise_error(Mongo::Error::OperationFailure)
+        before do
+          view.create(
+              'durran',
+              password: 'password', roles: [ Mongo::Auth::Roles::READ_WRITE ]
+          )
+        end
+
+        let(:operation) do
+          view.remove('durran', session: session)
+        end
+
+        let(:session) do
+          client.start_session
+        end
+
+        let(:client) do
+          root_authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
       end
 
-      it 'does not raise an exception', unless: write_command_enabled? do
-        expect(view.remove('notauser').written_count).to eq(0)
+      context 'when removal was not successful' do
+
+        let(:failed_operation) do
+          view.remove('notauser', session: session)
+        end
+
+        let(:session) do
+          client.start_session
+        end
+
+        let(:client) do
+          root_authorized_client
+        end
+
+        it_behaves_like 'a failed operation using a session'
       end
     end
   end
 
   describe '#info' do
 
-    context 'when a user exists in the database' do
+    context 'when a session is not used' do
 
-      before do
-        view.create(
-            'emily',
-            password: 'password'
-        )
-      end
+      context 'when a user exists in the database' do
+
+        before do
+          view.create(
+              'emily',
+              password: 'password'
+          )
+        end
+
+        after do
+          view.remove('emily')
+        end
 
-      after do
-        view.remove('emily')
+        it 'returns information for that user' do
+          expect(view.info('emily')).to_not be_empty
+        end
       end
 
-      it 'returns information for that user' do
-        expect(view.info('emily')).to_not be_empty
+      context 'when a user does not exist in the database' do
+
+        it 'returns nil' do
+          expect(view.info('emily')).to be_empty
+        end
       end
-    end
 
-    context 'when a user does not exist in the database' do
+      context 'when a user is not authorized' do
 
-      it 'returns nil' do
-        expect(view.info('emily')).to be_empty
+        let(:view) do
+          described_class.new(unauthorized_client.database)
+        end
+
+        it 'raises an OperationFailure', if: auth_enabled? do
+          expect{
+            view.info('emily')
+          }.to raise_exception(Mongo::Error::OperationFailure)
+        end
       end
     end
 
-    context 'when a user is not authorized' do
+    context 'when a session is used' do
+
+      context 'when a user exists in the database' do
+
+        before do
+          view.create(
+              'durran',
+              password: 'password'
+          )
+        end
+
+        let(:operation) do
+          view.info('durran', session: session)
+        end
+
+        let(:session) do
+          client.start_session
+        end
 
-      let(:view) do
-        described_class.new(unauthorized_client.database)
+        let(:client) do
+          root_authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
       end
 
-      it 'raises an OperationFailure', if: auth_enabled? do
-        expect{
-          view.info('emily')
-        }.to raise_exception(Mongo::Error::OperationFailure)
+      context 'when a user does not exist in the database' do
+
+        let(:operation) do
+          view.info('emily', session: session)
+        end
+
+        let(:session) do
+          client.start_session
+        end
+
+        let(:client) do
+          root_authorized_client
+        end
+
+        it_behaves_like 'an operation using a session'
       end
     end
   end