engineyard-serverside 1.5.26 → 1.5.27.pre

data/lib/vendor/celluloid/lib/celluloid/actor.rb

@@ -0,0 +1,242 @@
+module Celluloid
+  # Don't do Actor-like things outside Actor scope
+  class NotActorError < StandardError; end
+
+  # Trying to do something to a dead actor
+  class DeadActorError < StandardError; end
+
+  # The caller made an error, not the current actor
+  class AbortError < StandardError
+    attr_reader :cause
+
+    def initialize(cause)
+      @cause = cause
+      super "caused by #{cause.inspect}: #{cause.to_s}"
+    end
+  end
+
+  # Actors are Celluloid's concurrency primitive. They're implemented as
+  # normal Ruby objects wrapped in threads which communicate with asynchronous
+  # messages.
+  class Actor
+    extend Registry
+
+    attr_reader :proxy
+    attr_reader :links
+    attr_reader :mailbox
+
+    # Invoke a method on the given actor via its mailbox
+    def self.call(mailbox, meth, *args, &block)
+      call = SyncCall.new(Thread.mailbox, meth, args, block)
+
+      begin
+        mailbox << call
+      rescue MailboxError
+        raise DeadActorError, "attempted to call a dead actor"
+      end
+
+      if Celluloid.actor?
+        response = Thread.current[:actor].wait [:call, call.id]
+      else
+        # Otherwise we're inside a normal thread, so block
+        response = Thread.mailbox.receive do |msg|
+          msg.respond_to?(:call_id) and msg.call_id == call.id
+        end
+      end
+
+      response.value
+    end
+
+    # Invoke a method asynchronously on an actor via its mailbox
+    def self.async(mailbox, meth, *args, &block)
+      begin
+        mailbox << AsyncCall.new(Thread.mailbox, meth, args, block)
+      rescue MailboxError
+        # Silently swallow asynchronous calls to dead actors. There's no way
+        # to reliably generate DeadActorErrors for async calls, so users of
+        # async calls should find other ways to deal with actors dying
+        # during an async call (i.e. linking/supervisors)
+      end
+    end
+
+    # Wrap the given subject with an Actor
+    def initialize(subject)
+      @subject = subject
+
+      if subject.respond_to? :mailbox_factory
+        @mailbox = subject.mailbox_factory
+      else
+        @mailbox = Mailbox.new
+      end
+
+      @links     = Links.new
+      @signals   = Signals.new
+      @receivers = Receivers.new
+      @timers    = Timers.new
+      @proxy     = ActorProxy.new(@mailbox, self.class.to_s)
+      @running   = true
+
+      @thread = Pool.get do
+        Thread.current[:actor]   = self
+        Thread.current[:mailbox] = @mailbox
+
+        run
+      end
+    end
+
+    # Is this actor alive?
+    def alive?
+      @running
+    end
+
+    # Terminate this actor
+    def terminate
+      @running = false
+      nil
+    end
+
+    # Send a signal with the given name to all waiting methods
+    def signal(name, value = nil)
+      @signals.send name, value
+    end
+
+    # Wait for the given signal
+    def wait(name)
+      @signals.wait name
+    end
+
+    # Receive an asynchronous message
+    def receive(timeout = nil, &block)
+      @receivers.receive(timeout, &block)
+    end
+
+    # Run the actor loop
+    def run
+      while @running
+        begin
+          message = @mailbox.receive(timeout)
+        rescue ExitEvent => exit_event
+          Task.new(:exit_handler) { handle_exit_event exit_event }.resume
+          retry
+        end
+
+        if message
+          handle_message message
+        else
+          # No message indicates a timeout
+          @timers.fire
+          @receivers.fire_timers
+        end
+      end
+
+      cleanup ExitEvent.new(@proxy)
+    rescue MailboxShutdown
+      # If the mailbox detects shutdown, exit the actor
+      @running = false
+    rescue Exception => ex
+      @running = false
+      handle_crash(ex)
+    ensure
+      Pool.put @thread
+    end
+
+    # How long to wait until the next timer fires
+    def timeout
+      i1 = @timers.wait_interval
+      i2 = @receivers.wait_interval
+
+      if i1 and i2
+        i1 < i2 ? i1 : i2
+      elsif i1
+        i1
+      else
+        i2
+      end
+    end
+
+    # Obtain a hash of tasks that are currently waiting
+    def tasks
+      # A hash of tasks to what they're waiting on is more meaningful to the
+      # end-user, and lets us make a copy of the tasks table, rather than
+      # handing them the one we're using internally across threads, a definite
+      # thread safety shared state no-no
+      tasks = {}
+      current_task = Task.current rescue nil
+      tasks[current_task] = :running if current_task
+
+      @signals.waiting.each do |waitable, waiters|
+        if waiters.is_a? Enumerable
+          waiters.each { |waiter| tasks[waiter] = waitable }
+        else
+          tasks[waiters] = waitable
+        end
+      end
+
+      tasks
+    end
+
+    # Schedule a block to run at the given time
+    def after(interval)
+      @timers.add(interval) do
+        Task.new(:timer) { yield }.resume
+      end
+    end
+
+    # Sleep for the given amount of time
+    def sleep(interval)
+      task = Task.current
+      @timers.add(interval) { task.resume }
+      Task.suspend
+    end
+
+    # Handle an incoming message
+    def handle_message(message)
+      case message
+      when Call
+        Task.new(:message_handler) { message.dispatch(@subject) }.resume
+      when Response
+        handled_successfully = signal [:call, message.call_id], message
+
+        unless handled_successfully
+          Logger.debug("anomalous message! spurious response to call #{message.call_id}")
+        end
+      else
+        @receivers.handle_message(message)
+      end
+      message
+    end
+
+    # Handle exit events received by this actor
+    def handle_exit_event(exit_event)
+      exit_handler = @subject.class.exit_handler
+      if exit_handler
+        return @subject.send(exit_handler, exit_event.actor, exit_event.reason)
+      end
+
+      # Reraise exceptions from linked actors
+      # If no reason is given, actor terminated cleanly
+      raise exit_event.reason if exit_event.reason
+    end
+
+    # Handle any exceptions that occur within a running actor
+    def handle_crash(exception)
+      Logger.crash("#{@subject.class} crashed!", exception)
+      cleanup ExitEvent.new(@proxy, exception)
+    rescue Exception => ex
+      Logger.crash("#{@subject.class}: ERROR HANDLER CRASHED!", ex)
+    end
+
+    # Handle cleaning up this actor after it exits
+    def cleanup(exit_event)
+      @mailbox.shutdown
+      @links.send_event exit_event
+      tasks.each { |task, _| task.terminate }
+
+      begin
+        @subject.finalize if @subject.respond_to? :finalize
+      rescue Exception => ex
+        Logger.crash("#{@subject.class}#finalize crashed!", ex)
+      end
+    end
+  end
+end

data/lib/vendor/celluloid/lib/celluloid/actor_pool.rb

@@ -0,0 +1,54 @@
+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(&block)
+          @lock.synchronize do
+            if @pool.empty?
+              thread = create
+            else
+              thread = @pool.shift
+            end
+
+            thread[:queue] << block
+            thread
+          end
+        end
+
+        def put(thread)
+          @lock.synchronize do
+            if @pool.size >= @max_idle
+              thread[:queue] << nil
+            else
+              @pool << thread
+            end
+          end
+        end
+
+        def create
+          queue = Queue.new
+          thread = Thread.new do
+            begin
+              while func = queue.pop
+                func.call
+              end
+            rescue Exception => ex
+              Logger.crash("#{self} internal failure", ex)
+            end
+          end
+          thread[:queue] = queue
+          thread
+        end
+      end
+    end
+  end
+end

data/lib/vendor/celluloid/lib/celluloid/actor_proxy.rb

@@ -0,0 +1,75 @@
+module Celluloid
+  # A proxy object returned from Celluloid::Actor.spawn/spawn_link which
+  # dispatches calls and casts to normal Ruby objects which are running inside
+  # of their own threads.
+  class ActorProxy
+    attr_reader :mailbox
+
+    def initialize(mailbox, klass = "Object")
+      @mailbox, @klass = mailbox, klass
+    end
+
+    def send(meth, *args, &block)
+      Actor.call @mailbox, :send, meth, *args, &block
+    end
+
+    def class
+      Actor.call @mailbox, :send, :class
+    end
+
+    def respond_to?(meth)
+      Actor.call @mailbox, :respond_to?, meth
+    end
+
+    def methods(include_ancestors = true)
+      Actor.call @mailbox, :methods, include_ancestors
+    end
+
+    def alive?
+      @mailbox.alive?
+    end
+
+    def to_s
+      Actor.call @mailbox, :to_s
+    end
+
+    def inspect
+      Actor.call @mailbox, :inspect
+    rescue DeadActorError
+      "#<Celluloid::Actor(#{@klass}) dead>"
+    end
+
+    # Create a Celluloid::Future which calls a given method
+    def future(method_name, *args, &block)
+      Future.new { Actor.call @mailbox, method_name, *args, &block }
+    end
+
+    # Terminate the associated actor
+    def terminate
+      raise DeadActorError, "actor already terminated" unless alive?
+
+      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(/!$/)
+        unbanged_meth = meth.to_s.sub(/!$/, '')
+        Actor.async @mailbox, unbanged_meth, *args, &block
+        return
+      end
+
+      Actor.call @mailbox, meth, *args, &block
+    end
+  end
+end

data/lib/vendor/celluloid/lib/celluloid/application.rb

@@ -0,0 +1,78 @@
+module Celluloid
+  # Applications describe and manage networks of Celluloid actors
+  class Application
+    include Celluloid
+    trap_exit :restart_supervisor
+
+    class << self
+      # Actors or sub-applications to be supervised
+      def supervisables
+        @supervisables ||= []
+      end
+
+      # Start this application (and watch it with a supervisor)
+      alias_method :run!, :supervise
+
+      # Run the application in the foreground with a simple watchdog
+      def run
+        loop do
+          supervisor = run!
+
+          # Take five, toplevel supervisor
+          sleep 5 while supervisor.alive?
+
+          Logger.error "!!! Celluloid::Application #{self} crashed. Restarting..."
+        end
+      end
+
+      # Register an actor class or a sub-application class to be launched and
+      # supervised while this application is running. Available options are:
+      #
+      # * as: register this application in the Celluloid::Actor[] directory
+      # * args: start the actor with the given arguments
+      def supervise(klass, options = {})
+        supervisables << Supervisable.new(klass, options)
+      end
+    end
+
+    # Start the application
+    def initialize
+      @supervisors = {}
+
+      # This is some serious lolcode, but like... start the supervisors for
+      # this application
+      self.class.supervisables.each do |supervisable|
+        supervisor = supervisable.supervise
+        @supervisors[supervisor] = supervisable
+      end
+    end
+
+    # Restart a crashed supervisor
+    def restart_supervisor(supervisor, reason)
+      supervisable = @supervisors.delete supervisor
+      raise "a supervisable went missing. This shouldn't be!" unless supervisable
+
+      supervisor = supervisable.supervise
+      @supervisors[supervisor] = supervisable
+    end
+
+    # A subcomponent of an application to be supervised
+    class Supervisable
+      attr_reader :klass, :as, :args
+
+      def initialize(klass, options = {})
+        @klass = klass
+
+        # Stringify keys :/
+        options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
+
+        @as = options['as']
+        @args = options['args'] || []
+      end
+
+      def supervise
+        Supervisor.new_link(@as, @klass, *@args)
+      end
+    end
+  end
+end