mongo 1.6.4 → 1.7.0.rc0

data/test/replica_sets/count_test.rb

@@ -5,7 +5,7 @@ class ReplicaSetCountTest < Test::Unit::TestCase
 
   def setup
     ensure_rs
-    @conn = ReplSetConnection.new(build_seeds(3), :read => :secondary)
+    @conn = ReplSetConnection.new(build_seeds(3), :read => :primary_preferred)
     assert @conn.primary_pool
     @primary = Connection.new(@conn.primary_pool.host, @conn.primary_pool.port)
     @db = @conn.db(MONGO_TEST_DB)

data/test/replica_sets/cursor_test.rb

@@ -0,0 +1,70 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/replica_sets/rs_test_helper'
+
+class ReplicaSetCursorTest < Test::Unit::TestCase
+  def setup
+    ensure_rs
+  end
+
+  def test_cursors_get_closed
+    setup_connection
+    assert_cursor_count
+  end
+
+  def test_cursors_get_closed_secondary
+    setup_connection(:secondary)
+    assert_cursor_count
+  end
+
+  private
+
+  def setup_connection(read=:primary)
+    # Setup ReplicaSet Connection
+    @replconn = Mongo::ReplSetConnection.new(
+      build_seeds(3),
+      :read => read
+    )
+    
+    @db = @replconn.db(MONGO_TEST_DB)
+    @db.drop_collection("cursor_tests")
+    @coll = @db.collection("cursor_tests")
+
+    @coll.insert({:a => 1}, :safe => true, :w => 3)
+    @coll.insert({:b => 2}, :safe => true, :w => 3)
+    @coll.insert({:c => 3}, :safe => true, :w => 3)
+
+    # Pin reader
+    @coll.find_one
+
+    # Setup Direct Connections
+    @primary = Mongo::Connection.new(*@replconn.manager.primary)
+    @read = Mongo::Connection.new(*@replconn.manager.read)
+  end
+
+  def cursor_count(connection)
+    connection['cursor_tests'].command({:cursorInfo => 1})['totalOpen']
+  end
+
+  def query_count(connection)
+    connection['admin'].command({:serverStatus => 1})['opcounters']['query']
+  end
+
+  def assert_cursor_count
+    before_primary = cursor_count(@primary)
+    before_read = cursor_count(@read)
+    before_query = query_count(@read)
+
+    @coll.find.limit(2).to_a
+    sleep(1)
+
+    after_primary = cursor_count(@primary)
+    after_read = cursor_count(@read)
+    after_query = query_count(@read)
+
+    assert_equal before_primary, after_primary
+    assert_equal before_read, after_read
+    assert_equal 1, after_query - before_query
+  end
+
+end
+

data/test/replica_sets/read_preference_test.rb

@@ -5,80 +5,169 @@ require 'logger'
 class ReadPreferenceTest < Test::Unit::TestCase
 
   def setup
-    ensure_rs
-    log = Logger.new("test.log")
-    seeds = build_seeds(2)
-    args = {
-      :read => :secondary,
-      :pool_size => 50,
-      :refresh_mode => false,
-      :refresh_interval => 5,
-      :logger => log
-    }
-    @conn = ReplSetConnection.new(seeds, args)
-    @db = @conn.db(MONGO_TEST_DB)
-    @db.drop_collection("test-sets")
-  end
+    ensure_rs(:secondary_count => 1, :arbiter_count => 1)
 
-  def teardown
-    @rs.restart_killed_nodes
+    # Insert data
+    conn = Connection.new(@rs.host, @rs.primary[1])
+    db = conn.db(MONGO_TEST_DB)
+    coll = db.collection("test-sets")
+    coll.save({:a => 20}, :safe => {:w => 2})
   end
 
   def test_read_primary
+    conn = make_connection
+    rescue_connection_failure do
+      assert conn.read_primary?
+      assert conn.primary?
+    end
+
+    conn = make_connection(:primary_preferred)
     rescue_connection_failure do
-      assert !@conn.read_primary?
-      assert !@conn.primary?
+      assert conn.read_primary?
+      assert conn.primary?
+    end
+
+    conn = make_connection(:secondary)
+    rescue_connection_failure do
+      assert !conn.read_primary?
+      assert !conn.primary?
+    end
+
+    conn = make_connection(:secondary_preferred)
+    rescue_connection_failure do
+      assert !conn.read_primary?
+      assert !conn.primary?
     end
   end
 
-  def test_con
-    assert @conn.primary_pool, "No primary pool!"
-    assert @conn.read_pool, "No read pool!"
-    assert @conn.primary_pool.port != @conn.read_pool.port,
-      "Primary port and read port at the same!"
+  def test_connection_pools
+    conn = make_connection
+    assert conn.primary_pool, "No primary pool!"
+    assert conn.read_pool, "No read pool!"
+    assert conn.primary_pool.port == conn.read_pool.port,
+      "Primary port and read port are not the same!"
+
+    conn = make_connection(:primary_preferred)
+    assert conn.primary_pool, "No primary pool!"
+    assert conn.read_pool, "No read pool!"
+    assert conn.primary_pool.port == conn.read_pool.port,
+      "Primary port and read port are not the same!"
+
+    conn = make_connection(:secondary)
+    assert conn.primary_pool, "No primary pool!"
+    assert conn.read_pool, "No read pool!"
+    assert conn.primary_pool.port != conn.read_pool.port,
+      "Primary port and read port are the same!"
+
+    conn = make_connection(:secondary_preferred)
+    assert conn.primary_pool, "No primary pool!"
+    assert conn.read_pool, "No read pool!"
+    assert conn.primary_pool.port != conn.read_pool.port,
+      "Primary port and read port are the same!"
   end
 
-  def test_read_secondary_only
-    @rs.add_arbiter
-    @rs.remove_secondary_node
-    
-    @conn = ReplSetConnection.new(build_seeds(3), :read => :secondary_only)
+  def test_read_routing
+    prepare_routing_test
 
-    @db = @conn.db(MONGO_TEST_DB)
-    @coll = @db.collection("test-sets")
-    
-    @coll.save({:a => 20}, :safe => {:w => 2})
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
+  end
 
-    # Test that reads are going to secondary on ReplSetConnection
-    @secondary = Connection.new(@rs.host, @conn.secondary_pool.port, :slave_ok => true)
-    queries_before = @secondary['admin'].command({:serverStatus => 1})['opcounters']['query']
-    @coll.find_one
-    queries_after = @secondary['admin'].command({:serverStatus => 1})['opcounters']['query']
-    assert_equal 1, queries_after - queries_before
+  def test_read_routing_with_primary_down
+    prepare_routing_test
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
+
+    # Kill the primary so only a single secondary exists
+    @rs.kill_primary
 
+    # Test that reads are going to the right members
+    assert_raise_error ConnectionFailure do
+      @primary[MONGO_TEST_DB]['test-sets'].find_one
+    end
+    assert_query_route(@primary_preferred, @secondary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
+
+    # Restore set
+    @rs.restart_killed_nodes
+    sleep(1)
+    @repl_cons.each { |con| con.refresh }
+    sleep(1)
+    @primary_direct = Connection.new(
+      @rs.host,
+      @primary.read_pool.port
+    )
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
+  end
+
+  def test_read_routing_with_secondary_down
+    prepare_routing_test
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
+
+    # Kill the secondary so that only primary exists
     @rs.kill_secondary
-    @conn.refresh
-    
-    # Test that reads are only allowed from secondaries
-    assert_raise ConnectionFailure.new("Could not checkout a socket.") do
-      @coll.find_one
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_raise_error ConnectionFailure do
+      @secondary[MONGO_TEST_DB]['test-sets'].find_one
     end
-        
-    @rs = ReplSetManager.new
-    @rs.start_set
+    assert_query_route(@secondary_preferred, @primary_direct)
+
+    # Restore set
+    @rs.restart_killed_nodes
+    sleep(1)
+    @repl_cons.each { |con| con.refresh }
+    sleep(1)
+    @secondary_direct = Connection.new(
+      @rs.host,
+      @secondary.read_pool.port,
+      :slave_ok => true
+    )
+
+    # Test that reads are going to the right members
+    assert_query_route(@primary, @primary_direct)
+    assert_query_route(@primary_preferred, @primary_direct)
+    assert_query_route(@secondary, @secondary_direct)
+    assert_query_route(@secondary_preferred, @secondary_direct)
   end
 
-  def test_query_secondaries
-    @secondary = Connection.new(@rs.host, @conn.read_pool.port, :slave_ok => true)
-    @coll = @db.collection("test-sets", :safe => {:w => 3, :wtimeout => 20000})
+  def test_write_conecern
+    @conn = make_connection(:secondary_preferred)
+    @db = @conn[MONGO_TEST_DB]
+    @coll = @db.collection("test-sets", :safe => {
+      :w => 2, :wtimeout => 20000
+    })
     @coll.save({:a => 20})
     @coll.save({:a => 30})
     @coll.save({:a => 40})
+
+    # pin the read pool
+    @coll.find_one
+    @secondary = Connection.new(@rs.host, @conn.read_pool.port, :slave_ok => true)
+
     results = []
-    queries_before = @secondary['admin'].command({:serverStatus => 1})['opcounters']['query']
     @coll.find.each {|r| results << r["a"]}
-    queries_after = @secondary['admin'].command({:serverStatus => 1})['opcounters']['query']
-    assert_equal 1, queries_after - queries_before
+
     assert results.include?(20)
     assert results.include?(30)
     assert results.include?(40)
@@ -87,57 +176,17 @@ class ReadPreferenceTest < Test::Unit::TestCase
 
     results = []
     rescue_connection_failure do
-      #puts "@coll.find().each"
       @coll.find.each {|r| results << r}
       [20, 30, 40].each do |a|
         assert results.any? {|r| r['a'] == a}, "Could not find record for a => #{a}"
       end
     end
-  end
-
-  def test_kill_primary
-    @coll = @db.collection("test-sets", :safe => {:w => 3, :wtimeout => 10000})
-    @coll.save({:a => 20})
-    @coll.save({:a => 30})
-    assert_equal 2, @coll.find.to_a.length
-
-    # Should still be able to read immediately after killing master node
-    @rs.kill_primary
-    assert_equal 2, @coll.find.to_a.length
-    rescue_connection_failure do
-      @coll.save({:a => 50}, :safe => {:w => 2, :wtimeout => 10000})
-    end
     @rs.restart_killed_nodes
-    sleep(1)
-    @coll.save({:a => 50}, :safe => {:w => 2, :wtimeout => 10000})
-    assert_equal 4, @coll.find.to_a.length
-  end
-
-  def test_kill_secondary
-    @coll = @db.collection("test-sets", {:safe => {:w => 3, :wtimeout => 20000}})
-    @coll.save({:a => 20})
-    @coll.save({:a => 30})
-    assert_equal 2, @coll.find.to_a.length
-
-    read_node = @rs.get_node_from_port(@conn.read_pool.port)
-    @rs.kill(read_node)
-
-    # Should fail immediately on next read
-    old_read_pool_port = @conn.read_pool.port
-    assert_raise ConnectionFailure do
-      @coll.find.to_a.length
-    end
-
-    # Should eventually reconnect and be able to read
-    rescue_connection_failure do
-      length = @coll.find.to_a.length
-      assert_equal 2, length
-    end
-    new_read_pool_port = @conn.read_pool.port
-    assert old_read_pool_port != new_read_pool_port
   end
 
   def test_write_lots_of_data
+    @conn = make_connection(:secondary_preferred)
+    @db = @conn[MONGO_TEST_DB]
     @coll = @db.collection("test-sets", {:safe => {:w => 2}})
 
     6000.times do |n|
@@ -149,33 +198,37 @@ class ReadPreferenceTest < Test::Unit::TestCase
     cursor.close
   end
 
-  # TODO: enable this once we enable reads from tags.
-  # def test_query_tagged
-  #   col = @db['mongo-test']
+  private
 
-  #   col.insert({:a => 1}, :safe => {:w => 3})
-  #   col.find_one({}, :read => {:db => "main"})
-  #   col.find_one({}, :read => {:dc => "ny"})
-  #   col.find_one({}, :read => {:dc => "sf"})
+  def prepare_routing_test
+    # Setup replica set connections
+    @primary = make_connection(:primary)
+    @primary_preferred = make_connection(:primary_preferred)
+    @secondary = make_connection(:secondary)
+    @secondary_preferred = make_connection(:secondary_preferred)
+    @repl_cons = [@primary, @primary_preferred, @secondary, @secondary_preferred]
 
-  #   assert_raise Mongo::NodeWithTagsNotFound do
-  #     col.find_one({}, :read => {:foo => "bar"})
-  #   end
-
-  #   threads = []
-  #   100.times do
-  #     threads << Thread.new do
-  #       col.find_one({}, :read => {:dc => "sf"})
-  #     end
-  #   end
-
-  #   threads.each {|t| t.join }
+    # Setup direct connections
+    @primary_direct = Connection.new(@rs.host, @primary.read_pool.port)
+    @secondary_direct = Connection.new(@rs.host, @secondary.read_pool.port, :slave_ok => true)
+  end
 
-  #   col.remove
-  # end
+  def make_connection(mode = :primary, opts = {})
+    opts.merge!({:read => mode})
+    ReplSetConnection.new(build_seeds(3), opts)
+  end
 
-  #def teardown
-  #  @rs.restart_killed_nodes
-  #end
+  def query_count(connection)
+    connection['admin'].command({:serverStatus => 1})['opcounters']['query']
+  end
 
+  def assert_query_route(test_connection, expected_target)
+    #puts "#{test_connection.read_pool.port} #{expected_target.read_pool.port}"
+    queries_before = query_count(expected_target)
+    assert_nothing_raised do
+      test_connection['MONGO_TEST_DB']['test-sets'].find_one
+    end
+    queries_after = query_count(expected_target)
+    assert_equal 1, queries_after - queries_before
+  end
 end

data/test/replica_sets/refresh_test.rb

@@ -69,12 +69,12 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
     
     rescue_connection_failure do
       @conn = ReplSetConnection.new(build_seeds(3),
-        :refresh_interval => 2, :refresh_mode => :sync)
+        :refresh_interval => 2, :refresh_mode => :sync, :read => :secondary_preferred)
     end
 
     assert_equal [], @conn.secondaries
     assert @conn.connected?
-    assert_equal @conn.read_pool, @conn.primary_pool
+    assert_equal @conn.manager.read, @conn.manager.primary
     old_refresh_version = @conn.refresh_version
 
     @rs.restart_killed_nodes
@@ -86,7 +86,7 @@ class ReplicaSetRefreshTest < Test::Unit::TestCase
       "Refresh version hasn't changed."
     assert @conn.secondaries.length > 0,
       "No secondaries have been added."
-    assert @conn.read_pool != @conn.primary_pool,
+    assert @conn.manager.read != @conn.manager.primary,
       "Read pool and primary pool are identical."
   end
   

data/test/replica_sets/refresh_with_threads_test.rb

@@ -15,13 +15,13 @@ class ReplicaSetRefreshWithThreadsTest < Test::Unit::TestCase
 
   def test_read_write_load_with_added_nodes
     # MongoDB < 2.0 will disconnect clients on rs.reconfig()
-    return true if @rs.version.first < 2
+    return true if @rs.version < "2"
 
     seeds = build_seeds(3)
     args = {
       :refresh_interval => 5,
       :refresh_mode => :sync,
-      :read => :secondary
+      :read => :secondary_preferred
     }
     @conn = ReplSetConnection.new(seeds, args)
     @duplicate = @conn[MONGO_TEST_DB]['duplicate']