mongo 1.1.5 → 1.2.rc0

data/lib/mongo/db.rb

@@ -56,33 +56,33 @@ module Mongo
 
     # Instances of DB are normally obtained by calling Mongo#db.
     #
-    # @param [String] db_name the database name.
+    # @param [String] name the database name.
     # @param [Mongo::Connection] connection a connection object pointing to MongoDB. Note
     #   that databases are usually instantiated via the Connection class. See the examples below.
     #
-    # @option options [Boolean] :strict (False) If true, collections must exist to be accessed and must
+    # @option opts [Boolean] :strict (False) If true, collections must exist to be accessed and must
     #   not exist to be created. See DB#collection and DB#create_collection.
     #
-    # @option options [Object, #create_pk(doc)] :pk (Mongo::ObjectId) A primary key factory object,
+    # @option opts [Object, #create_pk(doc)] :pk (Mongo::ObjectId) A primary key factory object,
     #   which should take a hash and return a hash which merges the original hash with any primary key
     #   fields the factory wishes to inject. (NOTE: if the object already has a primary key,
     #   the factory should not inject a new key).
     #
-    # @option options [Boolean, Hash] :safe (false) Set the default safe-mode options
+    # @option opts [Boolean, Hash] :safe (false) Set the default safe-mode options
     #   propogated to Collection objects instantiated off of this DB. If no
     #   value is provided, the default value set on this instance's Connection object will be used. This
     #   default can be overridden upon instantiation of any collection by explicity setting a :safe value
     #   on initialization
-    # @option options [Integer] :cache_time (300) Set the time that all ensure_index calls should cache the command.
+    # @option opts [Integer] :cache_time (300) Set the time that all ensure_index calls should cache the command.
     #
     # @core databases constructor_details
-    def initialize(db_name, connection, options={})
-      @name       = Mongo::Support.validate_db_name(db_name)
+    def initialize(name, connection, opts={})
+      @name       = Mongo::Support.validate_db_name(name)
       @connection = connection
-      @strict     = options[:strict]
-      @pk_factory = options[:pk]
-      @safe       = options.has_key?(:safe) ? options[:safe] : @connection.safe
-      @cache_time = options[:cache_time] || 300 #5 minutes.
+      @strict     = opts[:strict]
+      @pk_factory = opts[:pk]
+      @safe       = opts.fetch(:safe, @connection.safe)
+      @cache_time = opts[:cache_time] || 300 #5 minutes.
     end
 
     # Authenticate with the given username and password. Note that mongod
@@ -208,8 +208,8 @@ module Mongo
     #
     # @return [Array<Mongo::Collection>]
     def collections
-      collection_names.map do |collection_name|
-        Collection.new(self, collection_name)
+      collection_names.map do |name|
+        Collection.new(name, self)
       end
     end
 
@@ -223,7 +223,7 @@ module Mongo
     def collections_info(coll_name=nil)
       selector = {}
       selector[:name] = full_collection_name(coll_name) if coll_name
-      Cursor.new(Collection.new(self, SYSTEM_NAMESPACE_COLLECTION), :selector => selector)
+      Cursor.new(Collection.new(SYSTEM_NAMESPACE_COLLECTION, self), :selector => selector)
     end
 
     # Create a collection.
@@ -233,52 +233,52 @@ module Mongo
     #
     # @param [String] name the name of the new collection.
     #
-    # @option options [Boolean] :capped (False) created a capped collection.
+    # @option opts [Boolean] :capped (False) created a capped collection.
     #
-    # @option options [Integer] :size (Nil) If +capped+ is +true+, specifies the maximum number of
+    # @option opts [Integer] :size (Nil) If +capped+ is +true+, specifies the maximum number of
     #   bytes for the capped collection. If +false+, specifies the number of bytes allocated
     #   for the initial extent of the collection.
     #
-    # @option options [Integer] :max (Nil) If +capped+ is +true+, indicates the maximum number of records 
+    # @option opts [Integer] :max (Nil) If +capped+ is +true+, indicates the maximum number of records
     #   in a capped collection.
     #
     # @raise [MongoDBError] raised under two conditions: either we're in +strict+ mode and the collection
     #   already exists or collection creation fails on the server.
     #
     # @return [Mongo::Collection]
-    def create_collection(name, options={})
+    def create_collection(name, opts={})
       # Does the collection already exist?
       if collection_names.include?(name)
         if strict?
           raise MongoDBError, "Collection #{name} already exists. Currently in strict mode."
         else
-          return Collection.new(self, name)
+          return Collection.new(name, self)
         end
       end
 
       # Create a new collection.
       oh = BSON::OrderedHash.new
       oh[:create] = name
-      doc = command(oh.merge(options || {}))
-      return Collection.new(self, name, :pk => @pk_factory) if ok?(doc)
+      doc = command(oh.merge(opts || {}))
+      return Collection.new(name, self, :pk => @pk_factory) if ok?(doc)
       raise MongoDBError, "Error creating collection: #{doc.inspect}"
     end
 
     # Get a collection by name.
     #
     # @param [String] name the collection name.
-    # @param [Hash] options any valid options that can me passed to Collection#new.
+    # @param [Hash] opts any valid options that can me passed to Collection#new.
     #
     # @raise [MongoDBError] if collection does not already exist and we're in +strict+ mode.
     #
     # @return [Mongo::Collection]
-    def collection(name, options={})
+    def collection(name, opts={})
       if strict? && !collection_names.include?(name)
         raise Mongo::MongoDBError, "Collection #{name} doesn't exist. Currently in strict mode."
       else
-        options[:safe] = options.has_key?(:safe) ? options[:safe] : @safe
-        options.merge!(:pk => @pk_factory) unless options[:pk]
-        Collection.new(self, name, options)
+        opts[:safe] = opts.fetch(:safe, @safe)
+        opts.merge!(:pk => @pk_factory) unless opts[:pk]
+        Collection.new(name, self, opts)
       end
     end
     alias_method :[], :collection
@@ -403,7 +403,7 @@ module Mongo
     def drop_index(collection_name, index_name)
       oh = BSON::OrderedHash.new
       oh[:deleteIndexes] = collection_name
-      oh[:index] = index_name
+      oh[:index] = index_name.to_s
       doc = command(oh, :check_response => false)
       ok?(doc) || raise(MongoDBError, "Error with drop_index command: #{doc.inspect}")
     end
@@ -418,7 +418,7 @@ module Mongo
     def index_information(collection_name)
       sel  = {:ns => full_collection_name(collection_name)}
       info = {}
-      Cursor.new(Collection.new(self, SYSTEM_INDEX_COLLECTION), :selector => sel).each do |index|
+      Cursor.new(Collection.new(SYSTEM_INDEX_COLLECTION, self), :selector => sel).each do |index|
         info[index['name']] = index
       end
       info
@@ -558,7 +558,7 @@ module Mongo
     #
     # @return [Array] a list of documents containing profiling information.
     def profiling_info
-      Cursor.new(Collection.new(self, DB::SYSTEM_PROFILE_COLLECTION), :selector => {}).to_a
+      Cursor.new(Collection.new(SYSTEM_PROFILE_COLLECTION, self), :selector => {}).to_a
     end
 
     # Validate a named collection.
@@ -581,7 +581,7 @@ module Mongo
     private
 
     def system_command_collection
-      Collection.new(self, SYSTEM_COMMAND_COLLECTION)
+      Collection.new(SYSTEM_COMMAND_COLLECTION, self)
     end
   end
 end

data/lib/mongo/repl_set_connection.rb

@@ -32,6 +32,8 @@ module Mongo
     # @param [Array] args A list of host-port pairs ending with a hash containing any options. See
     #   the examples below for exactly how to use the constructor.
     #
+    # @option options [String] :rs_name (nil) The name of the replica set to connect to. You
+    #   can use this option to verify that you're connecting to the right replica set.
     # @option options [Boolean, Hash] :safe (false) Set the default safe-mode options
     #   propogated to DB objects instantiated off of this Connection. This
     #   default can be overridden upon instantiation of any DB by explicity setting a :safe value
@@ -48,8 +50,10 @@ module Mongo
     # @example Connect to a replica set and provide two seed nodes:
     #   ReplSetConnection.new(['localhost', 30000], ['localhost', 30001])
     #
-    # @example Connect to a replica set providing two seed nodes and allowing reads from a
-    #   secondary node:
+    # @example Connect to a replica set providing two seed nodes and ensuring a connection to the replica set named 'prod':
+    #   ReplSetConnection.new(['localhost', 30000], ['localhost', 30001], :rs_name => 'prod')
+    #
+    # @example Connect to a replica set providing two seed nodes and allowing reads from a secondary node:
     #   ReplSetConnection.new(['localhost', 30000], ['localhost', 30001], :read_secondary => true)
     #
     # @see http://api.mongodb.org/ruby/current/file.REPLICA_SETS.html Replica sets in Ruby
@@ -111,7 +115,9 @@ module Mongo
 
       pick_secondary_for_read if @read_secondary
 
-      if !connected?
+      if connected?
+        BSON::BSON_CODER.update_max_bson_size(self)
+      else
         if @secondary_pools.empty?
           raise ConnectionFailure, "Failed to connect any given host:port"
         else
@@ -124,6 +130,14 @@ module Mongo
       @nodes_to_try.length > 0
     end
 
+    # Determine whether we're reading from a primary node. If false,
+    # this connection connects to a secondary node and @read_secondaries is true.
+    #
+    # @return [Boolean]
+    def read_primary?
+      !@read_pool || @read_pool.length.zero?
+    end
+
     # Close the connection to the database.
     def close
       super

data/lib/mongo/util/pool.rb

@@ -22,14 +22,14 @@ module Mongo
 
     # Create a new pool of connections.
     #
-    def initialize(connection, host, port, options={})
+    def initialize(connection, host, port, opts={})
       @connection  = connection
 
       @host, @port = host, port
 
       # Pool size and timeout.
-      @size      = options[:size] || 1
-      @timeout   = options[:timeout]   || 5.0
+      @size      = opts[:size] || 1
+      @timeout   = opts[:timeout]   || 5.0
 
       # Mutex for synchronizing pool access
       @connection_mutex = Mutex.new

data/lib/mongo/util/uri_parser.rb

@@ -17,28 +17,99 @@
 # ++
 
 module Mongo
-  module URIParser
+  class URIParser
 
     DEFAULT_PORT = 27017
     MONGODB_URI_MATCHER = /(([-_.\w\d]+):([-_\w\d]+)@)?([-.\w\d]+)(:([\w\d]+))?(\/([-\d\w]+))?/
     MONGODB_URI_SPEC = "mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/database]"
+    SPEC_ATTRS = [:nodes, :auths]
+    OPT_ATTRS  = [:connect, :replicaset, :slaveok, :safe, :w, :wtimeout, :fsync]
 
-    extend self
+    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_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_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}
+                 }
+
+    attr_reader :nodes, :auths, :connect, :replicaset, :slaveok, :safe, :w, :wtimeout, :fsync
 
     # 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.
     #
-    # @private
-    def parse(string)
+    # @core connections
+    def initialize(string)
       if string =~ /^mongodb:\/\//
         string = string[10..-1]
       else
         raise MongoArgumentError, "MongoDB URI must match this spec: #{MONGODB_URI_SPEC}"
       end
 
-      nodes = []
-      auths = []
-      specs = string.split(',')
+      hosts, opts = string.split('?')
+      parse_hosts(hosts)
+      parse_options(opts)
+      configure_connect
+    end
+
+    def connection_options
+      opts = {}
+
+      if (@w || @wtimeout || @fsync) && !@safe
+        raise MongoArgumentError, "Safe must be true if w, wtimeout, or fsync is specified"
+      end
+
+      if @safe
+        if @w || @wtimeout || @fsync
+          safe_opts = {}
+          safe_opts[:w] = @w if @w
+          safe_opts[:wtimeout] = @wtimeout if @wtimeout
+          safe_opts[:fsync] = @fsync if @fsync
+        else
+          safe_opts = true
+        end
+
+        opts[:safe] = safe_opts
+      end
+
+      if @slaveok
+        if @connect == 'direct'
+          opts[:slave_ok] = true
+        else
+          opts[:read_secondary] = true
+        end
+      end
+
+      opts[:rs_name] = @replicaset if @replicaset
+
+      opts
+    end
+
+    private
+
+    def parse_hosts(hosts)
+      @nodes = []
+      @auths = []
+      specs = hosts.split(',')
       specs.each do |spec|
         matches  = MONGODB_URI_MATCHER.match(spec)
         if !matches
@@ -52,8 +123,8 @@ module Mongo
         if !(port.to_s =~ /^\d+$/)
           raise MongoArgumentError, "Invalid port #{port}; port must be specified as digits."
         end
-        port  = port.to_i
-        db    = matches[8]
+        port    = port.to_i
+        db      = matches[8]
 
         if uname && pwd && db
           auths << {'db_name' => db, 'username' => uname, 'password' => pwd}
@@ -62,10 +133,47 @@ module Mongo
             "and db if any one of these is specified."
         end
 
-        nodes << [host, port]
+        @nodes << [host, port]
+      end
+    end
+
+    # This method uses the lambdas defined in OPT_VALID and OPT_CONV to validate
+    # and convert the given options.
+    def parse_options(opts)
+      return unless opts
+      separator = opts.include?('&') ? '&' : ';'
+      opts.split(separator).each do |attr|
+        key, value = attr.split('=')
+        key   = key.to_sym
+        value = value.strip.downcase
+        if !OPT_ATTRS.include?(key)
+          raise MongoArgumentError, "Invalid Mongo URI option #{key}"
+        end
+
+        if OPT_VALID[key].call(value)
+          instance_variable_set("@#{key}", OPT_CONV[key].call(value))
+        else
+          raise MongoArgumentError, "Invalid value for #{key}: #{OPT_ERR[key]}"
+        end
+      end
+    end
+
+    def configure_connect
+      if @nodes.length > 1 && !@connect
+        @connect = 'replicaset'
       end
 
-      [nodes, auths]
+      if !@connect
+        if @nodes.length > 1
+          @connect = 'replicaset'
+        else
+          @connect = 'direct'
+        end
+      end
+
+      if @connect == 'direct' && @replicaset
+        raise MongoArgumentError, "If specifying a replica set name, please also specify that connect=replicaset"
+      end
     end
   end
 end

data/test/bson/bson_test.rb

@@ -67,13 +67,26 @@ class BSONTest < Test::Unit::TestCase
     assert_doc_pass(doc)
   end
 
-  def test_document_length
-    doc = {'name' => 'a' * 5 * 1024 * 1024}
+  def test_limit_max_bson_size
+    doc = {'name' => 'a' * BSON_CODER.max_bson_size}
     assert_raise InvalidDocument do
       assert @encoder.serialize(doc)
     end
   end
 
+  def test_max_bson_size
+    assert BSON_CODER.max_bson_size >= BSON::DEFAULT_MAX_BSON_SIZE
+  end
+
+  def test_update_max_bson_size
+    require 'ostruct'
+    mock_conn = OpenStruct.new
+    size      = 7 * 1024 * 1024
+    mock_conn.max_bson_size = size
+    assert_equal size, BSON_CODER.update_max_bson_size(mock_conn)
+    assert_equal size, BSON_CODER.max_bson_size
+  end
+
   def test_round_trip
     doc = {'doc' => 123}
     @encoder.deserialize(@encoder.serialize(doc))
@@ -200,6 +213,15 @@ class BSONTest < Test::Unit::TestCase
     assert_doc_pass(doc)
   end
 
+  def test_array_keys
+    doc = {'doc' => [1, 2, 'a', 'b']}
+    bson = @encoder.serialize(doc).to_a
+    assert_equal 48, bson[14]
+    assert_equal 49, bson[21]
+    assert_equal 50, bson[28]
+    assert_equal 51, bson[37]
+  end
+
   def test_regex
     doc = {'doc' => /foobar/i}
     assert_doc_pass(doc)

data/test/collection_test.rb

@@ -32,11 +32,11 @@ class TestCollection < Test::Unit::TestCase
   end
 
   def test_pk_factory_on_collection
-    @coll = Collection.new(@@db, 'foo', TestPK)
+    @coll = Collection.new('foo', @@db, TestPK)
     assert_equal TestPK, @coll.pk_factory
 
 
-    @coll2 = Collection.new(@@db, 'foo', :pk => TestPK)
+    @coll2 = Collection.new('foo', @@db, :pk => TestPK)
     assert_equal TestPK, @coll2.pk_factory
   end
 
@@ -417,7 +417,7 @@ class TestCollection < Test::Unit::TestCase
 
       m = "function() { emit(this.user_id, 1); }"
       r = "function(k,vals) { return 1; }"
-      res = @@test.map_reduce(m, r);
+      res = @@test.map_reduce(m, r, :out => 'foo');
       assert res.find_one({"_id" => 1})
       assert res.find_one({"_id" => 2})
     end
@@ -428,7 +428,7 @@ class TestCollection < Test::Unit::TestCase
 
       m = Code.new("function() { emit(this.user_id, 1); }")
       r = Code.new("function(k,vals) { return 1; }")
-      res = @@test.map_reduce(m, r);
+      res = @@test.map_reduce(m, r, :out => 'foo');
       assert res.find_one({"_id" => 1})
       assert res.find_one({"_id" => 2})
     end
@@ -441,7 +441,7 @@ class TestCollection < Test::Unit::TestCase
 
       m = Code.new("function() { emit(this.user_id, 1); }")
       r = Code.new("function(k,vals) { return 1; }")
-      res = @@test.map_reduce(m, r, :query => {"user_id" => {"$gt" => 1}});
+      res = @@test.map_reduce(m, r, :query => {"user_id" => {"$gt" => 1}}, :out => 'foo');
       assert_equal 2, res.count
       assert res.find_one({"_id" => 2})
       assert res.find_one({"_id" => 3})
@@ -450,7 +450,7 @@ class TestCollection < Test::Unit::TestCase
     def test_map_reduce_with_raw_response
       m = Code.new("function() { emit(this.user_id, 1); }")
       r = Code.new("function(k,vals) { return 1; }")
-      res = @@test.map_reduce(m, r, :raw => true)
+      res = @@test.map_reduce(m, r, :raw => true, :out => 'foo')
       assert res["result"]
       assert res["counts"]
       assert res["timeMillis"]
@@ -600,6 +600,23 @@ class TestCollection < Test::Unit::TestCase
     @@test.drop_index("a_1")
   end
 
+  def test_ensure_index_timeout
+    @@db.cache_time = 2
+    coll = @@db['ensure_test']
+    coll.expects(:generate_indexes).twice
+    coll.ensure_index([['a', 1]])
+
+    # These will be cached
+    coll.ensure_index([['a', 1]])
+    coll.ensure_index([['a', 1]])
+    coll.ensure_index([['a', 1]])
+    coll.ensure_index([['a', 1]])
+
+    sleep(3)
+    # This won't be, so generate_indexes will be called twice
+    coll.ensure_index([['a', 1]])
+  end
+
   context "Grouping" do
     setup do
       @@test.remove
@@ -693,6 +710,17 @@ class TestCollection < Test::Unit::TestCase
       @geo        = @@db.collection('geo')
     end
 
+    should "create index using symbols" do
+      @collection.create_index :foo, :name => :bar
+      @geo.create_index :goo, :name => :baz
+      assert @collection.index_information['bar']
+      @collection.drop_index :bar
+      assert_nil @collection.index_information['bar']
+      assert @geo.index_information['baz']
+      @geo.drop_index(:baz)
+      assert_nil @geo.index_information['baz']
+    end
+
     should "create a geospatial index" do
       @geo.save({'loc' => [-100, 100]})
       @geo.create_index([['loc', Mongo::GEO2D]])