mongo 1.8.0 → 1.8.2

data/test/replica_set/replication_ack_test.rb

@@ -7,8 +7,8 @@ class ReplicaSetAckTest < Test::Unit::TestCase
     @client = MongoReplicaSetClient.new(@rs.repl_set_seeds)
 
     @slave1 = MongoClient.new(
-      @client.secondary_pools[0].host,
-      @client.secondary_pools[0].port, :slave_ok => true)
+      @client.secondary_pools.first.host,
+      @client.secondary_pools.first.port, :slave_ok => true)
 
     assert !@slave1.read_primary?
 
@@ -21,33 +21,35 @@ class ReplicaSetAckTest < Test::Unit::TestCase
     @client.close if @conn
   end
 
-  def self.shutdown
-    @@cluster.stop
-    @@cluster.clobber
-  end
-
   def test_safe_mode_with_w_failure
     assert_raise_error OperationFailure, "timeout" do
-      @col.insert({:foo => 1}, :w => 4, :wtimeout => 1, :fsync => true)
+      @col.insert({:foo => 1}, :w => 3, :wtimeout => 1, :fsync => true)
     end
     assert_raise_error OperationFailure, "timeout" do
-      @col.update({:foo => 1}, {:foo => 2}, :w => 4, :wtimeout => 1, :fsync => true)
+      @col.update({:foo => 1}, {:foo => 2}, :w => 3, :wtimeout => 1, :fsync => true)
     end
     assert_raise_error OperationFailure, "timeout" do
-      @col.remove({:foo => 2}, :w => 4, :wtimeout => 1, :fsync => true)
+      @col.remove({:foo => 2}, :w => 3, :wtimeout => 1, :fsync => true)
+    end
+    assert_raise_error OperationFailure do
+      @col.insert({:foo => 3}, :w => "test-tag")
     end
   end
 
   def test_safe_mode_replication_ack
-    @col.insert({:baz => "bar"}, :w => 3, :wtimeout => 5000)
+    @col.insert({:baz => "bar"}, :w => 2, :wtimeout => 5000)
 
-    assert @col.insert({:foo => "0" * 5000}, :w => 3, :wtimeout => 5000)
+    assert @col.insert({:foo => "0" * 5000}, :w => 2, :wtimeout => 5000)
     assert_equal 2, @slave1[MONGO_TEST_DB]["test-sets"].count
 
-    assert @col.update({:baz => "bar"}, {:baz => "foo"}, :w => 3, :wtimeout => 5000)
+    assert @col.update({:baz => "bar"}, {:baz => "foo"}, :w => 2, :wtimeout => 5000)
     assert @slave1[MONGO_TEST_DB]["test-sets"].find_one({:baz => "foo"})
 
-    assert @col.remove({}, :w => 3, :wtimeout => 5000)
+    assert @col.insert({:foo => "bar"}, :w => "majority")
+
+    assert @col.insert({:bar => "baz"}, :w => :majority)
+
+    assert @col.remove({}, :w => 2, :wtimeout => 5000)
     assert_equal 0, @slave1[MONGO_TEST_DB]["test-sets"].count
   end
 

data/test/sharded_cluster/basic_test.rb

@@ -1,6 +1,10 @@
 require 'test_helper'
 include Mongo
 
+class Cursor
+  public :construct_query_spec
+end
+
 class BasicTest < Test::Unit::TestCase
   
   def setup
@@ -22,6 +26,32 @@ class BasicTest < Test::Unit::TestCase
     @client.close
   end
 
+  def test_connect_from_standard_client
+    mongos = @sc.mongos_seeds.first
+    @client = MongoClient.new(*mongos.split(':'))
+    assert @client.connected?
+    assert @client.mongos?
+    @client.close
+  end
+
+  def test_read_from_client
+    host, port = @sc.mongos_seeds.first.split(':')
+    tags = [{:dc => "mongolia"}] 
+    @client = MongoClient.new(host, port, {:read => :secondary, :tag_sets => tags})
+    assert @client.connected?
+    cursor = Cursor.new(@client[MONGO_TEST_DB]['whatever'], {})
+    assert_equal cursor.construct_query_spec['$readPreference'], {:mode => :secondary, :tags => tags}
+  end
+
+  def test_read_from_sharded_client
+    seeds = @sc.mongos_seeds
+    tags = [{:dc => "mongolia"}] 
+    @client = MongoShardedClient.new(seeds, {:read => :secondary, :tag_sets => tags})
+    assert @client.connected?
+    cursor = Cursor.new(@client[MONGO_TEST_DB]['whatever'], {})
+    assert_equal cursor.construct_query_spec['$readPreference'], {:mode => :secondary, :tags => tags}
+  end
+
   def test_hard_refresh
     seeds = @sc.mongos_seeds
     @client = MongoShardedClient.new(seeds)

data/test/test_helper.rb

@@ -6,29 +6,28 @@ class Test::Unit::TestCase
 
   TEST_DATA = File.join(File.dirname(__FILE__), 'data')
 
-  def ensure_cluster(kind=nil)
-    if defined?(@@current_class) and @@current_class == self.class
-      @@cluster.start
-    else
-      @@current_class = self.class
+  def ensure_cluster(kind=nil, opts={})
+    @@cluster ||= false
 
+    unless @@cluster
       if kind == :rs
-        opts = Mongo::Config::DEFAULT_REPLICA_SET
-        opts.merge!(:arbiters => 2)
+        cluster_opts = Mongo::Config::DEFAULT_REPLICA_SET.dup
       else
-        opts = Mongo::Config::DEFAULT_SHARDED_SIMPLE
-        opts.merge!(:routers => 4)
+        cluster_opts = Mongo::Config::DEFAULT_SHARDED_SIMPLE.dup
       end
 
+      cluster_opts.merge!(opts)
+
       dbpath = ENV['DBPATH'] || 'data'
-      opts.merge!(:dbpath => dbpath)
+      cluster_opts.merge!(:dbpath => dbpath)
 
       #debug 1, opts
-      config = Mongo::Config.cluster(opts)
+      config = Mongo::Config.cluster(cluster_opts)
       #debug 1, config
       @@cluster = Mongo::Config::ClusterManager.new(config)
-      @@cluster.start
     end
+
+    @@cluster.start
     instance_variable_set("@#{kind}", @@cluster)
   end
 
@@ -61,7 +60,7 @@ end
 
 begin
   silently { require 'shoulda' }
-  silently { require 'mocha' }
+  silently { require 'mocha/setup' }
 rescue LoadError
   puts <<MSG
 
@@ -74,8 +73,6 @@ MSG
   exit
 end
 
-require 'bson_ext/cbson' if !(RUBY_PLATFORM =~ /java/) && ENV['C_EXT']
-
 unless defined? MONGO_TEST_DB
   MONGO_TEST_DB = 'ruby-test-db'
 end
@@ -128,6 +125,19 @@ class Test::Unit::TestCase
     self.class.mongo_port
   end
 
+  def method_name
+    caller[0]=~/`(.*?)'/
+    $1
+  end
+
+  def step_down_command
+    # Adding force=true to avoid 'no secondaries within 10 seconds of my optime' errors
+    step_down_command = BSON::OrderedHash.new
+    step_down_command[:replSetStepDown] = 5
+    step_down_command[:force]           = true
+    step_down_command
+  end
+
   def new_mock_socket(host='localhost', port=27017)
     socket = Object.new
     socket.stubs(:setsockopt).with(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
@@ -136,6 +146,14 @@ class Test::Unit::TestCase
     socket
   end
 
+  def new_mock_unix_socket(sockfile='/tmp/mongod.sock')
+    socket = Object.new
+    socket.stubs(:setsockopt).with(Socket::IPPROTO_TCP)
+    socket.stubs(:close)
+    socket.stubs(:closed?)
+    socket
+  end
+
   def new_mock_db
     Object.new
   end

data/test/threading/basic_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class TestThreading < Test::Unit::TestCase
+
+  include Mongo
+
+  def setup
+    @client = standard_connection(:pool_size => 50, :pool_timeout => 60)
+    @db = @client.db(MONGO_TEST_DB)
+    @coll = @db.collection('thread-test-collection')
+    @coll.drop
+
+    collections = ['duplicate', 'unique']
+
+    collections.each do |coll_name|
+      coll = @db.collection(coll_name)
+      coll.drop
+      coll.insert("test" => "insert")
+      coll.insert("test" => "update")
+      instance_variable_set("@#{coll_name}", coll)
+    end
+
+    @unique.create_index("test", :unique => true)
+  end
+
+  def test_safe_update
+    threads = []
+    300.times do |i|
+      threads << Thread.new do
+        if i % 2 == 0
+          assert_raise Mongo::OperationFailure do
+            @unique.update({"test" => "insert"}, {"$set" => {"test" => "update"}})
+          end
+        else
+          @duplicate.update({"test" => "insert"}, {"$set" => {"test" => "update"}})
+          @duplicate.update({"test" => "update"}, {"$set" => {"test" => "insert"}})
+        end
+      end
+    end
+
+    threads.each {|thread| thread.join}
+  end
+
+  def test_safe_insert
+    threads = []
+    300.times do |i|
+      threads << Thread.new do
+        if i % 2 == 0
+          assert_raise Mongo::OperationFailure do
+            @unique.insert({"test" => "insert"})
+          end
+        else
+          @duplicate.insert({"test" => "insert"})
+        end
+      end
+    end
+
+    threads.each {|thread| thread.join}
+  end
+
+  def test_count
+    1000.times do |i|
+      @coll.insert({ "x" => i })
+    end
+
+    threads = []
+    10.times do |i|
+      threads << Thread.new do
+        sum = 0
+        @coll.find().each do |document|
+          sum += document["x"]
+        end
+        assert_equal 499500, sum
+      end
+    end
+
+    threads.each {|thread| thread.join}
+  end
+end

data/test/tools/mongo_config.rb

@@ -25,8 +25,8 @@ end
 module Mongo
   class Config
     DEFAULT_BASE_OPTS = { :host => 'localhost', :dbpath => 'data', :logpath => 'data/log'}
-    DEFAULT_REPLICA_SET = DEFAULT_BASE_OPTS.merge( :replicas => 3, :arbiters => 0 )
-    DEFAULT_SHARDED_SIMPLE = DEFAULT_BASE_OPTS.merge( :shards => 2, :configs => 1, :routers => 2 )
+    DEFAULT_REPLICA_SET = DEFAULT_BASE_OPTS.merge( :replicas => 2, :arbiters => 1 )
+    DEFAULT_SHARDED_SIMPLE = DEFAULT_BASE_OPTS.merge( :shards => 2, :configs => 1, :routers => 4 )
     DEFAULT_SHARDED_REPLICA = DEFAULT_SHARDED_SIMPLE.merge( :replicas => 3, :arbiters => 0)
 
     IGNORE_KEYS = [:host, :command, :_id]
@@ -35,7 +35,7 @@ module Mongo
     MONGODS_OPT_KEYS = [:mongods]
     CLUSTER_OPT_KEYS = SHARDING_OPT_KEYS + REPLICA_OPT_KEYS + MONGODS_OPT_KEYS
 
-    FLAGS = [:noprealloc, :smallfiles, :logappend, :configsvr, :shardsvr, :quiet]
+    FLAGS = [:noprealloc, :smallfiles, :logappend, :configsvr, :shardsvr, :quiet, :fastsync]
 
     DEFAULT_VERIFIES = 60
     BASE_PORT = 3000
@@ -102,13 +102,15 @@ module Mongo
       noprealloc = opts[:noprealloc] || true
       smallfiles = opts[:smallfiles] || true
       quiet      = opts[:quiet]      || true
+      fast_sync  = opts[:fastsync]   || false
 
       params.merge(
         :command => mongod,
         :dbpath => path,
         :smallfiles => smallfiles,
         :noprealloc => noprealloc,
-        :quiet => quiet
+        :quiet => quiet,
+        :fastsync => fast_sync
       )
     end
 
@@ -116,7 +118,7 @@ module Mongo
       params = make_mongod('replicas', opts)
 
       replSet    = opts[:replSet]    || 'ruby-driver-test'
-      oplog_size = opts[:oplog_size] || 10
+      oplog_size = opts[:oplog_size] || 5
 
       params.merge(
         :_id => count,
@@ -185,8 +187,13 @@ module Mongo
         clear_zombie
         return @pid if running?
         begin
-          @pid = Process.spawn(*@cmd) # redirection not supported in jruby
-          sleep 1
+          # redirection not supported in jruby
+          if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+            @pid = Process.spawn(*@cmd)
+          else
+            cmd_and_opts = [@cmd, {:out => :close}].flatten
+            @pid = Process.spawn(*cmd_and_opts)
+          end
           verify(verifies) if verifies > 0
           @pid
         end
@@ -203,6 +210,8 @@ module Mongo
         rescue Errno::ESRCH
           false
         end
+        # cleanup lock if unclean shutdown
+        File.delete(File.join(@config[:dbpath], 'mongod.lock')) if @config[:dbpath]
       end
 
       def wait
@@ -260,9 +269,9 @@ module Mongo
         params = @config.reject{|k,v| IGNORE_KEYS.include?(k)}
         arguments = params.sort{|a, b| a[0].to_s <=> b[0].to_s}.collect do |arg, value| # sort block is needed for 1.8.7 which lacks Symbol#<=>
           argument = '--' + arg.to_s
-          if FLAGS.member?(arg)
+          if FLAGS.member?(arg) && value == true
             [argument]
-          else
+          elsif !FLAGS.member?(arg)
             [argument, value.to_s]
           end
         end
@@ -330,7 +339,7 @@ module Mongo
       end
 
       def repl_set_get_status
-        command( @config[:replicas].first, 'admin', { :replSetGetStatus => 1 }, {:check_response => false } )
+        command( @config[:replicas], 'admin', { :replSetGetStatus => 1 }, {:check_response => false } )
       end
 
       def repl_set_get_config
@@ -354,16 +363,27 @@ module Mongo
       end
 
       def repl_set_startup
-        response = nil
-        60.times do |i|
-          response = repl_set_get_status
-          members = response['members']
-          if response['ok'] == 1.0 && members.collect{|m| m['state']}.all?{|state| [1,2,7].index(state)}
-            return response if members.any?{|m| m['state'] == 1}
+        states = nil
+        60.times do
+          states = repl_set_get_status.zip(repl_set_is_master)
+          healthy = states.all? do |status, is_master|
+            members = status['members']
+            if status['ok'] == 1.0 && members.collect{|m| m['state']}.all?{|state| [1,2,7].index(state)}
+              members.any?{|m| m['state'] == 1} &&
+                case status['myState']
+                when 1
+                  is_master['ismaster'] == true && is_master['secondary'] == false
+                when 2
+                  is_master['ismaster'] == false && is_master['secondary'] == true
+                when 7
+                  is_master['ismaster'] == false && is_master['secondary'] == false
+                end
+            end
           end
-          sleep 1
+          return true if healthy
+          sleep(1)
         end
-        raise Mongo::OperationFailure, "replSet startup failed - status: #{response.inspect}"
+        raise Mongo::OperationFailure, "replSet startup failed - status: #{states.inspect}"
       end
 
       def repl_set_seeds
@@ -374,13 +394,17 @@ module Mongo
         @config[:replicas].collect{|node| [node[:host], node[:port]]}
       end
 
+      def repl_set_seeds_uri
+        repl_set_seeds.join(',')
+      end
+
       def repl_set_name
         @config[:replicas].first[:replSet]
       end
 
       def member_names_by_state(state)
         states = Array(state)
-        status = repl_set_get_status
+        status = repl_set_get_status.first
         status['members'].find_all{|member| states.index(member['state']) }.collect{|member| member['name']}
       end
 
@@ -414,6 +438,14 @@ module Mongo
         members_by_name(secondary_names)
       end
 
+      def kill_primary
+        primary.kill
+      end
+
+      def kill_secondary
+        secondaries[rand(secondaries.length)].kill
+      end
+
       def replicas
         members_by_name(replica_names)
       end
@@ -459,8 +491,16 @@ module Mongo
         config_names_by_kind(:routers)
       end
 
-      def ismaster
-        command( @config[:routers], 'admin', { :ismaster => 1 } )
+      def ismaster(servers)
+        command( servers, 'admin', { :ismaster => 1 } )
+      end
+
+      def sharded_cluster_is_master
+        ismaster(@config[:routers])
+      end
+
+      def repl_set_is_master
+        ismaster(@config[:replicas])
       end
 
       def addshards(shards = @config[:shards])
@@ -494,7 +534,7 @@ module Mongo
         servers.each{|server| server.start}
         # TODO - sharded replica sets - pending
         if @config[:replicas]
-          repl_set_initiate if repl_set_get_status['startupStatus'] == 3
+          repl_set_initiate if repl_set_get_status.first['startupStatus'] == 3
           repl_set_startup
         end
         if @config[:routers]