mongo 2.1.0.beta → 2.2.0

data/lib/mongo/cluster.rb

@@ -25,6 +25,16 @@ module Mongo
     include Event::Subscriber
     include Loggable
 
+    # The default number of mongos read retries.
+    #
+    # @since 2.1.1
+    MAX_READ_RETRIES = 1
+
+    # The default mongos read retry interval, in seconds.
+    #
+    # @since 2.1.1
+    READ_RETRY_INTERVAL = 5
+
     # @return [ Hash ] The options hash.
     attr_reader :options
 
@@ -65,7 +75,7 @@ module Mongo
       address = Address.new(host)
       if !addresses.include?(address)
         if addition_allowed?(address)
-          log_debug([ "Adding #{address.to_s} to the cluster." ])
+          log_debug("Adding #{address.to_s} to the cluster.")
           @update_lock.synchronize { @addresses.push(address) }
           server = Server.new(address, self, @monitoring, event_listeners, options)
           @update_lock.synchronize { @servers.push(server) }
@@ -88,7 +98,7 @@ module Mongo
     # @param [ Hash ] options The options.
     #
     # @since 2.0.0
-    def initialize(seeds, monitoring, options = {})
+    def initialize(seeds, monitoring, options = Options::Redacted.new)
       @addresses = []
       @servers = []
       @monitoring = monitoring
@@ -96,12 +106,34 @@ module Mongo
       @options = options.freeze
       @topology = Topology.initial(seeds, options)
       @update_lock = Mutex.new
+      @pool_lock = Mutex.new
 
       subscribe_to(Event::STANDALONE_DISCOVERED, Event::StandaloneDiscovered.new(self))
       subscribe_to(Event::DESCRIPTION_CHANGED, Event::DescriptionChanged.new(self))
       subscribe_to(Event::PRIMARY_ELECTED, Event::PrimaryElected.new(self))
 
       seeds.each{ |seed| add(seed) }
+      ObjectSpace.define_finalizer(self, self.class.finalize(pools))
+    end
+
+    # Finalize the cluster for garbage collection. Disconnects all the scoped
+    # connection pools.
+    #
+    # @example Finalize the cluster.
+    #   Cluster.finalize(pools)
+    #
+    # @param [ Hash<Address, Server::ConnectionPool> ] pools The connection
+    #   pools.
+    #
+    # @return [ Proc ] The Finalizer.
+    #
+    # @since 2.2.0
+    def self.finalize(pools)
+      proc do
+        pools.values.each do |pool|
+          pool.disconnect!
+        end
+      end
     end
 
     # Get the nicer formatted string for use in inspection.
@@ -121,11 +153,13 @@ module Mongo
     # @example Get the next primary server.
     #   cluster.next_primary
     #
+    # @param [ true, false ] ping Whether to ping the server before selection.
+    #
     # @return [ Mongo::Server ] A primary server.
     #
     # @since 2.0.0
-    def next_primary
-      ServerSelector.get({ mode: :primary }, options).select_server(self)
+    def next_primary(ping = true)
+      ServerSelector.get(ServerSelector::PRIMARY.merge(options)).select_server(self, ping)
     end
 
     # Elect a primary server from the description that has just changed to a
@@ -143,6 +177,48 @@ module Mongo
       @topology = topology.elect_primary(description, servers_list)
     end
 
+    # Get the maximum number of times the cluster can retry a read operation on
+    # a mongos.
+    #
+    # @example Get the max read retries.
+    #   cluster.max_read_retries
+    #
+    # @return [ Integer ] The maximum retries.
+    #
+    # @since 2.1.1
+    def max_read_retries
+      options[:max_read_retries] || MAX_READ_RETRIES
+    end
+
+    # Get the scoped connection pool for the server.
+    #
+    # @example Get the connection pool.
+    #   cluster.pool(server)
+    #
+    # @param [ Server ] server The server.
+    #
+    # @return [ Server::ConnectionPool ] The connection pool.
+    #
+    # @since 2.2.0
+    def pool(server)
+      @pool_lock.synchronize do
+        pools[server.address] ||= Server::ConnectionPool.get(server)
+      end
+    end
+
+    # Get the interval, in seconds, in which a mongos read operation is
+    # retried.
+    #
+    # @example Get the read retry interval.
+    #   cluster.read_retry_interval
+    #
+    # @return [ Float ] The interval.
+    #
+    # @since 2.1.1
+    def read_retry_interval
+      options[:read_retry_interval] || READ_RETRY_INTERVAL
+    end
+
     # Notify the cluster that a standalone server was discovered so that the
     # topology can be updated accordingly.
     #
@@ -166,7 +242,7 @@ module Mongo
     #
     # @since 2.0.0
     def remove(host)
-      log_debug([ "#{host} being removed from the cluster." ])
+      log_debug("#{host} being removed from the cluster.")
       address = Address.new(host)
       removed_servers = @servers.select { |s| s.address == address }
       @update_lock.synchronize { @servers = @servers - removed_servers }
@@ -301,6 +377,10 @@ module Mongo
       !@topology.single? || direct_connection?(address)
     end
 
+    def pools
+      @pools ||= {}
+    end
+
     def servers_list
       @update_lock.synchronize do
         @servers.reduce([]) do |servers, server|

data/lib/mongo/collection/view/aggregation.rb

@@ -25,6 +25,8 @@ module Mongo
         include Immutable
         include Iterable
         include Explainable
+        include Loggable
+        include Retryable
 
         # @return [ View ] view The collection view.
         attr_reader :view
@@ -37,14 +39,10 @@ module Mongo
         # Delegate necessary operations to the collection.
         def_delegators :collection, :database
 
-        # Options mapping for an aggregation.
+        # The reroute message.
         #
         # @since 2.1.0
-        OPTIONS_MAP = {
-                       :allow_disk_use => :allowDiskUse,
-                       :max_time_ms => :maxTimeMS,
-                       :explain => :explain
-                      }
+        REROUTE = 'Rerouting the Aggregation operation to the primary server.'.freeze
 
         # Set to true if disk usage is allowed during the aggregation.
         #
@@ -58,7 +56,7 @@ module Mongo
         #
         # @since 2.0.0
         def allow_disk_use(value = nil)
-          configure(__method__, value)
+          configure(:allow_disk_use, value)
         end
 
         # Initialize the aggregation for the provided collection view, pipeline
@@ -87,61 +85,37 @@ module Mongo
         #
         # @since 2.0.0
         def explain
-          self.class.new(view, pipeline, options.merge(explain_options)).first
+          self.class.new(view, pipeline, options.merge(explain: true)).first
         end
 
         private
 
         def aggregate_spec
-          { :db_name => database.name,
-            :read => read,
-            :selector => {
-              :aggregate => collection.name,
-              :pipeline => pipeline,
-              :cursor => cursor,
-            }.merge!(agg_options)
-          }
+          Builder::Aggregation.new(pipeline, view, options).specification
         end
 
-        def agg_options
-          @agg_options ||= options.each.reduce({}) do |opts, (key, value)|
-            OPTIONS_MAP[key] ? opts.merge!(OPTIONS_MAP[key] => value) : opts
-          end
-        end
-
-        def cursor
-          if options[:use_cursor] == true || options[:use_cursor].nil?
-            batch_size_doc
-          end
-        end
-
-        def batch_size_doc
-          (value = options[:batch_size] || view.batch_size) ?
-              { :batchSize => value } : {}
+        def new(options)
+          Aggregation.new(view, pipeline, options)
         end
 
-        def explain_options
-          { :explain => true }
+        def initial_query_op
+          Operation::Commands::Aggregate.new(aggregate_spec)
         end
 
-        def new(options)
-          Aggregation.new(view, pipeline, options)
+        def valid_server?(server)
+          server.standalone? || server.mongos? || server.primary? || secondary_ok?
         end
 
-        def initial_query_op
-          Operation::Aggregate.new(aggregate_spec)
+        def secondary_ok?
+          pipeline.none? { |op| op.key?('$out') || op.key?(:$out) }
         end
 
         def send_initial_query(server)
-          begin
-            initial_query_op.execute(server.context)
-          rescue Mongo::Error::NeedPrimaryServer
-            log_warn([
-              'Rerouting the Aggregation operation to the primary server.'
-            ])
-            server = ServerSelector.get(mode: :primary).select_server(cluster)
-            initial_query_op.execute(server.context)
+          unless valid_server?(server)
+            log_warn(REROUTE)
+            server = cluster.next_primary(false)
           end
+          initial_query_op.execute(server.context)
         end
       end
     end

data/lib/mongo/collection/view/builder/aggregation.rb

@@ -0,0 +1,98 @@
+# Copyright (C) 2015 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
+  class Collection
+    class View
+      module Builder
+
+        # Builds an aggregation command specification from the view and options.
+        #
+        # @since 2.2.0
+        class Aggregation
+          extend Forwardable
+
+          # The mappings from ruby options to the aggregation options.
+          #
+          # @since 2.2.0
+          MAPPINGS = BSON::Document.new(
+            :allow_disk_use => 'allowDiskUse',
+            :max_time_ms => 'maxTimeMS',
+            :explain => 'explain',
+            :bypass_document_validation => 'bypassDocumentValidation'
+          ).freeze
+
+          def_delegators :@view, :collection, :database, :read
+
+          # @return [ Array<Hash> ] pipeline The pipeline.
+          attr_reader :pipeline
+
+          # @return [ Collection::View ] view The collection view.
+          attr_reader :view
+
+          # @return [ Hash ] options The map/reduce specific options.
+          attr_reader :options
+
+          # Initialize the builder.
+          #
+          # @example Initialize the builder.
+          #   Aggregation.new(map, reduce, view, options)
+          #
+          # @param [ Array<Hash> ] pipeline The aggregation pipeline.
+          # @param [ Collection::View ] view The collection view.
+          # @param [ Hash ] options The map/reduce options.
+          #
+          # @since 2.2.0
+          def initialize(pipeline, view, options)
+            @pipeline = pipeline
+            @view = view
+            @options = options
+          end
+
+          # Get the specification to pass to the aggregation operation.
+          #
+          # @example Get the specification.
+          #   builder.specification
+          #
+          # @return [ Hash ] The specification.
+          #
+          # @since 2.2.0
+          def specification
+            { selector: aggregation_command, db_name: database.name, read: read }
+          end
+
+          private
+
+          def aggregation_command
+            command = BSON::Document.new(:aggregate => collection.name, :pipeline => pipeline)
+            command[:cursor] = cursor if cursor
+            command[:readConcern] = collection.read_concern if collection.read_concern
+            command.merge!(Options::Mapper.transform_documents(options, MAPPINGS))
+            command
+          end
+
+          def cursor
+            if options[:use_cursor] == true || options[:use_cursor].nil?
+              batch_size_doc
+            end
+          end
+
+          def batch_size_doc
+            (value = options[:batch_size] || view.batch_size) ?  { :batchSize => value } : {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/collection/view/builder/find_command.rb

@@ -0,0 +1,111 @@
+# Copyright (C) 2015 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
+  class Collection
+    class View
+      module Builder
+
+        # Builds a find command specification from options.
+        #
+        # @since 2.2.0
+        class FindCommand
+          extend Forwardable
+
+          # The mappings from ruby options to the find command.
+          #
+          # @since 2.2.0
+          MAPPINGS = BSON::Document.new(
+            sort: 'sort',
+            projection: 'projection',
+            hint: 'hint',
+            skip: 'skip',
+            limit: 'limit',
+            batch_size: 'batchSize',
+            single_batch: 'singleBatch',
+            comment: 'comment',
+            max_scan: 'maxScan',
+            max_time_ms: 'maxTimeMS',
+            max_value: 'max',
+            min_value: 'min',
+            return_key: 'returnKey',
+            show_disk_loc: 'showRecordId',
+            snapshot: 'snapshot',
+            tailable: 'tailable',
+            oplog_replay: 'oplogReplay',
+            no_cursor_timeout: 'noCursorTimeout',
+            await_data: 'awaitData',
+            allow_partial_results: 'allowPartialResults',
+            read_concern: 'readConcern'
+          ).freeze
+
+          def_delegators :@view, :collection, :database, :filter, :options, :read
+
+          # Get the specification for an explain command that wraps the find
+          # command.
+          #
+          # @example Get the explain spec.
+          #   builder.explain_specification
+          #
+          # @return [ Hash ] The specification.
+          #
+          # @since 2.2.0
+          def explain_specification
+            { selector: { explain: find_command }, db_name: database.name, read: read }
+          end
+
+          # Create the find command builder.
+          #
+          # @example Create the find command builder.
+          #   FindCommandBuilder.new(view)
+          #
+          # @param [ Collection::View ] view The collection view.
+          #
+          # @since 2.2.2
+          def initialize(view)
+            @view = view
+          end
+
+          # Get the specification to pass to the find command operation.
+          #
+          # @example Get the specification.
+          #   builder.specification
+          #
+          # @return [ Hash ] The specification.
+          #
+          # @since 2.2.0
+          def specification
+            { selector: find_command, db_name: database.name, read: read }
+          end
+
+          private
+
+          def find_command
+            document = BSON::Document.new('find' => collection.name, 'filter' => filter)
+            command = Options::Mapper.transform_documents(options, MAPPINGS, document)
+            convert_negative_limit(command)
+          end
+
+          def convert_negative_limit(command)
+            if command[:limit] && command[:limit] < 0
+              command.delete('limit')
+              command[:singleBatch] = true
+            end
+            command
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/collection/view/builder/flags.rb

@@ -0,0 +1,62 @@
+# Copyright (C) 2015 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
+  class Collection
+    class View
+      module Builder
+
+        # Provides behaviour for mapping flags.
+        #
+        # @since 2.2.0
+        module Flags
+          extend self
+
+          # Options to cursor flags mapping.
+          #
+          # @since 2.2.0
+          MAPPINGS = {
+            :allow_partial_results => [ :partial ],
+            :oplog_replay => [ :oplog_replay ],
+            :no_cursor_timeout => [ :no_cursor_timeout ],
+            :tailable => [ :tailable_cursor ],
+            :tailable_await => [ :await_data, :tailable_cursor],
+            :await_data => [ :await_data ],
+            :exhaust => [ :exhaust ]
+          }.freeze
+
+          # Maps an array of flags from the provided options.
+          #
+          # @example Map the flags.
+          #   Flags.map_flags(options)
+          #
+          # @param [ Hash, BSON::Document ] options The options.
+          #
+          # @return [ Array<Symbol> ] The flags.
+          #
+          # @since 2.2.0
+          def map_flags(options)
+            MAPPINGS.each.reduce(options[:flags] || []) do |flags, (key, value)|
+              cursor_type = options[:cursor_type]
+              if options[key] || (cursor_type && cursor_type == key)
+                flags.push(*value)
+              end
+              flags
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/collection/view/builder/map_reduce.rb

@@ -0,0 +1,134 @@
+# Copyright (C) 2015 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
+  class Collection
+    class View
+      module Builder
+
+        # Builds a map/reduce specification from the view and options.
+        #
+        # @since 2.2.0
+        class MapReduce
+          extend Forwardable
+
+          # The mappings from ruby options to the map/reduce options.
+          #
+          # @since 2.2.0
+          MAPPINGS = BSON::Document.new(
+            finalize: 'finalize',
+            js_mode: 'jsMode',
+            out: 'out',
+            scope: 'scope',
+            verbose: 'verbose',
+            bypass_document_validation: 'bypassDocumentValidation'
+          ).freeze
+
+          def_delegators :@view, :collection, :database, :filter, :read
+
+          # @return [ String ] map The map function.
+          attr_reader :map
+
+          # @return [ String ] reduce The reduce function.
+          attr_reader :reduce
+
+          # @return [ Collection::View ] view The collection view.
+          attr_reader :view
+
+          # @return [ Hash ] options The map/reduce specific options.
+          attr_reader :options
+
+          # Initialize the builder.
+          #
+          # @example Initialize the builder.
+          #   MapReduce.new(map, reduce, view, options)
+          #
+          # @param [ String ] map The map function.
+          # @param [ String ] reduce The reduce function.
+          # @param [ Collection::View ] view The collection view.
+          # @param [ Hash ] options The map/reduce options.
+          #
+          # @since 2.2.0
+          def initialize(map, reduce, view, options)
+            @map = map
+            @reduce = reduce
+            @view = view
+            @options = options
+          end
+
+          # Get the specification for issuing a find command on the map/reduce
+          # results.
+          #
+          # @example Get the command specification.
+          #   builder.command_specification
+          #
+          # @return [ Hash ] The specification.
+          #
+          # @since 2.2.0
+          def command_specification
+            { selector: find_command, db_name: database.name, read: read }
+          end
+
+          # Get the specification for the document query after a map/reduce.
+          #
+          # @example Get the query specification.
+          #   builder.query_specification
+          #
+          # @return [ Hash ] The specification.
+          #
+          # @since 2.2.0
+          def query_specification
+            { selector: {}, options: {}, db_name: database.name, coll_name: query_collection }
+          end
+
+          # Get the specification to pass to the map/reduce operation.
+          #
+          # @example Get the specification.
+          #   builder.specification
+          #
+          # @return [ Hash ] The specification.
+          #
+          # @since 2.2.0
+          def specification
+            { selector: map_reduce_command, db_name: database.name, read: read }
+          end
+
+          private
+
+          def find_command
+            BSON::Document.new('find' => query_collection, 'filter' => {})
+          end
+
+          def map_reduce_command
+            command = BSON::Document.new(
+              :mapreduce => collection.name,
+              :map => map,
+              :reduce => reduce,
+              :query => filter,
+              :out => { inline: 1 }
+            )
+            command[:readConcern] = collection.read_concern if collection.read_concern
+            command.merge!(Options::Mapper.transform_documents(options, MAPPINGS))
+            command.merge!(view.options)
+            command
+          end
+
+          def query_collection
+            options[:out].respond_to?(:keys) ? options[:out].values.first : options[:out]
+          end
+        end
+      end
+    end
+  end
+end