mongo 1.12.5 → 2.0.0

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/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/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.rb

@@ -0,0 +1,108 @@
+# 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/executable'
+require 'mongo/auth/cr'
+require 'mongo/auth/ldap'
+require 'mongo/auth/scram'
+require 'mongo/auth/user'
+require 'mongo/auth/x509'
+require 'mongo/auth/roles'
+
+module Mongo
+
+  # This namespace contains all authentication related behaviour.
+  #
+  # @since 2.0.0
+  module Auth
+    extend self
+
+    # The external database name.
+    #
+    # @since 2.0.0
+    EXTERNAL = '$external'.freeze
+
+    # Constant for the nonce command.
+    #
+    # @since 2.0.0
+    GET_NONCE = { getnonce: 1 }.freeze
+
+    # Constant for the nonce field.
+    #
+    # @since 2.0.0
+    NONCE = 'nonce'.freeze
+
+    # Map the symbols parsed from the URI connection string to strategies.
+    #
+    # @since 2.0.0
+    SOURCES = {
+      mongodb_cr: CR,
+      mongodb_x509: X509,
+      plain: LDAP,
+      scram: SCRAM
+    }
+
+    # Get the authorization strategy for the provided auth mechanism.
+    #
+    # @example Get the strategy.
+    #   Auth.get(user)
+    #
+    # @param [ Auth::User ] user The user object.
+    #
+    # @return [ CR, X509, LDAP, Kerberos ] The auth strategy.
+    #
+    # @since 2.0.0
+    def get(user)
+      mechanism = user.mechanism
+      raise InvalidMechanism.new(mechanism) if !SOURCES.has_key?(mechanism)
+      SOURCES[mechanism].new(user)
+    end
+
+    # Raised when trying to get an invalid authorization mechanism.
+    #
+    # @since 2.0.0
+    class InvalidMechanism < RuntimeError
+
+      # Instantiate the new error.
+      #
+      # @example Instantiate the error.
+      #   Mongo::Auth::InvalidMechanism.new(:test)
+      #
+      # @param [ Symbol ] mechanism The provided mechanism.
+      #
+      # @since 2.0.0
+      def initialize(mechanism)
+        super("#{mechanism.inspect} is invalid, please use mongodb_cr, mongodb_x509, gssapi or plain.")
+      end
+    end
+
+    # Raised when a user is not authorized on a database.
+    #
+    # @since 2.0.0
+    class Unauthorized < RuntimeError
+
+      # Instantiate the new error.
+      #
+      # @example Instantiate the error.
+      #   Mongo::Auth::Unauthorized.new(user)
+      #
+      # @param [ Mongo::Auth::User ] user The unauthorized user.
+      #
+      # @since 2.0.0
+      def initialize(user)
+        super("User #{user.name} is not authorized to access #{user.database}.")
+      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