mongo 2.0.6 → 2.1.0.beta

data/lib/mongo/bulk_write/unordered_bulk_write.rb

@@ -13,11 +13,12 @@
 # limitations under the License.
 
 module Mongo
-
   module BulkWrite
 
+    # Encapsulates behaviour around an unordered bulk write operation.
+    #
+    # @since 2.0.0
     class UnorderedBulkWrite
-
       include BulkWritable
 
       private
@@ -35,12 +36,8 @@ module Mongo
       end
 
       def finalize
-        @results.tap do |results|
-          if results[:write_errors] || results[:write_concern_errors]
-            raise Error::BulkWriteError.new(results)
-          end
-        end
+        Result.new(@results).validate!
       end
     end
   end
-end
+end

data/lib/mongo/bulk_write/updatable.rb

@@ -46,23 +46,24 @@ module Mongo
         end
       end
 
-      def update(ops, type, server)
+      def update(ops, type, server, operation_id)
         Operation::Write::BulkUpdate.new(
           :updates => updates(ops, type),
           :db_name => database.name,
           :coll_name => @collection.name,
           :write_concern => write_concern,
-          :ordered => ordered?
+          :ordered => ordered?,
+          :operation_id => operation_id
         ).execute(server.context)
       end
 
-      def update_one(op, server)
-        update(op[:update_one], __method__, server)
+      def update_one(op, server, operation_id)
+        update(op[:update_one], __method__, server, operation_id)
       end
 
-      def update_many(op, server)
-        update(op[:update_many], __method__, server)
+      def update_many(op, server, operation_id)
+        update(op[:update_many], __method__, server, operation_id)
       end
     end
   end
-end
+end

data/lib/mongo/client.rb

@@ -39,6 +39,9 @@ module Mongo
     # Delegate command execution to the current database.
     def_delegators :@database, :command
 
+    # Delegate subscription to monitoring.
+    def_delegators :@monitoring, :subscribe, :unsubscribe
+
     # Determine if this client is equivalent to another object.
     #
     # @example Check client equality.
@@ -143,14 +146,18 @@ module Mongo
     # @option options [ String ] :user The user name.
     # @option options [ Hash ] :write The write concern options. Can be :w =>
     #   Integer, :fsync => Boolean, :j => Boolean.
+    # @option options [ true, false ] :monitoring Initializes a client without
+    #   any default monitoring if false is provided.
     #
     # @since 2.0.0
     def initialize(addresses_or_uri, options = {})
+      @monitoring = Monitoring.new(options)
       if addresses_or_uri.is_a?(::String)
         create_from_uri(addresses_or_uri, options)
       else
         create_from_addresses(addresses_or_uri, options)
       end
+      yield(self) if block_given?
     end
 
     # Get an inspection of the client as a string.
@@ -207,11 +214,12 @@ module Mongo
     # @since 2.0.0
     def with(new_options = {})
       clone.tap do |client|
-        client.options.update(new_options)
+        opts = new_options || {}
+        client.options.update(opts)
         Database.create(client)
         # We can't use the same cluster if some options that would affect it
         # have changed.
-        if cluster_modifying?(new_options)
+        if cluster_modifying?(opts)
           Cluster.create(client)
         end
       end
@@ -230,6 +238,30 @@ module Mongo
       @write_concern ||= WriteConcern.get(options[:write])
     end
 
+    # Close all connections.
+    #
+    # @example Disconnect the client.
+    #   client.close
+    #
+    # @return [ true ] Always true.
+    #
+    # @since 2.1.0
+    def close
+      @cluster.disconnect! and true
+    end
+
+    # Reconnect the client.
+    #
+    # @example Reconnect the client.
+    #   client.reconnect
+    #
+    # @return [ true ] Always true.
+    #
+    # @since 2.1.0
+    def reconnect
+      @cluster.reconnect! and true
+    end
+
     # Get the names of all databases.
     #
     # @example Get the database names.
@@ -258,14 +290,14 @@ module Mongo
 
     def create_from_addresses(addresses, opts = {})
       @options = Database::DEFAULT_OPTIONS.merge(opts).freeze
-      @cluster = Cluster.new(addresses, options)
+      @cluster = Cluster.new(addresses, @monitoring, options)
       @database = Database.new(self, options[:database], options)
     end
 
     def create_from_uri(connection_string, opts = {})
       uri = URI.new(connection_string)
       @options = Database::DEFAULT_OPTIONS.merge(uri.client_options.merge(opts)).freeze
-      @cluster = Cluster.new(uri.servers, options)
+      @cluster = Cluster.new(uri.servers, @monitoring, options)
       @database = Database.new(self, options[:database], options)
     end
 

data/lib/mongo/cluster.rb

@@ -67,7 +67,7 @@ module Mongo
         if addition_allowed?(address)
           log_debug([ "Adding #{address.to_s} to the cluster." ])
           @update_lock.synchronize { @addresses.push(address) }
-          server = Server.new(address, self, event_listeners, options)
+          server = Server.new(address, self, @monitoring, event_listeners, options)
           @update_lock.synchronize { @servers.push(server) }
           server
         end
@@ -76,16 +76,22 @@ module Mongo
 
     # Instantiate the new cluster.
     #
+    # @api private
+    #
     # @example Instantiate the cluster.
-    #   Mongo::Cluster.new(["127.0.0.1:27017"])
+    #   Mongo::Cluster.new(["127.0.0.1:27017"], monitoring)
+    #
+    # @note Cluster should never be directly instantiated outside of a Client.
     #
     # @param [ Array<String> ] seeds The addresses of the configured servers.
+    # @param [ Monitoring ] monitoring The monitoring.
     # @param [ Hash ] options The options.
     #
     # @since 2.0.0
-    def initialize(seeds, options = {})
+    def initialize(seeds, monitoring, options = {})
       @addresses = []
       @servers = []
+      @monitoring = monitoring
       @event_listeners = Event::Listeners.new
       @options = options.freeze
       @topology = Topology.initial(seeds, options)
@@ -196,6 +202,31 @@ module Mongo
       topology.servers(servers_list.compact).compact
     end
 
+    # Disconnect all servers.
+    #
+    # @example Disconnect the cluster's servers.
+    #   cluster.disconnect!
+    #
+    # @return [ true ] Always true.
+    #
+    # @since 2.1.0
+    def disconnect!
+      @servers.each { |server| server.disconnect! } and true
+    end
+
+    # Reconnect all servers.
+    #
+    # @example Reconnect the cluster's servers.
+    #   cluster.reconnect!
+    #
+    # @return [ true ] Always true.
+    #
+    # @since 2.1.0
+    def reconnect!
+      scan!
+      servers.each { |server| server.reconnect! } and true
+    end
+
     # Add hosts in a description to the cluster.
     #
     # @example Add hosts in a description to the cluster.
@@ -240,7 +271,11 @@ module Mongo
     #
     # @since 2.0.0
     def self.create(client)
-      cluster = Cluster.new(client.cluster.addresses.map(&:to_s), client.options)
+      cluster = Cluster.new(
+        client.cluster.addresses.map(&:to_s),
+        client.instance_variable_get(:@monitoring).dup,
+        client.options
+      )
       client.instance_variable_set(:@cluster, cluster)
     end
 

data/lib/mongo/cluster/topology/replica_set.rb

@@ -60,11 +60,14 @@ module Mongo
         # @return [ ReplicaSet ] The topology.
         def elect_primary(description, servers)
           if description.replica_set_name == replica_set_name
-            log_debug([ "Server #{description.address.to_s} elected as primary in #{replica_set_name}." ])
-            servers.each do |server|
-              if server.primary? && server.address != description.address
-                server.description.unknown!
+            unless detect_stale_primary!(description)
+              log_debug([ "Server #{description.address.to_s} elected as primary in #{replica_set_name}." ])
+              servers.each do |server|
+                if server.primary? && server.address != description.address
+                  server.description.unknown!
+                end
               end
+              update_max_election_id(description)
             end
           else
             log_warn([
@@ -84,6 +87,7 @@ module Mongo
         # @since 2.0.0
         def initialize(options, seeds = [])
           @options = options
+          @max_election_id = 0
         end
 
         # A replica set topology is a replica set.
@@ -215,6 +219,18 @@ module Mongo
 
         private
 
+        def update_max_election_id(description)
+          if description.election_id && description.election_id > @max_election_id
+            @max_election_id = description.election_id
+          end
+        end
+
+        def detect_stale_primary!(description)
+          if description.election_id && description.election_id < @max_election_id
+            description.unknown!
+          end
+        end
+
         def has_primary?(servers)
           servers.find { |s| s.primary? }
         end

data/lib/mongo/cluster/topology/sharded.rb

@@ -184,7 +184,7 @@ module Mongo
         private
 
         def remove_self?(description, server)
-          description.is_server?(server) && !description.mongos?
+          description.is_server?(server) && !(description.mongos? || description.unknown?)
         end
       end
     end

data/lib/mongo/collection.rb

@@ -57,6 +57,23 @@ module Mongo
       name == other.name && database == other.database && options == other.options
     end
 
+    # Instantiate a new collection.
+    #
+    # @example Instantiate a new collection.
+    #   Mongo::Collection.new(database, 'test')
+    #
+    # @param [ Mongo::Database ] database The collection's database.
+    # @param [ String, Symbol ] name The collection name.
+    # @param [ Hash ] options The collection options.
+    #
+    # @since 2.0.0
+    def initialize(database, name, options = {})
+      raise Error::InvalidCollectionName.new unless name
+      @database = database
+      @name = name.to_s.freeze
+      @options = options.freeze
+    end
+
     # Is the collection capped?
     #
     # @example Is the collection capped?
@@ -108,12 +125,96 @@ module Mongo
     #   collection.find
     #
     # @param [ Hash ] filter The filter to use in the find.
+    # @param [ Hash ] options The options for the find.
+    #
+    # @option options [ true, false ] :allow_partial_results Allows the query to get partial
+    #   results if some shards are down.
+    # @option options [ Integer ] :batch_size The number of documents returned in each batch
+    #   of results from MongoDB.
+    # @option options [ String ] :comment Associate a comment with the query.
+    # @option options [ :tailable, :tailable_await ] :cursor_type The type of cursor to use.
+    # @option options [ Integer ] :limit The max number of docs to return from the query.
+    # @option options [ Integer ] :max_time_ms The maximum amount of time to allow the query
+    #   to run in milliseconds.
+    # @option options [ Hash ] :modifiers A document containing meta-operators modifying the
+    #   output or behavior of a query.
+    # @option options [ true, false ] :no_cursor_timeout The server normally times out idle
+    #   cursors after an inactivity period (10 minutes) to prevent excess memory use.
+    #   Set this option to prevent that.
+    # @option options [ true, false ] :oplog_replay Internal replication use only - driver
+    #   should not set.
+    # @option options [ Hash ] :projection The fields to include or exclude from each doc
+    #   in the result set.
+    # @option options [ Integer ] :skip The number of docs to skip before returning results.
+    # @option options [ Hash ] :sort The key and direction pairs by which the result set
+    #   will be sorted.
     #
     # @return [ CollectionView ] The collection view.
     #
     # @since 2.0.0
-    def find(filter = nil)
-      View.new(self, filter || {})
+    def find(filter = nil, options = {})
+      View.new(self, filter || {}, options)
+    end
+
+    # Perform an aggregation on the collection.
+    #
+    # @example Perform an aggregation.
+    #   collection.aggregate([ { "$group" => { "_id" => "$city", "tpop" => { "$sum" => "$pop" }}} ])
+    #
+    # @param [ Array<Hash> ] pipeline The aggregation pipeline.
+    # @param [ Hash ] options The aggregation options.
+    #
+    # @option options [ true, false ] :allow_disk_use Set to true if disk usage is allowed during
+    #   the aggregation.
+    # @option options [ Integer ] :batch_size The number of documents to return per batch.
+    # @option options [ Integer ] :max_time_ms The maximum amount of time in milliseconds to allow the
+    #   aggregation to run.
+    # @option options [ true, false ] :use_cursor Indicates whether the command will request that the server
+    #   provide results using a cursor.
+    #
+    # @return [ Aggregation ] The aggregation object.
+    #
+    # @since 2.1.0
+    def aggregate(pipeline, options = {})
+      View.new(self, {}).aggregate(pipeline, options)
+    end
+
+    # Get a count of matching documents in the collection.
+    #
+    # @example Get the count.
+    #   collection.count(name: 1)
+    #
+    # @param [ Hash ] filter A filter for matching documents.
+    # @param [ Hash ] options The count options.
+    #
+    # @option options [ Hash ] :hint The index to use.
+    # @option options [ Integer ] :limit The maximum number of documents to count.
+    # @option options [ Integer ] :max_time_ms The maximum amount of time to allow the command to run.
+    # @option options [ Integer ] :skip The number of documents to skip before counting.
+    #
+    # @return [ Integer ] The document count.
+    #
+    # @since 2.1.0
+    def count(filter = nil, options = {})
+      View.new(self, filter || {}).count(options)
+    end
+
+    # Get a list of distinct values for a specific field.
+    #
+    # @example Get the distinct values.
+    #   collection.distinct('name')
+    #
+    # @param [ Symbol, String ] field_name The name of the field.
+    # @param [ Hash ] filter The documents from which to retrieve the distinct values.
+    # @param [ Hash ] options The distinct command options.
+    #
+    # @option options [ Integer ] :max_time_ms The maximum amount of time to allow the command to run.
+    #
+    # @return [ Array<Object> ] The list of distinct values.
+    #
+    # @since 2.1.0
+    def distinct(field_name, filter = nil, options = {})
+      View.new(self, filter || {}).distinct(field_name, options)
     end
 
     # Get a view of all indexes for this collection. Can be iterated or has
@@ -131,23 +232,6 @@ module Mongo
       Index::View.new(self, options)
     end
 
-    # Instantiate a new collection.
-    #
-    # @example Instantiate a new collection.
-    #   Mongo::Collection.new(database, 'test')
-    #
-    # @param [ Mongo::Database ] database The collection's database.
-    # @param [ String, Symbol ] name The collection name.
-    # @param [ Hash ] options The collection options.
-    #
-    # @since 2.0.0
-    def initialize(database, name, options = {})
-      raise Error::InvalidCollectionName.new unless name
-      @database = database
-      @name = name.to_s.freeze
-      @options = options.freeze
-    end
-
     # Get a pretty printed string inspection for the collection.
     #
     # @example Inspect the collection.
@@ -172,7 +256,13 @@ module Mongo
     #
     # @since 2.0.0
     def insert_one(document, options = {})
-      insert_many([ document ], options)
+      Operation::Write::Insert.new(
+        :documents => [ document ],
+        :db_name => database.name,
+        :coll_name => name,
+        :write_concern => write_concern,
+        :options => options
+      ).execute(next_primary.context)
     end
 
     # Insert the provided documents into the collection.
@@ -187,13 +277,8 @@ module Mongo
     #
     # @since 2.0.0
     def insert_many(documents, options = {})
-      Operation::Write::Insert.new(
-        :documents => documents,
-        :db_name => database.name,
-        :coll_name => name,
-        :write_concern => write_concern,
-        :options => options
-      ).execute(next_primary.context)
+      inserts = documents.map{ |doc| { :insert_one => doc }}
+      bulk_write(inserts, options)
     end
 
     # Execute a batch of bulk write operations.
@@ -204,13 +289,181 @@ module Mongo
     # @param [ Array<Hash> ] operations The operations.
     # @param [ Hash ] options The options.
     #
-    # @return [ BSON::Document ] The result of the operation.
+    # @option options [ true, false ] :ordered Whether the operations
+    #   should be executed in order.
+    # @option options [ Hash ] :write_concern The write concern options.
+    #   Can be :w => Integer, :fsync => Boolean, :j => Boolean.
+    #
+    # @return [ BulkWrite::Result ] The result of the operation.
     #
     # @since 2.0.0
-    def bulk_write(operations, options)
+    def bulk_write(operations, options = {})
       BulkWrite.get(self, operations, options).execute
     end
 
+    # Remove a document from the collection.
+    #
+    # @example Remove a single document from the collection.
+    #   collection.delete_one
+    #
+    # @param [ Hash ] filter The filter to use.
+    #
+    # @return [ Result ] The response from the database.
+    #
+    # @since 2.1.0
+    def delete_one(filter = nil)
+      find(filter).delete_one
+    end
+
+    # Remove documents from the collection.
+    #
+    # @example Remove multiple documents from the collection.
+    #   collection.delete_many
+    #
+    # @param [ Hash ] filter The filter to use.
+    #
+    # @return [ Result ] The response from the database.
+    #
+    # @since 2.1.0
+    def delete_many(filter = nil)
+      find(filter).delete_many
+    end
+
+    # Replaces a single document in the collection with the new document.
+    #
+    # @example Replace a single document.
+    #   collection.replace_one({ name: 'test' }, { name: 'test1' })
+    #
+    # @param [ Hash ] filter The filter to use.
+    # @param [ Hash ] replacement The replacement document..
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ true, false ] :upsert Whether to upsert if the
+    #   document doesn't exist.
+    #
+    # @return [ Result ] The response from the database.
+    #
+    # @since 2.1.0
+    def replace_one(filter, replacement, options = {})
+      find(filter).replace_one(replacement, options)
+    end
+
+    # Update documents in the collection.
+    #
+    # @example Update multiple documents in the collection.
+    #   collection.update_many({ name: 'test'}, '$set' => { name: 'test1' })
+    #
+    # @param [ Hash ] filter The filter to use.
+    # @param [ Hash ] update The update statement.
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ true, false ] :upsert Whether to upsert if the
+    #   document doesn't exist.
+    #
+    # @return [ Result ] The response from the database.
+    #
+    # @since 2.1.0
+    def update_many(filter, update, options = {})
+      find(filter).update_many(update, options)
+    end
+
+    # Update a single document in the collection.
+    #
+    # @example Update a single document in the collection.
+    #   collection.update_one({ name: 'test'}, '$set' => { name: 'test1'})
+    #
+    # @param [ Hash ] filter The filter to use.
+    # @param [ Hash ] update The update statement.
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ true, false ] :upsert Whether to upsert if the
+    #   document doesn't exist.
+    #
+    # @return [ Result ] The response from the database.
+    #
+    # @since 2.1.0
+    def update_one(filter, update, options = {})
+      find(filter).update_one(update, options)
+    end
+
+    # Finds a single document in the database via findAndModify and deletes
+    # it, returning the original document.
+    #
+    # @example Find one document and delete it.
+    #   collection.find_one_and_delete(name: 'test')
+    #
+    # @param [ Hash ] filter The filter to use.
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ Integer ] :max_time_ms The maximum amount of time to allow the command
+    #   to run in milliseconds.
+    # @option options [ Hash ] :projection The fields to include or exclude in the returned doc.
+    # @option options [ Hash ] :sort The key and direction pairs by which the result set
+    #   will be sorted.
+    #
+    # @return [ BSON::Document, nil ] The document, if found.
+    #
+    # @since 2.1.0
+    def find_one_and_delete(filter, options = {})
+      find(filter, options).find_one_and_delete
+    end
+
+    # Finds a single document via findAndModify and updates it, returning the original doc unless
+    # otherwise specified.
+    #
+    # @example Find a document and update it, returning the original.
+    #   collection.find_one_and_update({ name: 'test' }, { "$set" => { name: 'test1' }})
+    #
+    # @example Find a document and update it, returning the updated document.
+    #   collection.find_one_and_update({ name: 'test' }, { "$set" => { name: 'test1' }}, :return_document => :after)
+    #
+    # @param [ Hash ] filter The filter to use.
+    # @param [ BSON::Document ] update The update statement.
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ Integer ] :max_time_ms The maximum amount of time to allow the command
+    #   to run in milliseconds.
+    # @option options [ Hash ] :projection The fields to include or exclude in the returned doc.
+    # @option options [ Hash ] :sort The key and direction pairs by which the result set
+    #   will be sorted.
+    # @option options [ Symbol ] :return_document Either :before or :after.
+    # @option options [ true, false ] :upsert Whether to upsert if the document doesn't exist.
+    #
+    # @return [ BSON::Document ] The document.
+    #
+    # @since 2.1.0
+    def find_one_and_update(filter, update, options = {})
+      find(filter, options).find_one_and_update(update, options)
+    end
+
+    # Finds a single document and replaces it, returning the original doc unless
+    # otherwise specified.
+    #
+    # @example Find a document and replace it, returning the original.
+    #   collection.find_one_and_replace({ name: 'test' }, { name: 'test1' })
+    #
+    # @example Find a document and replace it, returning the new document.
+    #   collection.find_one_and_replace({ name: 'test' }, { name: 'test1' }, :return_document => :after)
+    #
+    # @param [ Hash ] filter The filter to use.
+    # @param [ BSON::Document ] replacement The replacement document.
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ Integer ] :max_time_ms The maximum amount of time to allow the command
+    #   to run in milliseconds.
+    # @option options [ Hash ] :projection The fields to include or exclude in the returned doc.
+    # @option options [ Hash ] :sort The key and direction pairs by which the result set
+    #   will be sorted.
+    # @option options [ Symbol ] :return_document Either :before or :after.
+    # @option options [ true, false ] :upsert Whether to upsert if the document doesn't exist.
+    #
+    # @return [ BSON::Document ] The document.
+    #
+    # @since 2.1.0
+    def find_one_and_replace(filter, replacement, options = {})
+      find(filter, options).find_one_and_update(replacement, options)
+    end
+
     # Get the fully qualified namespace of the collection.
     #
     # @example Get the fully qualified namespace.