celluloid 0.6.2 → 0.7.0

data/lib/celluloid/future.rb

@@ -1,23 +1,19 @@
 require 'thread'
 
 module Celluloid
-  # Create a new Celluloid::Future object, allowing a block to be computed in
-  # the background and its return value obtained later
-  def self.Future(*args, &block)
-    Celluloid::Future.new(*args, &block)
-  end
-  
   # Celluloid::Future objects allow methods and blocks to run in the
   # background, their values requested later
   class Future
+    # Create a new Celluloid::Future object, allowing a block to be computed in
+    # the background and its return value obtained later
     def initialize(*args, &block)
       @lock = Mutex.new
       @value_obtained = false
-      
+
       @runner = Runner.new(*args, &block)
       @runner.run!
     end
-    
+
     # Obtain the value for this Future
     def value
       @lock.synchronize do
@@ -26,18 +22,19 @@ module Celluloid
           @runner.terminate
           @value_obtained = true
         end
-        
+
         @value
       end
     end
-    
+    alias_method :call, :value
+
     # Inspect this Celluloid::Future
     alias_method :inspect, :to_s
-    
+
     # Runner is an internal class which executes the given block/method
     class Runner
       include Celluloid
-      
+
       def initialize(*args, &block)
         @args, @block = args, block
       end
@@ -58,4 +55,4 @@ module Celluloid
       end
     end
   end
-end
+end

data/lib/celluloid/logger.rb

@@ -2,17 +2,22 @@ module Celluloid
   module Logger
     module_function
 
-    # Print a debug message
+    # Send a debug message
     def debug(string)
       Celluloid.logger.debug(string) if Celluloid.logger
     end
 
-    # Print a warning message
+    # Send a info message
+    def info(string)
+      Celluloid.logger.info(string) if Celluloid.logger
+    end
+
+    # Send a warning message
     def warn(string)
       Celluloid.logger.warn(string) if Celluloid.logger
     end
 
-    # Print an error message
+    # Send an error message
     def error(string)
       Celluloid.logger.error(string) if Celluloid.logger
     end

data/lib/celluloid/mailbox.rb

@@ -42,7 +42,7 @@ module Celluloid
     end
 
     # Receive a message from the Mailbox
-    def receive(&block)
+    def receive(timeout = nil, &block)
       message = nil
 
       @lock.synchronize do
@@ -50,7 +50,19 @@ module Celluloid
 
         begin
           message = next_message(&block)
-          @condition.wait(@lock) unless message
+
+          unless message
+            if timeout
+              now = Time.now
+              wait_until ||= now + timeout
+              wait_interval = wait_until - now
+              return if wait_interval < 0
+            else
+              wait_interval = nil
+            end
+
+            @condition.wait(@lock, wait_interval)
+          end
         end until message
       end
 
@@ -63,7 +75,7 @@ module Celluloid
 
       if block_given?
         index = @messages.index do |msg|
-          yield(msg) || msg.is_a?(Celluloid::SystemEvent)
+          yield(msg) || msg.is_a?(SystemEvent)
         end
 
         message = @messages.slice!(index, 1).first if index
@@ -71,7 +83,7 @@ module Celluloid
         message = @messages.shift
       end
 
-      raise message if message.is_a?(Celluloid::SystemEvent)
+      raise message if message.is_a? SystemEvent
       message
     end
 

data/lib/celluloid/receivers.rb

@@ -1,36 +1,66 @@
+require 'set'
+
 module Celluloid
   # Allow methods to directly interact with the actor protocol
   class Receivers
     def initialize
-      @handlers = []
+      @receivers = Set.new
+      @timers = Timers.new
     end
 
     # Receive an asynchronous message
-    def receive(&block)
-      raise ArgumentError, "receive must be given a block" unless block
+    def receive(timeout = nil, &block)
+      receiver = Receiver.new block
 
-      @handlers << [Fiber.current, block]
-      Fiber.yield
+      if timeout
+        receiver.timer = @timers.add(timeout) do
+          @receivers.delete receiver
+          receiver.resume
+        end
+      end
+
+      @receivers << receiver
+      Task.suspend
+    end
+
+    # How long to wait until the next timer fires
+    def wait_interval
+      @timers.wait_interval
+    end
+
+    # Fire any pending timers
+    def fire_timers
+      @timers.fire
     end
 
     # Handle incoming messages
     def handle_message(message)
-      handler = nil
+      receiver = @receivers.find { |r| r.match(message) }
+      return unless receiver
 
-      @handlers.each_with_index do |(fiber, block), index|
-        if block.call(message)
-          handler = index
-          break
-        end
-      end
+      @receivers.delete receiver
+      @timers.cancel receiver.timer if receiver.timer
+      receiver.resume message
+    end
+  end
 
-      if handler
-        fiber, _ = @handlers.delete_at handler
-        fiber.resume message
-        true
-      else
-        false
-      end
+  # Methods blocking on a call to receive
+  class Receiver
+    attr_accessor :timer
+
+    def initialize(block)
+      @block = block
+      @task  = Task.current
+      @timer = nil
+    end
+
+    # Match a message with this receiver's block
+    def match(message)
+      @block.call(message) if @block
+    end
+
+    def resume(message = nil)
+      @task.resume message
     end
   end
 end

data/lib/celluloid/registry.rb

@@ -9,8 +9,8 @@ module Celluloid
     # Register an Actor
     def []=(name, actor)
       actor_singleton = class << actor; self; end
-      unless actor_singleton.ancestors.include?(Celluloid::ActorProxy)
-        raise ArgumentError, "not an actor"
+      unless actor_singleton.ancestors.include? ActorProxy
+        raise TypeError, "not an actor"
       end
 
       @@registry_lock.synchronize do

data/lib/celluloid/signals.rb

@@ -1,25 +1,27 @@
 module Celluloid
   # Event signaling between methods of the same object
   class Signals
+    attr_reader :waiting
+
     def initialize
       @waiting = {}
     end
-    
+
     # Wait for the given signal name and return the associated value
     def wait(name)
-      fibers = @waiting[name] ||= []
-      fibers << Fiber.current
-      Fiber.yield
+      tasks = @waiting[name] ||= []
+      tasks << Task.current
+      Task.suspend
     end
-    
+
     # Send a signal to all method calls waiting for the given name
     # Returns true if any calls were signaled, or false otherwise
     def send(name, value = nil)
-      fibers = @waiting.delete name
-      return unless fibers
-      
-      fibers.each { |fiber| fiber.resume value }
+      tasks = @waiting.delete name
+      return unless tasks
+
+      tasks.each { |task| task.resume(value) if task.running? }
       value
     end
   end
-end
+end

data/lib/celluloid/supervisor.rb

@@ -18,10 +18,12 @@ module Celluloid
 
     def initialize(name, klass, *args, &block)
       @name, @klass, @args, @block = name, klass, args, block
+      @started = false
+
       start_actor
     end
 
-    def start_actor(start_attempts = 2, sleep_interval = 30)
+    def start_actor(start_attempts = 3, sleep_interval = 30)
       failures = 0
 
       begin
@@ -31,18 +33,19 @@ module Celluloid
         if failures >= start_attempts
           failures = 0
 
-          Celluloid::Logger.crash("#{@klass} is crashing on initialize repeatedly, sleeping for #{sleep_interval} seconds", ex)
+          Logger.warn("#{@klass} is crashing on initialize too quickly, sleeping for #{sleep_interval} seconds")
           sleep sleep_interval
         end
         retry
       end
 
-      Celluloid::Actor[@name] = @actor if @name
+      @started = true
+      Actor[@name] = @actor if @name
     end
 
     # When actors die, regardless of the reason, restart them
     def restart_actor(actor, reason)
-      start_actor
+      start_actor if @started
     end
 
     def inspect

data/lib/celluloid/task.rb

@@ -0,0 +1,53 @@
+module Celluloid
+  # Trying to resume a dead task
+  class DeadTaskError < StandardError; end
+
+  # Tasks are interruptable/resumable execution contexts used to run methods
+  class Task
+    attr_reader :type # what type of task is this?
+
+    # Obtain the current task
+    def self.current
+      task = Thread.current[:task]
+      raise "not in task scope" unless task
+      task
+    end
+
+    # Suspend the running task, deferring to the scheduler
+    def self.suspend(value = nil)
+      Fiber.yield(value)
+    end
+
+    # Run the given block within a task
+    def initialize(type)
+      @type = type
+
+      actor   = Thread.current[:actor]
+      mailbox = Thread.current[:mailbox]
+
+      @fiber = Fiber.new do
+        Thread.current[:actor]   = actor
+        Thread.current[:mailbox] = mailbox
+        Thread.current[:task]    = self
+
+        yield
+      end
+    end
+
+    # Resume a suspended task, giving it a value to return if needed
+    def resume(value = nil)
+      @fiber.resume value
+      nil
+    rescue FiberError
+      raise DeadTaskError, "cannot resume a dead task"
+    end
+
+    # Is the current task still running?
+    def running?; @fiber.alive?; end
+
+    # Nicer string inspect for tasks
+    def inspect
+      "<Celluloid::Task:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @running=#{@fiber.alive?}>"
+    end
+  end
+end

data/lib/celluloid/tcp_server.rb

@@ -14,7 +14,8 @@ module Celluloid
     # Run the TCP server event loop
     def run
       while true
-        wait_readable(@server) { on_connect @server.accept }
+        wait_readable(@server)
+        on_connect @server.accept
       end
     end
 

data/lib/celluloid/timers.rb

@@ -0,0 +1,109 @@
+module Celluloid
+  # Low precision timers implemented in pure Ruby
+  class Timers
+    def initialize
+      @timers = []
+    end
+
+    # Call the given block after the given interval
+    def add(interval, &block)
+      Timer.new(self, interval, block)
+    end
+
+    # Wait for the next timer and fire it
+    def wait
+      return if @timers.empty?
+
+      interval = wait_interval
+      sleep interval if interval >= Timer::QUANTUM
+      fire
+    end
+
+    # Interval to wait until when the next timer will fire
+    def wait_interval
+      @timers.first.time - Time.now unless empty?
+    end
+
+    # Fire all timers that are ready
+    def fire
+      return if @timers.empty?
+
+      time = Time.now + Timer::QUANTUM
+      while not empty? and time > @timers.first.time
+        timer = @timers.shift
+        timer.call
+      end
+    end
+
+    # Insert a timer into the active timers
+    def insert(timer)
+      @timers.insert(index(timer), timer)
+    end
+
+    # Remove a given timer from the set we're monitoring
+    def cancel(timer)
+      @timers.delete timer
+    end
+
+    # Are there any timers pending?
+    def empty?
+      @timers.empty?
+    end
+
+    # Index where a timer would be located in the sorted timers array
+    def index(timer)
+      l, r = 0, @timers.size - 1
+
+      while l <= r
+        m = (r + l) / 2
+        if timer < @timers.at(m)
+          r = m - 1
+        else
+          l = m + 1
+        end
+      end
+      l
+    end
+  end
+
+  # An individual timer set to fire a given proc at a given time
+  class Timer
+    include Comparable
+
+    # The timer system is guaranteed (at least by the specs) to be this precise
+    # during normal operation. Long blocking calls within actors will delay the
+    # firing of timers
+    QUANTUM = 0.02
+
+    attr_reader :interval, :time
+
+    def initialize(timers, interval, block)
+      @timers, @interval = timers, interval
+      @block = block
+
+      reset
+    end
+
+    def <=>(other)
+      @time <=> other.time
+    end
+
+    # Cancel this timer
+    def cancel
+      @timers.cancel self
+    end
+
+    # Reset this timer
+    def reset
+      @timers.cancel self if defined?(@time)
+      @time = Time.now + @interval
+      @timers.insert self
+    end
+
+    # Fire the block
+    def fire
+      @block.call
+    end
+    alias_method :call, :fire
+  end
+end