ione-rpc 1.0.0.pre0 → 1.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 80f4a0fbab22cefd0de19d54c779637b15129ea8
-  data.tar.gz: 35d701df7cba437f67fb5fd505b457d49d43ad7c
+  metadata.gz: 51144d6e83a35056bbefda51115605b74141c2a1
+  data.tar.gz: 0d983eee0b3c1810a6c8a3a1a311bf4d7e4b8941
 SHA512:
-  metadata.gz: ea81e63e8b59f31ac42b60be6e432480a365efa8f7de7da8475eb99acf8877445045e93c77634d14d9eb717cf9e4301b7c0bee2b82dc0366a3bd381b2b61e47e
-  data.tar.gz: a2384cb4793ed2dbbe7a344ee535d74844d386b94ff531aa0abad4a12ed1b5cc30461a90ca90cbdd787b761e1ee31b3936665f8c9ef164928387d02354571bc0
+  metadata.gz: 652a513b927f5c485e960e2211e4a687ba64034285fa631dbcfee72a91ab19f4bcbbaa09b95875b8deeba3efe2b3b3f77bf8674de1536225f9d0d042b7e06f61
+  data.tar.gz: 500e33e208a693abf1ce8495d4c8e6250672eb16832bd17ca8e9195def804a41338d2484d431bd13c8bbf0263164bd1c3dca4f3a1f95a3df6a8dc1a41419cc90

data/lib/ione/rpc/client.rb

@@ -141,15 +141,18 @@ module Ione
       # @param [Object] request the request to send.
       # @param [Object] connection the connection to send the request on. This
       #   parameter is internal and should only be used from {#initialize_connection}.
+      # @param [Object] timeout the maximum time in seconds to wait for a response
+      #   before failing the returned future with a {Ione::Rpc::TimeoutError}.
+      #   There is no timeout by default.
       # @return [Ione::Future<Object>] a future that resolves to the response
       #   from the server, or fails because there was an error while processing
       #   the request (this is not the same thing as the server sending an
       #   error response – that is protocol specific and up to the implementation
       #   to handle), or when there was no connection open.
-      def send_request(request, connection=nil)
+      def send_request(request, connection=nil, timeout=nil)
         connection = connection || @lock.synchronize { choose_connection(@connections, request) }
         if connection
-          f = connection.send_message(request)
+          f = connection.send_message(request, timeout)
           f = f.fallback do |error|
             if error.is_a?(Io::ConnectionClosedError)
               @logger.warn('Request failed because the connection closed, retrying') if @logger
@@ -261,7 +264,7 @@ module Ione
       end
 
       def create_connection(raw_connection)
-        Ione::Rpc::ClientPeer.new(raw_connection, @codec, @max_channels)
+        Ione::Rpc::ClientPeer.new(raw_connection, @codec, @io_reactor, @max_channels)
       end
 
       def handle_connected(connection)

data/lib/ione/rpc/client_peer.rb

@@ -7,14 +7,15 @@ module Ione
   module Rpc
     # @private
     class ClientPeer < Peer
-      def initialize(connection, codec, max_channels)
-        super(connection, codec)
+      def initialize(connection, codec, scheduler, max_channels)
+        raise ArgumentError, 'More than 2**15 channels is not supported' if max_channels > 2**15
+        super(connection, codec, scheduler)
         @lock = Mutex.new
         @channels = [nil] * max_channels
         @queue = []
       end
 
-      def send_message(request)
+      def send_message(request, timeout=nil)
         promise = Ione::Promise.new
         channel = @lock.synchronize do
           take_channel(promise)
@@ -26,6 +27,14 @@ module Ione
             @queue << [request, promise]
           end
         end
+        if timeout
+          @scheduler.schedule_timer(timeout).on_value do
+            unless promise.future.completed?
+              error = Rpc::TimeoutError.new('No response received within %ss' % timeout.to_s)
+              promise.fail(error)
+            end
+          end
+        end
         promise.future
       end
 
@@ -37,7 +46,7 @@ module Ione
           @channels[channel] = nil
           promise
         end
-        if promise
+        if promise && !promise.future.completed?
           promise.fulfill(response)
         end
         flush_queue

data/lib/ione/rpc/codec.rb

@@ -28,7 +28,7 @@ module Ione
       # @return [String] an encoded frame with the message and channel
       def encode(message, channel)
         data = encode_message(message)
-        [1, channel, data.bytesize, data.to_s].pack('ccNa*')
+        [2, 0, channel, data.bytesize, data.to_s].pack(FRAME_V2_FORMAT)
       end
 
       # Decodes a frame, piece by piece if necessary.
@@ -106,7 +106,11 @@ module Ione
         def read_header
           n = @buffer.read_short
           @version = n >> 8
-          @channel = n & 0xff
+          if @version == 1
+            @channel = n & 0xff
+          else
+            @channel = @buffer.read_short
+          end
           @length = @buffer.read_int
         end
 
@@ -115,13 +119,18 @@ module Ione
         end
 
         def header_ready?
-          @length.nil? && @buffer.size >= 6
+          @length.nil? && @buffer.size >= 8
         end
 
         def body_ready?
           @length && @buffer.size >= @length
         end
       end
+
+      private
+
+      FRAME_V1_FORMAT = 'ccNa*'.freeze
+      FRAME_V2_FORMAT = 'ccnNa*'.freeze
     end
 
     # A codec that works with encoders like JSON, MessagePack, YAML and others

data/lib/ione/rpc/peer.rb

@@ -6,13 +6,14 @@ module Ione
     class Peer
       attr_reader :host, :port
 
-      def initialize(connection, codec)
+      def initialize(connection, codec, scheduler=nil)
         @connection = connection
         @connection.on_data(&method(:handle_data))
         @connection.on_closed(&method(:handle_closed))
         @host = @connection.host
         @port = @connection.port
         @codec = codec
+        @scheduler = scheduler
         @buffer = Ione::ByteBuffer.new
         @closed_promise = Promise.new
         @current_message = nil

data/lib/ione/rpc/version.rb

@@ -2,6 +2,6 @@
 
 module Ione
   module Rpc
-    VERSION = '1.0.0.pre0'.freeze
+    VERSION = '1.0.0.pre1'.freeze
   end
 end

data/lib/ione/rpc.rb

@@ -5,6 +5,7 @@ require 'ione'
 
 module Ione
   module Rpc
+    TimeoutError = Class.new(StandardError)
   end
 end
 

data/spec/ione/rpc/client_peer_spec.rb

@@ -8,7 +8,7 @@ module Ione
   module Rpc
     describe ClientPeer do
       let! :peer do
-        RpcSpec::TestClientPeer.new(connection, codec, max_channels)
+        RpcSpec::TestClientPeer.new(connection, codec, scheduler, max_channels)
       end
 
       let :connection do
@@ -19,6 +19,10 @@ module Ione
         double(:codec)
       end
 
+      let :scheduler do
+        double(:scheduler)
+      end
+
       let :max_channels do
         16
       end
@@ -39,6 +43,15 @@ module Ione
         end
       end
 
+      before do
+        timer_promises = []
+        scheduler.stub(:schedule_timer) do |timeout|
+          timer_promises << Promise.new
+          timer_promises.last.future
+        end
+        scheduler.stub(:timer_promises).and_return(timer_promises)
+      end
+
       include_examples 'peers'
 
       context 'when the connection closes' do
@@ -51,6 +64,12 @@ module Ione
         end
       end
 
+      describe '#initialize' do
+        it 'raises ArgumentError when the specified max channels is more than the protocol handles' do
+          expect { RpcSpec::TestClientPeer.new(connection, codec, scheduler, 2**24) }.to raise_error(ArgumentError)
+        end
+      end
+
       describe '#send_message' do
         it 'encodes and sends a request frame' do
           peer.send_message('hello')
@@ -85,6 +104,19 @@ module Ione
           connection.data_listener.call('bar@000')
           f.value.payload.should == 'bar'
         end
+
+        it 'fails the request when the timeout passes before the response is received' do
+          f = peer.send_message('foo', 2)
+          scheduler.timer_promises.first.fulfill
+          expect { f.value }.to raise_error(Rpc::TimeoutError)
+        end
+
+        it 'does not fail the request when the response is received before the timeout passes' do
+          f = peer.send_message('foo', 2)
+          connection.data_listener.call('bar@000')
+          scheduler.timer_promises.first.fulfill
+          expect { f.value }.to_not raise_error
+        end
       end
     end
   end

data/spec/ione/rpc/client_spec.rb

@@ -16,8 +16,14 @@ module Ione
 
       let :io_reactor do
         running = [false]
+        timer_promises = []
         r = double(:io_reactor)
         r.stub(:running?) { running[0] }
+        r.stub(:schedule_timer) do |timeout|
+          timer_promises << Promise.new
+          timer_promises.last.future
+        end
+        r.stub(:timer_promises).and_return(timer_promises)
         r.stub(:start) do
           running[0] = true
           Future.resolved(r)
@@ -197,7 +203,7 @@ module Ione
           before do
             client.start.value
             client.created_connections.each do |connection|
-              connection.stub(:send_message).with('PING').and_return(Future.resolved('PONG'))
+              connection.stub(:send_message).with('PING', nil).and_return(Future.resolved('PONG'))
             end
           end
 
@@ -225,6 +231,20 @@ module Ione
           end
         end
 
+        context 'with a timeout' do
+          it 'passes the timeout to the connection' do
+            client.start.value
+            timeouts = []
+            client.created_connections.each do |connection|
+              connection.stub(:send_message) do |rq, timeout|
+                timeouts << timeout
+              end
+            end
+            client.send_request('PING', nil, 2)
+            timeouts.should include(2)
+          end
+        end
+
         context 'when the client chooses the connection per request' do
           it 'asks the client to choose a connection to send the request on' do
             client.override_choose_connection do |connections, request|
@@ -415,7 +435,7 @@ module Ione
 
         it 'logs when requests fail' do
           client.start.value
-          client.created_connections.each { |connection| connection.stub(:send_message).with('PING').and_return(Future.failed(StandardError.new('BORK'))) }
+          client.created_connections.each { |connection| connection.stub(:send_message).with('PING', nil).and_return(Future.failed(StandardError.new('BORK'))) }
           client.send_request('PING')
           logger.should have_received(:warn).with(/request failed: BORK/i)
         end
@@ -605,9 +625,9 @@ module ClientSpec
       @raw_connection.port
     end
 
-    def send_message(request)
+    def send_message(request, timeout=nil)
       @requests << request
-      @peer_connection.send_message(request)
+      @peer_connection.send_message(request, timeout)
       Ione::Future.resolved
     end
   end

data/spec/ione/rpc/codec_spec.rb

@@ -20,19 +20,19 @@ module Ione
         end
 
         it 'encodes the version in the first byte' do
-          encoded_message[0, 1].unpack('c').should == [1]
+          encoded_message[0, 1].unpack('c').should == [2]
         end
 
-        it 'encodes the channel in the second byte' do
-          encoded_message[1, 1].unpack('c').should == [42]
+        it 'encodes the channel in the third and fourth byte' do
+          encoded_message[2, 2].unpack('n').should == [42]
         end
 
         it 'encodes the length of the frame in the following four bytes' do
-          encoded_message[2, 4].unpack('N').should == [22]
+          encoded_message[4, 4].unpack('N').should == [22]
         end
 
         it 'encodes the object as JSON' do
-          encoded_message[6..-1].should == '{"foo":"bar","baz":42}'
+          encoded_message[8..-1].should == '{"foo":"bar","baz":42}'
         end
       end
 
@@ -99,21 +99,34 @@ module Ione
           42
         end
 
-        let :frame do
+        let :v1_frame do
           %(\x01\x2a\x00\x00\x00\x16{"foo":"bar","baz":42})
         end
 
-        it 'decoding a encoded frame returns the original message' do
-          frm = codec.encode(message, channel)
-          msg, ch, _ = codec.decode(Ione::ByteBuffer.new(frm), nil)
-          msg.should == message
-          ch.should == channel
+        let :v2_frame do
+          %(\x02\x00\x00\x2a\x00\x00\x00\x16{"foo":"bar","baz":42})
         end
 
-        it 'encoding a message gives the original frame' do
-          msg, ch, _ = codec.decode(Ione::ByteBuffer.new(frame), nil)
-          frm = codec.encode(msg, ch)
-          frm.should == frame
+        context 'with a v1 frame' do
+          it 'decodes a frame' do
+            msg, ch, _ = codec.decode(Ione::ByteBuffer.new(v1_frame), nil)
+            msg.should == message
+          end
+        end
+
+        context 'with a v2 frame' do
+          it 'decoding a encoded frame returns the original message' do
+            frm = codec.encode(message, channel)
+            msg, ch, _ = codec.decode(Ione::ByteBuffer.new(frm), nil)
+            msg.should == message
+            ch.should == channel
+          end
+
+          it 'encoding a message gives the original frame' do
+            msg, ch, _ = codec.decode(Ione::ByteBuffer.new(v2_frame), nil)
+            frm = codec.encode(msg, ch)
+            frm.should == v2_frame
+          end
         end
       end
     end
@@ -125,13 +138,13 @@ module Ione
 
       describe '#encode' do
         it 'calls #dump on the delegate' do
-          codec.encode({'foo' => 'bar'}, 0)[6..-1].should == '{"foo":"bar"}'
+          codec.encode({'foo' => 'bar'}, 0)[8..-1].should == '{"foo":"bar"}'
         end
       end
 
       describe '#decode' do
         it 'calls #load on the delegate' do
-          buffer = Ione::ByteBuffer.new(%(\x01\x00\x00\x00\x00\x0d{"foo":"bar"}))
+          buffer = Ione::ByteBuffer.new(%(\x02\x00\x00\x00\x00\x00\x00\x0d{"foo":"bar"}))
           message, _, _ = codec.decode(buffer, nil)
           message.should eql('foo' => 'bar')
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ione-rpc
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre0
+  version: 1.0.0.pre1
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-28 00:00:00.000000000 Z
+date: 2014-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione