engineyard-serverside 1.5.23.ruby19.8 → 1.5.23.ruby19.9

data/lib/vendor/celluloid/lib/celluloid/mailbox.rb

@@ -0,0 +1,124 @@
+require 'thread'
+
+module Celluloid
+  class MailboxError < StandardError; end # you can't message the dead
+  class MailboxShutdown < StandardError; end # raised if the mailbox can no longer be used
+
+  # Actors communicate with asynchronous messages. Messages are buffered in
+  # Mailboxes until Actors can act upon them.
+  class Mailbox
+    include Enumerable
+
+    # A unique address at which this mailbox can be found
+    alias_method :address, :object_id
+
+    def initialize
+      @messages = []
+      @lock  = Mutex.new
+      @dead = false
+      @condition = ConditionVariable.new
+    end
+
+    # Add a message to the Mailbox
+    def <<(message)
+      @lock.synchronize do
+        raise MailboxError, "dead recipient" if @dead
+
+        @messages << message
+        @condition.signal
+      end
+      nil
+    end
+
+    # Add a high-priority system event to the Mailbox
+    def system_event(event)
+      @lock.synchronize do
+        unless @dead # Silently fail if messages are sent to dead actors
+          @messages.unshift event
+          @condition.signal
+        end
+      end
+      nil
+    end
+
+    # Receive a message from the Mailbox
+    def receive(timeout = nil, &block)
+      message = nil
+
+      @lock.synchronize do
+        raise MailboxError, "attempted to receive from a dead mailbox" if @dead
+
+        begin
+          message = next_message(&block)
+
+          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
+
+      message
+    end
+
+    # Retrieve the next message in the mailbox
+    def next_message
+      message = nil
+
+      if block_given?
+        index = @messages.index do |msg|
+          yield(msg) || msg.is_a?(SystemEvent)
+        end
+
+        message = @messages.slice!(index, 1).first if index
+      else
+        message = @messages.shift
+      end
+
+      raise message if message.is_a? SystemEvent
+      message
+    end
+
+    # Shut down this mailbox and clean up its contents
+    def shutdown
+      messages = nil
+
+      @lock.synchronize do
+        messages = @messages
+        @messages = []
+        @dead = true
+      end
+
+      messages.each { |msg| msg.cleanup if msg.respond_to? :cleanup }
+      true
+    end
+
+    # Is the mailbox alive?
+    def alive?
+      !@dead
+    end
+
+    # Cast to an array
+    def to_a
+      @lock.synchronize { @messages.dup }
+    end
+
+    # Iterate through the mailbox
+    def each(&block)
+      to_a.each(&block)
+    end
+
+    # Inspect the contents of the Mailbox
+    def inspect
+      "#<#{self.class}:#{object_id.to_s(16)} @messages=[#{map { |m| m.inspect }.join(', ')}]>"
+    end
+  end
+end

data/lib/vendor/celluloid/lib/celluloid/receivers.rb

@@ -0,0 +1,66 @@
+require 'set'
+
+module Celluloid
+  # Allow methods to directly interact with the actor protocol
+  class Receivers
+    def initialize
+      @receivers = Set.new
+      @timers = Timers.new
+    end
+
+    # Receive an asynchronous message
+    def receive(timeout = nil, &block)
+      receiver = Receiver.new block
+
+      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)
+      receiver = @receivers.find { |r| r.match(message) }
+      return unless receiver
+
+      @receivers.delete receiver
+      @timers.cancel receiver.timer if receiver.timer
+      receiver.resume message
+    end
+  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/vendor/celluloid/lib/celluloid/registry.rb

@@ -0,0 +1,33 @@
+require 'thread'
+
+module Celluloid
+  # The Registry allows us to refer to specific actors by human-meaningful names
+  module Registry
+    @@registry = {}
+    @@registry_lock = Mutex.new
+
+    # Register an Actor
+    def []=(name, actor)
+      actor_singleton = class << actor; self; end
+      unless actor_singleton.ancestors.include? ActorProxy
+        raise TypeError, "not an actor"
+      end
+
+      @@registry_lock.synchronize do
+        @@registry[name.to_sym] = actor
+      end
+    end
+
+    # Retrieve an actor by name
+    def [](name)
+      @@registry_lock.synchronize do
+        @@registry[name.to_sym]
+      end
+    end
+
+    # List all registered actors by name
+    def registered
+      @@registry_lock.synchronize { @@registry.keys }
+    end
+  end
+end

data/lib/vendor/celluloid/lib/celluloid/responses.rb

@@ -0,0 +1,26 @@
+module Celluloid
+  # Responses to calls
+  class Response
+    attr_reader :call_id, :value
+    
+    def initialize(call_id, value)
+      @call_id, @value = call_id, value
+    end
+  end
+  
+  # Call completed successfully
+  class SuccessResponse < Response; end
+  
+  # Call was aborted due to caller error
+  class ErrorResponse < Response
+    def value
+      if super.is_a? AbortError
+        # Aborts are caused by caller error, so ensure they capture the
+        # caller's backtrace instead of the receiver's
+        raise super.cause.class.new(super.cause.message)
+      else
+        raise super
+      end
+    end
+  end
+end

data/lib/vendor/celluloid/lib/celluloid/rspec.rb

@@ -0,0 +1,2 @@
+require File.expand_path('../../../spec/support/actor_examples', __FILE__)
+require File.expand_path('../../../spec/support/mailbox_examples', __FILE__)

data/lib/vendor/celluloid/lib/celluloid/signals.rb

@@ -0,0 +1,50 @@
+module Celluloid
+  # Event signaling between methods of the same object
+  class Signals
+    attr_reader :waiting
+
+    def initialize
+      @waiting = {}
+    end
+
+    # Wait for the given signal and return the associated value
+    def wait(signal)
+      tasks = @waiting[signal]
+
+      case tasks
+      when Array
+        tasks << Task.current
+      when NilClass
+        @waiting[signal] = Task.current
+      else
+        @waiting[signal] = [tasks, Task.current]
+      end
+
+      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)
+      tasks = @waiting.delete name
+
+      case tasks
+      when Array
+        tasks.each { |task| run_task task, value }
+      when NilClass
+        Logger.debug("spurious signal: #{name}")
+      else
+        run_task tasks, value
+      end
+
+      value
+    end
+
+    # Run the given task, reporting errors that occur
+    def run_task(task, value)
+      task.resume(value)
+    rescue => ex
+      Celluloid::Logger.crash("signaling error", ex)
+    end
+  end
+end

data/lib/vendor/celluloid/lib/celluloid/supervisor.rb

@@ -0,0 +1,57 @@
+module Celluloid
+  # Supervisors are actors that watch over other actors and restart them if
+  # they crash
+  class Supervisor
+    include Celluloid
+    trap_exit :restart_actor
+
+    # Retrieve the actor this supervisor is supervising
+    attr_reader :actor
+
+    def self.supervise(klass, *args, &block)
+      new(nil, klass, *args, &block)
+    end
+
+    def self.supervise_as(name, klass, *args, &block)
+      new(name, klass, *args, &block)
+    end
+
+    def initialize(name, klass, *args, &block)
+      @name, @klass, @args, @block = name, klass, args, block
+      @started = false
+
+      start_actor
+    end
+
+    def start_actor(start_attempts = 3, sleep_interval = 30)
+      failures = 0
+
+      begin
+        @actor = @klass.new_link(*@args, &@block)
+      rescue => ex
+        failures += 1
+        if failures >= start_attempts
+          failures = 0
+
+          Logger.warn("#{@klass} is crashing on initialize too quickly, sleeping for #{sleep_interval} seconds")
+          sleep sleep_interval
+        end
+        retry
+      end
+
+      @started = true
+      Actor[@name] = @actor if @name
+    end
+
+    # When actors die, regardless of the reason, restart them
+    def restart_actor(actor, reason)
+      start_actor if @started
+    end
+
+    def inspect
+      str = "#<#{self.class}(#{@klass}):0x#{object_id.to_s(16)}"
+      str << " " << @args.map { |arg| arg.inspect }.join(' ') unless @args.empty?
+      str << ">"
+    end
+  end
+end

data/lib/vendor/celluloid/lib/celluloid/task.rb

@@ -0,0 +1,73 @@
+module Celluloid
+  # Trying to resume a dead task
+  class DeadTaskError < StandardError; end
+
+  # Tasks are interruptable/resumable execution contexts used to run methods
+  class Task
+    class TerminatedError < StandardError; end # kill a running fiber
+
+    attr_reader :type # what type of task is this?
+
+    # Obtain the current task
+    def self.current
+      task = Fiber.current.task
+      raise "not in task scope" unless task
+      task
+    end
+
+    # Suspend the running task, deferring to the scheduler
+    def self.suspend(value = nil)
+      result = Fiber.yield(value)
+      raise TerminatedError, "task was terminated" if result == TerminatedError
+      result
+    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
+
+        Fiber.current.task = self
+
+        begin
+          yield
+        rescue TerminatedError
+          # Task was explicitly terminated
+        end
+      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"
+    rescue RuntimeError => ex
+      # These occur spuriously on 1.9.3 if we shut down an actor with running tasks
+      return if ex.message == ""
+      raise
+    end
+
+    # Terminate this task
+    def terminate
+      resume TerminatedError
+    rescue FiberError
+      # If we're getting this the task should already be dead
+    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/vendor/celluloid/lib/celluloid/tcp_server.rb

@@ -0,0 +1,33 @@
+require 'socket'
+
+module Celluloid
+  # A TCPServer that runs as an actor
+  class TCPServer
+    include Celluloid::IO
+
+    # Bind a TCP server to the given host and port
+    def initialize(host, port)
+      @server = ::TCPServer.new host, port
+      run!
+    end
+
+    # Run the TCP server event loop
+    def run
+      while true
+        wait_readable(@server)
+        on_connect @server.accept
+      end
+    end
+
+    # Terminate this server
+    def terminate
+      @server.close
+      super
+    end
+
+    # Called whenever a new connection is opened
+    def on_connect(connection)
+      connection.close
+    end
+  end
+end