mongo 1.12.5 → 2.0.0.beta

data/lib/mongo/server/connectable.rb

@@ -0,0 +1,99 @@
+# 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
+
+    # This provides common behaviour for connection objects.
+    #
+    # @since 2.0.0
+    module Connectable
+      include Loggable
+
+      # The default time in seconds to timeout a connection attempt.
+      #
+      # @since 2.0.0
+      TIMEOUT = 5.freeze
+
+      # @return [ Mongo::Address ] address The address to connect to.
+      attr_reader :address
+
+      # @return [ Hash ] options The passed in options.
+      attr_reader :options
+
+      # Determine if the connection is currently connected.
+      #
+      # @example Is the connection connected?
+      #   connection.connected?
+      #
+      # @return [ true, false ] If connected.
+      #
+      # @since 2.0.0
+      def connected?
+        !!@socket && @socket.alive?
+      end
+
+      # Dispatch the provided messages to the connection. If the last message
+      # requires a response a reply will be returned.
+      #
+      # @example Dispatch the messages.
+      #   connection.dispatch([ insert, command ])
+      #
+      # @note This method is named dispatch since 'send' is a core Ruby method on
+      #   all objects.
+      #
+      # @param [ Array<Message> ] messages The messages to dispatch.
+      #
+      # @return [ Protocol::Reply ] The reply if needed.
+      #
+      # @since 2.0.0
+      def dispatch(messages)
+        log_debug(messages) do |msgs|
+          write(msgs)
+          msgs.last.replyable? ? read : nil
+        end
+      end
+
+      # Get the connection timeout.
+      #
+      # @example Get the connection timeout.
+      #   connection.timeout
+      #
+      # @return [ Float ] The connection timeout in seconds.
+      #
+      # @since 2.0.0
+      def timeout
+        @timeout ||= options[:socket_timeout] || TIMEOUT
+      end
+
+      private
+
+      attr_reader :socket, :ssl_options
+
+      def ensure_connected
+        connect! if socket.nil? || !socket.alive?
+        begin
+          yield socket
+        rescue Error::SocketError, Error::SocketTimeoutError => e
+          disconnect!
+          raise e
+        end
+      end
+
+      def read
+        ensure_connected{ |socket| Protocol::Reply.deserialize(socket) }
+      end
+    end
+  end
+end

data/lib/mongo/server/connection.rb

@@ -0,0 +1,133 @@
+# 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
+        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.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/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 [ Integer ] size The initial size of the queue.
+        #
+        # @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