mongo 1.1.5 → 1.3.0

data/lib/mongo/util/core_ext.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 
 # --
-# Copyright (C) 2008-2010 10gen Inc.
+# 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.
@@ -48,3 +48,13 @@ class Hash
   end
 
 end
+
+#:nodoc:
+class String
+
+  #:nodoc:
+  def to_bson_code
+    BSON::Code.new(self)
+  end
+
+end

data/lib/mongo/util/pool.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 
 # --
-# Copyright (C) 2008-2010 10gen Inc.
+# 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.
@@ -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
@@ -37,7 +37,11 @@ module Mongo
       # Condition variable for signal and wait
       @queue = ConditionVariable.new
 
+      # Operations to perform on a socket
+      @socket_ops = Hash.new { |h, k| h[k] = [] }
+
       @sockets      = []
+      @pids         = {}
       @checked_out  = []
     end
 
@@ -46,12 +50,12 @@ module Mongo
         begin
           sock.close
         rescue IOError => ex
-          warn "IOError when attempting to close socket connected "
-           + "to #{@host}:#{@port}: #{ex.inspect}"
+          warn "IOError when attempting to close socket connected to #{@host}:#{@port}: #{ex.inspect}"
         end
       end
       @host = @port = nil
       @sockets.clear
+      @pids.clear
       @checked_out.clear
     end
 
@@ -73,21 +77,63 @@ module Mongo
       socket = TCPSocket.new(@host, @port)
       socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
       rescue => ex
-        raise ConnectionFailure, "Failed to connect socket: #{ex}"
+        raise ConnectionFailure, "Failed to connect to host #{@host} and port #{@port}: #{ex}"
       end
+
+      # If any saved authentications exist, we want to apply those
+      # when creating new sockets.
+      @connection.apply_saved_authentication(:socket => socket)
+
       @sockets << socket
+      @pids[socket] = Process.pid
       @checked_out << socket
       socket
     end
 
+    # If a user calls DB#authenticate, and several sockets exist,
+    # then we need a way to apply the authentication on each socket.
+    # So we store the apply_authentication method, and this will be
+    # applied right before the next use of each socket.
+    def authenticate_existing
+      @connection_mutex.synchronize do
+        @sockets.each do |socket|
+          @socket_ops[socket] << Proc.new do
+            @connection.apply_saved_authentication(:socket => socket)
+          end
+        end
+      end
+    end
+
+    # Store the logout op for each existing socket to be applied before
+    # the next use of each socket.
+    def logout_existing(db)
+      @connection_mutex.synchronize do
+        @sockets.each do |socket|
+          @socket_ops[socket] << Proc.new do
+            @connection.db(db).issue_logout(:socket => socket)
+          end
+        end
+      end
+    end
+
     # Checks out the first available socket from the pool.
     #
+    # If the pid has changed, remove the socket and check out
+    # new one.
+    #
     # 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
+      if @pids[socket] != Process.pid
+         @pids[socket] = nil
+         @sockets.delete(socket)
+         socket.close
+         checkout_new_socket
+      else
+        @checked_out << socket
+        socket
+      end
     end
 
     # Check out an existing socket or create a new socket if the maximum
@@ -110,14 +156,20 @@ module Mongo
                      checkout_new_socket
                    end
 
-          return socket if socket
+          if socket
+
+          # This calls all procs, in order, scoped to existing sockets.
+          # At the moment, we use this to lazily authenticate and
+          # logout existing socket connections.
+          @socket_ops[socket].reject! do |op|
+            op.call
+          end
 
-          # Otherwise, wait
-          if @logger
-            @logger.warn "MONGODB Waiting for available connection; " +
-              "#{@checked_out.size} of #{@size} connections checked out."
+            return socket
+          else
+            # Otherwise, wait
+            @queue.wait(@connection_mutex)
           end
-          @queue.wait(@connection_mutex)
         end
       end
     end

data/lib/mongo/util/server_version.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 
 # --
-# Copyright (C) 2008-2010 10gen Inc.
+# 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.

data/lib/mongo/util/support.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 
 # --
-# Copyright (C) 2008-2010 10gen Inc.
+# 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.

data/lib/mongo/util/uri_parser.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 
 # --
-# Copyright (C) 2008-2010 10gen Inc.
+# 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.
@@ -17,28 +17,101 @@
 # ++
 
 module Mongo
-  module URIParser
+  class URIParser
 
     DEFAULT_PORT = 27017
-    MONGODB_URI_MATCHER = /(([-_.\w\d]+):([-_\w\d]+)@)?([-.\w\d]+)(:([\w\d]+))?(\/([-\d\w]+))?/
+    MONGODB_URI_MATCHER = /(([-.\w]+):([^@]+)@)?([-.\w]+)(:([\w]+))?(\/([-\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)
+    # Note: passwords can contain any character except for a ','.
+    #
+    # @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 +125,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 +135,51 @@ 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)
+      # initialize instance variables for available options
+      OPT_VALID.keys.each { |k| instance_variable_set("@#{k}", nil) }
+
+      return unless opts
 
-      [nodes, auths]
+      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
+
+      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/lib/mongo.rb

@@ -1,9 +1,25 @@
 # 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.
+# ++
 
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 module Mongo
-  VERSION = "1.1.5"
+  VERSION = "1.3.0"
 end
 
 module Mongo
@@ -11,6 +27,8 @@ module Mongo
   DESCENDING = -1
   GEO2D      = '2d'
 
+  DEFAULT_MAX_BSON_SIZE = 4 * 1024 * 1024
+
   module Constants
     OP_REPLY        = 1
     OP_MSG          = 1000
@@ -58,4 +76,22 @@ if RUBY_PLATFORM =~ /java/
 end
 require 'mongo/gridfs/grid_file_system'
 
-
+# Use SystemTimer on Ruby 1.8
+if !defined?(RUBY_ENGINE) || (RUBY_ENGINE == 'ruby' && RUBY_VERSION < '1.9.0')
+  begin
+    require 'system_timer'
+    if SystemTimer.method(:timeout).arity.abs != 2
+      raise LoadError
+    end
+    Mongo::TimeoutHandler = SystemTimer
+  rescue LoadError
+    warn "Could not load SystemTimer >= v1.2.0. Falling back to timeout.rb. " +
+         "SystemTimer is STRONGLY recommended for timeouts in Ruby 1.8.7. " +
+         "See http://ph7spot.com/blog/system-timer-1-2-release for details."
+    require 'timeout'
+    Mongo::TimeoutHandler = Timeout
+  end
+else
+  require 'timeout'
+  Mongo::TimeoutHandler = Timeout
+end

data/test/async/collection_test.rb

@@ -0,0 +1,224 @@
+require 'test/test_helper'
+
+class TestCollection < Test::Unit::TestCase
+  @@connection ||= Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost', ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT)
+  @@db   = @@connection.db(MONGO_TEST_DB)
+  @@test = @@db.collection("test")
+  @@version = @@connection.server_version
+
+  def setup
+    @@test.remove
+  end
+
+  def wait_for_async
+    sleep 0.2
+  end
+
+  def test_async_update
+    id1 = @@test.save("x" => 5)
+    failsafe = mock('failsafe will get called in block', :call => true)
+
+    @@test.update({}, {"$inc" => {"x" => 1}}, :async => true) do |error, result|
+      assert_nil error
+      assert result
+      failsafe.call
+    end
+    wait_for_async
+
+    assert_equal 1, @@test.count()
+    assert_equal 6, @@test.find_one(:_id => id1)["x"]
+  end
+
+  if @@version >= "1.1.3"
+    def test_async_multi_update
+      failsafe = mock('failsafe will get called in block', :call => true)
+
+      @@test.save("num" => 10)
+      @@test.save("num" => 10)
+      @@test.save("num" => 10)
+      assert_equal 3, @@test.count
+
+      @@test.update({"num" => 10}, {"$set" => {"num" => 100}}, :multi => true, :async => true) do |error, result|
+        assert_nil error
+        assert result
+        failsafe.call
+      end
+      wait_for_async
+    end
+  end
+
+  def test_async_upsert
+    failsafe = mock('failsafe will get called in block')
+    failsafe.expects(:call).times(2)
+
+    @@test.update({"page" => "/"}, {"$inc" => {"count" => 1}}, :upsert => true, :async => true) do |error, result|
+      assert_nil error
+      assert result
+      failsafe.call
+    end
+
+    @@test.update({"page" => "/"}, {"$inc" => {"count" => 1}}, :upsert => true, :async => true) do |error, result|
+      assert_nil error
+      assert result
+      failsafe.call
+    end
+    wait_for_async
+
+    assert_equal 1, @@test.count()
+    assert_equal 2, @@test.find_one()["count"]
+  end
+
+  def test_async_save
+    failsafe = mock('failsafe will get called in block', :call => true)
+
+    # note that the first parameter has explicit curly brackets around
+    # the hash; without those brackets as a delimiter, the :async key is
+    # viewed as part of the required +document+ parameter
+    @@test.save({"hello" => "world"}, :async => true) do |error, result|
+      assert_nil error
+      assert result
+      failsafe.call
+    end
+    wait_for_async
+    
+    assert_equal "world", @@test.find_one()["hello"]
+  end
+
+  def test_async_save_with_exception
+    failsafe = mock('failsafe will get called in block', :call => true)
+
+    @@test.create_index("hello", :unique => true)
+    @@test.save("hello" => "world")
+    
+    # all async calls on collections occur in :safe mode
+    @@test.save({"hello" => "world"}, :async => true) do |error, result|
+      assert error
+      assert error.instance_of?(OperationFailure)
+      assert_nil result
+      failsafe.call
+    end
+    wait_for_async
+    
+    assert_equal 1, @@test.count()
+    @@test.drop
+  end
+
+  def test_async_remove
+    failsafe = mock('failsafe will get called in block', :call => true)
+
+    @conn = Connection.new
+    @db   = @conn[MONGO_TEST_DB]
+    @test = @db['test-async-remove']
+    @test.save({:a => 50})
+    @test.remove({}, :async => true) do |error, result|
+      assert_nil error
+      assert result
+      failsafe.call
+    end
+    wait_for_async
+    
+    @test.drop
+  end
+
+  def test_async_count
+    failsafe = mock('failsafe will get called in block', :call => true)
+
+    @@test.drop
+
+    @@test.save("x" => 1)
+    @@test.save("x" => 2)
+
+    @@test.count(:async => true) do |error, result|
+      assert_nil error
+      assert_equal 2, result
+      failsafe.call
+    end
+    wait_for_async
+  end
+
+  # Note: #size is just an alias for #count.
+  def test_async_size
+    failsafe = mock('failsafe will get called in block', :call => true)
+    
+    @@test.drop
+
+    @@test.save("x" => 1)
+    @@test.save("x" => 2)
+
+    @@test.size(:async => true) do |error, result|
+      assert_nil error
+      assert_equal 2, result
+      failsafe.call
+    end
+    wait_for_async
+  end
+
+  def test_async_find_one
+    failsafe = mock('failsafe will get called in block', :call => true)
+
+    id = @@test.save("hello" => "world", "foo" => "bar")
+
+    @@test.find_one({}, :async => true) do |error, result|
+      assert_nil error
+      assert_equal @@test.find_one(id), result
+      failsafe.call
+    end
+    wait_for_async
+  end
+
+  def test_async_insert
+    failsafe = mock('failsafe will get called in block', :call => true)
+
+    doc = {"hello" => "world"}
+    @@test.insert(doc, :async => true) do |error, result|
+      assert_nil error
+      assert result
+      failsafe.call
+    end
+    wait_for_async
+    
+    assert_equal 1, @@test.count
+  end
+
+  def test_async_find
+    assert_raise RuntimeError do
+      @@test.find({}, :async => true)
+    end
+  end
+
+  if @@version > "1.3.0"
+    def test_async_find_and_modify
+      failsafe = mock('failsafe will get called in block', :call => true)
+
+      @@test << { :a => 1, :processed => false }
+      @@test << { :a => 2, :processed => false }
+      @@test << { :a => 3, :processed => false }
+
+      @@test.find_and_modify(:query => {}, :sort => [['a', -1]], :update => {"$set" => {:processed => true}}, :async => true) do |error, result|
+        assert_nil error
+        assert result
+        failsafe.call
+      end
+      wait_for_async
+
+      assert @@test.find_one({:a => 3})['processed']
+    end
+
+    def test_async_find_and_modify_with_invalid_options
+      failsafe = mock('failsafe will get called in block', :call => true)
+
+      @@test << { :a => 1, :processed => false }
+      @@test << { :a => 2, :processed => false }
+      @@test << { :a => 3, :processed => false }
+
+      @@test.find_and_modify(:blimey => {}, :async => true) do |error, result|
+        assert error
+        assert error.instance_of?(OperationFailure)
+        assert_nil result
+        failsafe.call
+      end
+      wait_for_async
+    end
+  end
+
+end

data/test/async/connection_test.rb

@@ -0,0 +1,24 @@
+require 'test/test_helper'
+include Mongo
+
+class ConnectionTest < Test::Unit::TestCase
+  context "Initialization: " do
+
+    context "given async connection options" do
+
+      should "default the workers pool to 1" do
+        Async::WorkerPool.expects(:new).with(1)
+
+        Connection.new('localhost', 27017)
+      end
+
+      should "override the workers pool size with the :worker_pool_size key" do
+        size = 6
+        Async::WorkerPool.expects(:new).with(size)
+
+        Connection.new('localhost', 27017, :worker_pool_size => size)
+      end
+    end # context 'given async connection options'
+
+  end # context 'Initialization'
+end