monga 0.0.2 → 0.0.3

data/lib/monga/connections/buffer.rb

@@ -0,0 +1,33 @@
+module Monga::Connections
+  class Buffer
+    include Enumerable
+
+    attr_reader :buffer
+
+    def initialize
+      @buffer = ""
+      @positon = 0
+    end
+
+    def append(data)
+      @buffer += data
+    end
+
+    def each
+      while true
+        size = @buffer.size
+        if size > Monga::HEADER_SIZE
+          msg_length = @buffer[0, 4].unpack("L").first
+          if msg_length && size >= msg_length
+            data = @buffer.slice!(0, msg_length)
+            yield data.unpack("LLLLLQLLa*")
+          else
+            break
+          end
+        else
+          break
+        end
+      end
+    end
+  end
+end

data/lib/monga/connections/em_connection.rb

@@ -2,61 +2,29 @@ module Monga::Connections
   class EMConnection < EM::Connection
     include EM::Deferrable
 
-    class Buffer
-      include Enumerable
-
-      attr_reader :buffer
-
-      def initialize
-        @buffer = ""
-        @positon = 0
-      end
-
-      def append(data)
-        @buffer += data
-      end
-
-      def each
-        while true
-          size = @buffer.size
-          if size > Monga::HEADER_SIZE
-            msg_length = @buffer[0, 4].unpack("L").first
-            if msg_length && size >= msg_length
-              data = @buffer.slice!(0, msg_length)
-              yield data.unpack("LLLLLQLLa*")
-            else
-              break
-            end
-          else
-            break
-          end
-        end
-      end
-    end
-
     attr_reader :responses, :host, :port
 
-    def initialize(opts = {})
-      @host = opts[:host]
-      @port = opts[:port]
+    def initialize(host, port, timeout)
+      @host = host
+      @port = port
+      @timeout = timeout
       @reactor_running = true
       @responses = {}
     end
 
-    def self.connect(opts = {})
-      host = opts[:host] ||= Monga::DEFAULT_HOST
-      port = opts[:port] ||= Monga::DEFAULT_PORT
-
-      EM.connect(host, port, self, opts)
+    def self.connect(host, port, timeout)
+      EM.connect(host, port, self, host, port, timeout)
     end
 
     def send_command(msg, request_id=nil, &cb)
+      # Reconnect is a hack for testing.
+      # We are stopping EvenMachine for each test.
+      # This hack reconnects to Mongo on first query
       reconnect unless @connected
 
       callback do
         send_data msg
       end
-
       @responses[request_id] = cb if cb
     end
 
@@ -99,22 +67,21 @@ module Monga::Connections
       end
     end
 
-    def force_reconnect(host, port)
-      @connected = false
-      @host = host
-      @port = port
-    end
-
     def connected?
-      EM.schedule { reconnect } unless @reactor_running
+      reconnect unless @reactor_running
       @connected || false
     end
 
     def unbind
+      @connected = false
       Monga.logger.debug("Lost connection #{@host}:#{@port}")
 
-      @responses.each{ |k, cb| cb.call(Monga::Exceptions::LostConnection.new("Mongo has lost connection"))}
-      @connected = false
+      @responses.keys.each do |k|
+        cb = @responses.delete k
+        err = Monga::Exceptions::Disconnected.new("Disconnected from #{@host}:#{@port}")
+        cb.call(err)
+      end
+
       @primary = false
       @pending_for_reconnect = false
       set_deferred_status(nil)
@@ -129,21 +96,23 @@ module Monga::Connections
       @reactor_running = false
     end
 
-    def master?
+    def primary?
       @primary || false
     end
 
-    def is_master?(client)
-      db = client["admin"]
-      req = Monga::Requests::Query.new(db, "$cmd", query: {"isMaster" => 1}, limit: 1)
+    def is_master?
+      reconnect unless @connected
+      req = Monga::Protocol::Query.new(self, "admin", "$cmd", query: {"isMaster" => 1}, limit: 1)
       command = req.command
       request_id = req.request_id
       @responses[request_id] = proc do |data|
-        resp = req.parse_response(data)
-        if Exception === resp
+        err, resp = req.parse_response(data)
+        if Exception === err
           @primary = false
+          yield nil
         else
           @primary = resp.last.first["ismaster"]
+          yield @primary ? :primary : :secondary
         end
       end
       send_data command

data/lib/monga/connections/em_proxy_connection.rb

@@ -0,0 +1,80 @@
+module Monga::Connections
+  # ProxyConnection accepts requests when ReplicaSetClient didn't know where to send requests.
+  # I.E. when client is just initialized here is no any established connections,
+  # so client waits for the connection ready to accept requests.
+  # Also, when primary is down it will collect request while nodes are voting.
+  # Importaint to say, that requests will be stored in this object only for `timeout` period.
+  class EMProxyConnection
+    # Pause while searching server in seconds
+    WAIT = 0.1
+    
+    def initialize(client)
+      @client = client
+      @timeout = @client.timeout
+      @requests = {}
+    end
+
+    # If timeout is defined then collect request and start timout.
+    # If timout is not defined or zero then return exception.
+    def send_command(msg, request_id = nil, &cb)
+      if @timeout && @timeout > 0 
+        @requests[request_id] = [msg, cb] if cb
+        set_timeout
+        find_server!
+      else
+        error = Monga::Exceptions::Disconnected.new "Can't find appropriate server (all disconnected)"
+        cb.call(error) if cb
+      end
+    end
+
+    # If timeout happend send exception to all collected requests.
+    def set_timeout
+      unless @pending_timeout
+        @pending_timeout = true
+        EM.add_timer(@timeout) do
+          @pending_timeout = false
+          @requests.keys.each do |request_id|
+            msg, cb = @requests.delete request_id
+            error = Monga::Exceptions::Disconnected.new "Can't find appropriate server (all disconnected)"
+            cb.call(error)
+          end
+        end
+      end
+    end
+
+    # Find server unless server is found
+    def find_server!
+      if !@pending_server && @pending_timeout
+        @pending_server = true
+        _count = 0
+        @client.clients.each do |client|
+          client.force_status! do |status|
+            if status == :primary && [:primary, :primary_preferred, :secondary_preferred].include?(@client.read_pref)
+              @pending_server = false
+              server_found!
+            elsif status == :secondary && [:secondary, :primary_preferred, :secondary_preferred].include?(@client.read_pref)
+              @pending_server = false
+              server_found!
+            else
+              EM.add_timer(WAIT) do
+                EM.next_tick do
+                  @pending_server = false if (_count +=1) == @client.clients.size
+                  find_server!
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # YEEEHA! Send all collected requests back to client
+      def server_found!
+        @pending_timeout = false
+        @requests.keys.each do |request_id|
+          msg, blk = @requests.delete request_id
+          @client.aquire_connection.send_command(msg, request_id, &blk)
+        end
+      end
+    end
+  end
+end

data/lib/monga/connections/fibered_connection.rb

@@ -0,0 +1,26 @@
+require 'fiber'
+
+class Fiber
+  alias :call :resume
+end
+
+module Monga::Connections
+  class FiberedConnection < EMConnection
+    def send_command(msg, request_id=nil, &cb)
+      fib = Fiber.current
+      reconnect unless @connected
+
+      callback do
+        send_data msg
+      end
+
+      if cb
+        reconnect unless @connected
+        @responses[request_id] = fib
+        res = Fiber.yield
+        raise res if Exception === res
+        cb.call(res)
+      end
+    end
+  end
+end

data/lib/monga/connections/fibered_proxy_connection.rb

@@ -0,0 +1,23 @@
+module Monga::Connections
+  class FiberedProxyConnection < EMProxyConnection
+    def send_command(msg, request_id = nil, &cb)
+      if @timeout && @timeout > 0
+        @requests[request_id] = [msg, @fib]
+        @fib = Fiber.current
+        set_timeout
+        find_server!
+        res = Fiber.yield
+        @requests.delete(request_id)
+        raise res if Exception === res
+        @client.aquire_connection.send_command(msg, request_id, &cb)
+      else
+        error = Monga::Exceptions::Disconnected.new "Can't find appropriate server (all disconnected)"
+        cb.call(error) if cb
+      end
+    end
+
+    def server_found!
+      @fib.resume
+    end
+  end
+end

data/lib/monga/connections/proxy_connection.rb

@@ -0,0 +1,4 @@
+module Monga::Connections
+  class ProxyConnection
+  end
+end

data/lib/monga/connections/tcp_connection.rb

@@ -0,0 +1,57 @@
+require 'socket'
+
+# Currently blocking mode is very poor.
+# It is working as is.
+# Going to support reconnecting and timouts later.
+# Use it for tests and prototyping. Not the best choice for production.
+
+module Monga::Connections
+  class TCPConnection
+    def self.connect(host, port, timeout)
+      new(host, port, timeout)
+    end
+
+    def initialize(host, port, timeout)
+      @host, @port, @timout = host, port, timeout
+      @connected = true
+      @buffer = Buffer.new
+    end
+
+    def connected?
+      @connected
+    end
+
+    def socket
+      @socket ||= TCPSocket.new(@host, @port)
+    end
+
+    # Fake answer, as far as we are blocking
+    def responses
+      0
+    end
+
+    def send_command(msg, request_id=nil, &cb)
+      socket.send msg.to_s, 0
+      if cb
+        length = socket.read(4)
+        raise Errno::ECONNREFUSED, "Socket returns nothing like it would be closed." unless length
+        @buffer.append(length)
+        l = length.unpack("L").first
+        rest = socket.read(l-4)
+        @buffer.append(rest)
+        @buffer.each do |message|
+          rid = message[2]
+          fail "Returned Request Id is not equal to sended one" if rid != request_id
+          cb.call(message)
+        end
+      end
+    rescue Errno::ECONNREFUSED, Errno::EPIPE => e
+      @connected = false
+      @socket = nil
+      if cb
+        err = Monga::Exceptions::Disconnected.new("Disconnected from #{@host}:#{@port}, #{e.message}")
+        cb.call(err)
+      end
+    end
+  end
+end