ione 1.0.0.pre0

data/lib/ione/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Ione
+  VERSION = '1.0.0.pre0'.freeze
+end

data/spec/integration/io_spec.rb

@@ -0,0 +1,283 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+describe 'An IO reactor' do
+  let :io_reactor do
+    Ione::Io::IoReactor.new
+  end
+
+  context 'with a generic server' do
+    let :protocol_handler_factory do
+      lambda { |c| IoSpec::TestConnection.new(c) }
+    end
+
+    let :fake_server do
+      FakeServer.new
+    end
+
+    before do
+      fake_server.start!
+      io_reactor.start
+    end
+
+    after do
+      io_reactor.stop
+      fake_server.stop!
+    end
+
+    it 'connects to the server' do
+      io_reactor.connect(ENV['SERVER_HOST'], fake_server.port, 1).map(&protocol_handler_factory)
+      fake_server.await_connects!(1)
+    end
+
+    it 'receives data' do
+      protocol_handler = io_reactor.connect(ENV['SERVER_HOST'], fake_server.port, 1).map(&protocol_handler_factory).value
+      fake_server.await_connects!(1)
+      fake_server.broadcast!('hello world')
+      await { protocol_handler.data.bytesize > 0 }
+      protocol_handler.data.should == 'hello world'
+    end
+
+    it 'receives data on multiple connections' do
+      protocol_handlers = Array.new(10) { io_reactor.connect(ENV['SERVER_HOST'], fake_server.port, 1).map(&protocol_handler_factory).value }
+      fake_server.await_connects!(10)
+      fake_server.broadcast!('hello world')
+      await { protocol_handlers.all? { |c| c.data.bytesize > 0 } }
+      protocol_handlers.sample.data.should == 'hello world'
+    end
+  end
+
+  context 'when talking to Redis' do
+    let :protocol_handler do
+      begin
+        io_reactor.connect(ENV['SERVER_HOST'], 6379, 1).map { |c| IoSpec::RedisProtocolHandler.new(c) }.value
+      rescue Ione::Io::ConnectionError
+        nil
+      end
+    end
+
+    before do
+      io_reactor.start.value
+    end
+
+    after do
+      io_reactor.stop.value
+    end
+
+    it 'can set a value' do
+      pending('Redis not running', unless: protocol_handler)
+      response = protocol_handler.send_request('SET', 'foo', 'bar').value
+      response.should == 'OK'
+    end
+
+    it 'can get a value' do
+      pending('Redis not running', unless: protocol_handler)
+      f = protocol_handler.send_request('SET', 'foo', 'bar').flat_map do
+        protocol_handler.send_request('GET', 'foo')
+      end
+      f.value.should == 'bar'
+    end
+
+    it 'can delete values' do
+      pending('Redis not running', unless: protocol_handler)
+      f = protocol_handler.send_request('SET', 'hello', 'world').flat_map do
+        protocol_handler.send_request('DEL', 'hello')
+      end
+      f.value.should == 1
+    end
+
+    it 'handles nil values' do
+      pending('Redis not running', unless: protocol_handler)
+      f = protocol_handler.send_request('DEL', 'hello').flat_map do
+        protocol_handler.send_request('GET', 'hello')
+      end
+      f.value.should be_nil
+    end
+
+    it 'handles errors' do
+      pending('Redis not running', unless: protocol_handler)
+      f = protocol_handler.send_request('SET', 'foo')
+      expect { f.value }.to raise_error("ERR wrong number of arguments for 'set' command")
+    end
+
+    it 'handles replies with multiple elements' do
+      pending('Redis not running', unless: protocol_handler)
+      f = protocol_handler.send_request('DEL', 'stuff')
+      f.value
+      f = protocol_handler.send_request('RPUSH', 'stuff', 'hello', 'world')
+      f.value.should == 2
+      f = protocol_handler.send_request('LRANGE', 'stuff', 0, 2)
+      f.value.should == ['hello', 'world']
+    end
+
+    it 'handles nil values when reading multiple elements' do
+      pending('Redis not running', unless: protocol_handler)
+      protocol_handler.send_request('DEL', 'things')
+      protocol_handler.send_request('HSET', 'things', 'hello', 'world')
+      f = protocol_handler.send_request('HMGET', 'things', 'hello', 'foo')
+      f.value.should == ['world', nil]
+    end
+  end
+end
+
+module IoSpec
+  class TestConnection
+    def initialize(connection)
+      @connection = connection
+      @connection.on_data(&method(:receive_data))
+      @lock = Mutex.new
+      @data = Ione::ByteBuffer.new
+    end
+
+    def data
+      @lock.synchronize { @data.to_s }
+    end
+
+    private
+
+    def receive_data(new_data)
+      @lock.synchronize { @data << new_data }
+    end
+  end
+
+  class LineProtocolHandler
+    def initialize(connection)
+      @connection = connection
+      @connection.on_data(&method(:process_data))
+      @lock = Mutex.new
+      @buffer = ''
+      @requests = []
+    end
+
+    def on_line(&listener)
+      @line_listener = listener
+    end
+
+    def write(command_string)
+      @connection.write(command_string)
+    end
+
+    def process_data(new_data)
+      lines = []
+      @lock.synchronize do
+        @buffer << new_data
+        while newline_index = @buffer.index("\r\n")
+          line = @buffer.slice!(0, newline_index + 2)
+          line.chomp!
+          lines << line
+        end
+      end
+      lines.each do |line|
+        @line_listener.call(line) if @line_listener
+      end
+    end
+  end
+
+  class RedisProtocolHandler
+    def initialize(connection)
+      @line_protocol = LineProtocolHandler.new(connection)
+      @line_protocol.on_line(&method(:handle_line))
+      @lock = Mutex.new
+      @responses = []
+      @state = BaseState.new(method(:handle_response))
+    end
+
+    def send_request(*args)
+      promise = Ione::Promise.new
+      @lock.synchronize do
+        @responses << promise
+      end
+      request = "*#{args.size}\r\n"
+      args.each do |arg|
+        arg_str = arg.to_s
+        request << "$#{arg_str.bytesize}\r\n#{arg_str}\r\n"
+      end
+      @line_protocol.write(request)
+      promise.future
+    end
+
+    def handle_response(result, error=false)
+      promise = @lock.synchronize do
+        @responses.shift
+      end
+      if error
+        promise.fail(StandardError.new(result))
+      else
+        promise.fulfill(result)
+      end
+    end
+
+    def handle_line(line)
+      @state = @state.handle_line(line)
+    end
+
+    class State
+      def initialize(result_handler)
+        @result_handler = result_handler
+      end
+
+      def complete!(result)
+        @result_handler.call(result)
+      end
+
+      def fail!(message)
+        @result_handler.call(message, true)
+      end
+    end
+
+    class BulkState < State
+      def handle_line(line)
+        complete!(line)
+        BaseState.new(@result_handler)
+      end
+    end
+
+    class MultiBulkState < State
+      def initialize(result_handler, expected_elements)
+        super(result_handler)
+        @expected_elements = expected_elements
+        @elements = []
+      end
+
+      def handle_line(line)
+        if line.start_with?('$')
+          line.slice!(0, 1)
+          if line.to_i == -1
+            @elements << nil
+          end
+        else
+          @elements << line
+        end
+        if @elements.size == @expected_elements
+          complete!(@elements)
+          BaseState.new(@result_handler)
+        else
+          self
+        end
+      end
+    end
+
+    class BaseState < State
+      def handle_line(line)
+        next_state = self
+        first_char = line.slice!(0, 1)
+        case first_char
+        when '+' then complete!(line)
+        when ':' then complete!(line.to_i)
+        when '-' then fail!(line)
+        when '$'
+          if line.to_i == -1
+            complete!(nil)
+          else
+            next_state = BulkState.new(@result_handler)
+          end
+        when '*'
+          next_state = MultiBulkState.new(@result_handler, line.to_i)
+        end
+        next_state
+      end
+    end
+  end
+end

data/spec/ione/byte_buffer_spec.rb

@@ -0,0 +1,342 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Ione
+  describe ByteBuffer do
+    let :buffer do
+      described_class.new
+    end
+
+    describe '#initialize' do
+      it 'can be inititialized empty' do
+        described_class.new.should be_empty
+      end
+
+      it 'can be initialized with bytes' do
+        described_class.new('hello').length.should == 5
+      end
+    end
+
+    describe '#length/#size/#bytesize' do
+      it 'returns the number of bytes in the buffer' do
+        buffer << 'foo'
+        buffer.length.should == 3
+      end
+
+      it 'is zero initially' do
+        buffer.length.should == 0
+      end
+
+      it 'is aliased as #size' do
+        buffer << 'foo'
+        buffer.size.should == 3
+      end
+
+      it 'is aliased as #bytesize' do
+        buffer << 'foo'
+        buffer.bytesize.should == 3
+      end
+    end
+
+    describe '#empty?' do
+      it 'is true initially' do
+        buffer.should be_empty
+      end
+
+      it 'is false when there are bytes in the buffer' do
+        buffer << 'foo'
+        buffer.should_not be_empty
+      end
+    end
+
+    describe '#append/#<<' do
+      it 'adds bytes to the buffer' do
+        buffer.append('foo')
+        buffer.should_not be_empty
+      end
+
+      it 'can be used as <<' do
+        buffer << 'foo'
+        buffer.should_not be_empty
+      end
+
+      it 'returns itself' do
+        buffer.append('foo').should eql(buffer)
+      end
+
+      it 'stores its bytes as binary' do
+        buffer.append('hällö').length.should == 7
+        buffer.to_s.encoding.should == ::Encoding::BINARY
+      end
+
+      it 'handles appending with multibyte strings' do
+        buffer.append('hello')
+        buffer.append('würld')
+        buffer.to_s.should == 'hellowürld'.force_encoding(::Encoding::BINARY)
+      end
+
+      it 'handles appending with another byte buffer' do
+        buffer.append('hello ').append(ByteBuffer.new('world'))
+        buffer.to_s.should == 'hello world'
+      end
+    end
+
+    describe '#eql?' do
+      it 'is equal to another buffer with the same contents' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.append('foo')
+        b2.append('foo')
+        b1.should eql(b2)
+      end
+
+      it 'is not equal to another buffer with other contents' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.append('foo')
+        b2.append('bar')
+        b1.should_not eql(b2)
+      end
+
+      it 'is aliased as #==' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.append('foo')
+        b2.append('foo')
+        b1.should == b2
+      end
+
+      it 'is equal to another buffer when both are empty' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.should eql(b2)
+      end
+    end
+
+    describe '#hash' do
+      it 'has the same hash code as another buffer with the same contents' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.append('foo')
+        b2.append('foo')
+        b1.hash.should == b2.hash
+      end
+
+      it 'is not equal to the hash code of another buffer with other contents' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.append('foo')
+        b2.append('bar')
+        b1.hash.should_not == b2.hash
+      end
+
+      it 'is equal to the hash code of another buffer when both are empty' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.hash.should == b2.hash
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns the bytes' do
+        buffer.append('hello world').to_s.should == 'hello world'
+      end
+    end
+
+    describe '#to_str' do
+      it 'returns the bytes' do
+        buffer.append('hello world').to_str.should == 'hello world'
+      end
+    end
+
+    describe '#inspect' do
+      it 'returns the bytes wrapped in ByteBuffer(...)' do
+        buffer.append("\xca\xfe")
+        buffer.inspect.should == '#<Ione::ByteBuffer: "\xCA\xFE">'
+      end
+    end
+
+    describe '#discard' do
+      it 'discards the specified number of bytes from the front of the buffer' do
+        buffer.append('hello world')
+        buffer.discard(4)
+        buffer.should == ByteBuffer.new('o world')
+      end
+
+      it 'returns the byte buffer' do
+        buffer.append('hello world')
+        buffer.discard(4).should == ByteBuffer.new('o world')
+      end
+
+      it 'raises an error if the number of bytes in the buffer is fewer than the number to discard' do
+        expect { buffer.discard(1) }.to raise_error(RangeError)
+        buffer.append('hello')
+        expect { buffer.discard(7) }.to raise_error(RangeError)
+      end
+    end
+
+    describe '#read' do
+      it 'returns the specified number of bytes, as a string' do
+        buffer.append('hello')
+        buffer.read(4).should == 'hell'
+      end
+
+      it 'removes the bytes from the buffer' do
+        buffer.append('hello')
+        buffer.read(3)
+        buffer.should == ByteBuffer.new('lo')
+        buffer.read(2).should == 'lo'
+      end
+
+      it 'raises an error if there are not enough bytes' do
+        buffer.append('hello')
+        expect { buffer.read(23423543) }.to raise_error(RangeError)
+        expect { buffer.discard(5).read(1) }.to raise_error(RangeError)
+      end
+
+      it 'returns a string with binary encoding' do
+        buffer.append('hello')
+        buffer.read(4).encoding.should == ::Encoding::BINARY
+        buffer.append('∆')
+        buffer.read(2).encoding.should == ::Encoding::BINARY
+      end
+    end
+
+    describe '#read_int' do
+      it 'returns the first four bytes interpreted as an int' do
+        buffer.append("\xca\xfe\xba\xbe\x01")
+        buffer.read_int.should == 0xcafebabe
+      end
+
+      it 'removes the bytes from the buffer' do
+        buffer.append("\xca\xfe\xba\xbe\x01")
+        buffer.read_int
+        buffer.should == ByteBuffer.new("\x01")
+      end
+
+      it 'raises an error if there are not enough bytes' do
+        buffer.append("\xca\xfe\xba")
+        expect { buffer.read_int }.to raise_error(RangeError)
+      end
+    end
+
+    describe '#read_short' do
+      it 'returns the first two bytes interpreted as a short' do
+        buffer.append("\xca\xfe\x01")
+        buffer.read_short.should == 0xcafe
+      end
+
+      it 'removes the bytes from the buffer' do
+        buffer.append("\xca\xfe\x01")
+        buffer.read_short
+        buffer.should == ByteBuffer.new("\x01")
+      end
+
+      it 'raises an error if there are not enough bytes' do
+        buffer.append("\xca")
+        expect { buffer.read_short }.to raise_error(RangeError)
+      end
+    end
+
+    describe '#read_byte' do
+      it 'returns the first bytes interpreted as an int' do
+        buffer.append("\x10\x01")
+        buffer.read_byte.should == 0x10
+        buffer.read_byte.should == 0x01
+      end
+
+      it 'removes the byte from the buffer' do
+        buffer.append("\x10\x01")
+        buffer.read_byte
+        buffer.should == ByteBuffer.new("\x01")
+      end
+
+      it 'raises an error if there are no bytes' do
+        expect { buffer.read_byte }.to raise_error(RangeError)
+      end
+
+      it 'can interpret the byte as signed' do
+        buffer.append("\x81\x02")
+        buffer.read_byte(true).should == -127
+        buffer.read_byte(true).should == 2
+      end
+    end
+
+    describe '#update' do
+      it 'changes the bytes at the specified location' do
+        buffer.append('foo bar')
+        buffer.update(4, 'baz')
+        buffer.to_s.should == 'foo baz'
+      end
+
+      it 'handles updates after a read' do
+        buffer.append('foo bar')
+        buffer.read(1)
+        buffer.update(3, 'baz')
+        buffer.to_s.should == 'oo baz'
+      end
+
+      it 'handles updates after multiple reads and appends' do
+        buffer.append('foo bar')
+        buffer.read(1)
+        buffer.append('x')
+        buffer.update(4, 'baz')
+        buffer.append('yyyy')
+        buffer.read(1)
+        buffer.to_s.should == 'o bbazyyyy'
+      end
+
+      it 'returns itself' do
+        buffer.append('foo')
+        buffer.update(0, 'bar').should equal(buffer)
+      end
+    end
+
+    describe '#dup' do
+      it 'returns a copy' do
+        buffer.append('hello world')
+        copy = buffer.dup
+        copy.should eql(buffer)
+      end
+
+      it 'returns a copy which can be modified without modifying the original' do
+        buffer.append('hello world')
+        copy = buffer.dup
+        copy.append('goodbye')
+        copy.should_not eql(buffer)
+      end
+    end
+
+    describe '#cheap_peek' do
+      it 'returns a prefix of the buffer' do
+        buffer.append('foo')
+        buffer.append('bar')
+        buffer.read_byte
+        buffer.append('hello')
+        x = buffer.cheap_peek
+        x.bytesize.should be > 0
+        x.bytesize.should be <= buffer.bytesize
+        buffer.to_str.should start_with(x)
+      end
+    end
+
+    context 'when reading and appending' do
+      it 'handles heavy churn' do
+        1000.times do
+          buffer.append('x' * 6)
+          buffer.read_byte
+          buffer.append('y')
+          buffer.read_int
+          buffer.read_short
+          buffer.append('z' * 4)
+          buffer.read_byte
+          buffer.append('z')
+          buffer.read_int
+          buffer.should be_empty
+        end
+      end
+    end
+  end
+end