mongo 1.5.2 → 1.6.0

data/lib/mongo/util/support.rb

@@ -59,11 +59,11 @@ module Mongo
     end
 
     def validate_read_preference(value)
-      if [:primary, :secondary, nil].include?(value)
+      if [:primary, :secondary, :secondary_only, nil].include?(value)
         return true
       else
         raise MongoArgumentError, "#{value} is not a valid read preference. " +
-          "Please specify either :primary or :secondary."
+          "Please specify either :primary or :secondary or :secondary_only."
       end
     end
 

data/lib/mongo/util/uri_parser.rb

@@ -20,39 +20,63 @@ module Mongo
   class URIParser
 
     DEFAULT_PORT = 27017
-    MONGODB_URI_MATCHER = /(([-.\w:]+):([^@,]+)@)?((?:(?:[-.\w]+)(?::(?:[\w]+))?,?)+)(\/([-\w]+))?/
-    MONGODB_URI_SPEC = "mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/database]"
+
+    USER_REGEX = /([-.\w:]+)/
+    PASS_REGEX = /([^@,]+)/
+    AUTH_REGEX = /(#{USER_REGEX}:#{PASS_REGEX}@)?/
+
+    HOST_REGEX = /([-.\w]+)/
+    PORT_REGEX = /(?::(\w+))?/
+    NODE_REGEX = /((#{HOST_REGEX}#{PORT_REGEX},?)+)/
+
+    PATH_REGEX = /(?:\/([-\w]+))?/
+
+    MONGODB_URI_MATCHER = /#{AUTH_REGEX}#{NODE_REGEX}#{PATH_REGEX}/
+    MONGODB_URI_SPEC = "mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]"
+
     SPEC_ATTRS = [:nodes, :auths]
-    OPT_ATTRS  = [:connect, :replicaset, :slaveok, :safe, :w, :wtimeout, :fsync]
-
-    OPT_VALID  = {:connect    => lambda {|arg| ['direct', 'replicaset'].include?(arg)},
-                  :replicaset => lambda {|arg| arg.length > 0},
-                  :slaveok    => lambda {|arg| ['true', 'false'].include?(arg)},
-                  :safe       => lambda {|arg| ['true', 'false'].include?(arg)},
-                  :w          => lambda {|arg| arg =~ /^\d+$/ },
-                  :wtimeout   => lambda {|arg| arg =~ /^\d+$/ },
-                  :fsync      => lambda {|arg| ['true', 'false'].include?(arg)}
+    OPT_ATTRS  = [:connect, :replicaset, :slaveok, :safe, :w, :wtimeout, :fsync, :journal, :connecttimeoutms, :sockettimeoutms, :wtimeoutms]
+
+    OPT_VALID  = {:connect          => lambda {|arg| ['direct', 'replicaset'].include?(arg)},
+                  :replicaset       => lambda {|arg| arg.length > 0},
+                  :slaveok          => lambda {|arg| ['true', 'false'].include?(arg)},
+                  :safe             => lambda {|arg| ['true', 'false'].include?(arg)},
+                  :w                => lambda {|arg| arg =~ /^\d+$/ },
+                  :wtimeout         => lambda {|arg| arg =~ /^\d+$/ },
+                  :fsync            => lambda {|arg| ['true', 'false'].include?(arg)},
+                  :journal          => lambda {|arg| ['true', 'false'].include?(arg)},
+                  :connecttimeoutms => lambda {|arg| arg =~ /^\d+$/ },
+                  :sockettimeoutms  => lambda {|arg| arg =~ /^\d+$/ },
+                  :wtimeoutms       => lambda {|arg| arg =~ /^\d+$/ }
                  }
 
-    OPT_ERR    = {:connect    => "must be 'direct' or 'replicaset'",
-                  :replicaset => "must be a string containing the name of the replica set to connect to",
-                  :slaveok    => "must be 'true' or 'false'",
-                  :safe       => "must be 'true' or 'false'",
-                  :w          => "must be an integer specifying number of nodes to replica to",
-                  :wtimeout   => "must be an integer specifying milliseconds",
-                  :fsync      => "must be 'true' or 'false'"
+    OPT_ERR    = {:connect          => "must be 'direct' or 'replicaset'",
+                  :replicaset       => "must be a string containing the name of the replica set to connect to",
+                  :slaveok          => "must be 'true' or 'false'",
+                  :safe             => "must be 'true' or 'false'",
+                  :w                => "must be an integer specifying number of nodes to replica to",
+                  :wtimeout         => "must be an integer specifying milliseconds",
+                  :fsync            => "must be 'true' or 'false'",
+                  :journal          => "must be 'true' or 'false'",
+                  :connecttimeoutms => "must be an integer specifying milliseconds",
+                  :sockettimeoutms  => "must be an integer specifying milliseconds",
+                  :wtimeoutms       => "must be an integer specifying milliseconds"
                  }
 
-    OPT_CONV   = {:connect    => lambda {|arg| arg},
-                  :replicaset => lambda {|arg| arg},
-                  :slaveok    => lambda {|arg| arg == 'true' ? true : false},
-                  :safe       => lambda {|arg| arg == 'true' ? true : false},
-                  :w          => lambda {|arg| arg.to_i},
-                  :wtimeout   => lambda {|arg| arg.to_i},
-                  :fsync      => lambda {|arg| arg == 'true' ? true : false}
+    OPT_CONV   = {:connect          => lambda {|arg| arg},
+                  :replicaset       => lambda {|arg| arg},
+                  :slaveok          => lambda {|arg| arg == 'true' ? true : false},
+                  :safe             => lambda {|arg| arg == 'true' ? true : false},
+                  :w                => lambda {|arg| arg.to_i},
+                  :wtimeout         => lambda {|arg| arg.to_i},
+                  :fsync            => lambda {|arg| arg == 'true' ? true : false},
+                  :journal          => lambda {|arg| arg == 'true' ? true : false},
+                  :connecttimeoutms => lambda {|arg| arg.to_f / 1000 }, # stored as seconds
+                  :sockettimeoutms  => lambda {|arg| arg.to_f / 1000 }, # stored as seconds
+                  :wtimeoutms       => lambda {|arg| arg.to_i }
                  }
 
-    attr_reader :nodes, :auths, :connect, :replicaset, :slaveok, :safe, :w, :wtimeout, :fsync
+    attr_reader :nodes, :auths, :connect, :replicaset, :slaveok, :safe, :w, :wtimeout, :fsync, :journal, :connecttimeoutms, :sockettimeoutms, :wtimeoutms
 
     # Parse a MongoDB URI. This method is used by Connection.from_uri.
     # Returns an array of nodes and an array of db authorizations, if applicable.
@@ -76,15 +100,25 @@ module Mongo
     def connection_options
       opts = {}
 
-      if (@w || @wtimeout || @fsync) && !@safe
-        raise MongoArgumentError, "Safe must be true if w, wtimeout, or fsync is specified"
+      if (@w || @journal || @wtimeout || @fsync || @wtimeoutms) && !@safe
+        raise MongoArgumentError, "Safe must be true if w, journal, wtimeoutMS, or fsync is specified"
       end
 
       if @safe
-        if @w || @wtimeout || @fsync
+        if @w || @journal || @wtimeout || @fsync || @wtimeoutms
           safe_opts = {}
           safe_opts[:w] = @w if @w
-          safe_opts[:wtimeout] = @wtimeout if @wtimeout
+          safe_opts[:j] = @journal if @journal
+          
+          if @wtimeout
+            warn "Using wtimeout in a URI is deprecated, please use wtimeoutMS. It will be removed in v2.0."
+            safe_opts[:wtimeout] = @wtimeout
+          end
+          
+          if @wtimeoutms
+            safe_opts[:wtimeout] = @wtimeoutms
+          end
+          
           safe_opts[:fsync] = @fsync if @fsync
         else
           safe_opts = true
@@ -92,6 +126,14 @@ module Mongo
 
         opts[:safe] = safe_opts
       end
+      
+      if @connecttimeoutms
+        opts[:connect_timeout] = @connecttimeoutms
+      end
+      
+      if @sockettimeoutms
+        opts[:op_timeout] = @sockettimeoutms
+      end
 
       if @slaveok
         if @connect == 'direct'
@@ -121,7 +163,7 @@ module Mongo
       uname    = matches[2]
       pwd      = matches[3]
       hosturis = matches[4].split(',')
-      db       = matches[6]
+      db       = matches[8]
 
       hosturis.each do |hosturi|
         # If port is present, use it, otherwise use default port
@@ -158,7 +200,7 @@ module Mongo
       separator = opts.include?('&') ? '&' : ';'
       opts.split(separator).each do |attr|
         key, value = attr.split('=')
-        key   = key.to_sym
+        key = key.downcase.to_sym
         value = value.strip.downcase
         if !OPT_ATTRS.include?(key)
           raise MongoArgumentError, "Invalid Mongo URI option #{key}"
@@ -173,10 +215,6 @@ module Mongo
     end
 
     def configure_connect
-      if @nodes.length > 1 && !@connect
-        @connect = 'replicaset'
-      end
-
       if !@connect
         if @nodes.length > 1
           @connect = 'replicaset'

data/lib/mongo/version.rb

@@ -1,3 +1,3 @@
 module Mongo
-  VERSION = "1.5.2"
+  VERSION = "1.6.0"
 end

data/mongo.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.version = Mongo::VERSION
 
   s.platform = Gem::Platform::RUBY
-  s.summary = 'Ruby driver for the MongoDB'
+  s.summary = 'Ruby driver for MongoDB'
   s.description = 'A Ruby driver for MongoDB. For more information about Mongo, see http://www.mongodb.org.'
 
   s.require_paths = ['lib']
@@ -26,7 +26,7 @@ Gem::Specification.new do |s|
   s.rdoc_options = ['--main', 'README.md', '--inline-source']
   s.extra_rdoc_files = ['README.md']
 
-  s.authors = ['Jim Menard', 'Mike Dirolf', 'Kyle Banker']
+  s.authors = ['Jim Menard', 'Mike Dirolf', 'Kyle Banker', 'Tyler Brock']
   s.email = 'mongodb-dev@googlegroups.com'
   s.homepage = 'http://www.mongodb.org'
 

data/test/auxillary/authentication_test.rb

@@ -26,6 +26,7 @@ class AuthenticationTest < Test::Unit::TestCase
     @admin.authenticate('bob', 'secret')
     @db1.add_user('user1', 'secret')
     @db2.add_user('user2', 'secret')
+    @db2.add_user('userRO', 'secret', true) # read-only
     @admin.logout
 
     assert_raise Mongo::OperationFailure do
@@ -53,6 +54,7 @@ class AuthenticationTest < Test::Unit::TestCase
 
     assert @db1['stuff'].insert({:a => 2}, :safe => true)
     assert @db2['stuff'].insert({:a => 2}, :safe => true)
+    assert @db2['stuff'].find(:safe => true)
 
     @db1.logout
     assert_raise Mongo::OperationFailure do
@@ -63,6 +65,12 @@ class AuthenticationTest < Test::Unit::TestCase
     assert_raise Mongo::OperationFailure do
       assert @db2['stuff'].insert({:a => 2}, :safe => true)
     end
+
+    @db2.authenticate('userRO', 'secret')
+    assert @db2['stuff'].find(:safe => true)
+    assert_raise Mongo::OperationFailure do
+      assert @db2['stuff'].insert({:a => 2}, :safe => true)
+    end
   end
 
 end

data/test/auxillary/repl_set_auth_test.rb

@@ -15,8 +15,7 @@ class AuthTest < Test::Unit::TestCase
   end
 
   def test_repl_set_auth
-    @conn = ReplSetConnection.new([@manager.host, @manager.ports[0]], [@manager.host, @manager.ports[1]],
-      [@manager.host, @manager.ports[2]], :name => @manager.name)
+    @conn = ReplSetConnection.new(build_seeds(3), :name => @manager.name)
 
     # Add an admin user
     @conn['admin'].add_user("me", "secret")

data/test/bson/ordered_hash_test.rb

@@ -15,7 +15,7 @@ class OrderedHashTest < Test::Unit::TestCase
     a['x'] = 1
     a['y'] = 2
 
-    b = BSON::OrderedHash['x' => 1, 'y' => 2]
+    b = BSON::OrderedHash['x', 1, 'y', 2]
     assert_equal a, b
   end
 

data/test/bson/test_helper.rb

@@ -1,5 +1,6 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'bson')
-require 'rubygems' if RUBY_VERSION < '1.9.0' && ENV['C_EXT']
+require 'rubygems' if RUBY_VERSION < '1.9.0'
+gem 'test-unit'
 require 'test/unit'
 
 def silently

data/test/collection_test.rb

@@ -151,6 +151,17 @@ class TestCollection < Test::Unit::TestCase
     end
   end
 
+  def test_bulk_insert
+    docs = []
+    docs << {:foo => 1}
+    docs << {:foo => 2}
+    docs << {:foo => 3}
+    response = @@test.insert(docs)
+    assert_equal 3, response.length
+    assert response.all? {|id| id.is_a?(BSON::ObjectId)}
+    assert_equal 3, @@test.count
+  end
+
   def test_bulk_insert_with_continue_on_error
     if @@version >= "2.0"
       @@test.create_index([["foo", 1]], :unique => true)
@@ -180,6 +191,50 @@ class TestCollection < Test::Unit::TestCase
     end
   end
 
+  def test_bson_valid_with_collect_on_error
+    docs = []
+    docs << {:foo => 1}
+    docs << {:bar => 1}
+    doc_ids, error_docs = @@test.insert(docs, :collect_on_error => true)
+    assert_equal 2, @@test.count
+    assert_equal error_docs, []
+  end
+
+  def test_bson_invalid_key_serialize_error_with_collect_on_error
+    docs = []
+    docs << {:foo => 1}
+    docs << {:bar => 1}
+    invalid_docs = []
+    invalid_docs << {'$invalid-key' => 1}
+    invalid_docs << {'invalid.key'  => 1}
+    docs += invalid_docs
+    assert_raise BSON::InvalidKeyName do
+      @@test.insert(docs, :collect_on_error => false)
+    end
+    assert_equal 0, @@test.count
+
+    doc_ids, error_docs = @@test.insert(docs, :collect_on_error => true)
+    assert_equal 2, @@test.count
+    assert_equal error_docs, invalid_docs
+  end
+
+  def test_bson_invalid_encoding_serialize_error_with_collect_on_error
+    docs = []
+    docs << {:foo => 1}
+    docs << {:bar => 1}
+    invalid_docs = []
+    invalid_docs << {"\223\372\226{" => 1} # non utf8 encoding
+    docs += invalid_docs
+    assert_raise BSON::InvalidStringEncoding do
+      @@test.insert(docs, :collect_on_error => false)
+    end
+    assert_equal 0, @@test.count
+
+    doc_ids, error_docs = @@test.insert(docs, :collect_on_error => true)
+    assert_equal 2, @@test.count
+    assert_equal error_docs, invalid_docs
+  end
+
   def test_maximum_insert_size
     docs = []
     16.times do
@@ -546,6 +601,22 @@ class TestCollection < Test::Unit::TestCase
         @@test.map_reduce(m, r, :raw => true, :out => {:inline => 1})
         assert res["results"]
       end
+      
+      def test_map_reduce_with_collection_output_to_other_db
+        @@test << {:user_id => 1}
+        @@test << {:user_id => 2}
+        
+        m = Code.new("function() { emit(this.user_id, 1); }")
+        r = Code.new("function(k,vals) { return 1; }")
+        oh = BSON::OrderedHash.new
+        oh[:replace] = 'foo'
+        oh[:db] = 'somedb'
+        res = @@test.map_reduce(m, r, :out => (oh))
+        assert res["result"]
+        assert res["counts"]
+        assert res["timeMillis"]
+        assert res.find.to_a.any? {|doc| doc["_id"] == 2 && doc["value"] == 1}
+      end
     end
   end
 

data/test/connection_test.rb

@@ -137,6 +137,15 @@ class TestConnection < Test::Unit::TestCase
     assert output.string.include?("admin['$cmd'].find")
   end
 
+  def test_logging_duration
+    output = StringIO.new
+    logger = Logger.new(output)
+    logger.level = Logger::DEBUG
+    connection = standard_connection(:logger => logger).db(MONGO_TEST_DB)
+    assert_match /\(\d+ms\)/, output.string
+    assert output.string.include?("admin['$cmd'].find")
+  end
+
   def test_connection_logger
     output = StringIO.new
     logger = Logger.new(output)

data/test/db_test.rb

@@ -151,6 +151,13 @@ class DBTest < Test::Unit::TestCase
     @@db.remove_user('foo:bar')
   end
 
+  def test_authenticate_read_only
+    @@db.add_user('joebob', 'user', true) # read-only user
+    assert @@db.authenticate('joebob', 'user')
+    @@db.logout
+    @@db.remove_user('joebob')
+  end
+
   def test_authenticate_with_connection_uri
     @@db.add_user('spongebob', 'squarepants')
     assert Mongo::Connection.from_uri("mongodb://spongebob:squarepants@#{host_port}/#{@@db.name}")

data/test/grid_file_system_test.rb

@@ -165,6 +165,18 @@ class GridFileSystemTest < Test::Unit::TestCase
            assert_equal 0, @db['fs.chunks'].find({'files_id' => {'$in' => @ids}}).count
          end
 
+         should "delete all versions which exceed the number of versions to keep specified by the option :versions" do
+           @versions = 1 + rand(4-1)
+           @grid.open('sample', 'w', :versions => @versions) do |f|
+             f.write @new_data
+           end
+           @new_ids = @db['fs.files'].find({'filename' => 'sample'}).map {|file| file['_id']}
+           assert_equal @versions, @new_ids.length
+           id = @new_ids.first
+           assert !@ids.include?(id)
+           assert_equal @versions, @db['fs.files'].find({'filename' => 'sample'}).count
+         end
+         
          should "delete old versions on write with :delete_old is passed in" do
            @grid.open('sample', 'w', :delete_old => true) do |f|
              f.write @new_data

data/test/load/thin/load.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), '..', '..', '..', 'lib', 'mongo')
 require 'logger'
 
-$con = Mongo::ReplSetConnection.new(['localhost', 30000], ['localhost', 30001], :read => :secondary, :refresh_mode => :sync, :refresh_interval => 30)
+$con = Mongo::ReplSetConnection.new(['localhost:30000', 'localhost:30001'], :read => :secondary, :refresh_mode => :sync, :refresh_interval => 30)
 $db = $con['foo']
 
 class Load < Sinatra::Base

data/test/replica_sets/basic_test.rb

@@ -2,63 +2,64 @@ $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require './test/replica_sets/rs_test_helper'
 
 class BasicTest < Test::Unit::TestCase
-  include ReplicaSetTest
+  
+  def setup
+    ensure_rs
+  end
 
   def teardown
-    self.rs.restart_killed_nodes
+    @rs.restart_killed_nodes
     @conn.close if defined?(@conn) && @conn
   end
 
   def test_connect
-    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[1]], [self.rs.host, self.rs.ports[0]],
-      [self.rs.host, self.rs.ports[2]], :name => self.rs.name)
+    @conn = ReplSetConnection.new(build_seeds(3), :name => @rs.name)
     assert @conn.connected?
 
-    assert_equal self.rs.primary, @conn.primary
-    assert_equal self.rs.secondaries.sort, @conn.secondaries.sort
-    assert_equal self.rs.arbiters.sort, @conn.arbiters.sort
+    assert_equal @rs.primary, @conn.primary
+    assert_equal @rs.secondaries.sort, @conn.secondaries.sort
+    assert_equal @rs.arbiters.sort, @conn.arbiters.sort
 
-    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[1]], [self.rs.host, self.rs.ports[0]],
-      :name => self.rs.name)
+    @conn = ReplSetConnection.new(["#{@rs.host}:#{@rs.ports[1]}","#{@rs.host}:#{@rs.ports[0]}"],
+      :name => @rs.name)
     assert @conn.connected?
   end
 
   def test_cache_original_seed_nodes
-    @conn = ReplSetConnection.new([self.rs.host, self.rs.ports[1]], [self.rs.host, self.rs.ports[0]],
-      [self.rs.host, self.rs.ports[2]], [self.rs.host, 19356], :name => self.rs.name)
+    seeds = build_seeds(3) << "#{@rs.host}:19356"
+    @conn = ReplSetConnection.new(seeds, :name => @rs.name)
     assert @conn.connected?
-    assert @conn.seeds.include?([self.rs.host, 19356]), "Original seed nodes not cached!"
-    assert_equal [self.rs.host, 19356], @conn.seeds.last, "Original seed nodes not cached!"
+    assert @conn.seeds.include?([@rs.host, 19356]), "Original seed nodes not cached!"
+    assert_equal [@rs.host, 19356], @conn.seeds.last, "Original seed nodes not cached!"
   end
 
   def test_accessors
-    seeds = [[self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
-      [self.rs.host, self.rs.ports[2]]]
-    args = seeds << {:name => self.rs.name}
-    @conn = ReplSetConnection.new(*args)
+    seeds = build_seeds(3)
+    args = {:name => @rs.name}
+    @conn = ReplSetConnection.new(seeds, args)
+    @major_version = @rs.version.first
 
-    assert_equal @conn.host, self.rs.primary[0]
-    assert_equal @conn.port, self.rs.primary[1]
+    assert_equal @conn.host, @rs.primary[0]
+    assert_equal @conn.port, @rs.primary[1]
     assert_equal @conn.host, @conn.primary_pool.host
     assert_equal @conn.port, @conn.primary_pool.port
     assert_equal @conn.nodes.sort, @conn.seeds.sort
     assert_equal 2, @conn.secondaries.length
     assert_equal 0, @conn.arbiters.length
     assert_equal 2, @conn.secondary_pools.length
-    assert_equal self.rs.name, @conn.replica_set_name
+    assert_equal @rs.name, @conn.replica_set_name
     assert @conn.secondary_pools.include?(@conn.read_pool)
-    assert_equal 5, @conn.tag_map.keys.length
     assert_equal 90, @conn.refresh_interval
     assert_equal @conn.refresh_mode, false
+    assert_equal 5, @conn.tag_map.keys.length unless @major_version < 2
   end
 
   context "Socket pools" do
     context "checking out writers" do
       setup do
-        seeds = [[self.rs.host, self.rs.ports[0]], [self.rs.host, self.rs.ports[1]],
-          [self.rs.host, self.rs.ports[2]]]
-        args = seeds << {:name => self.rs.name}
-        @con = ReplSetConnection.new(*args)
+        seeds = build_seeds(3)
+        args = {:name => @rs.name}
+        @con = ReplSetConnection.new(seeds, args)
         @coll = @con[MONGO_TEST_DB]['test-connection-exceptions']
       end
 
@@ -88,7 +89,16 @@ class BasicTest < Test::Unit::TestCase
         rescue SystemStackError
         end
       end
-
+    end
+    
+    context "checking out readers" do
+      setup do
+        seeds = build_seeds(3)
+        args = {:name => @rs.name}
+        @con = ReplSetConnection.new(seeds, args)
+        @coll = @con[MONGO_TEST_DB]['test-connection-exceptions']
+      end
+      
       should "close the connection on receive_message for major exceptions" do
         @con.expects(:checkout_reader).raises(SystemStackError)
         @con.expects(:close)