mongo 1.8.2 → 1.8.3.rc0

data/lib/mongo/util/read_preference.rb

@@ -34,8 +34,10 @@ module Mongo
     end
 
     def select_pool(mode, tags, latency)
+      return primary_pool if @client.mongos?
+
       if mode == :primary && !tags.empty?
-        raise MongoArgumentError, "Read preferecy :primary cannot be combined with tags"
+        raise MongoArgumentError, "Read preference :primary cannot be combined with tags"
       end
 
       case mode
@@ -79,4 +81,4 @@ module Mongo
       near_pools[ rand(near_pools.length) ]
     end
   end
-end
+end

data/lib/mongo/util/server_version.rb

@@ -1,20 +1,3 @@
-# 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.
-# ++
 module Mongo
   # Simple class for comparing server versions.
   class ServerVersion

data/lib/mongo/util/sharding_pool_manager.rb

@@ -1,21 +1,6 @@
 
 module Mongo
   class ShardingPoolManager < PoolManager
-
-    attr_reader :client, :primary, :primary_pool, :hosts, :nodes,
-      :max_bson_size, :members
-
-    # Create a new set of connection pools.
-    #
-    # The pool manager will by default use the original seed list passed
-    # to the connection objects, accessible via connection.seeds. In addition,
-    # the user may pass an additional list of seeds nodes discovered in real
-    # time. The union of these lists will be used when attempting to connect,
-    # with the newly-discovered nodes being used first.
-    def initialize(client, seeds=[])
-      super
-    end
-
     def inspect
       "<Mongo::ShardingPoolManager:0x#{self.object_id.to_s(16)} @seeds=#{@seeds}>"
     end
@@ -27,14 +12,10 @@ module Mongo
     end
 
     def connect
-      close if @previously_connected
-
-      initialize_data
-      members = connect_to_members
-      initialize_pools(best(members))
-
-      @members = members
-      @previously_connected = true
+      @refresh_required = false
+      disconnect_old_members
+      connect_to_members
+      initialize_pools best(@members)
     end
 
     # We want to refresh to the member with the fastest ping time

data/lib/mongo/util/socket_util.rb

@@ -0,0 +1,20 @@
+module SocketUtil
+
+  attr_accessor :pool, :pid
+
+  def checkout
+    @pool.checkout if @pool
+  end
+
+  def checkin
+    @pool.checkin(self) if @pool
+  end
+
+  def close
+    @socket.close unless closed?
+  end
+
+  def closed?
+    @socket.closed?
+  end
+end

data/lib/mongo/util/ssl_socket.rb

@@ -8,19 +8,18 @@ module Mongo
   # a TCP connection over SSL and then provides an basic interface
   # mirroring Ruby's TCPSocket, vis., TCPSocket#send and TCPSocket#read.
   class SSLSocket
-
-    attr_accessor :pool, :pid
+    include SocketUtil
 
     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)
+      @tcp_socket = ::TCPSocket.new(host, port)
+      @tcp_socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
 
-      @ssl = OpenSSL::SSL::SSLSocket.new(@socket)
-      @ssl.sync_close = true
+      @socket = OpenSSL::SSL::SSLSocket.new(@tcp_socket)
+      @socket.sync_close = true
 
       connect
     end
@@ -28,33 +27,25 @@ module Mongo
     def connect
       if @connect_timeout
         Timeout::timeout(@connect_timeout, ConnectionTimeoutError) do
-          @ssl.connect
+          @socket.connect
         end
       else
-        @ssl.connect
+        @socket.connect
       end
     end
 
     def send(data)
-      @ssl.syswrite(data)
+      @socket.syswrite(data)
     end
 
     def read(length, buffer)
       if @op_timeout
         Timeout::timeout(@op_timeout, OperationTimeout) do
-          @ssl.sysread(length, buffer)
+          @socket.sysread(length, buffer)
         end
       else
-        @ssl.sysread(length, buffer)
+        @socket.sysread(length, buffer)
       end 
     end
-
-    def close
-      @ssl.close
-    end
-
-    def closed?
-      @ssl.closed?
-    end
   end
 end

data/lib/mongo/util/support.rb

@@ -1,21 +1,3 @@
-# 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.
-# ++
-
 require 'digest/md5'
 
 module Mongo

data/lib/mongo/util/tcp_socket.rb

@@ -8,7 +8,7 @@ module Mongo
   # sans Timeout::timeout
   #
   class TCPSocket
-    attr_accessor :pool, :pid
+    include SocketUtil
 
     def initialize(host, port, op_timeout=nil, connect_timeout=nil)
       @op_timeout = op_timeout
@@ -58,13 +58,5 @@ module Mongo
         raise ConnectionFailure, ex
       end
     end
-
-    def close
-      @socket.close
-    end
-
-    def closed?
-      @socket.closed?
-    end
   end
 end

data/lib/mongo/util/thread_local_variable_manager.rb

@@ -1,21 +1,3 @@
-# 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

data/lib/mongo/util/uri_parser.rb

@@ -1,21 +1,3 @@
-# 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.
-# ++
-
 require 'cgi'
 
 module Mongo
@@ -36,83 +18,100 @@ module Mongo
 
     SPEC_ATTRS = [:nodes, :auths]
 
+    READ_PREFERENCES = {
+      "primary" => :primary,
+      "primarypreferred" => :primary_preferred,
+      "secondary" => :secondary,
+      "secondarypreferred" => :secondary_preferred,
+      "nearest" => :nearest
+    }
+
     OPT_ATTRS  = [
       :connect,
+      :connecttimeoutms,
+      :fsync,
+      :journal,
+      :pool_size,
+      :readpreference,
       :replicaset,
+      :safe,
       :slaveok,
+      :sockettimeoutms,
       :ssl,
-      :safe,
       :w,
       :wtimeout,
-      :fsync,
-      :journal,
-      :connecttimeoutms,
-      :sockettimeoutms,
-      :wtimeoutms,
-      :pool_size
+      :wtimeoutms
     ]
 
-    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 =~ /^\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+$/ },
-                  :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 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",
-                  :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| 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 },
-                  :pool_size        => lambda {|arg| arg.to_i }
-                 }
+    OPT_VALID = {
+      :connect          => lambda { |arg| [ 'direct', 'replicaset', 'true', 'false', true, false ].include?(arg) },
+      :connecttimeoutms => lambda { |arg| arg =~ /^\d+$/ },
+      :fsync            => lambda { |arg| ['true', 'false'].include?(arg) },
+      :journal          => lambda { |arg| ['true', 'false'].include?(arg) },
+      :pool_size        => lambda { |arg| arg.to_i > 0 },
+      :readpreference   => lambda { |arg| READ_PREFERENCES.keys.include?(arg) },
+      :replicaset       => lambda { |arg| arg.length > 0 },
+      :safe             => lambda { |arg| ['true', 'false'].include?(arg) },
+      :slaveok          => lambda { |arg| ['true', 'false'].include?(arg) },
+      :sockettimeoutms  => lambda { |arg| arg =~ /^\d+$/ },
+      :ssl              => lambda { |arg| ['true', 'false'].include?(arg) },
+      :w                => lambda { |arg| arg =~ /^\w+$/ },
+      :wtimeout         => lambda { |arg| arg =~ /^\d+$/ },
+      :wtimeoutms       => lambda { |arg| arg =~ /^\d+$/ }
+     }
+
+    OPT_ERR = {
+      :connect          => "must be 'direct', 'replicaset', 'true', or 'false'",
+      :connecttimeoutms => "must be an integer specifying milliseconds",
+      :fsync            => "must be 'true' or 'false'",
+      :journal          => "must be 'true' or 'false'",
+      :pool_size        => "must be an integer greater than zero",
+      :readpreference   => "must be on of #{READ_PREFERENCES.keys.map(&:inspect).join(",")}",
+      :replicaset       => "must be a string containing the name of the replica set to connect to",
+      :safe             => "must be 'true' or 'false'",
+      :slaveok          => "must be 'true' or 'false'",
+      :sockettimeoutms  => "must be an integer specifying milliseconds",
+      :ssl              => "must be 'true' or 'false'",
+      :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",
+      :wtimeoutms       => "must be an integer specifying milliseconds"
+    }
+
+    OPT_CONV = {
+      :connect          => lambda { |arg| arg == 'false' ? false : arg }, # convert 'false' to FalseClass
+      :connecttimeoutms => lambda { |arg| arg.to_f / 1000 }, # stored as seconds
+      :fsync            => lambda { |arg| arg == 'true' ? true : false },
+      :journal          => lambda { |arg| arg == 'true' ? true : false },
+      :pool_size        => lambda { |arg| arg.to_i },
+      :readpreference   => lambda { |arg| READ_PREFERENCES[arg] },
+      :replicaset       => lambda { |arg| arg },
+      :safe             => lambda { |arg| arg == 'true' ? true : false },
+      :slaveok          => lambda { |arg| arg == 'true' ? true : false },
+      :sockettimeoutms  => lambda { |arg| arg.to_f / 1000 }, # stored as seconds
+      :ssl              => lambda { |arg| arg == 'true' ? true : false },
+      :w                => lambda { |arg| Mongo::Support.is_i?(arg) ? arg.to_i : arg.to_sym },
+      :wtimeout         => lambda { |arg| arg.to_i },
+      :wtimeoutms       => lambda { |arg| arg.to_i }
+     }
 
     attr_reader :auths,
                 :connect,
+                :connecttimeoutms,
+                :fsync,
+                :journal,
+                :nodes,
+                :pool_size,
+                :readpreference,
                 :replicaset,
+                :safe,
                 :slaveok,
+                :sockettimeoutms,
                 :ssl,
-                :safe,
                 :w,
                 :wtimeout,
-                :fsync,
-                :journal,
-                :connecttimeoutms,
-                :sockettimeoutms,
-                :wtimeoutms,
-                :pool_size,
-                :nodes
+                :wtimeoutms
 
     # 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.
@@ -141,8 +140,8 @@ module Mongo
     # @note Don't confuse this with attribute getter method #connect.
     #
     # @return [MongoClient,MongoReplicaSetClient]
-    def connection(extra_opts, legacy=false)
-      opts = connection_options.merge! extra_opts
+    def connection(extra_opts, legacy = false, sharded = false)
+      opts = connection_options.merge!(extra_opts)
       if(legacy)
         if replicaset?
           ReplSetConnection.new(node_strings, opts)
@@ -150,7 +149,9 @@ module Mongo
           Connection.new(host, port, opts)
         end
       else
-        if replicaset?
+        if sharded
+          MongoShardedClient.new(node_strings, opts)
+        elsif replicaset?
           MongoReplicaSetClient.new(node_strings, opts)
         else
           MongoClient.new(host, port, opts)
@@ -219,7 +220,11 @@ module Mongo
         opts[:pool_size] = @pool_size
       end
 
-      if @slaveok
+      if @readpreference && replicaset?
+        opts[:read] = @readpreference
+      end
+
+      if @slaveok && !@readpreference
         if direct?
           opts[:slave_ok] = true
         else