engineyard-serverside 2.0.4 → 2.0.5.pre

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

@@ -1,242 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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