mongo 2.0.0.beta → 2.0.0.rc

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4fd709834ca22c23121ccd052a08277d95dee73f
-  data.tar.gz: 87ff2b2bde354cf9160909c7d2ea18c6dbf8534e
+  metadata.gz: 05111deea6c32629a6dea5c78f42502e4667f42e
+  data.tar.gz: c83465c51c98355b68843b3e9cdf5f9c89621a8e
 SHA512:
-  metadata.gz: b385d02b0e3cf9b60b65051f2c5c417767a722c49f2a4aa90551cd040b64b3871b2ee023a6bc5d3e20855a23d5a162d4ede62028269573231c1e965e67ccf8d2
-  data.tar.gz: e3408e4cacf4956b4b06f8a1541eb6e34414469f773892592733f028a7a39f9238d51ad842ca637a01d5cd71a7a798aaf20c70153636a391b3deb902984c1299
+  metadata.gz: ef54dd2b1941e7b27aae4887e1c8661d929a0c8efe06b00fc3a4ec56541f75023111efbbe7e6dd0934acf48e2147b883d4c68d6756c62c305b374b512ba1ff4a
+  data.tar.gz: 38079d819c3d24a50f7f8b4346196b37936ae04074175a06c0aff4dbeee1564544eb10d91cbc97453326b7e0e41461cc79b3239faa836a9ef94c8a3f8ab9e70a

data/Rakefile

@@ -29,8 +29,21 @@ namespace :spec do
 end
 
 task :release => :spec do
-  system "git tag -a v#{Mongo::VERSION} -m 'Tagging release: #{Mongo::VERSION}'"
+  system "git tag -a #{Mongo::VERSION} -m 'Tagging release: #{Mongo::VERSION}'"
   system "git push --tags"
+  system "gem build mongo.gemspec"
   system "gem push mongo-#{Mongo::VERSION}.gem"
   system "rm mongo-#{Mongo::VERSION}.gem"
 end
+
+desc "Generate all documentation"
+task :docs => 'docs:yard'
+
+namespace :docs do
+  desc "Generate yard documention"
+  task :yard do
+    out = File.join('docs', Mongo::VERSION)
+    FileUtils.rm_rf(out)
+    system "yardoc -o #{out} --title mongo-#{Mongo::VERSION}"
+  end
+end

data/lib/mongo.rb

@@ -21,7 +21,7 @@ require 'mongo/error'
 require 'mongo/event'
 require 'mongo/address'
 require 'mongo/auth'
-require 'mongo/bulk'
+require 'mongo/bulk_write'
 require 'mongo/client'
 require 'mongo/cluster'
 require 'mongo/collection'
@@ -30,6 +30,7 @@ require 'mongo/database'
 require 'mongo/grid'
 require 'mongo/index'
 require 'mongo/operation'
+require 'mongo/options'
 require 'mongo/protocol'
 require 'mongo/server'
 require 'mongo/server_selector'

data/lib/mongo/auth.rb

@@ -56,9 +56,9 @@ module Mongo
     # Get the authorization strategy for the provided auth mechanism.
     #
     # @example Get the strategy.
-    #   Auth.get(:mongodb_cr)
+    #   Auth.get(user)
     #
-    # @param [ Symbol ] mechanism The authorization mechanism.
+    # @param [ Auth::User ] user The user object.
     #
     # @return [ CR, X509, LDAP, Kerberos ] The auth strategy.
     #

data/lib/mongo/bulk_write.rb

@@ -0,0 +1,52 @@
+# Copyright (C) 2014-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.
+
+require 'mongo/bulk_write/bulk_writable'
+require 'mongo/bulk_write/ordered_bulk_write'
+require 'mongo/bulk_write/unordered_bulk_write'
+
+module Mongo
+  module BulkWrite
+    extend self
+
+    # Get a bulk write object either of type ordered or unordered.
+    #
+    # @example Get a bulk write object.
+    #   Mongo::BulkWrite.get(collection, operations, ordered: true)
+    #
+    # @param [ Collection ] collection The collection on which the operations
+    #   will be executed.
+    #
+    # @param [ Array<Hash> ] operations The operations to execute.
+    #
+    # @param [ Hash ] options The options for the bulk write object.
+    #
+    # @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 [ OrderedBulkWrite, UnorderedBulkWrite ] The appropriate bulk
+    #   write object.
+    #
+    # @since 2.0.0
+    def get(collection, operations, options)
+      if options.fetch(:ordered, true)
+        OrderedBulkWrite.new(collection, operations, options)
+      else
+        UnorderedBulkWrite.new(collection, operations, options)
+      end
+    end
+  end
+end

data/lib/mongo/bulk_write/bulk_writable.rb

@@ -0,0 +1,191 @@
+# Copyright (C) 2014-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.
+
+require 'mongo/bulk_write/insertable'
+require 'mongo/bulk_write/deletable'
+require 'mongo/bulk_write/updatable'
+require 'mongo/bulk_write/replacable'
+
+module Mongo
+  module BulkWrite
+
+    # Defines shared behaviour between ordered and unordered bulk operations.
+    #
+    # @since 2.0.0
+    module BulkWritable
+      include Insertable
+      include Deletable
+      include Updatable
+      include Replacable
+      extend Forwardable
+
+      # Delegate various methods to the collection.
+      def_delegators :@collection, :database, :cluster, :next_primary
+
+      # The fields contained in the result document returned from executing the
+      # operations.
+      #
+      # @since 2.0.0.
+      RESULT_FIELDS = [ :n_inserted,
+                        :n_removed,
+                        :n_modified,
+                        :n_upserted,
+                        :n_matched ]
+
+
+      # Initialize a bulk write object.
+      #
+      # @example Initialize a bulk write object.
+      #   Mongo::BulkWrite::OrderedBulkWrite.new(collection, operations, options)
+      #   Mongo::BulkWrite::UnorderedBulkWrite.new(collection, operations, options)
+      #
+      # @param [ Mongo::Collection ] collection The collection the operations will
+      #   be executed on.
+      # @param [ Array<Hash> ] operations The operations to be executed.
+      # @param [ Hash ] options The options.
+      #
+      # @option options [ Hash ] :write_concern The write concern to use for this
+      #   bulk write.
+      #
+      # @since 2.0.0
+      def initialize(collection, operations, options)
+        @collection = collection
+        @operations = operations
+        @options = options
+      end
+
+      # Execute the bulk operations.
+      #
+      # @example Execute the operations.
+      #   bulk.execute
+      #
+      # @return [ Hash ] The results from the bulk write.
+      #
+      # @since 2.0.0
+      def execute
+        server = next_primary
+        validate_operations!
+        merged_ops.each do |op|
+          validate_type!(op.keys.first)
+          execute_op(op, server)
+        end
+        finalize
+      end
+
+      private
+
+      def write_concern
+        @write_concern ||= WriteConcern.get(@options[:write_concern]) ||
+                            @collection.write_concern
+      end
+
+      def validate_operations!
+        unless @operations && @operations.size > 0
+          raise ArgumentError.new('Operations cannot be empty')
+        end
+      end
+
+      def validate_type!(type)
+        unless respond_to?(type, true)
+          raise Error::InvalidBulkOperationType.new(type)
+        end
+      end
+
+      def max_write_batches(op, server)
+        type = op.keys.first
+        ops = []
+        while op[type].size > server.max_write_batch_size
+          ops << { type => op[type].shift(server.max_write_batch_size),
+                   :indexes => op[:indexes].shift(server.max_write_batch_size) }
+        end
+        ops << op
+      end
+
+      def split(op, type)
+        n = op[type].size/2
+        [ { type => op[type].shift(n),
+            :indexes => op[:indexes].shift(n) },
+          { type => op[type],
+            :indexes => op[:indexes] }
+        ]
+      end
+
+      def execute_op(operation, server)
+        ops = max_write_batches(operation, server)
+
+        until ops.empty?
+          op = ops.shift
+          type = op.keys.first
+          begin
+            process(send(type, op, server), op[:indexes])
+          rescue Error::MaxBSONSize, Error::MaxMessageSize => ex
+            raise ex if op[type].size < 2
+            ops = split(op, type) + ops
+          end
+        end
+      end
+
+      def merge_consecutive_ops(ops)
+        ops.each_with_index.inject([]) do |merged, (op, i)|
+          type = op.keys.first
+          op[:indexes] ||= [ i ]
+          previous = merged.last
+          if previous && previous.keys.first == type
+            merged[-1].merge!(type => previous[type] << op[type],
+                             :indexes => previous[:indexes] + op[:indexes])
+            merged
+          else
+            merged << { type => [ op[type] ].flatten,
+                        :indexes => op[:indexes] }
+          end
+        end
+      end
+
+      def merge_ops_by_type
+        indexes = {}
+        ops_hash = @operations.each_with_index.inject({}) do |merged, (op, i)|
+          type = op.keys.first
+          merged.merge!(op) { |type, v1, v2| ([v1] << v2).flatten }
+          indexes[type] = (indexes[type] || []).push(i)
+          merged
+        end
+        ops_hash.keys.reduce([]) do |ops_list, type|
+          ops_list << { type => ops_hash[type], :indexes => indexes[type] }
+        end
+      end
+
+      def combine_results(result, indexes)
+        @results ||= {}
+        write_errors = result.aggregate_write_errors(indexes)
+
+        # The Bulk API only returns the first write concern error encountered.
+        @write_concern_errors ||= result.aggregate_write_concern_errors(indexes)
+
+        @results.tap do |results|
+          RESULT_FIELDS.each do |field|
+            results.merge!(
+              field => (results[field] || 0) + result.send(field)
+            ) if result.respond_to?(field)
+          end
+
+          results.merge!(
+            write_errors: ((results[:write_errors] || []) << write_errors).flatten
+          ) if write_errors
+
+          results.merge!(write_concern_errors: @write_concern_errors) if @write_concern_errors
+        end
+      end
+    end
+  end
+end

data/lib/mongo/bulk_write/deletable.rb

@@ -0,0 +1,60 @@
+# Copyright (C) 2014-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
+  module BulkWrite
+
+    # Defines behavior for validating and combining delete bulk write operations.
+    #
+    # @since 2.0.0.
+    module Deletable
+
+      private
+
+      def valid_doc?(doc)
+        doc.respond_to?(:keys)
+      end
+
+      def validate_delete_op!(type, d)
+        raise Error::InvalidBulkOperation.new(type, d) unless valid_doc?(d)
+      end
+
+      def deletes(ops, type)
+        limit = (type == :delete_one) ? 1 : 0
+        ops.collect do |d|
+          validate_delete_op!(type, d)
+          { q: d, limit: limit }
+        end
+      end
+
+      def delete(ops, type, server)
+        Operation::Write::BulkDelete.new(
+          :deletes => deletes(ops, type),
+          :db_name => database.name,
+          :coll_name => @collection.name,
+          :write_concern => write_concern,
+          :ordered => ordered?
+        ).execute(server.context)
+      end
+
+      def delete_one(op, server)
+        delete(op[:delete_one], __method__, server)
+      end
+
+      def delete_many(op, server)
+        delete(op[:delete_many], __method__, server)
+      end
+    end
+  end
+end

data/lib/mongo/bulk_write/insertable.rb

@@ -0,0 +1,52 @@
+# Copyright (C) 2014-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
+  module BulkWrite
+
+    # Defines behavior for validating and combining insert bulk write operations.
+    #
+    # @since 2.0.0.
+    module Insertable
+
+      private
+
+      def valid_doc?(doc)
+        doc.respond_to?(:keys)
+      end
+
+      def validate_insert_ops!(type, inserts)
+        if inserts.empty?
+          raise Error::InvalidBulkOperation.new(type, inserts)
+        end
+        inserts.each do |i|
+          unless valid_doc?(i)
+            raise Error::InvalidBulkOperation.new(type, i)
+          end
+        end
+      end
+
+      def insert_one(op, server)
+        validate_insert_ops!(__method__, op[:insert_one])
+        Operation::Write::BulkInsert.new(
+          :documents => op[:insert_one].flatten,
+          :db_name => database.name,
+          :coll_name => @collection.name,
+          :write_concern => write_concern,
+          :ordered => ordered?
+        ).execute(server.context)
+      end
+    end
+  end
+end

data/lib/mongo/bulk_write/ordered_bulk_write.rb

@@ -0,0 +1,48 @@
+# Copyright (C) 2014-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
+
+  module BulkWrite
+
+    class OrderedBulkWrite
+
+      include BulkWritable
+
+      private
+
+      def ordered?
+        true
+      end
+
+      def merged_ops
+        merge_consecutive_ops(@operations)
+      end
+
+      def process(result, indexes)
+        combine_results(result, indexes)
+        raise Error::BulkWriteError.new(@results) if stop?
+      end
+
+      def stop?
+        @results.keys.include?(:write_errors)
+      end
+
+      def finalize
+        raise Error::BulkWriteError.new(@results) if @results[:write_concern_errors]
+        @results
+      end
+    end
+  end
+end