mongo 1.12.5 → 2.0.0.beta

data/lib/mongo/auth/user.rb

@@ -0,0 +1,159 @@
+# 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/auth/user/view'
+
+module Mongo
+  module Auth
+
+    # Represents a user in MongoDB.
+    #
+    # @since 2.0.0
+    class User
+
+      # The users collection for the database.
+      #
+      # @since 2.0.0
+      COLLECTION = 'system.users'.freeze
+
+      # @return [ String ] The authorization source, either a database or
+      #   external name.
+      attr_reader :auth_source
+
+      # @return [ String ] The database the user is created in.
+      attr_reader :database
+
+      # @return [ Hash ] The authentication mechanism properties.
+      attr_reader :auth_mech_properties
+
+      # @return [ Symbol ] The authorization mechanism.
+      attr_reader :mechanism
+
+      # @return [ String ] The username.
+      attr_reader :name
+
+      # @return [ String ] The cleartext password.
+      attr_reader :password
+
+      # @return [ Array<String> ] roles The user roles.
+      attr_reader :roles
+
+      # Determine if this user is equal to another.
+      #
+      # @example Check user equality.
+      #   user == other
+      #
+      # @param [ Object ] other The object to compare against.
+      #
+      # @return [ true, false ] If the objects are equal.
+      #
+      # @since 2.0.0
+      def ==(other)
+        return false unless other.is_a?(User)
+        name == other.name && database == other.database && password == other.password
+      end
+
+      # Get an authentication key for the user based on a nonce from the
+      # server.
+      #
+      # @example Get the authentication key.
+      #   user.auth_key(nonce)
+      #
+      # @param [ String ] nonce The response from the server.
+      #
+      # @return [ String ] The authentication key.
+      #
+      # @since 2.0.0
+      def auth_key(nonce)
+        Digest::MD5.hexdigest("#{nonce}#{name}#{hashed_password}")
+      end
+
+      # Get the UTF-8 encoded name with escaped special characters for use with
+      # SCRAM authorization.
+      #
+      # @example Get the encoded name.
+      #   user.encoded_name
+      #
+      # @return [ String ] The encoded user name.
+      #
+      # @since 2.0.0
+      def encoded_name
+        name.encode(BSON::UTF8).gsub('=','=3D').gsub(',','=2C')
+      end
+
+      # Get the hash key for the user.
+      #
+      # @example Get the hash key.
+      #   user.hash
+      #
+      # @return [ String ] The user hash key.
+      #
+      # @since 2.0.0
+      def hash
+        [ name, database, password ].hash
+      end
+
+      # Get the user's hashed password.
+      #
+      # @example Get the user's hashed password.
+      #   user.hashed_password
+      #
+      # @return [ String ] The hashed password.
+      #
+      # @since 2.0.0
+      def hashed_password
+        @hashed_password ||= Digest::MD5.hexdigest("#{name}:mongo:#{password}").encode(BSON::UTF8)
+      end
+
+      # Create the new user.
+      #
+      # @example Create a new user.
+      #   Mongo::Auth::User.new(options)
+      #
+      # @param [ Hash ] options The options to create the user from.
+      #
+      # @option options [ String ] :auth_source The authorization database or
+      #   external source.
+      # @option options [ String ] :database The database the user is
+      #   authorized for.
+      # @option options [ String ] :user The user name.
+      # @option options [ String ] :password The user's password.
+      # @option options [ Symbol ] :auth_mech The authorization mechanism.
+      # @option options [ Array<String>, Array<Hash> ] roles The user roles.
+      #
+      # @since 2.0.0
+      def initialize(options)
+        @auth_source = options[:auth_source] || options[:database] || Database::ADMIN
+        @database = options[:database] || Database::ADMIN
+        @name = options[:user]
+        @password = options[:password] || options[:pwd]
+        @mechanism = options[:auth_mech] || :mongodb_cr
+        @auth_mech_properties = options[:auth_mech_properties] || {}
+        @roles = options[:roles] || []
+      end
+
+      # Get the specification for the user, used in creation.
+      #
+      # @example Get the user's specification.
+      #   user.spec
+      #
+      # @return [ Hash ] The user spec.
+      #
+      # @since 2.0.0
+      def spec
+        { pwd: hashed_password, roles: roles }
+      end
+    end
+  end
+end

data/lib/mongo/auth/user/view.rb

@@ -0,0 +1,102 @@
+# 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 Auth
+    class User
+
+      # Defines behaviour for user related operation on databases.
+      #
+      # @since 2.0.0
+      class View
+        extend Forwardable
+
+        # @return [ Database ] database The view's database.
+        attr_reader :database
+
+        def_delegators :database, :cluster, :read_preference
+        def_delegators :cluster, :next_primary
+
+        # Create a new user in the database.
+        #
+        # @example Create a new read/write user.
+        #   view.create('user', password: 'password', roles: [ 'readWrite' ])
+        #
+        # @param [ Auth::User, String ] user_or_name The user object or user name.
+        # @param [ Hash ] options The user options.
+        #
+        # @return [ Result ] The command response.
+        #
+        # @since 2.0.0
+        def create(user_or_name, options = {})
+          user = generate(user_or_name, options)
+          Operation::Write::CreateUser.new(
+            user: user,
+            db_name: database.name
+          ).execute(next_primary.context)
+        end
+
+        # Initialize the new user view.
+        #
+        # @example Initialize the user view.
+        #   View::User.new(database)
+        #
+        # @param [ Mongo::Database ] database The database the view is for.
+        #
+        # @since 2.0.0
+        def initialize(database)
+          @database = database
+        end
+
+        # Remove a user from the database.
+        #
+        # @example Remove the user from the database.
+        #   view.remove('user')
+        #
+        # @param [ String ] name The user name.
+        #
+        # @return [ Result ] The command response.
+        #
+        # @since 2.0.0
+        def remove(name)
+          Operation::Write::RemoveUser.new(
+            user_name: name,
+            db_name: database.name
+          ).execute(next_primary.context)
+        end
+
+        # Update a user in the database.
+        #
+        # @example Update a user.
+        #   view.update('name', password: 'testpwd')
+        #
+        # @param [ Auth::User, String ] user_or_name The user object or user name.
+        # @param [ Hash ] options The user options.
+        #
+        # @return [ Result ] The response.
+        #
+        # @since 2.0.0
+        def update(user_or_name, options = {})
+
+        end
+
+        private
+
+        def generate(user, options)
+          user.is_a?(String) ? Auth::User.new({ user: user }.merge(options)) : user
+        end
+      end
+    end
+  end
+end

data/lib/mongo/auth/x509.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.
+
+require 'mongo/auth/x509/conversation'
+
+module Mongo
+  module Auth
+
+    # Defines behaviour for x.509 authentication.
+    #
+    # @since 2.0.0
+    class X509
+      include Executable
+
+      # The authentication mechinism string.
+      #
+      # @since 2.0.0
+      MECHANISM = 'MONGODB-X509'.freeze
+
+      # Log the user in on the given connection.
+      #
+      # @example Log the user in.
+      #   user.login(connection)
+      #
+      # @param [ Mongo::Connection ] connection The connection to log into.
+      #   on.
+      #
+      # @return [ Protocol::Reply ] The authentication response.
+      #
+      # @since 2.0.0
+      def login(connection)
+        conversation = Conversation.new(user)
+        conversation.finalize(connection.dispatch([ conversation.start ]))
+      end
+    end
+  end
+end

data/lib/mongo/auth/x509/conversation.rb

@@ -0,0 +1,92 @@
+# Copyright (C) 2014 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 Auth
+    class X509
+
+      # Defines behaviour around a single x.509 conversation between the
+      # client and server.
+      #
+      # @since 2.0.0
+      class Conversation
+
+        # The login message.
+        #
+        # @since 2.0.0
+        LOGIN = { authenticate: 1 }.freeze
+
+        # @return [ Protocol::Reply ] reply The current reply in the
+        #   conversation.
+        attr_reader :reply
+
+        # @return [ User ] user The user for the conversation.
+        attr_reader :user
+
+        # Finalize the x.509 conversation. This is meant to be iterated until
+        # the provided reply indicates the conversation is finished.
+        #
+        # @example Finalize the conversation.
+        #   conversation.finalize(reply)
+        #
+        # @param [ Protocol::Reply ] reply The reply of the previous
+        #   message.
+        #
+        # @return [ Protocol::Query ] The next message to send.
+        #
+        # @since 2.0.0
+        def finalize(reply)
+          validate!(reply)
+        end
+
+        # Start the x.509 conversation. This returns the first message that
+        # needs to be send to the server.
+        #
+        # @example Start the conversation.
+        #   conversation.start
+        #
+        # @return [ Protocol::Query ] The first x.509 conversation message.
+        #
+        # @since 2.0.0
+        def start
+          Protocol::Query.new(
+            Auth::EXTERNAL,
+            Database::COMMAND,
+            LOGIN.merge(user: user.name, mechanism: X509::MECHANISM),
+            limit: -1
+          )
+        end
+
+        # Create the new conversation.
+        #
+        # @example Create the new coversation.
+        #   Conversation.new(user, "admin")
+        #
+        # @param [ Auth::User ] user The user to converse about.
+        #
+        # @since 2.0.0
+        def initialize(user)
+          @user = user
+        end
+
+        private
+
+        def validate!(reply)
+          raise Unauthorized.new(user) if reply.documents[0]['ok'] != 1
+          @reply = reply
+        end
+      end
+    end
+  end
+end

data/lib/mongo/{gridfs.rb → bulk.rb}

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2013 MongoDB, Inc.
+# 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.
@@ -12,7 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mongo/gridfs/grid_ext'
-require 'mongo/gridfs/grid'
-require 'mongo/gridfs/grid_file_system'
-require 'mongo/gridfs/grid_io'
+require 'mongo/bulk/bulk_write'

data/lib/mongo/bulk/bulk_write.rb

@@ -0,0 +1,307 @@
+# 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
+
+  # This semi-public class handles the logic for executing a batch of
+  # operations.
+  #
+  # @since 2.0.0
+  class BulkWrite
+
+    # @return [ Mongo::Collection ] The collection on which this bulk write
+    #   operation will be executed.
+    attr_reader :collection
+
+    # @return [ Array<Hash> ] operations The list of operations.
+    attr_reader :operations
+
+    # @return [ Hash ] options The options.
+    attr_reader :options
+
+    # @return [ Acknowledged, Unacknowledged ] write_concern The write concern.
+    attr_reader :write_concern
+
+    # Initialize the BulkWrite object.
+    #
+    # @example Create an ordered bulk write object.
+    #   BulkWrite.new([
+    #       { insert_one: { x: 1 }},
+    #       { update_one: [{ x: 1 }, { '$set' => { x: 2 }}]}
+    #     ],
+    #     { ordered: true },
+    #     collection
+    #   )
+    #
+    # @example Create an unordered bulk write object.
+    #   BulkWrite.new([
+    #       { insert_one: { x: 1 }},
+    #       { update_one: [{ x: 1 }, { '$set' => { x: 2 }}]}
+    #     ],
+    #     { ordered: false },
+    #     collection
+    #   )
+    #
+    # @param [ Array<Hash> ] operations The operations to execute.
+    # @param [ Hash ] options The options for executing the operations.
+    # @param [ Collection ] collection The collection on which the
+    #   operations will be executed.
+    #
+    # @option options [ String ] :ordered Whether the operations should
+    #   be executed in order.
+    # @option options [ Hash ] :write_concern The write concern to use when
+    #   executing the operations.
+    #
+    # @since 2.0.0
+    def initialize(operations, options, collection)
+      @operations = operations
+      @options = options
+      @collection = collection
+      if options[:write_concern]
+        @write_concern = WriteConcern.get(options[:write_concern])
+      else
+        @write_concern = collection.write_concern
+      end
+    end
+
+    # Is the bulk write operation ordered?
+    #
+    # @example Is the bulk write operation ordered?
+    #   bulk_write.ordered?
+    #
+    # @return [ true, false ] If the bulk write is ordered.
+    #
+    # @since 2.0.0
+    def ordered?
+      @ordered ||= !!options[:ordered]
+    end
+
+    # Execute the bulk write.
+    #
+    # @example execute the bulk write operations.
+    #   bulk.execute
+    #
+    # @return [ Hash ] The result of doing the bulk write.
+    def execute
+      raise Error::EmptyBatch.new if operations.empty?
+
+      @index = -1
+      @ops = []
+
+      operations.each do |operation|
+        operation.each do |name, document|
+          if respond_to?(name, true)
+            send(name, document)
+          else
+            raise Error::InvalidBulkOperation.new(name)
+          end
+        end
+      end
+
+      ops = merge_ops
+
+      replies = []
+      until ops.empty?
+        op = ops.shift
+
+        until op.valid_batch_size?(collection.next_primary.context.max_write_batch_size)
+          ops = op.batch(2) + ops
+          op = ops.shift
+        end
+
+        begin
+          replies << op.execute(collection.next_primary.context)
+          # @todo: No test for max message size.
+        rescue Error::MaxBSONSize, Error::MaxMessageSize => ex
+          raise ex unless op.batchable?
+          ops = op.batch(2) + ops
+        end
+        return make_response!(replies) if stop_executing?(replies.last)
+      end
+      make_response!(replies) if op.write_concern.get_last_error
+    end
+
+    private
+
+    def increment_index
+      @index += 1
+    end
+
+    def valid_doc?(doc)
+      doc.respond_to?(:keys)
+    end
+
+    def update_doc?(doc)
+      !doc.empty? &&
+        doc.respond_to?(:keys) &&
+        doc.keys.first.to_s =~ /^\$/
+    end
+
+    def replacement_doc?(doc)
+      doc.respond_to?(:keys) && doc.keys.all?{|key| key !~ /^\$/}
+    end
+
+    def insert_one(doc)
+      raise Error::InvalidDocument.new unless valid_doc?(doc)
+      spec = { documents: [ doc ],
+               db_name: db_name,
+               coll_name: collection.name,
+               ordered: ordered?,
+               write_concern: write_concern }
+
+      push_op(Mongo::Operation::Write::BulkInsert, spec)
+    end
+
+    def delete_one(selector)
+      raise Error::InvalidDocument.new unless valid_doc?(selector)
+      spec = { deletes: [{ q: selector, limit: 1 }],
+               db_name:   db_name,
+               coll_name: collection.name,
+               ordered: ordered?,
+               write_concern: write_concern }
+
+      push_op(Mongo::Operation::Write::BulkDelete, spec)
+    end
+
+    def delete_many(selector)
+      raise Error::InvalidDocument.new unless valid_doc?(selector)
+      spec = { deletes: [{ q: selector, limit: 0 }],
+               db_name:   db_name,
+               coll_name: collection.name,
+               ordered: ordered?,
+               write_concern: write_concern }
+
+      push_op(Mongo::Operation::Write::BulkDelete, spec)
+    end
+
+    def replace_one(docs)
+      selector = docs[0]
+      replacement = docs[1]
+      upsert = (docs[2] || {})[:upsert]
+      raise ArgumentError unless selector && replacement
+      raise Error::InvalidReplacementDocument.new unless replacement_doc?(replacement)
+      upsert = !!upsert
+      spec = { updates: [{ q: selector,
+                           u: replacement,
+                           multi: false,
+                           upsert: upsert }],
+               db_name:   db_name,
+               coll_name: collection.name,
+               ordered: ordered?,
+               write_concern: write_concern }
+
+      push_op(Mongo::Operation::Write::BulkUpdate, spec)
+    end
+
+    def update_one(docs)
+      upsert = (docs[2] || {})[:upsert]
+      update_one_or_many(docs[0], docs[1], upsert, false)
+    end
+
+    def update_many(docs)
+      upsert = (docs[2] || {})[:upsert]
+      update_one_or_many(docs[0], docs[1], upsert, true)
+    end
+
+    def update_one_or_many(selector, update, upsert, multi)
+      raise ArgumentError unless selector && update
+      raise Error::InvalidUpdateDocument.new unless update_doc?(update)
+      upsert = !!upsert
+      spec = { updates: [{ q: selector,
+                           u: update,
+                           multi: multi,
+                           upsert: upsert }],
+               db_name:   db_name,
+               coll_name: collection.name,
+               ordered: ordered?,
+               write_concern: write_concern }
+
+      push_op(Mongo::Operation::Write::BulkUpdate, spec)
+    end
+
+    def push_op(op_class, spec)
+      spec.merge!(indexes: [ increment_index ])
+      @ops << op_class.send(:new, spec)
+    end
+
+    def merge_ops
+      if ordered?
+        merge_consecutive_ops(@ops)
+      else
+        merge_ops_by_type(@ops)
+      end
+    end
+
+    def merge_consecutive_ops(operations)
+      operations.inject([]) do |merged_ops, op|
+        previous_op = merged_ops.last
+        if previous_op.class == op.class
+          merged_ops.tap do |m|
+            m[m.size - 1] = previous_op.merge!(op)
+          end
+        else
+          merged_ops << op
+        end
+      end
+    end
+
+    def merge_ops_by_type(operations)
+      ops_by_type = operations.inject({}) do |merged_ops, op|
+        if merged_ops[op.class]
+          merged_ops.tap do |m|
+            m[op.class] << op
+          end
+        else
+          merged_ops.tap do |m|
+            m[op.class] = [ op ]
+          end
+        end
+      end
+
+      ops_by_type.keys.inject([]) do |merged_ops, type|
+        merged_ops << merge_consecutive_ops( ops_by_type[ type ] )
+      end.flatten
+    end
+
+    def stop_executing?(result)
+      result && ordered? && !result.successful?
+    end
+
+    def make_response!(results)
+      response = results.reduce({}) do |response, result|
+        write_errors = result.aggregate_write_errors
+        write_concern_errors = result.aggregate_write_concern_errors
+        response.tap do |r|
+          r['nInserted'] = ( r['nInserted'] || 0 ) + result.n_inserted if result.respond_to?(:n_inserted)
+          r['nMatched'] = ( r['nMatched'] || 0 ) + result.n_matched if result.respond_to?(:n_matched)
+          r['nModified'] = ( r['nModified'] || 0 ) + result.n_modified if result.respond_to?(:n_modified) && result.n_modified
+          r['nUpserted'] = ( r['nUpserted'] || 0 ) + result.n_upserted if result.respond_to?(:n_upserted)
+          r['nRemoved'] = ( r['nRemoved'] || 0 ) + result.n_removed if result.respond_to?(:n_removed)
+          r['writeErrors'] = ( r['writeErrors'] || [] ) + write_errors if write_errors
+          r['writeConcernErrors'] = ( r['writeConcernErrors'] || [] ) + write_concern_errors if write_concern_errors
+        end
+      end
+
+      if response['writeErrors'] || response['writeConcernErrors']
+        response.merge!('errmsg' => 'batch item errors occurred')
+        raise Error::BulkWriteFailure.new(response)
+      end
+      response
+    end
+
+    def db_name
+      collection.database.name
+    end
+  end
+end