mongo 1.6.4 → 1.7.0.rc0

data/lib/mongo/sharded_connection.rb

@@ -0,0 +1,221 @@
+# encoding: UTF-8
+
+# --
+# Copyright (C) 2008-2011 10gen 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
+
+  # Instantiates and manages connections to a MongoDB sharded cluster for high availability.
+  class ShardedConnection < ReplSetConnection
+
+    SHARDED_CLUSTER_OPTS = [:refresh_mode, :refresh_interval]
+
+    attr_reader :seeds, :refresh_interval, :refresh_mode,
+                :refresh_version, :manager
+
+    # Create a connection to a MongoDB sharded cluster.
+    #
+    # If no args are provided, it will check <code>ENV["MONGODB_URI"]</code>.
+    #
+    # @param [Array] seeds "host:port" strings
+    #
+    # @option opts [String] :name (nil) The name of the sharded cluster to connect to. You
+    #   can use this option to verify that you're connecting to the right sharded cluster.
+    # @option opts [Boolean, Hash] :safe (false) Set the default safe-mode options
+    #   propagated to DB objects instantiated off of this Connection. This
+    #   default can be overridden upon instantiation of any DB by explicitly setting a :safe value
+    #   on initialization.
+    # @option opts [Logger] :logger (nil) Logger instance to receive driver operation log.
+    # @option opts [Integer] :pool_size (1) The maximum number of socket connections allowed per
+    #   connection pool. Note: this setting is relevant only for multi-threaded applications.
+    # @option opts [Float] :pool_timeout (5.0) When all of the connections a pool are checked out,
+    #   this is the number of seconds to wait for a new connection to be released before throwing an exception.
+    #   Note: this setting is relevant only for multi-threaded applications.
+    # @option opts [Float] :op_timeout (nil) The number of seconds to wait for a read operation to time out.
+    # @option opts [Float] :connect_timeout (30) 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 (false) Set this to :sync to periodically update the
+    #   state of the connection every :refresh_interval seconds. Sharded cluster connection failures
+    #   will always trigger a complete refresh. This option is useful when you want to add new nodes
+    #   or remove sharded cluster 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 sharded cluster's state.
+    # Note: that the number of seed nodes does not have to be equal to the number of sharded cluster members.
+    # The purpose of seed nodes is to permit the driver to find at least one sharded cluster member even if a member is down.
+    #
+    # @example Connect to a sharded cluster and provide two seed nodes.
+    #   Mongo::ShardedConnection.new(['localhost:30000', 'localhost:30001'])
+    #
+    # @raise [MongoArgumentError] This is raised for usage errors.
+    #
+    # @raise [ConnectionFailure] This is raised for the various connection failures.
+    def initialize(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+
+      nodes = args.flatten
+
+      if nodes.empty? and ENV.has_key?('MONGODB_URI')
+        parser = URIParser.new ENV['MONGODB_URI']
+        if parser.direct?
+          raise MongoArgumentError, "Mongo::ShardedConnection.new called with no arguments, but ENV['MONGODB_URI'] implies a direct connection."
+        end
+        opts = parser.connection_options.merge! opts
+        nodes = [parser.nodes]
+      end
+
+      unless nodes.length > 0
+        raise MongoArgumentError, "A ShardedConnection requires at least one seed node."
+      end
+
+      @seeds = nodes.map do |host_port|
+        host, port = host_port.split(":")
+        [ host, port.to_i ]
+      end
+
+      # TODO: add a method for replacing this list of node.
+      @seeds.freeze
+
+      # Refresh
+      @last_refresh = Time.now
+      @refresh_version = 0
+
+      # No connection manager by default.
+      @manager = nil
+      @old_managers = []
+
+      # Lock for request ids.
+      @id_lock = Mutex.new
+
+      @pool_mutex = Mutex.new
+      @connected = false
+
+      @safe_mutex_lock = Mutex.new
+      @safe_mutexes = Hash.new {|hash, key| hash[key] = Mutex.new}
+
+      @connect_mutex = Mutex.new
+      @refresh_mutex = Mutex.new
+
+      check_opts(opts)
+      setup(opts)
+    end
+
+    def valid_opts
+      GENERIC_OPTS + SHARDED_CLUSTER_OPTS
+    end
+
+    def inspect
+      "<Mongo::ShardedConnection:0x#{self.object_id.to_s(16)} @seeds=#{@seeds.inspect} " +
+          "@connected=#{@connected}>"
+    end
+
+    # Initiate a connection to the sharded cluster.
+    def connect(force = !@connected)
+      return unless force
+      log(:info, "Connecting...")
+      @connect_mutex.synchronize do
+        discovered_seeds = @manager ? @manager.seeds : []
+        @old_managers << @manager if @manager
+        @manager = ShardingPoolManager.new(self, discovered_seeds | @seeds)
+
+        Thread.current[:managers] ||= Hash.new
+        Thread.current[:managers][self] = @manager
+
+        @manager.connect
+        @refresh_version += 1
+        @last_refresh = Time.now
+        @connected = true
+      end
+    end
+
+    # Force a hard refresh of this connection's view
+    # of the sharded cluster.
+    #
+    # @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...")
+      connect(true)
+      return true
+    end
+
+    def connected?
+      @connected && @manager.primary_pool
+    end
+
+    # Returns +true+ if it's okay to read from a secondary node.
+    # Since this is a sharded cluster, this must always be false.
+    #
+    # This method exist primarily so that Cursor objects will
+    # generate query messages with a slaveOkay value of +true+.
+    #
+    # @return [Boolean] +true+
+    def slave_ok?
+      false
+    end
+
+    def checkout(&block)
+      2.times do
+        if connected?
+          sync_refresh
+        else
+          connect
+        end
+
+        begin
+          socket = block.call
+        rescue => ex
+          checkin(socket) if socket
+          raise ex
+        end
+
+        if socket
+          return socket
+        else
+          @connected = false
+          #raise ConnectionFailure.new("Could not checkout a socket.")
+        end
+      end
+    end
+
+    private
+
+    # Parse option hash
+    def setup(opts)
+      # Refresh
+      @refresh_mode = opts.fetch(:refresh_mode, false)
+      @refresh_interval = opts.fetch(:refresh_interval, 90)
+
+      if @refresh_mode && @refresh_interval < 60
+        @refresh_interval = 60 unless ENV['TEST_MODE'] = 'TRUE'
+      end
+
+      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 either :sync or false."
+      end
+
+      opts[:connect_timeout] = opts[:connect_timeout] || 30
+
+      super opts
+    end
+
+  end
+end

data/lib/mongo/util/node.rb

@@ -1,24 +1,18 @@
 module Mongo
   class Node
 
-    attr_accessor :host, :port, :address, :config, :connection, :socket,
-      :last_state
+    attr_accessor :host, :port, :address, :config, :connection, :socket, :last_state
 
-    def initialize(connection, data)
+    def initialize(connection, host_port)
       @connection = connection
-      if data.is_a?(String)
-        @host, @port = split_nodes(data)
-      else
-        @host = data[0]
-        @port = data[1].nil? ? Connection::DEFAULT_PORT : data[1].to_i
-      end
-      @address = "#{host}:#{port}"
+      @host, @port = split_node(host_port)
+      @address = "#{@host}:#{@port}"
       @config = nil
       @socket = nil
     end
 
     def eql?(other)
-      other.is_a?(Node) && host == other.host && port == other.port
+      other.is_a?(Node) && @address == other.address
     end
     alias :== :eql?
 
@@ -35,16 +29,12 @@ module Mongo
     # return nil.
     def connect
       begin
-        socket = nil
         socket = @connection.socket_class.new(@host, @port, 
           @connection.op_timeout, @connection.connect_timeout
         )
-
-        return nil if socket.nil?
       rescue OperationTimeout, ConnectionFailure, OperationFailure, SocketError, SystemCallError, IOError => ex
         @connection.log(:debug, "Failed connection to #{host_string} with #{ex.class}, #{ex.message}.")
         socket.close if socket
-        return nil
       end
 
       @socket = socket
@@ -65,10 +55,10 @@ module Mongo
     def active?
       begin
         result = @connection['admin'].command({:ping => 1}, :socket => @socket)
-        return result['ok'] == 1
       rescue OperationFailure, SocketError, SystemCallError, IOError
         return nil
       end
+      result['ok'] == 1
     end
 
     # Get the configuration for the provided node as returned by the
@@ -78,7 +68,7 @@ module Mongo
       begin
         @config = @connection['admin'].command({:ismaster => 1}, :socket => @socket)
 
-        if @config['msg'] && @logger
+        if @config['msg']
           @connection.log(:warn, "#{config['msg']}")
         end
 
@@ -89,11 +79,7 @@ module Mongo
                             "#{ex.class}: #{ex.message}")
 
         # Socket may already be nil from issuing command
-        if @socket && !@socket.closed?
-          @socket.close
-        end
-
-        return nil
+        close
       end
 
       @config
@@ -119,18 +105,10 @@ module Mongo
       return [] unless config['arbiters']
 
       config['arbiters'].map do |arbiter|
-        split_nodes(arbiter)
+        split_node(arbiter)
       end
     end
 
-    def tags
-      connect unless connected?
-      set_config unless @config
-      return {} unless config['tags'] && !config['tags'].empty?
-
-      config['tags']
-    end
-
     def primary?
       @config['ismaster'] == true || @config['ismaster'] == 1
     end
@@ -139,6 +117,10 @@ module Mongo
       @config['secondary'] == true || @config['secondary'] == 1
     end
 
+    def tags
+      @config['tags'] || {}
+    end
+
     def host_port
       [@host, @port]
     end
@@ -147,19 +129,30 @@ module Mongo
       address.hash
     end
 
+    def healthy?
+      if @config.has_key?('secondary')
+        @config['ismaster'] || @config['secondary']
+      else
+        true
+      end
+    end
+
     private
 
-    def split_nodes(host_string)
-      data = host_string.split(":")
-      host = data[0]
-      port = data[1].nil? ? Connection::DEFAULT_PORT : data[1].to_i
+    def split_node(host_port)
+      if host_port.is_a?(String)
+        host_port = host_port.split(":")
+      end
+
+      host = host_port[0]
+      port = host_port[1].nil? ? Connection::DEFAULT_PORT : host_port[1].to_i
 
       [host, port]
     end
 
     # Ensure that this node is a healty member of a replica set.
     def check_set_membership(config)
-      if !config['hosts']
+      if !config.has_key?('hosts')
         message = "Will not connect to #{host_string} because it's not a member " +
           "of a replica set."
         raise ConnectionFailure, message

data/lib/mongo/util/pool.rb

@@ -72,7 +72,13 @@ module Mongo
           close_sockets(@sockets)
           @closed = true
         end
+        @node.close if @node
       end
+      true
+    end
+
+    def tags
+      @node.tags
     end
 
     def closed?
@@ -81,7 +87,8 @@ module Mongo
 
     def inspect
       "#<Mongo::Pool:0x#{self.object_id.to_s(16)} @host=#{@host} @port=#{port} " +
-        "@ping_time=#{@ping_time} #{@checked_out.size}/#{@size} sockets available.>"
+        "@ping_time=#{@ping_time} #{@checked_out.size}/#{@size} sockets available " +
+        "up=#{!closed?}>"
     end
 
     def host_string
@@ -132,8 +139,8 @@ module Mongo
 
     def ping
       begin
-        return self.connection['admin'].command({:ping => 1}, :socket => @node.socket)
-      rescue OperationFailure, SocketError, SystemCallError, IOError
+        return self.connection['admin'].command({:ping => 1}, :socket => @node.socket, :timeout => 1)
+      rescue ConnectionFailure, OperationFailure, SocketError, SystemCallError, IOError
         return false
       end
     end

data/lib/mongo/util/pool_manager.rb

@@ -2,8 +2,10 @@ module Mongo
   class PoolManager
 
     attr_reader :connection, :arbiters, :primary, :secondaries, :primary_pool,
-      :read_pool, :secondary_pool, :secondary_pools, :hosts, :nodes,
-      :max_bson_size, :tags_to_pools, :tag_map, :members
+      :secondary_pool, :secondary_pools, :hosts, :nodes, :members, :seeds,
+      :max_bson_size
+
+    attr_accessor :pinned_pools
 
     # Create a new set of connection pools.
     #
@@ -13,8 +15,8 @@ module Mongo
     # time. The union of these lists will be used when attempting to connect,
     # with the newly-discovered nodes being used first.
     def initialize(connection, seeds=[])
+      @pinned_pools = {}
       @connection = connection
-      @original_seeds = connection.seeds
       @seeds = seeds
       @previously_connected = false
     end
@@ -30,8 +32,6 @@ module Mongo
       members = connect_to_members
       initialize_pools(members)
       cache_discovered_seeds(members)
-      set_read_pool
-      set_tag_mappings
 
       @members = members
       @previously_connected = true
@@ -90,38 +90,54 @@ module Mongo
 
     def close(opts={})
       begin
-        if @primary_pool
-          @primary_pool.close(opts)
-        end
+        pools.each { |pool| pool.close(opts) }
+      rescue ConnectionFailure
+      end
+    end
 
-        if @secondary_pools
-          @secondary_pools.each do |pool|
-            pool.close(opts)
-          end
-        end
+    def read
+      read_pool.host_port
+    end
 
-        if @members
-          @members.each do |member|
-            member.close
-          end
+    def read_pool(mode=@connection.read_preference, tags=@connection.tag_sets, 
+      acceptable_latency=@connection.acceptable_latency)
+
+      if mode == :primary && !tags.empty?
+        raise MongoArgumentError, "Read preferecy :primary cannot be combined with tags"
+      end
+
+      pinned = @pinned_pools[Thread.current]
+      if mode && pinned && select_pool([pinned], tags, acceptable_latency) && !pinned.closed?
+        pool = pinned
+      else
+        pool = case mode
+        when :primary
+          @primary_pool
+        when :primary_preferred
+          @primary_pool || select_pool(@secondary_pools, tags, acceptable_latency)
+        when :secondary
+          select_pool(@secondary_pools, tags, acceptable_latency)
+        when :secondary_preferred
+          select_pool(@secondary_pools, tags, acceptable_latency) || @primary_pool
+        when :nearest
+          select_pool(pools, tags, acceptable_latency)
         end
+      end
 
-        rescue ConnectionFailure
+      unless pool
+        raise ConnectionFailure, "No replica set member available for query " +
+          "with read preference matching mode #{mode} and tags matching #{tags}."
       end
-    end
 
-    # The set of nodes that this class has discovered and
-    # successfully connected to.
-    def seeds
-      @seeds || []
+      pool
     end
 
-    private
-
     def pools
-      [@primary_pool, *@secondary_pools]
+      [@primary_pool, *@secondary_pools].compact
     end
 
+    private
+
     def validate_existing_member(member)
       config = member.set_config
       if !config
@@ -145,6 +161,7 @@ module Mongo
     def initialize_data
       @primary = nil
       @primary_pool = nil
+      @read = nil
       @read_pool = nil
       @arbiters = []
       @secondaries = []
@@ -152,9 +169,8 @@ module Mongo
       @secondary_pools = []
       @hosts = Set.new
       @members = Set.new
-      @tags_to_pools = {}
-      @tag_map = {}
       @refresh_required = false
+      @pinned_pools = {}
     end
 
     # Connect to each member of the replica set
@@ -167,7 +183,7 @@ module Mongo
 
       seed.node_list.each do |host|
         node = Mongo::Node.new(self.connection, host)
-        if node.connect && node.set_config
+        if node.connect && node.set_config && node.healthy?
           members << node
         end
       end
@@ -180,13 +196,6 @@ module Mongo
       members
     end
 
-    def associate_tags_with_pool(tags, pool)
-      tags.each_key do |key|
-        @tags_to_pools[{key => tags[key]}] ||= []
-        @tags_to_pools[{key => tags[key]}] << pool
-      end
-    end
-
     # Initialize the connection pools for the primary and secondary nodes.
     def initialize_pools(members)
       members.each do |member|
@@ -208,68 +217,48 @@ module Mongo
       member.last_state = :primary
       @primary = member.host_port
       @primary_pool = Pool.new(self.connection, member.host, member.port,
-                              :size => self.connection.pool_size,
-                              :timeout => self.connection.pool_timeout,
-                              :node => member)
-      associate_tags_with_pool(member.tags, @primary_pool)
+        :size => self.connection.pool_size,
+        :timeout => self.connection.pool_timeout,
+        :node => member
+      )
     end
 
     def assign_secondary(member)
       member.last_state = :secondary
       @secondaries << member.host_port
       pool = Pool.new(self.connection, member.host, member.port,
-                                   :size => self.connection.pool_size,
-                                   :timeout => self.connection.pool_timeout,
-                                   :node => member)
+        :size => self.connection.pool_size,
+        :timeout => self.connection.pool_timeout,
+        :node => member
+      )
       @secondary_pools << pool
-      associate_tags_with_pool(member.tags, pool)
     end
 
-    # If there's more than one pool associated with
-    # a given tag, choose a close one using the bucket method.
-    def set_tag_mappings
-      @tags_to_pools.each do |key, pool_list|
-        if pool_list.length == 1
-          @tag_map[key] = pool_list.first
-        else
-          @tag_map[key] = nearby_pool_from_set(pool_list)
-        end
-      end
-    end
-
-    # Pick a node from the set of possible secondaries.
-    # If more than one node is available, use the ping
-    # time to figure out which nodes to choose from.
-    def set_read_pool
-      if @secondary_pools.empty?
-        @read_pool = @primary_pool
-      elsif @secondary_pools.size == 1
-        @read_pool = @secondary_pools[0]
-        @secondary_pool = @read_pool
-      else
-        @read_pool = nearby_pool_from_set(@secondary_pools)
-        @secondary_pool = @read_pool
-      end
-    end
+    def select_pool(candidates, tag_sets, acceptable_latency)
+      tag_sets = [tag_sets] unless tag_sets.is_a?(Array)
 
-    def nearby_pool_from_set(pool_set)
-      ping_ranges = Array.new(3) { |i| Array.new }
-        pool_set.each do |pool|
-          case pool.ping_time
-            when 0..150
-              ping_ranges[0] << pool
-            when 150..1000
-              ping_ranges[1] << pool
-            else
-              ping_ranges[2] << pool
+      if !tag_sets.empty?
+        matches = []
+        tag_sets.detect do |tag_set|
+          matches = candidates.select do |candidate|
+            tag_set.none? { |k,v| candidate.tags[k.to_s] != v } &&
+            candidate.ping_time
           end
+          !matches.empty?
         end
+      else
+        matches = candidates
+      end
 
-        for list in ping_ranges do
-          break if !list.empty?
-        end
+      matches.empty? ? nil : near_pool(matches, acceptable_latency)
+    end
 
-      list[rand(list.length)]
+    def near_pool(pool_set, acceptable_latency)
+      nearest_pool = pool_set.min_by { |pool| pool.ping_time }
+      near_pools = pool_set.select do |pool|
+        (pool.ping_time - nearest_pool.ping_time) <= acceptable_latency
+      end
+      near_pools[ rand(near_pools.length) ]
     end
 
     # Iterate through the list of provided seed
@@ -278,11 +267,11 @@ module Mongo
     #
     # If we don't get a response, raise an exception.
     def get_valid_seed_node
-      seed_list.each do |seed|
+      @seeds.each do |seed|
         node = Mongo::Node.new(self.connection, seed)
         if !node.connect
           next
-        elsif node.set_config
+        elsif node.set_config && node.healthy?
           return node
         else
           node.close
@@ -290,12 +279,10 @@ module Mongo
       end
 
       raise ConnectionFailure, "Cannot connect to a replica set using seeds " +
-        "#{seed_list.map {|s| "#{s[0]}:#{s[1]}" }.join(', ')}"
+        "#{@seeds.map {|s| "#{s[0]}:#{s[1]}" }.join(', ')}"
     end
 
-    def seed_list
-      @seeds | @original_seeds
-    end
+    private
 
     def cache_discovered_seeds(members)
       @seeds = members.map { |n| n.host_port }