em-mongo 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc5694302e6f8f0c1a436480b2cf62bd5a6f12f6
-  data.tar.gz: a0a7642623266b5080405ff926cac3dbaab8e91c
+  metadata.gz: 3f0b2c50ede300816de67e11528b73a7d1e337f1
+  data.tar.gz: fbc4c31accd66a72abf2aa1e70397cf4c66fcd6b
 SHA512:
-  metadata.gz: ec15f1759525115e4a888b69c18514f0a30f043dfcf3f9e0b485ec13e21e6e88a28443762688c7111cfe8c7b06bc137a697b0138eff673a7d074386a7e4b45ed
-  data.tar.gz: af2937db963c6a8e6b4997f611027737cf330af79ca7f7822c9efe362e99bac1a786114023463b3199a7b502c6b298fc079df664c477b6fb009803d8c2314ad8
+  metadata.gz: cca17b4be1e91a7d1a787054a49e3205a237eddebd44387134e4085c20337c87f1375e3a6da5bab1b98ab971f8dd3ac56bda6675a147ef0097a5d6150c4cc0e5
+  data.tar.gz: c0f8f8f69281f7046e5a9b91b5c819895224d4fa1edf0e6db620ab901c5ef1a7a0d1ef23f62c51be2706d5ecc7bd79c4433d1c1cc15f179e4b9e5725a96370bd

data/.gitignore

@@ -4,3 +4,5 @@ Gemfile.lock
 vendor
 .rvmrc
 .ruby-version
+.idea
+*~

data/CHANGELOG

@@ -1,3 +1,12 @@
+- 0.6.0
+
+ * add SCRAM-SHA-1 authentication mechanism
+ * add aggregation pipeline
+ * allow passing options to create_collection
+ 
+ * fix usage of em-mongo git repos with bundler
+ * update dependencies to bson <= 2.0, eventmachine >=0.12.10, <= 2.0
+
 - 0.5.1
 
   * fixed bson dependency (do not use 2.x)

data/README.rdoc

@@ -1,6 +1,5 @@
 
-    Em-mongo is no longer being maintained (hasn't been for some time). If you are interested in the commit bit
-    or want to take over the full project, please let me know!
+    Em-mongo needs collaborators to help maintaining this project. If you are interested, please let me know!
 
 = EM-Mongo
 
@@ -122,6 +121,22 @@ In addition to calling your errback if the write fails, you can provide the usua
 
   safe_insert( {:a=>"v"}, :last_error_params => { :fsync => true, :w => 5 } )
 
+
+== Authentication
+At the moment the mechhanisms SCRAM-SHA-1(:scram_sha1) and MONGODB-CR(:mongodb_cr) are supported.
+It works as follows:
+
+    # establish connection and get authentication db
+    connection = EM::Mongo::Connection.new(db_server, port)
+    auth_db = connection.db(db_name)
+    
+    # authentication itself
+    resp = auth_db.authenticate(user,password, :scram_sha1)
+    resp.callback do |success| 
+      do_authenticated #auth successful
+    end
+    resp.errback {|err| auth_failure err} # authentication failed
+
 == Documentation
 
 em-mongo now has some YARD docs. These are mostly ported directly from the mongo-ruby-driver. While they have been updated to reflect em-mongo's async API, there are probably a few errors left over in the translation. Please file an issue or submit a pull request if you notice any inaccuracies. 

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.6.0

data/em-mongo.gemspec

@@ -1,8 +1,10 @@
-version = File.read("VERSION").strip
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'em-mongo/version.rb' #for version
 
 Gem::Specification.new do |s|
   s.name    = 'em-mongo'
-  s.version = version
+  s.version = EventMachine::Mongo::VERSION
 
   s.authors = ['bcg', 'PlasticLizard']
   s.email   = 'brenden.grace@gmail.com'
@@ -23,6 +25,6 @@ Gem::Specification.new do |s|
 
   s.summary = 'An EventMachine driver for MongoDB.'
 
-  s.add_dependency 'eventmachine', ['>= 0.12.10']
-  s.add_dependency  "bson", ["~> 1.9.2"]
+  s.add_dependency 'eventmachine', ['>=0.12.10', '< 2.0']
+  s.add_dependency 'bson',         ['>=1.9.2'  , '< 2.0']
 end

data/examples/legacy.rb

@@ -5,9 +5,16 @@ require 'em-mongo/prev.rb'
 require 'eventmachine'
 
 EM.run do
-  conn = EM::Mongo::Connection.new('localhost')
+  conn = EM::Mongo::Connection.new('localhost',27017)
   db = conn.db('my_database')
   collection = db.collection('my_collection')
+
+  resp = conn.db('admin').authenticate('test','test')
+
+  resp.callback{|response| puts "successfully authenticated #{response}"}
+  resp.errback {|response| puts "error on authentication #{response}"; return}
+
+
   EM.next_tick do
 
     (1..10).each do |i|

data/lib/em-mongo.rb

@@ -5,18 +5,14 @@ rescue LoadError
   require "bson"
 end
 
-module EM::Mongo
 
-  module Version
-    STRING = File.read(File.dirname(__FILE__) + '/../VERSION')
-    MAJOR, MINOR, TINY = STRING.split('.')
-  end
+module EM::Mongo
 
   NAME    = 'em-mongo'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH    = ::File.dirname(LIBPATH) + ::File::SEPARATOR
 end
-
+require File.join(EM::Mongo::LIBPATH, "em-mongo/version")
 require File.join(EM::Mongo::LIBPATH, "em-mongo/conversions")
 require File.join(EM::Mongo::LIBPATH, "em-mongo/support")
 require File.join(EM::Mongo::LIBPATH, "em-mongo/database")
@@ -27,5 +23,7 @@ require File.join(EM::Mongo::LIBPATH, "em-mongo/cursor")
 require File.join(EM::Mongo::LIBPATH, "em-mongo/request_response")
 require File.join(EM::Mongo::LIBPATH, "em-mongo/server_response")
 require File.join(EM::Mongo::LIBPATH, "em-mongo/core_ext")
+require File.join(EM::Mongo::LIBPATH, "em-mongo/auth/Authentication.rb")
+
 
 EMMongo = EM::Mongo

data/lib/em-mongo/auth/Authentication.rb

@@ -0,0 +1,37 @@
+require 'eventmachine'
+
+# interface for all possible authentications
+module EM::Mongo
+  class Authentication
+    include EM::Deferrable
+
+    SYSTEM_COMMAND_COLLECTION = '$cmd'
+
+    # supported AuthMethods (TODO make instantiation (in database.authenticate) dynamic)
+      module AuthMethod
+        SCRAM_SHA1 = :scram_sha1
+        MONGODB_CR = :mongodb_cr
+      end
+
+    def initialize(database)
+      @db = database
+    end
+
+      # Authenticate with the given username and password. Note that mongod
+      # must be started with the --auth option for authentication to be enabled.
+      #
+      # @param [String] username
+      # @param [String] password
+      #
+      # @return [EM::Mongo::RequestResponse] Calls back with +true+ or +false+, indicating success or failure
+      #
+      # @raise [AuthenticationError]
+      #
+      # @core authenticate authenticate-instance_method
+    def authenticate(username, password)
+      r=DefaultDeferrable.new #stub implementation
+      r.fail "not implemented, use a subclass instead"
+      return r
+    end
+  end
+end

data/lib/em-mongo/auth/mongodb_cr.rb

@@ -0,0 +1,52 @@
+require 'openssl'
+require_relative '../support.rb'
+
+module EM::Mongo
+  class MONGODB_CR < Authentication
+
+    MECHANISM = 'MONGODB-CR'.freeze
+
+    def authenticate(username, password)
+      response = RequestResponse.new
+
+      auth_resp = @db.collection(SYSTEM_COMMAND_COLLECTION).first({'getnonce' => 1})
+      auth_resp.callback do |res|
+        if not res or not res['nonce']
+          if res.nil? then response.fail "connection failure"
+          else response.fail "invalid first server response: " + res.to_s
+          end
+        else
+          auth                 = BSON::OrderedHash.new
+          auth['authenticate'] = 1
+          auth['user']         = username
+          auth['nonce']        = res['nonce']
+          auth['key']          = auth_key(username, password, res['nonce'])
+
+          auth_resp2 = @db.collection(SYSTEM_COMMAND_COLLECTION).first(auth)
+          auth_resp2.callback do |res|
+            if Support.ok?(res)
+              response.succeed true
+            else
+              response.fail res
+            end
+          end
+          auth_resp2.errback { |err| response.fail err }
+        end
+      end
+      auth_resp.errback { |err| response.fail err }
+      response
+    end
+
+    # Generate an MD5 for authentication.
+    #
+    # @param [String] username
+    # @param [String] password
+    # @param [String] nonce
+    #
+    # @return [String] a key for db authentication.
+    def auth_key(username, password, nonce)
+      OpenSSL::Digest::MD5.hexdigest("#{nonce}#{username}#{Support.hash_password(username, password)}")
+    end
+
+  end
+end

data/lib/em-mongo/auth/scram.rb

@@ -0,0 +1,237 @@
+require 'openssl'
+require 'bson'
+require 'eventmachine'
+
+require_relative '../support.rb'
+
+module EM::Mongo
+
+  # an RFC 5802 compilant SCRAM(-SHA-1) implementation
+  # for MongoDB-Authentication
+  #
+  # so everything is encapsulated, but the main part (PAYLOAD of messages) is RFC5802 compilant
+  class SCRAM < Authentication
+
+      MECHANISM = 'SCRAM-SHA-1'.freeze
+
+      DIGEST = OpenSSL::Digest::SHA1.new.freeze
+
+      CLIENT_FIRST_MESSAGE = { saslStart: 1, autoAuthorize: 1 }.freeze
+      CLIENT_FINAL_MESSAGE = CLIENT_EMPTY_MESSAGE = { saslContinue: 1 }.freeze
+
+
+      CLIENT_KEY = 'Client Key'.freeze
+      SERVER_KEY = 'Server Key'.freeze
+
+      RNONCE = /r=([^,]*)/.freeze
+      SALT = /s=([^,]*)/.freeze
+      ITERATIONS = /i=(\d+)/.freeze
+      VERIFIER = /v=([^,]*)/.freeze
+      PAYLOAD = 'payload'.freeze
+
+      # @param [String] username
+      # @param [String] password
+      #
+      # @return [EM::Mongo::RequestResponse] Calls back with +true+ or +false+, indicating success or failure
+      #
+      # @raise [AuthenticationError]
+      #
+      # @core authenticate authenticate-instance_method
+      def authenticate(username, password)
+        response = RequestResponse.new
+        
+        #TODO look for fail-fast-ness (strange word!?)
+        #TODO Flatten Hierarchies
+        @username = username
+        @plain_password = password
+
+        gs2_header = 'n,,'
+        client_first_bare = "n=#{@username},r=#{client_nonce}"
+
+        client_first = BSON::Binary.new(gs2_header+client_first_bare) # client_first msg
+        client_first_msg = CLIENT_FIRST_MESSAGE.merge({PAYLOAD=>client_first, mechanism:MECHANISM})
+
+        client_first_resp = @db.collection(EM::Mongo::Database::SYSTEM_COMMAND_COLLECTION).first(client_first_msg) #TODO extract and make easier to understand (e.g. command(first_msg) or sthg like that)
+
+        #server_first_resp #for flattening
+
+        client_first_resp.callback do |res_first|
+          if not is_server_response_valid? res_first
+            response.fail "first server response not valid: " + res_first.to_s
+          else
+            # take the salt & iterations and do the pw-derivation
+            server_first = res_first[PAYLOAD].to_s
+
+            @conversation_id=conv_id = res_first['conversationId']
+
+            combined_nonce = server_first.match(RNONCE)[1] #r= ...
+            salt       =     server_first.match( SALT )[1] #s=... (from server_first)
+            iterations = server_first.match(ITERATIONS)[1].to_i #i=...  ..
+
+            if not combined_nonce.start_with?(client_nonce) # combined_nonce should be client_nonce+server_nonce
+              response.fail "nonce doesn't start with client_nonce: " + res_first.to_s
+            else
+              client_final_wo_proof= "c=#{Base64.strict_encode64(gs2_header)},r=#{combined_nonce}" #c='biws'
+              auth_message = client_first_bare + ',' + server_first + ',' + client_final_wo_proof
+
+              # proof = clientKey XOR clientSig  ## needs to be sent back
+              #
+              # ClientSign  = HMAC(StoredKey, AuthMessage)
+              # StoredKey = H(ClientKey) ## lt. RFC5802 (needs to be verified against ruby-mongo driver impl)
+              # AuthMessage = client_first_bare + ','+server_first+','+client_final_wo_proof
+
+              @salt = salt
+              @iterations = iterations
+              #client_key = client_key()
+
+              @auth_message = auth_message
+              #client_signature = client_signature()
+
+              proof = Base64.strict_encode64(xor(client_key, client_signature))
+              client_final = BSON::Binary.new ( client_final_wo_proof + ",p=#{proof}")
+              client_final_msg = CLIENT_FINAL_MESSAGE.merge({PAYLOAD => client_final, conversationId: conv_id})
+
+              client_final_resp = @db.collection(SYSTEM_COMMAND_COLLECTION).first(client_final_msg)
+              client_final_resp.callback do |res_final|
+                if not is_server_response_valid? res_final
+                  response.fail "Final Server Response not valid " + res_final.to_s
+                else
+                  server_final = res_final[PAYLOAD].to_s # in RFC this equals server_final
+                  verifier = server_final.match(VERIFIER)[1] #r= ...
+                  if verifier and verifier_valid? verifier
+                    handle_server_end(response,conv_id) # will set the response
+                  else
+                    response.fail "verifier #{verifier.nil? ? 'not present':'invalid'} #{res_final}"
+                  end
+                end
+              end
+            client_final_resp.errback { |err| response.fail err }
+            end
+          end
+        end
+        client_first_resp.errback {
+            |err| response.fail err }
+        return response
+      end
+
+
+      # MongoDB handles the end of authentication different than in RFC 5802
+      # it needs at least an additional empty response (this needs to be iterated until res[done]=true 
+      #  (at least it is done so in the official mongo-ruby-drive (at least it is done so in the official mongo-ruby-driver))
+      #   -> recursion (is technically more loop than recursion but here it's one)
+      # 
+      # @param response [EM::Mongo::ResponseRequest] to fail or succeed after completion
+      # @param conv_id   ConversationId to send to the server on each iteration
+    def handle_server_end(response,conv_id) # will set the response
+      client_end = BSON::Binary.new('')
+      client_end_msg = CLIENT_EMPTY_MESSAGE.merge(PAYLOAD=>client_end, conversationId:conv_id)
+      server_end_resp = @db.collection(SYSTEM_COMMAND_COLLECTION).first(client_end_msg)
+      
+      server_end_resp.errback{|err| response.fail err}
+      
+      server_end_resp.callback do |res|
+        if not is_server_response_valid? res
+          response.fail "got invalid response on handling server_end: #{res.nil? ? 'nil' : res}"
+        else
+         if res['done'] == true || res['done'] == 'true'
+           response.succeed true
+         else
+           handle_server_end(response,conv_id) # try it again
+         end
+        end
+      end
+    end
+      
+      # to be valid the response has to
+      #  * be not nil
+      #  * contain at least ['done'], ['ok'], ['payload'], ['conversationId']
+      #  * ['ok'].to_i has to be 1
+      #  * ['conversationId'] has to match the first sent one
+      # @param [BSON::OrderedHash] response the response got from server
+    def is_server_response_valid?(response)
+      if response.nil? then return false; end
+      if response['done'].nil?    or
+         response['ok'].nil?      or
+         response['payload'].nil? or
+         response['conversationId'].nil? then
+        return false;
+      end
+      
+      if not Support.ok? response then return false; end
+      if not @conversation_id.nil? and response['conversationId'] != @conversation_id
+        return false;
+      end
+      
+      true
+    end
+      
+      ## verify the verifier (v=...)
+    def verifier_valid?(verifier)
+      verifier == server_signature
+    end
+
+
+   ### Building blocks
+     # @see http://tools.ietf.org/html/rfc5802#section-2.2
+
+    def hi(password, salt, iterations)
+      OpenSSL::PKCS5.pbkdf2_hmac_sha1(
+        password,
+        Base64.strict_decode64(salt),
+        iterations,
+        DIGEST.size
+       )
+    end
+
+    def hmac(data,key)
+      OpenSSL::HMAC.digest(DIGEST, data, key)
+    end
+
+    # xor for strings
+    def xor(first, second)
+      first.bytes
+        .zip(second.bytes)
+        .map{|(x,y)| (x ^ y).chr}
+        .join('')
+    end
+
+
+    def client_nonce
+        @client_nonce ||= SecureRandom.base64
+    end
+
+    # needs @username, @plain_password defined
+    def hashed_password
+      @hashed_password ||= Support.hash_password(@username, @plain_password).encode("UTF-8")
+    end
+
+    #needs @username, @plain_password, @salt, @iterations defined
+    def salted_password
+      @salted_password ||= hi(hashed_password, @salt, @iterations)
+    end
+    
+    # @see http://tools.ietf.org/html/rfc5802#section-3
+    def client_key 
+      @client_key ||= hmac(salted_password,CLIENT_KEY)
+    end
+      # server_key = hmac(salted_password,"Server Key")
+    def server_key
+      @server_key ||= hmac(salted_password,SERVER_KEY)
+    end
+
+    #needs @username, @plain_password, @salt, @iterations, @auth_message defined
+    def client_signature
+      @client_signature ||= hmac(DIGEST.digest(client_key), @auth_message)
+    end
+
+    # server_signature = B64(hmac(server_key, auth_message)
+   def server_signature
+     @server_signature ||= Base64.strict_encode64(hmac(server_key, @auth_message))
+   end
+
+    class FirstMessage
+      include EM::Deferrable
+
+    end
+  end
+end

data/lib/em-mongo/collection.rb

@@ -401,6 +401,59 @@ module EM::Mongo
       response
     end
 
+    # Perform an aggregation using the aggregation framework on the current collection.
+    # @note Aggregate requires server version >= 2.1.1
+    # @note Field References: Within an expression, field names must be quoted and prefixed by a dollar sign ($).
+    #
+    # @example Define the pipeline as an array of operator hashes:
+    #   coll.aggregate([ {"$project" => {"last_name" => 1, "first_name" => 1 }}, {"$match" => {"last_name" => "Jones"}} ])
+    #
+    # @param [Array] pipeline Should be a single array of pipeline operator hashes.
+    #
+    #   '$project' Reshapes a document stream by including fields, excluding fields, inserting computed fields,
+    #   renaming fields,or creating/populating fields that hold sub-documents.
+    #
+    #   '$match' Query-like interface for filtering documents out of the aggregation pipeline.
+    #
+    #   '$limit' Restricts the number of documents that pass through the pipeline.
+    #
+    #   '$skip' Skips over the specified number of documents and passes the rest along the pipeline.
+    #
+    #   '$unwind' Peels off elements of an array individually, returning one document for each member.
+    #
+    #   '$group' Groups documents for calculating aggregate values.
+    #
+    #   '$sort' Sorts all input documents and returns them to the pipeline in sorted order.
+    #
+    # @option opts [:primary, :secondary] :read Read preference indicating which server to perform this query
+    #  on. See Collection#find for more details.
+    # @option opts [String]  :comment (nil) a comment to include in profiling logs
+    #
+    # @return [Array] An Array with the aggregate command's results.
+    #
+    # @raise MongoArgumentError if operators either aren't supplied or aren't in the correct format.
+    # @raise MongoOperationFailure if the aggregate command fails.
+    #
+    def aggregate(pipeline=nil, opts={})
+      response = RequestResponse.new
+      raise MongoArgumentError, "pipeline must be an array of operators" unless pipeline.class == Array
+      raise MongoArgumentError, "pipeline operators must be hashes" unless pipeline.all? { |op| op.class == Hash }
+
+      hash = BSON::OrderedHash.new
+      hash['aggregate'] = self.name
+      hash['pipeline'] = pipeline
+
+      cmd_resp = db.command(hash)
+      cmd_resp.callback do |resp|
+        response.succeed resp["result"]
+      end
+      cmd_resp.errback do |err|
+        response.fail err
+      end
+
+      response
+    end
+
     # Perform a map-reduce operation on the current collection.
     #
     # @param [String, BSON::Code] map a map function, written in JavaScript.
@@ -809,3 +862,4 @@ module EM::Mongo
 
   end
 end
+

data/lib/em-mongo/connection.rb

@@ -27,7 +27,6 @@ module EM::Mongo
   SPHERE2D   = '2dsphere'
   GEO2D      = '2d'
 
-  DEFAULT_MAX_BSON_SIZE = 4 * 1024 * 1024
 
   class EMConnection < EM::Connection
     MAX_RETRIES = 5

data/lib/em-mongo/database.rb

@@ -1,3 +1,7 @@
+require_relative 'auth/Authentication.rb'
+require_relative 'auth/scram.rb'
+require_relative 'auth/mongodb_cr.rb'
+
 module EM::Mongo
   class Database
 
@@ -83,7 +87,7 @@ module EM::Mongo
     # a cursor which can be iterated over. For each collection, a hash
     # will be yielded containing a 'name' string and, optionally, an 'options' hash.
     #
-    # @param [String] coll_name return info for the specifed collection only.
+    # @param [String] coll_name return info for the specified collection only.
     #
     # @return [EM::Mongo::Cursor]
     def collections_info(coll_name=nil)
@@ -114,7 +118,7 @@ module EM::Mongo
     #   already exists or collection creation fails on the server.
     #
     # @return [EM::Mongo::RequestResponse] Calls back with the new collection
-    def create_collection(name)
+    def create_collection(name, opts = {})
       response = RequestResponse.new
       names_resp = collection_names
       names_resp.callback do |names|
@@ -125,6 +129,7 @@ module EM::Mongo
         # Create a new collection.
         oh = BSON::OrderedHash.new
         oh[:create] = name
+        oh.merge! opts
         cmd_resp = command(oh)
         cmd_resp.callback do |doc|
           if EM::Mongo::Support.ok?(doc)
@@ -302,7 +307,7 @@ module EM::Mongo
       check_response = opts.fetch(:check_response, true)
       raise MongoArgumentError, "command must be given a selector" unless selector.is_a?(Hash) && !selector.empty?
 
-      if selector.keys.length > 1 && RUBY_VERSION < '1.9' && selector.class != BSON::OrderedHash
+      if selector.size > 1 && RUBY_VERSION < '1.9' && selector.class != BSON::OrderedHash
         raise MongoArgumentError, "DB#command requires an OrderedHash when hash contains multiple keys"
       end
 
@@ -331,38 +336,20 @@ module EM::Mongo
     #
     # @param [String] username
     # @param [String] password
+    # @param [Authentication::AuthMethod] auth_method, defaults to MONGODB_CR for downward compatibility
     #
     # @return [EM::Mongo::RequestResponse] Calls back with +true+ or +false+, indicating success or failure
     #
     # @raise [AuthenticationError]
     #
     # @core authenticate authenticate-instance_method
-    def authenticate(username, password)
-      response = RequestResponse.new
-      auth_resp = self.collection(SYSTEM_COMMAND_COLLECTION).first({'getnonce' => 1})
-      auth_resp.callback do |res|
-        if not res or not res['nonce']
-          response.succeed false
-        else
-          auth                 = BSON::OrderedHash.new
-          auth['authenticate'] = 1
-          auth['user']         = username
-          auth['nonce']        = res['nonce']
-          auth['key']          = EM::Mongo::Support.auth_key(username, password, res['nonce'])
-
-          auth_resp2 = self.collection(SYSTEM_COMMAND_COLLECTION).first(auth)
-          auth_resp2.callback do |res|
-            if EM::Mongo::Support.ok?(res)
-              response.succeed true
-            else
-              response.fail res
-            end
-          end
-          auth_resp2.errback { |err| response.fail err }
-        end
-      end
-      auth_resp.errback { |err| response.fail err }
-      response
+    def authenticate(username, password, auth_method=Authentication::AuthMethod::MONGODB_CR)
+      auth = case auth_method
+             when Authentication::AuthMethod::SCRAM_SHA1 then SCRAM.new self
+             when Authentication::AuthMethod::MONGODB_CR then MONGODB_CR.new self
+             else raise AuthenticationError.new("Authentication method #{auth_method} not supported")
+             end
+       return auth.authenticate(username, password)
     end
 
     # Adds a user to this database for use with authentication. If the user already
@@ -372,6 +359,7 @@ module EM::Mongo
     # @param [String] password
     #
     # @return [EM::Mongo::RequestResponse] Calls back with an object representing the user.
+    # #TODO check if that works as it should with SCRAM-SHA1
     def add_user(username, password)
       response = RequestResponse.new
       user_resp = self.collection(SYSTEM_USER_COLLECTION).first({:user => username})

data/lib/em-mongo/support.rb

@@ -16,23 +16,13 @@
 # limitations under the License.
 # ++
 
-require 'digest/md5'
+require 'openssl'
 
 module EM::Mongo
   module Support
     include EM::Mongo::Conversions
     extend self
 
-    # Generate an MD5 for authentication.
-    #
-    # @param [String] username
-    # @param [String] password
-    # @param [String] nonce
-    #
-    # @return [String] a key for db authentication.
-    def auth_key(username, password, nonce)
-      Digest::MD5.hexdigest("#{nonce}#{username}#{hash_password(username, password)}")
-    end
 
     # Return a hashed password for auth.
     #
@@ -41,7 +31,7 @@ module EM::Mongo
     #
     # @return [String]
     def hash_password(username, plaintext)
-      Digest::MD5.hexdigest("#{username}:mongo:#{plaintext}")
+      OpenSSL::Digest::MD5.hexdigest("#{username}:mongo:#{plaintext}")
     end
 
 

data/lib/em-mongo/version.rb

@@ -0,0 +1,11 @@
+module EventMachine
+  module Mongo
+
+    VERSION = File.read(File.expand_path('../../../VERSION',__FILE__)).strip
+
+    module Version
+      STRING = EventMachine::Mongo::VERSION
+      MAJOR, MINOR, TINY = STRING.split('.')
+    end
+  end
+end

data/spec/integration/collection_spec.rb

@@ -395,6 +395,19 @@ describe EMMongo::Collection do
 
   end
 
+  describe "aggregate" do
+    it "should aggregate" do
+      @coll << { :a => 1, :b => 1 }
+      @coll << { :a => 2, :b => 1 }
+      @coll << { :a => 3, :b => 1 }
+
+      resp = @coll.aggregate([{'$project' => {:a => 1}}, {'$group' => {:_id => :counts, :counts => {'$sum' => 1} }}])
+      resp.callback do |doc|
+        doc[0]["counts"].should == 3
+      end
+    end
+  end
+
   describe "mapreduce" do
     it "should map, and then reduce" do
       @conn, @coll = connection_and_collection

data/spec/integration/database_spec.rb

@@ -34,6 +34,18 @@ describe EMMongo::Database do
     end
   end
 
+  it "should create a collection with options" do
+    @conn = EM::Mongo::Connection.new
+    @db = @conn.db
+    @db.create_collection('capped', {:capped => true, :max => 10}).callback do |col|
+      @db.command({:collstats => 'capped'}).callback do |doc|
+        doc['capped'].should == 1
+        doc['max'].should == 10
+        done
+      end
+    end
+  end
+
   it "should drop a collection" do
     @conn = EM::Mongo::Connection.new
     @db = @conn.db

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: em-mongo
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - bcg
@@ -18,6 +18,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.12.10
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -25,20 +28,29 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.12.10
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: bson
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.9.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.9.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: EventMachine driver for MongoDB.
 email: brenden.grace@gmail.com
 executables: []
@@ -56,6 +68,9 @@ files:
 - examples/legacy.rb
 - examples/readme.rb
 - lib/em-mongo.rb
+- lib/em-mongo/auth/Authentication.rb
+- lib/em-mongo/auth/mongodb_cr.rb
+- lib/em-mongo/auth/scram.rb
 - lib/em-mongo/collection.rb
 - lib/em-mongo/connection.rb
 - lib/em-mongo/conversions.rb
@@ -67,6 +82,7 @@ files:
 - lib/em-mongo/request_response.rb
 - lib/em-mongo/server_response.rb
 - lib/em-mongo/support.rb
+- lib/em-mongo/version.rb
 - spec/gem/Gemfile
 - spec/gem/bundler.rb
 - spec/gem/rubygems.rb
@@ -97,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: em-mongo
-rubygems_version: 2.2.0
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: An EventMachine driver for MongoDB.