engineyard-serverside 2.0.4 → 2.0.5.pre

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

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

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

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

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

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

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

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

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

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