mongo 1.12.5 → 2.0.0

data/lib/mongo/server/connection.rb

@@ -0,0 +1,134 @@
+# Copyright (C) 2014-2015 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 Server
+
+    # This class models the socket connections for servers and their behavior.
+    #
+    # @since 2.0.0
+    class Connection
+      include Connectable
+      extend Forwardable
+
+      # @return [ Mongo::Auth::CR, Mongo::Auth::X509, Mongo::Auth:LDAP ]
+      #   authenticator The authentication strategy.
+      attr_reader :authenticator
+
+      def_delegators :@server,
+                     :features,
+                     :max_bson_object_size,
+                     :max_message_size,
+                     :mongos?
+
+      # Is this connection authenticated. Will return true if authorization
+      # details were provided and authentication passed.
+      #
+      # @example Is the connection authenticated?
+      #   connection.authenticated?
+      #
+      # @return [ true, false ] If the connection is authenticated.
+      #
+      # @since 2.0.0
+      def authenticated?
+        !!@authenticated
+      end
+
+      # Tell the underlying socket to establish a connection to the host.
+      #
+      # @example Connect to the host.
+      #   connection.connect!
+      #
+      # @note This method mutates the connection class by setting a socket if
+      #   one previously did not exist.
+      #
+      # @return [ true ] If the connection succeeded.
+      #
+      # @since 2.0.0
+      def connect!
+        unless socket
+          @socket = address.socket(timeout, ssl_options)
+          @socket.connect!
+          if authenticator
+            authenticator.login(self)
+            @authenticated = true
+          end
+        end
+        true
+      end
+
+      # Disconnect the connection.
+      #
+      # @example Disconnect from the host.
+      #   connection.disconnect!
+      #
+      # @note This method mutates the connection by setting the socket to nil
+      #   if the closing succeeded.
+      #
+      # @return [ true ] If the disconnect succeeded.
+      #
+      # @since 2.0.0
+      def disconnect!
+        if socket
+          socket.close
+          @socket = nil
+          @authenticated = false
+        end
+        true
+      end
+
+      # Initialize a new socket connection from the client to the server.
+      #
+      # @example Create the connection.
+      #   Connection.new(server)
+      #
+      # @param [ Mongo::Server ] server The server the connection is for.
+      # @param [ Hash ] options The connection options.
+      #
+      # @since 2.0.0
+      def initialize(server, options = {})
+        @address = server.address
+        @options = options.freeze
+        @server = server
+        @ssl_options = options.reject { |k, v| !k.to_s.start_with?('ssl') }
+        @socket = nil
+        @pid = Process.pid
+        setup_authentication!
+      end
+
+      private
+
+      def setup_authentication!
+        if options[:user]
+          default_mechanism = @server.features.scram_sha_1_enabled? ? :scram : :mongodb_cr
+          user = Auth::User.new({ :auth_mech => default_mechanism }.merge(options))
+          @authenticator = Auth.get(user)
+        end
+      end
+
+      def write(messages, buffer = '')
+        start_size = 0
+        messages.each do |message|
+          message.serialize(buffer, max_bson_object_size)
+          if max_message_size &&
+            (buffer.size - start_size) > max_message_size
+            raise Error::MaxMessageSize.new(max_message_size)
+            start_size = buffer.size
+          end
+        end
+        ensure_connected{ |socket| socket.write(buffer) }
+      end
+    end
+  end
+end

data/lib/mongo/server/connection_pool/queue.rb

@@ -0,0 +1,182 @@
+# Copyright (C) 2014-2015 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 Server
+    class ConnectionPool
+
+      # A FIFO queue of connections to be used by the connection pool. This is
+      # based on mperham's connection pool, implemented with a queue instead of a
+      # stack.
+      #
+      # @since 2.0.0
+      class Queue
+        extend Forwardable
+
+        # Size of the queue delegates to the wrapped queue.
+        def_delegators :queue, :size
+
+        # The default max size for the queue.
+        MAX_SIZE = 5.freeze
+
+        # The default min size for the queue.
+        MIN_SIZE = 1.freeze
+
+        # The default timeout, in seconds, to wait for a connection.
+        WAIT_TIMEOUT = 1.freeze
+
+        # @return [ Array ] queue The underlying array of connections.
+        attr_reader :queue
+
+        # @return [ Mutex ] mutex The mutex used for synchronization.
+        attr_reader :mutex
+
+        # @return [ Hash ] options The options.
+        attr_reader :options
+
+        # @return [ ConditionVariable ] resource The resource.
+        attr_reader :resource
+
+        # Dequeue a connection from the queue, waiting for the provided timeout
+        # for an item if none is in the queue.
+        #
+        # @example Dequeue a connection.
+        #   queue.dequeue
+        #
+        # @return [ Mongo::Pool::Connection ] The next connection.
+        #
+        # @since 2.0.0
+        def dequeue
+          mutex.synchronize do
+            dequeue_connection
+          end
+        end
+
+        # Enqueue a connection in the queue.
+        #
+        # @example Enqueue a connection.
+        #   queue.enqueue(connection)
+        #
+        # @param [ Mongo::Pool::Connection ] connection The connection.
+        #
+        # @since 2.0.0
+        def enqueue(connection)
+          mutex.synchronize do
+            queue.push(connection)
+            resource.broadcast
+          end
+        end
+
+        # Initialize the new queue. Will yield the block the number of times for
+        # the initial size of the queue.
+        #
+        # @example Create the queue.
+        #   Mongo::Pool::Queue.new(max_pool_size: 5) { Connection.new }
+        #
+        # @param [ Hash ] options The options.
+        #
+        # @option options [ Integer ] :max_pool_size The maximum size.
+        # @option options [ Integer ] :min_pool_size The minimum size.
+        # @option options [ Float ] :wait_queue_timeout The time to wait, in
+        #   seconds, for a free connection.
+        #
+        # @since 2.0.0
+        def initialize(options = {}, &block)
+          @block = block
+          @connections = 0
+          @options = options
+          @queue = Array.new(min_size, create_connection)
+          @mutex = Mutex.new
+          @resource = ConditionVariable.new
+        end
+
+        # Get a pretty printed string inspection for the queue.
+        #
+        # @example Inspect the queue.
+        #   queue.inspect
+        #
+        # @return [ String ] The queue inspection.
+        #
+        # @since 2.0.0
+        def inspect
+          "#<Mongo::Pool::Queue:0x#{object_id} min_size=#{min_size} max_size=#{max_size} " +
+            "wait_timeout=#{wait_timeout} current_size=#{queue.size}>"
+        end
+
+        # Get the maximum size of the queue.
+        #
+        # @example Get the max size.
+        #   queue.max_size
+        #
+        # @return [ Integer ] The maximum size of the queue.
+        #
+        # @since 2.0.0
+        def max_size
+          @max_size ||= options[:max_pool_size] || MAX_SIZE
+        end
+
+        # Get the minimum size of the queue.
+        #
+        # @example Get the min size.
+        #   queue.min_size
+        #
+        # @return [ Integer ] The minimum size of the queue.
+        #
+        # @since 2.0.0
+        def min_size
+          @min_size ||= options[:min_pool_size] || MIN_SIZE
+        end
+
+        # The time to wait, in seconds, for a connection to become available.
+        #
+        # @example Get the wait timeout.
+        #   queue.wait_timeout
+        #
+        # @return [ Float ] The queue wait timeout.
+        #
+        # @since 2.0.0
+        def wait_timeout
+          @wait_timeout ||= options[:wait_queue_timeout] || WAIT_TIMEOUT
+        end
+
+        private
+
+        def dequeue_connection
+          deadline = Time.now + wait_timeout
+          loop do
+            return queue.delete_at(0) unless queue.empty?
+            connection = create_connection
+            return connection if connection
+            wait_for_next!(deadline)
+          end
+        end
+
+        def create_connection
+          if @connections < max_size
+            @connections += 1
+            @block.call
+          end
+        end
+
+        def wait_for_next!(deadline)
+          wait = deadline - Time.now
+          if wait <= 0
+            raise Timeout::Error.new("Timed out attempting to dequeue connection after #{wait_timeout} sec.")
+          end
+          resource.wait(mutex, wait)
+        end
+      end
+    end
+  end
+end

data/lib/mongo/server/connection_pool.rb

@@ -0,0 +1,141 @@
+# Copyright (C) 2014-2015 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.
+
+require 'mongo/server/connection_pool/queue'
+
+module Mongo
+  class Server
+
+    # Represents a connection pool for server connections.
+    #
+    # @since 2.0.0
+    class ConnectionPool
+      include Loggable
+
+      # Used for synchronization of pools access.
+      MUTEX = Mutex.new
+
+      # @return [ Hash ] options The pool options.
+      attr_reader :options
+
+      # Check a connection back into the pool. Will pull the connection from a
+      # thread local stack that should contain it after it was checked out.
+      #
+      # @example Checkin the thread's connection to the pool.
+      #   pool.checkin
+      #
+      # @since 2.0.0
+      def checkin(connection)
+        queue.enqueue(connection)
+      end
+
+      # Check a connection out from the pool. If a connection exists on the same
+      # thread it will get that connection, otherwise it will dequeue a
+      # connection from the queue and pin it to this thread.
+      #
+      # @example Check a connection out from the pool.
+      #   pool.checkout
+      #
+      # @return [ Mongo::Pool::Connection ] The checked out connection.
+      #
+      # @since 2.0.0
+      def checkout
+        queue.dequeue
+      end
+
+      # Create the new connection pool.
+      #
+      # @example Create the new connection pool.
+      #   Pool.new(timeout: 0.5) do
+      #     Connection.new
+      #   end
+      #
+      # @note A block must be passed to set up the connections on initialization.
+      #
+      # @param [ Hash ] options The connection pool options.
+      #
+      # @since 2.0.0
+      def initialize(options = {}, &block)
+        @options = options.freeze
+        @queue = Queue.new(options, &block)
+      end
+
+      # Get a pretty printed string inspection for the pool.
+      #
+      # @example Inspect the pool.
+      #   pool.inspect
+      #
+      # @return [ String ] The pool inspection.
+      #
+      # @since 2.0.0
+      def inspect
+        "#<Mongo::Server::ConnectionPool:0x#{object_id} queue=#{queue.inspect}>"
+      end
+
+      # Yield the block to a connection, while handling checkin/checkout logic.
+      #
+      # @example Execute with a connection.
+      #   pool.with_connection do |connection|
+      #     connection.read
+      #   end
+      #
+      # @return [ Object ] The result of the block.
+      #
+      # @since 2.0.0
+      def with_connection
+        begin
+          connection = checkout
+          yield(connection)
+        ensure
+          checkin(connection)
+        end
+      end
+
+      private
+
+      attr_reader :queue
+
+      class << self
+
+        # Get a connection pool for the provided server.
+        #
+        # @example Get a connection pool.
+        #   Mongo::Pool.get(server)
+        #
+        # @param [ Mongo::Server ] server The server.
+        #
+        # @return [ Mongo::Pool ] The connection pool.
+        #
+        # @since 2.0.0
+        def get(server)
+          MUTEX.synchronize do
+            pools[server.address] ||= create_pool(server)
+          end
+        end
+
+        private
+
+        def create_pool(server)
+          ConnectionPool.new(server.options) do
+            Connection.new(server, server.options)
+          end
+        end
+
+        def pools
+          @pools ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/mongo/server/context.rb

@@ -0,0 +1,66 @@
+# Copyright (C) 2014-2015 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 Server
+
+    # Represents a context in which messages are sent to the server on a
+    # connection.
+    #
+    # @since 2.0.0
+    class Context
+      extend Forwardable
+
+      # @return [ Mongo::Server ] server The server the context is for.
+      attr_reader :server
+
+      # Delegate state checks to the server.
+      def_delegators :@server,
+                     :features,
+                     :max_wire_version,
+                     :max_write_batch_size,
+                     :mongos?,
+                     :primary?,
+                     :secondary?,
+                     :standalone?
+
+      # Instantiate a server context.
+      #
+      # @example Instantiate a server context.
+      #   Mongo::Server::Context.new(server)
+      #
+      # @param [ Mongo::Server ] server The server the context is for.
+      #
+      # @since 2.0.0
+      def initialize(server)
+        @server = server
+      end
+
+      # Execute a block of code with a connection, that is checked out of the
+      # pool and then checked back in.
+      #
+      # @example Send a message with the connection.
+      #   context.with_connection do |connection|
+      #     connection.dispatch([ command ])
+      #   end
+      #
+      # @return [ Object ] The result of the block execution.
+      #
+      # @since 2.0.0
+      def with_connection(&block)
+        server.pool.with_connection(&block)
+      end
+    end
+  end
+end

data/lib/mongo/server/description/features.rb

@@ -0,0 +1,85 @@
+# Copyright (C) 2014 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 Server
+    class Description
+
+      # Defines behaviour around what features a specific server supports.
+      #
+      # @since 2.0.0
+      class Features
+
+        # List of features and the wire protocol version they appear in.
+        #
+        # @since 2.0.0
+        MAPPINGS = {
+          :list_collections => 3,
+          :list_indexes => 3,
+          :scram_sha_1 => 3,
+          :write_command => 2
+        }.freeze
+
+        # The wire protocol versions that this version of the driver supports.
+        #
+        # @since 2.0.0
+        DRIVER_WIRE_VERSIONS = (0..3).freeze
+
+        # Create the methods for each mapping to tell if they are supported.
+        #
+        # @since 2.0.0
+        MAPPINGS.each do |name, version|
+
+          # Determine whether or not the feature is enabled.
+          #
+          # @example Is a feature enabled?
+          #   features.list_collections_enabled?
+          #
+          # @return [ true, false ] If the feature is enabled.
+          #
+          # @since 2.0.0
+          define_method("#{name}_enabled?") do
+            server_wire_versions.include?(MAPPINGS[name])
+          end
+        end
+
+        # @return [ Range ] server_wire_versions The server's supported wire
+        #   versions.
+        attr_reader :server_wire_versions
+
+        # Initialize the features.
+        #
+        # @example Initialize the features.
+        #   Features.new(0..3)
+        #
+        # @param [ Range ] server_wire_versions The server supported wire
+        #   versions.
+        #
+        # @since 2.0.0
+        def initialize(server_wire_versions)
+          @server_wire_versions = server_wire_versions
+          check_driver_support!
+        end
+
+        private
+
+        def check_driver_support!
+          if DRIVER_WIRE_VERSIONS.max < server_wire_versions.max
+            raise Error::UnsupportedFeatures.new(server_wire_versions)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/server/description/inspector/primary_elected.rb

@@ -0,0 +1,58 @@
+# Copyright (C) 2015 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 Server
+    class Description
+      class Inspector
+
+        # Handles inspecting the result of an ismaster command to check if this
+        # server was elected primary.
+        #
+        # @since 2.0.0
+        class PrimaryElected
+          include Event::Publisher
+
+          # Instantiate the primary elected inspection.
+          #
+          # @example Instantiate the inspection.
+          #   PrimaryElected.new(listeners)
+          #
+          # @param [ Event::Listeners ] event_listeners The event listeners.
+          #
+          # @since 2.0.0
+          def initialize(event_listeners)
+            @event_listeners = event_listeners
+          end
+
+          # Run the primary elected inspection.
+          #
+          # @example Run the inspection.
+          #   PrimaryElected.run(description, {})
+          #
+          # @param [ Description ] description The server description.
+          # @param [ Description ] updated The updated description.
+          #
+          # @since 2.0.0
+          def run(description, updated)
+            if (!description.primary? && updated.primary?) ||
+              (!description.mongos? && updated.mongos?)
+              publish(Event::PRIMARY_ELECTED, updated)
+            end
+          end
+        end
+      end
+    end
+  end
+end