engineyard-serverside 1.5.23.ruby19.16 → 1.5.24

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

@@ -1,57 +0,0 @@
-module Celluloid
-  # Supervisors are actors that watch over other actors and restart them if
-  # they crash
-  class Supervisor
-    include Celluloid
-    trap_exit :restart_actor
-
-    # Retrieve the actor this supervisor is supervising
-    attr_reader :actor
-
-    def self.supervise(klass, *args, &block)
-      new(nil, klass, *args, &block)
-    end
-
-    def self.supervise_as(name, klass, *args, &block)
-      new(name, klass, *args, &block)
-    end
-
-    def initialize(name, klass, *args, &block)
-      @name, @klass, @args, @block = name, klass, args, block
-      @started = false
-
-      start_actor
-    end
-
-    def start_actor(start_attempts = 3, sleep_interval = 30)
-      failures = 0
-
-      begin
-        @actor = @klass.new_link(*@args, &@block)
-      rescue => ex
-        failures += 1
-        if failures >= start_attempts
-          failures = 0
-
-          Logger.warn("#{@klass} is crashing on initialize too quickly, sleeping for #{sleep_interval} seconds")
-          sleep sleep_interval
-        end
-        retry
-      end
-
-      @started = true
-      Actor[@name] = @actor if @name
-    end
-
-    # When actors die, regardless of the reason, restart them
-    def restart_actor(actor, reason)
-      start_actor if @started
-    end
-
-    def inspect
-      str = "#<#{self.class}(#{@klass}):0x#{object_id.to_s(16)}"
-      str << " " << @args.map { |arg| arg.inspect }.join(' ') unless @args.empty?
-      str << ">"
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-module Celluloid
-  # Trying to resume a dead task
-  class DeadTaskError < StandardError; end
-
-  # Tasks are interruptable/resumable execution contexts used to run methods
-  class Task
-    class TerminatedError < StandardError; end # kill a running fiber
-
-    attr_reader :type # what type of task is this?
-
-    # Obtain the current task
-    def self.current
-      task = Fiber.current.task
-      raise "not in task scope" unless task
-      task
-    end
-
-    # Suspend the running task, deferring to the scheduler
-    def self.suspend(value = nil)
-      result = Fiber.yield(value)
-      raise TerminatedError, "task was terminated" if result == TerminatedError
-      result
-    end
-
-    # Run the given block within a task
-    def initialize(type)
-      @type = type
-
-      actor   = Thread.current[:actor]
-      mailbox = Thread.current[:mailbox]
-
-      @fiber = Fiber.new do
-        Thread.current[:actor]   = actor
-        Thread.current[:mailbox] = mailbox
-
-        Fiber.current.task = self
-
-        begin
-          yield
-        rescue TerminatedError
-          # Task was explicitly terminated
-        end
-      end
-    end
-
-    # Resume a suspended task, giving it a value to return if needed
-    def resume(value = nil)
-      @fiber.resume value
-      nil
-    rescue FiberError
-      raise DeadTaskError, "cannot resume a dead task"
-    rescue RuntimeError => ex
-      # These occur spuriously on 1.9.3 if we shut down an actor with running tasks
-      return if ex.message == ""
-      raise
-    end
-
-    # Terminate this task
-    def terminate
-      resume TerminatedError
-    rescue FiberError
-      # If we're getting this the task should already be dead
-    end
-
-    # Is the current task still running?
-    def running?; @fiber.alive?; end
-
-    # Nicer string inspect for tasks
-    def inspect
-      "<Celluloid::Task:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @running=#{@fiber.alive?}>"
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'socket'
-
-module Celluloid
-  # A TCPServer that runs as an actor
-  class TCPServer
-    include Celluloid::IO
-
-    # Bind a TCP server to the given host and port
-    def initialize(host, port)
-      @server = ::TCPServer.new host, port
-      run!
-    end
-
-    # Run the TCP server event loop
-    def run
-      while true
-        wait_readable(@server)
-        on_connect @server.accept
-      end
-    end
-
-    # Terminate this server
-    def terminate
-      @server.close
-      super
-    end
-
-    # Called whenever a new connection is opened
-    def on_connect(connection)
-      connection.close
-    end
-  end
-end

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

@@ -1,109 +0,0 @@
-module Celluloid
-  # Low precision timers implemented in pure Ruby
-  class Timers
-    def initialize
-      @timers = []
-    end
-
-    # Call the given block after the given interval
-    def add(interval, &block)
-      Timer.new(self, interval, block)
-    end
-
-    # Wait for the next timer and fire it
-    def wait
-      return if @timers.empty?
-
-      interval = wait_interval
-      sleep interval if interval >= Timer::QUANTUM
-      fire
-    end
-
-    # Interval to wait until when the next timer will fire
-    def wait_interval
-      @timers.first.time - Time.now unless empty?
-    end
-
-    # Fire all timers that are ready
-    def fire
-      return if @timers.empty?
-
-      time = Time.now + Timer::QUANTUM
-      while not empty? and time > @timers.first.time
-        timer = @timers.shift
-        timer.call
-      end
-    end
-
-    # Insert a timer into the active timers
-    def insert(timer)
-      @timers.insert(index(timer), timer)
-    end
-
-    # Remove a given timer from the set we're monitoring
-    def cancel(timer)
-      @timers.delete timer
-    end
-
-    # Are there any timers pending?
-    def empty?
-      @timers.empty?
-    end
-
-    # Index where a timer would be located in the sorted timers array
-    def index(timer)
-      l, r = 0, @timers.size - 1
-
-      while l <= r
-        m = (r + l) / 2
-        if timer < @timers.at(m)
-          r = m - 1
-        else
-          l = m + 1
-        end
-      end
-      l
-    end
-  end
-
-  # An individual timer set to fire a given proc at a given time
-  class Timer
-    include Comparable
-
-    # The timer system is guaranteed (at least by the specs) to be this precise
-    # during normal operation. Long blocking calls within actors will delay the
-    # firing of timers
-    QUANTUM = 0.02
-
-    attr_reader :interval, :time
-
-    def initialize(timers, interval, block)
-      @timers, @interval = timers, interval
-      @block = block
-
-      reset
-    end
-
-    def <=>(other)
-      @time <=> other.time
-    end
-
-    # Cancel this timer
-    def cancel
-      @timers.cancel self
-    end
-
-    # Reset this timer
-    def reset
-      @timers.cancel self if defined?(@time)
-      @time = Time.now + @interval
-      @timers.insert self
-    end
-
-    # Fire the block
-    def fire
-      @block.call
-    end
-    alias_method :call, :fire
-  end
-end

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

@@ -1,4 +0,0 @@
-module Celluloid
-  VERSION = '0.7.1'
-  def self.version; VERSION; end
-end