moped 1.5.3 → 2.0.0.beta

data/lib/moped/collection.rb

@@ -1,16 +1,18 @@
+# encoding: utf-8
+require "moped/query"
+
 module Moped
 
   # The class for interacting with a MongoDB collection.
   #
-  # @example
-  #   users = session[:users] # => <Moped::Collection ...>
-  #   users.drop
-  #   users.insert(name: "John")
-  #   users.find.to_a # => [{ name: "John" }]
+  # @since 1.0.0
   class Collection
+    include Readable
 
-    # @attribute [r] database The collection's database.
-    # @attribute [r] name The collection name.
+    # @!attribute database
+    #   @return [ Database ] The database for the collection.
+    # @!attribute name
+    #   @return [ String ] The name of the collection.
     attr_reader :database, :name
 
     # Return whether or not this collection is a capped collection.
@@ -35,15 +37,31 @@ module Moped
     # @since 1.0.0
     def drop
       begin
-        database.session.with(consistency: :strong) do |session|
-          session.context.command(database.name, drop: name)
-        end
+        session.with(read: :primary).command(drop: name)
       rescue Moped::Errors::OperationFailure => e
-        raise e unless e.details["errmsg"] == "ns not found"
+        raise e unless e.ns_not_found?
         false
       end
     end
 
+    # Rename the collection
+    #
+    # @example Rename the collection to 'foo'
+    #   collection.rename('foo')
+    #
+    # @return [ Hash ] The command information.
+    #
+    # @since 2.0.0
+    def rename(to_name)
+      begin
+        session.
+          with(database: "admin", read: :primary).
+          command(renameCollection: "#{database.name}.#{name}", to: "#{database.name}.#{to_name}")
+      rescue Moped::Errors::OperationFailure => e
+        raise e unless e.ns_not_exists?
+        false
+      end
+    end
     # Build a query for this collection.
     #
     # @example Build a query based on the provided selector.
@@ -81,7 +99,8 @@ module Moped
     #
     # @since 1.0.0
     def initialize(database, name)
-      @database, @name = database, name.to_s
+      @database = database
+      @name = name.to_s
     end
 
     # Insert one or more documents into the collection.
@@ -101,9 +120,9 @@ module Moped
     #
     # @since 1.0.0
     def insert(documents, flags = nil)
-      documents = [documents] unless documents.is_a?(Array)
-      database.session.with(consistency: :strong) do |session|
-        session.context.insert(database.name, name, documents, flags: flags || [])
+      docs = documents.is_a?(Array) ? documents : [ documents ]
+      cluster.with_primary do |node|
+        node.insert(database.name, name, docs, write_concern, flags: flags || [])
       end
     end
 
@@ -117,15 +136,30 @@ module Moped
     #     }
     #   })
     #
-    # @param [ Hash, Array<Hash> ] documents representing the aggregate function to execute
+    # @param [ Hash, Array<Hash> ] documents representing the aggregate
+    #   function to execute
     #
     # @return [ Hash ] containing the result of aggregation
     #
     # @since 1.3.0
     def aggregate(*pipeline)
-      pipeline.flatten!
-      command = { aggregate: name.to_s, pipeline: pipeline }
-      database.session.command(command)["result"]
+      session.command(aggregate: name, pipeline: pipeline.flatten)["result"]
+    end
+
+    # Get the session for the collection.
+    #
+    # @example Get the session for the collection.
+    #   collection.session
+    #
+    # @return [ Session ] The session for the collection.
+    #
+    # @since 2.0.0
+    def session
+      database.session
+    end
+
+    def write_concern
+      session.write_concern
     end
   end
 end

data/lib/moped/connection.rb

@@ -1,16 +1,33 @@
-require "timeout"
-require "moped/sockets/connectable"
-require "moped/sockets/tcp"
-require "moped/sockets/ssl"
+# encoding: utf-8
+require "moped/connection/manager"
+require "moped/connection/pool"
+require "moped/connection/queue"
+require "moped/connection/reaper"
+require "moped/connection/sockets"
 
 module Moped
 
   # This class contains behaviour of database socket connections.
   #
-  # @api private
+  # @since 2.0.0
   class Connection
 
-    attr_reader :host, :port, :timeout, :options
+    # The default connection timeout, in seconds.
+    #
+    # @since 2.0.0
+    TIMEOUT = 5
+
+    # @!attribute host
+    #   @return [ String ] The ip address of the host.
+    # @!attribute options
+    #   @return [ Hash ] The connection options.
+    # @!attribute port
+    #   @return [ String ] The port the connection connects on.
+    # @!attribute timeout
+    #   @return [ Integer ] The timeout in seconds.
+    # @!attribute last_use
+    #   @return [ Time ] The time the connection was last checked out.
+    attr_reader :host, :options, :port, :timeout, :last_use
 
     # Is the connection alive?
     #
@@ -34,9 +51,9 @@ module Moped
     # @since 1.0.0
     def connect
       @sock = if !!options[:ssl]
-        Sockets::SSL.connect(host, port, timeout)
+        Socket::SSL.connect(host, port, timeout)
       else
-        Sockets::TCP.connect(host, port, timeout)
+        Socket::TCP.connect(host, port, timeout)
       end
     end
 
@@ -80,9 +97,49 @@ module Moped
     # @option options [ Boolean ] :ssl Connect using SSL
     # @since 1.0.0
     def initialize(host, port, timeout, options = {})
+      @host = host
+      @port = port
+      @timeout = timeout
+      @options = options
       @sock = nil
+      @last_use = nil
       @request_id = 0
-      @host, @port, @timeout, @options = host, port, timeout, options
+    end
+
+    # Expiring a connection means returning it to the connection pool.
+    #
+    # @example Expire the connection.
+    #   connection.expire
+    #
+    # @return [ nil ] nil.
+    #
+    # @since 2.0.0
+    def expire
+      @last_use = nil
+    end
+
+    # An expired connection is not currently being used.
+    #
+    # @example Is the connection expired?
+    #   connection.expired?
+    #
+    # @return [ true, false ] If the connection is expired.
+    #
+    # @since 2.0.0
+    def expired?
+      @last_use.nil?
+    end
+
+    # A leased connection is currently checkout out from the connection pool.
+    #
+    # @example Lease the connection.
+    #   connection.lease
+    #
+    # @return [ Time ] The current time of leasing.
+    #
+    # @since 2.0.0
+    def lease
+      @last_use = Time.now
     end
 
     # Read from the connection.
@@ -113,7 +170,7 @@ module Moped
           sock_read = read_data(socket, reply.length - 36)
           buffer = StringIO.new(sock_read)
           reply.documents = reply.count.times.map do
-            BSON::Document.deserialize(buffer)
+            BSON::Document.from_bson(buffer)
           end
         end
         reply
@@ -189,6 +246,8 @@ module Moped
     # Yields a connected socket to the calling back. It will attempt to reconnect
     # the socket if it is not connected.
     #
+    # @api private
+    #
     # @example Write to the connection.
     #   with_connection do |socket|
     #     socket.write(buf)

data/lib/moped/connection/manager.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+module Moped
+  class Connection
+
+    # This class contains behaviour of connection pools for specific addresses.
+    #
+    # @since 2.0.0
+    module Manager
+      extend self
+
+      # Used for synchronization of pools access.
+      MUTEX = Mutex.new
+
+      # Get a connection pool for the provided node.
+      #
+      # @example Get a connection pool for the node.
+      #   Manager.pool(node)
+      #
+      # @param [ Node ] The node.
+      #
+      # @return [ Pool ] The connection pool for the Node.
+      #
+      # @since 2.0.0
+      def pool(node)
+        MUTEX.synchronize do
+          pools[node.address.resolved] ||=
+            Pool.new(node.address.ip, node.address.port, node.options)
+        end
+      end
+
+      private
+
+      # Get all the connection pools. This is a cache that stores each pool
+      # with lookup by it's resolved address.
+      #
+      # @api private
+      #
+      # @example Get the pools.
+      #   Manager.pools
+      #
+      # @return [ Hash ] The cache of pools.
+      #
+      # @since 2.0.0
+      def pools
+        @pools ||= {}
+      end
+    end
+  end
+end

data/lib/moped/connection/pool.rb

@@ -0,0 +1,198 @@
+# encoding: utf-8
+module Moped
+  class Connection
+
+    # This class contains behaviour of connection pools for specific addresses.
+    #
+    # @since 2.0.0
+    class Pool
+
+      # The default max size for the connection pool.
+      POOL_SIZE = 5
+
+      # The default timeout for getting connections from the queue.
+      TIMEOUT = 0.25
+
+      # @!attribute host
+      #   @return [ String ] The host the pool is for.
+      # @!attribute port
+      #   @return [ Integer ] The port on the host.
+      # @!attribute options
+      #   @return [ Hash ] The connection pool options.
+      # @!attribute reaper
+      #   @return [ Reaper ] The connection pool reaper.
+      attr_reader :host, :port, :options, :reaper
+
+      # Checkout a connection from the connection pool. If there exists a
+      # connection pinned to the current thread, then we return that first. If
+      # no connection is pinned, we will take an unpinned connection or create
+      # a new one if no unpinned exist and the pool is not saturated.
+      #
+      # @example Checkout a connection.
+      #   pool.checkout
+      #
+      # @return [ Connection ] A connection.
+      #
+      # @since 2.0.0
+      def checkout
+        mutex.synchronize do
+          connection = pinned[thread_id]
+          if connection
+            unless connection.expired?
+              raise Errors::ConnectionInUse, "The connection on thread: #{thread_id} is in use."
+            else
+              lease(connection)
+            end
+          else
+            connection = pinned[thread_id] = next_connection
+            lease(connection)
+          end
+        end
+      end
+
+      # Checkin the connection, indicating that it is finished being used. The
+      # connection will stay pinned to the current thread.
+      #
+      # @example Checkin the connection.
+      #   pool.checkin(connection)
+      #
+      # @param [ Connection ] connection The connection to checkin.
+      #
+      # @since 2.0.0
+      def checkin(connection)
+        mutex.synchronize do
+          expire(connection)
+        end
+      end
+
+      # Initialize the connection pool.
+      #
+      # @example Instantiate the connection pool.
+      #   Pool.new(max_size: 4)
+      #
+      # @param [ Hash ] options The connection pool options.
+      #
+      # @since 2.0.0
+      def initialize(host, port, options = {})
+        @host = host
+        @port = port
+        @options = options
+        @reaper = Reaper.new(options[:reap_interval] || Reaper::INTERVAL, self)
+        @mutex = Mutex.new
+        @resource = ConditionVariable.new
+        @pinned = {}
+        @unpinned = Queue.new(max_size) do
+          Connection.new(host, port, options[:timeout] || Connection::TIMEOUT, options)
+        end
+        reaper.start
+      end
+
+      # Get the max size for the connection pool.
+      #
+      # @example Get the max size.
+      #   pool.max_size
+      #
+      # @return [ Integer ] The max size of the pool.
+      #
+      # @since 2.0.0
+      def max_size
+        @max_size ||= (options[:pool_size] || POOL_SIZE)
+      end
+
+      # Reap all connections that are active and associated with dead threads.
+      #
+      # @example Reap the connections.
+      #   pool.reap([ 12351122313 ])
+      #
+      # @param [ Array<Integer> ] ids The ids of the current active threads.
+      #
+      # @return [ Pool ] The connection pool.
+      #
+      # @since 2.0.0
+      def reap(ids = active_threads)
+        pinned.each do |id, conn|
+          unless ids.include?(id)
+            conn.expire
+            unpinned.push(pinned.delete(id))
+          end
+        end and self
+      end
+
+      # Get the current size of the connection pool. Is the total of pinned
+      # plus unpinned connections.
+      #
+      # @example Get the pool's current size.
+      #   pool.size
+      #
+      # @return [ Integer ] The current size of the pool.
+      #
+      # @since 2.0.0
+      def size
+        unpinned.size + pinned.size
+      end
+
+      # Get the timeout when attempting to check out items from the pool.
+      #
+      # @example Get the checkout timeout.
+      #   pool.timeout
+      #
+      # @return [ Float ] The pool timeout.
+      #
+      # @since 2.0.0
+      def timeout
+        @timeout ||= (options[:pool_timeout] || TIMEOUT)
+      end
+
+      # Execute the block with a connection, ensuring that the checkin/checkout
+      # workflow is properly executed.
+      #
+      # @example Execute the block with a connection.
+      #   pool.with_connection do |conn|
+      #     conn.connect
+      #   end
+      #
+      # @return [ Object ] The result of the yield.
+      #
+      # @since 2.0.0
+      def with_connection
+        connection = checkout
+        begin
+          yield(connection)
+        ensure
+          checkin(connection)
+        end
+      end
+
+      private
+
+      attr_reader :mutex, :resource, :pinned, :unpinned
+
+      def expire(connection)
+        connection.expire
+        pinned[thread_id] = connection
+      end
+
+      def lease(connection)
+        connection.lease
+        connection
+      end
+
+      def next_connection
+        reap if saturated?
+        unpinned.pop(timeout)
+      end
+
+      def saturated?
+        size == max_size
+      end
+
+      def thread_id
+        Thread.current.object_id
+      end
+
+      def active_threads
+        Thread.list.select{ |thread| thread.alive? }.map{ |thread| thread.object_id }
+      end
+    end
+  end
+end