celluloid-io 0.14.1 → 0.15.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c82454c284234ca1c206dab2aaea9cb4190b8e60
-  data.tar.gz: b66f5869c880be9551294363865dfd7c5555e377
+  metadata.gz: 7ba7ea0fac5d91976c3b8a556686e8d4b778fc7b
+  data.tar.gz: 65297d64467f098af4097564c9b266b83d273b09
 SHA512:
-  metadata.gz: 57b61a4028497fd37fedc84ea1fc4ffe485475959931e115f1d8485b9cd7b517420fbec83b6a2e85f4e2a57f7ac79e6d62eb5d4f5069fed12e66f9ed07e29488
-  data.tar.gz: 7f2f28bf81ae7bf8c91fe43bf5456da3a40123e6e7c81bb774bb3da99e0f8b14eb6d0a6e319173a861f445781a12bab05641f6dbc4c274191df3cdf07dc9aa1e
+  metadata.gz: 65b04ba6086bf29c11e8b12faf2d7f674660be68b67c77161d4658b7248885602f7cb3dff056af97355ba9e3ab9a3d32e9879e65468f344a3cff19bc65856a99
+  data.tar.gz: af01de9578c5408dea445db8ff076d75e75bc3ddca754c4c07895f486c9fed15bd10beab6f3808f2d291be38994e3d6e3af389ed88a7eb813cb8339b26c94840

data/.travis.yml

@@ -10,7 +10,6 @@ rvm:
 matrix:
   allow_failures:
     - rvm: ruby-head
-    - rvm: jruby-19mode
     - rvm: jruby-head
     - rvm: rbx-19mode
 

data/CHANGES.md

@@ -1,7 +1,9 @@
-0.14.1 (2013-06-01)
--------------------
-* Remove obsolete code for condition owners which is broken by the
-  Celluloid 0.14.1 release.
+0.15.0.pre (2013-08-21)
+-----------------------
+* Improved DNS resolver with less NIH and more Ruby stdlib goodness
+* Better match Ruby stdlib TCPServer API
+* Add missing #setsockopt method on Celluloid::IO::TCPServer
+* Add missing #peeraddr method on Celluloid::IO::SSLSocket
 
 0.14.0 (2013-05-07)
 -------------------

data/Gemfile

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'coveralls', require: false
-gem 'celluloid', github: 'celluloid/celluloid', branch: '0-14-stable'
+gem 'celluloid', github: 'celluloid/celluloid', branch: 'master'

data/README.md

@@ -30,7 +30,7 @@ library just to take advantage of Celluloid::IO's event loop and you can
 freely switch between evented and blocking IO even over the lifetime of a
 single connection.
 
-Celluloid::IO uses the [nio4r gem](https://github.com/tarcieri/nio4r)
+Celluloid::IO uses the [nio4r gem](https://github.com/celluloid/nio4r)
 to monitor IO objects, which provides cross-platform and cross-Ruby
 implementation access to high-performance system calls such as epoll
 and kqueue.

data/benchmarks/actor.rb

@@ -37,7 +37,7 @@ end
 
 Benchmark.ips do |ips|
   ips.report("spawn")       { ExampleActor.new.terminate }
-  
+
   ips.report("calls")       { example_actor.example_method }
 
   ips.report("async calls") do |n|

data/celluloid-io.gemspec

@@ -15,8 +15,8 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Celluloid::IO::VERSION
 
-  gem.add_dependency 'celluloid', '>= 0.14.1'
-  gem.add_dependency 'nio4r',     '>= 0.4.5'
+  gem.add_dependency 'celluloid', '>= 0.15.0.pre'
+  gem.add_dependency 'nio4r',     '>= 0.5.0'
 
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'

data/lib/celluloid/io/dns_resolver.rb

@@ -5,36 +5,22 @@ module Celluloid
     # Asynchronous DNS resolver using Celluloid::IO::UDPSocket
     class DNSResolver
       RESOLV_CONF = '/etc/resolv.conf'
-      HOSTS       = '/etc/hosts'
       DNS_PORT    = 53
-      
+
       @mutex = Mutex.new
       @identifier = 1
-      
+
       def self.generate_id
         @mutex.synchronize { @identifier = (@identifier + 1) & 0xFFFF }
       end
-      
+
       def self.nameservers(config = RESOLV_CONF)
         File.read(config).scan(/^\s*nameserver\s+([0-9.:]+)/).flatten
       end
 
-      # FIXME: Y U NO Resolv::Hosts?     
-      def self.hosts(hostfile = HOSTS)
-        hosts = {}
-        File.open(hostfile) do |f|
-          f.each_line do |host_entry|
-            entries = host_entry.gsub(/#.*$/, '').gsub(/\s+/, ' ').split(' ')
-            addr = entries.shift
-            entries.each { |e| hosts[e] ||= addr }
-          end
-        end
-        hosts
-      end
-      
       def initialize
-        @nameservers, @hosts = self.class.nameservers, self.class.hosts
-        
+        @nameservers = self.class.nameservers
+
         # TODO: fall back on other nameservers if the first one is unavailable
         @server = @nameservers.first
 
@@ -42,42 +28,61 @@ module Celluloid
         # Celluloid::IO::UDPSocket
         @socket = UDPSocket.new
       end
-      
-      def resolve(hostname)
-        host = @hosts[hostname]
-        if host
-          begin
-            return Resolv::IPv4.create(host)
-          rescue ArgumentError
-          end
 
-          begin
-            return Resolv::IPv6.create(host)
-          rescue ArgumentError
+      def resolve(hostname)
+        if host = resolve_hostname(hostname)
+          unless ip_address = resolve_host(host)
+            raise Resolv::ResolvError, "invalid entry in hosts file: #{host}"
           end
-          
-          raise Resolv::ResolvError, "invalid entry in hosts file: #{host}"
+          return ip_address
         end
-        
-        query = Resolv::DNS::Message.new
-        query.id = self.class.generate_id
-        query.rd = 1
-        query.add_question hostname, Resolv::DNS::Resource::IN::A
-        
+
+        query = build_query(hostname)
         @socket.send query.encode, 0, @server, DNS_PORT
         data, _ = @socket.recvfrom(512)
         response = Resolv::DNS::Message.decode(data)
-        
+
         addrs = []
         # The answer might include IN::CNAME entries so filters them out
         # to include IN::A & IN::AAAA entries only.
-        response.each_answer { |name, ttl, value| addrs << (value.respond_to?(:address) ? value.address : nil) }
-        addrs.compact!
-        
+        response.each_answer { |name, ttl, value| addrs << value.address if value.respond_to?(:address) }
+
         return if addrs.empty?
         return addrs.first if addrs.size == 1
         addrs
       end
+
+      private
+
+      def resolve_hostname(hostname)
+        # Resolv::Hosts#getaddresses pushes onto a stack
+        # so since we want the first occurance, simply
+        # pop off the stack.
+        resolv.getaddresses(hostname).pop rescue nil
+      end
+
+      def resolv
+        @resolv ||= Resolv::Hosts.new
+      end
+
+      def build_query(hostname)
+        Resolv::DNS::Message.new.tap do |query|
+          query.id = self.class.generate_id
+          query.rd = 1
+          query.add_question hostname, Resolv::DNS::Resource::IN::A
+        end
+      end
+
+      def resolve_host(host)
+        resolve_ip(Resolv::IPv4, host) || resolve_ip(Resolv::IPv6, host)
+      end
+
+      def resolve_ip(klass, host)
+        begin
+          klass.create(host)
+        rescue ArgumentError
+        end
+      end
     end
   end
 end

data/lib/celluloid/io/ssl_socket.rb

@@ -7,7 +7,7 @@ module Celluloid
       extend Forwardable
 
       def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?,
-        :cert, :cipher, :client_ca, :peer_cert, :peer_cert_chain, :verify_result
+        :cert, :cipher, :client_ca, :peer_cert, :peer_cert_chain, :verify_result, :peeraddr
 
       def initialize(io, ctx = OpenSSL::SSL::SSLContext.new)
         super()

data/lib/celluloid/io/tcp_server.rb

@@ -5,10 +5,10 @@ module Celluloid
     # TCPServer with combined blocking and evented support
     class TCPServer
       extend Forwardable
-      def_delegators :@server, :listen, :sysaccept, :close, :closed?, :addr
+      def_delegators :@server, :listen, :sysaccept, :close, :closed?, :addr, :setsockopt
 
-      def initialize(hostname, port)
-        @server = ::TCPServer.new(hostname, port)
+      def initialize(hostname_or_port, port = nil)
+        @server = ::TCPServer.new(hostname_or_port, port)
       end
 
       def accept

data/lib/celluloid/io/tcp_socket.rb

@@ -37,7 +37,7 @@ module Celluloid
       # local end to establish the connection.
       def initialize(remote_host, remote_port = nil, local_host = nil, local_port = nil)
         super()
-        
+
         # Allow users to pass in a Ruby TCPSocket directly
         if remote_host.is_a? ::TCPSocket
           @addr = nil
@@ -65,7 +65,7 @@ module Celluloid
         unless @addr
           addrs = Array(DNSResolver.new.resolve(remote_host))
           raise Resolv::ResolvError, "DNS result has no information for #{remote_host}" if addrs.empty?
-          
+
           # Pseudorandom round-robin DNS support :/
           @addr = addrs[rand(addrs.size)]
         end

data/lib/celluloid/io/unix_socket.rb

@@ -22,7 +22,7 @@ module Celluloid
       # Open a UNIX connection.
       def initialize(socket_path, &block)
         super()
-        
+
         # Allow users to pass in a Ruby UNIXSocket directly
         if socket_path.is_a? ::UNIXSocket
           @socket = socket_path

data/lib/celluloid/io/version.rb

@@ -1,5 +1,5 @@
 module Celluloid
   module IO
-    VERSION = "0.14.1"
+    VERSION = "0.15.0.pre"
   end
 end

data/spec/celluloid/io/dns_resolver_spec.rb

@@ -1,26 +1,33 @@
 require 'spec_helper'
 
 describe Celluloid::IO::DNSResolver do
-  it "resolves domain names" do
-    resolver = Celluloid::IO::DNSResolver.new
-    resolver.resolve("celluloid.io").should == Resolv::IPv4.create("207.97.227.245")
-  end
+  describe '#resolve' do
+    it 'resolves hostnames' do
+      resolver = Celluloid::IO::DNSResolver.new
+      resolver.resolve('localhost').should eq Resolv::IPv4.create("127.0.0.1")
+    end
 
-  it "resolves CNAME responses" do
-    resolver = Celluloid::IO::DNSResolver.new
-    results = resolver.resolve("www.google.com")
-    if results.is_a?(Array)
-      results.all? {|i| i.is_a?(Resolv::IPv4) }.should be_true
-    else
-      results.is_a?(Resolv::IPv4).should be_true
+    it "resolves domain names" do
+      resolver = Celluloid::IO::DNSResolver.new
+      resolver.resolve("celluloid.io").should == Resolv::IPv4.create("207.97.227.245")
     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.is_a?(Resolv::IPv4) }.should be_true
-    else
-      results.is_a?(Resolv::IPv4).should be_true
+
+    it "resolves CNAME responses" 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) }
+      else
+        results.should 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) }
+      else
+        results.should be_an_instance_of(Resolv::IPv4)
+      end
     end
   end
 end

data/spec/celluloid/io/ssl_socket_spec.rb

@@ -59,6 +59,14 @@ describe Celluloid::IO::SSLSocket do
     end
   end
 
+  context "duck typing ::SSLSocket" do
+    it "responds to #peeraddr" do
+      with_ssl_sockets do |ssl_client, ssl_peer|
+        expect{ ssl_client.peeraddr }.to_not raise_error
+      end
+    end
+  end
+
   context "inside Celluloid::IO" do
     it "connects to SSL servers over TCP" do
       with_ssl_sockets do |ssl_client, ssl_peer|

data/spec/celluloid/io/tcp_server_spec.rb

@@ -4,6 +4,10 @@ describe Celluloid::IO::TCPServer do
   describe "#accept" do
     let(:payload) { 'ohai' }
 
+    it "can be initialized without a host" do
+      expect{ server = Celluloid::IO::TCPServer.new(2000); server.close }.to_not raise_error
+    end
+
     context "inside Celluloid::IO" do
       it "should be evented" do
         with_tcp_server do |subject|

data/spec/celluloid/io/tcp_socket_spec.rb

@@ -79,6 +79,32 @@ describe Celluloid::IO::TCPSocket do
       }.to raise_error(Errno::ECONNREFUSED)
     end
 
+    context 'eof?' do
+      it "blocks actor then returns by close" do
+        with_connected_sockets do |subject, peer|
+          started_at = Time.now
+          Thread.new{ sleep 0.5; peer.close; }
+          within_io_actor { subject.eof? }
+          (Time.now - started_at).should > 0.5
+        end
+      end
+      
+      it "blocks until gets the next byte" do
+        with_connected_sockets do |subject, peer|
+          peer << 0x00
+          peer.flush
+          expect {
+            within_io_actor {
+              subject.read(1)
+              Celluloid.timeout(0.5) {
+                subject.eof?.should be_false
+              }
+            }
+          }.to raise_error(Celluloid::Task::TimeoutError)
+        end
+      end
+    end
+
     context "readpartial" do
       it "raises EOFError when reading from a closed socket" do
         with_connected_sockets do |subject, peer|
@@ -90,7 +116,7 @@ describe Celluloid::IO::TCPSocket do
       end
 
       it "raises IOError when active sockets are closed across threads" do
-	      pending "not implemented"
+        pending "not implemented"
 
         with_connected_sockets do |subject, peer|
           actor = ExampleActor.new

data/spec/celluloid/io/unix_server_spec.rb

@@ -26,7 +26,7 @@ describe Celluloid::IO::UNIXServer do
           peer.read(payload.size).should eq payload
         end
       end
-      
+
       it "raises if server already up" do
         with_unix_server do |subject|
           within_io_actor do
@@ -55,7 +55,7 @@ describe Celluloid::IO::UNIXServer do
             peer.read(payload.size).should eq payload
           end
         end
-          
+
         it "raises if server already up" do
           with_unix_server do |subject|
             expect {
@@ -63,7 +63,7 @@ describe Celluloid::IO::UNIXServer do
             }.to raise_error(Errno::EADDRINUSE)
           end
         end
-        
+
       end
     end
   end

data/spec/celluloid/io/unix_socket_spec.rb

@@ -92,6 +92,32 @@ describe Celluloid::IO::UNIXSocket do
         }.to raise_error(EOFError)
       end
     end
+
+    context 'eof?' do
+      it "blocks actor then returns by close" do
+        with_connected_sockets do |subject, peer|
+          started_at = Time.now
+          Thread.new{ sleep 0.5; peer.close; }
+          within_io_actor { subject.eof? }
+          (Time.now - started_at).should > 0.5
+        end
+      end
+      
+      it "blocks until gets the next byte" do
+        with_connected_sockets do |subject, peer|
+          peer << 0x00
+          peer.flush
+          expect {
+            within_io_actor {
+              subject.read(1)
+              Celluloid.timeout(0.5) {
+                subject.eof?.should be_false
+              }
+            }
+          }.to raise_error(Celluloid::Task::TimeoutError)
+        end
+      end
+    end
   end
 
   context "outside Celluloid::IO" do

data/spec/spec_helper.rb

@@ -6,21 +6,23 @@ require 'coveralls'
 Coveralls.wear!
 
 logfile = File.open(File.expand_path("../../log/test.log", __FILE__), 'a')
-Celluloid.logger = Logger.new(logfile)
+logfile.sync = true
+
+logger = Celluloid.logger = Logger.new(logfile)
+
+Celluloid.shutdown_timeout = 1
 
 RSpec.configure do |config|
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+
   config.before do
+    Celluloid.logger = logger
     Celluloid.shutdown
+
     Celluloid.boot
-    FileUtils.rm("/tmp/cell_sock") if File.exist?("/tmp/cell_sock")
-  end
-end
 
-# FIXME: Hax until test termination can be cleaned up
-module Celluloid
-  class << self
-    undef :shutdown
-    def shutdown; end # hax: noop!
+    FileUtils.rm("/tmp/cell_sock") if File.exist?("/tmp/cell_sock")
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: celluloid-io
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.15.0.pre
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-01 00:00:00.000000000 Z
+date: 2013-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.14.1
+        version: 0.15.0.pre
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.14.1
+        version: 0.15.0.pre
 - !ruby/object:Gem::Dependency
   name: nio4r
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.4.5
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.4.5
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -177,9 +177,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.3