mongo 0.15.1 → 0.16

data/lib/mongo/connection.rb

@@ -120,6 +120,17 @@ module Mongo
       single_db_command(name, :dropDatabase => 1)
     end
 
+    # Return the build information for the current connection.
+    def server_info
+      db("admin").db_command(:buildinfo => 1)
+    end
+
+    # Returns the build version of the current server, using
+    # a ServerVersion object for comparability.
+    def server_version
+      ServerVersion.new(server_info["version"])
+    end
+
     protected
 
     # Turns an array containing a host name string and a

data/lib/mongo/constants.rb

@@ -0,0 +1,15 @@
+module Mongo
+  module Constants
+    OP_REPLY        = 1   
+    OP_MSG          = 1000 
+    OP_UPDATE       = 2001 
+    OP_INSERT       = 2002
+    OP_QUERY        = 2004
+    OP_GET_MORE     = 2005
+    OP_DELETE       = 2006
+    OP_KILL_CURSORS = 2007
+
+    OP_QUERY_SLAVE_OK          = 4
+    OP_QUERY_NO_CURSOR_TIMEOUT = 16
+  end
+end

data/lib/mongo/cursor.rb

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mongo/message'
 require 'mongo/util/byte_buffer'
 require 'mongo/util/bson'
 
@@ -20,18 +19,35 @@ module Mongo
 
   # A cursor over query results. Returned objects are hashes.
   class Cursor
+    include Mongo::Conversions
 
     include Enumerable
 
     RESPONSE_HEADER_SIZE = 20
 
-    attr_reader :db, :collection, :query
+    attr_reader :collection, :selector, :admin, :fields, 
+      :order, :hint, :snapshot, :timeout,
+      :full_collection_name
 
     # Create a new cursor.
     #
     # Should not be called directly by application developers.
-    def initialize(db, collection, query, admin=false)
-      @db, @collection, @query, @admin = db, collection, query, admin
+    def initialize(collection, options={})
+      @db         = collection.db
+      @collection = collection
+
+      @selector   = convert_selector_for_query(options[:selector])
+      @fields     = convert_fields_for_query(options[:fields])
+      @admin      = options[:admin]    || false
+      @skip       = options[:skip]     || 0
+      @limit      = options[:limit]    || 0
+      @order      = options[:order]
+      @hint       = options[:hint]
+      @snapshot   = options[:snapshot]
+      @timeout    = options[:timeout]  || false
+      @explain    = options[:explain]
+
+      @full_collection_name   = "#{@collection.db.name}.#{@collection.name}"
       @cache = []
       @closed = false
       @query_run = false
@@ -64,9 +80,9 @@ module Mongo
     # not take limit and skip into account. Raises OperationFailure on a
     # database error.
     def count
-      command = OrderedHash["count", @collection.name,
-                            "query", @query.selector,
-                            "fields", @query.fields()]
+      command = OrderedHash["count",  @collection.name,
+                            "query",  @selector,
+                            "fields", @fields]
       response = @db.db_command(command)
       return response['n'].to_i if response['ok'] == 1
       return 0 if response['errmsg'] == "ns missing"
@@ -93,35 +109,39 @@ module Mongo
         order = key_or_list
       end
 
-      @query.order_by = order
+      @order = order
       self
     end
 
     # Limits the number of results to be returned by this cursor.
+    # Returns the current number_to_return if no parameter is given.
     #
     # Raises InvalidOperation if this cursor has already been used.
     #
     # This method overrides any limit specified in the Collection#find method,
     # and only the last limit applied has an effect.
-    def limit(number_to_return)
+    def limit(number_to_return=nil)
+      return @limit unless number_to_return
       check_modifiable
       raise ArgumentError, "limit requires an integer" unless number_to_return.is_a? Integer
 
-      @query.number_to_return = number_to_return
+      @limit = number_to_return
       self
     end
 
     # Skips the first +number_to_skip+ results of this cursor.
-    #
+    # Returns the current number_to_skip if no parameter is given.
+    # 
     # Raises InvalidOperation if this cursor has already been used.
     #
     # This method overrides any skip specified in the Collection#find method,
     # and only the last skip applied has an effect.
-    def skip(number_to_skip)
+    def skip(number_to_skip=nil)
+      return @skip unless number_to_skip
       check_modifiable
       raise ArgumentError, "skip requires an integer" unless number_to_skip.is_a? Integer
 
-      @query.number_to_skip = number_to_skip
+      @skip = number_to_skip
       self
     end
 
@@ -131,7 +151,7 @@ module Mongo
     # Iterating over an entire cursor will close it.
     def each
       num_returned = 0
-      while more? && (@query.number_to_return <= 0 || num_returned < @query.number_to_return)
+      while more? && (@limit <= 0 || num_returned < @limit)
         yield next_object()
         num_returned += 1
       end
@@ -148,7 +168,7 @@ module Mongo
       raise InvalidOperation, "can't call Cursor#to_a on a used cursor" if @query_run
       rows = []
       num_returned = 0
-      while more? && (@query.number_to_return <= 0 || num_returned < @query.number_to_return)
+      while more? && (@limit <= 0 || num_returned < @limit)
         rows << next_object()
         num_returned += 1
       end
@@ -157,39 +177,96 @@ module Mongo
 
     # Returns an explain plan record for this cursor.
     def explain
-      limit = @query.number_to_return
-      @query.explain = true
-      @query.number_to_return = -limit.abs
-
-      c = Cursor.new(@db, @collection, @query)
+      c = Cursor.new(@collection, query_options_hash.merge(:limit => -@limit.abs, :explain => true))
       explanation = c.next_object
       c.close
 
-      @query.explain = false
-      @query.number_to_return = limit
       explanation
     end
 
     # Close the cursor.
     #
-    # Note: if a cursor is read until exhausted (read until OP_QUERY or
-    # OP_GETMORE returns zero for the cursor id), there is no need to
+    # Note: if a cursor is read until exhausted (read until Mongo::Constants::OP_QUERY or
+    # Mongo::Constants::OP_GETMORE returns zero for the cursor id), there is no need to
     # close it by calling this method.
     #
     # Collection#find takes an optional block argument which can be used to
     # ensure that your cursors get closed. See the documentation for
     # Collection#find for details.
     def close
-      @db.send_to_db(KillCursorsMessage.new(@cursor_id)) if @cursor_id
+      if @cursor_id
+        message = ByteBuffer.new
+        message.put_int(0)
+        message.put_int(1)
+        message.put_long(@cursor_id)
+        @db.send_message_with_operation(Mongo::Constants::OP_KILL_CURSORS, message)
+      end
       @cursor_id = 0
-      @closed = true
+      @closed    = true
     end
 
     # Returns true if this cursor is closed, false otherwise.
     def closed?; @closed; end
 
+    # Returns an integer indicating which query options have been selected.
+    # See http://www.mongodb.org/display/DOCS/Mongo+Wire+Protocol#MongoWireProtocol-Mongo::Constants::OPQUERY
+    def query_opts
+      timeout  = @timeout ? 0 : Mongo::Constants::OP_QUERY_NO_CURSOR_TIMEOUT
+      slave_ok = @db.slave_ok? ? Mongo::Constants::OP_QUERY_SLAVE_OK : 0 
+      slave_ok + timeout
+    end
+
+    # Returns the query options set on this Cursor.
+    def query_options_hash
+      { :selector => @selector,
+        :fields   => @fields,   
+        :admin    => @admin,   
+        :skip     => @skip_num, 
+        :limit    => @limit_num, 
+        :order    => @order,   
+        :hint     => @hint,   
+        :snapshot => @snapshot, 
+        :timeout  => @timeout }
+    end
+
     private
 
+    # Converts the +:fields+ parameter from a single field name or an array
+    # of fields names to a hash, with the field names for keys and '1' for each
+    # value.
+    def convert_fields_for_query(fields)
+      case fields
+        when String, Symbol
+          {fields => 1}
+        when Array
+          return nil if fields.length.zero?
+          returning({}) do |hash|
+            fields.each { |field| hash[field] = 1 }
+          end
+      end
+    end
+
+    # Set query selector hash. If the selector is a Code or String object, 
+    # the selector will be used in a $where clause.
+    # See http://www.mongodb.org/display/DOCS/Server-side+Code+Execution
+    def convert_selector_for_query(selector)
+       case selector
+         when Hash
+          selector
+         when nil
+           {}
+         when String
+          {"$where" => Code.new(selector)}
+         when Code
+          {"$where" => selector}
+      end
+    end
+
+    # Returns true if the query contains order, explain, hint, or snapshot.
+    def query_contains_special_fields?
+      @order || @explain || @hint || @snapshot
+    end
+
     def read_all
       read_message_header
       read_response_header
@@ -203,7 +280,16 @@ module Mongo
     end
 
     def read_message_header
-      MessageHeader.new.read_header(@db)
+      message = ByteBuffer.new
+      message.put_array(@db.receive_full(16).unpack("C*"))
+      unless message.size == 16 #HEADER_SIZE
+        raise "Short read for DB response header: expected #{16} bytes, saw #{message.size}" 
+      end
+      message.rewind
+      size = message.get_int
+      request_id = message.get_int
+      response_to = message.get_int
+      op = message.get_int
     end
 
     def read_response_header
@@ -220,9 +306,6 @@ module Mongo
       else
         @n_received = @n_remaining
       end
-      if @query.number_to_return > 0 and @n_received >= @query.number_to_return
-        close()
-      end
     end
 
     def num_remaining
@@ -231,7 +314,7 @@ module Mongo
     end
 
     # Internal method, not for general use. Return +true+ if there are
-    # more records to retrieve. We do not check @query.number_to_return;
+    # more records to retrieve. This methods does not check @limit;
     # #each is responsible for doing that.
     def more?
       num_remaining > 0
@@ -246,13 +329,25 @@ module Mongo
     end
 
     def refill_via_get_more
-      if send_query_if_needed or @cursor_id == 0
-        return
-      end
+      return if send_query_if_needed || @cursor_id.zero?
       @db._synchronize {
-        @db.send_to_db(GetMoreMessage.new(@admin ? 'admin' : @db.name, @collection.name, @cursor_id))
+        message = ByteBuffer.new
+        # Reserved.
+        message.put_int(0)
+
+        # DB name.
+        db_name = @admin ? 'admin' : @db.name
+        BSON.serialize_cstr(message, "#{db_name}.#{@collection.name}")
+
+        # Number of results to return; db decides for now.
+        message.put_int(0)
+        
+        # Cursor id.
+        message.put_long(@cursor_id)
+        @db.send_message_with_operation_without_synchronize(Mongo::Constants::OP_GET_MORE, message)
         read_all
       }
+      close_cursor_if_query_complete
     end
 
     def object_from_stream
@@ -271,19 +366,64 @@ module Mongo
       if @query_run
         false
       else
+        message = construct_query_message(@query)
         @db._synchronize {
-          @db.send_query_message(QueryMessage.new(@admin ? 'admin' : @db.name, @collection.name, @query))
+          @db.send_message_with_operation_without_synchronize(Mongo::Constants::OP_QUERY, message)
           @query_run = true
           read_all
         }
+        close_cursor_if_query_complete
         true
       end
     end
 
+    def construct_query_message(query)
+      message = ByteBuffer.new
+      message.put_int(query_opts)
+      db_name = @admin ? 'admin' : @db.name
+      BSON.serialize_cstr(message, "#{db_name}.#{@collection.name}")
+      message.put_int(@skip)
+      message.put_int(@limit)
+      selector = @selector
+      if query_contains_special_fields?
+        selector = selector_with_special_query_fields
+      end
+      message.put_array(BSON.new.serialize(selector).to_a)
+      message.put_array(BSON.new.serialize(@fields).to_a) if @fields
+      message
+    end
+
+    def selector_with_special_query_fields
+      sel = OrderedHash.new
+      sel['query']     = @selector
+      sel['orderby']   = formatted_order_clause if @order
+      sel['$hint']     = @hint if @hint && @hint.length > 0
+      sel['$explain']  = true if @explain
+      sel['$snapshot'] = true if @snapshot
+      sel
+    end
+
+    def formatted_order_clause
+      case @order
+        when String then string_as_sort_parameters(@order)
+        when Symbol then symbol_as_sort_parameters(@order)
+        when Array  then array_as_sort_parameters(@order)
+        when Hash # Should be an ordered hash, but this message doesn't care
+          warn_if_deprecated(@order)
+          @order 
+        else
+          raise InvalidSortValueError, "Illegal order_by, '#{@order.class.name}'; must be String, Array, Hash, or OrderedHash"
+      end
+    end
+
     def to_s
       "DBResponse(flags=#@result_flags, cursor_id=#@cursor_id, start=#@starting_from)"
     end
 
+    def close_cursor_if_query_complete
+      close if @limit > 0 && @n_received >= @limit
+    end
+
     def check_modifiable
       if @query_run || @closed
         raise InvalidOperation, "Cannot modify the query once it has been run or closed."

data/lib/mongo/db.rb

@@ -16,10 +16,8 @@
 
 require 'socket'
 require 'digest/md5'
-require 'mutex_m'
+require 'thread'
 require 'mongo/collection'
-require 'mongo/message'
-require 'mongo/query'
 require 'mongo/util/ordered_hash.rb'
 require 'mongo/admin'
 
@@ -34,6 +32,9 @@ module Mongo
     SYSTEM_USER_COLLECTION = "system.users"
     SYSTEM_COMMAND_COLLECTION = "$cmd"
 
+    # Counter for generating unique request ids.
+    @@current_request_id = 0
+
     # Strict mode enforces collection existence checks. When +true+,
     # asking for a collection that does not exist or trying to create a
     # collection that already exists raises an error.
@@ -137,8 +138,7 @@ module Mongo
       @pk_factory = options[:pk]
       @slave_ok = options[:slave_ok] && @nodes.length == 1 # only OK if one node
       @auto_reconnect = options[:auto_reconnect]
-      @semaphore = Object.new
-      @semaphore.extend Mutex_m
+      @semaphore = Mutex.new
       @socket = nil
       @logger = options[:logger]
       connect_to_master
@@ -160,6 +160,9 @@ module Mongo
           is_master = master?
           @semaphore.lock if semaphore_is_locked
 
+          if !@slave_ok && !is_master
+            raise ConfigurationError, "Trying to connect directly to slave; if this is what you want, specify :slave_ok => true."
+          end
           @slave_ok || is_master
         rescue SocketError, SystemCallError, IOError => ex
           close if @socket
@@ -211,8 +214,8 @@ module Mongo
     # specified, an array of length 1 is returned.
     def collections_info(coll_name=nil)
       selector = {}
-      selector[:name] = full_coll_name(coll_name) if coll_name
-      query(Collection.new(self, SYSTEM_NAMESPACE_COLLECTION), Query.new(selector))
+      selector[:name] = full_collection_name(coll_name) if coll_name
+      Cursor.new(Collection.new(self, SYSTEM_NAMESPACE_COLLECTION), :selector => selector)
     end
 
     # Create a collection. If +strict+ is false, will return existing or
@@ -243,7 +246,7 @@ module Mongo
       oh[:create] = name
       doc = db_command(oh.merge(options || {}))
       ok = doc['ok']
-      return Collection.new(self, name) if ok.kind_of?(Numeric) && (ok.to_i == 1 || ok.to_i == 0)
+      return Collection.new(self, name, @pk_factory) if ok.kind_of?(Numeric) && (ok.to_i == 1 || ok.to_i == 0)
       raise "Error creating collection: #{doc.inspect}"
     end
 
@@ -255,7 +258,7 @@ module Mongo
     # new collection. If +strict+ is true, will raise an error if
     # collection +name+ does not already exists.
     def collection(name)
-      return Collection.new(self, name) if !strict? || collection_names.include?(name)
+      return Collection.new(self, name, @pk_factory) if !strict? || collection_names.include?(name)
       raise "Collection #{name} doesn't exist. Currently in strict mode."
     end
     alias_method :[], :collection
@@ -353,11 +356,6 @@ module Mongo
       message
     end
 
-    # Send a MsgMessage to the database.
-    def send_message(msg)
-      send_to_db(MsgMessage.new(msg))
-    end
-
     # Returns a Cursor over the query results.
     #
     # Note that the query gets sent lazily; the cursor calls
@@ -367,38 +365,6 @@ module Mongo
       Cursor.new(self, collection, query, admin)
     end
 
-    # Used by a Cursor to lazily send the query to the database.
-    def send_query_message(query_message)
-      send_to_db(query_message)
-    end
-
-    # Remove the records that match +selector+ from +collection_name+.
-    # Normally called by Collection#remove or Collection#clear.
-    def remove_from_db(collection_name, selector)
-      _synchronize {
-        send_to_db(RemoveMessage.new(@name, collection_name, selector))
-      }
-    end
-
-    # Update records in +collection_name+ that match +selector+ by
-    # applying +obj+ as an update. Normally called by Collection#replace.
-    def replace_in_db(collection_name, selector, obj)
-      _synchronize {
-        send_to_db(UpdateMessage.new(@name, collection_name, selector, obj, false))
-      }
-    end
-
-    # Update records in +collection_name+ that match +selector+ by
-    # applying +obj+ as an update. If no match, inserts (???). Normally
-    # called by Collection#repsert.
-    def repsert_in_db(collection_name, selector, obj)
-      _synchronize {
-        obj = @pk_factory.create_pk(obj) if @pk_factory
-        send_to_db(UpdateMessage.new(@name, collection_name, selector, obj, true))
-        obj
-      }
-    end
-
     # Dereference a DBRef, getting the document it points to.
     def dereference(dbref)
       collection(dbref.namespace).find_one("_id" => dbref.object_id)
@@ -447,9 +413,9 @@ module Mongo
     # the values are lists of [key, direction] pairs specifying the index
     # (as passed to Collection#create_index).
     def index_information(collection_name)
-      sel = {:ns => full_coll_name(collection_name)}
+      sel = {:ns => full_collection_name(collection_name)}
       info = {}
-      query(Collection.new(self, SYSTEM_INDEX_COLLECTION), Query.new(sel)).each { |index|
+      Cursor.new(Collection.new(self, SYSTEM_INDEX_COLLECTION), :selector => sel).each { |index|
         info[index['name']] = index['key'].to_a
       }
       info
@@ -462,42 +428,7 @@ module Mongo
     # by Collection#create_index. If +unique+ is true the index will
     # enforce a uniqueness constraint.
     def create_index(collection_name, field_or_spec, unique=false)
-      field_h = OrderedHash.new
-      if field_or_spec.is_a?(String) || field_or_spec.is_a?(Symbol)
-        field_h[field_or_spec.to_s] = 1
-      else
-        field_or_spec.each { |f| field_h[f[0].to_s] = f[1] }
-      end
-      name = gen_index_name(field_h)
-      sel = {
-        :name => name,
-        :ns => full_coll_name(collection_name),
-        :key => field_h,
-        :unique => unique
-      }
-      _synchronize {
-        send_to_db(InsertMessage.new(@name, SYSTEM_INDEX_COLLECTION, false, sel))
-      }
-      name
-    end
-
-    # Insert +objects+ into +collection_name+. Normally called by
-    # Collection#insert. Returns a new array containing the _ids
-    # of the inserted documents.
-    def insert_into_db(collection_name, objects)
-      _synchronize {
-        if @pk_factory
-          objects.collect! { |o|
-            @pk_factory.create_pk(o)
-          }
-        else
-          objects = objects.collect do |o|
-            o[:_id] || o['_id'] ? o : o.merge!(:_id => ObjectID.new)
-          end
-        end
-        send_to_db(InsertMessage.new(@name, collection_name, true, *objects))
-        objects.collect { |o| o[:_id] || o['_id'] }
-      }
+      self.collection(collection_name).create_index(field_or_spec, unique)
     end
 
     def send_to_db(message)
@@ -512,8 +443,43 @@ module Mongo
       end
     end
 
-    def full_coll_name(collection_name)
-      "#{@name}.#{collection_name}"
+    # Sends a message to MongoDB.
+    #
+    # Takes a MongoDB opcode, +operation+, and a message of class ByteBuffer,
+    # +message+, and sends the message to the databse, adding the necessary headers.
+    def send_message_with_operation(operation, message)
+      @semaphore.synchronize do
+        connect_to_master if !connected? && @auto_reconnect
+        begin
+          message_with_headers = add_message_headers(operation, message)
+          @logger.debug("  MONGODB #{message}") if @logger
+          @socket.print(message_with_headers.to_s)
+          @socket.flush
+        rescue => ex
+          close
+          raise ex
+        end
+      end
+    end
+
+    def send_message_with_operation_without_synchronize(operation, message)
+      connect_to_master if !connected? && @auto_reconnect
+      begin
+        message_with_headers = add_message_headers(operation, message)
+        @logger.debug("  MONGODB #{operation} #{message}") if @logger
+        @socket.print(message_with_headers.to_s)
+        @socket.flush
+      rescue => ex
+        close
+        raise ex
+      end
+    end
+
+    def receive_message_with_operation(operation, message)
+      @semaphore.synchronize do 
+
+
+      end
     end
 
     # Return +true+ if +doc+ contains an 'ok' field with the value 1.
@@ -532,27 +498,48 @@ module Mongo
         end
       end
 
-      q = Query.new(selector)
-      q.number_to_return = -1
-      query(Collection.new(self, SYSTEM_COMMAND_COLLECTION), q, use_admin_db).next_object
+      cursor = Cursor.new(Collection.new(self, SYSTEM_COMMAND_COLLECTION), :admin => use_admin_db, :limit => -1, :selector => selector)
+      cursor.next_object
     end
 
     def _synchronize &block
       @semaphore.synchronize &block
     end
 
+    def full_collection_name(collection_name)
+      "#{@name}.#{collection_name}"
+    end
+
     private
 
-    def hash_password(username, plaintext)
-      Digest::MD5.hexdigest("#{username}:mongo:#{plaintext}")
+    # Prepares a message for transmission to MongoDB by
+    # constructing a valid message header.
+    def add_message_headers(operation, message)
+      headers = ByteBuffer.new
+
+      # Message size.
+      headers.put_int(16 + message.size)
+
+      # Unique request id.
+      headers.put_int(get_request_id)
+
+      # Response id.
+      headers.put_int(0)
+
+      # Opcode.
+      headers.put_int(operation)
+      message.prepend!(headers)
     end
 
-    def gen_index_name(spec)
-      temp = []
-      spec.each_pair { |field, direction|
-        temp = temp.push("#{field}_#{direction}")
-      }
-      return temp.join("_")
+    # Increments and then returns the next available request id.
+    # Note: this method should be called from within a lock.
+    def get_request_id
+      @@current_request_id += 1
+      @@current_request_id
+    end
+
+    def hash_password(username, plaintext)
+      Digest::MD5.hexdigest("#{username}:mongo:#{plaintext}")
     end
   end
 end