engineyard-serverside 1.5.23.ruby19.16 → 1.5.24

data/lib/vendor/celluloid/lib/celluloid/future.rb

@@ -1,60 +0,0 @@
-require 'thread'
-
-module Celluloid
-  # 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
-        unless @value_obtained
-          @value = @runner.value
-          @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
-        @called = nil
-        @error = nil
-      end
-
-      def run
-        @value = @block.call(*@args)
-      rescue Exception => error
-        @error = error
-      ensure
-        @called = true
-        signal :finished
-      end
-
-      def value
-        wait :finished unless @called
-        abort @error if @error
-        @value
-      end
-    end
-  end
-end

data/lib/vendor/celluloid/lib/celluloid/links.rb

@@ -1,61 +0,0 @@
-require 'thread'
-
-module Celluloid
-  # Thread safe storage of inter-actor links
-  class Links
-    include Enumerable
-
-    def initialize
-      @links = {}
-      @lock  = Mutex.new
-    end
-
-    # Add an actor to the current links
-    def <<(actor)
-      @lock.synchronize do
-        @links[actor.mailbox.address] = actor
-      end
-      actor
-    end
-
-    # Do links include the given actor?
-    def include?(actor)
-      @lock.synchronize do
-        @links.has_key? actor.mailbox.address
-      end
-    end
-
-    # Remove an actor from the links
-    def delete(actor)
-      @lock.synchronize do
-        @links.delete actor.mailbox.address
-      end
-      actor
-    end
-
-    # Iterate through all links
-    def each
-      @lock.synchronize do
-        @links.each { |_, actor| yield(actor) }
-      end
-    end
-
-    # Map across links
-    def map
-      result = []
-      each { |actor| result << yield(actor) }
-      result
-    end
-
-    # Send an event message to all actors
-    def send_event(event)
-      each { |actor| actor.mailbox.system_event event }
-    end
-
-    # Generate a string representation
-    def inspect
-      links = self.map(&:inspect).join(',')
-      "#<#{self.class}[#{links}]>"
-    end
-  end
-end

data/lib/vendor/celluloid/lib/celluloid/logger.rb

@@ -1,32 +0,0 @@
-module Celluloid
-  module Logger
-    module_function
-
-    # Send a debug message
-    def debug(string)
-      Celluloid.logger.debug(string) if Celluloid.logger
-    end
-
-    # 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
-
-    # Send an error message
-    def error(string)
-      Celluloid.logger.error(string) if Celluloid.logger
-    end
-
-    # Handle a crash
-    def crash(string, exception)
-      string += "\n#{exception.class}: #{exception.to_s}\n"
-      string << exception.backtrace.join("\n")
-      error(string)
-    end
-  end
-end

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