ione 1.2.0.pre1 → 1.2.0.pre2

data/lib/ione/io/ssl_acceptor.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+
+module Ione
+  module Io
+    # @private
+    class SslAcceptor < Acceptor
+      def initialize(host, port, backlog, unblocker, reactor, ssl_context, socket_impl=nil, ssl_socket_impl=nil)
+        super(host, port, backlog, unblocker, reactor, socket_impl)
+        @ssl_context = ssl_context
+        @ssl_socket_impl = ssl_socket_impl
+      end
+
+      def read
+        client_socket, host, port = accept
+        connection = SslServerConnection.new(client_socket, host, port, @unblocker, @ssl_context, method(:notify_accept_listeners), @ssl_socket_impl)
+        @reactor.accept(connection)
+      end
+    end
+  end
+end

data/lib/ione/io/ssl_connection.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require 'openssl'
+
+
+module Ione
+  module Io
+    # @private
+    class SslConnection < BaseConnection
+      def initialize(host, port, io, unblocker, ssl_context=nil, socket_impl=OpenSSL::SSL::SSLSocket)
+        super(host, port, unblocker)
+        @socket_impl = socket_impl
+        @ssl_context = ssl_context
+        @raw_io = io
+        @connected_promise = Promise.new
+        on_closed(&method(:cleanup_on_close))
+      end
+
+      def connect
+        if @io.nil? && @ssl_context
+          @io = @socket_impl.new(@raw_io, @ssl_context)
+        elsif @io.nil?
+          @io = @socket_impl.new(@raw_io)
+        end
+        @io.connect_nonblock
+        @state = :connected
+        @connected_promise.fulfill(self)
+        @connected_promise.future
+      rescue IO::WaitReadable, IO::WaitWritable
+        # WaitReadable in JRuby, WaitWritable in MRI
+        @connected_promise.future
+      rescue => e
+        close(e)
+        @connected_promise.future
+      end
+
+      def to_io
+        @raw_io
+      end
+
+      if RUBY_ENGINE == 'jruby'
+        # @private
+        def read
+          while true
+            new_data = @io.read_nonblock(2**16)
+            @data_listener.call(new_data) if @data_listener
+          end
+        rescue IO::WaitReadable
+          # no more data available
+        rescue => e
+          close(e)
+        end
+      else
+        # @private
+        def read
+          read_size = 2**16
+          while read_size > 0
+            new_data = @io.read_nonblock(read_size)
+            @data_listener.call(new_data) if @data_listener
+            read_size = @io.pending
+          end
+        rescue => e
+          close(e)
+        end
+      end
+
+      private
+
+      def cleanup_on_close(cause)
+        if cause && !cause.is_a?(IoError)
+          cause = ConnectionError.new(cause.message)
+        end
+        unless @connected_promise.future.completed?
+          @connected_promise.fail(cause)
+        end
+      end
+    end
+  end
+end

data/lib/ione/io/ssl_server_connection.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+module Ione
+  module Io
+    # @private
+    class SslServerConnection < ServerConnection
+      def initialize(socket, host, port, unblocker, ssl_context, accept_callback, ssl_socket_impl=nil)
+        super(socket, host, port, unblocker)
+        @ssl_context = ssl_context
+        @accept_callback = accept_callback
+        @ssl_socket_impl = ssl_socket_impl || OpenSSL::SSL::SSLSocket
+        @ssl_state = :accepting
+      end
+
+      # @private
+      def to_io
+        if @ssl_state == :established
+          @io.to_io
+        else
+          @io
+        end
+      end
+
+      def read
+        if @ssl_state == :accepting
+          begin
+            @ssl_io ||= @ssl_socket_impl.new(@io, @ssl_context)
+            @ssl_io.accept_nonblock
+            @io = @ssl_io
+            @ssl_state = :established
+            @accept_callback.call(self)
+          rescue IO::WaitReadable
+            # connection not ready yet
+          rescue => e
+            close(e)
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/ione/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Ione
-  VERSION = '1.2.0.pre1'.freeze
+  VERSION = '1.2.0.pre2'.freeze
 end

data/spec/integration/ssl_spec.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+describe 'SSL' do
+  let :io_reactor do
+    Ione::Io::IoReactor.new
+  end
+
+  let :port do
+    2**15 + rand(2**15)
+  end
+
+  let :ssl_key do
+    OpenSSL::PKey::RSA.new(2048)
+  end
+
+  let :ssl_cert do
+    cert = OpenSSL::X509::Certificate.new
+    cert.version = 2
+    cert.serial = 1
+    name = OpenSSL::X509::Name.new([['CN', 'localhost']])
+    cert.subject = name
+    cert.issuer = name
+    cert.not_before = Time.now
+    cert.not_after = Time.now + (365*24*60*60)
+    cert.public_key = ssl_key.public_key
+    cert.sign(ssl_key, OpenSSL::Digest::SHA1.new)
+    cert
+  end
+
+  let :ssl_context do
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.cert = ssl_cert
+    ctx.key = ssl_key
+    ctx
+  end
+
+  let :server_received_data do
+    Ione::ByteBuffer.new
+  end
+
+  let :client_received_data do
+    Ione::ByteBuffer.new
+  end
+
+  def start_server
+    ssl_context = OpenSSL::SSL::SSLContext.new
+    ssl_context.key = OpenSSL::PKey::RSA.new(ssl_key)
+    ssl_context.cert = OpenSSL::X509::Certificate.new(ssl_cert)
+
+    f = io_reactor.start
+    f = f.flat_map do
+      io_reactor.bind(ENV['SERVER_HOST'], port, ssl: ssl_context) do |acceptor|
+        acceptor.on_accept do |connection|
+          connection.on_data do |data|
+            server_received_data << data
+            connection.write(data.reverse)
+          end
+        end
+      end
+    end
+    f
+  end
+
+  it 'establishes an encrypted connection' do
+    ssl_context = OpenSSL::SSL::SSLContext.new
+    ssl_context.cert = OpenSSL::X509::Certificate.new(ssl_cert)
+
+    response_received = Ione::Promise.new
+    f = start_server
+    f = f.flat_map do
+      io_reactor.connect(ENV['SERVER_HOST'], port, ssl: ssl_context)
+    end
+    client = f.value
+    client.on_data do |data|
+      client_received_data << data
+      response_received.fulfill(data)
+    end
+    client.write('hello world')
+    response_received.future.value
+    server_received_data.to_s.should == 'hello world'
+    client_received_data.to_s.should == 'dlrow olleh'
+  end
+
+  it 'fails to send a message when not using encryption' do
+    f = start_server
+    f = f.flat_map do
+      io_reactor.connect(ENV['SERVER_HOST'], port)
+    end
+    client = f.value
+    client.write('hello world')
+    await { client.closed? }
+    client.should be_closed
+  end
+end

data/spec/ione/future_spec.rb

@@ -211,15 +211,91 @@ module Ione
           f2.should equal(future)
         end
 
-        it 'passes the value as the second parameter to the block' do
+        it 'passes the value as the first parameter to the block when it expects two arguments' do
           v1, v2 = nil, nil
-          future.on_complete { |_, v| v1 = v }
-          future.on_complete { |_, v| v2 = v }
+          future.on_complete { |v, _| v1 = v }
+          future.on_complete { |v, _| v2 = v }
           promise.fulfill('bar')
           v1.should == 'bar'
           v2.should == 'bar'
         end
 
+        it 'passes future as the third parameter to the block when it expects three arguments' do
+          f1, f2 = nil, nil
+          future.on_complete { |_, _, f| f1 = f }
+          future.on_complete { |_, _, f| f2 = f }
+          promise.fulfill('bar')
+          f1.should equal(future)
+          f2.should equal(future)
+        end
+
+        it 'passes the value, error and future to the block when it expects any number of arguments' do
+          value = 'bar'
+          error = StandardError.new('bork')
+          args1, args2 = nil, nil
+          p1 = Promise.new
+          p2 = Promise.new
+          p1.future.on_complete { |*a| args1 = a }
+          p2.future.on_complete { |*a| args2 = a }
+          p1.fulfill(value)
+          p2.fail(error)
+          args1[0].should equal(value)
+          args1[1].should be_nil
+          args1[2].should equal(p1.future)
+          args2[0].should be_nil
+          args2[1].should equal(error)
+          args2[2].should equal(p2.future)
+        end
+
+        it 'passes the value, error and future to the listener when the listener is a lambda' do
+          value = 'bar'
+          error = StandardError.new('bork')
+          args1, args2 = nil, nil
+          p1 = Promise.new
+          p2 = Promise.new
+          p1.future.on_complete(&lambda { |v, e, f| args1 = [v, e, f] })
+          p2.future.on_complete(&lambda { |v, e, f| args2 = [v, e, f] })
+          p1.fulfill(value)
+          p2.fail(error)
+          args1[0].should equal(value)
+          args1[1].should be_nil
+          args1[2].should equal(p1.future)
+          args2[0].should be_nil
+          args2[1].should equal(error)
+          args2[2].should equal(p2.future)
+        end
+
+        it 'ignores optional arguments for lambdas' do
+          value = 'bar'
+          error = StandardError.new('bork')
+          args1, args2 = nil, nil
+          p1 = Promise.new
+          p2 = Promise.new
+          p1.future.on_complete(&lambda { |v, e, f=nil| args1 = [v, e, f] })
+          p2.future.on_complete(&lambda { |v, e, f, x=1, y=2| args2 = [v, e, f, x, y] })
+          p1.fulfill(value)
+          p2.fail(error)
+          args1[0].should equal(value)
+          args1[1].should be_nil
+          args1[2].should be_nil
+          args2[0].should be_nil
+          args2[1].should equal(error)
+          args2[2].should equal(p2.future)
+        end
+
+        it 'does not handle listeners that are lambdas and have one optional argument' do
+          pending 'MRI 1.9.3 thinks these lambas have arity 1 and not -2' if RUBY_ENGINE == 'ruby' && RUBY_VERSION < '2.0.0'
+          called1, called2 = false, false
+          p1 = Promise.new
+          p2 = Promise.new
+          p1.future.on_complete(&lambda { |v, e=nil| called1 = true })
+          p2.future.on_complete(&lambda { |v, e=nil| called2 = true })
+          p1.fulfill('bar')
+          p2.fail(StandardError.new('bork'))
+          called1.should be_false
+          called2.should be_false
+        end
+
         it 'notifies all listeners when the promise fails' do
           c1, c2 = nil, nil
           future.on_complete { c1 = true }
@@ -229,10 +305,10 @@ module Ione
           c2.should be_true
         end
 
-        it 'passes the error as the third parameter' do
+        it 'passes the error as the second parameter to the block when it expects two arguments' do
           e1, e2 = nil, nil
-          future.on_complete { |_, _, e| e1 = e }
-          future.on_complete { |_, _, e| e2 = e }
+          future.on_complete { |_, e| e1 = e }
+          future.on_complete { |_, e| e2 = e }
           future.fail(error)
           e1.should equal(error)
           e2.should equal(error)
@@ -257,7 +333,7 @@ module Ione
         it 'notifies listeners registered after the promise was fulfilled' do
           f, v, e = nil, nil, nil
           promise.fulfill('bar')
-          future.on_complete { |ff, vv, ee| f = ff; v = vv; e = ee }
+          future.on_complete { |vv, ee, ff| v = vv; e = ee; f = ff }
           f.should equal(future)
           v.should == 'bar'
           e.should be_nil
@@ -266,7 +342,7 @@ module Ione
         it 'notifies listeners registered after the promise failed' do
           f, v, e = nil, nil, nil
           promise.fail(StandardError.new('bork'))
-          future.on_complete { |ff, vv, ee| f = ff; v = vv; e = ee }
+          future.on_complete { |vv, ee, ff| v = vv; e = ee; f = ff }
           f.should equal(future)
           v.should be_nil
           e.message.should == 'bork'
@@ -274,7 +350,7 @@ module Ione
 
         it 'notifies listeners registered after the promise failed' do
           promise.fail(error)
-          expect { future.on_complete { |v| raise 'blurgh' } }.to_not raise_error
+          expect { future.on_complete { raise 'blurgh' } }.to_not raise_error
         end
 
         it 'returns nil' do
@@ -432,6 +508,12 @@ module Ione
         promise.fulfill(:hello)
         listeners.map(&:value).should == Array.new(10, :hello)
       end
+
+      it 'is aliased as #get' do
+        obj = 'hello world'
+        promise.fulfill(obj)
+        future.get.should equal(obj)
+      end
     end
 
     describe '#map' do
@@ -512,7 +594,7 @@ module Ione
 
       it 'accepts anything that implements #on_complete as a chained future' do
         fake_future = double(:fake_future)
-        fake_future.stub(:on_complete) { |&listener| listener.call(nil, :foobar) }
+        fake_future.stub(:on_complete) { |&listener| listener.call(:foobar, nil) }
         p = Promise.new
         f = p.future.flat_map { fake_future }
         p.fulfill
@@ -531,13 +613,26 @@ module Ione
       end
 
       context 'when the block returns something that quacks like a future' do
-        it 'works like #flat_map' do
-          fake_future = double(:fake_future)
-          fake_future.stub(:on_complete) { |&listener| listener.call(nil, :foobar) }
-          p = Promise.new
-          f = p.future.then { |v| fake_future }
-          p.fulfill
-          f.value.should == :foobar
+        context 'and yields a value from #on_complete' do
+          it 'works like #flat_map' do
+            fake_future = double(:fake_future)
+            fake_future.stub(:on_complete) { |&listener| listener.call(:foobar) }
+            p = Promise.new
+            f = p.future.then { |v| fake_future }
+            p.fulfill
+            f.value.should == :foobar
+          end
+        end
+
+        context 'and yields an error from #on_complete' do
+          it 'works like #flat_map' do
+            fake_future = double(:fake_future)
+            fake_future.stub(:on_complete) { |&listener| listener.call(nil, StandardError.new('bork')) }
+            p = Promise.new
+            f = p.future.then { |v| fake_future }
+            p.fulfill
+            expect { f.value }.to raise_error(StandardError, 'bork')
+          end
         end
       end
 
@@ -662,7 +757,7 @@ module Ione
 
         it 'accepts anything that implements #on_complete as a fallback future' do
           fake_future = double(:fake_future)
-          fake_future.stub(:on_complete) { |&listener| listener.call(nil, 'foo') }
+          fake_future.stub(:on_complete) { |&listener| listener.call('foo', nil) }
           p = Promise.new
           f = p.future.fallback { fake_future }
           p.fail(error)
@@ -703,7 +798,7 @@ module Ione
 
       it 'accepts anything that implements #on_complete as futures' do
         fake_future = double(:fake_future)
-        fake_future.stub(:on_complete) { |&listener| listener.call(nil, :foobar) }
+        fake_future.stub(:on_complete) { |&listener| listener.call(:foobar, nil) }
         future = Future.traverse([1, 2, 3]) { fake_future }
         future.value.should == [:foobar, :foobar, :foobar]
       end
@@ -785,9 +880,9 @@ module Ione
 
       it 'accepts anything that implements #on_complete as futures' do
         ff1, ff2, ff3 = double, double, double
-        ff1.stub(:on_complete) { |&listener| listener.call(nil, 1) }
-        ff2.stub(:on_complete) { |&listener| listener.call(nil, 2) }
-        ff3.stub(:on_complete) { |&listener| listener.call(nil, 3) }
+        ff1.stub(:on_complete) { |&listener| listener.call(1, nil) }
+        ff2.stub(:on_complete) { |&listener| listener.call(2, nil) }
+        ff3.stub(:on_complete) { |&listener| listener.call(3, nil) }
         future = Future.reduce([ff1, ff2, ff3], 0) { |sum, n| sum + n }
         future.value.should == 6
       end
@@ -907,9 +1002,9 @@ module Ione
 
         it 'accepts anything that implements #on_complete as futures' do
           ff1, ff2, ff3 = double, double, double
-          ff1.stub(:on_complete) { |&listener| listener.call(nil, 1) }
-          ff2.stub(:on_complete) { |&listener| listener.call(nil, 2) }
-          ff3.stub(:on_complete) { |&listener| listener.call(nil, 3) }
+          ff1.stub(:on_complete) { |&listener| listener.call(1, nil) }
+          ff2.stub(:on_complete) { |&listener| listener.call(2, nil) }
+          ff3.stub(:on_complete) { |&listener| listener.call(3, nil) }
           future = Future.all(ff1, ff2, ff3)
           future.value.should == [1, 2, 3]
         end
@@ -1006,8 +1101,8 @@ module Ione
 
         it 'accepts anything that implements #on_complete as futures' do
           ff1, ff2 = double, double
-          ff1.stub(:on_complete) { |&listener| listener.call(nil, 1) }
-          ff2.stub(:on_complete) { |&listener| listener.call(nil, 2) }
+          ff1.stub(:on_complete) { |&listener| listener.call(1, nil) }
+          ff2.stub(:on_complete) { |&listener| listener.call(2, nil) }
           future = Future.first(ff1, ff2)
           future.value.should == 1
         end
@@ -1040,11 +1135,21 @@ module Ione
 
         it 'calls its complete callbacks immediately' do
           f, v = nil, nil
-          future.on_complete { |ff, vv| f = ff; v = vv }
+          future.on_complete { |vv, _, ff| f = ff; v = vv }
           f.should equal(future)
           v.should == 'hello world'
         end
 
+        it 'calls its complete callbacks with the right arity' do
+          f1, v, f2 = nil, nil, nil
+          future.on_complete { |ff| f1 = ff }
+          future.on_complete { |vv, ee| v = vv }
+          future.on_complete { |vv, ee, ff| f2 = ff }
+          f1.should equal(future)
+          f2.should equal(future)
+          v.should == 'hello world'
+        end
+
         it 'does not block on #value' do
           future.value.should == 'hello world'
         end
@@ -1081,15 +1186,25 @@ module Ione
 
         it 'calls its complete callbacks immediately' do
           f, e = nil, nil
-          future.on_complete { |ff, _, ee| f = ff; e = ee }
+          future.on_complete { |_, ee, ff| f = ff; e = ee }
           f.should equal(future)
           e.message.should == 'bork'
         end
 
+        it 'calls its complete callbacks with the right arity' do
+          f1, e, f2 = nil, nil, nil
+          future.on_complete { |ff| f1 = ff }
+          future.on_complete { |vv, ee| e = ee }
+          future.on_complete { |vv, ee, ff| f2 = ff }
+          f1.should equal(future)
+          f2.should equal(future)
+          e.message.should == 'bork'
+        end
+
         it 'does not block on #value' do
           expect { future.value }.to raise_error('bork')
         end
       end
     end
   end
-end
+end