mongo 1.4.0 → 1.5.0.rc0

data/test/replica_sets/rs_test_helper.rb

@@ -2,12 +2,19 @@ $:.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
+module ReplicaSetTest
+
+  def self.rs
+    unless defined?(@rs)
+      @rs = ReplSetManager.new
+      @rs.start_set
+    end
+    @rs
+  end
 
-class Test::Unit::TestCase
+  def rs
+    ReplicaSetTest.rs
+  end
 
   # Generic code for rescuing connection failures and retrying operations.
   # This could be combined with some timeout functionality.
@@ -23,5 +30,4 @@ class Test::Unit::TestCase
       retry
     end
   end
-
 end

data/test/replica_sets/threading_test.rb

@@ -0,0 +1,111 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require './test/replica_sets/rs_test_helper'
+
+class ReplicaSetThreadingTest < Test::Unit::TestCase
+  include ReplicaSetTest
+
+  def setup_safe_data
+    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
+                                 :pool_size => 100)
+    @db = @conn[MONGO_TEST_DB]
+    @coll = @db.collection('thread-test-collection')
+    @db.drop_collection('duplicate')
+    @db.drop_collection('unique')
+    @duplicate = @db.collection('duplicate')
+    @unique    = @db.collection('unique')
+
+    @duplicate.insert("test" => "insert")
+    @duplicate.insert("test" => "update")
+    @unique.insert("test" => "insert")
+    @unique.insert("test" => "update")
+    @unique.create_index("test", :unique => true)
+  end
+
+  def test_safe_update
+    setup_safe_data
+    times = []
+    threads = []
+    100.times do |i|
+      threads[i] = Thread.new do
+        10.times do
+          if i % 2 == 0
+            assert_raise Mongo::OperationFailure do
+              t1 = Time.now
+              @unique.update({"test" => "insert"},
+                             {"$set" => {"test" => "update"}}, :safe => true)
+              times << Time.now - t1
+            end
+          else
+            t1 = Time.now
+            @duplicate.update({"test" => "insert"},
+                              {"$set" => {"test" => "update"}}, :safe => true)
+            times << Time.now - t1
+          end
+        end
+      end
+    end
+
+    100.times do |i|
+      threads[i].join
+    end
+    @conn.close
+  end
+
+  def test_safe_insert
+    setup_safe_data
+    threads = []
+    100.times do |i|
+      threads[i] = Thread.new do
+        if i % 2 == 0
+          assert_raise Mongo::OperationFailure do
+            @unique.insert({"test" => "insert"}, :safe => true)
+          end
+        else
+          @duplicate.insert({"test" => "insert"}, :safe => true)
+        end
+      end
+    end
+
+    100.times do |i|
+      threads[i].join
+    end
+    @conn.close
+  end
+
+  def setup_replica_set_connection
+    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[0]],
+                                 :pool_size => 100, :auto_refresh => :sync,
+                                 :refresh_interval => 2)
+    @db = @conn[MONGO_TEST_DB]
+    @coll = @db.collection('thread-test-collection')
+  end
+
+  def test_threading_with_queries
+    setup_replica_set_connection
+    @coll.drop
+    @coll = @db.collection('thread-test-collection')
+
+    1000.times do |i|
+      @coll.insert("x" => i)
+    end
+
+    threads = []
+
+    10.times do |i|
+      threads[i] = Thread.new do
+        100.times do
+          sum = 0
+          @coll.find().each do |document|
+            sum += document["x"]
+          end
+          assert_equal 499500, sum
+        end
+      end
+    end
+
+    10.times do |i|
+      threads[i].join
+    end
+    @conn.close
+  end
+end

data/test/test_helper.rb

@@ -82,6 +82,7 @@ class Test::Unit::TestCase
     socket = Object.new
     socket.stubs(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
     socket.stubs(:close)
+    socket.stubs(:closed?)
     socket
   end
 
@@ -93,8 +94,14 @@ class Test::Unit::TestCase
     begin
       yield
     rescue => e
-      assert_equal klass, e.class
-      assert e.message.include?(message), "#{e.message} does not include #{message}."
+      if klass.to_s != e.class.to_s
+        flunk "Expected exception class #{klass} but got #{e.class}.\n #{e.backtrace}"
+      end
+
+      if !e.message.include?(message)
+        p e.backtrace
+        flunk "#{e.message} does not include #{message}.\n#{e.backtrace}"
+      end
     else
       flunk "Expected assertion #{klass} but none was raised."
     end

data/test/threading_test.rb

@@ -4,7 +4,8 @@ class TestThreading < Test::Unit::TestCase
 
   include Mongo
 
-  @@db = standard_connection(:pool_size => 1, :timeout => 30).db(MONGO_TEST_DB)
+  @@con = standard_connection(:pool_size => 10, :timeout => 30)
+  @@db  = @@con[MONGO_TEST_DB]
   @@coll = @@db.collection('thread-test-collection')
 
   def set_up_safe_data
@@ -21,16 +22,23 @@ class TestThreading < Test::Unit::TestCase
   end
 
   def test_safe_update
+    times = []
     set_up_safe_data
     threads = []
     100.times do |i|
       threads[i] = Thread.new do
-        if i % 2 == 0
-          assert_raise Mongo::OperationFailure do
-            @unique.update({"test" => "insert"}, {"$set" => {"test" => "update"}}, :safe => true)
+        100.times do
+          if i % 2 == 0
+            assert_raise Mongo::OperationFailure do
+              t1 = Time.now
+              @unique.update({"test" => "insert"}, {"$set" => {"test" => "update"}}, :safe => true)
+              times << Time.now - t1
+            end
+          else
+            t1 = Time.now
+            @duplicate.update({"test" => "insert"}, {"$set" => {"test" => "update"}}, :safe => true)
+            times << Time.now - t1
           end
-        else
-          @duplicate.update({"test" => "insert"}, {"$set" => {"test" => "update"}}, :safe => true)
         end
       end
     end

data/test/tools/repl_set_manager.rb

@@ -20,13 +20,14 @@ class ReplSetManager
     @retries    = opts[:retries] || 30
     @config     = {"_id" => @name, "members" => []}
     @durable    = opts.fetch(:durable, false)
+    @smallfiles = opts.fetch(:smallfiles, true)
     @path       = File.join(File.expand_path(File.dirname(__FILE__)), "data")
-    @oplog_size = opts.fetch(:oplog_size, 32)
+    @oplog_size = opts.fetch(:oplog_size, 16)
     @tags = [{"dc" => "ny", "rack" => "a", "db" => "main"},
              {"dc" => "ny", "rack" => "b", "db" => "main"},
              {"dc" => "sf", "rack" => "a", "db" => "main"}]
 
-    @arbiter_count   = opts[:arbiter_count]   || 2
+    @arbiter_count   = opts[:arbiter_count]   || 0
     @secondary_count = opts[:secondary_count] || 2
     @passive_count   = opts[:passive_count] || 0
     @primary_count   = 1
@@ -43,19 +44,10 @@ class ReplSetManager
   end
 
   def start_set
-    begin
-    con = Mongo::Connection.new(@host, @start_port)
-      rescue Mongo::ConnectionFailure
-    end
-
-    if con && ensure_up(1, con)
-      should_start = false
-      puts "** Replica set already started."
-    else
-      should_start = true
-      system("killall mongod")
-      puts "** Starting a replica set with #{@count} nodes"
-    end
+    system("killall mongod")
+    sleep(1)
+    should_start = true
+    puts "** Starting a replica set with #{@count} nodes"
 
     n = 0
     (@primary_count + @secondary_count).times do
@@ -81,15 +73,8 @@ class ReplSetManager
       n += 1
     end
 
-    if con && ensure_up(1, con)
-      @mongods.each do |k, v|
-        v['up'] = true
-        v['pid'] = File.open(File.join(v['db_path'], 'mongod.lock')).read.strip
-      end
-    else
-      initiate
-      ensure_up
-    end
+    initiate
+    ensure_up
   end
 
   def cleanup_set
@@ -142,6 +127,7 @@ class ReplSetManager
     @mongods[n]['start'] = "mongod --replSet #{@name} --logpath '#{@mongods[n]['log_path']}' " +
      "--oplogSize #{@oplog_size} #{journal_switch} --dbpath #{@mongods[n]['db_path']} --port #{@mongods[n]['port']} --fork"
     @mongods[n]['start'] += " --dur" if @durable
+    @mongods[n]['start'] += " --smallfiles" if @smallfiles
     @mongods[n]['start']
   end
 
@@ -157,7 +143,7 @@ class ReplSetManager
     @config['version'] = config['version'] + 1
 
     begin
-    con['admin'].command({'replSetReconfig' => @config})
+      con['admin'].command({'replSetReconfig' => @config})
     rescue Mongo::ConnectionFailure
     end
 
@@ -169,8 +155,8 @@ class ReplSetManager
   def add_node(n=nil)
     primary = get_node_with_state(1)
     con = get_connection(primary)
-    init_node(n || @mongods.length)
 
+    init_node(n || @mongods.length)
     config = con['local']['system.replset'].find_one
     @config['version'] = config['version'] + 1
 
@@ -187,9 +173,8 @@ class ReplSetManager
   def kill(node, signal=2)
     pid = @mongods[node]['pid']
     puts "** Killing node with pid #{pid} at port #{@mongods[node]['port']}"
-    system("kill -#{signal} #{@mongods[node]['pid']}")
+    system("kill #{pid}")
     @mongods[node]['up'] = false
-    sleep(1)
   end
 
   def kill_primary(signal=2)
@@ -254,21 +239,49 @@ class ReplSetManager
     print "** Ensuring members are up..."
 
     attempt(n) do
-      con = connection || 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"
-        con.close
-        return status
-      else
+      con = connection || get_connection
+      begin
+        status = con['admin'].command({:replSetGetStatus => 1})
+      rescue Mongo::OperationFailure => ex
         con.close
-        raise Mongo::OperationFailure
+        raise ex
       end
-    end
-
+      if status['members'].all? { |m| m['health'] == 1 &&
+       [1, 2, 7].include?(m['state']) } &&
+       status['members'].any? { |m| m['state'] == 1 }
+
+       connections = []
+       states      = []
+       status['members'].each do |member|
+         begin
+           host, port = member['name'].split(':')
+           port = port.to_i
+           conn = Mongo::Connection.new(host, port, :slave_ok => true)
+           connections << conn
+           state = conn['admin'].command({:ismaster => 1})
+           states << state
+         rescue Mongo::ConnectionFailure
+           connections.each {|c| c.close }
+           con.close
+           raise Mongo::OperationFailure
+         end
+       end
+
+       if states.any? {|s| s['ismaster']}
+         print "all members up!\n\n"
+         connections.each {|c| c.close }
+         con.close
+         return status
+       else
+         con.close
+         raise Mongo::OperationFailure
+       end
+     else
+       con.close
+       raise Mongo::OperationFailure
+     end
+     end
     return false
   end
 
@@ -298,9 +311,11 @@ class ReplSetManager
   private
 
   def initiate
+    puts "Initiating replica set..."
     con = get_connection
 
     attempt do
+      con.object_id
       con['admin'].command({'replSetInitiate' => @config})
     end
 

data/test/unit/collection_test.rb

@@ -5,7 +5,7 @@ class CollectionTest < Test::Unit::TestCase
   context "Basic operations: " do
     setup do
       @logger = mock()
-      @logger.expects(:debug)
+      @logger.expects(:warn)
     end
 
     should "send update message" do
@@ -36,6 +36,7 @@ class CollectionTest < Test::Unit::TestCase
       @conn = Connection.new('localhost', 27017, :logger => @logger, :connect => false)
       @db   = @conn['testing']
       @coll = @db.collection('books')
+      @conn.expects(:checkout_writer).returns(mock())
       @conn.expects(:receive_message).with do |op, msg, log, sock|
         op == 2004
       end.returns([[], 0, 0])

data/test/unit/connection_test.rb

@@ -40,6 +40,12 @@ class ConnectionTest < Test::Unit::TestCase
         assert_equal [host_name, 27017], @conn.host_to_try
       end
 
+      should "allow db without username and password" do
+        host_name = "foo.bar-12345.org"
+        @conn = Connection.from_uri("mongodb://#{host_name}/foo", :connect => false)
+        assert_equal [host_name, 27017], @conn.host_to_try
+      end
+
       should "parse a uri with a hyphen & underscore in the username or password" do
         @conn = Connection.from_uri("mongodb://hyphen-user_name:p-s_s@localhost:27017/db", :connect => false)
         assert_equal ['localhost', 27017], @conn.host_to_try
@@ -65,16 +71,10 @@ class ConnectionTest < Test::Unit::TestCase
         assert_raise MongoArgumentError do
           Connection.from_uri("mongodb://localhost:abc", :connect => false)
         end
-
-        assert_raise MongoArgumentError do
-          Connection.from_uri("mongodb://localhost:27017, my.db.com:27018, ", :connect => false)
-        end
       end
 
-      should "require all of username, password, and database if any one is specified" do
-        assert_raise MongoArgumentError do
-          Connection.from_uri("mongodb://localhost/db", :connect => false)
-        end
+      should "require all of username, if password and db are specified" do
+        assert Connection.from_uri("mongodb://kyle:jones@localhost/db", :connect => false)
 
         assert_raise MongoArgumentError do
           Connection.from_uri("mongodb://kyle:password@localhost", :connect => false)

data/test/unit/grid_test.rb

@@ -19,7 +19,8 @@ class GridTest < Test::Unit::TestCase
 
     context "Grid classe with standard connections" do
       setup do
-        @conn.expects(:slave_ok?).returns(false)
+        @conn.expects(:class).returns(Connection)
+        @conn.expects(:read_primary?).returns(true)
       end
 
       should "create indexes for Grid" do
@@ -36,7 +37,8 @@ class GridTest < Test::Unit::TestCase
 
     context "Grid classes with slave connection" do
       setup do
-        @conn.expects(:slave_ok?).returns(true)
+        @conn.expects(:class).twice.returns(Connection)
+        @conn.expects(:read_primary?).returns(false)
       end
 
       should "not create indexes for Grid" do

data/test/unit/pool_manager_test.rb

@@ -12,6 +12,7 @@ class PoolManagerTest < Test::Unit::TestCase
       @connection = stub("Connection")
       @connection.stubs(:connect_timeout).returns(5000)
       @connection.stubs(:pool_size).returns(2)
+      @connection.stubs(:pool_timeout).returns(100)
       @connection.stubs(:socket_class).returns(TCPSocket)
       @connection.stubs(:[]).returns(@db)