mongo 1.2.4 → 1.3.0.rc0

data/lib/mongo/db.rb

@@ -69,7 +69,7 @@ module Mongo
     #   the factory should not inject a new key).
     #
     # @option opts [Boolean, Hash] :safe (false) Set the default safe-mode options
-    #   propogated to Collection objects instantiated off of this DB. If no
+    #   propagated 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
@@ -272,7 +272,7 @@ module Mongo
         if strict?
           raise MongoDBError, "Collection #{name} already exists. Currently in strict mode."
         else
-          return Collection.new(name, self)
+          return Collection.new(name, self, opts)
         end
       end
 
@@ -287,7 +287,7 @@ module Mongo
     # Get a collection by name.
     #
     # @param [String] name the collection name.
-    # @param [Hash] opts any valid options that can me passed to Collection#new.
+    # @param [Hash] opts any valid options that can be passed to Collection#new.
     #
     # @raise [MongoDBError] if collection does not already exist and we're in +strict+ mode.
     #

data/lib/mongo/exceptions.rb

@@ -57,6 +57,9 @@ module Mongo
   # Raised when a database operation fails.
   class OperationFailure < MongoDBError; end
 
+  # Raised when a socket read operation times out.
+  class OperationTimeout < ::Timeout::Error; end
+
   # Raised when a client attempts to perform an invalid operation.
   class InvalidOperation < MongoDBError; end
 

data/lib/mongo/gridfs/grid_io.rb

@@ -17,10 +17,6 @@
 # ++
 
 require 'digest/md5'
-begin
-require 'mime/types'
-rescue LoadError
-end
 
 module Mongo
 
@@ -172,6 +168,91 @@ module Mongo
     def tell
       @file_position
     end
+    alias :pos :tell
+
+    # Rewind the file. This is equivalent to seeking to the zeroth position.
+    #
+    # @return [Integer] the position of the file after rewinding (always zero).
+    def rewind
+      raise GridError, "file not opened for read" unless @mode[0] == ?r
+      seek(0)
+    end
+
+    # Return a boolean indicating whether the position pointer is
+    # at the end of the file.
+    #
+    # @return [Boolean]
+    def eof
+      raise GridError, "file not opened for read #{@mode}" unless @mode[0] == ?r
+      @file_position >= @file_length
+    end
+    alias :eof? :eof
+
+    # Return the next line from a GridFS file. This probably
+    # makes sense only if you're storing plain text. This method
+    # has a somewhat tricky API, which it inherits from Ruby's
+    # StringIO#gets.
+    #
+    # @param [String, Integer] separator or length. If a separator,
+    #   read up to the separator. If a length, read the +length+ number
+    #   of bytes. If nil, read the entire file.
+    # @param [Integer] length If a separator is provided, then
+    #   read until either finding the separator or
+    #   passing over the +length+ number of bytes.
+    #
+    # @return [String]
+    def gets(separator="\n", length=nil)
+      if separator.nil?
+        read_all
+      elsif separator.is_a?(Integer)
+        read_length(separator)
+      elsif separator.length > 1
+        result = ''
+        len = 0
+        match_idx = 0
+        match_num = separator.length - 1
+        to_match = separator[match_idx].chr
+        if length
+          matcher = lambda {|idx, num| idx < num && len < length }
+        else
+          matcher = lambda {|idx, num| idx < num}
+        end
+        while matcher.call(match_idx, match_num) && char = getc
+          result << char
+          len += 1
+          if char == to_match
+            while match_idx < match_num do
+              match_idx += 1
+              to_match = separator[match_idx].chr
+              char = getc
+              result << char
+              if char != to_match
+                match_idx = 0
+                to_match = separator[match_idx].chr
+                break
+              end
+            end
+          end
+        end
+        result
+      else
+        result = ''
+        len = 0
+        while char = getc
+          result << char
+          len += 1
+          break if char == separator || (length ? len >= length : false)
+        end
+        result
+      end
+    end
+
+    # Return the next byte from the GridFS file.
+    #
+    # @return [String]
+    def getc
+      read_length(1)
+    end
 
     # Creates or updates the document from the files collection that
     # stores the chunks' metadata. The file becomes available only after
@@ -260,7 +341,7 @@ module Mongo
       if length.nil?
         to_read = remaining
       else
-        to_read    = length > remaining ? remaining : length
+        to_read = length > remaining ? remaining : length
       end
       return nil unless remaining > 0
 
@@ -335,8 +416,8 @@ module Mongo
       @files_id      = opts.delete(:_id) || BSON::ObjectId.new
       @content_type  = opts.delete(:content_type) || (defined? MIME) && get_content_type || DEFAULT_CONTENT_TYPE
       @chunk_size    = opts.delete(:chunk_size) || DEFAULT_CHUNK_SIZE
-      @metadata      = opts.delete(:metadata) if opts[:metadata]
-      @aliases       = opts.delete(:aliases) if opts[:aliases]
+      @metadata      = opts.delete(:metadata)
+      @aliases       = opts.delete(:aliases)
       @file_length   = 0
       opts.each {|k, v| self[k] = v}
       check_existing_file if @safe

data/lib/mongo/repl_set_connection.rb

@@ -29,8 +29,8 @@ module Mongo
     # Connection#arbiters. This is useful if your application needs to connect manually to nodes other
     # than the primary.
     #
-    # @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.
+    # @param [Array] args A list of host-port pairs to be used as seed nodes followed by 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.
@@ -47,7 +47,9 @@ module Mongo
     #   this is the number of seconds to wait for a new connection to be released before throwing an exception.
     #   Note: this setting is relevant only for multi-threaded applications.
     #
-    # @example Connect to a replica set and provide two seed nodes:
+    # @example Connect to a replica set and provide two seed nodes. Note that the number of seed nodes does
+    #   not have to be equal to the number of replica set members. The purpose of seed nodes is to permit
+    #   the driver to find at least one replica set member even if a member is down.
     #   ReplSetConnection.new(['localhost', 30000], ['localhost', 30001])
     #
     # @example Connect to a replica set providing two seed nodes and ensuring a connection to the replica set named 'prod':
@@ -99,7 +101,7 @@ module Mongo
     #
     # @raise [ConnectionFailure] if unable to connect to any host or port.
     def connect
-      reset_connection
+      close
       @nodes_to_try = @nodes.clone
 
       while connecting?
@@ -133,6 +135,20 @@ module Mongo
       @nodes_to_try.length > 0
     end
 
+    # The replica set primary's host name.
+    #
+    # @return [String]
+    def host
+      super
+    end
+
+    # The replica set primary's port.
+    #
+    # @return [Integer]
+    def port
+      super
+    end
+
     # Determine whether we're reading from a primary node. If false,
     # this connection connects to a secondary node and @read_secondaries is true.
     #
@@ -149,13 +165,6 @@ module Mongo
       @secondary_pools.each do |pool|
         pool.close
       end
-    end
-
-    # If a ConnectionFailure is raised, this method will be called
-    # to close the connection and reset connection values.
-    # TODO: what's the point of this method?
-    def reset_connection
-      super
       @secondaries     = []
       @secondary_pools = []
       @arbiters        = []
@@ -163,6 +172,15 @@ module Mongo
       @nodes_to_try = []
     end
 
+    # If a ConnectionFailure is raised, this method will be called
+    # to close the connection and reset connection values.
+    # @deprecated
+    def reset_connection
+      close
+      warn "ReplSetConnection#reset_connection is now deprecated. " +
+        "Use ReplSetConnection#close instead."
+    end
+
     # Is it okay to connect to a slave?
     #
     # @return [Boolean]

data/lib/mongo/util/pool.rb

@@ -41,6 +41,7 @@ module Mongo
       @socket_ops = Hash.new { |h, k| h[k] = [] }
 
       @sockets      = []
+      @pids         = {}
       @checked_out  = []
     end
 
@@ -54,6 +55,7 @@ module Mongo
       end
       @host = @port = nil
       @sockets.clear
+      @pids.clear
       @checked_out.clear
     end
 
@@ -83,6 +85,7 @@ module Mongo
       @connection.apply_saved_authentication(:socket => socket)
 
       @sockets << socket
+      @pids[socket] = Process.pid
       @checked_out << socket
       socket
     end
@@ -115,12 +118,22 @@ module Mongo
 
     # 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
@@ -155,10 +168,6 @@ module Mongo
             return socket
           else
             # 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

data/lib/mongo/util/timeout.rb

@@ -0,0 +1,42 @@
+# 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.
+# ++
+module Mongo #:nodoc:
+  module TimeoutWrapper
+    extend self
+
+    def timeout_lib=(lib)
+      @@timeout_lib = lib
+    end
+
+    def timeout_lib
+      @@timeout_lib
+    end
+
+    def timeout(delay, &block)
+      if timeout_lib
+        begin
+        timeout_lib.timeout(delay, &block)
+        rescue ::Timeout::Error
+          raise Mongo::OperationTimeout
+        end
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/mongo/util/uri_parser.rb

@@ -20,7 +20,7 @@ module Mongo
   class URIParser
 
     DEFAULT_PORT = 27017
-    MONGODB_URI_MATCHER = /(([-_.\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]
@@ -142,7 +142,11 @@ module Mongo
     # 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
+
       separator = opts.include?('&') ? '&' : ';'
       opts.split(separator).each do |attr|
         key, value = attr.split('=')

data/test/auxillary/fork_test.rb

@@ -0,0 +1,30 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mongo'
+require 'test/unit'
+require './test/test_helper'
+
+class ForkTest < Test::Unit::TestCase
+  include Mongo
+
+  def setup
+    @conn = standard_connection
+  end
+
+  def test_fork
+    # Now insert some data
+    10.times do |n|
+      @conn[MONGO_TEST_DB]['nums'].insert({:a => n})
+    end
+
+    # Now fork. You'll almost always see an exception here.
+    if !Kernel.fork
+      10.times do
+        assert @conn[MONGO_TEST_DB]['nums'].find_one
+      end
+    else
+      10.times do
+        assert @conn[MONGO_TEST_DB]['nums'].find_one
+      end
+    end
+  end
+end

data/test/bson/bson_test.rb

@@ -1,10 +1,14 @@
 # encoding:utf-8
 require './test/test_helper'
-require 'complex'
+
+if RUBY_VERSION < '1.9'
+  require 'complex'
+  require 'rational'
+end
 require 'bigdecimal'
-require 'rational'
 
 begin
+  require 'tzinfo'
   require 'active_support/core_ext'
   Time.zone = "Pacific Time (US & Canada)"
   Zone = Time.zone.now
@@ -116,15 +120,23 @@ class BSONTest < Test::Unit::TestCase
     end
   else
     def test_non_utf8_string
-      bson = BSON::BSON_CODER.serialize({'str' => 'aé'.encode('iso-8859-1')})
-      result = BSON::BSON_CODER.deserialize(bson)['str']
-      assert_equal 'aé', result
-      assert_equal 'UTF-8', result.encoding.name
+      assert_raise BSON::InvalidStringEncoding do
+        BSON::BSON_CODER.serialize({'str' => 'aé'.encode('iso-8859-1')})
+      end
+    end
+
+    def test_invalid_utf8_string
+      str = "123\xD9"
+      assert !str.valid_encoding?
+      assert_raise BSON::InvalidStringEncoding do
+        BSON::BSON_CODER.serialize({'str' => str})
+      end
     end
 
     def test_non_utf8_key
-      bson = BSON::BSON_CODER.serialize({'aé'.encode('iso-8859-1') => 'hello'})
-      assert_equal 'hello', BSON::BSON_CODER.deserialize(bson)['aé']
+      assert_raise BSON::InvalidStringEncoding do
+        BSON::BSON_CODER.serialize({'aé'.encode('iso-8859-1') => 'hello'})
+      end
     end
 
     # Based on a test from sqlite3-ruby
@@ -134,14 +146,14 @@ class BSONTest < Test::Unit::TestCase
       str = "壁に耳あり、障子に目あり"
       bson = BSON::BSON_CODER.serialize("x" => str)
 
-      Encoding.default_internal = 'EUC-JP'
+      silently { Encoding.default_internal = 'EUC-JP' }
       out = BSON::BSON_CODER.deserialize(bson)["x"]
 
       assert_equal Encoding.default_internal, out.encoding
       assert_equal str.encode('EUC-JP'), out
       assert_equal str, out.encode(str.encoding)
     ensure
-      Encoding.default_internal = before_enc
+      silently { Encoding.default_internal = before_enc }
     end
   end
 
@@ -161,12 +173,12 @@ class BSONTest < Test::Unit::TestCase
     assert_doc_pass(doc)
   end
 
-   def test_double
-     doc = {'doc' => 41.25}
-     assert_doc_pass(doc)
-   end
+  def test_double
+    doc = {'doc' => 41.25}
+    assert_doc_pass(doc)
+  end
 
- def test_int
+  def test_int
     doc = {'doc' => 42}
     assert_doc_pass(doc)
 
@@ -246,8 +258,14 @@ class BSONTest < Test::Unit::TestCase
     assert_in_delta doc['date'], doc2['date'], 0.001
   end
 
+  def test_date_in_array
+    doc = {'date' => [Time.now.utc]}
+    bson = @encoder.serialize(doc)
+    doc2 = @encoder.deserialize(bson)
+  end
+
   def test_date_returns_as_utc
-    doc = {'date' => Time.now}
+    doc = {'date' => Time.now.utc}
     bson = @encoder.serialize(doc)
     doc2 = @encoder.deserialize(bson)
     assert doc2['date'].utc?
@@ -277,7 +295,7 @@ class BSONTest < Test::Unit::TestCase
       ensure
         if !invalid_date.is_a? Time
           assert_equal InvalidDocument, e.class
-          assert_match /UTC Time/, e.message
+          assert_match(/UTC Time/, e.message)
         end
       end
     end
@@ -311,6 +329,20 @@ class BSONTest < Test::Unit::TestCase
     bin = Binary.new
     'binstring'.each_byte { |b| bin.put(b) }
 
+    doc = {'bin' => bin}
+    bson = @encoder.serialize(doc)
+    doc2 = @encoder.deserialize(bson)
+    bin2 = doc2['bin']
+    assert_kind_of Binary, bin2
+    assert_equal 'binstring', bin2.to_s
+    assert_equal Binary::SUBTYPE_SIMPLE, bin2.subtype
+  end
+
+  def test_binary_with_deprecated_subtype
+    bin = Binary.new
+    'binstring'.each_byte { |b| bin.put(b) }
+    bin.subtype = Binary::SUBTYPE_BYTES
+
     doc = {'bin' => bin}
     bson = @encoder.serialize(doc)
     doc2 = @encoder.deserialize(bson)
@@ -328,7 +360,7 @@ class BSONTest < Test::Unit::TestCase
     bin2 = doc2['bin']
     assert_kind_of Binary, bin2
     assert_equal 'somebinarystring', bin2.to_s
-    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
+    assert_equal Binary::SUBTYPE_SIMPLE, bin2.subtype
   end
 
   def test_binary_type
@@ -368,7 +400,7 @@ class BSONTest < Test::Unit::TestCase
     bin2 = doc2['bin']
     assert_kind_of Binary, bin2
     assert_equal [1, 2, 3, 4, 5], bin2.to_a
-    assert_equal Binary::SUBTYPE_BYTES, bin2.subtype
+    assert_equal Binary::SUBTYPE_SIMPLE, bin2.subtype
   end
 
   def test_put_id_first
@@ -393,15 +425,24 @@ class BSONTest < Test::Unit::TestCase
   if !(RUBY_PLATFORM =~ /java/)
     def test_timestamp
       val = {"test" => [4, 20]}
-      assert_equal val, @encoder.deserialize([0x13, 0x00, 0x00, 0x00,
-                                        0x11, 0x74, 0x65, 0x73,
-                                        0x74, 0x00, 0x04, 0x00,
-                                        0x00, 0x00, 0x14, 0x00,
-                                        0x00, 0x00, 0x00])
+      result = @encoder.deserialize([0x13, 0x00, 0x00, 0x00,
+                                     0x11, 0x74, 0x65, 0x73,
+                                     0x74, 0x00, 0x04, 0x00,
+                                     0x00, 0x00, 0x14, 0x00,
+                                     0x00, 0x00, 0x00])
 
+      assert_equal 4, result["test"][0]
+      assert_equal 20, result["test"][1]
     end
   end
 
+  def test_timestamp_type
+    ts = Timestamp.new(5000, 100)
+    doc = {:ts => ts}
+    bson = @encoder.serialize(doc)
+    assert_equal ts, @encoder.deserialize(bson)["ts"]
+  end
+
   def test_overflow
     doc = {"x" => 2**75}
     assert_raise RangeError do
@@ -439,7 +480,7 @@ class BSONTest < Test::Unit::TestCase
       rescue => e
       ensure
         assert_equal InvalidDocument, e.class
-        assert_match /Cannot serialize/, e.message
+        assert_match(/Cannot serialize/, e.message)
       end
     end
   end
@@ -573,7 +614,7 @@ class BSONTest < Test::Unit::TestCase
       @encoder.serialize({"he\0llo" => "world"}, true)
     end
 
-    assert_raise_error BSON::InvalidKeyName, "$hello" do
+    assert_raise BSON::InvalidKeyName do
       @encoder.serialize({"$hello" => "world"}, true)
     end
 
@@ -581,7 +622,7 @@ class BSONTest < Test::Unit::TestCase
       @encoder.serialize({"hello" => {"$hello" => "world"}}, true)
     end
 
-    assert_raise_error BSON::InvalidKeyName, ".hello" do
+    assert_raise BSON::InvalidKeyName  do
       @encoder.serialize({".hello" => "world"}, true)
     end