engineyard-serverside 2.0.4 → 2.0.5.pre

data/lib/vendor/celluloid/lib/celluloid/calls.rb

@@ -1,93 +0,0 @@
-module Celluloid
-  # Calls represent requests to an actor
-  class Call
-    attr_reader :id, :caller, :method, :arguments, :block
-
-    def initialize(caller, method, arguments, block)
-      @id = object_id # memoize object ID for serialization
-      @caller, @method, @arguments, @block = caller, method, arguments, block
-    end
-
-    def check_signature(obj)
-      unless obj.respond_to? @method
-        raise NoMethodError, "undefined method `#{@method}' for #{obj.inspect}"
-      end
-
-      arity = obj.method(@method).arity
-      if arity >= 0
-        if arguments.size != arity
-          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{arity})"
-        end
-      elsif arity < -1
-        mandatory_args = -arity - 1
-        if arguments.size < mandatory_args
-          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{mandatory_args})"
-        end
-      end
-    end
-  end
-
-  # Synchronous calls wait for a response
-  class SyncCall < Call
-    def dispatch(obj)
-      begin
-        check_signature(obj)
-      rescue Exception => ex
-        respond ErrorResponse.new(@id, AbortError.new(ex))
-        return
-      end
-
-      begin
-        result = obj.send @method, *@arguments, &@block
-      rescue Exception => exception
-        # Exceptions that occur during synchronous calls are reraised in the
-        # context of the caller
-        respond ErrorResponse.new(@id, exception)
-
-        if exception.is_a? AbortError
-          # Aborting indicates a protocol error on the part of the caller
-          # It should crash the caller, but the exception isn't reraised
-          return
-        else
-          # Otherwise, it's a bug in this actor and should be reraised
-          raise exception
-        end
-      end
-
-      respond SuccessResponse.new(@id, result)
-    end
-
-    def cleanup
-      exception = DeadActorError.new("attempted to call a dead actor")
-      respond ErrorResponse.new(@id, exception)
-    end
-
-    #######
-    private
-    #######
-
-    def respond(message)
-      @caller << message
-    rescue MailboxError
-      # It's possible the caller exited or crashed before we could send a
-      # response to them.
-    end
-  end
-
-  # Asynchronous calls don't wait for a response
-  class AsyncCall < Call
-    def dispatch(obj)
-      begin
-        check_signature(obj)
-      rescue Exception => ex
-        Logger.crash("#{obj.class}: async call failed!", ex)
-        return
-      end
-
-      obj.send(@method, *@arguments, &@block)
-    rescue AbortError => ex
-      # Swallow aborted async calls, as they indicate the caller made a mistake
-      Logger.crash("#{obj.class}: async call aborted!", ex)
-    end
-  end
-end

data/lib/vendor/celluloid/lib/celluloid/core_ext.rb

@@ -1,14 +0,0 @@
-require 'celluloid/fiber'
-
-# Monkeypatch Thread to allow lazy access to its Celluloid::Mailbox
-class Thread
-  # Retrieve the mailbox for the current thread or lazily initialize it
-  def self.mailbox
-    current[:mailbox] ||= Celluloid::Mailbox.new
-  end
-end
-
-class Fiber
-  # Celluloid::Task associated with this Fiber
-  attr_accessor :task
-end

data/lib/vendor/celluloid/lib/celluloid/events.rb

@@ -1,14 +0,0 @@
-module Celluloid
-  # Exceptional system events which need to be processed out of band
-  class SystemEvent < Exception; end
-
-  # An actor has exited for the given reason
-  class ExitEvent < SystemEvent
-    attr_reader :actor, :reason
-
-    def initialize(actor, reason = nil)
-      @actor, @reason = actor, reason
-      super reason.to_s
-    end
-  end
-end

data/lib/vendor/celluloid/lib/celluloid/fiber.rb

@@ -1,33 +0,0 @@
-# Fibers are hard... let's go shopping!
-begin
-  require 'fiber'
-rescue LoadError => ex
-  if defined? JRUBY_VERSION
-    if RUBY_VERSION < "1.9.2"
-      raise LoadError, "Celluloid requires JRuby 1.9 mode. Please pass the --1.9 flag or set JRUBY_OPTS=--1.9"
-    end
-
-    # Fibers are broken on JRuby 1.6.5. This works around the issue
-    if JRUBY_VERSION == "1.6.5"
-      require 'jruby'
-      org.jruby.ext.fiber.FiberExtLibrary.new.load(JRuby.runtime, false)
-      class org::jruby::ext::fiber::ThreadFiber
-        field_accessor :state
-      end
-
-      class Fiber
-        def alive?
-          JRuby.reference(self).state != org.jruby.ext.fiber.ThreadFiberState::FINISHED
-        end
-      end
-    else
-      # Just in case subsequent JRuby releases have broken fibers :/
-      raise ex
-    end
-  elsif defined? Rubinius
-    # If we're on Rubinius, we can still work in 1.8 mode
-    Fiber = Rubinius::Fiber
-  else
-    raise ex
-  end
-end

data/lib/vendor/celluloid/lib/celluloid/fsm.rb

@@ -1,141 +0,0 @@
-module Celluloid
-  # Turn concurrent objects into finite state machines
-  # Inspired by Erlang's gen_fsm. See http://www.erlang.org/doc/man/gen_fsm.html
-  module FSM
-    DEFAULT_STATE = :default # Default state name unless one is explicitly set
-
-    # Included hook to extend class methods
-    def self.included(klass)
-      klass.send :include, Celluloid
-      klass.send :extend,  ClassMethods
-    end
-
-    module ClassMethods
-      # Ensure FSMs transition into the default state after they're initialized
-      def new(*args, &block)
-        fsm = super
-        fsm.transition default_state
-        fsm
-      end
-
-      # Ensure FSMs transition into the default state after they're initialized
-      def new_link(*args, &block)
-        fsm = super
-        fsm.transition default_state
-        fsm
-      end
-
-      # Obtain or set the default state
-      # Passing a state name sets the default state
-      def default_state(new_default = nil)
-        if new_default
-          @default_state = new_default.to_sym
-        else
-          defined?(@default_state) ? @default_state : DEFAULT_STATE
-        end
-      end
-
-      # Obtain the valid states for this FSM
-      def states
-        @states ||= {}
-      end
-
-      # Declare an FSM state and optionally provide a callback block to fire
-      # Options:
-      # * to: a state or array of states this state can transition to
-      def state(*args, &block)
-        if args.last.is_a? Hash
-          options = args.pop.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
-        else
-          options = {}
-        end
-
-        args.each do |name|
-          name = name.to_sym
-          states[name] = State.new(name, options['to'], &block)
-        end
-      end
-    end
-
-    # Obtain the current state of the FSM
-    def current_state
-      defined?(@state) ? @state : @state = self.class.default_state
-    end
-    alias_method :state, :current_state
-
-    # Transition to another state
-    # Options:
-    # * delay: don't transition immediately, wait the given number of seconds.
-    #          This will return a Celluloid::Timer object you can use to
-    #          cancel the pending state transition.
-    #
-    # Note: making additional state transitions will cancel delayed transitions
-    def transition(state_name, options = {})
-      state_name = state_name.to_sym
-      current_state = self.class.states[@state]
-
-      return if current_state && current_state.name == state_name
-
-      if current_state and not current_state.valid_transition? state_name
-        valid = current_state.transitions.map(&:to_s).join(", ")
-        raise ArgumentError, "#{self.class} can't change state from '#{@state}' to '#{state_name}', only to: #{valid}"
-      end
-
-      new_state = self.class.states[state_name]
-
-      if !new_state and state_name == self.class.default_state
-        # FIXME This probably isn't thread safe... or wise
-        new_state = self.class.states[state_name] = State.new(state_name)
-      end
-
-      if new_state
-        if options[:delay]
-          @delayed_transition.cancel if @delayed_transition
-
-          @delayed_transition = after(options[:delay]) do
-            transition! new_state.name
-            new_state.call(self)
-          end
-
-          return @delayed_transition
-        end
-
-        if defined?(@delayed_transition) and @delayed_transition
-          @delayed_transition.cancel
-          @delayed_transition = nil
-        end
-
-        transition! new_state.name
-        new_state.call(self)
-      else
-        raise ArgumentError, "invalid state for #{self.class}: #{state_name}"
-      end
-    end
-
-    # Immediate state transition with no sanity checks. "Dangerous!"
-    def transition!(state_name)
-      @state = state_name
-    end
-
-    # FSM states as declared by Celluloid::FSM.state
-    class State
-      attr_reader :name, :transitions
-
-      def initialize(name, transitions = nil, &block)
-        @name, @block = name, block
-        @transitions = Array(transitions).map { |t| t.to_sym } if transitions
-      end
-
-      def call(obj)
-        obj.instance_eval(&@block) if @block
-      end
-
-      def valid_transition?(new_state)
-        # All transitions are allowed unless expressly
-        return true unless @transitions
-
-        @transitions.include? new_state.to_sym
-      end
-    end
-  end
-end

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