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

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

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

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

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

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

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

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

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

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