mongo 1.1.4 → 1.1.5

data/test/replica_sets/query_test.rb

@@ -1,7 +1,5 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'mongo'
-require 'test/unit'
-require './test/test_helper'
+require './test/replica_sets/rs_test_helper'
 
 # NOTE: This test expects a replica set of three nodes to be running
 # on the local host.
@@ -9,24 +7,27 @@ class ReplicaSetQueryTest < Test::Unit::TestCase
   include Mongo
 
   def setup
-    @conn = Mongo::Connection.multi([['localhost', 27017], ['localhost', 27018], ['localhost', 27019]])
+    @conn = ReplSetConnection.new([RS.host, RS.ports[0]])
     @db = @conn.db(MONGO_TEST_DB)
     @db.drop_collection("test-sets")
     @coll = @db.collection("test-sets")
   end
 
+  def teardown
+    RS.restart_killed_nodes
+  end
+
   def test_query
-    @coll.save({:a => 20})
-    @coll.save({:a => 30})
-    @coll.save({:a => 40})
+    @coll.save({:a => 20}, :safe => {:w => 3})
+    @coll.save({:a => 30}, :safe => {:w => 3})
+    @coll.save({:a => 40}, :safe => {:w => 3})
     results = []
     @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
 
-    puts "Please disconnect the current master."
-    gets
+    RS.kill_primary
 
     results = []
     rescue_connection_failure do

data/test/replica_sets/replication_ack_test.rb

@@ -1,20 +1,17 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'mongo'
-require 'test/unit'
-require './test/test_helper'
+require './test/replica_sets/rs_test_helper'
 
 # NOTE: This test expects a replica set of three nodes to be running on local host.
 class ReplicaSetAckTest < Test::Unit::TestCase
   include Mongo
 
   def setup
-    @conn = Mongo::Connection.multi([['localhost', 27017], ['localhost', 27018], ['localhost', 27019]])
+    RS.ensure_up
 
-    master = [@conn.host, @conn.port]
-    @slaves = @conn.nodes - master
+    @conn = ReplSetConnection.new([RS.host, RS.ports[0]])
 
-    @slave1 = Mongo::Connection.new(@slaves[0][0], @slaves[0][1], :slave_ok => true)
-    @slave2 = Mongo::Connection.new(@slaves[1][0], @slaves[1][1], :slave_ok => true)
+    @slave1 = Connection.new(@conn.secondary_pools[0].host,
+      @conn.secondary_pools[0].port, :slave_ok => true)
 
     @db = @conn.db(MONGO_TEST_DB)
     @db.drop_collection("test-sets")
@@ -22,47 +19,43 @@ class ReplicaSetAckTest < Test::Unit::TestCase
   end
 
   def test_safe_mode_with_w_failure
-    assert_raise_error OperationFailure, "timed out waiting for slaves" do
+    assert_raise_error OperationFailure, "timeout" do
       @col.insert({:foo => 1}, :safe => {:w => 4, :wtimeout => 1, :fsync => true})
     end
-    assert_raise_error OperationFailure, "timed out waiting for slaves" do
+    assert_raise_error OperationFailure, "timeout" do
       @col.update({:foo => 1}, {:foo => 2}, :safe => {:w => 4, :wtimeout => 1, :fsync => true})
     end
-    assert_raise_error OperationFailure, "timed out waiting for slaves" do
+    assert_raise_error OperationFailure, "timeout" do
       @col.remove({:foo => 2}, :safe => {:w => 4, :wtimeout => 1, :fsync => true})
     end
   end
 
   def test_safe_mode_replication_ack
-    @col.insert({:baz => "bar"}, :safe => {:w => 3, :wtimeout => 1000})
+    @col.insert({:baz => "bar"}, :safe => {:w => 2, :wtimeout => 5000})
 
-    assert @col.insert({:foo => "0" * 10000}, :safe => {:w => 3, :wtimeout => 1000})
+    assert @col.insert({:foo => "0" * 5000}, :safe => {:w => 2, :wtimeout => 5000})
     assert_equal 2, @slave1[MONGO_TEST_DB]["test-sets"].count
-    assert_equal 2, @slave2[MONGO_TEST_DB]["test-sets"].count
 
-
-    assert @col.update({:baz => "bar"}, {:baz => "foo"}, :safe => {:w => 3, :wtimeout => 1000})
+    assert @col.update({:baz => "bar"}, {:baz => "foo"}, :safe => {:w => 2, :wtimeout => 5000})
     assert @slave1[MONGO_TEST_DB]["test-sets"].find_one({:baz => "foo"})
-    assert @slave2[MONGO_TEST_DB]["test-sets"].find_one({:baz => "foo"})
 
-    assert @col.remove({}, :safe => {:w => 3, :wtimeout => 1000})
+    assert @col.remove({}, :safe => {:w => 2, :wtimeout => 5000})
     assert_equal 0, @slave1[MONGO_TEST_DB]["test-sets"].count
-    assert_equal 0, @slave2[MONGO_TEST_DB]["test-sets"].count
   end
 
   def test_last_error_responses
     20.times { @col.insert({:baz => "bar"}) }
-    response = @db.get_last_error(:w => 3, :wtimeout => 10000)
+    response = @db.get_last_error(:w => 2, :wtimeout => 5000)
     assert response['ok'] == 1
     assert response['lastOp']
 
     @col.update({}, {:baz => "foo"}, :multi => true)
-    response = @db.get_last_error(:w => 3, :wtimeout => 1000)
+    response = @db.get_last_error(:w => 2, :wtimeout => 5000)
     assert response['ok'] == 1
     assert response['lastOp']
 
     @col.remove({})
-    response =  @db.get_last_error(:w => 3, :wtimeout => 1000)
+    response =  @db.get_last_error(:w => 2, :wtimeout => 5000)
     assert response['ok'] == 1
     assert response['n'] == 20
     assert response['lastOp']

data/test/replica_sets/rs_test_helper.rb

@@ -0,0 +1,29 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/test_helper'
+require './test/tools/repl_set_manager'
+
+unless defined? RS
+  RS = ReplSetManager.new
+  RS.start_set
+end
+
+class Test::Unit::TestCase
+
+  # Generic code for rescuing connection failures and retrying operations.
+  # This could be combined with some timeout functionality.
+  def rescue_connection_failure(max_retries=60)
+    success = false
+    tries   = 0
+    while !success && tries < max_retries
+      begin
+        yield
+        success = true
+      rescue Mongo::ConnectionFailure
+        puts "Rescue attempt #{tries}\n"
+        tries += 1
+        sleep(1)
+      end
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -22,7 +22,15 @@ end
 require 'bson_ext/cbson' if !(RUBY_PLATFORM =~ /java/) && ENV['C_EXT']
 
 unless defined? MONGO_TEST_DB
-  MONGO_TEST_DB = 'mongo-ruby-test'
+  MONGO_TEST_DB = 'ruby-test-db'
+end
+
+unless defined? TEST_PORT
+  TEST_PORT = ENV['MONGO_RUBY_DRIVER_PORT'] ? ENV['MONGO_RUBY_DRIVER_PORT'].to_i : Mongo::Connection::DEFAULT_PORT
+end
+
+unless defined? TEST_HOST
+  TEST_HOST = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
 end
 
 class Test::Unit::TestCase
@@ -30,8 +38,7 @@ class Test::Unit::TestCase
   include BSON
 
   def self.standard_connection(options={})
-    Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
-      ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT, options)
+    Connection.new(TEST_HOST, TEST_PORT, options)
   end
 
   def standard_connection(options={})
@@ -43,11 +50,11 @@ class Test::Unit::TestCase
   end
 
   def self.mongo_host
-    ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
+    TEST_HOST
   end
 
   def self.mongo_port
-    ENV['MONGO_RUBY_DRIVER_PORT'] ? ENV['MONGO_RUBY_DRIVER_PORT'].to_i : 27017
+    TEST_PORT
   end
 
   def host_port
@@ -62,21 +69,7 @@ class Test::Unit::TestCase
     self.class.mongo_port
   end
 
-  # Generic code for rescuing connection failures and retrying operations.
-  # This could be combined with some timeout functionality.
-  def rescue_connection_failure
-    success = false
-    while !success
-      begin
-        yield
-        success = true
-      rescue Mongo::ConnectionFailure
-        puts "Rescuing"
-        sleep(1)
-      end
-    end
-  end
-
+  
   def assert_raise_error(klass, message)
     begin
       yield

data/test/threading/{test_threading_large_pool.rb → threading_with_large_pool_test.rb}

@@ -1,4 +1,4 @@
-require 'test/test_helper'
+require './test/test_helper'
 
 # Essentialy the same as test_threading.rb but with an expanded pool for
 # testing multiple connections.

data/test/tools/repl_set_manager.rb

@@ -0,0 +1,241 @@
+#!/usr/bin/ruby
+
+STDOUT.sync = true
+
+unless defined? Mongo
+  require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'mongo')
+end
+
+class ReplSetManager
+
+  attr_accessor :host, :start_port, :ports, :name, :mongods
+
+  def initialize(opts={})
+    @start_port = opts[:start_port] || 30000
+    @ports      = []
+    @name       = opts[:name] || 'replica-set-foo'
+    @host       = opts[:host]  || 'localhost'
+    @retries    = opts[:retries] || 60
+    @config     = {"_id" => @name, "members" => []}
+    @path       = File.join(File.expand_path(File.dirname(__FILE__)), "data")
+
+    @arbiter_count   = opts[:arbiter_count]   || 2
+    @secondary_count = opts[:secondary_count] || 1
+    @passive_count   = opts[:passive_count] || 1
+    @primary_count   = 1
+
+    @count = @primary_count + @passive_count + @arbiter_count + @secondary_count
+    if @count > 7
+      raise StandardError, "Cannot create a replica set with #{node_count} nodes. 7 is the max."
+    end
+
+    @mongods   = {}
+  end
+
+  def start_set
+    puts "** Starting a replica set with #{@count} nodes"
+
+    system("killall mongod")
+
+    n = 0
+    (@primary_count + @secondary_count).times do |n|
+      init_node(n)
+      n += 1
+    end
+
+    @passive_count.times do
+      init_node(n) do |attrs|
+        attrs['priority'] = 0
+      end
+      n += 1
+    end
+
+    @arbiter_count.times do
+      init_node(n) do |attrs|
+        attrs['arbiterOnly'] = true
+      end
+      n += 1
+    end
+
+    initiate
+    ensure_up
+  end
+
+  def init_node(n)
+    @mongods[n] ||= {}
+    port = @start_port + n
+    @ports << port
+    @mongods[n]['port'] = port
+    @mongods[n]['db_path'] = get_path("rs-#{port}")
+    @mongods[n]['log_path'] = get_path("log-#{port}")
+    system("rm -rf #{@mongods[n]['db_path']}")
+    system("mkdir -p #{@mongods[n]['db_path']}")
+
+    @mongods[n]['start'] = "mongod --replSet #{@name} --logpath '#{@mongods[n]['log_path']}' " +
+     " --dbpath #{@mongods[n]['db_path']} --port #{@mongods[n]['port']} --fork"
+
+    start(n)
+
+    member = {'_id' => n, 'host' => "#{@host}:#{@mongods[n]['port']}"}
+
+    if block_given?
+      custom_attrs = {}
+      yield custom_attrs
+      member.merge!(custom_attrs)
+      @mongods[n].merge!(custom_attrs)
+    end
+
+    @config['members'] << member
+  end
+
+  def kill(node)
+    pid = @mongods[node]['pid']
+    puts "** Killing node with pid #{pid} at port #{@mongods[node]['port']}"
+    system("kill -2 #{@mongods[node]['pid']}")
+    @mongods[node]['up'] = false
+    sleep(1)
+  end
+
+  def kill_primary
+    node = get_node_with_state(1)
+    kill(node)
+    return node
+  end
+
+  # Note that we have to rescue a connection failure
+  # when we run the StepDown command because that
+  # command will close the connection.
+  def step_down_primary
+    primary = get_node_with_state(1)
+    con = get_connection(primary)
+    begin
+      con['admin'].command({'replSetStepDown' => 90})
+    rescue Mongo::ConnectionFailure
+    end
+  end
+
+  def kill_secondary
+    node = get_node_with_state(2)
+    kill(node)
+    return node
+  end
+
+  def restart_killed_nodes
+    nodes = @mongods.keys.select do |key|
+      @mongods[key]['up'] == false
+    end
+
+    nodes.each do |node|
+      start(node)
+    end
+
+    ensure_up
+  end
+
+  def get_node_from_port(port)
+    @mongods.keys.detect { |key| @mongods[key]['port'] == port }
+  end
+
+  def start(node)
+    system(@mongods[node]['start'])
+    @mongods[node]['up'] = true
+    sleep(0.5)
+    @mongods[node]['pid'] = File.open(File.join(@mongods[node]['db_path'], 'mongod.lock')).read.strip
+  end
+  alias :restart :start
+
+  def ensure_up
+    print "** Ensuring members are up..."
+
+    attempt do
+      con = get_connection
+      status = con['admin'].command({'replSetGetStatus' => 1})
+      print "."
+      if status['members'].all? { |m| m['health'] == 1 && [1, 2, 7].include?(m['state']) } &&
+         status['members'].any? { |m| m['state'] == 1 }
+        print "all members up!\n\n"
+        return status
+      else
+        raise Mongo::OperationFailure
+      end
+    end
+  end
+
+  def primary
+    nodes = get_all_host_pairs_with_state(1)
+    nodes.empty? ? nil : nodes[0]
+  end
+
+  def secondaries
+    get_all_host_pairs_with_state(2)
+  end
+
+  def arbiters
+    get_all_host_pairs_with_state(7)
+  end
+
+  private
+
+  def initiate
+    con = get_connection
+
+    attempt do
+      con['admin'].command({'replSetInitiate' => @config})
+    end
+  end
+
+  def get_node_with_state(state)
+    status = ensure_up
+    node = status['members'].detect {|m| m['state'] == state}
+    if node
+      host_port = node['name'].split(':')
+      port = host_port[1] ? host_port[1].to_i : 27017
+      key = @mongods.keys.detect {|key| @mongods[key]['port'] == port}
+      return key
+    else
+      return false
+    end
+  end
+
+  def get_all_host_pairs_with_state(state)
+    status = ensure_up
+    nodes = status['members'].select {|m| m['state'] == state}
+    nodes.map do |node|
+      host_port = node['name'].split(':')
+      port = host_port[1] ? host_port[1].to_i : 27017
+      [host, port]
+    end
+  end
+
+  def get_connection(node=nil)
+    con = attempt do
+      if !node
+        node = @mongods.keys.detect {|key| !@mongods[key]['arbiterOnly'] && @mongods[key]['up'] }
+      end
+      con = Mongo::Connection.new(@host, @mongods[node]['port'], :slave_ok => true)
+    end
+
+    return con
+  end
+
+  def get_path(name)
+    File.join(@path, name)
+  end
+
+  def attempt
+    raise "No block given!" unless block_given?
+    count = 0
+
+    while count < @retries do
+      begin
+        return yield
+        rescue Mongo::OperationFailure, Mongo::ConnectionFailure
+          sleep(1)
+          count += 1
+      end
+    end
+
+    raise exception
+  end
+
+end