mongo 1.8.3 → 1.8.4.rc0

data/lib/mongo/mongo_client.rb

@@ -241,7 +241,7 @@ module Mongo
     def apply_saved_authentication(opts={})
       return false if @auths.empty?
       @auths.each do |auth|
-        self[auth['db_name']].issue_authentication(auth['username'], auth['password'], false,
+        self[auth[:db_name]].issue_authentication(auth[:username], auth[:password], false,
           :socket => opts[:socket])
       end
       true
@@ -261,11 +261,15 @@ module Mongo
     #
     # @return [Hash] a hash representing the authentication just added.
     def add_auth(db_name, username, password)
-      remove_auth(db_name)
-      auth = {}
-      auth['db_name']  = db_name
-      auth['username'] = username
-      auth['password'] = password
+      if @auths.any? {|a| a[:db_name] == db_name}
+        raise MongoArgumentError, "Cannot apply multiple authentications to database '#{db_name}'"
+      end
+
+      auth = {
+        :db_name  => db_name,
+        :username => username,
+        :password => password
+      }
       @auths << auth
       auth
     end
@@ -277,11 +281,7 @@ module Mongo
     # @return [Boolean]
     def remove_auth(db_name)
       return unless @auths
-      if @auths.reject! { |a| a['db_name'] == db_name }
-        true
-      else
-        false
-      end
+      @auths.reject! { |a| a[:db_name] == db_name } ? true : false
     end
 
     # Remove all authentication information stored in this connection.
@@ -351,10 +351,14 @@ module Mongo
     def refresh
     end
 
-    def pin_pool(pool)
+    def pinned_pool
+      @primary_pool
+    end
+
+    def pin_pool(pool, read_prefs)
     end
 
-    def unpin_pool(pool)
+    def unpin_pool
     end
 
     # Drop a database.
@@ -521,7 +525,7 @@ module Mongo
 
     # Checkout a socket for reading (i.e., a secondary node).
     # Note: this is overridden in MongoReplicaSetClient.
-    def checkout_reader(mode=:primary, tag_sets={}, acceptable_latency=15)
+    def checkout_reader(read_preference)
       connect unless connected?
       @primary_pool.checkout
     end

data/lib/mongo/mongo_replica_set_client.rb

@@ -2,6 +2,7 @@ module Mongo
 
   # Instantiates and manages connections to a MongoDB replica set.
   class MongoReplicaSetClient < MongoClient
+    include ReadPreference
     include ThreadLocalVariableManager
 
     REPL_SET_OPTS = [
@@ -268,7 +269,7 @@ module Mongo
     #
     # @return [Boolean]
     def read_primary?
-      @manager.read_pool == @manager.primary_pool
+      read_pool == primary_pool
     end
     alias :primary? :read_primary?
 
@@ -282,6 +283,7 @@ module Mongo
 
       # Clear the reference to this object.
       thread_local[:managers].delete(self)
+      unpin_pool
 
       @connected = false
     end
@@ -335,9 +337,9 @@ module Mongo
       end
     end
 
-    def checkout_reader(mode=@read, tag_sets=@tag_sets, acceptable_latency=@acceptable_latency)
+    def checkout_reader(read_pref={})
       checkout do
-        pool = read_pool(mode, tag_sets, acceptable_latency)
+        pool = read_pool(read_pref)
         get_socket_from_pool(pool)
       end
     end
@@ -361,11 +363,20 @@ module Mongo
       thread_local[:managers][self] = @manager
     end
 
-    def pin_pool(pool)
-      thread_local[:pinned_pools][@manager.object_id] = pool if @manager
+    def pinned_pool
+      thread_local[:pinned_pools][@manager.object_id] if @manager
     end
 
-    def unpin_pool(pool)
+    def pin_pool(pool, read_preference)
+      if @manager
+        thread_local[:pinned_pools][@manager.object_id] = {
+          :pool => pool,
+          :read_preference => read_preference
+        }
+      end
+    end
+
+    def unpin_pool
       thread_local[:pinned_pools].delete @manager.object_id if @manager
     end
 
@@ -402,10 +413,6 @@ module Mongo
       local_manager ? local_manager.primary_pool : nil
     end
 
-    def read_pool(mode=@read, tags=@tag_sets, acceptable_latency=@acceptable_latency)
-      local_manager ? local_manager.read_pool(mode, tags, acceptable_latency) : nil
-    end
-
     def secondary_pool
       local_manager ? local_manager.secondary_pool : nil
     end

data/lib/mongo/util/pool.rb

@@ -85,25 +85,6 @@ module Mongo
       !@closed
     end
 
-    def matches_mode(mode)
-      if mode == :primary && @node.secondary? ||
-        mode == :secondary && @node.primary?
-        false
-      else
-        true
-      end
-    end
-
-    def matches_tag_set(tag_set)
-      tag_set.all? do |tag, value|
-        tags.has_key?(tag) && tags[tag] == value
-      end
-    end
-
-    def matches_tag_sets(tag_sets)
-      tag_sets.all? {|set| matches_tag_set(set)}
-    end
-
     def inspect
       "#<Mongo::Pool:0x#{self.object_id.to_s(16)} @host=#{@host} @port=#{port} " +
         "@ping_time=#{@ping_time} #{@checked_out.size}/#{@size} sockets available " +

data/lib/mongo/util/pool_manager.rb

@@ -1,6 +1,5 @@
 module Mongo
   class PoolManager
-    include Mongo::ReadPreference
     include ThreadLocalVariableManager
 
     attr_reader :client,
@@ -114,26 +113,6 @@ module Mongo
       read_pool.host_port
     end
 
-    def read_pool(mode=@client.read,
-                  tags=@client.tag_sets,
-                  acceptable_latency=@client.acceptable_latency)
-
-      pinned = thread_local[:pinned_pools][self.object_id]
-
-      if pinned && pinned.matches_mode(mode) && pinned.matches_tag_sets(tags) && pinned.up?
-        pool = pinned
-      else
-        pool = select_pool(mode, tags, acceptable_latency)
-      end
-
-      unless pool
-        raise ConnectionFailure, "No replica set member available for query " +
-          "with read preference matching mode #{mode} and tags matching #{tags}."
-      end
-
-      pool
-    end
-
     def max_bson_size
       @max_bson_size ||= config_min('maxBsonObjectSize', DEFAULT_MAX_BSON_SIZE)
     end

data/lib/mongo/util/read_preference.rb

@@ -33,29 +33,56 @@ module Mongo
       end
     end
 
-    def select_pool(mode, tags, latency)
-      return primary_pool if @client.mongos?
+    def read_preference
+      {
+        :mode => @read,
+        :tags => @tag_sets,
+        :latency => @acceptable_latency
+      }
+    end
+
+    def read_pool(read_preference_override={})
+      return primary_pool if mongos?
+
+      read_pref = read_preference.merge(read_preference_override)
+
+      if pinned_pool && pinned_pool[:read_preference] == read_pref
+        pool = pinned_pool[:pool]
+      else
+        unpin_pool
+        pool = select_pool(read_pref)
+      end
+
+      unless pool
+        raise ConnectionFailure, "No replica set member available for query " +
+          "with read preference matching mode #{read_pref[:mode]} and tags " +
+          "matching #{read_pref[:tags]}."
+      end
+
+      pool
+    end
 
-      if mode == :primary && !tags.empty?
+    def select_pool(read_pref)
+      if read_pref[:mode] == :primary && !read_pref[:tags].empty?
         raise MongoArgumentError, "Read preference :primary cannot be combined with tags"
       end
 
-      case mode
+      case read_pref[:mode]
         when :primary
           primary_pool
         when :primary_preferred
-          primary_pool || select_secondary_pool(secondary_pools, tags, latency)
+          primary_pool || select_secondary_pool(secondary_pools, read_pref)
         when :secondary
-          select_secondary_pool(secondary_pools, tags, latency)
+          select_secondary_pool(secondary_pools, read_pref)
         when :secondary_preferred
-          select_secondary_pool(secondary_pools, tags, latency) || primary_pool
+          select_secondary_pool(secondary_pools, read_pref) || primary_pool
         when :nearest
-          select_secondary_pool(pools, tags, latency)
+          select_secondary_pool(pools, read_pref)
       end
     end
 
-    def select_secondary_pool(candidates, tag_sets, latency)
-      tag_sets = [tag_sets] unless tag_sets.is_a?(Array)
+    def select_secondary_pool(candidates, read_pref)
+      tag_sets = read_pref[:tags]
 
       if !tag_sets.empty?
         matches = []
@@ -70,10 +97,11 @@ module Mongo
         matches = candidates
       end
 
-      matches.empty? ? nil : select_near_pool(matches, latency)
+      matches.empty? ? nil : select_near_pool(matches, read_pref)
     end
 
-    def select_near_pool(candidates, latency)
+    def select_near_pool(candidates, read_pref)
+      latency = read_pref[:latency]
       nearest_pool = candidates.min_by { |candidate| candidate.ping_time }
       near_pools = candidates.select do |candidate|
         (candidate.ping_time - nearest_pool.ping_time) <= latency

data/lib/mongo/util/uri_parser.rb

@@ -220,7 +220,7 @@ module Mongo
         opts[:pool_size] = @pool_size
       end
 
-      if @readpreference && replicaset?
+      if @readpreference
         opts[:read] = @readpreference
       end
 
@@ -285,7 +285,7 @@ module Mongo
       end
 
       if uname && pwd && db
-        auths << {'db_name' => db, 'username' => uname, 'password' => pwd}
+        auths << {:db_name => db, :username => uname, :password => pwd}
       elsif uname || pwd
         raise MongoArgumentError, "MongoDB URI must include username, password, "
           "and db if username and password are specified."

data/mongo.gemspec

@@ -9,6 +9,7 @@ Gem::Specification.new do |s|
   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.license           = 'Apache License Version 2.0'
 
   s.signing_key       = 'gem-private_key.pem'
   s.cert_chain        = ['gem-public_cert.pem']

data/test/bson/object_id_test.rb

@@ -70,11 +70,17 @@ class ObjectIdTest < Test::Unit::TestCase
   end
 
   def test_illegal_from_string
-    assert_raise InvalidObjectId do 
+    assert_raise InvalidObjectId do
       ObjectId.from_string("")
     end
   end
 
+  def test_from_string_with_object_id
+    assert_raise InvalidObjectId do
+      ObjectId.from_string(@o)
+    end
+  end
+
   def test_legal
     assert !ObjectId.legal?(nil)
     assert !ObjectId.legal?("fred")

data/test/functional/collection_test.rb

@@ -1075,7 +1075,6 @@ end
     coll.ensure_index([['a', 1]])
   end
 
-
   if @@version > '2.0.0'
     def test_show_disk_loc
       @@test.save({:a => 1})
@@ -1252,12 +1251,36 @@ end
       assert_nil @geo.index_information['baz']
     end
 
+    #should "create a text index" do
+    #  @geo.save({'title' => "some text"})
+    #  @geo.create_index([['title', Mongo::TEXT]])
+    #  assert @geo.index_information['title_text']
+    #end
+
+    should "create a hashed index" do
+      @geo.save({'a' => 1})
+      @geo.create_index([['a', Mongo::HASHED]])
+      assert @geo.index_information['a_hashed']
+    end
+
     should "create a geospatial index" do
       @geo.save({'loc' => [-100, 100]})
       @geo.create_index([['loc', Mongo::GEO2D]])
       assert @geo.index_information['loc_2d']
     end
 
+    should "create a geoHaystack index" do
+      @geo.save({ "_id" => 100, "pos" => { "long" => 126.9, "lat" => 35.2 }, "type" => "restaurant"})
+      @geo.create_index([['pos', Mongo::GEOHAYSTACK], ['type', Mongo::ASCENDING]], :bucket_size => 1)
+      puts @geo.index_information['loc_geoHaystack_type_1']
+    end
+
+    should "create a geo 2dsphere index" do
+      @collection.insert({"coordinates" => [ 5 , 5 ], "type" => "Point"})
+      @geo.create_index([['coordinates', Mongo::GEO2DSPHERE]])
+      assert @geo.index_information['coordinates_2dsphere']
+    end
+
     should "create a unique index" do
       @collection.create_index([['a', Mongo::ASCENDING]], :unique => true)
       assert @collection.index_information['a_1']['unique'] == true

data/test/functional/connection_test.rb

@@ -336,8 +336,8 @@ class TestConnection < Test::Unit::TestCase
   context "Saved authentications" do
     setup do
       @client = standard_connection
-      @auth = {'db_name' => 'test', 'username' => 'bob', 'password' => 'secret'}
-      @client.add_auth(@auth['db_name'], @auth['username'], @auth['password'])
+      @auth = {:db_name => 'test', :username => 'bob', :password => 'secret'}
+      @client.add_auth(@auth[:db_name], @auth[:username], @auth[:password])
     end
 
     teardown do
@@ -348,11 +348,11 @@ class TestConnection < Test::Unit::TestCase
       assert_equal @auth, @client.auths[0]
     end
 
-    should "replace the auth if given a new auth for the same db" do
-      auth = {'db_name' => 'test', 'username' => 'mickey', 'password' => 'm0u53'}
-      @client.add_auth(auth['db_name'], auth['username'], auth['password'])
-      assert_equal 1, @client.auths.length
-      assert_equal auth, @client.auths[0]
+    should "not allow multiple authentications for the same db" do
+      auth = {:db_name => 'test', :username => 'mickey', :password => 'm0u53'}
+      assert_raise Mongo::MongoArgumentError do
+        @client.add_auth(auth[:db_name], auth[:username], auth[:password])
+      end
     end
 
     should "remove auths by database" do

data/test/functional/db_api_test.rb

@@ -92,7 +92,7 @@ class DBAPITest < Test::Unit::TestCase
     # Can't compare _id values because at insert, an _id was added to @r1 by
     # the database but we don't know what it is without re-reading the record
     # (which is what we are doing right now).
-#   assert_equal doc['_id'], @r1['_id']
+    # assert_equal doc['_id'], @r1['_id']
     assert_equal doc['a'], @r1['a']
   end
 
@@ -194,7 +194,7 @@ class DBAPITest < Test::Unit::TestCase
     @@coll.insert('a' => 2, 'b' => 1)
     @@coll.insert('a' => 3, 'b' => 2)
     @@coll.insert('a' => 4, 'b' => 1)
-    
+
     oh = BSON::OrderedHash.new
     oh['a'] = -1
 
@@ -312,7 +312,7 @@ class DBAPITest < Test::Unit::TestCase
 
     begin
       coll = @@db.create_collection('foobar', :capped => true, :size => 1024)
-      options = coll.options()
+      options = coll.options
       assert_equal 'foobar', options['create']
       assert_equal true, options['capped']
       assert_equal 1024, options['size']
@@ -488,7 +488,7 @@ HERE
       fail "expected exception"
     rescue => ex
       assert_equal Mongo::MongoDBError, ex.class
-      assert_equal "Collection does-not-exist doesn't exist. Currently in strict mode.", ex.to_s
+      assert_equal "Collection 'does-not-exist' doesn't exist. (strict=true)", ex.to_s
     ensure
       @@db.strict = false
       @@db.drop_collection('does-not-exist')
@@ -500,8 +500,7 @@ HERE
     @@db.strict = true
 
     begin
-      @@db.create_collection('foobar')
-      assert true
+      assert @@db.create_collection('foobar')
     rescue => ex
       fail "did not expect exception \"#{ex}\""
     end

data/test/functional/uri_test.rb

@@ -26,17 +26,17 @@ class URITest < Test::Unit::TestCase
 
   def test_complex_passwords
     parser = Mongo::URIParser.new('mongodb://bob:secret.word@a.example.com:27018/test')
-    assert_equal "bob", parser.auths[0]["username"]
-    assert_equal "secret.word", parser.auths[0]["password"]
+    assert_equal "bob", parser.auths[0][:username]
+    assert_equal "secret.word", parser.auths[0][:password]
 
     parser = Mongo::URIParser.new('mongodb://bob:s-_3#%R.t@a.example.com:27018/test')
-    assert_equal "bob", parser.auths[0]["username"]
-    assert_equal "s-_3#%R.t", parser.auths[0]["password"]
+    assert_equal "bob", parser.auths[0][:username]
+    assert_equal "s-_3#%R.t", parser.auths[0][:password]
   end
 
   def test_complex_usernames
     parser = Mongo::URIParser.new('mongodb://b:ob:secret.word@a.example.com:27018/test')
-    assert_equal "b:ob", parser.auths[0]["username"]
+    assert_equal "b:ob", parser.auths[0][:username]
   end
 
   def test_passwords_contain_no_commas
@@ -51,12 +51,12 @@ class URITest < Test::Unit::TestCase
     assert_equal ['a.example.com', 27018], parser.nodes[0]
     assert_equal ['b.example.com', 27017], parser.nodes[1]
     assert_equal 2, parser.auths.length
-    assert_equal "bob", parser.auths[0]["username"]
-    assert_equal "secret", parser.auths[0]["password"]
-    assert_equal "test", parser.auths[0]["db_name"]
-    assert_equal "bob", parser.auths[1]["username"]
-    assert_equal "secret", parser.auths[1]["password"]
-    assert_equal "test", parser.auths[1]["db_name"]
+    assert_equal "bob", parser.auths[0][:username]
+    assert_equal "secret", parser.auths[0][:password]
+    assert_equal "test", parser.auths[0][:db_name]
+    assert_equal "bob", parser.auths[1][:username]
+    assert_equal "secret", parser.auths[1][:password]
+    assert_equal "test", parser.auths[1][:db_name]
   end
 
   def test_opts_with_semincolon_separator
@@ -165,14 +165,14 @@ class URITest < Test::Unit::TestCase
     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")
+  def test_read_preference_connection_options_with_no_replica_set
+    parser = Mongo::URIParser.new("mongodb://localhost:27018?readPreference=nearest")
     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]
+  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_connection_when_sharded_with_no_options