mongo 1.3.0 → 1.12.5

data/lib/mongo/networking.rb

@@ -0,0 +1,372 @@
+# Copyright (C) 2009-2013 MongoDB, 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
+  module Networking
+
+    STANDARD_HEADER_SIZE = 16
+    RESPONSE_HEADER_SIZE = 20
+
+    # Counter for generating unique request ids.
+    @@current_request_id = 0
+
+    # Send a message to MongoDB, adding the necessary headers.
+    #
+    # @param [Integer] operation a MongoDB opcode.
+    # @param [BSON::ByteBuffer] message a message to send to the database.
+    #
+    # @option opts [Symbol] :connection (:writer) The connection to which
+    #   this message should be sent. Valid options are :writer and :reader.
+    #
+    # @return [Integer] number of bytes sent
+    def send_message(operation, message, opts={})
+      if opts.is_a?(String)
+        warn "MongoClient#send_message no longer takes a string log message. " +
+          "Logging is now handled within the Collection and Cursor classes."
+        opts = {}
+      end
+
+      add_message_headers(message, operation)
+      packed_message = message.to_s
+
+      sock = nil
+      pool = opts.fetch(:pool, nil)
+      begin
+        if pool
+          #puts "send_message pool.port:#{pool.port}"
+          sock = pool.checkout
+        else
+          sock ||= checkout_writer
+        end
+        send_message_on_socket(packed_message, sock)
+      rescue SystemStackError, NoMemoryError, SystemCallError => ex
+        close
+        raise ex
+      ensure
+        if sock
+          sock.checkin
+        end
+      end
+      true
+    end
+
+    # Sends a message to the database, waits for a response, and raises
+    # an exception if the operation has failed.
+    #
+    # @param [Integer] operation a MongoDB opcode.
+    # @param [BSON::ByteBuffer] message a message to send to the database.
+    # @param [String] db_name the name of the database. used on call to get_last_error.
+    # @param [String] log_message this is currently a no-op and will be removed.
+    # @param [Hash] write_concern write concern.
+    #
+    # @see DB#get_last_error for valid last error params.
+    #
+    # @return [Hash] The document returned by the call to getlasterror.
+    def send_message_with_gle(operation, message, db_name, log_message=nil, write_concern=false)
+      docs = num_received = cursor_id = ''
+      add_message_headers(message, operation)
+
+      last_error_message = build_get_last_error_message(db_name, write_concern)
+      last_error_id = add_message_headers(last_error_message, Mongo::Constants::OP_QUERY)
+
+      packed_message = message.append!(last_error_message).to_s
+      sock = nil
+      begin
+        sock = checkout_writer
+        send_message_on_socket(packed_message, sock)
+        docs, num_received, cursor_id = receive(sock, last_error_id)
+      rescue ConnectionFailure, OperationFailure, OperationTimeout => ex
+        raise ex
+      rescue SystemStackError, NoMemoryError, SystemCallError => ex
+        close
+        sock = nil
+        raise ex
+      ensure
+        checkin(sock) if sock
+        sock = nil
+      end
+
+      if num_received == 1
+        error = docs[0]['err'] || docs[0]['errmsg']
+        if error && error.include?("not master")
+          close
+          raise ConnectionFailure.new(docs[0]['code'].to_s + ': ' + error, docs[0]['code'], docs[0])
+        elsif (!error.nil? && note = docs[0]['jnote'] || docs[0]['wnote']) # assignment
+          code = docs[0]['code'] || Mongo::ErrorCode::BAD_VALUE # as of server version 2.5.5
+          raise WriteConcernError.new(code.to_s + ': ' + note, code, docs[0])
+        elsif error
+          code = docs[0]['code'] || Mongo::ErrorCode::UNKNOWN_ERROR
+          error = "wtimeout" if error == "timeout"
+          raise WriteConcernError.new(code.to_s + ': ' + error, code, docs[0]) if error == "wtimeout"
+          raise OperationFailure.new(code.to_s + ': ' + error, code, docs[0])
+        end
+      end
+
+      docs[0]
+    end
+
+    # Sends a message to the database and waits for the response.
+    #
+    # @param [Integer] operation a MongoDB opcode.
+    # @param [BSON::ByteBuffer] message a message to send to the database.
+    # @param [String] log_message this is currently a no-op and will be removed.
+    # @param [Socket] socket a socket to use in lieu of checking out a new one.
+    # @param [Boolean] command (false) indicate whether this is a command. If this is a command,
+    #   the message will be sent to the primary node.
+    # @param [Symbol] read the read preference.
+    # @param [Boolean] exhaust (false) indicate whether the cursor should be exhausted. Set
+    #   this to true only when the OP_QUERY_EXHAUST flag is set.
+    # @param [Boolean] compile_regex whether BSON regex objects should be compiled into Ruby regexes.
+    #
+    # @return [Array]
+    #   An array whose indexes include [0] documents returned, [1] number of document received,
+    #   and [3] a cursor_id.
+    def receive_message(operation, message, log_message=nil, socket=nil, command=false,
+                        read=:primary, exhaust=false, compile_regex=true)
+      request_id     = add_message_headers(message, operation)
+      packed_message = message.to_s
+      opts = { :exhaust => exhaust,
+               :compile_regex => compile_regex }
+
+      result = ''
+
+      begin
+        send_message_on_socket(packed_message, socket)
+        result = receive(socket, request_id, opts)
+      rescue ConnectionFailure => ex
+        socket.close
+        checkin(socket)
+        raise ex
+      rescue SystemStackError, NoMemoryError, SystemCallError => ex
+        close
+        raise ex
+      rescue Exception => ex
+        if defined?(IRB)
+          close if ex.class == IRB::Abort
+        end
+        raise ex
+      end
+      result
+    end
+
+    private
+
+    def receive(sock, cursor_id, opts={})
+      exhaust    = !!opts.delete(:exhaust)
+
+      if exhaust
+        docs = []
+        num_received = 0
+
+        while(cursor_id != 0) do
+          receive_header(sock, cursor_id, exhaust)
+          number_received, cursor_id = receive_response_header(sock)
+          new_docs, n = read_documents(number_received, sock, opts)
+          docs += new_docs
+          num_received += n
+        end
+
+        return [docs, num_received, cursor_id]
+      else
+        receive_header(sock, cursor_id, exhaust)
+        number_received, cursor_id = receive_response_header(sock)
+        docs, num_received = read_documents(number_received, sock, opts)
+
+        return [docs, num_received, cursor_id]
+      end
+    end
+
+    def receive_header(sock, expected_response, exhaust=false)
+      header = receive_message_on_socket(16, sock)
+
+      # unpacks to size, request_id, response_to
+      response_to = header.unpack('VVV')[2]
+      if !exhaust && expected_response != response_to
+        raise Mongo::ConnectionFailure, "Expected response #{expected_response} but got #{response_to}"
+      end
+
+      unless header.size == STANDARD_HEADER_SIZE
+        raise "Short read for DB response header: " +
+          "expected #{STANDARD_HEADER_SIZE} bytes, saw #{header.size}"
+      end
+      nil
+    end
+
+    def receive_response_header(sock)
+      header_buf = receive_message_on_socket(RESPONSE_HEADER_SIZE, sock)
+      if header_buf.length != RESPONSE_HEADER_SIZE
+        raise "Short read for DB response header; " +
+          "expected #{RESPONSE_HEADER_SIZE} bytes, saw #{header_buf.length}"
+      end
+
+      # unpacks to flags, cursor_id_a, cursor_id_b, starting_from, number_remaining
+      flags, cursor_id_a, cursor_id_b, _, number_remaining = header_buf.unpack('VVVVV')
+
+      check_response_flags(flags)
+      cursor_id = (cursor_id_b << 32) + cursor_id_a
+      [number_remaining, cursor_id]
+    end
+
+    def check_response_flags(flags)
+      if flags & Mongo::Constants::REPLY_CURSOR_NOT_FOUND != 0
+        raise Mongo::OperationFailure, "Query response returned CURSOR_NOT_FOUND. " +
+          "Either an invalid cursor was specified, or the cursor may have timed out on the server."
+      elsif flags & Mongo::Constants::REPLY_QUERY_FAILURE != 0
+        # Mongo query reply failures are handled in Cursor#next.
+      end
+    end
+
+    def read_documents(number_received, sock, opts)
+      docs = []
+      number_remaining = number_received
+      while number_remaining > 0 do
+        buf = receive_message_on_socket(4, sock)
+        size = buf.unpack('V')[0]
+        buf << receive_message_on_socket(size - 4, sock)
+        number_remaining -= 1
+        docs << BSON::BSON_CODER.deserialize(buf, opts)
+      end
+      [docs, number_received]
+    end
+
+    def build_command_message(db_name, query, projection=nil, skip=0, limit=-1)
+      message = BSON::ByteBuffer.new("", max_message_size)
+      message.put_int(0)
+      BSON::BSON_RUBY.serialize_cstr(message, "#{db_name}.$cmd")
+      message.put_int(skip)
+      message.put_int(limit)
+      message.put_binary(BSON::BSON_CODER.serialize(query, false, false, max_bson_size).to_s)
+      message.put_binary(BSON::BSON_CODER.serialize(projection, false, false, max_bson_size).to_s) if projection
+      message
+    end
+
+    # Constructs a getlasterror message. This method is used exclusively by
+    # MongoClient#send_message_with_gle.
+    def build_get_last_error_message(db_name, write_concern)
+      gle = BSON::OrderedHash.new
+      gle[:getlasterror] = 1
+      if write_concern.is_a?(Hash)
+        write_concern.assert_valid_keys(:w, :wtimeout, :fsync, :j)
+        gle.merge!(write_concern)
+        gle.delete(:w) if gle[:w] == 1
+      end
+      gle[:w] = gle[:w].to_s if gle[:w].is_a?(Symbol)
+      build_command_message(db_name, gle)
+    end
+
+    # Prepares a message for transmission to MongoDB by
+    # constructing a valid message header.
+    #
+    # Note: this method modifies message by reference.
+    #
+    # @return [Integer] the request id used in the header
+    def add_message_headers(message, operation)
+      headers = [
+        # Message size.
+        16 + message.size,
+
+        # Unique request id.
+        request_id = get_request_id,
+
+        # Response id.
+        0,
+
+        # Opcode.
+        operation
+      ].pack('VVVV')
+
+      message.prepend!(headers)
+
+      request_id
+    end
+
+    # Increment and return the next available request id.
+    #
+    # return [Integer]
+    def get_request_id
+      request_id = ''
+      @id_lock.synchronize do
+        request_id = @@current_request_id += 1
+      end
+      request_id
+    end
+
+    # Low-level method for sending a message on a socket.
+    # Requires a packed message and an available socket,
+    #
+    # @return [Integer] number of bytes sent
+    def send_message_on_socket(packed_message, socket)
+      begin
+      total_bytes_sent = socket.send(packed_message)
+      if total_bytes_sent != packed_message.size
+        packed_message.slice!(0, total_bytes_sent)
+        while packed_message.size > 0
+          byte_sent = socket.send(packed_message)
+          total_bytes_sent += byte_sent
+          packed_message.slice!(0, byte_sent)
+        end
+      end
+      total_bytes_sent
+      rescue => ex
+        socket.close
+        raise ConnectionFailure, "Operation failed with the following exception: #{ex}:#{ex.message}"
+      end
+    end
+
+    # Low-level method for receiving data from socket.
+    # Requires length and an available socket.
+    def receive_message_on_socket(length, socket)
+      begin
+          message = receive_data(length, socket)
+      rescue OperationTimeout, ConnectionFailure => ex
+        socket.close
+
+        if ex.class == OperationTimeout
+          raise OperationTimeout, "Timed out waiting on socket read."
+        else
+          raise ConnectionFailure, "Operation failed with the following exception: #{ex}"
+        end
+      end
+      message
+    end
+
+    def receive_data(length, socket)
+      message = new_binary_string
+      socket.read(length, message)
+
+      raise ConnectionFailure, "connection closed" unless message && message.length > 0
+      if message.length < length
+        chunk = new_binary_string
+        while message.length < length
+          socket.read(length - message.length, chunk)
+          raise ConnectionFailure, "connection closed" unless chunk.length > 0
+          message << chunk
+        end
+      end
+      message
+    end
+
+    if defined?(Encoding)
+      BINARY_ENCODING = Encoding.find("binary")
+
+      def new_binary_string
+        "".force_encoding(BINARY_ENCODING)
+      end
+    else
+      def new_binary_string
+        ""
+      end
+    end
+  end
+end

data/lib/mongo/{util → utils}/conversions.rb

@@ -1,20 +1,17 @@
-# encoding: UTF-8
-
-# --
-# Copyright (C) 2008-2011 10gen Inc.
+# Copyright (C) 2009-2013 MongoDB, 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
+#   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:
 
   # Utility module to include when needing to convert certain types of
@@ -24,8 +21,31 @@ module Mongo #:nodoc:
     ASCENDING_CONVERSION  = ["ascending", "asc", "1"]
     DESCENDING_CONVERSION = ["descending", "desc", "-1"]
 
+    # Allows sort parameters to be defined as a Hash.
+    # Does not allow usage of un-ordered hashes, therefore
+    # Ruby 1.8.x users must use BSON::OrderedHash.
+    #
+    # Example:
+    #
+    # <tt>hash_as_sort_parameters({:field1 => :asc, "field2" => :desc})</tt> =>
+    # <tt>{ "field1" => 1, "field2" => -1}</tt>
+    def hash_as_sort_parameters(value)
+      if RUBY_VERSION < '1.9' && !value.is_a?(BSON::OrderedHash)
+        raise InvalidSortValueError.new(
+          "Hashes used to supply sort order must maintain ordering." +
+          "Use BSON::OrderedHash."
+        )
+      else
+        order_by = value.inject({}) do |memo, (key, direction)|
+          memo[key.to_s] = sort_value(direction)
+          memo
+        end
+      end
+      order_by
+    end
+
     # Converts the supplied +Array+ to a +Hash+ to pass to mongo as
-    # sorting parameters. The returned +Hash+ will vary depending 
+    # sorting parameters. The returned +Hash+ will vary depending
     # on whether the passed +Array+ is one or two dimensional.
     #
     # Example:
@@ -67,7 +87,7 @@ module Mongo #:nodoc:
       { str => 1 }
     end
 
-    # Converts the +String+, +Symbol+, or +Integer+ to the 
+    # Converts the +String+, +Symbol+, or +Integer+ to the
     # corresponding sort value in MongoDB.
     #
     # Valid conversions (case-insensitive):
@@ -77,6 +97,7 @@ module Mongo #:nodoc:
     #
     # If the value is invalid then an error will be raised.
     def sort_value(value)
+      return value if value.is_a?(Hash)
       val = value.to_s.downcase
       return 1 if ASCENDING_CONVERSION.include?(val)
       return -1 if DESCENDING_CONVERSION.include?(val)

data/lib/mongo/{util → utils}/core_ext.rb

@@ -1,20 +1,16 @@
-# encoding: UTF-8
-
-# --
-# Copyright (C) 2008-2011 10gen Inc.
+# Copyright (C) 2009-2013 MongoDB, 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
+#   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:
 class Object
@@ -27,17 +23,6 @@ class Object
 
 end
 
-#:nodoc:
-module Enumerable
-
-  #:nodoc:
-  def each_with_object(memo)
-    each { |element| yield(element, memo) }
-    memo
-  end unless [].respond_to?(:each_with_object)
-
-end
-
 #:nodoc:
 class Hash
 
@@ -45,7 +30,7 @@ class Hash
   def assert_valid_keys(*valid_keys)
     unknown_keys = keys - [valid_keys].flatten
     raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
-  end
+  end unless instance_methods.include?(:assert_valid_keys)
 
 end
 
@@ -58,3 +43,28 @@ class String
   end
 
 end
+
+#:nodoc:
+class Class
+  def mongo_thread_local_accessor name, options = {}
+    m = Module.new
+    m.module_eval do
+      class_variable_set :"@@#{name}", Hash.new {|h,k| h[k] = options[:default] }
+    end
+    m.module_eval %{
+
+      def #{name}
+        @@#{name}[Thread.current.object_id]
+      end
+
+      def #{name}=(val)
+        @@#{name}[Thread.current.object_id] = val
+      end
+    }
+
+    class_eval do
+      include m
+      extend m
+    end
+  end
+end

data/lib/mongo/{util → utils}/server_version.rb

@@ -1,21 +1,19 @@
-# encoding: UTF-8
-
-# --
-# Copyright (C) 2008-2011 10gen Inc.
+# Copyright (C) 2009-2013 MongoDB, 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
+#   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
     include Comparable

data/lib/mongo/{util → utils}/support.rb

@@ -1,50 +1,23 @@
-# encoding: UTF-8
-
-# --
-# Copyright (C) 2008-2011 10gen Inc.
+# Copyright (C) 2009-2013 MongoDB, 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
+#   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
   module Support
+
     include Mongo::Conversions
     extend self
 
-    # Generate an MD5 for authentication.
-    #
-    # @param [String] username
-    # @param [String] password
-    # @param [String] nonce
-    #
-    # @return [String] a key for db authentication.
-    def auth_key(username, password, nonce)
-      Digest::MD5.hexdigest("#{nonce}#{username}#{hash_password(username, password)}")
-    end
-
-    # Return a hashed password for auth.
-    #
-    # @param [String] username
-    # @param [String] plaintext
-    #
-    # @return [String]
-    def hash_password(username, plaintext)
-      Digest::MD5.hexdigest("#{username}:mongo:#{plaintext}")
-    end
-
-
     def validate_db_name(db_name)
       unless [String, Symbol].include?(db_name.class)
         raise TypeError, "db_name must be a string or symbol"
@@ -61,6 +34,7 @@ module Mongo
 
     def format_order_clause(order)
       case order
+        when Hash, BSON::OrderedHash then hash_as_sort_parameters(order)
         when String, Symbol then string_as_sort_parameters(order)
         when Array then array_as_sort_parameters(order)
         else
@@ -69,6 +43,29 @@ module Mongo
       end
     end
 
+    def normalize_seeds(seeds)
+      pairs = Array(seeds)
+      pairs = [ seeds ] if pairs.last.is_a?(Fixnum)
+      pairs = pairs.collect do |hostport|
+        if hostport.is_a?(String)
+          if hostport[0,1] == '['
+            host, port = hostport.split(']:') << MongoClient::DEFAULT_PORT
+            host = host.end_with?(']') ? host[1...-1] : host[1..-1]
+          else
+            host, port = hostport.split(':') << MongoClient::DEFAULT_PORT
+          end
+          [ host, port.to_i ]
+        else
+          hostport
+        end
+      end
+      pairs.length > 1 ? pairs : pairs.first
+    end
+
+    def is_i?(value)
+      return !!(value =~ /^\d+$/)
+    end
+
     # Determine if a database command has succeeded by
     # checking the document response.
     #
@@ -76,7 +73,8 @@ module Mongo
     #
     # @return [Boolean] true if the 'ok' key is either 1 or *true*.
     def ok?(doc)
-      doc['ok'] == 1.0 || doc['ok'] == true
+      ok = doc['ok']
+      ok == 1 || ok == 1.0 || ok == true
     end
   end
 end

data/lib/mongo/utils/thread_local_variable_manager.rb

@@ -0,0 +1,25 @@
+# Copyright (C) 2009-2013 MongoDB, 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/utils.rb

@@ -0,0 +1,19 @@
+# Copyright (C) 2009-2013 MongoDB, 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 'mongo/utils/conversions'
+require 'mongo/utils/core_ext'
+require 'mongo/utils/server_version'
+require 'mongo/utils/support'
+require 'mongo/utils/thread_local_variable_manager'