iproto 0.2 → 0.3.3

data/iproto.gemspec

@@ -4,8 +4,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = '1.3.5'
 
   s.name              = 'iproto'
-  s.version           = '0.2'
-  s.date              = '2012-01-27'
+  s.version           = '0.3.3'
+  s.date              = '2012-07-06'
   s.rubyforge_project = 'iproto'
 
   s.summary     = "Mail.Ru simple network protocol"
@@ -28,6 +28,7 @@ Gem::Specification.new do |s|
     iproto.gemspec
     lib/iproto.rb
     lib/iproto/connection_api.rb
+    lib/iproto/core-ext.rb
     lib/iproto/em.rb
     lib/iproto/tcp_socket.rb
   ]

data/lib/iproto/connection_api.rb

@@ -1,16 +1,12 @@
 module IProto
   module ConnectionAPI
+    PACK = 'VVV'.freeze
     def next_request_id
-      @next_request_id ||= 0
-      @next_request_id += 1
-      if @next_request_id > 0xffffffff
-        @next_request_id = 0
-      end
-      @next_request_id
+      @next_request_id = ((@next_request_id ||= 0) + 1) & 0x7fffffff
     end
 
     def send_request(request_id, data)
       # for override
     end
   end
-end
+end

data/lib/iproto/core-ext.rb

@@ -0,0 +1,3 @@
+class Fiber
+  alias call resume
+end

data/lib/iproto/em.rb

@@ -1,118 +1,194 @@
 require 'eventmachine'
 require 'fiber'
+require 'iproto/core-ext'
+
 module IProto
   module EM
-    module FixedHeaderProtocol
-      def self.included(base)
-        base.extend ClassMethods
+    module FixedLengthProtocol
+      def post_init
+        raise "you should set @_needed_size"  unless @_needed_size
       end
 
-      module ClassMethods
-        def header_size(size = nil)
-          if size
-            @_header_size = size
-          else
-            @_header_size
-          end
-        end
-      end
-
-      attr_accessor :header, :body
-
       def receive_data(data)
         @buffer ||= ''
         offset = 0
-        while (chunk = data[offset, _needed_size - @buffer.size]).size > 0 || _needed_size == 0
-          @buffer += chunk
+        while (chunk = data[offset, _needed_size - @buffer.size]).size > 0
+          @buffer << chunk
           offset += chunk.size
           if @buffer.size == _needed_size
-            case _state
-            when :receive_header
-              @_state = :receive_body
-              receive_header @buffer
-            when :receive_body
-              @_state = :receive_header
-              receive_body @buffer
-            end
+            chunk = @buffer
             @buffer = ''
+            receive_chunk chunk
           end
         end 
       end
 
-      def receive_header(header)
+      def receive_chunk(chunk)
         # for override
       end
-
-      def body_size
-        # for override
-      end
-
-      def receive_body(body)
-        # for override
-      end
-
-      def _needed_size
-        case _state
-        when :receive_header
-          self.class.header_size
-        when :receive_body
-          body_size
-        end
-      end
-
-      def _state
-        @_state ||= :receive_header
-      end
     end
 
   class Connection < ::EM::Connection
     include IProto::ConnectionAPI
-    include FixedHeaderProtocol
+    include FixedLengthProtocol
+    HEADER_SIZE = 12
+
+    def initialize(host, port, reconnect = true)
+      @host = host
+      @port = port
+      @should_reconnect = !!reconnect
+      @reconnect_timer = nil
+      @connected = false
+      @waiting_requests = {}
+      @waiting_for_connect = []
+      init_protocol
+    end
 
-    header_size 12
+    def shutdown_hook
+      ::EM.add_shutdown_hook {
+        @connected = false
+        if @reconnect_timer && !(Symbol === @reconnect_timer)
+          ::EM.cancel_timer @reconnect_timer
+        end
+        @reconnect_timer = @should_reconnect ? :force : nil
+      }
+    end
 
     def connection_completed
+      @reconnect_timer = nil
       @connected = true
+      shutdown_hook
+      _perform_waiting_for_connect(true)
     end
 
-    # begin FixedHeaderAndBody API
-    def body_size
-      @body_size
+    attr_reader :_needed_size
+    def init_protocol
+      @_needed_size = HEADER_SIZE
+      @_state = :receive_header
     end
 
-    def receive_header(header)
-      @type, @body_size, @request_id = header.unpack('L3')
+    def receive_chunk(chunk)
+      if @_state == :receive_header
+        @type, body_size, @request_id = chunk.unpack(PACK)
+        @_needed_size = body_size
+        @_state = :receive_body
+      else
+        request = @waiting_requests.delete @request_id
+        raise IProto::UnexpectedResponse.new("For request id #{@request_id}") unless request
+        @_needed_size = HEADER_SIZE
+        @_state = :receive_header
+        do_response(request, chunk)
+      end
     end
 
-    def receive_body(data)
-      fiber = waiting_requests.delete @request_id
-      raise IProto::UnexpectedResponse.new("For request id #{@request_id}") unless fiber
-      fiber.resume data
+    def do_response(request, data)
+      request.call data
     end
-    # end FixedHeaderAndBody API
 
-    # begin ConnectionAPI
-    def send_request(request_type, body)
-      request_id = next_request_id
-      send_data [request_type, body.size, request_id].pack('LLL') + body
-      f = Fiber.current
-      waiting_requests[request_id] = f
-      Fiber.yield
+    def _setup_reconnect_timer(timeout)
+      if @reconnect_timer.nil? || @reconnect_timer == :force
+        @reconnect_timer = :waiting
+        if @timeout == 0
+          reconnect @host, @port
+        else
+          @reconnect_timer = ::EM.add_timer(timeout) do
+            reconnect @host, @port
+          end
+        end
+      end
     end
-    # end
 
-    def waiting_requests
-      @waiting_requests ||= {}
+    def _send_request(request_type, body, request)
+      unless @connected
+        unless @should_reconnect
+          raise IProto::Disconnected.new("connection is closed")  if @should_reconnect.nil?
+        else
+          @waiting_for_connect << [request_type, body, request]
+          _setup_reconnect_timer(0)
+        end
+      else
+        _do_send_request(request_type, body, request)
+      end
+    end
+
+    def _perform_waiting_for_connect(real)
+      if real
+        @waiting_for_connect.each do |request_type, body, request|
+          _do_send_request(request_type, body, request)
+        end
+      else
+        i = -1
+        @waiting_for_connect.each do |request_type, body, request|
+          @waiting_requests[i] = request
+          i -= 1
+        end
+      end
+      @waiting_for_connect.clear
+    end
+
+    def _do_send_request(request_type, body, request)
+      while @waiting_requests.include?(request_id = next_request_id); end
+      send_data [request_type, body.size, request_id].pack(PACK) + body
+      @waiting_requests[request_id] = request
+    end
+
+    def close
+      close_connection(false)
     end
 
     def close_connection(*args)
-      super(*args)
+      @should_reconnect = nil
+      if @reconnect_timer
+        ::EM.cancel_timer @reconnect_timer  unless Symbol === @reconnect_timer
+        @reconnect_timer = nil
+      end
+      if @connected
+        super(*args)
+      end
+      discard_requests
+    end
+
+    def discard_requests
+      exc = IProto::Disconnected.new("discarded cause of disconnect")
+      _perform_waiting_for_connect(false)
+      @waiting_requests.keys.each do |req|
+        request = @waiting_requests.delete req
+        do_response request, exc
+      end
     end
 
     def unbind
-      raise IProto::CouldNotConnect.new unless @connected
+      discard_requests
+      case @should_reconnect
+      when true
+        @connected = false
+        _setup_reconnect_timer(0.03) unless @reconnect_timer == :force
+      when false
+        if @connected
+          raise IProto::Disconnected
+        else
+          raise IProto::CouldNotConnect
+        end
+      when nil
+        # do nothing cause we explicitely disconnected
+      end
+    end
+  end
+
+  class FiberedConnection < Connection
+    def send_request(request_type, body)
+      _send_request(request_type, body, Fiber.current)
+      result = Fiber.yield
+      raise result  if Exception === result
+      result
+    end
+  end
+
+  class CallbackConnection < Connection
+    def send_request(request_type, body, cb = nil, &block)
+      _send_request(request_type, body, cb || block)
     end
   end
 
   end
-end
+end

data/lib/iproto/tcp_socket.rb

@@ -1,27 +1,56 @@
 require 'socket'
 module IProto
   # TODO: timeouts
-  class TCPSocket < ::TCPSocket
+  class TCPSocket
     include IProto::ConnectionAPI
+    def initialize(host, port, reconnect = true)
+      @host = host
+      @port = port
+      @reconnect = true
+    end
+
+    def close
+      @reconnect = false
+      if @socket
+        @socket.close rescue nil
+      end
+    end
+
+    def socket
+      @socket ||= ::TCPSocket.new(@host, @port)
+    rescue Errno::ECONNREFUSED => e
+      raise CouldNotConnect, e
+    end
 
     # begin ConnectionAPI
     def send_request(request_type, body)
       request_id = next_request_id
-      r = send [request_type, body.bytesize, request_id].pack('LLL') + body, 0
+      r = socket.send ([request_type, body.bytesize, request_id].pack(PACK) << body), 0
       response_size = recv_header request_id
       recv_response response_size
+    rescue Errno::EPIPE => e
+      @socket = nil  if @reconnect
+      raise Disconnected, e
     end
     # end ConnectionAPI
 
     def recv_header(request_id)
-      header = read(12)
-      type, response_size, recv_request_id = header.unpack('L3')
-      raise UnexpectedResponse.new("Waiting response for request_id #{request_id}, but received for #{recv_request_id}") unless request_id == recv_request_id
+      header = socket.read(12)  or begin
+        @socket = nil  if @reconnect
+        raise Disconnected, 'disconnected while read'
+      end
+      type, response_size, recv_request_id = header.unpack(PACK)
+      unless request_id == recv_request_id
+        raise UnexpectedResponse.new("Waiting response for request_id #{request_id}, but received for #{recv_request_id}")
+      end
       response_size
     end
 
     def recv_response(response_size)
-      read(response_size)
+      socket.read(response_size)  or begin
+        @socket = nil  if @reconnect
+        raise Disconnected, 'disconnected while read'
+      end
     end
   end
-end
+end

data/lib/iproto.rb

@@ -1,24 +1,28 @@
 module IProto
-  VERSION = '0.2'
+  VERSION = '0.3.3'
   class IProtoError < StandardError; end
   class CouldNotConnect < IProtoError; end
   class UnexpectedResponse < IProtoError; end
+  class Disconnected < IProtoError; end
 
   require 'iproto/connection_api'
 
   # types:
   # :em
   # :block
-  def self.get_connection(host, port, type = :block)
+  def self.get_connection(host, port, type = :block, reconnect = true)
     case type
     when :em
       require 'iproto/em'
-      ::EM.connect host, port, IProto::EM::Connection
+      ::EM.connect host, port, IProto::EM::FiberedConnection, host, port, reconnect
+    when :em_callback
+      require 'iproto/em'
+      ::EM.connect host, port, IProto::EM::CallbackConnection, host, port, reconnect
     when :block
       require 'iproto/tcp_socket'
-      IProto::TCPSocket.new(host, port)
+      IProto::TCPSocket.new(host, port, reconnect)
     else
       raise "Undefined type #{type}"
     end    
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iproto
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: 0.3.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-27 00:00:00.000000000Z
+date: 2012-07-06 00:00:00.000000000 Z
 dependencies: []
 description: Mail.Ru simple network protocol
 email: ceo@prepor.ru
@@ -25,6 +25,7 @@ files:
 - iproto.gemspec
 - lib/iproto.rb
 - lib/iproto/connection_api.rb
+- lib/iproto/core-ext.rb
 - lib/iproto/em.rb
 - lib/iproto/tcp_socket.rb
 homepage: http://github.com/mailru/iproto-ruby
@@ -48,7 +49,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: iproto
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 2
 summary: Mail.Ru simple network protocol