celluloid-io 0.16.2 → 0.16.5.pre0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 478d600640a4868162a199bc7db4ac8926be40f2
-  data.tar.gz: d0cc206f1aeb05290be388ba6fc0e66375bd179f
+  metadata.gz: bf0058f46b15fb91d5363861cc8035e0f41f6396
+  data.tar.gz: cad3855d8ca89f73731dceaa18716ba25f315484
 SHA512:
-  metadata.gz: 244c3a718d4e0237682640dd2e4005fbf254893f0c12441efc7cab19de65585ac4e14a8b99e7e11cf796c4c8cf1e18dc60cab259787b0fabffaa306fa73d240c
-  data.tar.gz: 09a0bbc5a409bde43ada45ac692467a9702d98d79f45e27d63ddcc6586e682cb3ff0d067e1e764e1b06a839de37d849d35efb05db9b0c6304a18aee63c02c994
+  metadata.gz: 39ce8ad8e39920264f26c199bf14e5dbd03c6e97943d7d5a636e68d6e9cc687aa79d14b3d6542ff5af8e11eb19e118e8ff3b262fd61966c89814d3966bcfc0fb
+  data.tar.gz: 03ffeaedee0b08276537ff5cfedf5d11157c34c932129f1c394626ff45923b93867901bb67f2718e5fe6b032649dd7112d910c527c983e82b1c8c6c7c532f026

data/.env-ci

@@ -0,0 +1,4 @@
+CELLULOID_SPECS_LOG_STRATEGY=stderr
+CELLULOID_SPECS_LOG_LEVEL=3
+CELLULOID_SPECS_LOG_FILE=log/ci.log
+CELLULOID_SPECS_LOG_SYNC=false

data/.env-dev

@@ -0,0 +1,4 @@
+CELLULOID_SPECS_LOG_STRATEGY=single
+CELLULOID_SPECS_LOG_FILE=log/test.log
+CELLULOID_SPECS_LOG_LEVEL=0
+CELLULOID_SPECS_LOG_SYNC=true

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "culture"]
+	path = culture
+	url = http://github.com/celluloid/culture.git

data/.travis.yml

@@ -1,19 +1,35 @@
 script: rake ci
+language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.1
-  - ruby-head
+  - 2.2.0
+  - 2.2.2
   - jruby
+  - ruby-head
   - jruby-head
   - rbx-2
 
+# TODO: Put these back:
+# * CELLULOID_TASK_CLASS=Fibered
+# * CELLULOID_TASK_CLASS=Threaded
+# For right now the imporant thing is to test BACKPORTED mode:
+
 matrix:
+  fast_finish: true
   allow_failures:
+    - rvm: rbx-2
     - rvm: ruby-head
-    - rvm: jruby
     - rvm: jruby-head
-    - rvm: rbx-2
+    - env: CELLULOID_BACKPORTED=true
+
+env:
+  matrix:
+    - CELLULOID_BACKPORTED=true
+    - CELLULOID_BACKPORTED=false
+  global:
+    - NUMBER_OF_PROCESSORS=2 CELLULOID_CONFIG_FILE=.env-ci
 
 notifications:
   irc: "irc.freenode.org#celluloid"
+
+sudo: false
+install: bundle install --without=development

data/CHANGES.md

@@ -1,21 +1,25 @@
-0.16.2 (2014-01-30)
--------------------
+HEAD
+-----
+* Adjust class name for Celluloid::Mailbox::Evented, per 0.17.0 of Celluloid.
+
+0.16.2 (2015-01-30)
+-----
 * More TCPSocket compatibility fixes
 * Ensure monitors are closed when tasks resume
 * Fix Errno::EAGAIN handling in Stream#syswrite
 
 0.16.1 (2014-10-08)
--------------------
+-----
 * Revert read/write interest patch as it caused file descriptor leaks
 
 0.16.0 (2014-09-04)
--------------------
+-----
 * Fix bug handling simultaneous read/write interests
 * Use Resolv::DNS::Config to obtain nameservers
 * Celluloid::IO.copy_stream support (uses a background thread)
 
 0.15.0 (2013-09-04)
--------------------
+-----
 * Improved DNS resolver with less NIH and more Ruby stdlib goodness
 * Better match Ruby stdlib TCPServer API
 * Add missing #send and #recv on Celluloid::IO::TCPSocket
@@ -23,16 +27,16 @@
 * Add missing #peeraddr method on Celluloid::IO::SSLSocket
 
 0.14.0 (2013-05-07)
--------------------
+-----
 * Add `close_read`/`close_write` delegates for rack-hijack support
 * Depend on EventedMailbox from core
 
 0.13.1
-------
+-----
 * Remove overhead for `wait_readable`/`wait_writable`
 
 0.13.0
-------
+-----
 * Support for many, many more IO methods, particularly line-oriented
   methods like #gets, #readline, and #readlines
 * Initial SSL support via Celluloid::IO::SSLSocket and
@@ -42,15 +46,15 @@
 * Celluloid 0.13 compatibility fixes
 
 0.12.0
-------
+-----
 * Tracking release for Celluloid 0.12.0
 
 0.11.0
-------
+-----
 * "Unofficial" SSL support (via nio4r 0.4.0)
 
 0.10.0
-------
+-----
 * Read/write operations are now atomic across tasks
 * True non-blocking connect support
 * Non-blocking DNS resolution support

data/Gemfile

@@ -1,5 +1,2 @@
-source 'https://rubygems.org'
-gemspec
-
-gem 'coveralls', require: false
-gem 'celluloid', github: 'celluloid/celluloid', branch: 'master'
+require File.expand_path("../culture/sync", __FILE__)
+Celluloid::Sync::Gemfile[self]

data/celluloid-io.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/celluloid/io/version', __FILE__)
+require File.expand_path("../culture/sync", __FILE__)
 
 Gem::Specification.new do |gem|
   gem.name          = "celluloid-io"
@@ -16,12 +16,10 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.require_paths = ["lib"]
 
-  gem.add_dependency 'celluloid', '>= 0.16.0'
+  Celluloid::Sync::Gemspec[gem]
+  
   gem.add_dependency 'nio4r',     '>= 1.1.0'
 
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec', '~> 2.14.0'
-  gem.add_development_dependency 'benchmark_suite'
   gem.add_development_dependency 'guard-rspec'
   gem.add_development_dependency 'rb-fsevent', '~> 0.9.1' if RUBY_PLATFORM =~ /darwin/
 end

data/lib/celluloid/io/mailbox.rb

@@ -1,7 +1,7 @@
 module Celluloid
   module IO
     # An alternative implementation of Celluloid::Mailbox using Reactor
-    class Mailbox < Celluloid::EventedMailbox
+    class Mailbox < Celluloid::Mailbox::Evented
       def initialize
         super(Reactor)
       end

data/lib/celluloid/io/ssl_socket.rb

@@ -6,13 +6,26 @@ module Celluloid
     class SSLSocket < Stream
       extend Forwardable
 
-      def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?,
-        :cert, :cipher, :client_ca, :peer_cert, :peer_cert_chain, :verify_result, :peeraddr
+      def_delegators :@socket,
+        :read_nonblock,
+        :write_nonblock,
+        :close,
+        :closed?,
+        :cert,
+        :cipher,
+        :client_ca,
+        :peeraddr,
+        :peer_cert,
+        :peer_cert_chain,
+        :post_connection_check,
+        :verify_result,
+        :sync_close=
 
       def initialize(io, ctx = OpenSSL::SSL::SSLContext.new)
         super()
         @context = ctx
         @socket = OpenSSL::SSL::SSLSocket.new(::IO.try_convert(io), @context)
+        @socket.sync_close = true if @socket.respond_to?(:sync_close=)
       end
 
       def connect

data/lib/celluloid/io/tcp_socket.rb

@@ -80,13 +80,15 @@ module Celluloid
 
         begin
           @socket.connect_nonblock Socket.sockaddr_in(remote_port, @addr.to_s)
-        rescue Errno::EINPROGRESS
+        rescue Errno::EINPROGRESS, Errno::EALREADY
+          # JRuby raises EINPROGRESS, MRI raises EALREADY
+
           wait_writable
 
           # HAX: for some reason we need to finish_connect ourselves on JRuby
           # This logic is unnecessary but JRuby still throws Errno::EINPROGRESS
           # if we retry the non-blocking connect instead of just finishing it
-          retry unless defined?(JRUBY_VERSION) && @socket.to_channel.finish_connect
+          retry unless RUBY_PLATFORM == 'java' && @socket.to_channel.finish_connect
         rescue Errno::EISCONN
           # We're now connected! Yay exceptions for flow control
           # NOTE: This is the approach the Ruby stdlib docs suggest ;_;

data/lib/celluloid/io/version.rb

@@ -1,5 +1,5 @@
 module Celluloid
   module IO
-    VERSION = "0.16.2"
+    VERSION = "0.16.5.pre0"
   end
 end

data/spec/celluloid/io/dns_resolver_spec.rb

@@ -5,14 +5,14 @@ describe Celluloid::IO::DNSResolver do
     it 'resolves hostnames statically from hosts file without nameservers' do
       # /etc/resolv.conf doesn't exist on Mac OSX when no networking is
       # disabled, thus .nameservers would return nil
-      Celluloid::IO::DNSResolver.should_receive(:nameservers).at_most(:once) { nil }
+      expect(Celluloid::IO::DNSResolver).to receive(:nameservers).at_most(:once) { nil }
       resolver = Celluloid::IO::DNSResolver.new
-      resolver.resolve('localhost').should eq Resolv::IPv4.create("127.0.0.1")
+      expect(resolver.resolve('localhost')).to eq Resolv::IPv4.create("127.0.0.1")
     end
 
     it 'resolves hostnames' do
       resolver = Celluloid::IO::DNSResolver.new
-      resolver.resolve('localhost').should eq Resolv::IPv4.create("127.0.0.1")
+      expect(resolver.resolve('localhost')).to eq Resolv::IPv4.create("127.0.0.1")
     end
 
     it "resolves domain names" do
@@ -26,17 +26,17 @@ describe Celluloid::IO::DNSResolver do
       resolver = Celluloid::IO::DNSResolver.new
       results = resolver.resolve("www.google.com")
       if results.is_a?(Array)
-        results.all? {|i| i.should be_an_instance_of(Resolv::IPv4) }
+        results.all? {|i| expect(i).to be_an_instance_of(Resolv::IPv4) }
       else
-        results.should be_an_instance_of(Resolv::IPv4)
+        expect(results).to be_an_instance_of(Resolv::IPv4)
       end
       # www.yahoo.com will be resolved randomly whether multiple or
       # single entry.
       results = resolver.resolve("www.yahoo.com")
       if results.is_a?(Array)
-        results.all? {|i| i.should be_an_instance_of(Resolv::IPv4) }
+        results.all? {|i| expect(i).to be_an_instance_of(Resolv::IPv4) }
       else
-        results.should be_an_instance_of(Resolv::IPv4)
+        expect(results).to be_an_instance_of(Resolv::IPv4)
       end
     end
   end

data/spec/celluloid/io/reactor_spec.rb

@@ -29,7 +29,7 @@ describe Celluloid::IO::Reactor do
       end
     end
     
-    expect(handle).to be_true
+    expect(handle).to be_truthy
     
     server.close
     peer.close

data/spec/celluloid/io/ssl_server_spec.rb

@@ -25,7 +25,7 @@ describe Celluloid::IO::SSLServer do
     context "inside Celluloid::IO" do
       it "should be evented" do
         with_ssl_server do |subject|
-          within_io_actor { Celluloid::IO.evented? }.should be_true
+          expect(within_io_actor { Celluloid::IO.evented? }).to be_truthy
         end
       end
 
@@ -36,11 +36,11 @@ describe Celluloid::IO::SSLServer do
             OpenSSL::SSL::SSLSocket.new(raw, client_context).connect
           end
           peer = within_io_actor { subject.accept }
-          peer.should be_a Celluloid::IO::SSLSocket
+          expect(peer).to be_a Celluloid::IO::SSLSocket
 
           client = thread.value
           client.write payload
-          peer.read(payload.size).should eq payload
+          expect(peer.read(payload.size)).to eq payload
         end
       end
     end
@@ -48,7 +48,7 @@ describe Celluloid::IO::SSLServer do
     context "outside Celluloid::IO" do
       it "should be blocking" do
         with_ssl_server do |subject|
-          Celluloid::IO.should_not be_evented
+          expect(Celluloid::IO).not_to be_evented
         end
       end
 
@@ -59,11 +59,11 @@ describe Celluloid::IO::SSLServer do
             OpenSSL::SSL::SSLSocket.new(raw, client_context).connect
           end
           peer = subject.accept
-          peer.should be_a Celluloid::IO::SSLSocket
+          expect(peer).to be_a Celluloid::IO::SSLSocket
 
           client = thread.value
           client.write payload
-          peer.read(payload.size).should eq payload
+          expect(peer.read(payload.size)).to eq payload
         end
       end
     end
@@ -73,7 +73,7 @@ describe Celluloid::IO::SSLServer do
     it "should auto-wrap a raw ::TCPServer" do
       raw_server = ::TCPServer.new(example_addr, example_ssl_port)
       with_ssl_server(raw_server) do |ssl_server|
-        ssl_server.tcp_server.class.should == Celluloid::IO::TCPServer
+        expect(ssl_server.tcp_server.class).to eq(Celluloid::IO::TCPServer)
       end
     end
   end

data/spec/celluloid/io/ssl_socket_spec.rb

@@ -72,35 +72,38 @@ describe Celluloid::IO::SSLSocket do
       with_ssl_sockets do |ssl_client, ssl_peer|
         within_io_actor do
           ssl_peer << request
-          ssl_client.read(request.size).should eq(request)
+          expect(ssl_client.read(request.size)).to eq(request)
 
           ssl_client << response
-          ssl_peer.read(response.size).should eq(response)
+          expect(ssl_peer.read(response.size)).to eq(response)
         end
       end
     end
 
     it "starts SSL on a connected TCP socket" do
-      pending "JRuby support" if defined?(JRUBY_VERSION)
+      if RUBY_PLATFORM == 'java'
+        pending "JRuby support"
+        fail "Bypassing potential deadlock."
+      end
       with_raw_sockets do |client, peer|
         within_io_actor do
           peer << request
-          client.read(request.size).should eq(request)
+          expect(client.read(request.size)).to eq(request)
 
           client << response
-          peer.read(response.size).should eq(response)
+          expect(peer.read(response.size)).to eq(response)
 
           # now that we've written bytes, upgrade to SSL
           client_thread = Thread.new { OpenSSL::SSL::SSLSocket.new(client).connect }
           ssl_peer = Celluloid::IO::SSLSocket.new peer, server_context
-          ssl_peer.should eq(ssl_peer.accept)
+          expect(ssl_peer).to eq(ssl_peer.accept)
           ssl_client = client_thread.value
 
           ssl_peer << request
-          ssl_client.read(request.size).should eq(request)
+          expect(ssl_client.read(request.size)).to eq(request)
 
           ssl_client << response
-          ssl_peer.read(response.size).should eq(response)
+          expect(ssl_peer.read(response.size)).to eq(response)
         end
       end
     end
@@ -110,80 +113,83 @@ describe Celluloid::IO::SSLSocket do
     it "connects to SSL servers over TCP" do
       with_ssl_sockets do |ssl_client, ssl_peer|
         ssl_peer << request
-        ssl_client.read(request.size).should eq(request)
+        expect(ssl_client.read(request.size)).to eq(request)
 
         ssl_client << response
-        ssl_peer.read(response.size).should eq(response)
+        expect(ssl_peer.read(response.size)).to eq(response)
       end
     end
 
     it "starts SSL on a connected TCP socket" do
-      pending "JRuby support" if defined?(JRUBY_VERSION)
+      if RUBY_PLATFORM == 'java'
+        pending "JRuby support"
+        fail "Bypassing potential deadlock."
+      end
       with_raw_sockets do |client, peer|
         peer << request
-        client.read(request.size).should eq(request)
+        expect(client.read(request.size)).to eq(request)
 
         client << response
-        peer.read(response.size).should eq(response)
+        expect(peer.read(response.size)).to eq(response)
 
         # now that we've written bytes, upgrade to SSL
         client_thread = Thread.new { OpenSSL::SSL::SSLSocket.new(client).connect }
         ssl_peer = Celluloid::IO::SSLSocket.new peer, server_context
-        ssl_peer.should eq(ssl_peer.accept)
+        expect(ssl_peer).to eq(ssl_peer.accept)
         ssl_client = client_thread.value
 
         ssl_peer << request
-        ssl_client.read(request.size).should eq(request)
+        expect(ssl_client.read(request.size)).to eq(request)
 
         ssl_client << response
-        ssl_peer.read(response.size).should eq(response)
+        expect(ssl_peer.read(response.size)).to eq(response)
       end
     end
   end
 
   it "knows its cert" do
     # FIXME: seems bad? o_O
-    pending "wtf is wrong with this on JRuby" if defined? JRUBY_VERSION
+    pending "wtf is wrong with this on JRuby" if RUBY_PLATFORM == 'java'
     with_ssl_sockets do |ssl_client|
-      ssl_client.cert.to_der.should eq(client_cert.to_der)
+      expect(ssl_client.cert.to_der).to eq(client_cert.to_der)
     end
   end
 
   it "knows its peer_cert" do
     with_ssl_sockets do |ssl_client|
-      ssl_client.peer_cert.to_der.should eq(ssl_client.to_io.peer_cert.to_der)
+      expect(ssl_client.peer_cert.to_der).to eq(ssl_client.to_io.peer_cert.to_der)
     end
   end
 
   it "knows its peer_cert_chain" do
     with_ssl_sockets do |ssl_client|
-      ssl_client.peer_cert_chain.zip(ssl_client.to_io.peer_cert_chain).map do |c1, c2|
+      expect(ssl_client.peer_cert_chain.zip(ssl_client.to_io.peer_cert_chain).map do |c1, c2|
         c1.to_der == c2.to_der
-      end.should be_all
+      end).to be_all
     end
   end
 
   it "knows its cipher" do
     with_ssl_sockets do |ssl_client|
-      ssl_client.cipher.should eq(ssl_client.to_io.cipher)
+      expect(ssl_client.cipher).to eq(ssl_client.to_io.cipher)
     end
   end
 
   it "knows its client_ca" do
     # jruby-openssl does not implement this method
-    pending "jruby-openssl support" if defined? JRUBY_VERSION
+    pending "jruby-openssl support" if RUBY_PLATFORM == 'java'
 
     with_ssl_sockets do |ssl_client|
-      ssl_client.client_ca.should eq(ssl_client.to_io.client_ca)
+      expect(ssl_client.client_ca).to eq(ssl_client.to_io.client_ca)
     end
   end
 
   it "verifies peer certificates" do
     # FIXME: JRuby seems to be giving the wrong result here o_O
-    pending "jruby-openssl support" if defined? JRUBY_VERSION
+    pending "jruby-openssl support" if RUBY_PLATFORM == 'java'
 
     with_ssl_sockets do |ssl_client, ssl_peer|
-      ssl_client.verify_result.should eq(OpenSSL::X509::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT)
+      expect(ssl_client.verify_result).to eq(OpenSSL::X509::V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT)
     end
   end