mongo 1.7.1 → 1.8.0

data/examples/strict.rb

@@ -0,0 +1,35 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'mongo'
+
+include Mongo
+
+host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
+port = ENV['MONGO_RUBY_DRIVER_PORT'] || MongoClient::DEFAULT_PORT
+
+puts "Connecting to #{host}:#{port}"
+db = MongoClient.new(host, port).db('ruby-mongo-examples')
+
+db.drop_collection('does-not-exist')
+db.create_collection('test')
+
+db.strict = true
+
+begin
+  # Can't reference collection that does not exist
+  db.collection('does-not-exist')
+  puts "error: expected exception"
+rescue => ex
+  puts "expected exception: #{ex}"
+end
+
+begin
+  # Can't create collection that already exists
+  db.create_collection('test')
+  puts "error: expected exception"
+rescue => ex
+  puts "expected exception: #{ex}"
+end
+
+db.strict = false
+db.drop_collection('test')

data/examples/types.rb

@@ -0,0 +1,36 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'mongo'
+require 'pp'
+
+include Mongo
+
+host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
+port = ENV['MONGO_RUBY_DRIVER_PORT'] || MongoClient::DEFAULT_PORT
+
+puts "Connecting to #{host}:#{port}"
+db = MongoClient.new(host, port).db('ruby-mongo-examples')
+coll = db.collection('test')
+
+# Remove all records, if any
+coll.remove
+
+# Insert record with all sorts of values
+coll.insert('array' => [1, 2, 3],
+            'string' => 'hello',
+            'hash' => {'a' => 1, 'b' => 2},
+            'date' => Time.now, # milliseconds only; microseconds are not stored
+            'oid' => ObjectID.new,
+            'binary' => Binary.new([1, 2, 3]),
+            'int' => 42,
+            'float' => 33.33333,
+            'regex' => /foobar/i,
+            'boolean' => true,
+            'where' => Code.new('this.x == 3'),
+            'dbref' => DBRef.new(coll.name, ObjectID.new),
+            'null' => nil,
+            'symbol' => :zildjian)
+
+pp coll.find().next_document
+
+coll.remove

data/{test/load → examples/web}/thin/load.rb

@@ -1,7 +1,9 @@
 require File.join(File.dirname(__FILE__), '..', '..', '..', 'lib', 'mongo')
 require 'logger'
 
-$con = Mongo::ReplSetConnection.new(['localhost:30000', 'localhost:30001'], :read => :secondary, :refresh_mode => :sync, :refresh_interval => 30)
+include Mongo
+
+$con = MongoReplicaSetClient.new(['localhost:30000', 'localhost:30001'], :read => :secondary, :refresh_mode => :sync, :refresh_interval => 30)
 $db = $con['foo']
 
 class Load < Sinatra::Base

data/{test/load → examples/web}/unicorn/load.rb

@@ -1,7 +1,9 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'mongo')
+require File.join(File.dirname(__FILE__), '..', '..', 'lib', 'mongo') 
 
-$con = Mongo::Connection.new
-$db = $con['foo']
+include Mongo
+
+$client = MongoClient.new('localhost', 27017)
+$db = $client['foo']
 
 class Load < Sinatra::Base
 

data/lib/mongo.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 #
 # --
-# Copyright (C) 2008-2011 10gen Inc.
+# 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.
@@ -16,8 +16,6 @@
 # limitations under the License.
 # ++
 
-require 'mongo/version'
-
 module Mongo
   ASCENDING   =  1
   DESCENDING  = -1
@@ -54,6 +52,7 @@ require 'bson'
 
 require 'mongo/util/conversions'
 require 'mongo/util/support'
+require 'mongo/util/write_concern'
 require 'mongo/util/core_ext'
 require 'mongo/util/logging'
 require 'mongo/util/node'
@@ -65,18 +64,17 @@ require 'mongo/util/ssl_socket'
 require 'mongo/util/tcp_socket'
 require 'mongo/util/uri_parser'
 
-require 'mongo/collection'
+
 require 'mongo/networking'
-require 'mongo/connection'
-require 'mongo/repl_set_connection'
-require 'mongo/sharded_connection'
+require 'mongo/mongo_client'
+require 'mongo/mongo_replica_set_client'
+require 'mongo/mongo_sharded_client'
+require 'mongo/legacy'
+require 'mongo/collection'
 require 'mongo/cursor'
 require 'mongo/db'
 require 'mongo/exceptions'
 require 'mongo/gridfs/grid_ext'
 require 'mongo/gridfs/grid'
 require 'mongo/gridfs/grid_io'
-if RUBY_PLATFORM =~ /java/
-  require 'mongo/gridfs/grid_io_fix'
-end
 require 'mongo/gridfs/grid_file_system'

data/lib/mongo/collection.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 
 # --
-# Copyright (C) 2008-2011 10gen Inc.
+# 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.
@@ -20,11 +20,18 @@ module Mongo
   # A named collection of documents in a database.
   class Collection
     include Mongo::Logging
+    include Mongo::WriteConcern
 
-    attr_reader :db, :name, :pk_factory, :hint, :safe
+    attr_reader :db,
+                :name,
+                :pk_factory,
+                :hint,
+                :write_concern
 
     # Read Preference
-    attr_accessor :read_preference, :tag_sets, :acceptable_latency
+    attr_accessor :read_preference,
+                  :tag_sets,
+                  :acceptable_latency
 
     # Initialize a collection object.
     #
@@ -34,10 +41,10 @@ module Mongo
     # @option opts [:create_pk] :pk (BSON::ObjectId) A primary key factory to use
     #   other than the default BSON::ObjectId.
     #
-    # @option opts [Boolean, Hash] :safe (false) Set the default safe-mode options
-    #   for insert, update, and remove method called on this Collection instance. If no
-    #   value is provided, the default value set on this instance's DB will be used. This
-    #   default can be overridden for any invocation of insert, update, or remove.
+    # @option opts [Hash] :w, :j, :wtimeout, :fsync Set the default write concern
+    #   for +insert+, +update+, and +remove+ method called on this Collection instance. If no
+    #   value is provided, the default values set on this instance's DB will be used. These option 
+    #   values can be overridden for any invocation of +insert+, +update+, or +remove+.
     # @option options [:primary, :secondary] :read The default read preference for queries
     #   initiates from this connection object. If +:secondary+ is chosen, reads will be sent
     #   to one of the closest available secondary nodes. If a secondary node cannot be located, the
@@ -91,16 +98,16 @@ module Mongo
       @connection = @db.connection
       @logger     = @connection.logger
       @cache_time = @db.cache_time
-      @cache = Hash.new(0)
+      @cache      = Hash.new(0)
       unless pk_factory
-        @safe = opts.fetch(:safe, @db.safe)
+        @write_concern = get_write_concern(opts, db)
         if value = opts[:read]
           Mongo::Support.validate_read_preference(value)
         else
           value = @db.read_preference
         end
-        @read_preference = value.is_a?(Hash) ? value.dup : value
-        @tag_sets = opts.fetch(:tag_sets, @db.tag_sets)
+        @read_preference    = value.is_a?(Hash) ? value.dup : value
+        @tag_sets           = opts.fetch(:tag_sets, @db.tag_sets)
         @acceptable_latency = opts.fetch(:acceptable_latency, @db.acceptable_latency)
       end
       @pk_factory = pk_factory || opts[:pk] || BSON::ObjectId
@@ -169,7 +176,7 @@ module Mongo
     #   to Ruby 1.8).
     #
     # @option opts [Array, Hash] :fields field names that should be returned in the result
-    #   set ("_id" will be included unless explicity excluded). By limiting results to a certain subset of fields,
+    #   set ("_id" will be included unless explicitly excluded). By limiting results to a certain subset of fields,
     #   you can cut down on network traffic and decoding time. If using a Hash, keys should be field
     #   names and values should be either 1 or 0, depending on whether you want to include or exclude
     #   the given field.
@@ -194,13 +201,14 @@ module Mongo
     # @option opts [Boolean] :timeout (true) when +true+, the returned cursor will be subject to
     #   the normal cursor timeout behavior of the mongod process. When +false+, the returned cursor will
     #   never timeout. Note that disabling timeout will only work when #find is invoked with a block.
-    #   This is to prevent any inadvertant failure to close the cursor, as the cursor is explicitly
+    #   This is to prevent any inadvertent failure to close the cursor, as the cursor is explicitly
     #   closed when block code finishes.
     # @option opts [Integer] :max_scan (nil) Limit the number of items to scan on both collection scans and indexed queries..
     # @option opts [Boolean] :show_disk_loc (false) Return the disk location of each query result (for debugging).
     # @option opts [Boolean] :return_key (false) Return the index key used to obtain the result (for debugging).
-    # @option opts [Block] :transformer (nil) a block for tranforming returned documents.
+    # @option opts [Block] :transformer (nil) a block for transforming returned documents.
     #   This is normally used by object mappers to convert each returned document to an instance of a class.
+    # @option opts [String] :comment (nil) a comment to include in profiling logs
     #
     # @raise [ArgumentError]
     #   if timeout is set to false and find is not invoked in a block
@@ -210,22 +218,23 @@ module Mongo
     #
     # @core find find-instance_method
     def find(selector={}, opts={})
-      opts   = opts.dup
-      fields = opts.delete(:fields)
-      fields = ["_id"] if fields && fields.empty?
-      skip   = opts.delete(:skip) || skip || 0
-      limit  = opts.delete(:limit) || 0
-      sort   = opts.delete(:sort)
-      hint   = opts.delete(:hint)
-      snapshot   = opts.delete(:snapshot)
-      batch_size = opts.delete(:batch_size)
-      timeout    = (opts.delete(:timeout) == false) ? false : true
-      max_scan   = opts.delete(:max_scan)
-      return_key = opts.delete(:return_key)
-      transformer = opts.delete(:transformer)
-      show_disk_loc = opts.delete(:show_disk_loc)
-      read          = opts.delete(:read) || @read_preference
-      tag_sets      = opts.delete(:tag_sets) || @tag_sets
+      opts               = opts.dup
+      fields             = opts.delete(:fields)
+      fields             = ["_id"] if fields && fields.empty?
+      skip               = opts.delete(:skip) || skip || 0
+      limit              = opts.delete(:limit) || 0
+      sort               = opts.delete(:sort)
+      hint               = opts.delete(:hint)
+      snapshot           = opts.delete(:snapshot)
+      batch_size         = opts.delete(:batch_size)
+      timeout            = (opts.delete(:timeout) == false) ? false : true
+      max_scan           = opts.delete(:max_scan)
+      return_key         = opts.delete(:return_key)
+      transformer        = opts.delete(:transformer)
+      show_disk_loc      = opts.delete(:show_disk_loc)
+      comment            = opts.delete(:comment)
+      read               = opts.delete(:read) || @read_preference
+      tag_sets           = opts.delete(:tag_sets) || @tag_sets
       acceptable_latency = opts.delete(:acceptable_latency) || @acceptable_latency
 
       if timeout == false && !block_given?
@@ -241,27 +250,31 @@ module Mongo
       raise RuntimeError, "Unknown options [#{opts.inspect}]" unless opts.empty?
 
       cursor = Cursor.new(self, {
-        :selector    => selector,
-        :fields      => fields,
-        :skip        => skip,
-        :limit       => limit,
-        :order       => sort,
-        :hint        => hint,
-        :snapshot    => snapshot,
-        :timeout     => timeout,
-        :batch_size  => batch_size,
-        :transformer => transformer,
-        :max_scan    => max_scan,
-        :show_disk_loc => show_disk_loc,
-        :return_key    => return_key,
-        :read          => read,
-        :tag_sets      => tag_sets,
+        :selector           => selector,
+        :fields             => fields,
+        :skip               => skip,
+        :limit              => limit,
+        :order              => sort,
+        :hint               => hint,
+        :snapshot           => snapshot,
+        :timeout            => timeout,
+        :batch_size         => batch_size,
+        :transformer        => transformer,
+        :max_scan           => max_scan,
+        :show_disk_loc      => show_disk_loc,
+        :return_key         => return_key,
+        :read               => read,
+        :tag_sets           => tag_sets,
+        :comment            => comment,
         :acceptable_latency => acceptable_latency
       })
 
       if block_given?
-        yield cursor
-        cursor.close
+        begin
+          yield cursor
+        ensure
+          cursor.close
+        end
         nil
       else
         cursor
@@ -306,20 +319,23 @@ module Mongo
     #
     # @return [ObjectId] the _id of the saved document.
     #
-    # @option opts [Boolean, Hash] :safe (+false+)
-    #   run the operation in safe mode, which run a getlasterror command on the
-    #   database to report any assertion. In addition, a hash can be provided to
-    #   run an fsync and/or wait for replication of the save (>= 1.5.1). See the options
-    #   for DB#error.
+    # @option opts [Hash] :w, :j, :wtimeout, :fsync Set the write concern for this operation.
+    #   :w > 0 will run a +getlasterror+ command on the database to report any assertion. 
+    #   :j will confirm a write has been committed to the journal,
+    #   :wtimeout specifies how long to wait for write confirmation,
+    #   :fsync will confirm that a write has been fsynced. 
+    #   Options provided here will override any write concern options set on this collection,
+    #   its database object, or the current connection. See the options
+    #   for +DB#get_last_error+.
     #
-    # @raise [OperationFailure] when :safe mode fails.
+    # @raise [Mongo::OperationFailure] will be raised iff :w > 0 and the operation fails.
     def save(doc, opts={})
       if doc.has_key?(:_id) || doc.has_key?('_id')
         id = doc[:_id] || doc['_id']
-        update({:_id => id}, doc, :upsert => true, :safe => opts.fetch(:safe, @safe))
+        update({:_id => id}, doc, opts.merge!({:upsert => true}))
         id
       else
-        insert(doc, :safe => opts.fetch(:safe, @safe))
+        insert(doc, opts)
       end
     end
 
@@ -335,31 +351,34 @@ module Mongo
     #   2nd, a list of invalid documents.
     #   Return this result format only when :collect_on_error is true.
     #
-    # @option opts [Boolean, Hash] :safe (+false+)
-    #   run the operation in safe mode, which run a getlasterror command on the
-    #   database to report any assertion. In addition, a hash can be provided to
-    #   run an fsync and/or wait for replication of the insert (>= 1.5.1). Safe
-    #   options provided here will override any safe options set on this collection,
-    #   its database object, or the current connection. See the options on
-    #   for DB#get_last_error.
+    # @option opts [Hash] :w, :j, :wtimeout, :fsync Set the write concern for this operation.
+    #   :w > 0 will run a +getlasterror+ command on the database to report any assertion. 
+    #   :j will confirm a write has been committed to the journal,
+    #   :wtimeout specifies how long to wait for write confirmation,
+    #   :fsync will confirm that a write has been fsynced. 
+    #   Options provided here will override any write concern options set on this collection,
+    #   its database object, or the current connection. See the options
+    #   for +DB#get_last_error+.
     #
     # @option opts [Boolean] :continue_on_error (+false+) If true, then
     #   continue a bulk insert even if one of the documents inserted
     #   triggers a database assertion (as in a duplicate insert, for instance).
-    #   If not using safe mode, the list of ids returned will
+    #   If not acknowledging writes, the list of ids returned will
     #   include the object ids of all documents attempted on insert, even
-    #   if some are rejected on error. When safe mode is
-    #   enabled, any error will raise an OperationFailure exception.
+    #   if some are rejected on error. When acknowledging writes, any error will raise an 
+    #   OperationFailure exception.
     #   MongoDB v2.0+.
     # @option opts [Boolean] :collect_on_error (+false+) if true, then
     #   collects invalid documents as an array. Note that this option changes the result format.
     #
+    # @raise [Mongo::OperationFailure] will be raised iff :w > 0 and the operation fails. 
+    #
     # @core insert insert-instance_method
     def insert(doc_or_docs, opts={})
       doc_or_docs = [doc_or_docs] unless doc_or_docs.is_a?(Array)
       doc_or_docs.collect! { |doc| @pk_factory.create_pk(doc) }
-      safe = opts.fetch(:safe, @safe)
-      result = insert_documents(doc_or_docs, @name, true, safe, opts)
+      write_concern = get_write_concern(opts, self)
+      result = insert_documents(doc_or_docs, @name, true, write_concern, opts)
       result.size > 1 ? result : result.first
     end
     alias_method :<<, :insert
@@ -369,12 +388,14 @@ module Mongo
     # @param [Hash] selector
     #   If specified, only matching documents will be removed.
     #
-    # @option opts [Boolean, Hash] :safe (+false+)
-    #   run the operation in safe mode, which will run a getlasterror command on the
-    #   database to report any assertion. In addition, a hash can be provided to
-    #   run an fsync and/or wait for replication of the remove (>= 1.5.1). Safe
-    #   options provided here will override any safe options set on this collection,
-    #   its database, or the current connection. See the options for DB#get_last_error for more details.
+    # @option opts [Hash] :w, :j, :wtimeout, :fsync Set the write concern for this operation.
+    #   :w > 0 will run a +getlasterror+ command on the database to report any assertion. 
+    #   :j will confirm a write has been committed to the journal,
+    #   :wtimeout specifies how long to wait for write confirmation,
+    #   :fsync will confirm that a write has been fsynced. 
+    #   Options provided here will override any write concern options set on this collection,
+    #   its database object, or the current connection. See the options
+    #   for +DB#get_last_error+. 
     #
     # @example remove all documents from the 'users' collection:
     #   users.remove
@@ -383,24 +404,22 @@ module Mongo
     # @example remove only documents that have expired:
     #   users.remove({:expire => {"$lte" => Time.now}})
     #
-    # @return [Hash, true] Returns a Hash containing the last error object if running in safe mode.
+    # @return [Hash, true] Returns a Hash containing the last error object if acknowledging writes
     #   Otherwise, returns true.
     #
-    # @raise [Mongo::OperationFailure] an exception will be raised iff safe mode is enabled
-    #   and the operation fails.
+    # @raise [Mongo::OperationFailure] will be raised iff :w > 0 and the operation fails.
     #
     # @core remove remove-instance_method
     def remove(selector={}, opts={})
-      # Initial byte is 0.
-      safe = opts.fetch(:safe, @safe)
+      write_concern = get_write_concern(opts, self)
       message = BSON::ByteBuffer.new("\0\0\0\0")
       BSON::BSON_RUBY.serialize_cstr(message, "#{@db.name}.#{@name}")
       message.put_int(0)
       message.put_binary(BSON::BSON_CODER.serialize(selector, false, true, @connection.max_bson_size).to_s)
 
       instrument(:remove, :database => @db.name, :collection => @name, :selector => selector) do
-        if safe
-          @connection.send_message_with_safe_check(Mongo::Constants::OP_DELETE, message, @db.name, nil, safe)
+        if Mongo::WriteConcern.gle?(write_concern)
+          @connection.send_message_with_gle(Mongo::Constants::OP_DELETE, message, @db.name, nil, write_concern)
         else
           @connection.send_message(Mongo::Constants::OP_DELETE, message)
           true
@@ -422,20 +441,24 @@ module Mongo
     # @option opts [Boolean] :upsert (+false+) if true, performs an upsert (update or insert)
     # @option opts [Boolean] :multi (+false+) update all documents matching the selector, as opposed to
     #   just the first matching document. Note: only works in MongoDB 1.1.3 or later.
-    # @option opts [Boolean] :safe (+false+)
-    #   If true, check that the save succeeded. OperationFailure
-    #   will be raised on an error. Note that a safe check requires an extra
-    #   round-trip to the database. Safe options provided here will override any safe
-    #   options set on this collection, its database object, or the current collection.
-    #   See the options for DB#get_last_error for details.
-    #
-    # @return [Hash, true] Returns a Hash containing the last error object if running in safe mode.
+    # @option opts [Hash] :w, :j, :wtimeout, :fsync Set the write concern for this operation.
+    #   :w > 0 will run a +getlasterror+ command on the database to report any assertion. 
+    #   :j will confirm a write has been committed to the journal,
+    #   :wtimeout specifies how long to wait for write confirmation,
+    #   :fsync will confirm that a write has been fsynced. 
+    #   Options provided here will override any write concern options set on this collection,
+    #   its database object, or the current connection. See the options
+    #   for +DB#get_last_error+. 
+    #
+    # @return [Hash, true] Returns a Hash containing the last error object if acknowledging writes.
     #   Otherwise, returns true.
     #
+    # @raise [Mongo::OperationFailure] will be raised iff :w > 0 and the operation fails.
+    #
     # @core update update-instance_method
     def update(selector, document, opts={})
       # Initial byte is 0.
-      safe = opts.fetch(:safe, @safe)
+      write_concern = get_write_concern(opts, self)
       message = BSON::ByteBuffer.new("\0\0\0\0")
       BSON::BSON_RUBY.serialize_cstr(message, "#{@db.name}.#{@name}")
       update_options  = 0
@@ -450,8 +473,8 @@ module Mongo
       message.put_binary(BSON::BSON_CODER.serialize(document, check_keys, true, @connection.max_bson_size).to_s)
 
       instrument(:update, :database => @db.name, :collection => @name, :selector => selector, :document => document) do
-        if safe
-          @connection.send_message_with_safe_check(Mongo::Constants::OP_UPDATE, message, @db.name, nil, safe)
+        if Mongo::WriteConcern.gle?(write_concern)
+          @connection.send_message_with_gle(Mongo::Constants::OP_UPDATE, message, @db.name, nil, write_concern)
         else
           @connection.send_message(Mongo::Constants::OP_UPDATE, message)
         end
@@ -502,18 +525,17 @@ module Mongo
     # @core indexes create_index-instance_method
     def create_index(spec, opts={})
       opts[:dropDups] = opts[:drop_dups] if opts[:drop_dups]
-      field_spec = parse_index_spec(spec)
-      opts = opts.dup
-      name = opts.delete(:name) || generate_index_name(field_spec)
-      name = name.to_s if name
-
+      field_spec      = parse_index_spec(spec)
+      opts            = opts.dup
+      name            = opts.delete(:name) || generate_index_name(field_spec)
+      name            = name.to_s if name
       generate_indexes(field_spec, name, opts)
       name
     end
 
     # Calls create_index and sets a flag to not do so again for another X minutes.
     # this time can be specified as an option when initializing a Mongo::DB object as options[:cache_time]
-    # Any changes to an index will be propogated through regardless of cache time (e.g., a change of index direction)
+    # Any changes to an index will be propagated through regardless of cache time (e.g., a change of index direction)
     #
     # The parameters and options for this methods are the same as those for Collection#create_index.
     #
@@ -528,12 +550,11 @@ module Mongo
     #
     # @return [String] the name of the index.
     def ensure_index(spec, opts={})
-      now = Time.now.utc.to_i
+      now             = Time.now.utc.to_i
       opts[:dropDups] = opts[:drop_dups] if opts[:drop_dups]
-      field_spec = parse_index_spec(spec)
-
-      name = opts[:name] || generate_index_name(field_spec)
-      name = name.to_s if name
+      field_spec      = parse_index_spec(spec)
+      name            = opts[:name] || generate_index_name(field_spec)
+      name            = name.to_s if name
 
       if !@cache[name] || @cache[name] <= now
         generate_indexes(field_spec, name, opts)
@@ -594,7 +615,7 @@ module Mongo
 
       @db.command(cmd)['value']
     end
-    
+
     # Perform an aggregation using the aggregation framework on the current collection.
     # @note Aggregate requires server version >= 2.1.1
     # @note Field References: Within an expression, field names must be quoted and prefixed by a dollar sign ($).
@@ -603,13 +624,13 @@ module Mongo
     #   coll.aggregate([ {"$project" => {"last_name" => 1, "first_name" => 1 }}, {"$match" => {"last_name" => "Jones"}} ])
     #
     # @param [Array] pipeline Should be a single array of pipeline operator hashes.
-    #   
+    #
     #   '$project' Reshapes a document stream by including fields, excluding fields, inserting computed fields, 
     #   renaming fields,or creating/populating fields that hold sub-documents.
     #
     #   '$match' Query-like interface for filtering documents out of the aggregation pipeline.
     #
-    #   '$limit' Restricts the number of documents that pass through the pipline.
+    #   '$limit' Restricts the number of documents that pass through the pipeline.
     #
     #   '$skip' Skips over the specified number of documents and passes the rest along the pipeline.
     #
@@ -636,10 +657,10 @@ module Mongo
       unless Mongo::Support.ok?(result)
         raise Mongo::OperationFailure, "aggregate failed: #{result['errmsg']}"
       end
-      
+
       return result["result"]
     end
-    
+
     # Perform a map-reduce operation on the current collection.
     #
     # @param [String, BSON::Code] map a map function, written in JavaScript.
@@ -655,7 +676,7 @@ module Mongo
     # @option opts [String] :out (nil) a valid output type. In versions of MongoDB prior to v1.7.6,
     #   this option takes the name of a collection for the output results. In versions 1.7.6 and later,
     #   this option specifies the output type. See the core docs for available output types.
-    # @option opts [Boolean] :keeptemp (false) if true, the generated collection will be persisted. The defualt
+    # @option opts [Boolean] :keeptemp (false) if true, the generated collection will be persisted. The default
     #   is false. Note that this option has no effect is versions of MongoDB > v1.7.6.
     # @option opts [Boolean ] :verbose (false) if true, provides statistics on job execution time.
     # @option opts [Boolean] :raw (false) if true, return the raw result object from the map_reduce command, and not
@@ -841,11 +862,10 @@ module Mongo
     # @return [Array] an array of distinct values.
     def distinct(key, query=nil)
       raise MongoArgumentError unless [String, Symbol].include?(key.class)
-      command = BSON::OrderedHash.new
+      command            = BSON::OrderedHash.new
       command[:distinct] = @name
       command[:key]      = key.to_s
       command[:query]    = query
-
       @db.command(command)["values"]
     end
 
@@ -977,7 +997,7 @@ module Mongo
       selector.merge!(opts)
 
       begin
-      insert_documents([selector], Mongo::DB::SYSTEM_INDEX_COLLECTION, false, true)
+      insert_documents([selector], Mongo::DB::SYSTEM_INDEX_COLLECTION, false, {:w => 1})
 
       rescue Mongo::OperationFailure => e
         if selector[:dropDups] && e.message =~ /^11000/
@@ -994,7 +1014,7 @@ module Mongo
     # Sends a Mongo::Constants::OP_INSERT message to the database.
     # Takes an array of +documents+, an optional +collection_name+, and a
     # +check_keys+ setting.
-    def insert_documents(documents, collection_name=@name, check_keys=true, safe=false, flags={})
+    def insert_documents(documents, collection_name=@name, check_keys=true, write_concern={}, flags={})
       if flags[:continue_on_error]
         message = BSON::ByteBuffer.new
         message.put_int(1)
@@ -1026,8 +1046,8 @@ module Mongo
       raise InvalidOperation, "Exceded maximum insert size of 16,777,216 bytes" if message.size > @connection.max_bson_size
 
       instrument(:insert, :database => @db.name, :collection => collection_name, :documents => documents) do
-        if safe
-          @connection.send_message_with_safe_check(Mongo::Constants::OP_INSERT, message, @db.name, nil, safe)
+        if Mongo::WriteConcern.gle?(write_concern)
+          @connection.send_message_with_gle(Mongo::Constants::OP_INSERT, message, @db.name, nil, write_concern)
         else
           @connection.send_message(Mongo::Constants::OP_INSERT, message)
         end