engineyard-serverside 1.5.23.ruby19.16 → 1.5.24

data/lib/vendor/celluloid/lib/celluloid/actor_pool.rb

@@ -1,54 +0,0 @@
-require 'thread'
-
-module Celluloid
-  class Actor
-    # Maintain a thread pool of actors FOR SPEED!!
-    class Pool
-      @pool = []
-      @lock = Mutex.new
-      @max_idle = 16
-
-      class << self
-        attr_accessor :max_idle
-
-        def get(&block)
-          @lock.synchronize do
-            if @pool.empty?
-              thread = create
-            else
-              thread = @pool.shift
-            end
-
-            thread[:queue] << block
-            thread
-          end
-        end
-
-        def put(thread)
-          @lock.synchronize do
-            if @pool.size >= @max_idle
-              thread[:queue] << nil
-            else
-              @pool << thread
-            end
-          end
-        end
-
-        def create
-          queue = Queue.new
-          thread = Thread.new do
-            begin
-              while func = queue.pop
-                func.call
-              end
-            rescue Exception => ex
-              Logger.crash("#{self} internal failure", ex)
-            end
-          end
-          thread[:queue] = queue
-          thread
-        end
-      end
-    end
-  end
-end

data/lib/vendor/celluloid/lib/celluloid/actor_proxy.rb

@@ -1,75 +0,0 @@
-module Celluloid
-  # A proxy object returned from Celluloid::Actor.spawn/spawn_link which
-  # dispatches calls and casts to normal Ruby objects which are running inside
-  # of their own threads.
-  class ActorProxy
-    attr_reader :mailbox
-
-    def initialize(mailbox, klass = "Object")
-      @mailbox, @klass = mailbox, klass
-    end
-
-    def send(meth, *args, &block)
-      Actor.call @mailbox, :send, meth, *args, &block
-    end
-
-    def class
-      Actor.call @mailbox, :send, :class
-    end
-
-    def respond_to?(meth)
-      Actor.call @mailbox, :respond_to?, meth
-    end
-
-    def methods(include_ancestors = true)
-      Actor.call @mailbox, :methods, include_ancestors
-    end
-
-    def alive?
-      @mailbox.alive?
-    end
-
-    def to_s
-      Actor.call @mailbox, :to_s
-    end
-
-    def inspect
-      Actor.call @mailbox, :inspect
-    rescue DeadActorError
-      "#<Celluloid::Actor(#{@klass}) dead>"
-    end
-
-    # Create a Celluloid::Future which calls a given method
-    def future(method_name, *args, &block)
-      Future.new { Actor.call @mailbox, method_name, *args, &block }
-    end
-
-    # Terminate the associated actor
-    def terminate
-      raise DeadActorError, "actor already terminated" unless alive?
-
-      begin
-        send :terminate
-      rescue DeadActorError
-        # In certain cases this is thrown during termination. This is likely
-        # a bug in Celluloid's internals, but it shouldn't affect the caller.
-        # FIXME: track this down and fix it, or at the very least log it
-      end
-
-      # Always return nil until a dependable exit value can be obtained
-      nil
-    end
-
-    # method_missing black magic to call bang predicate methods asynchronously
-    def method_missing(meth, *args, &block)
-      # bang methods are async calls
-      if meth.to_s.match(/!$/)
-        unbanged_meth = meth.to_s.sub(/!$/, '')
-        Actor.async @mailbox, unbanged_meth, *args, &block
-        return
-      end
-
-      Actor.call @mailbox, meth, *args, &block
-    end
-  end
-end

data/lib/vendor/celluloid/lib/celluloid/application.rb

@@ -1,78 +0,0 @@
-module Celluloid
-  # Applications describe and manage networks of Celluloid actors
-  class Application
-    include Celluloid
-    trap_exit :restart_supervisor
-
-    class << self
-      # Actors or sub-applications to be supervised
-      def supervisables
-        @supervisables ||= []
-      end
-
-      # Start this application (and watch it with a supervisor)
-      alias_method :run!, :supervise
-
-      # Run the application in the foreground with a simple watchdog
-      def run
-        loop do
-          supervisor = run!
-
-          # Take five, toplevel supervisor
-          sleep 5 while supervisor.alive?
-
-          Logger.error "!!! Celluloid::Application #{self} crashed. Restarting..."
-        end
-      end
-
-      # Register an actor class or a sub-application class to be launched and
-      # supervised while this application is running. Available options are:
-      #
-      # * as: register this application in the Celluloid::Actor[] directory
-      # * args: start the actor with the given arguments
-      def supervise(klass, options = {})
-        supervisables << Supervisable.new(klass, options)
-      end
-    end
-
-    # Start the application
-    def initialize
-      @supervisors = {}
-
-      # This is some serious lolcode, but like... start the supervisors for
-      # this application
-      self.class.supervisables.each do |supervisable|
-        supervisor = supervisable.supervise
-        @supervisors[supervisor] = supervisable
-      end
-    end
-
-    # Restart a crashed supervisor
-    def restart_supervisor(supervisor, reason)
-      supervisable = @supervisors.delete supervisor
-      raise "a supervisable went missing. This shouldn't be!" unless supervisable
-
-      supervisor = supervisable.supervise
-      @supervisors[supervisor] = supervisable
-    end
-
-    # A subcomponent of an application to be supervised
-    class Supervisable
-      attr_reader :klass, :as, :args
-
-      def initialize(klass, options = {})
-        @klass = klass
-
-        # Stringify keys :/
-        options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
-
-        @as = options['as']
-        @args = options['args'] || []
-      end
-
-      def supervise
-        Supervisor.new_link(@as, @klass, *@args)
-      end
-    end
-  end
-end

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

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