celluloid-io 0.12.1 → 0.13.0.pre

data/.travis.yml

@@ -3,12 +3,13 @@ rvm:
   - 1.9.3
   - ruby-head
   - jruby-19mode
+  - rbx-19mode
+  - jruby-head
 
-# Getting a deadlock in the nonblocking connect code :(
-#  - jruby-head
-
-# See https://github.com/rubinius/rubinius/issues/1611
-#  - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
 
 notifications:
   irc: "irc.freenode.org#celluloid"

data/CHANGES.md

@@ -1,6 +1,8 @@
-0.12.1
-------
-* Non-blocking connect workaround for JRuby
+0.13.0.pre
+----------
+* Initial SSL support via Celluloid::IO::SSLSocket and
+  Celluloid::IO::SSLServer
+* Celluloid 0.13 compatibility fixes
 
 0.12.0
 ------

data/Gemfile

@@ -1,6 +1,6 @@
 source :rubygems
 
-gem 'celluloid', :git => 'git://github.com/celluloid/celluloid'
+#gem 'celluloid', :git => 'git://github.com/celluloid/celluloid'
 
 # Specify your gem's dependencies in celluloid-io.gemspec
 gemspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', :cli => '--format documentation' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec/" }
+end

data/README.md

@@ -2,6 +2,7 @@
 =============
 [![Build Status](https://secure.travis-ci.org/celluloid/celluloid-io.png?branch=master)](http://travis-ci.org/celluloid/celluloid-io)
 [![Dependency Status](https://gemnasium.com/celluloid/celluloid-io.png)](https://gemnasium.com/celluloid/celluloid-io)
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/celluloid/celluloid-io)
 
 You don't have to choose between threaded and evented IO! Celluloid::IO
 provides an event-driven IO system for building fast, scalable network
@@ -35,6 +36,37 @@ and kqueue.
 
 Like Celluloid::IO? [Join the Google Group](http://groups.google.com/group/celluloid-ruby)
 
+When should I use Celluloid::IO?
+--------------------------------
+
+Unlike systems like Node.js, Celluloid does not require that all I/O be
+"evented". Celluloid fully supports any libraries that support blocking I/O
+and for the *overwhelming majority* of use cases blocking I/O is more than
+sufficient. Using blocking I/O means that any Ruby library you want will
+Just Work without resorting to any kind of theatrics.
+
+Celluloid::IO exists for a few reasons:
+
+* During a blocking I/O operation, Celluloid actors cannot respond to incoming
+  messages to their mailboxes. They will process messages as soon as the
+  method containing a blocking I/O operation completes, however until this
+  happens the entire actor is blocked. If you would like to multiplex both
+  message processing and I/O operations, you will want to use Celluloid::IO.
+  This is especially important for *indefinite* blocking operations, such as
+  listening for incoming TCP connections.
+* Celluloid uses a native thread per actor. While native threads aren't
+  particularly expensive in Ruby (~20kB of RAM), you can use less RAM using
+  Celluloid::IO. You might consider using Celluloid::IO over an 
+  actor-per-connection if you are dealing with 10,000 connections or more.
+* The goal of Celluloid::IO is to fully integrate it into the Celluloid
+  ecosystem, including DCell. DCell will hopefully eventually support
+  serializable I/O handles that you can seamlessly transfer between nodes.
+
+All that said, if you are just starting out with Celluloid, you probably want
+to start off using blocking I/O until you understand the fundamentals of
+Celluloid and have encountered one of the above reasons for switching
+over to Celluloid::IO.
+
 Supported Platforms
 -------------------
 

data/benchmarks/actor.rb

@@ -2,12 +2,25 @@
 
 require 'rubygems'
 require 'bundler/setup'
-require 'celluloid/io'
+require 'celluloid'
 require 'benchmark/ips'
 
 class ExampleActor
   include Celluloid::IO
+
+  def initialize
+    @condition = Condition.new
+  end
+
   def example_method; end
+
+  def finished
+    @condition.signal
+  end
+
+  def wait_until_finished
+    @condition.wait
+  end
 end
 
 example_actor = ExampleActor.new
@@ -24,11 +37,18 @@ end
 
 Benchmark.ips do |ips|
   ips.report("spawn")       { ExampleActor.new.terminate }
-  ips.report("calls")       { example_actor.example_method }
-  
-  # FIXME: deadlock?! o_O
-  ips.report("async calls") { example_actor.example_method! } unless RUBY_ENGINE == 'ruby'
   
+  ips.report("calls")       { example_actor.example_method }
+
+  ips.report("async calls") do |n|
+    waiter = example_actor.future.wait_until_finished
+
+    for i in 1..n; example_actor.async.example_method; end
+    example_actor.async.finished
+
+    waiter.value
+  end
+
   ips.report("messages") do |n|
     latch_in << n
     for i in 0..n; mailbox << :message; end

data/celluloid-io.gemspec

@@ -15,10 +15,12 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Celluloid::IO::VERSION
 
-  gem.add_dependency 'celluloid', '~> 0.12.0'
+  gem.add_dependency 'celluloid', '>= 0.13.0.pre'
   gem.add_dependency 'nio4r',     '>= 0.4.0'
-  
+
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
   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/examples/echo_server.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-$:.push File.expand_path('../../lib', __FILE__)
+require 'bundler/setup'
 require 'celluloid/io'
 
 class EchoServer

data/examples/echo_unix_client.rb

@@ -0,0 +1,28 @@
+require 'bundler/setup'
+require 'celluloid/io'
+
+class EchoUNIXClient
+  include Celluloid::IO
+
+  def initialize(socket_path)
+    puts "*** connecting to #{socket_path}"
+    @socket_path = socket_path
+    @socket = UNIXSocket.open(socket_path)
+  end
+
+  def echo(msg)
+    puts "*** send to server: '#{msg}'"
+    @socket.puts(msg)
+    data = @socket.readline.chomp
+    puts "*** server unswer '#{data}'"
+    data
+  end
+
+  def finalize
+    @socket.close if @socket
+  end
+
+end
+
+c = EchoUNIXClient.new("/tmp/sock_test")
+c.echo("DATA")

data/examples/echo_unix_server.rb

@@ -0,0 +1,43 @@
+require 'bundler/setup'
+require 'celluloid/io'
+
+class EchoUNIXServer
+  include Celluloid::IO
+    
+  attr_reader :socket_path, :server
+
+  def initialize(socket_path)
+    puts "*** start server #{socket_path}"
+    @socket_path = socket_path
+    @server = UNIXServer.open(socket_path)
+  end
+
+  def run
+    loop { handle_connection! @server.accept }
+  end
+
+  def handle_connection(socket)
+    loop do
+      data = socket.readline
+      puts "*** gets data #{data}"
+      socket.write(data)
+    end
+  
+  rescue EOFError
+    puts "*** disconnected"
+
+  ensure
+    socket.close
+  end
+
+  def finalize
+    if @server
+      @server.close
+      File.delete(@socket_path)
+    end
+  end
+
+end
+
+s = EchoUNIXServer.new("/tmp/sock_test")
+s.run

data/lib/celluloid/io/common_methods.rb

@@ -4,7 +4,7 @@ module Celluloid
     module CommonMethods
       # Are we inside of a Celluloid::IO actor?
       def evented?
-        actor = Thread.current[:actor]
+        actor = Thread.current[:celluloid_actor]
         actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
       end
 
@@ -29,7 +29,7 @@ module Celluloid
       # Request exclusive control for a particular operation
       # Type should be one of :r (read) or :w (write)
       def acquire_ownership(type)
-        return unless Thread.current[:actor]
+        return unless Thread.current[:celluloid_actor]
 
         case type
         when :r
@@ -40,14 +40,14 @@ module Celluloid
         end
 
         # Celluloid needs a better API here o_O
-        Thread.current[:actor].wait(self) while instance_variable_get(ivar)
+        Thread.current[:celluloid_actor].wait(self) while instance_variable_defined?(ivar) && instance_variable_get(ivar)
         instance_variable_set(ivar, Task.current)
       end
 
       # Release ownership for a particular operation
       # Type should be one of :r (read) or :w (write)
       def release_ownership(type)
-        return unless Thread.current[:actor]
+        return unless Thread.current[:celluloid_actor]
 
         case type
         when :r
@@ -57,13 +57,13 @@ module Celluloid
         else raise ArgumentError, "invalid ownership type: #{type}"
         end
 
-        raise "not owner" unless instance_variable_get(ivar) == Task.current
+        raise "not owner" unless instance_variable_defined?(ivar) && instance_variable_get(ivar) == Task.current
         instance_variable_set(ivar, nil)
-        Thread.current[:actor].signal(self)
+        Thread.current[:celluloid_actor].signal(self)
       end
 
       def read(length = nil, buffer = nil)
-        buffer ||= ''
+        buffer ||= ''.force_encoding(Encoding::ASCII_8BIT)
         remaining = length
 
         acquire_ownership :r
@@ -97,7 +97,7 @@ module Celluloid
       end
 
       def readpartial(length, buffer = nil)
-        buffer ||= ''
+        buffer ||= ''.force_encoding(Encoding::ASCII_8BIT)
 
         begin
           read_nonblock(length, buffer)
@@ -136,7 +136,11 @@ module Celluloid
 
         total_written
       end
-      alias_method :<<, :write
+      
+      def <<(string)
+        write string
+        self
+      end
     end
   end
 end

data/lib/celluloid/io/mailbox.rb

@@ -5,8 +5,8 @@ module Celluloid
       attr_reader :reactor
 
       def initialize(reactor = nil)
-        @messages = []
-        @mutex = Mutex.new
+        super()
+        # @condition won't be used in the class.
         @reactor = reactor || Reactor.new
       end
 
@@ -26,7 +26,7 @@ module Celluloid
             @messages << message
           end
           
-          current_actor = Thread.current[:actor]
+          current_actor = Thread.current[:celluloid_actor]
           @reactor.wakeup unless current_actor && current_actor.mailbox == self
         rescue IOError
           raise MailboxError, "dead recipient"

data/lib/celluloid/io/reactor.rb

@@ -29,14 +29,14 @@ module Celluloid
       # Wait for the given IO operation to complete
       def wait(io, set)
         # zomg ugly type conversion :(
-        unless io.is_a?(::IO)
+        unless io.is_a?(::IO) or io.is_a?(OpenSSL::SSL::SSLSocket)
           if io.respond_to? :to_io
             io = io.to_io
           elsif ::IO.respond_to? :try_convert
             io = ::IO.try_convert(io)
           end
 
-          raise TypeError, "can't convert #{io.class} into IO" unless io.is_a? IO
+          raise TypeError, "can't convert #{io.class} into IO" unless io.is_a?(::IO)
         end
 
         monitor = @selector.register(io, set)

data/lib/celluloid/io/ssl_server.rb

@@ -0,0 +1,36 @@
+require 'socket'
+
+module Celluloid
+  module IO
+    # SSLServer wraps a TCPServer to provide immediate SSL accept
+    class SSLServer
+      extend Forwardable
+      def_delegators :@tcp_server, :listen, :shutdown, :close, :closed?, :to_io, :evented?
+
+      attr_accessor :start_immediately
+      attr_reader :tcp_server
+
+      def initialize(server, ctx)
+        if server.is_a?(::TCPServer)
+          server = Celluloid::IO::TCPServer.from_ruby_server(server)
+        end
+        @tcp_server = server
+        @ctx = ctx
+        @start_immediately = true
+      end
+
+      def accept
+        sock = @tcp_server.accept
+        begin
+          ssl = Celluloid::IO::SSLSocket.new(sock, @ctx)
+          ssl.accept if @start_immediately
+          ssl
+        rescue SSLError
+          sock.close
+          raise
+        end
+      end
+    end
+  end
+end
+

data/lib/celluloid/io/ssl_socket.rb

@@ -0,0 +1,39 @@
+require 'openssl'
+
+module Celluloid
+  module IO
+    # SSLSocket with Celluloid::IO support
+    class SSLSocket
+      include CommonMethods
+      extend Forwardable
+
+      def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?,
+        :cert, :cipher, :client_ca, :peer_cert, :peer_cert_chain, :verify_result
+
+      def initialize(io, ctx = OpenSSL::SSL::SSLContext.new)
+        @context = ctx
+        @socket = OpenSSL::SSL::SSLSocket.new(::IO.try_convert(io), @context)
+      end
+
+      def connect
+        @socket.connect_nonblock
+      rescue ::IO::WaitReadable
+        wait_readable
+        retry
+      end
+
+      def accept
+        @socket.accept_nonblock
+        self
+      rescue ::IO::WaitReadable
+        wait_readable
+        retry
+      rescue ::IO::WaitWritable
+        wait_writable
+        retry
+      end
+
+      def to_io; @socket; end
+    end
+  end
+end

data/lib/celluloid/io/tcp_server.rb

@@ -5,14 +5,14 @@ module Celluloid
     # TCPServer with combined blocking and evented support
     class TCPServer
       extend Forwardable
-      def_delegators :@server, :listen, :sysaccept, :close, :closed?
+      def_delegators :@server, :listen, :sysaccept, :close, :closed?, :addr
 
       def initialize(hostname, port)
         @server = ::TCPServer.new(hostname, port)
       end
 
       def accept
-        actor = Thread.current[:actor]
+        actor = Thread.current[:celluloid_actor]
 
         if evented?
           Celluloid.current_actor.wait_readable @server
@@ -32,9 +32,16 @@ module Celluloid
 
       # Are we inside a Celluloid ::IO actor?
       def evented?
-        actor = Thread.current[:actor]
+        actor = Thread.current[:celluloid_actor]
         actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
       end
+
+      # Convert a Ruby TCPServer into a Celluloid::IO::TCPServer
+      def self.from_ruby_server(ruby_server)
+        server = allocate
+        server.instance_variable_set(:@server, ruby_server)
+        server
+      end
     end
   end
 end

data/lib/celluloid/io/tcp_socket.rb

@@ -39,8 +39,6 @@ module Celluloid
 
         # Guess it's not an IP address, so let's try DNS
         unless @addr
-          # TODO: suppport asynchronous DNS
-          # Even EventMachine doesn't do async DNS by default o_O
           addrs = Array(DNSResolver.new.resolve(remote_host))
           raise Resolv::ResolvError, "DNS result has no information for #{remote_host}" if addrs.empty?
           

data/lib/celluloid/io/udp_socket.rb

@@ -11,7 +11,7 @@ module Celluloid
 
       # Are we inside of a Celluloid::IO actor?
       def evented?
-        actor = Thread.current[:actor]
+        actor = Thread.current[:celluloid_actor]
         actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
       end
 

data/lib/celluloid/io/unix_server.rb

@@ -0,0 +1,44 @@
+require 'socket'
+
+module Celluloid
+  module IO
+    # UNIXServer with combined blocking and evented support
+    class UNIXServer
+      extend Forwardable
+      def_delegators :@server, :listen, :sysaccept, :close, :closed?
+
+      def self.open(socket_path)
+        self.new(socket_path)
+      end
+
+      def initialize(socket_path)
+        @server = ::UNIXServer.new(socket_path)
+      end
+
+      def accept
+        actor = Thread.current[:celluloid_actor]
+
+        if evented?
+          Celluloid.current_actor.wait_readable @server
+          accept_nonblock
+        else
+          Celluloid::IO::UNIXSocket.from_ruby_socket @server.accept
+        end
+      end
+
+      def accept_nonblock
+        Celluloid::IO::UNIXSocket.from_ruby_socket @server.accept_nonblock
+      end
+
+      def to_io
+        @server
+      end
+
+      # Are we inside a Celluloid ::IO actor?
+      def evented?
+        actor = Thread.current[:celluloid_actor]
+        actor && actor.mailbox.is_a?(Celluloid::IO::Mailbox)
+      end
+    end
+  end
+end

data/lib/celluloid/io/unix_socket.rb

@@ -0,0 +1,40 @@
+require 'socket'
+
+module Celluloid
+  module IO
+    # UNIXSocket with combined blocking and evented support
+    class UNIXSocket
+      include CommonMethods
+      extend Forwardable
+
+      def_delegators :@socket, :read_nonblock, :write_nonblock, :close, :closed?, :readline, :puts, :addr
+
+      # Convert a Ruby UNIXSocket into a Celluloid::IO::UNIXSocket
+      def self.from_ruby_socket(ruby_socket)
+        # Some hax here, but whatever ;)
+        socket = allocate
+        socket.instance_variable_set(:@socket, ruby_socket)
+        socket
+      end
+
+      # Open a UNIX connection.
+      def self.open(socket_path, &block)
+        self.new(socket_path, &block)
+      end
+
+      # Open a UNIX connection.
+      def initialize(socket_path, &block)
+        # FIXME: not doing non-blocking connect
+        @socket = if block
+          ::UNIXSocket.open(socket_path, &block)
+        else
+          ::UNIXSocket.new(socket_path)
+        end
+      end
+
+      def to_io
+        @socket
+      end
+    end
+  end
+end

data/lib/celluloid/io/version.rb

@@ -1,5 +1,5 @@
 module Celluloid
   module IO
-    VERSION = "0.12.1"
+    VERSION = "0.13.0.pre"
   end
 end

data/lib/celluloid/io.rb

@@ -10,13 +10,18 @@ require 'celluloid/io/reactor'
 require 'celluloid/io/tcp_server'
 require 'celluloid/io/tcp_socket'
 require 'celluloid/io/udp_socket'
+require 'celluloid/io/unix_server'
+require 'celluloid/io/unix_socket'
+
+require 'celluloid/io/ssl_server'
+require 'celluloid/io/ssl_socket'
 
 module Celluloid
   # Actors with evented IO support
   module IO
     def self.included(klass)
       klass.send :include, Celluloid
-      klass.use_mailbox Celluloid::IO::Mailbox
+      klass.mailbox_class Celluloid::IO::Mailbox
     end
 
     extend Forwardable

data/log/.gitignore

@@ -0,0 +1 @@
+*.log