engineyard-serverside 1.5.23.ruby19.16 → 1.5.24

data/lib/engineyard-serverside/future.rb

@@ -1,29 +0,0 @@
-module EY
-  module Serverside
-    class Future
-      def self.success?(futures)
-        futures.empty? || futures.all? {|f| f.success?}
-      end
-
-      def initialize(server, *args, &block)
-        @server = server
-        @args = args
-        @block = block
-      end
-
-      def success?
-        @value == true
-      end
-
-      def error?
-        !success?
-      end
-    end
-
-    if defined?(Fiber)
-      require 'engineyard-serverside/futures/celluloid'
-    else
-      require 'engineyard-serverside/futures/dataflow'
-    end
-  end
-end

data/lib/engineyard-serverside/futures/celluloid.rb

@@ -1,25 +0,0 @@
-module EY
-  module Serverside
-    $LOAD_PATH.unshift File.expand_path('../../vendor/celluloid/lib', File.dirname(__FILE__))
-    require 'celluloid'
-    class Future
-      def self.call(servers, *args, &block)
-        futures = servers.map do |server|
-          new(server, *args, &block)
-        end
-
-        futures.each {|f| f.call}
-        futures
-      end
-
-      def future
-        Celluloid::Future.new(@server, *@args, &@block)
-      end
-
-      def call
-        # Celluloid needs to call the block explicitely
-        @value ||= future.call
-      end
-    end
-  end
-end

data/lib/engineyard-serverside/futures/dataflow.rb

@@ -1,31 +0,0 @@
-module EY
-  module Serverside
-    $LOAD_PATH.unshift File.expand_path('../../vendor/dataflow', File.dirname(__FILE__))
-    require 'dataflow'
-
-    class Future
-      extend Dataflow
-
-      def self.call(servers, *args, &block)
-        futures = []
-        # Dataflow needs to call `barrier` and `need_later` in the same object
-        barrier(*servers.map do |server|
-          future = new(server, *args, &block)
-          futures << future
-
-          need_later { future.call }
-        end)
-
-        futures
-      end
-
-      def future
-        @block.call(@server, *@args)
-      end
-
-      def call
-        @value ||= future
-      end
-    end
-  end
-end

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

@@ -1,261 +0,0 @@
-require 'logger'
-require 'thread'
-
-module Celluloid
-  @logger = Logger.new STDERR
-
-  class << self
-    attr_accessor :logger # Thread-safe logger class
-
-    def included(klass)
-      klass.send :extend, ClassMethods
-    end
-
-    # Are we currently inside of an actor?
-    def actor?
-      !!Thread.current[:actor]
-    end
-
-    # Obtain the currently running actor (if one exists)
-    def current_actor
-      actor = Thread.current[:actor]
-      raise NotActorError, "not in actor scope" unless actor
-      actor.proxy
-    end
-    alias_method :current, :current_actor
-
-    # Receive an asynchronous message
-    def receive(timeout = nil, &block)
-      actor = Thread.current[:actor]
-      if actor
-        actor.receive(timeout, &block)
-      else
-        Thread.mailbox.receive(timeout, &block)
-      end
-    end
-
-    # Sleep letting the actor continue processing messages
-    def sleep(interval)
-      actor = Thread.current[:actor]
-      if actor
-        actor.sleep(interval)
-      else
-        Kernel.sleep interval
-      end
-    end
-
-    # Obtain a hash of active tasks to their current activities
-    def tasks
-      actor = Thread.current[:actor]
-      raise NotActorError, "not in actor scope" unless actor
-      actor.tasks
-    end
-  end
-
-  # Class methods added to classes which include Celluloid
-  module ClassMethods
-    # Create a new actor
-    def new(*args, &block)
-      proxy = Actor.new(allocate).proxy
-      proxy.send(:initialize, *args, &block)
-      proxy
-    end
-    alias_method :spawn, :new
-
-    # Create a new actor and link to the current one
-    def new_link(*args, &block)
-      current_actor = Celluloid.current_actor
-      raise NotActorError, "can't link outside actor context" unless current_actor
-
-      proxy = Actor.new(allocate).proxy
-      current_actor.link proxy
-      proxy.send(:initialize, *args, &block)
-      proxy
-    end
-    alias_method :spawn_link, :new_link
-
-    # Create a supervisor which ensures an instance of an actor will restart
-    # an actor if it fails
-    def supervise(*args, &block)
-      Supervisor.supervise(self, *args, &block)
-    end
-
-    # Create a supervisor which ensures an instance of an actor will restart
-    # an actor if it fails, and keep the actor registered under a given name
-    def supervise_as(name, *args, &block)
-      Supervisor.supervise_as(name, self, *args, &block)
-    end
-
-    # Trap errors from actors we're linked to when they exit
-    def trap_exit(callback)
-      @exit_handler = callback.to_sym
-    end
-
-    # Obtain the exit handler for this actor
-    attr_reader :exit_handler
-
-    # Configure a custom mailbox factory
-    def use_mailbox(klass = nil, &block)
-      if block
-        define_method(:mailbox_factory, &block)
-      else
-        define_method(:mailbox_factory) { klass.new }
-      end
-    end
-  end
-
-  #
-  # Instance methods
-  #
-
-  # Is this actor alive?
-  def alive?
-    Thread.current[:actor].alive?
-  end
-
-  # Raise an exception in caller context, but stay running
-  def abort(cause)
-    raise AbortError.new(cause)
-  end
-
-  # Terminate this actor
-  def terminate
-    Thread.current[:actor].terminate
-  end
-
-  def inspect
-    str = "#<Celluloid::Actor(#{self.class}:0x#{object_id.to_s(16)})"
-    ivars = instance_variables.map do |ivar|
-      "#{ivar}=#{instance_variable_get(ivar).inspect}"
-    end
-
-    str << " " << ivars.join(' ') unless ivars.empty?
-    str << ">"
-  end
-
-  # Send a signal with the given name to all waiting methods
-  def signal(name, value = nil)
-    Thread.current[:actor].signal name, value
-  end
-
-  # Wait for the given signal
-  def wait(name)
-    Thread.current[:actor].wait name
-  end
-
-  # Obtain the current_actor
-  def current_actor
-    Celluloid.current_actor
-  end
-
-  # Obtain the running tasks for this actor
-  def tasks
-    Celluloid.tasks
-  end
-
-  # Obtain the Ruby object the actor is wrapping. This should ONLY be used
-  # for a limited set of use cases like runtime metaprogramming. Interacting
-  # directly with the wrapped object foregoes any kind of thread safety that
-  # Celluloid would ordinarily provide you, and the object is guaranteed to
-  # be shared with at least the actor thread. Tread carefully.
-  def wrapped_object; self; end
-
-  # Obtain the Celluloid::Links for this actor
-  def links
-    Thread.current[:actor].links
-  end
-
-  # Link this actor to another, allowing it to crash or react to errors
-  def link(actor)
-    actor.notify_link current_actor
-    notify_link actor
-  end
-
-  # Remove links to another actor
-  def unlink(actor)
-    actor.notify_unlink current_actor
-    notify_unlink actor
-  end
-
-  def notify_link(actor)
-    links << actor
-  end
-
-  def notify_unlink(actor)
-    links.delete actor
-  end
-
-  # Is this actor linked to another?
-  def linked_to?(actor)
-    Thread.current[:actor].links.include? actor
-  end
-
-  # Receive an asynchronous message via the actor protocol
-  def receive(timeout = nil, &block)
-    Celluloid.receive(timeout, &block)
-  end
-
-  # Sleep while letting the actor continue to receive messages
-  def sleep(interval)
-    Celluloid.sleep(interval)
-  end
-
-  # Call a block after a given interval
-  def after(interval, &block)
-    Thread.current[:actor].after(interval, &block)
-  end
-
-  # Perform a blocking or computationally intensive action inside an
-  # asynchronous thread pool, allowing the caller to continue processing other
-  # messages in its mailbox in the meantime
-  def async(&block)
-    # This implementation relies on the present implementation of
-    # Celluloid::Future, which uses an Actor to run the block
-    Future.new(&block).value
-  end
-
-  # Process async calls via method_missing
-  def method_missing(meth, *args, &block)
-    # bang methods are async calls
-    if meth.to_s.match(/!$/)
-      unbanged_meth = meth.to_s.sub(/!$/, '')
-      call = AsyncCall.new(@mailbox, unbanged_meth, args, block)
-
-      begin
-        Thread.current[:actor].mailbox << call
-      rescue MailboxError
-        # Silently swallow asynchronous calls to dead actors. There's no way
-        # to reliably generate DeadActorErrors for async calls, so users of
-        # async calls should find other ways to deal with actors dying
-        # during an async call (i.e. linking/supervisors)
-      end
-
-      return # casts are async and return immediately
-    end
-
-    super
-  end
-end
-
-require 'celluloid/version'
-require 'celluloid/actor_proxy'
-require 'celluloid/calls'
-require 'celluloid/core_ext'
-require 'celluloid/events'
-require 'celluloid/fiber'
-require 'celluloid/fsm'
-require 'celluloid/links'
-require 'celluloid/logger'
-require 'celluloid/mailbox'
-require 'celluloid/receivers'
-require 'celluloid/registry'
-require 'celluloid/responses'
-require 'celluloid/signals'
-require 'celluloid/task'
-require 'celluloid/timers'
-
-require 'celluloid/actor'
-require 'celluloid/actor_pool'
-require 'celluloid/supervisor'
-require 'celluloid/future'
-require 'celluloid/application'

data/lib/vendor/celluloid/lib/celluloid/actor.rb

@@ -1,242 +0,0 @@
-module Celluloid
-  # Don't do Actor-like things outside Actor scope
-  class NotActorError < StandardError; end
-
-  # Trying to do something to a dead actor
-  class DeadActorError < StandardError; end
-
-  # The caller made an error, not the current actor
-  class AbortError < StandardError
-    attr_reader :cause
-
-    def initialize(cause)
-      @cause = cause
-      super "caused by #{cause.inspect}: #{cause.to_s}"
-    end
-  end
-
-  # Actors are Celluloid's concurrency primitive. They're implemented as
-  # normal Ruby objects wrapped in threads which communicate with asynchronous
-  # messages.
-  class Actor
-    extend Registry
-
-    attr_reader :proxy
-    attr_reader :links
-    attr_reader :mailbox
-
-    # Invoke a method on the given actor via its mailbox
-    def self.call(mailbox, meth, *args, &block)
-      call = SyncCall.new(Thread.mailbox, meth, args, block)
-
-      begin
-        mailbox << call
-      rescue MailboxError
-        raise DeadActorError, "attempted to call a dead actor"
-      end
-
-      if Celluloid.actor?
-        response = Thread.current[:actor].wait [:call, call.id]
-      else
-        # Otherwise we're inside a normal thread, so block
-        response = Thread.mailbox.receive do |msg|
-          msg.respond_to?(:call_id) and msg.call_id == call.id
-        end
-      end
-
-      response.value
-    end
-
-    # Invoke a method asynchronously on an actor via its mailbox
-    def self.async(mailbox, meth, *args, &block)
-      begin
-        mailbox << AsyncCall.new(Thread.mailbox, meth, args, block)
-      rescue MailboxError
-        # Silently swallow asynchronous calls to dead actors. There's no way
-        # to reliably generate DeadActorErrors for async calls, so users of
-        # async calls should find other ways to deal with actors dying
-        # during an async call (i.e. linking/supervisors)
-      end
-    end
-
-    # Wrap the given subject with an Actor
-    def initialize(subject)
-      @subject = subject
-
-      if subject.respond_to? :mailbox_factory
-        @mailbox = subject.mailbox_factory
-      else
-        @mailbox = Mailbox.new
-      end
-
-      @links     = Links.new
-      @signals   = Signals.new
-      @receivers = Receivers.new
-      @timers    = Timers.new
-      @proxy     = ActorProxy.new(@mailbox, self.class.to_s)
-      @running   = true
-
-      @thread = Pool.get do
-        Thread.current[:actor]   = self
-        Thread.current[:mailbox] = @mailbox
-
-        run
-      end
-    end
-
-    # Is this actor alive?
-    def alive?
-      @running
-    end
-
-    # Terminate this actor
-    def terminate
-      @running = false
-      nil
-    end
-
-    # Send a signal with the given name to all waiting methods
-    def signal(name, value = nil)
-      @signals.send name, value
-    end
-
-    # Wait for the given signal
-    def wait(name)
-      @signals.wait name
-    end
-
-    # Receive an asynchronous message
-    def receive(timeout = nil, &block)
-      @receivers.receive(timeout, &block)
-    end
-
-    # Run the actor loop
-    def run
-      while @running
-        begin
-          message = @mailbox.receive(timeout)
-        rescue ExitEvent => exit_event
-          Task.new(:exit_handler) { handle_exit_event exit_event }.resume
-          retry
-        end
-
-        if message
-          handle_message message
-        else
-          # No message indicates a timeout
-          @timers.fire
-          @receivers.fire_timers
-        end
-      end
-
-      cleanup ExitEvent.new(@proxy)
-    rescue MailboxShutdown
-      # If the mailbox detects shutdown, exit the actor
-      @running = false
-    rescue Exception => ex
-      @running = false
-      handle_crash(ex)
-    ensure
-      Pool.put @thread
-    end
-
-    # How long to wait until the next timer fires
-    def timeout
-      i1 = @timers.wait_interval
-      i2 = @receivers.wait_interval
-
-      if i1 and i2
-        i1 < i2 ? i1 : i2
-      elsif i1
-        i1
-      else
-        i2
-      end
-    end
-
-    # Obtain a hash of tasks that are currently waiting
-    def tasks
-      # A hash of tasks to what they're waiting on is more meaningful to the
-      # end-user, and lets us make a copy of the tasks table, rather than
-      # handing them the one we're using internally across threads, a definite
-      # thread safety shared state no-no
-      tasks = {}
-      current_task = Task.current rescue nil
-      tasks[current_task] = :running if current_task
-
-      @signals.waiting.each do |waitable, waiters|
-        if waiters.is_a? Enumerable
-          waiters.each { |waiter| tasks[waiter] = waitable }
-        else
-          tasks[waiters] = waitable
-        end
-      end
-
-      tasks
-    end
-
-    # Schedule a block to run at the given time
-    def after(interval)
-      @timers.add(interval) do
-        Task.new(:timer) { yield }.resume
-      end
-    end
-
-    # Sleep for the given amount of time
-    def sleep(interval)
-      task = Task.current
-      @timers.add(interval) { task.resume }
-      Task.suspend
-    end
-
-    # Handle an incoming message
-    def handle_message(message)
-      case message
-      when Call
-        Task.new(:message_handler) { message.dispatch(@subject) }.resume
-      when Response
-        handled_successfully = signal [:call, message.call_id], message
-
-        unless handled_successfully
-          Logger.debug("anomalous message! spurious response to call #{message.call_id}")
-        end
-      else
-        @receivers.handle_message(message)
-      end
-      message
-    end
-
-    # Handle exit events received by this actor
-    def handle_exit_event(exit_event)
-      exit_handler = @subject.class.exit_handler
-      if exit_handler
-        return @subject.send(exit_handler, exit_event.actor, exit_event.reason)
-      end
-
-      # Reraise exceptions from linked actors
-      # If no reason is given, actor terminated cleanly
-      raise exit_event.reason if exit_event.reason
-    end
-
-    # Handle any exceptions that occur within a running actor
-    def handle_crash(exception)
-      Logger.crash("#{@subject.class} crashed!", exception)
-      cleanup ExitEvent.new(@proxy, exception)
-    rescue Exception => ex
-      Logger.crash("#{@subject.class}: ERROR HANDLER CRASHED!", ex)
-    end
-
-    # Handle cleaning up this actor after it exits
-    def cleanup(exit_event)
-      @mailbox.shutdown
-      @links.send_event exit_event
-      tasks.each { |task, _| task.terminate }
-
-      begin
-        @subject.finalize if @subject.respond_to? :finalize
-      rescue Exception => ex
-        Logger.crash("#{@subject.class}#finalize crashed!", ex)
-      end
-    end
-  end
-end