mongo 1.1.1 → 1.1.2

data/lib/mongo/exceptions.rb

@@ -42,6 +42,9 @@ module Mongo
   # Raised on failures in connection to the database server.
   class ConnectionError < MongoRubyError; end
 
+  # Raised on failures in connection to the database server.
+  class ReplicaSetConnectionError < ConnectionError; end
+
   # Raised on failures in connection to the database server.
   class ConnectionTimeoutError < MongoRubyError; end
 

data/lib/mongo/gridfs/grid.rb

@@ -38,7 +38,10 @@ module Mongo
       @chunks  = @db["#{fs_name}.chunks"]
       @fs_name = fs_name
 
-      @chunks.create_index([['files_id', Mongo::ASCENDING], ['n', Mongo::ASCENDING]], :unique => true)
+      # Ensure indexes only if not connected to slave.
+      unless db.connection.slave_ok?
+        @chunks.create_index([['files_id', Mongo::ASCENDING], ['n', Mongo::ASCENDING]], :unique => true)
+      end
     end
 
     # Store a file in the file store. This method is designed only for writing new files;

data/lib/mongo/gridfs/grid_file_system.rb

@@ -39,8 +39,11 @@ module Mongo
 
       @default_query_opts = {:sort => [['filename', 1], ['uploadDate', -1]], :limit => 1}
 
-      @files.create_index([['filename', 1], ['uploadDate', -1]])
-      @chunks.create_index([['files_id', Mongo::ASCENDING], ['n', Mongo::ASCENDING]], :unique => true)
+      # Ensure indexes only if not connected to slave.
+      unless db.connection.slave_ok?
+        @files.create_index([['filename', 1], ['uploadDate', -1]])
+        @chunks.create_index([['files_id', Mongo::ASCENDING], ['n', Mongo::ASCENDING]], :unique => true)
+      end
     end
 
     # Open a file for reading or writing. Note that the options for this method only apply

data/lib/mongo/util/pool.rb

@@ -0,0 +1,115 @@
+# encoding: UTF-8
+
+# --
+# Copyright (C) 2008-2010 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
+  class Pool
+
+    def initialize(host, port, socket, options={})
+      @host, @port = host, port
+
+      # Pool size and timeout.
+      @size      = options[:pool_size] || 1
+      @timeout   = options[:timeout]   || 5.0
+
+      # Mutex for synchronizing pool access
+      @connection_mutex = Mutex.new
+
+      # Global safe option. This is false by default.
+      @safe = options[:safe] || false
+
+      # Create a mutex when a new key, in this case a socket,
+      # is added to the hash.
+      @safe_mutexes = Hash.new { |h, k| h[k] = Mutex.new }
+
+      # Condition variable for signal and wait
+      @queue = ConditionVariable.new
+
+      @sockets      = []
+      @checked_out  = []
+    end
+
+    def close
+    end
+
+    # Return a socket to the pool.
+    def checkin(socket)
+      @connection_mutex.synchronize do
+        @checked_out.delete(socket)
+        @queue.signal
+      end
+      true
+    end
+
+    # Adds a new socket to the pool and checks it out.
+    #
+    # This method is called exclusively from #checkout;
+    # therefore, it runs within a mutex.
+    def checkout_new_socket
+      begin
+      socket = TCPSocket.new(@host, @port)
+      socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      rescue => ex
+        raise ConnectionFailure, "Failed to connect socket: #{ex}"
+      end
+      @sockets << socket
+      @checked_out << socket
+      socket
+    end
+
+    # Checks out the first available socket from the pool.
+    #
+    # This method is called exclusively from #checkout;
+    # therefore, it runs within a mutex.
+    def checkout_existing_socket
+      socket = (@sockets - @checked_out).first
+      @checked_out << socket
+      socket
+    end
+
+    # Check out an existing socket or create a new socket if the maximum
+    # pool size has not been exceeded. Otherwise, wait for the next
+    # available socket.
+    def checkout
+      connect if !connected?
+      start_time = Time.now
+      loop do
+        if (Time.now - start_time) > @timeout
+            raise ConnectionTimeoutError, "could not obtain connection within " +
+              "#{@timeout} seconds. The max pool size is currently #{@size}; " +
+              "consider increasing the pool size or timeout."
+        end
+
+        @connection_mutex.synchronize do
+          socket = if @checked_out.size < @sockets.size
+                     checkout_existing_socket
+                   elsif @sockets.size < @size
+                     checkout_new_socket
+                   end
+
+          return socket if socket
+
+          # Otherwise, wait
+          if @logger
+            @logger.warn "MONGODB Waiting for available connection; " +
+              "#{@checked_out.size} of #{@size} connections checked out."
+          end
+          @queue.wait(@connection_mutex)
+        end
+      end
+    end
+  end
+end

data/mongo.gemspec

@@ -11,10 +11,9 @@ Gem::Specification.new do |s|
 
   s.require_paths = ['lib']
 
-  s.files  = ['README.rdoc', 'HISTORY', 'Rakefile',
-    'mongo.gemspec', 'LICENSE.txt']
+  s.files  = ['README.md', 'Rakefile', 'mongo.gemspec', 'LICENSE.txt']
   s.files += ['lib/mongo.rb'] + Dir['lib/mongo/**/*.rb']
-  s.files += Dir['examples/**/*.rb'] + Dir['bin/**/*.rb']
+  s.files += Dir['docs/**/*.md'] + Dir['examples/**/*.rb'] + Dir['bin/**/*.rb']
   s.files += Dir['bin/mongo_console']
   s.test_files = Dir['test/**/*.rb']
 
@@ -25,8 +24,8 @@ Gem::Specification.new do |s|
   s.test_files -= Dir['test/mongo_bson/*.rb'] # remove these files from the manifest
 
   s.has_rdoc = true
-  s.rdoc_options = ['--main', 'README.rdoc', '--inline-source']
-  s.extra_rdoc_files = ['README.rdoc']
+  s.rdoc_options = ['--main', 'README.md', '--inline-source']
+  s.extra_rdoc_files = ['README.md']
 
   s.authors = ['Jim Menard', 'Mike Dirolf', 'Kyle Banker']
   s.email = 'mongodb-dev@googlegroups.com'

data/test/bson/bson_test.rb

@@ -437,11 +437,13 @@ class BSONTest < Test::Unit::TestCase
   # HashWithIndifferentAccess can cause problems for _id but not for other
   # keys. rather than require rails to test with HWIA directly, we do this
   # somewhat hacky test.
+  #
+  # Note that the driver only eliminates duplicate ids when move_id is true.
   def test_no_duplicate_id
     dup = {"_id" => "foo", :_id => "foo"}
     one = {"_id" => "foo"}
 
-    assert_equal @encoder.serialize(one).to_a, @encoder.serialize(dup).to_a
+    assert_equal @encoder.serialize(one, false, true).to_a, @encoder.serialize(dup, false, true).to_a
   end
 
   def test_duplicate_keys

data/test/collection_test.rb

@@ -26,6 +26,20 @@ class TestCollection < Test::Unit::TestCase
     assert @coll.pk_factory.is_a?(Object)
   end
 
+  class TestPK
+    def self.create_pk
+    end
+  end
+
+  def test_pk_factory_on_collection
+    @coll = Collection.new(@@db, 'foo', TestPK)
+    assert_equal TestPK, @coll.pk_factory
+
+
+    @coll2 = Collection.new(@@db, 'foo', :pk => TestPK)
+    assert_equal TestPK, @coll2.pk_factory
+  end
+
   def test_valid_names
     assert_raise Mongo::InvalidNSName do
       @@db["te$t"]
@@ -628,6 +642,22 @@ class TestCollection < Test::Unit::TestCase
       assert @collection.index_information['a_1']['unique'] == true
     end
 
+    should "drop duplicates" do
+      @collection.insert({:a => 1})
+      @collection.insert({:a => 1})
+      assert_equal 2, @collection.find({:a => 1}).count
+      @collection.create_index([['a', Mongo::ASCENDING]], :unique => true, :dropDups => true)
+      assert_equal 1, @collection.find({:a => 1}).count
+    end
+
+    should "drop duplicates with ruby-like drop_dups key" do
+      @collection.insert({:a => 1})
+      @collection.insert({:a => 1})
+      assert_equal 2, @collection.find({:a => 1}).count
+      @collection.create_index([['a', Mongo::ASCENDING]], :unique => true, :drop_dups => true)
+      assert_equal 1, @collection.find({:a => 1}).count
+    end
+
     should "create an index in the background" do
       if @@version > '1.3.1'
         @collection.create_index([['b', Mongo::ASCENDING]], :background => true)

data/test/connection_test.rb

@@ -9,15 +9,15 @@ class TestConnection < Test::Unit::TestCase
   include BSON
 
   def setup
-    @mongo = standard_connection
+    @conn = standard_connection
   end
 
   def teardown
-    @mongo[MONGO_TEST_DB].get_last_error
+    @conn[MONGO_TEST_DB].get_last_error
   end
 
   def test_server_info
-    server_info = @mongo.server_info
+    server_info = @conn.server_info
     assert server_info.keys.include?("version")
     assert Mongo::Support.ok?(server_info)
   end
@@ -29,63 +29,76 @@ class TestConnection < Test::Unit::TestCase
   end
 
   def test_server_version
-    assert_match /\d\.\d+(\.\d+)?/, @mongo.server_version.to_s
+    assert_match /\d\.\d+(\.\d+)?/, @conn.server_version.to_s
   end
 
   def test_invalid_database_names
-    assert_raise TypeError do @mongo.db(4) end
+    assert_raise TypeError do @conn.db(4) end
 
-    assert_raise Mongo::InvalidNSName do @mongo.db('') end
-    assert_raise Mongo::InvalidNSName do @mongo.db('te$t') end
-    assert_raise Mongo::InvalidNSName do @mongo.db('te.t') end
-    assert_raise Mongo::InvalidNSName do @mongo.db('te\\t') end
-    assert_raise Mongo::InvalidNSName do @mongo.db('te/t') end
-    assert_raise Mongo::InvalidNSName do @mongo.db('te st') end
+    assert_raise Mongo::InvalidNSName do @conn.db('') end
+    assert_raise Mongo::InvalidNSName do @conn.db('te$t') end
+    assert_raise Mongo::InvalidNSName do @conn.db('te.t') end
+    assert_raise Mongo::InvalidNSName do @conn.db('te\\t') end
+    assert_raise Mongo::InvalidNSName do @conn.db('te/t') end
+    assert_raise Mongo::InvalidNSName do @conn.db('te st') end
+  end
+
+  def test_replica_set_connection_name
+    assert_raise_error(Mongo::ReplicaSetConnectionError, "replSet") do
+      standard_connection(:name => "replica-set-foo")
+    end
+  end
+
+  def test_options_passed_to_db
+    @pk_mock = Object.new
+    db = @conn.db('test', :pk => @pk_mock, :strict => true)
+    assert_equal @pk_mock, db.pk_factory
+    assert db.strict?
   end
 
   def test_database_info
-    @mongo.drop_database(MONGO_TEST_DB)
-    @mongo.db(MONGO_TEST_DB).collection('info-test').insert('a' => 1)
+    @conn.drop_database(MONGO_TEST_DB)
+    @conn.db(MONGO_TEST_DB).collection('info-test').insert('a' => 1)
 
-    info = @mongo.database_info
+    info = @conn.database_info
     assert_not_nil info
     assert_kind_of Hash, info
     assert_not_nil info[MONGO_TEST_DB]
     assert info[MONGO_TEST_DB] > 0
 
-    @mongo.drop_database(MONGO_TEST_DB)
+    @conn.drop_database(MONGO_TEST_DB)
   end
 
   def test_copy_database
-    @mongo.db('old').collection('copy-test').insert('a' => 1)
-    @mongo.copy_database('old', 'new', host_port)
-    old_object = @mongo.db('old').collection('copy-test').find.next_document
-    new_object = @mongo.db('new').collection('copy-test').find.next_document
+    @conn.db('old').collection('copy-test').insert('a' => 1)
+    @conn.copy_database('old', 'new', host_port)
+    old_object = @conn.db('old').collection('copy-test').find.next_document
+    new_object = @conn.db('new').collection('copy-test').find.next_document
     assert_equal old_object, new_object
-    @mongo.drop_database('old')
-    @mongo.drop_database('new')
+    @conn.drop_database('old')
+    @conn.drop_database('new')
   end
 
   def test_copy_database_with_auth
-    @mongo.db('old').collection('copy-test').insert('a' => 1)
-    @mongo.db('old').add_user('bob', 'secret')
+    @conn.db('old').collection('copy-test').insert('a' => 1)
+    @conn.db('old').add_user('bob', 'secret')
 
     assert_raise Mongo::OperationFailure do
-      @mongo.copy_database('old', 'new', host_port, 'bob', 'badpassword')
+      @conn.copy_database('old', 'new', host_port, 'bob', 'badpassword')
     end
 
-    result = @mongo.copy_database('old', 'new', host_port, 'bob', 'secret')
+    result = @conn.copy_database('old', 'new', host_port, 'bob', 'secret')
     assert Mongo::Support.ok?(result)
 
-    @mongo.drop_database('old')
-    @mongo.drop_database('new')
+    @conn.drop_database('old')
+    @conn.drop_database('new')
   end
 
   def test_database_names
-    @mongo.drop_database(MONGO_TEST_DB)
-    @mongo.db(MONGO_TEST_DB).collection('info-test').insert('a' => 1)
+    @conn.drop_database(MONGO_TEST_DB)
+    @conn.db(MONGO_TEST_DB).collection('info-test').insert('a' => 1)
 
-    names = @mongo.database_names
+    names = @conn.database_names
     assert_not_nil names
     assert_kind_of Array, names
     assert names.length >= 1
@@ -112,15 +125,15 @@ class TestConnection < Test::Unit::TestCase
   end
 
   def test_drop_database
-    db = @mongo.db('ruby-mongo-will-be-deleted')
+    db = @conn.db('ruby-mongo-will-be-deleted')
     coll = db.collection('temp')
     coll.remove
     coll.insert(:name => 'temp')
     assert_equal 1, coll.count()
-    assert @mongo.database_names.include?('ruby-mongo-will-be-deleted')
+    assert @conn.database_names.include?('ruby-mongo-will-be-deleted')
 
-    @mongo.drop_database('ruby-mongo-will-be-deleted')
-    assert !@mongo.database_names.include?('ruby-mongo-will-be-deleted')
+    @conn.drop_database('ruby-mongo-will-be-deleted')
+    assert !@conn.database_names.include?('ruby-mongo-will-be-deleted')
   end
 
   def test_nodes
@@ -138,15 +151,15 @@ class TestConnection < Test::Unit::TestCase
   end
 
   def test_fsync_lock
-    assert !@mongo.locked?
-    @mongo.lock!
-    assert @mongo.locked?
-    assert_equal 1, @mongo['admin']['$cmd.sys.inprog'].find_one['fsyncLock'], "Not fsync-locked"
-    assert_equal "unlock requested", @mongo.unlock!['info']
+    assert !@conn.locked?
+    @conn.lock!
+    assert @conn.locked?
+    assert_equal 1, @conn['admin']['$cmd.sys.inprog'].find_one['fsyncLock'], "Not fsync-locked"
+    assert_equal "unlock requested", @conn.unlock!['info']
     unlocked = false
     counter  = 0
     while counter < 5
-      if @mongo['admin']['$cmd.sys.inprog'].find_one['fsyncLock'].nil?
+      if @conn['admin']['$cmd.sys.inprog'].find_one['fsyncLock'].nil?
         unlocked = true
         break
       else
@@ -154,7 +167,7 @@ class TestConnection < Test::Unit::TestCase
         counter += 1
       end
     end
-    assert !@mongo.locked?
+    assert !@conn.locked?
     assert unlocked, "mongod failed to unlock"
   end
 
@@ -192,35 +205,35 @@ class TestConnection < Test::Unit::TestCase
 
   context "Connection exceptions" do
     setup do
-      @conn = standard_connection(:pool_size => 10, :timeout => 10)
-      @coll = @conn[MONGO_TEST_DB]['test-connection-exceptions']
+      @con = standard_connection(:pool_size => 10, :timeout => 10)
+      @coll = @con[MONGO_TEST_DB]['test-connection-exceptions']
     end
 
     should "release connection if an exception is raised on send_message" do
-      @conn.stubs(:send_message_on_socket).raises(ConnectionFailure)
-      assert_equal 0, @conn.checked_out.size
+      @con.stubs(:send_message_on_socket).raises(ConnectionFailure)
+      assert_equal 0, @con.checked_out.size
       assert_raise ConnectionFailure do
         @coll.insert({:test => "insert"})
       end
-      assert_equal 0, @conn.checked_out.size
+      assert_equal 0, @con.checked_out.size
     end
 
     should "release connection if an exception is raised on send_with_safe_check" do
-      @conn.stubs(:receive).raises(ConnectionFailure)
-      assert_equal 0, @conn.checked_out.size
+      @con.stubs(:receive).raises(ConnectionFailure)
+      assert_equal 0, @con.checked_out.size
       assert_raise ConnectionFailure do
         @coll.insert({:test => "insert"}, :safe => true)
       end
-      assert_equal 0, @conn.checked_out.size
+      assert_equal 0, @con.checked_out.size
     end
 
     should "release connection if an exception is raised on receive_message" do
-      @conn.stubs(:receive).raises(ConnectionFailure)
-      assert_equal 0, @conn.checked_out.size
+      @con.stubs(:receive).raises(ConnectionFailure)
+      assert_equal 0, @con.checked_out.size
       assert_raise ConnectionFailure do
         @coll.find.to_a
       end
-      assert_equal 0, @conn.checked_out.size
+      assert_equal 0, @con.checked_out.size
     end
   end
 end