monga 0.0.2 → 0.0.3

data/.gitignore

@@ -11,6 +11,7 @@ doc/
 lib/bundler/man
 pkg
 rdoc
+benchmarks
 spec/reports
 test/tmp
 test/version_tmp

data/.travis.yml

@@ -0,0 +1 @@
+services: mongodb

data/README.md

@@ -1,11 +1,66 @@
+[![Build Status](https://travis-ci.org/fl00r/monga.png?branch=master)](https://travis-ci.org/fl00r/monga)
+
 # Monga
 
-[MongoDB](http://www.mongodb.org/) Ruby Client on [EventMachine](https://github.com/eventmachine/eventmachine).
+[MongoDB](http://www.mongodb.org/) Ruby Client on [EventMachine](https://github.com/eventmachine/eventmachine). Also it supports synchrony mode ([em-synchrony](https://github.com/igrigorik/em-synchrony)).
 
 This client is under development. You can try [em-mongo](https://github.com/bcg/em-mongo).
 
 Client supports MongoDB 2.4. Some features won't work in lower versions.
 
+# Introduction
+
+Monga supports asynchronous (over EventMachine), synchronous (Fibers) and blocking (TCPSocket) interfaces.
+
+API will be familiar to Node.js developers: it returns `err, response` into callback.
+
+```ruby
+# Async mode
+EM.run do
+  connection = Monga::Client.new(host: "127.0.0.1", port: 27017, type: :em)
+  db = connection["dbTest"]
+  collection = db["testCollection"]
+  collection.safe_insert(title: "Test") do |err, resp|
+    if err
+      puts "Error happend: #{err.message}"
+    else
+      puts "saved!"
+      collection.find.all do |err, docs|
+        if err 
+          puts "Error happend: #{err.message}"
+        else
+          puts "Docs fetched: #{docs.size}"
+        end
+        EM.stop
+      end
+    end
+  end
+end
+
+# Sync mode
+EM.synchrony do
+  connection = Monga::Client.new(host: "127.0.0.1", port: 27017, type: :sync)
+  db = connection["dbTest"]
+  collection = db["testCollection"]
+  collection.safe_insert(title: "Test")
+  puts "saved"
+  docs = collection.find.all
+  puts "Docs fetched: #{docs.size}"
+  EM.stop
+end
+
+# Blocking mode
+connection = Monga::Client.new(host: "127.0.0.1", port: 27017, type: :block)
+db = connection["dbTest"]
+collection = db["testCollection"]
+collection.safe_insert(title: "Test")
+puts "saved"
+docs = collection.find.all
+puts "Docs fetched: #{docs.size}"
+```
+
+README and WIKI is going to be written.
+
 ## To Do List
 
 * [ ] Write a Wiki
@@ -46,13 +101,14 @@ Client supports MongoDB 2.4. Some features won't work in lower versions.
 * [ ] check maxBsonSize / validate
 * [x] cmd
 * [x] eval
-* [ ] where
+* [ ] aggregation
+* [ ] gridfs?
 
 ### Collection
 * QUERY_OP
     * [x] find
     * [x] find_one (first)
-    * [ ] sorting
+    * [x] sorting
 * INSERT_OP
     * [x] insert (single)
     * [x] insert (batch)

data/lib/monga/client.rb

@@ -1,8 +1,53 @@
-require File.expand_path("../clients/client", __FILE__)
-require File.expand_path("../clients/replica_set_client", __FILE__)
-require File.expand_path("../clients/master_slave_client", __FILE__)
 module Monga
-  Client = Monga::Clients::Client
-  ReplicaSetClient = Monga::Clients::ReplicaSetClient
-  MasterSlaveClient = Monga::Clients::MasterSlaveClient
+  class Client
+    extend Forwardable
+
+    def_delegators :@client, :aquire_connection
+
+    VALID_OPTS = [:host, :port, :server, :type, :pool_size, :servers, :read_pref, :timeout]
+
+    # Following options are allowed
+    # * host - host of server to connect, default 127.0.0.1
+    # * port - port of server to connect, default 27017
+    # * server - host:port of server to connect (you can pass server or host/port pair)
+    # * type - :em/:sync/:block - socket type, asynchronouse on EventMachine, Fibered or blocking TCP
+    # * pool_size - connection pool size
+    # * servers - array of server names (host:port) to connect or array of hashes host/port (for Replica Set connection)
+    # * read_pref - read preference for Replica Set (:primary, :secondary, :primary_preferred, :secondary_preferred), default :primary
+    # * timeout - client will try to reconnect till timout (in seconds) if connection failed, default 10 seconds
+    def initialize(opts = {})
+      @opts = opts
+      @opts[:type] ||= :block
+
+      sanitize_opts!
+      create_client
+    end
+
+    # Choose database by it's name
+    def get_database(db_name)
+      Monga::Database.new(@client, db_name)
+    end
+    alias :[] :get_database
+
+    private
+
+    # Validates incoming options to prevent missunderstanding
+    def sanitize_opts!
+      @opts.each_key do |key|
+        unless VALID_OPTS.include? key
+          raise Monga::Exceptions::InvalidClientOption, "`#{key}` is invalid option for Client. Following options are valid: #{VALID_OPTS * ', '}"
+        end
+      end
+    end
+
+    # If servers options is defined it will create ReplicaSetClient,
+    # otherwise SingleInstanceClient will be created
+    def create_client
+      @client = if @opts[:servers]
+        Monga::Clients::ReplicaSetClient.new(@opts)
+      else
+        Monga::Clients::SingleInstanceClient.new(@opts)
+      end
+    end
+  end
 end

data/lib/monga/clients/master_slave_client.rb

@@ -1,5 +0,0 @@
-module Monga::Clients
-  class MasterSlaveClient
-
-  end
-end

data/lib/monga/clients/replica_set_client.rb

@@ -1,45 +1,35 @@
-# How it works
-# Replica Set tries to establish connections to all passed servers.
-# Till no connection established it queues al queries inside it's
-
 module Monga::Clients
   class ReplicaSetClient
-    class ProxyConnection
-      include EM::Deferrable
-      def initialize(client)
-        @client = client
-      end
-
-      def send_command(msg, request_id=nil, &cb)
-        callback do
-          connection = @client.aquire_connection
-          connection.send_command(msg, request_id, &cb)
+    attr_reader :read_pref, :timeout, :clients
+
+    # ReplicaSetClient creates SingleInstanceClient to each server.
+    # Accepts
+    # * servers - you could pas them as a array of servers (['1.1.1.1:27017', '1.1.1.2:27017']), or as a array of hashes: ([{host: '1.1.1.1', port: 27017}, {host: '1.1.1.2', port: 27017}])
+    # * read_pref - read preferrence (:primary, :primary_preferred, :secondary, :secondary_preferred)
+    # * pool_size - connection pool size to each server
+    # * type - connection type (:em/:sync/:block)
+    def initialize(opts)
+      @timeout = opts[:timeout]
+      @read_pref = opts[:read_pref] || :primary
+
+      servers = opts.delete :servers
+      @clients = servers.map do |server|
+        case server
+        when Hash
+          Monga::Clients::SingleInstanceClient.new(opts.merge(server))
+        when String
+          h, p = server.split(":")
+          o = { host: h, port: p.to_i }
+          Monga::Clients::SingleInstanceClient.new(opts.merge(o))
         end
       end
-    end
-
-    include EM::Deferrable
-
-    attr_reader :servers, :clients
-
-    def initialize(opts = {})
-      @read_pref = opts.delete(:read_pref) || :primary
-      @servers = opts.delete(:servers)
-      raise ArgumentError, "servers option is not passed or empty" if @servers.empty?
-
-      @clients = @servers.map do |server|
-        Monga::Client.new(server.merge(opts))
-      end
-
-      @proxy_connection = ProxyConnection.new(self)
-    end
 
-    def [](db_name)
-      Monga::Database.new(self, db_name)
+      @proxy_connection = Monga::Connection.proxy_connection_class(opts[:type]).new(self)
     end
 
+    # Aquires connection due to read_pref option
     def aquire_connection
-      server ||= case @read_pref
+      server = case @read_pref
       when :primary
         primary
       when :secondary
@@ -49,53 +39,24 @@ module Monga::Clients
       when :secondary_preferred
         secondary || primary
       when :nearest
-        fail "unimplemented read_pref mode"
+        raise ArgumentError, "nearest read preferrence is not implemented yet"
       else
-        fail "read_pref is undefined"
-      end
-
-
-      if server
-        if @deferred_status != :succeeded
-          set_deferred_status :succeeded 
-          @proxy_connection.set_deferred_status :succeeded
-        end
-      else
-        if @deferred_status == :succeeded
-          set_deferred_status nil
-          @proxy_connection.set_deferred_status nil
-        end
+        raise ArgumentError, "`#{@read_pref}` is not valid read preferrence, use :primary, :primary_preferred, :secondary, or :secondary_preferred"
       end
 
       server || @proxy_connection
     end
 
+    # Fetch primary server
     def primary
-      prim = @clients.detect{ |c| c.primary? && c.connected? }
-      unless prim
-        find_primary!
-      end
-      prim
+      pr = @clients.detect{ |c| c.primary? && c.connected? }
+      pr.aquire_connection if pr
     end
 
+    # Fetch secondary server
     def secondary
-      @clients.select{ |c| !c.primary? && c.connected? }.sample
-    end
-
-    def find_primary!
-      unless @pending_primary
-        @pending_primary = true
-        @clients.each{ |c| c.find_primary! }
-        EM.add_timer(0.1) do
-          if primary
-            aquire_connection
-            @pending_primary = false
-          else
-            @pending_primary = false
-            find_primary!
-          end
-        end
-      end
+      sc = @clients.select{ |c| c.secondary? && c.connected? }.sample
+      sc.aquire_connection if sc
     end
   end
 end

data/lib/monga/clients/single_instance_client.rb

@@ -0,0 +1,53 @@
+module Monga::Clients
+  class SingleInstanceClient
+    # Status will inform Replica Set client of current client's status 
+    # primary/secondary/nil
+    attr_reader :status
+
+    def initialize(opts)
+      pool_size = opts[:pool_size]
+      if pool_size && pool_size > 1
+        @connection_pool = Monga::ConnectionPool.new(opts)
+      else
+        @connection = Monga::Connection.new(opts)
+      end
+    end
+
+    # If single connection then return it.
+    # If connection pool then aquire connection from pool.
+    # If connection is not connected, then status will be setted to nil.
+    def aquire_connection
+      conn = if @connection_pool
+        @connection_pool.aquire_connection
+      else
+        @connection
+      end
+      @status = nil unless conn.connected?
+      conn
+    end
+
+    def connected?
+      aquire_connection.connected?
+    end
+
+    # Check status of connection.
+    # If ReplicaSetClient can't find connection with read_pref status 
+    # it will send foce_status! to all clients while timout happend
+    # or while preferred status will be returned
+    def force_status!
+      conn = aquire_connection
+      conn.is_master? do |status|
+        @status = status
+        yield(@status) if block_given?
+      end
+    end
+
+    def primary?
+      @status == :primary
+    end
+
+    def secondary?
+      @status == :secondary
+    end
+  end
+end

data/lib/monga/collection.rb

@@ -1,40 +1,50 @@
 module Monga
   class Collection
-    attr_reader :name, :db
+    attr_reader :collection_name
 
-    def initialize(db, name)
+    def initialize(db, collection_name)
       @db = db
-      @name = name
+      @collection_name = collection_name
     end
 
-    def query(query = {}, fields = {}, opts = {})
+    # Querying database. It returns cursor.
+    # Alias to collection#query is colleciotn#find
+    #
+    #   cursor = collection.find(title: "Madonna")
+    #   # choose fields to return
+    #   cursor = collection.find({ title: "Madonna" }, { track: 1 })
+    #   # get all documents
+    #   cursor.all{ |err, docs| docs.each{ |doc| puts doc } }
+    #
+    def query(query = {}, selector = {}, opts = {})
       options = {}
       options[:query] = query
-      options[:fields] = fields
-      options.merge! opts
-      Monga::Miner.new(db, name, options)
+      options[:selector] = selector
+      options.merge!(opts)
+      Monga::Cursor.create(connection, db_name, collection_name, options)
     end
     alias :find :query
 
-    def find_one(query = {}, fields = {}, opts = {})
+    def find_one(query = {}, selector = {}, opts = {})
       options = {}
       options[:query] = query
-      options[:fields] = fields
-      options.merge! opts
-
-      Monga::Response.surround do |resp|
-        req = Monga::Miner.new(db, name, options).limit(1)
-        req.callback{ |data| resp.succeed data.first }
-        req.errback{ |err| resp.fail err }
+      options[:selector] = selector
+      options.merge!(opts)
+      Monga::Cursor.create(connection, db_name, collection_name, options).first do |err, resp|
+        if block_given?
+          yield(err, resp)
+        else
+          err ? raise(err) : resp
+        end
       end
     end
     alias :first :find_one
 
-    def insert(documents, opts = {})
+    def insert(document, opts = {})
       options = {}
-      options[:documents] = documents
+      options[:documents] = document
       options.merge!(opts)
-      Monga::Requests::Insert.new(@db, @name, options).perform
+      Monga::Protocol::Insert.new(connection, db_name, collection_name, options).perform
     end
 
     def update(query = {}, update = {}, flags = {})
@@ -42,67 +52,118 @@ module Monga
       options[:query] = query
       options[:update] = update
       options.merge!(flags)
-      Monga::Requests::Update.new(@db, @name, options).perform
+      Monga::Protocol::Update.new(connection, db_name, collection_name, options).perform
     end
 
     def delete(query = {}, opts = {})
       options = {}
       options[:query] = query
       options.merge!(opts)
-      Monga::Requests::Delete.new(@db, @name, options).perform
+      Monga::Protocol::Delete.new(connection, db_name, collection_name, options).perform
     end
     alias :remove :delete
 
     def ensure_index(keys, opts={})
       doc = {}
-      doc.merge!(opts)
+      doc[:key] = keys
       # Read docs about naming
       doc[:name] ||= keys.to_a.flatten * "_"
-      doc[:key] = keys
-      doc[:ns] = "#{db.name}.#{name}"
-      Monga::Requests::Insert.new(@db, "system.indexes", {documents: doc}).perform
+      doc[:ns] = "#{db_name}.#{collection_name}"
+      doc.merge!(opts)
+      Monga::Protocol::Insert.new(connection, db_name, "system.indexes", {documents: doc}).perform
     end
 
     def drop_index(indexes)
-      @db.drop_indexes(@name, indexes)
+      @db.drop_indexes(@collection_name, indexes) do |err, resp|
+        if block_given?
+          yield(err, resp)
+        else
+          raise err if err
+          return resp
+        end
+      end
     end
 
     def drop_indexes
-      @db.drop_indexes(@name, "*")
+      @db.drop_indexes(@collection_name, "*") do |err, resp|
+        if block_given?
+          yield(err, resp)
+        else
+          raise err if err
+          return resp
+        end
+      end
     end
 
     def get_indexes
-      Monga::Miner.new(@db, "system.indexes")
+      Monga::Cursor.create(connection, db_name, "system.indexes").all do |err, resp|
+        if block_given?
+          yield(err, resp)
+        else
+          raise err if err
+          return resp
+        end
+      end
     end
 
     def drop
-      @db.drop_collection(@name)
+      @db.drop_collection(@collection_name) do |err, resp|
+        if block_given?
+          yield(err, resp)
+        else
+          raise err if err
+          return resp
+        end
+      end
     end
 
-    def count
-      @db.count(@name)
+    # You could pass query/limit/skip options
+    #
+    #    count(query: {artist: "Madonna"}, limit: 10, skip: 0)
+    #
+    def count(opts = {})
+      @db.count(@collection_name, opts) do |err, resp|
+        if block_given?
+          yield(err, resp)
+        else
+          raise err if err
+          return resp
+        end
+      end
     end
 
     # Safe methods
     [:update, :insert, :delete, :remove, :ensure_index].each do |meth|
       class_eval <<-EOS
         def safe_#{meth}(*args)
-          safe do
-            #{meth}(*args)
+          last = args.last
+          opts = {}
+          if Hash === last
+            [ :j, :w, :fsync, :wtimeout ].each do |k|
+              v = last.delete k
+              opts[k] = v if v
+            end
+          end
+          req = #{meth}(*args)
+          @db.raise_last_error(req.connection, opts) do |err, resp|
+            if block_given?
+              yield(err, resp)
+            else
+              err ? raise(err) : resp
+            end
           end
         end
       EOS
     end
 
-    def safe
-      response = Monga::Response.new
-      request_id = yield
-      req = @db.get_last_error
-      req.callback do |data|
-        response.succeed(request_id)
-      end
-      req.errback{ |err| response.fail(err) }
-      response
+    private
+
+    def connection
+      @db.client.aquire_connection
+    end
+
+    def db_name
+      @db.name
     end
   end
 end

data/lib/monga/connection.rb

@@ -1,23 +1,48 @@
-require File.expand_path("../connections/em_connection", __FILE__)
-require File.expand_path("../connections/primary", __FILE__)
-require File.expand_path("../connections/secondary", __FILE__)
-
 module Monga
   class Connection
     extend Forwardable
 
-    def_delegators :@connection, :connected?, :reconnect, :responses, :send_command, :master?, :is_master?, :host, :port
+    def_delegators :@connection, :connected?, :responses, :send_command, :is_master?, :port
+
+    attr_reader :type
 
-    CONNECTION_TYPES = {
-      default: Monga::Connections::EMConnection,
-      primary: Monga::Connections::Primary,
-      secondary: Monga::Connections::Secondary,
+    CONNECTIONS = {
+      em: Monga::Connections::EMConnection,
+      sync: Monga::Connections::FiberedConnection,
+      block: Monga::Connections::TCPConnection,
     }
+    PROXY_CONNECTIONS = {
+      em: Monga::Connections::EMProxyConnection,
+      sync: Monga::Connections::FiberedProxyConnection,
+      block: Monga::Connections::ProxyConnection,
+    }
+
+    # Simple connection wrapper.
+    # Accpets 
+    # * host/port or server
+    # * connection type
+    # * timeout
+    def initialize(opts)
+      @type = opts[:type]
+
+      host, port = if server = opts[:server]
+        h, p = server.split(":")
+        [h, p.to_i]
+      else
+        h = opts[:host] || Monga::DEFAULT_HOST
+        p = opts[:port] || Monga::DEFAULT_PORT
+        [h, p]
+      end
+      timeout = opts[:timeout]
+
+      conn_type = CONNECTIONS[@type]
+      raise Monga::Exceptions::WrongConnectionType, "Connection type `#{opts[:type]}` is non valid, choose one of: :em, :sync, or :block" unless conn_type
+      @connection = conn_type.connect(host, port, timeout)
+    end
 
-    def initialize(opts={})
-      conn_type = opts.delete(:connection_type) || :default
-      conn_class = CONNECTION_TYPES[conn_type]
-      @connection = conn_class.connect(opts)
+    # Returns name of proxy_connection class
+    def self.proxy_connection_class(type)
+      PROXY_CONNECTIONS[type]
     end
   end
 end

data/lib/monga/connection_pool.rb

@@ -1,20 +1,18 @@
 module Monga
-  class ConnectionPool < Monga::Connection
-    extend Forwardable
-
-    def_delegators :aquire_connection, :send_command
-
+  class ConnectionPool
     attr_reader :connections
-
-    def initialize(opts={})
-      @connections = []
+    
+    def initialize(opts)
       pool_size = opts.delete :pool_size
 
+      @connections = []
       pool_size.times do
         @connections << Monga::Connection.new(opts)
       end
     end
 
+    # Aquires random connection with min waiting responses among connected.
+    # Otherwise return random disconnected one.
     def aquire_connection
       connected = @connections.select(&:connected?)
       if connected.any?
@@ -25,14 +23,5 @@ module Monga
         @connections.sample
       end
     end
-
-    def primary?
-      conn = aquire_connection
-      conn ? conn.master? : false
-    end
-
-    def connected?
-      @connections.any?(&:connected?)
-    end
   end
 end