celluloid 0.2.2 → 0.5.0

data/lib/celluloid/actor_pool.rb

@@ -0,0 +1,57 @@
+require 'thread'
+
+module Celluloid
+  class Actor
+    # Maintain a thread pool of actors FOR SPEED!!
+    class Pool
+      @pool = []
+      @lock = Mutex.new
+      @max_idle = 16
+
+      class << self
+        attr_accessor :max_idle
+
+        def get
+          @lock.synchronize do
+            if @pool.empty?
+              create
+            else
+              @pool.shift
+            end
+          end
+        end
+
+        def put(thread)
+          @lock.synchronize do
+            if @pool.size >= @max_idle
+              thread.kill
+            else
+              @pool << thread
+            end
+          end
+        end
+
+        def create
+          queue = Queue.new
+          thread = Thread.new do
+            begin
+              while true
+                queue.pop.call
+              end
+            rescue Exception => ex
+              # Rubinius hax
+              raise if defined?(Thread::Die) and ex.is_a? Thread::Die
+
+              message = "Celluloid::Actor::Pool internal failure:\n"
+              message << "#{ex.class}: #{ex.to_s}\n"
+              message << ex.backtrace.join("\n")
+              Celluloid.logger.error message if Celluloid.logger
+            end
+          end
+          thread[:queue] = queue
+          thread
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/actor_proxy.rb

@@ -5,54 +5,64 @@ module Celluloid
   class ActorProxy
     # FIXME: not nearly enough methods are delegated here
     attr_reader :mailbox
-    
+
     def initialize(actor, mailbox)
       @actor, @mailbox = actor, mailbox
     end
-    
+
     def send(meth, *args, &block)
       __call :send, meth, *args, &block
     end
-    
+
     def respond_to?(meth)
       __call :respond_to?, meth
     end
-    
+
     def methods(include_ancestors = true)
       __call :methods, include_ancestors
     end
-    
+
     def alive?
       @actor.alive?
     end
-    
+
     def to_s
       __call :to_s
     end
-    
+
     def inspect
       return __call :inspect if alive?
       "#<Celluloid::Actor(#{@actor.class}:0x#{@actor.object_id.to_s(16)}) dead>"
     end
-    
+
     # Create a Celluloid::Future which calls a given method
     def future(method_name, *args, &block)
       Celluloid::Future.new { __call method_name, *args, &block }
     end
-    
+
     # Terminate the associated actor
     def terminate
       raise DeadActorError, "actor already terminated" unless alive?
-      terminate!
+
+      begin
+        send :terminate
+      rescue DeadActorError
+        # In certain cases this is thrown during termination. This is likely
+        # a bug in Celluloid's internals, but it shouldn't affect the caller.
+        # FIXME: track this down and fix it, or at the very least log it
+      end
+
+      # Always return nil until a dependable exit value can be obtained
+      nil
     end
-    
+
     # method_missing black magic to call bang predicate methods asynchronously
     def method_missing(meth, *args, &block)
       # bang methods are async calls
-      if meth.to_s.match(/!$/) 
+      if meth.to_s.match(/!$/)
         unbanged_meth = meth.to_s.sub(/!$/, '')
         our_mailbox = Thread.current.mailbox
-        
+
         begin
           @mailbox << AsyncCall.new(our_mailbox, unbanged_meth, args, block)
         rescue MailboxError
@@ -61,22 +71,22 @@ module Celluloid
           # async calls should find other ways to deal with actors dying
           # during an async call (i.e. linking/supervisors)
         end
-        
+
         return # casts are async and return immediately
       end
-      
+
       __call(meth, *args, &block)
     end
-    
+
     #######
     private
     #######
-    
+
     # Make a synchronous call to the actor we're proxying to
     def __call(meth, *args, &block)
       our_mailbox = Thread.current.mailbox
       call = SyncCall.new(our_mailbox, meth, args, block)
-      
+
       begin
         @mailbox << call
       rescue MailboxError
@@ -111,4 +121,4 @@ module Celluloid
       end
     end
   end
-end
+end

data/lib/celluloid/core_ext.rb

@@ -1,6 +1,13 @@
 # Monkeypatch Thread to allow lazy access to its Celluloid::Mailbox
 class Thread
+  # Retrieve the current mailbox or lazily initialize it
   def mailbox
-    self[:mailbox] ||= Celluloid::Mailbox.new
+    self[:mailbox] || begin
+      if Thread.current != self
+        raise "attempt to access an uninitialized mailbox"
+      end
+
+      self[:mailbox] = Celluloid::Mailbox.new
+    end
   end
-end
+end

data/lib/celluloid/io.rb

@@ -0,0 +1,50 @@
+require 'celluloid/io/waker'
+require 'celluloid/io/reactor'
+require 'celluloid/io/mailbox'
+require 'celluloid/io/actor'
+
+module Celluloid
+  # Actors which can run alongside other I/O operations
+  module IO
+    def self.included(klass)
+      klass.send :include, ::Celluloid
+      klass.send :extend,  IO::ClassMethods
+    end
+
+    # Class methods added to classes which include Celluloid::IO
+    module ClassMethods
+      # Create a new actor
+      def new(*args, &block)
+        proxy = IO::Actor.new(allocate).proxy
+        proxy.send(:initialize, *args, &block)
+        proxy
+      end
+
+      # Create a new actor and link to the current one
+      def new_link(*args, &block)
+        current_actor = Thread.current[:actor]
+        raise NotActorError, "can't link outside actor context" unless current_actor
+
+        proxy = IO::Actor.new(allocate).proxy
+        current_actor.link proxy
+        proxy.send(:initialize, *args, &block)
+        proxy
+      end
+    end
+
+    #
+    # Instance methods
+    #
+
+    # Wait for the given IO object to become readable
+    def wait_readable(io, &block)
+      # Law of demeter be damned!
+      current_actor.mailbox.reactor.wait_readable(io, &block)
+    end
+
+    # Wait for the given IO object to become writeable
+    def wait_writeable(io, &block)
+      current_actor.mailbox.reactor.wait_writeable(io, &block)
+    end
+  end
+end

data/lib/celluloid/io/actor.rb

@@ -0,0 +1,10 @@
+module Celluloid
+  module IO
+    class Actor < Celluloid::Actor
+      # Use the special Celluloid::IO::Mailbox to handle incoming requests
+      def initialize_mailbox
+        Celluloid::IO::Mailbox.new
+      end
+    end
+  end
+end

data/lib/celluloid/io/mailbox.rb

@@ -0,0 +1,65 @@
+require 'thread'
+
+module Celluloid
+  module IO
+    # An alternative implementation of Celluloid::Mailbox using Wakers
+    class Mailbox < Celluloid::Mailbox
+      attr_reader :reactor
+
+      def initialize
+        @messages = []
+        @lock  = Mutex.new
+        @waker = Waker.new
+        @reactor = Reactor.new(@waker)
+      end
+
+      # Add a message to the Mailbox
+      def <<(message)
+        @lock.synchronize do
+          @messages << message
+          @waker.signal
+        end
+        nil
+      rescue DeadWakerError
+        raise MailboxError, "dead recipient"
+      end
+
+      # Add a high-priority system event to the Mailbox
+      def system_event(event)
+        @lock.synchronize do
+          @messages.unshift event
+
+          begin
+            @waker.signal
+          rescue DeadWakerError
+            # Silently fail if messages are sent to dead actors
+          end
+        end
+        nil
+      end
+
+      # Receive a message from the Mailbox
+      def receive(&block)
+        message = nil
+
+        begin
+          @reactor.run_once do
+            @waker.wait
+            message = next_message(&block)
+          end
+        end until message
+
+        message
+      rescue DeadWakerError
+        shutdown # force shutdown of the mailbox
+        raise MailboxShutdown, "mailbox shutdown called during receive"
+      end
+
+      # Cleanup any IO objects this Mailbox may be using
+      def shutdown
+        @waker.cleanup
+        super
+      end
+    end
+  end
+end

data/lib/celluloid/io/reactor.rb

@@ -0,0 +1,63 @@
+module Celluloid
+  module IO
+    # React to external I/O events. This is kinda sorta supposed to resemble the
+    # Reactor design pattern.
+    class Reactor
+      def initialize(waker)
+        @waker = waker
+        @readers = {}
+        @writers = {}
+      end
+
+      # Wait for the given IO object to become readable
+      def wait_readable(io)
+        monitor_io io, @readers
+        Fiber.yield
+        block_given? ? yield(io) : io
+      end
+
+      # Wait for the given IO object to become writeable
+      def wait_writeable(io)
+        monitor_io io, @writers
+        Fiber.yield
+        block_given? ? yield(io) : io
+      end
+
+      # Run the reactor, waiting for events, and calling the given block if
+      # the reactor is awoken by the waker
+      def run_once
+        readers, writers = select @readers.keys << @waker.io, @writers.keys
+        yield if readers.include? @waker.io
+
+        [[readers, @readers], [writers, @writers]].each do |ios, registered|
+          ios.each do |io|
+            fiber = registered.delete io
+            fiber.resume if fiber
+          end
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def monitor_io(io, set)
+        # zomg ugly type conversion :(
+        unless io.is_a?(IO)
+          if IO.respond_to? :try_convert
+            io = IO.try_convert(io)
+          elsif io.respond_to? :to_io
+            io = io.to_io
+          else raise TypeError, "can't convert #{io.class} into IO"
+          end
+        end
+
+        if set.has_key? io
+          raise ArgumentError, "another method is already waiting on #{io.inspect}"
+        else
+          set[io] = Fiber.current
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/io/waker.rb

@@ -0,0 +1,43 @@
+module Celluloid
+  module IO
+    class DeadWakerError < StandardError; end # You can't wake the dead
+
+    # Wakes up sleepy threads so that they can check their mailbox
+    # Works like a ConditionVariable, except it's implemented as an IO object so
+    # that it can be multiplexed alongside other IO objects.
+    class Waker
+      PAYLOAD = "\0" # the payload doesn't matter. each byte is a signal
+      def initialize
+        @receiver, @sender = ::IO.pipe
+      end
+
+      # Wakes up the thread that is waiting for this Waker
+      def signal
+        @sender << PAYLOAD
+        nil
+      rescue IOError, Errno::EPIPE, Errno::EBADF
+        raise DeadWakerError, "waker is already dead"
+      end
+
+      # Wait for another thread to signal this Waker
+      def wait
+          byte = @receiver.read(1)
+          raise DeadWakerError, "can't wait on a dead waker" unless byte == PAYLOAD
+      rescue IOError, RuntimeError
+          raise DeadWakerError, "can't wait on a dead waker"
+      end
+
+      # Return the IO object which will be readable when this Waker is signaled
+      def io
+        @receiver
+      end
+
+      # Clean up the IO objects associated with this waker
+      def cleanup
+        @receiver.close rescue nil
+        @sender.close rescue nil
+        nil
+      end
+    end
+  end
+end

data/lib/celluloid/linking.rb

@@ -5,12 +5,12 @@ module Celluloid
   # Thread safe storage of inter-actor links
   class Links
     include Enumerable
-    
+
     def initialize
       @links = Set.new
       @lock  = Mutex.new
     end
-    
+
     # Add an actor to the current links
     def <<(actor)
       @lock.synchronize do
@@ -18,14 +18,14 @@ module Celluloid
       end
       actor
     end
-    
+
     # Do links include the given actor?
     def include?(actor)
       @lock.synchronize do
         @links.include? actor
       end
     end
-    
+
     # Remove an actor from the links
     def delete(actor)
       @lock.synchronize do
@@ -33,19 +33,19 @@ module Celluloid
       end
       actor
     end
-    
+
     # Iterate through all links
     def each(&block)
       @lock.synchronize do
         @links.each(&block)
       end
     end
-    
+
     # Send an event message to all actors
     def send_event(event)
       each { |actor| actor.mailbox.system_event event }
     end
-    
+
     # Generate a string representation
     def inspect
       @lock.synchronize do
@@ -54,32 +54,36 @@ module Celluloid
       end
     end
   end
-  
+
   # Support for linking actors together so they can crash or react to errors
   module Linking
     # Link this actor to another, allowing it to crash or react to errors
     def link(actor)
-      actor.notify_link(@_proxy)
-      self.notify_link(actor)
+      current_actor = Thread.current[:actor]
+
+      actor.notify_link(current_actor.proxy)
+      current_actor.notify_link(actor)
     end
-    
+
     # Remove links to another actor
     def unlink(actor)
-      actor.notify_unlink(@_proxy)
-      self.notify_unlink(actor)
+      current_actor = Thread.current[:actor]
+
+      actor.notify_unlink(current_actor.proxy)
+      current_actor.notify_unlink(actor)
     end
-    
+
     def notify_link(actor)
-      @_links << actor
+      Thread.current[:actor].links << actor
     end
-    
+
     def notify_unlink(actor)
-      @_links.delete actor
+      Thread.current[:actor].links.delete actor
     end
-    
+
     # Is this actor linked to another?
     def linked_to?(actor)
-      @_links.include? actor
+      Thread.current[:actor].links.include? actor
     end
   end
-end
+end