mongo 1.8.2 → 1.8.3.rc0

data/lib/mongo/util/write_concern.rb

@@ -1,21 +1,3 @@
-# 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
   module WriteConcern
 

data/mongo.gemspec

@@ -3,13 +3,16 @@ Gem::Specification.new do |s|
 
   s.version           = File.read(File.join(File.dirname(__FILE__), 'VERSION'))
   s.platform          = Gem::Platform::RUBY
-  s.authors           = ['Tyler Brock', 'Gary Murakami', 'Emily Stolfo', 'Brandon Black']
+  s.authors           = ['Tyler Brock', 'Gary Murakami', 'Emily Stolfo', 'Brandon Black', 'Durran Jordan']
   s.email             = 'mongodb-dev@googlegroups.com'
   s.homepage          = 'http://www.mongodb.org'
   s.summary           = 'Ruby driver for MongoDB'
   s.description       = 'A Ruby driver for MongoDB. For more information about Mongo, see http://www.mongodb.org.'
   s.rubyforge_project = 'mongo'
 
+  s.signing_key       = 'gem-private_key.pem'
+  s.cert_chain        = ['gem-public_cert.pem']
+
   s.files             = ['mongo.gemspec', 'LICENSE', 'VERSION']
   s.files             += ['README.md', 'Rakefile', 'bin/mongo_console']
   s.files             += ['lib/mongo.rb'] + Dir['lib/mongo/**/*.rb']

data/test/auxillary/pool_reuse_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+require 'mongo'
+
+class PoolReuseTest < Test::Unit::TestCase
+  include Mongo
+
+  def count_open_file_handles
+    @conn["admin"].command(:serverStatus => 1)["connections"]["current"]
+  end
+
+  def setup
+    ensure_cluster(:rs, :replicas => 2, :arbiters => 1)
+    connect
+  end
+
+  def teardown
+    @@cluster.stop if @@cluster
+    @conn.close if @conn
+  end
+
+  def connect
+    @conn.close if @conn
+    @conn = MongoReplicaSetClient.new(["%s:%s" % [@rs.primary.host, @rs.primary.port]])
+  end
+
+  def test_pool_resources_are_reused
+    handles_before_refresh = count_open_file_handles
+    10.times do
+      @conn.hard_refresh!
+    end
+    assert_equal handles_before_refresh, count_open_file_handles
+  end
+
+  def test_pool_connectability_after_cycling_members
+    db   = @conn['sample-db']
+
+    assert_equal db.collection_names, []
+    old_primary = @@cluster.primary
+    @conn["admin"].command step_down_command rescue nil
+    old_primary.stop
+
+    rescue_connection_failure do
+      db.collection_names
+    end
+
+    # We should be reconnected to the new master now
+    assert_equal db.collection_names, []
+
+    # Start up the old primary
+    old_primary.start
+
+    # Stop the new primary
+    primary = @@cluster.primary
+    @conn["admin"].command step_down_command rescue nil
+    primary.stop
+
+    # Wait for primary failover
+    rescue_connection_failure do
+      db.collection_names
+    end
+
+    # Reconnect and verify that we can read again
+    assert_equal db.collection_names, []
+  end
+end

data/test/functional/collection_test.rb

@@ -244,14 +244,103 @@ class TestCollection < Test::Unit::TestCase
     assert_equal error_docs, invalid_docs
   end
 
+  def limited_collection
+    conn = standard_connection(:connect => false)
+    admin_db = Object.new
+    admin_db.expects(:command).returns({
+      'ok' => 1,
+      'ismaster' => 1,
+      'maxBsonObjectSize' => 1024,
+      'maxMessageSizeBytes' => 3 * 1024
+    })
+    conn.expects(:[]).with('admin').returns(admin_db)
+    conn.connect
+    return conn.db(MONGO_TEST_DB)["test"]
+  end
+
   def test_maximum_insert_size
     docs = []
-    16.times do
-      docs << {'foo' => 'a' * 1024 * 1024}
+    3.times do
+      docs << {'foo' => 'a' * 950}
+    end
+    assert_equal limited_collection.insert(docs).length, 3
+  end
+
+  def test_maximum_document_size
+    assert_raise InvalidDocument do
+      limited_collection.insert({'foo' => 'a' * 1024})
+    end
+  end
+
+  def test_maximum_message_size
+    docs = []
+    4.times do
+      docs << {'foo' => 'a' * 950}
     end
 
     assert_raise InvalidOperation do
-      @@test.insert(docs)
+      limited_collection.insert(docs)
+    end
+  end
+
+  def test_maximum_save_size
+    assert limited_collection.save({'foo' => 'a' * 950})
+    assert_raise InvalidDocument do
+      limited_collection.save({'foo' => 'a' * 1024})
+    end
+  end
+
+  def test_maximum_remove_size
+    assert limited_collection.remove({'foo' => 'a' * 950})
+    assert_raise InvalidDocument do
+      limited_collection.remove({'foo' => 'a' * 1024})
+    end
+  end
+
+  def test_maximum_update_size
+    assert_raise InvalidDocument do
+      limited_collection.update(
+        {'foo' => 'a' * 1024},
+        {'foo' => 'a' * 950}
+      )
+    end
+
+    assert_raise InvalidDocument do
+      limited_collection.update(
+        {'foo' => 'a' * 950},
+        {'foo' => 'a' * 1024}
+      )
+    end
+
+    assert_raise InvalidDocument do
+      limited_collection.update(
+        {'foo' => 'a' * 1024},
+        {'foo' => 'a' * 1024}
+      )
+    end
+
+    assert limited_collection.update(
+      {'foo' => 'a' * 950},
+      {'foo' => 'a' * 950}
+    )
+  end
+
+  def test_maximum_query_size
+    assert limited_collection.find({'foo' => 'a' * 950}).to_a
+    assert limited_collection.find(
+      {'foo' => 'a' * 950},
+      {:fields => {'foo' => 'a' * 950}}
+    ).to_a
+
+    assert_raise InvalidDocument do
+      limited_collection.find({'foo' => 'a' * 1024}).to_a
+    end
+
+    assert_raise InvalidDocument do
+      limited_collection.find(
+        {'foo' => 'a' * 950},
+        {:fields => {'foo' => 'a' * 1024}}
+      ).to_a
     end
   end
 

data/test/functional/connection_test.rb

@@ -269,11 +269,24 @@ class TestConnection < Test::Unit::TestCase
     if conn.server_version > "1.7.2"
       assert_equal conn['admin'].command({:ismaster => 1})['maxBsonObjectSize'], conn.max_bson_size
     end
+  end
+
+  def test_max_message_size_value
+    conn = standard_connection(:connect => false)
 
+    admin_db = Object.new
+    admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1, 'maxMessageSizeBytes' => 20_000_000})
+    conn.expects(:[]).with('admin').returns(admin_db)
     conn.connect
-    doc = {'n' => 'a' * (conn.max_bson_size)}
-    assert_raise InvalidDocument do
-      assert BSON::BSON_CODER.serialize(doc, false, true, @client.max_bson_size)
+
+    assert_equal 20_000_000, conn.max_message_size
+
+    conn = standard_connection
+    maxMessageSizeBytes = conn['admin'].command({:ismaster => 1})['maxMessageSizeBytes']
+    if conn.server_version.to_s[/([^-]+)/,1] >= "2.4.0"
+      assert_equal 48_000_000, maxMessageSizeBytes
+    elsif conn.server_version > "2.3.2"
+      assert_equal conn.max_bson_size, maxMessageSizeBytes
     end
   end
 
@@ -288,6 +301,17 @@ class TestConnection < Test::Unit::TestCase
     assert_equal Mongo::DEFAULT_MAX_BSON_SIZE, conn.max_bson_size
   end
 
+  def test_max_message_size_with_no_reported_max_size
+    conn = standard_connection(:connect => false)
+
+    admin_db = Object.new
+    admin_db.expects(:command).returns({'ok' => 1, 'ismaster' => 1})
+    conn.expects(:[]).with('admin').returns(admin_db)
+
+    conn.connect
+    assert_equal Mongo::DEFAULT_MAX_MESSAGE_SIZE, conn.max_message_size
+  end
+
   def test_connection_activity
     conn = standard_connection
     assert conn.active?
@@ -365,7 +389,7 @@ class TestConnection < Test::Unit::TestCase
         @con.expects(:checkout_writer).raises(SystemStackError)
         @con.expects(:close)
         begin
-          @coll.insert({:foo => "bar"}, :safe => true)
+          @coll.insert({:foo => "bar"}, :w => 1)
         rescue SystemStackError
         end
       end
@@ -396,11 +420,11 @@ class TestConnection < Test::Unit::TestCase
       assert_equal 0, @con.primary_pool.checked_out.size
     end
 
-    should "release connection if an exception is raised on send_with_safe_check" do
+    should "release connection if an exception is raised on write concern :w => 1" do
       @con.stubs(:receive).raises(ConnectionFailure)
       assert_equal 0, @con.primary_pool.checked_out.size
       assert_raise ConnectionFailure do
-        @coll.insert({:test => "insert"}, :safe => true)
+        @coll.insert({:test => "insert"}, :w => 1)
       end
       assert_equal 0, @con.primary_pool.checked_out.size
     end

data/test/functional/db_api_test.rb

@@ -575,6 +575,17 @@ HERE
     end
   end
 
+  def test_named_hint
+    name = @@coll.create_index('a', :name => 'named_index')
+    begin
+      assert_nil @@coll.hint
+      assert_equal 1, @@coll.find({'a' => 1}, :named_hint => 'named_index').to_a.size
+      assert_equal 1, @@coll.find({'a' => 1}, :hint => 'a', :named_hint => "bad_hint").to_a.size
+    ensure
+      @@coll.drop_index('named_index')
+    end
+  end
+
   def test_hash_default_value_id
     val = Hash.new(0)
     val["x"] = 5

data/test/functional/timeout_test.rb

@@ -15,8 +15,31 @@ class TestTimeout < Test::Unit::TestCase
     assert_raise Mongo::OperationTimeout do
       admin.command(command) 
     end
+  end
+
+  def test_external_timeout_does_not_leave_socket_in_bad_state
+    client = Mongo::MongoClient.new
+    db = client['testdb']
+    coll = db['testcoll']
+
+    # prepare the database
+    coll.drop
+    coll.insert({:a => 1})
 
+    # use external timeout to mangle socket
+    begin
+      Timeout::timeout(1) do
+        db.command({:eval => "sleep(1500)"})
+      end
+    rescue Timeout::Error => ex
+      #puts "Thread timed out and has now mangled the socket"
+    end
+
+    assert_nothing_raised do
+      coll.find_one
+    end
   end
+
 =begin
   def test_ssl_op_timeout
     connection = standard_connection(:op_timeout => 1, :ssl => true)

data/test/functional/uri_test.rb

@@ -128,4 +128,73 @@ class URITest < Test::Unit::TestCase
     assert_equal true, parser.journal
     assert_equal true, parser.safe
   end
+
+  def test_read_preference_option_primary
+    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=primary")
+    assert_equal :primary, parser.readpreference
+  end
+
+  def test_read_preference_option_primary_preferred
+    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=primaryPreferred")
+    assert_equal :primary_preferred, parser.readpreference
+  end
+
+  def test_read_preference_option_secondary
+    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=secondary")
+    assert_equal :secondary, parser.readpreference
+  end
+
+  def test_read_preference_option_secondary_preferred
+    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=secondaryPreferred")
+    assert_equal :secondary_preferred, parser.readpreference
+  end
+
+  def test_read_preference_option_nearest
+    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=nearest")
+    assert_equal :nearest, parser.readpreference
+  end
+
+  def test_read_preference_option_with_invalid
+    assert_raise_error MongoArgumentError  do
+      Mongo::URIParser.new("mongodb://localhost:27018?readPreference=invalid")
+    end
+  end
+
+  def test_read_preference_connection_options
+    parser = Mongo::URIParser.new("mongodb://localhost:27018?replicaset=test&readPreference=nearest")
+    assert_equal :nearest, parser.connection_options[:read]
+  end
+
+  def test_read_preference_connection_options_prefers_preference_over_slaveok
+    parser = Mongo::URIParser.new("mongodb://localhost:27018?replicaset=test&readPreference=nearest&slaveok=true")
+    assert_equal :nearest, parser.connection_options[:read]
+  end
+
+  def test_read_preference_when_no_replica_set
+    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=nearest")
+    assert_nil parser.connection_options[:read]
+  end
+
+  def test_connection_when_sharded_with_no_options
+    parser = Mongo::URIParser.new("mongodb://localhost:27017,localhost:27018")
+    client = parser.connection({}, false, true)
+    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+    assert_true client.mongos?
+  end
+
+  def test_connection_when_sharded_with_options
+    parser = Mongo::URIParser.new("mongodb://localhost:27017,localhost:27018")
+    client = parser.connection({ :refresh_interval => 10 }, false, true)
+    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+    assert_equal 10, client.refresh_interval
+    assert_true client.mongos?
+  end
+
+  def test_connection_when_sharded_with_uri_options
+    parser = Mongo::URIParser.new("mongodb://localhost:27017,localhost:27018?readPreference=nearest")
+    client = parser.connection({}, false, true)
+    assert_equal [[ "localhost", 27017 ], [ "localhost", 27018 ]], client.seeds
+    assert_equal :nearest, client.read
+    assert_true client.mongos?
+  end
 end

data/test/replica_set/client_test.rb

@@ -28,28 +28,6 @@ class ClientTest < Test::Unit::TestCase
     end
   end
 
-  def test_reconnect_method_override
-    rescue_connection_failure do
-      @client = MongoReplicaSetClient.new(@rs.repl_set_seeds)
-    end
-
-    MongoReplicaSetClient.any_instance.expects(:connect)
-    MongoClient.any_instance.expects(:connect).never
-    assert_nothing_raised Mongo::ConnectionFailure do
-      @client.reconnect
-    end
-  end
-
-  def test_primary_method_override
-    rescue_connection_failure do
-      @client = MongoReplicaSetClient.new(@rs.repl_set_seeds)
-    end
-
-    MongoReplicaSetClient.any_instance.expects(:read_primary?)
-    MongoClient.any_instance.expects(:read_primary?).never
-    @client.primary?
-  end
-
   def test_connect_with_first_secondary_node_terminated
     @rs.secondaries.first.stop
 

data/test/replica_set/cursor_test.rb

@@ -13,12 +13,18 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
 
   def test_cursors_get_closed_secondary
     setup_client(:secondary)
-    assert_cursor_count
+    assert_cursor_count(:secondary)
+  end
+
+  def test_cusors_get_closed_secondary_query
+    setup_client(:primary, :secondary)
+    assert_cursor_count(:secondary)
   end
 
   private
 
-  def setup_client(read=:primary)
+  def setup_client(read=:primary, route_read=nil)
+    route_read ||= read
     # Setup ReplicaSet Connection
     @client = MongoReplicaSetClient.new(@rs.repl_set_seeds, :read => read)
 
@@ -35,7 +41,7 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
 
     # Setup Direct Connections
     @primary = Mongo::MongoClient.new(*@client.manager.primary)
-    @read = Mongo::MongoClient.new(*@client.manager.read)
+    @read = Mongo::MongoClient.new(*@client.manager.read_pool(route_read).host_port)
   end
 
   def cursor_count(client)
@@ -46,12 +52,12 @@ class ReplicaSetCursorTest < Test::Unit::TestCase
     client['admin'].command({:serverStatus => 1})['opcounters']['query']
   end
 
-  def assert_cursor_count
+  def assert_cursor_count(read=:primary)
     before_primary_cursor = cursor_count(@primary)
     before_read_cursor = cursor_count(@read)
     before_read_query = query_count(@read)
 
-    @coll.find.limit(2).to_a
+    @coll.find({}, :read => read).limit(2).to_a
 
     after_primary_cursor = cursor_count(@primary)
     after_read_cursor = cursor_count(@read)