mongo 1.4.0 → 1.5.0.rc0

data/lib/mongo/repl_set_connection.rb

@@ -16,15 +16,14 @@
 # limitations under the License.
 # ++
 
-require 'sync'
-
 module Mongo
 
   # Instantiates and manages connections to a MongoDB replica set.
   class ReplSetConnection < Connection
-    attr_reader :nodes, :secondaries, :arbiters, :secondary_pools,
-      :replica_set_name, :read_pool, :seeds, :tags_to_pools,
-      :refresh_interval, :refresh_mode
+    CLEANUP_INTERVAL = 300
+
+    attr_reader :replica_set_name, :seeds, :refresh_interval, :refresh_mode,
+      :refresh_version
 
     # Create a connection to a MongoDB replica set.
     #
@@ -57,11 +56,10 @@ module Mongo
     # @option opts [Float] :connect_timeout (nil) The number of seconds to wait before timing out a
     #   connection attempt.
     # @option opts [Boolean] :ssl (false) If true, create the connection to the server using SSL.
-    # @option opts [Boolean] :refresh_mode (:sync) Set this to :async to enable a background thread that
-    #   periodically updates the state of the connection. If, for example, you initially connect while a secondary
-    #   is down, this will reconnect to that secondary behind the scenes to
-    #   prevent you from having to reconnect manually. If set to :sync, refresh will happen
-    #   synchronously. If +false+, no automatic refresh will occur unless there's a connection failure.
+    # @option opts [Boolean] :refresh_mode (false) Set this to :sync to periodically update the
+    #   state of the connection every :refresh_interval seconds. Replica set connection failures
+    #   will always trigger a complete refresh. This option is useful when you want to add new nodes
+    #   or remove replica set nodes not currently in use by the driver.
     # @option opts [Integer] :refresh_interval (90) If :refresh_mode is enabled, this is the number of seconds
     #   between calls to check the replica set's state.
     # @option opts [Boolean] :require_primary (true) If true, require a primary node for the connection
@@ -83,8 +81,6 @@ module Mongo
     # @raise [ReplicaSetConnectionError] This is raised if a replica set name is specified and the
     #   driver fails to connect to a replica set with that name.
     def initialize(*args)
-      extend Sync_m
-
       if args.last.is_a?(Hash)
         opts = args.pop
       else
@@ -101,31 +97,21 @@ module Mongo
       # TODO: get rid of this
       @nodes = @seeds.dup
 
-      # The members of the replica set, stored as instances of Mongo::Node.
-      @members = []
-
-      # Connection pool for primary node
-      @primary      = nil
-      @primary_pool = nil
-
-      # Connection pools for each secondary node
-      @secondaries = []
-      @secondary_pools = []
-
-      # The secondary pool to which we'll be sending reads.
-      # This may be identical to the primary pool.
-      @read_pool = nil
-
-      # A list of arbiter addresses (for client information only)
-      @arbiters = []
-
       # Refresh
-      @refresh_mode = opts.fetch(:refresh_mode, :sync)
+      @refresh_mode = opts.fetch(:refresh_mode, false)
       @refresh_interval = opts[:refresh_interval] || 90
+      @last_refresh = Time.now
 
-      if ![:sync, :async, false].include?(@refresh_mode)
+      # No connection manager by default.
+      @manager = nil
+      @pool_mutex = Mutex.new
+
+      if @refresh_mode == :async
+        warn ":async refresh mode has been deprecated. Refresh
+        mode will be disabled."
+      elsif ![:sync, false].include?(@refresh_mode)
         raise MongoArgumentError,
-          "Refresh mode must be one of :sync, :async, or false."
+          "Refresh mode must be either :sync or false."
       end
 
       # Are we allowing reads from secondaries?
@@ -140,13 +126,7 @@ module Mongo
       end
 
       @connected = false
-
-      # Store the refresher thread
-      @refresh_thread = nil
-
-      # Maps
-      @sockets_to_pools = {}
-      @tags_to_pools = {}
+      @refresh_version = 0
 
       # Replica set name
       if opts[:rs_name]
@@ -164,68 +144,75 @@ module Mongo
     end
 
     def inspect
-      "<Mongo::ReplSetConnection:0x#{self.object_id.to_s(16)} @seeds=#{@seeds} " +
+      "<Mongo::ReplSetConnection:0x#{self.object_id.to_s(16)} @seeds=#{@seeds.inspect} " +
         "@connected=#{@connected}>"
     end
 
     # Initiate a connection to the replica set.
     def connect
       log(:info, "Connecting...")
-      sync_synchronize(:EX) do
-        return if @connected
-        manager = PoolManager.new(self, @seeds)
-        manager.connect
-
-        update_config(manager)
-        initiate_refresh_mode
-
-        if @require_primary && @primary.nil? #TODO: in v2.0, we'll let this be optional and do a lazy connect.
-          raise ConnectionFailure, "Failed to connect to primary node."
-        elsif !@read_pool
-          raise ConnectionFailure, "Failed to connect to any node."
-        else
-          @connected = true
-        end
+      return if @connected
+      manager = PoolManager.new(self, @seeds)
+      manager.connect
+
+      update_config(manager)
+
+      if @require_primary && self.primary.nil? #TODO: in v2.0, we'll let this be optional and do a lazy connect.
+        close
+        raise ConnectionFailure, "Failed to connect to primary node."
+      elsif self.read_pool.nil?
+        close
+        raise ConnectionFailure, "Failed to connect to any node."
+      else
+        @connected = true
       end
     end
 
-    # Note: this method must be called from within
-    # an exclusive lock.
-    def update_config(manager)
-      @arbiters = manager.arbiters.nil? ? [] : manager.arbiters.dup
-      @primary = manager.primary.nil? ? nil : manager.primary.dup
-      @secondaries = manager.secondaries.dup
-      @hosts = manager.hosts.dup
-
-      @primary_pool = manager.primary_pool
-      @read_pool    = manager.read_pool
-      @secondary_pools = manager.secondary_pools
-      @tags_to_pools   = manager.tags_to_pools
-      @seeds = manager.seeds
-      @manager = manager
-      @nodes = manager.nodes
-      @max_bson_size = manager.max_bson_size
-    end
-
-    # Refresh the current replica set configuration.
+    # Determine whether a replica set refresh is
+    # required. If so, run a hard refresh. You can
+    # force a hard refresh by running
+    # ReplSetConnection#hard_refresh!
+    #
+    # @return [Boolean] +true+ unless a hard refresh
+    #   is run and the refresh lock can't be acquired.
     def refresh(opts={})
-      return false if !connected?
+      if !connected?
+        log(:info, "Trying to check replica set health but not " +
+          "connected...")
+        return hard_refresh!
+      end
 
-      # Return if another thread is already in the process of refreshing.
-      return if sync_exclusive?
+      log(:debug, "Checking replica set connection health...")
+      @manager.check_connection_health
 
-      sync_synchronize(:EX) do
-        log(:info, "Refreshing...")
-        @background_manager ||= PoolManager.new(self, @seeds)
-        @background_manager.connect
-        update_config(@background_manager)
+      if @manager.refresh_required?
+        return hard_refresh!
       end
 
       return true
     end
 
+    # Force a hard refresh of this connection's view
+    # of the replica set.
+    #
+    # @return [Boolean] +true+ if hard refresh
+    #   occurred. +false+ is returned when unable
+    #   to get the refresh lock.
+    def hard_refresh!
+      log(:info, "Initiating hard refresh...")
+      background_manager = PoolManager.new(self, @seeds)
+      background_manager.connect
+
+      # TODO: make sure that connect has succeeded
+      old_manager = @manager
+      update_config(background_manager)
+      old_manager.close(:soft => true)
+
+      return true
+    end
+
     def connected?
-      !@primary_pool.nil? || !@read_pool.nil?
+      self.primary_pool || self.read_pool
     end
 
     # @deprecated
@@ -238,14 +225,14 @@ module Mongo
     #
     # @return [String]
     def host
-      super
+      self.primary_pool.host
     end
 
     # The replica set primary's port.
     #
     # @return [Integer]
     def port
-      super
+      self.primary_pool.port
     end
 
     def nodes
@@ -259,9 +246,7 @@ module Mongo
     #
     # @return [Boolean]
     def read_primary?
-      sync_synchronize(:SH) do
-        @read_pool == @primary_pool
-      end
+      self.read_pool == self.primary_pool
     end
     alias :primary? :read_primary?
 
@@ -271,36 +256,8 @@ module Mongo
 
     # Close the connection to the database.
     def close
-      sync_synchronize(:EX) do
-        @connected = false
-        super
-
-        if @refresh_thread
-          @refresh_thread.kill
-          @refresh_thread = nil
-        end
-
-        if @nodes
-          @nodes.each do |member|
-            member.close
-          end
-        end
-
-        @nodes = []
-        @read_pool = nil
-
-        if @secondary_pools
-          @secondary_pools.each do |pool|
-            pool.close
-          end
-        end
-
-        @secondaries     = []
-        @secondary_pools = []
-        @arbiters        = []
-        @tags_to_pools.clear
-        @sockets_to_pools.clear
-      end
+      @connected = false
+      @manager.close(:soft => true) if @manager
     end
 
     # If a ConnectionFailure is raised, this method will be called
@@ -324,45 +281,29 @@ module Mongo
     end
 
     def authenticate_pools
-      super
-      @secondary_pools.each do |pool|
+      self.primary_pool.authenticate_existing
+      self.secondary_pools.each do |pool|
         pool.authenticate_existing
       end
     end
 
     def logout_pools(db)
-      super
-      @secondary_pools.each do |pool|
+      self.primary_pool.logout_existing(db)
+      self.secondary_pools.each do |pool|
         pool.logout_existing(db)
       end
     end
 
-    private
-
-    def initiate_refresh_mode
-      if @refresh_mode == :async
-        return if @refresh_thread && @refresh_thread.alive?
-        @refresh_thread = Thread.new do
-          while true do
-            sleep(@refresh_interval)
-            refresh
-          end
-        end
-      end
-
-      @last_refresh = Time.now
-    end
-
     # Checkout a socket for reading (i.e., a secondary node).
     # Note that @read_pool might point to the primary pool
     # if no read pool has been defined.
     def checkout_reader
       connect unless connected?
-      socket = get_socket_from_pool(@read_pool)
+      socket = get_socket_from_pool(self.read_pool)
 
       if !socket
-        refresh
-        socket = get_socket_from_pool(@primary_pool)
+        connect
+        socket = get_socket_from_pool(self.primary_pool)
       end
 
       if socket
@@ -372,35 +313,14 @@ module Mongo
       end
     end
 
-    # Checkout a socket connected to a node with one of
-    # the provided tags. If no such node exists, raise
-    # an exception.
-    #
-    # NOTE: will be available in driver release v2.0.
-    def checkout_tagged(tags)
-      sync_synchronize(:SH) do
-        tags.each do |k, v|
-          pool = @tags_to_pools[{k.to_s => v}]
-          if pool
-            socket = pool.checkout
-            @sockets_to_pools[socket] = pool
-            return socket
-          end
-        end
-      end
-
-      raise NodeWithTagsNotFound,
-        "Could not find a connection tagged with #{tags}."
-    end
-
     # Checkout a socket for writing (i.e., a primary node).
     def checkout_writer
       connect unless connected?
-      socket = get_socket_from_pool(@primary_pool)
+      socket = get_socket_from_pool(self.primary_pool)
 
       if !socket
-        refresh
-        socket = get_socket_from_pool(@primary_pool)
+        connect
+        socket = get_socket_from_pool(self.primary_pool)
       end
 
       if socket
@@ -410,49 +330,174 @@ module Mongo
       end
     end
 
+    # Checkin a socket used for reading.
+    def checkin_reader(socket)
+      if !self.read_pool.checkin(socket) &&
+        !self.primary_pool.checkin(socket)
+        close_socket(socket)
+      end
+      sync_refresh
+    end
+
+    # Checkin a socket used for writing.
+    def checkin_writer(socket)
+      if !self.primary_pool.checkin(socket)
+        close_socket(socket)
+      end
+      sync_refresh
+    end
+
+    def close_socket(socket)
+      begin
+        socket.close
+      rescue IOError
+        log(:info, "Tried to close socket #{socket} but already closed.")
+      end
+    end
+
     def get_socket_from_pool(pool)
       begin
-        sync_synchronize(:SH) do
-          if pool
-            socket = pool.checkout
-            @sockets_to_pools[socket] = pool
-            socket
-          end
+        if pool
+          socket = pool.checkout
+          socket
         end
-
       rescue ConnectionFailure => ex
         log(:info, "Failed to checkout from #{pool} with #{ex.class}; #{ex.message}")
         return nil
       end
     end
 
-    # Checkin a socket used for reading.
-    def checkin_reader(socket)
-      warn "ReplSetConnection#checkin_writer is deprecated and will be removed " +
-        "in driver v2.0. Use ReplSetConnection#checkin instead."
-      checkin(socket)
+    def arbiters
+      @manager.arbiters.nil? ? [] : @manager.arbiters
     end
 
-    # Checkin a socket used for writing.
-    def checkin_writer(socket)
-      warn "ReplSetConnection#checkin_writer is deprecated and will be removed " +
-        "in driver v2.0. Use ReplSetConnection#checkin instead."
-      checkin(socket)
+    def primary
+      @manager.primary
+    end
+
+    # Note: might want to freeze these after connecting.
+    def secondaries
+      @manager.secondaries
+    end
+
+    def hosts
+      @manager.hosts
+    end
+
+    def primary_pool
+      @manager.primary_pool
+    end
+
+    def read_pool
+      @manager.read_pool
+    end
+
+    def secondary_pools
+      @manager.secondary_pools
+    end
+
+    def tag_map
+      @manager.tag_map
+    end
+
+    def max_bson_size
+      @manager.max_bson_size
+    end
+
+    private
+
+    # Generic initialization code.
+    def setup(opts)
+      # Default maximum BSON object size
+      @max_bson_size = Mongo::DEFAULT_MAX_BSON_SIZE
+
+      @safe_mutex_lock = Mutex.new
+      @safe_mutexes = Hash.new {|hash, key| hash[key] = Mutex.new}
+
+      # Determine whether to use SSL.
+      @ssl = opts.fetch(:ssl, false)
+      if @ssl
+        @socket_class = Mongo::SSLSocket
+      else
+        @socket_class = ::TCPSocket
+      end
+
+      # Authentication objects
+      @auths = opts.fetch(:auths, [])
+
+      # Lock for request ids.
+      @id_lock = Mutex.new
+
+      # Pool size and timeout.
+      @pool_size = opts[:pool_size] || 1
+      if opts[:timeout]
+        warn "The :timeout option has been deprecated " +
+          "and will be removed in the 2.0 release. Use :pool_timeout instead."
+      end
+      @pool_timeout = opts[:pool_timeout] || opts[:timeout] || 5.0
+
+      # Timeout on socket read operation.
+      @op_timeout = opts[:op_timeout] || nil
+
+      # Timeout on socket connect.
+      @connect_timeout = opts[:connect_timeout] || nil
+
+      # Mutex for synchronizing pool access
+      # TODO: remove this.
+      @connection_mutex = Mutex.new
+
+      # Global safe option. This is false by default.
+      @safe = opts[:safe] || false
+
+      # Condition variable for signal and wait
+      @queue = ConditionVariable.new
+
+      @logger = opts[:logger] || nil
+
+      # Clean up connections to dead threads.
+      @last_cleanup = Time.now
+      @cleanup_lock = Mutex.new
+
+      if @logger
+        write_logging_startup_message
+      end
+
+      @last_refresh = Time.now
+
+      should_connect = opts.fetch(:connect, true)
+      connect if should_connect
     end
 
-    def checkin(socket)
-      sync_synchronize(:SH) do
-        if pool = @sockets_to_pools[socket]
-          pool.checkin(socket)
-        elsif socket
-          socket.close
+    # Given a pool manager, update this connection's
+    # view of the replica set.
+    def update_config(new_manager)
+      @manager = new_manager
+      @seeds   = @manager.seeds.dup
+      @refresh_version += 1
+    end
+
+    # Checkout a socket connected to a node with one of
+    # the provided tags. If no such node exists, raise
+    # an exception.
+    #
+    # NOTE: will be available in driver release v2.0.
+    def checkout_tagged(tags)
+      tags.each do |k, v|
+        pool = self.tag_map[{k.to_s => v}]
+        if pool
+          socket = pool.checkout
+          return socket
         end
       end
 
-      # Refresh synchronously every @refresh_interval seconds
-      # if synchronous refresh mode is enabled.
+      raise NodeWithTagsNotFound,
+        "Could not find a connection tagged with #{tags}."
+    end
+
+    def sync_refresh
       if @refresh_mode == :sync &&
         ((Time.now - @last_refresh) > @refresh_interval)
+        @last_refresh = Time.now
         refresh
       end
     end