mongo 1.8.0 → 1.8.2

data/lib/mongo/util/ssl_socket.rb

@@ -9,11 +9,12 @@ module Mongo
   # mirroring Ruby's TCPSocket, vis., TCPSocket#send and TCPSocket#read.
   class SSLSocket
 
-    attr_accessor :pool
+    attr_accessor :pool, :pid
 
     def initialize(host, port, op_timeout=nil, connect_timeout=nil)
       @op_timeout = op_timeout
       @connect_timeout = connect_timeout
+      @pid = Process.pid
 
       @socket = ::TCPSocket.new(host, port)
       @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)

data/lib/mongo/util/support.rb

@@ -24,14 +24,6 @@ module Mongo
     include Mongo::Conversions
     extend self
 
-    READ_PREFERENCES = [
-      :primary,
-      :primary_preferred,
-      :secondary,
-      :secondary_preferred,
-      :nearest
-    ]
-
     # Commands that may be sent to replica-set secondaries, depending on
     # read preference and tags. All other commands are always run on the primary.
     SECONDARY_OK_COMMANDS = [
@@ -43,7 +35,10 @@ module Mongo
       'distinct',
       'geonear',
       'geosearch',
-      'geowalk'
+      'geowalk',
+      'mapreduce',
+      'replsetgetstatus',
+      'ismaster',
     ]
 
     # Generate an MD5 for authentication.
@@ -94,15 +89,6 @@ module Mongo
       end
     end
 
-    def validate_read_preference(value)
-      if READ_PREFERENCES.include?(value)
-        return true
-      else
-        raise MongoArgumentError, "#{value} is not a valid read preference. " +
-          "Please specify one of the following read preferences as a symbol: #{READ_PREFERENCES}"
-      end
-    end
-
     def format_order_clause(order)
       case order
         when Hash, BSON::OrderedHash then hash_as_sort_parameters(order)
@@ -114,6 +100,10 @@ module Mongo
       end
     end
 
+    def is_i?(value)
+      return !!(value =~ /^\d+$/)
+    end
+
     # Determine if a database command has succeeded by
     # checking the document response.
     #

data/lib/mongo/util/tcp_socket.rb

@@ -8,17 +8,18 @@ module Mongo
   # sans Timeout::timeout
   #
   class TCPSocket
-    attr_accessor :pool
+    attr_accessor :pool, :pid
 
     def initialize(host, port, op_timeout=nil, connect_timeout=nil)
-      @op_timeout = op_timeout 
+      @op_timeout = op_timeout
       @connect_timeout = connect_timeout
+      @pid = Process.pid
 
       # TODO: Prefer ipv6 if server is ipv6 enabled
-      @host = Socket.getaddrinfo(host, nil, Socket::AF_INET).first[3]
+      @address = Socket.getaddrinfo(host, nil, Socket::AF_INET).first[3]
       @port = port
 
-      @socket_address = Socket.pack_sockaddr_in(@port, @host)
+      @socket_address = Socket.pack_sockaddr_in(@port, @address)
       @socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
       @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
 

data/lib/mongo/util/thread_local_variable_manager.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+# --
+# Copyright (C) 2008-2012 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.
+# ++
+
+#:nodoc:
+module Mongo
+  module ThreadLocalVariableManager
+    def thread_local
+      Thread.current[:mongo_thread_locals] ||= Hash.new do |hash, key|
+        hash[key] = Hash.new unless hash.key? key
+        hash[key]
+      end
+    end
+  end
+end

data/lib/mongo/util/unix_socket.rb

@@ -0,0 +1,23 @@
+require 'socket'
+
+module Mongo
+  # Wrapper class for Socket
+  #
+  # Emulates UNIXSocket with operation and connection timeout
+  # sans Timeout::timeout
+  #
+  class UNIXSocket < TCPSocket
+    def initialize(socket_path, port=:socket, op_timeout=nil, connect_timeout=nil)
+      @op_timeout = op_timeout
+      @connect_timeout = connect_timeout
+
+      @address = socket_path
+      @port = :socket # purposely override input
+
+      @socket_address = Socket.pack_sockaddr_un(@address)
+      @socket = Socket.new(Socket::AF_UNIX, Socket::SOCK_STREAM, 0)
+      connect
+    end
+  end
+end
+

data/lib/mongo/util/uri_parser.rb

@@ -40,6 +40,7 @@ module Mongo
       :connect,
       :replicaset,
       :slaveok,
+      :ssl,
       :safe,
       :w,
       :wtimeout,
@@ -47,52 +48,61 @@ module Mongo
       :journal,
       :connecttimeoutms,
       :sockettimeoutms,
-      :wtimeoutms
+      :wtimeoutms,
+      :pool_size
     ]
 
     OPT_VALID  = {:connect          => lambda {|arg| ['direct', 'replicaset', 'true', 'false', true, false].include?(arg)},
                   :replicaset       => lambda {|arg| arg.length > 0},
                   :slaveok          => lambda {|arg| ['true', 'false'].include?(arg)},
+                  :ssl              => lambda {|arg| ['true', 'false'].include?(arg)},
                   :safe             => lambda {|arg| ['true', 'false'].include?(arg)},
-                  :w                => lambda {|arg| arg =~ /^\d+$/ },
+                  :w                => lambda {|arg| arg =~ /^\w+$/ },
                   :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+$/ }
+                  :wtimeoutms       => lambda {|arg| arg =~ /^\d+$/ },
+                  :pool_size        => lambda {|arg| arg.to_i > 0 }
                  }
 
     OPT_ERR    = {:connect          => "must be 'direct', 'replicaset', 'true', or 'false'",
                   :replicaset       => "must be a string containing the name of the replica set to connect to",
                   :slaveok          => "must be 'true' or 'false'",
+                  :ssl              => "must be 'true' or 'false'",
                   :safe             => "must be 'true' or 'false'",
-                  :w                => "must be an integer specifying number of nodes to replica to",
+                  :w                => "must be an integer indicating number of nodes to replicate to or a string specifying
+                                        that replication is required to the majority or nodes with a particilar getLastErrorMode.",
                   :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"
+                  :wtimeoutms       => "must be an integer specifying milliseconds",
+                  :pool_size        => "must be an integer greater than zero"
                  }
 
     OPT_CONV   = {:connect          => lambda {|arg| arg == 'false' ? false : arg}, # be sure to convert 'false' to FalseClass
                   :replicaset       => lambda {|arg| arg},
                   :slaveok          => lambda {|arg| arg == 'true' ? true : false},
+                  :ssl              => lambda {|arg| arg == 'true' ? true : false},
                   :safe             => lambda {|arg| arg == 'true' ? true : false},
-                  :w                => lambda {|arg| arg.to_i},
+                  :w                => lambda {|arg| Mongo::Support.is_i?(arg) ? arg.to_i : arg.to_sym },
                   :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 }
+                  :wtimeoutms       => lambda {|arg| arg.to_i },
+                  :pool_size        => lambda {|arg| arg.to_i }
                  }
 
     attr_reader :auths,
                 :connect,
                 :replicaset,
                 :slaveok,
+                :ssl,
                 :safe,
                 :w,
                 :wtimeout,
@@ -100,7 +110,9 @@ module Mongo
                 :journal,
                 :connecttimeoutms,
                 :sockettimeoutms,
-                :wtimeoutms
+                :wtimeoutms,
+                :pool_size,
+                :nodes
 
     # Parse a MongoDB URI. This method is used by MongoClient.from_uri.
     # Returns an array of nodes and an array of db authorizations, if applicable.
@@ -133,13 +145,13 @@ module Mongo
       opts = connection_options.merge! extra_opts
       if(legacy)
         if replicaset?
-          ReplSetConnection.new(nodes, opts)
+          ReplSetConnection.new(node_strings, opts)
         else
           Connection.new(host, port, opts)
         end
       else
         if replicaset?
-          MongoReplicaSetClient.new(nodes, opts)
+          MongoReplicaSetClient.new(node_strings, opts)
         else
           MongoClient.new(host, port, opts)
         end
@@ -203,14 +215,20 @@ module Mongo
         opts[:op_timeout] = @sockettimeoutms
       end
 
+      if @pool_size
+        opts[:pool_size] = @pool_size
+      end
+
       if @slaveok
         if direct?
           opts[:slave_ok] = true
         else
-          opts[:read] = :secondary
+          opts[:read] = :secondary_preferred
         end
       end
 
+      opts[:ssl] = @ssl
+
       if direct?
         opts[:auths] = auths
       end
@@ -224,12 +242,8 @@ module Mongo
       opts
     end
 
-    def nodes
-      if @nodes.length == 1
-        @nodes
-      else
-        @nodes.collect {|node| "#{node[0]}:#{node[1]}"}
-      end
+    def node_strings
+      nodes.map { |node| node.join(':') }
     end
 
     private
@@ -258,7 +272,6 @@ module Mongo
         end
 
         port = port.to_i
-
         @nodes << [host, port]
       end
 

data/lib/mongo/util/write_concern.rb

@@ -52,7 +52,7 @@ module Mongo
         :w        => 1,
         :j        => false,
         :fsync    => false,
-        :wtimeout => false
+        :wtimeout => nil
       }
       write_concern.merge!(parent.write_concern) if parent
       write_concern.merge!(opts.reject {|k,v| !write_concern.keys.include?(k)})
@@ -60,7 +60,12 @@ module Mongo
     end
 
     def self.gle?(write_concern)
-      write_concern[:w] > 0 || write_concern[:j] || write_concern[:fsync] || write_concern[:wtimeout]
+      (write_concern[:w].is_a? Symbol) ||
+      (write_concern[:w].is_a? String) ||
+      write_concern[:w] > 0 ||
+      write_concern[:j] ||
+      write_concern[:fsync] ||
+      write_concern[:wtimeout]
     end
 
   end

data/mongo.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
 
   s.files             = ['mongo.gemspec', 'LICENSE', 'VERSION']
   s.files             += ['README.md', 'Rakefile', 'bin/mongo_console']
-  s.files             += ['lib/mongo.rb'] + Dir['lib/mongo/**/*.rb'] + Dir['examples/**/*.rb']
+  s.files             += ['lib/mongo.rb'] + Dir['lib/mongo/**/*.rb']
 
   s.test_files        = Dir['test/**/*.rb']
   s.executables       = ['mongo_console']

data/test/auxillary/repl_set_auth_test.rb

@@ -21,14 +21,14 @@ class AuthTest < Test::Unit::TestCase
 
     # Ensure that insert fails
     assert_raise_error Mongo::OperationFailure, "unauthorized" do
-      @client['foo']['stuff'].insert({:a => 2}, {:w => 3})
+      @client['foo']['stuff'].insert({:a => 2}, {:w => 2})
     end
 
     # Then authenticate
     assert @client['admin'].authenticate("me", "secret")
 
     # Insert should succeed now
-    assert @client['foo']['stuff'].insert({:a => 2}, {:w => 3})
+    assert @client['foo']['stuff'].insert({:a => 2}, {:w => 2})
 
     # So should a query
     assert @client['foo']['stuff'].find_one

data/test/bson/bson_test.rb

@@ -349,7 +349,7 @@ class BSONTest < Test::Unit::TestCase
     doc2 = @encoder.deserialize(bson)
 
     # Java doesn't deserialize to DBRefs
-    if RUBY_PLATFORM =~ /java/
+    if RUBY_PLATFORM =~ /java/ && BSON.extension?
       assert_equal 'namespace', doc2['dbref']['$ns']
       assert_equal oid, doc2['dbref']['$id']
     else

data/test/bson/byte_buffer_test.rb

@@ -45,10 +45,6 @@ class ByteBufferTest < Test::Unit::TestCase
     assert_equal 4, @buf.length
   end
 
-  def test_default_order
-    assert_equal :little_endian, @buf.order
-  end
-
   def test_long_length
     @buf.put_long 1027
     assert_equal 8, @buf.length
@@ -66,29 +62,31 @@ class ByteBufferTest < Test::Unit::TestCase
     assert_equal 41.2, @buf.get_double
   end
   
-  if defined?(Encoding)
-    def test_serialize_cstr_converts_encoding_to_utf8
-      theta = "hello \xC8".force_encoding("ISO-8859-7")
-      ByteBuffer.serialize_cstr(@buf, theta)
-      assert_equal "hello \xCE\x98\0", @buf.to_s
-      assert_equal Encoding.find('binary'), @buf.to_s.encoding
-    end
-    
-    def test_serialize_cstr_validates_data_as_utf8
-      assert_raises(Encoding::UndefinedConversionError) do
-        ByteBuffer.serialize_cstr(@buf, "hello \xFF")
+  if BSON_CODER == BSON::BSON_RUBY
+    if defined?(Encoding)
+      def test_serialize_cstr_throws_error_for_bad_utf8
+        bad = "hello \xC8".force_encoding("ISO-8859-7")
+        assert_raises(BSON::InvalidStringEncoding) do
+          BSON_CODER::serialize_cstr(@buf, bad)
+        end
       end
-    end
-  else
-    def test_serialize_cstr_forces_encoding_to_utf8
-      # Unicode snowman (\u2603)
-      ByteBuffer.serialize_cstr(@buf, "hello \342\230\203")
-      assert_equal "hello \342\230\203\0", @buf.to_s
-    end
-    
-    def test_serialize_cstr_validates_data_as_utf8
-      assert_raises(BSON::InvalidStringEncoding) do
-        ByteBuffer.serialize_cstr(@buf, "hello \xFF")
+
+      def test_serialize_cstr_does_not_validate_data_as_utf8
+        assert_raises(BSON::InvalidStringEncoding) do
+          BSON_CODER::serialize_cstr(@buf, "hello \xFF")
+        end
+      end
+    else
+      def test_serialize_cstr_forces_encoding_to_utf8
+        # Unicode snowman (\u2603)
+        BSON_CODER::serialize_cstr(@buf, "hello \342\230\203")
+        assert_equal "hello \342\230\203\0", @buf.to_s
+      end
+
+      def test_serialize_cstr_validates_data_as_utf8
+        assert_raises(BSON::InvalidStringEncoding) do
+          BSON_CODER::serialize_cstr(@buf, "hello \xFF")
+        end
       end
     end
   end

data/test/bson/hash_with_indifferent_access_test.rb

@@ -1,6 +1,16 @@
 # encoding:utf-8
 require 'test_helper'
-require 'support/hash_with_indifferent_access'
+
+# Note: HashWithIndifferentAccess is so commonly used
+# that we always need to make sure that the driver works
+# with it. However, the bson gem should never need to
+# depend on it.
+
+# As a result, ActiveSupport is no longer a gem dependency and it should remain
+# that way. It must be required by the application code or
+# via bundler for developmet.
+
+require 'bson/support/hash_with_indifferent_access'
 
 class HashWithIndifferentAccessTest < Test::Unit::TestCase
   include BSON

data/test/functional/collection_test.rb

@@ -231,8 +231,8 @@ class TestCollection < Test::Unit::TestCase
     docs << {:bar => 1}
     invalid_docs = []
     invalid_docs << {"\223\372\226}" => 1} # non utf8 encoding
-    docs += invalid_docs 
-    
+    docs += invalid_docs
+
     assert_raise BSON::InvalidStringEncoding do
       @@test.insert(docs, :collect_on_error => false)
     end
@@ -295,7 +295,7 @@ class TestCollection < Test::Unit::TestCase
     @@test.update({"x" => 1}, {"$set" => {"a.b" => 2}})
     assert_equal 2, @@test.find_one("x" => 1)["a"]["b"]
 
-    assert_raise_error BSON::InvalidKeyName, "key a.b must not contain '.'" do
+    assert_raise_error BSON::InvalidKeyName do
       @@test.update({"x" => 1}, {"a.b" => 3})
     end
   end
@@ -535,7 +535,7 @@ class TestCollection < Test::Unit::TestCase
     end
     assert c.closed?
   end
-  
+
   def setup_aggregate_data
     # save some data
     @@test.save( {
@@ -551,7 +551,7 @@ class TestCollection < Test::Unit::TestCase
             ],
         "other" => { "foo" => 5 }
         } )
-    
+
     @@test.save( {
          "_id" => 2,
          "title" => "this is your title", 
@@ -565,7 +565,7 @@ class TestCollection < Test::Unit::TestCase
          ],
           "other" => { "bar" => 14 }
         })
-        
+
     @@test.save( {
             "_id" => 3,
             "title" => "this is some other title", 
@@ -579,9 +579,9 @@ class TestCollection < Test::Unit::TestCase
             ],
             "other" => { "bar" => 14 }
         })
-    
+
   end
-  
+
   if @@version > '2.1.1'
     def test_reponds_to_aggregate
       assert_respond_to @@test, :aggregate
@@ -629,7 +629,7 @@ class TestCollection < Test::Unit::TestCase
       assert_equal 1, results.length
     end
 
-    def test_aggregate_pipeline_unwind                    
+    def test_aggregate_pipeline_unwind
       setup_aggregate_data
       desired_results = [ {"_id"=>1, "title"=>"this is my title", "author"=>"bob", "posted"=>Time.utc(2000),
                           "pageViews"=>5, "tags"=>"fun", "comments"=>[{"author"=>"joe", "text"=>"this is cool"}, 
@@ -742,11 +742,11 @@ 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
@@ -866,7 +866,7 @@ class TestCollection < Test::Unit::TestCase
     cursor      = @@test.find({}, :transformer => transformer)
     assert_equal(transformer, cursor.transformer)
   end
-  
+
   def test_find_one_with_transformer
     klass       = Struct.new(:id, :a)
     transformer = Proc.new { |doc| klass.new(doc['_id'], doc['a']) }
@@ -1048,7 +1048,7 @@ class TestCollection < Test::Unit::TestCase
       assert_equal 1, @collection.size
     end
   end
-  
+
   context "Drop index " do
     setup do
       @@db.drop_collection('test-collection')
@@ -1061,21 +1061,21 @@ class TestCollection < Test::Unit::TestCase
       @collection.drop_index([['a', Mongo::ASCENDING]])
       assert_nil @collection.index_information['a_1']
     end
-    
+
     should "drop an index which was given a specific name" do
       @collection.create_index([['a', Mongo::DESCENDING]], {:name => 'i_will_not_fear'})
       assert @collection.index_information['i_will_not_fear']
       @collection.drop_index([['a', Mongo::DESCENDING]])
       assert_nil @collection.index_information['i_will_not_fear']
     end
-  
+
     should "drops an composite index" do
       @collection.create_index([['a', Mongo::DESCENDING], ['b', Mongo::ASCENDING]])
       assert @collection.index_information['a_-1_b_1']
       @collection.drop_index([['a', Mongo::DESCENDING], ['b', Mongo::ASCENDING]])
       assert_nil @collection.index_information['a_-1_b_1']
     end
-    
+
     should "drops an index with symbols" do
       @collection.create_index([['a', Mongo::DESCENDING], [:b, Mongo::ASCENDING]])
       assert @collection.index_information['a_-1_b_1']