celluloid 0.16.0 → 0.17.3

data/lib/celluloid/rspec/mailbox_examples.rb

@@ -1,84 +0,0 @@
-shared_context "a Celluloid Mailbox" do
-  after do
-    Celluloid.logger.stub(:debug)
-    subject.shutdown if subject.alive?
-  end
-
-  it "receives messages" do
-    message = :ohai
-
-    subject << message
-    subject.receive.should == message
-  end
-
-  it "prioritizes system events over other messages" do
-    subject << :dummy1
-    subject << :dummy2
-
-    subject << Celluloid::SystemEvent.new
-    subject.receive.should be_a(Celluloid::SystemEvent)
-  end
-
-  it "selectively receives messages with a block" do
-    class Foo; end
-    class Bar; end
-    class Baz; end
-
-    foo, bar, baz = Foo.new, Bar.new, Baz.new
-
-    subject << baz
-    subject << foo
-    subject << bar
-
-    subject.receive { |msg| msg.is_a? Foo }.should eq(foo)
-    subject.receive { |msg| msg.is_a? Bar }.should eq(bar)
-    subject.receive.should eq(baz)
-  end
-
-  it "waits for a given timeout interval" do
-    interval = 0.1
-    started_at = Time.now
-
-    expect do
-      subject.receive(interval) { false }
-    end.to raise_exception(Celluloid::TimeoutError)
-
-    (Time.now - started_at).should be_within(Celluloid::TIMER_QUANTUM).of interval
-  end
-
-  it "has a size" do
-    subject.should respond_to(:size)
-    subject.size.should be_zero
-    subject << :foo
-    subject << :foo
-    subject.should have(2).entries
-  end
-
-  it "discards messages received when when full" do
-    subject.max_size = 2
-    subject << :first
-    subject << :second
-    subject << :third
-    subject.to_a.should =~ [:first, :second]
-  end
-
-  it "logs discarded messages" do
-    Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): third")
-
-    subject.max_size = 2
-    subject << :first
-    subject << :second
-    subject << :third
-  end
-
-  it "discard messages when dead" do
-    Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): first")
-    Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): second")
-    Celluloid.logger.should_receive(:debug).with("Discarded message (mailbox is dead): third")
-
-    subject << :first
-    subject << :second
-    subject.shutdown
-    subject << :third
-  end
-end

data/lib/celluloid/signals.rb

@@ -1,23 +0,0 @@
-module Celluloid
-  # Event signaling between methods of the same object
-  class Signals
-    def initialize
-      @conditions = {}
-    end
-
-    # Wait for the given signal and return the associated value
-    def wait(name)
-      raise "cannot wait for signals while exclusive" if Celluloid.exclusive?
-
-      @conditions[name] ||= Condition.new
-      @conditions[name].wait
-    end
-
-    # Send a signal to all method calls waiting for the given name
-    def broadcast(name, value = nil)
-      if condition = @conditions.delete(name)
-        condition.broadcast(value)
-      end
-    end
-  end
-end

data/lib/celluloid/stack_dump.rb

@@ -1,133 +0,0 @@
-module Celluloid
-  class StackDump
-    module DisplayBacktrace
-      def display_backtrace(backtrace, output, indent = nil)
-        backtrace ||= ["EMPTY BACKTRACE"]
-        backtrace.each do |line|
-          output << indent if indent
-          output << "\t" << line << "\n"
-        end
-        output << "\n\n"
-      end
-    end
-
-    class TaskState < Struct.new(:task_class, :type, :meta, :status, :backtrace)
-    end
-
-    class ActorState
-      include DisplayBacktrace
-      attr_accessor :name, :id, :cell
-      attr_accessor :status, :tasks
-      attr_accessor :backtrace
-
-      def dump
-        string = ""
-        string << "Celluloid::Actor 0x#{id.to_s(16)}"
-        string << " [#{name}]" if name
-        string << "\n"
-
-        if cell
-          string << cell.dump
-          string << "\n"
-        end
-
-        if status == :idle
-          string << "State: Idle (waiting for messages)\n"
-          display_backtrace backtrace, string
-        else
-          string << "State: Running (executing tasks)\n"
-          display_backtrace backtrace, string
-          string << "\tTasks:\n"
-
-          tasks.each_with_index do |task, i|
-            string << "\t  #{i+1}) #{task.task_class}[#{task.type}]: #{task.status}\n"
-            string << "\t      #{task.meta.inspect}\n"
-            display_backtrace task.backtrace, string, "\t"
-          end
-        end
-
-        string
-      end
-    end
-
-    class CellState < Struct.new(:subject_id, :subject_class)
-      def dump
-        "Celluloid::Cell 0x#{subject_id.to_s(16)}: #{subject_class}"
-      end
-    end
-
-    class ThreadState < Struct.new(:thread_id, :backtrace, :role)
-      include DisplayBacktrace
-
-      def dump
-        string = ""
-        string << "Thread 0x#{thread_id.to_s(16)} (#{role}):\n"
-        display_backtrace backtrace, string
-        string
-      end
-    end
-
-    attr_accessor :actors, :threads
-
-    def initialize(internal_pool)
-      @internal_pool = internal_pool
-
-      @actors  = []
-      @threads = []
-
-      snapshot
-    end
-
-    def snapshot
-      @internal_pool.each do |thread|
-        if thread.role == :actor
-          @actors << snapshot_actor(thread.actor) if thread.actor
-        else
-          @threads << snapshot_thread(thread)
-        end
-      end
-    end
-
-    def snapshot_actor(actor)
-      state = ActorState.new
-      state.id = actor.object_id
-
-      # TODO: delegate to the behavior
-      if actor.behavior.is_a?(Cell)
-        state.cell = snapshot_cell(actor.behavior)
-      end
-
-      tasks = actor.tasks
-      if tasks.empty?
-        state.status = :idle
-      else
-        state.status = :running
-        state.tasks = tasks.to_a.map { |t| TaskState.new(t.class, t.type, t.meta, t.status, t.backtrace) }
-      end
-
-      state.backtrace = actor.thread.backtrace if actor.thread
-      state
-    end
-
-    def snapshot_cell(behavior)
-      state = CellState.new
-      state.subject_id = behavior.subject.object_id
-      state.subject_class = behavior.subject.class
-      state
-    end
-
-    def snapshot_thread(thread)
-      ThreadState.new(thread.object_id, thread.backtrace, thread.role)
-    end
-
-    def print(output = STDERR)
-      @actors.each do |actor|
-        output.print actor.dump
-      end
-
-      @threads.each do |thread|
-        output.print thread.dump
-      end
-    end
-  end
-end

data/lib/celluloid/supervision_group.rb

@@ -1,169 +0,0 @@
-module Celluloid
-  # Supervise collections of actors as a group
-  class SupervisionGroup
-    include Celluloid
-    trap_exit :restart_actor
-
-    class << self
-
-      # Actors or sub-applications to be supervised
-      def blocks
-        @blocks ||= []
-      end
-
-      # Start this application (and watch it with a supervisor)
-      def run!(registry = nil)
-        group = new(registry) do |_group|
-          blocks.each do |block|
-            block.call(_group)
-          end
-        end
-        group
-      end
-
-      # Run the application in the foreground with a simple watchdog
-      def run(registry = nil)
-        loop do
-          supervisor = run!(registry)
-
-          # Take five, toplevel supervisor
-          sleep 5 while supervisor.alive?
-
-          Logger.error "!!! Celluloid::SupervisionGroup #{self} crashed. Restarting..."
-        end
-      end
-
-      # Register an actor class or a sub-group to be launched and supervised
-      # Available options are:
-      #
-      # * as: register this application in the Celluloid::Actor[] directory
-      # * args: start the actor with the given arguments
-      def supervise(klass, options = {})
-        blocks << lambda do |group|
-          group.add klass, options
-        end
-      end
-
-      # Register a pool of actors to be launched on group startup
-      # Available options are:
-      #
-      # * as: register this application in the Celluloid::Actor[] directory
-      # * args: start the actor pool with the given arguments
-      def pool(klass, options = {})
-        blocks << lambda do |group|
-          group.pool klass, options
-        end
-      end
-    end
-
-    finalizer :finalize
-
-    # Start the group
-    def initialize(registry = nil)
-      @members = []
-      @registry = registry || Celluloid.actor_system.registry
-
-      yield current_actor if block_given?
-    end
-
-    execute_block_on_receiver :initialize, :supervise, :supervise_as
-
-    def supervise(klass, *args, &block)
-      add(klass, :args => args, :block => block)
-    end
-
-    def supervise_as(name, klass, *args, &block)
-      add(klass, :args => args, :block => block, :as => name)
-    end
-
-    def pool(klass, options = {})
-      options[:method] = 'pool_link'
-      add(klass, options)
-    end
-
-    def add(klass, options)
-      member = Member.new(@registry, klass, options)
-      @members << member
-      member.actor
-    end
-
-    def actors
-      @members.map(&:actor)
-    end
-
-    def [](actor_name)
-      @registry[actor_name]
-    end
-
-    # Restart a crashed actor
-    def restart_actor(actor, reason)
-      member = @members.find do |_member|
-        _member.actor == actor
-      end
-      raise "a group member went missing. This shouldn't be!" unless member
-
-      if reason
-        member.restart
-      else
-        member.cleanup
-        @members.delete(member)
-      end
-    end
-
-    # A member of the group
-    class Member
-      def initialize(registry, klass, options = {})
-        @registry = registry
-        @klass = klass
-
-        # Stringify keys :/
-        options = options.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
-
-        @name = options['as']
-        @block = options['block']
-        @args = options['args'] ? Array(options['args']) : []
-        @method = options['method'] || 'new_link'
-        @pool = @method == 'pool_link'
-        @pool_size = options['size'] if @pool
-
-        start
-      end
-      attr_reader :name, :actor
-
-      def start
-        # when it is a pool, then we don't splat the args
-        # and we need to extract the pool size if set
-        if @pool
-          options = {:args => @args}
-          options[:size] = @pool_size if @pool_size
-          @args = [options]
-        end
-        @actor = @klass.send(@method, *@args, &@block)
-        @registry[@name] = @actor if @name
-      end
-
-      def restart
-        @actor = nil
-        cleanup
-
-        start
-      end
-
-      def terminate
-        cleanup
-        @actor.terminate if @actor
-      rescue DeadActorError
-      end
-
-      def cleanup
-        @registry.delete(@name) if @name
-      end
-    end
-
-    private
-
-    def finalize
-      @members.reverse_each(&:terminate) if @members
-    end
-  end
-end

data/lib/celluloid/supervisor.rb

@@ -1,22 +0,0 @@
-module Celluloid
-  # Supervisors are actors that watch over other actors and restart them if
-  # they crash
-  class Supervisor
-    class << self
-      # Define the root of the supervision tree
-      attr_accessor :root
-
-      def supervise(klass, *args, &block)
-        SupervisionGroup.new do |group|
-          group.supervise klass, *args, &block
-        end
-      end
-
-      def supervise_as(name, klass, *args, &block)
-        SupervisionGroup.new do |group|
-          group.supervise_as name, klass, *args, &block
-        end
-      end
-    end
-  end
-end

data/lib/celluloid/task_set.rb

@@ -1,49 +0,0 @@
-require 'set'
-require 'forwardable'
-
-module Celluloid
-  if defined? JRUBY_VERSION
-    require 'jruby/synchronized'
-
-    class TaskSet
-      extend  Forwardable
-      include JRuby::Synchronized
-
-      def_delegators :@tasks, :<<, :delete, :first, :empty?, :to_a
-
-      def initialize
-        @tasks = Set.new
-      end
-    end
-  elsif defined? Rubinius
-    class TaskSet
-      def initialize
-        @tasks = Set.new
-      end
-
-      def <<(task)
-        Rubinius.synchronize(self) { @tasks << task }
-      end
-
-      def delete(task)
-        Rubinius.synchronize(self) { @tasks.delete task }
-      end
-
-      def first
-        Rubinius.synchronize(self) { @tasks.first }
-      end
-
-      def empty?
-        Rubinius.synchronize(self) { @tasks.empty? }
-      end
-
-      def to_a
-        Rubinius.synchronize(self) { @tasks.to_a }
-      end
-    end
-  else
-    # Assume we're on MRI, where we have the GIL. But what about IronRuby?
-    # Or MacRuby. Do people care? This will break Celluloid::StackDumps
-    TaskSet = Set
-  end
-end

data/lib/celluloid/tasks/task_fiber.rb

@@ -1,43 +0,0 @@
-module Celluloid
-  class FiberStackError < Celluloid::Error; end
-
-  # Tasks with a Fiber backend
-  class TaskFiber < Task
-
-    def create
-      queue = Thread.current[:celluloid_queue]
-      actor_system = Thread.current[:celluloid_actor_system]
-      @fiber = Fiber.new do
-        # FIXME: cannot use the writer as specs run inside normal Threads
-        Thread.current[:celluloid_role] = :actor
-        Thread.current[:celluloid_queue] = queue
-        Thread.current[:celluloid_actor_system] = actor_system
-        yield
-      end
-    end
-
-    def signal
-      Fiber.yield
-    end
-
-    # Resume a suspended task, giving it a value to return if needed
-    def deliver(value)
-      @fiber.resume value
-    rescue SystemStackError => ex
-      raise FiberStackError, "#{ex} (please see https://github.com/celluloid/celluloid/wiki/Fiber-stack-errors)"
-    rescue FiberError => ex
-      raise DeadTaskError, "cannot resume a dead task (#{ex})"
-    end
-
-    # Terminate this task
-    def terminate
-      super
-    rescue FiberError
-      # If we're getting this the task should already be dead
-    end
-
-    def backtrace
-      ["#{self.class} backtrace unavailable. Please try `Celluloid.task_class = Celluloid::TaskThread` if you need backtraces here."]
-    end
-  end
-end

data/lib/celluloid/tasks/task_thread.rb

@@ -1,53 +0,0 @@
-module Celluloid
-  # Tasks with a Thread backend
-  class TaskThread < Task
-    # Run the given block within a task
-    def initialize(type, meta)
-      @resume_queue = Queue.new
-      @exception_queue = Queue.new
-      @yield_mutex  = Mutex.new
-      @yield_cond   = ConditionVariable.new
-
-      super
-    end
-
-    def create
-      # TODO: move this to ActorSystem#get_thread (ThreadHandle inside InternalPool)
-      @thread = ThreadHandle.new(Thread.current[:celluloid_actor_system], :task) do
-        begin
-          ex = @resume_queue.pop
-          raise ex if ex.is_a?(Task::TerminatedError)
-
-          yield
-        rescue Exception => ex
-          @exception_queue << ex
-        ensure
-          @yield_cond.signal
-        end
-      end
-    end
-
-    def signal
-      @yield_cond.signal
-      @resume_queue.pop
-    end
-
-    def deliver(value)
-      raise DeadTaskError, "cannot resume a dead task" unless @thread.alive?
-
-      @yield_mutex.synchronize do
-        @resume_queue.push(value)
-        @yield_cond.wait(@yield_mutex)
-        while @exception_queue.size > 0
-          raise @exception_queue.pop
-        end
-      end
-    rescue ThreadError
-      raise DeadTaskError, "cannot resume a dead task"
-    end
-
-    def backtrace
-      @thread.backtrace
-    end
-  end
-end

data/lib/celluloid/thread_handle.rb

@@ -1,50 +0,0 @@
-module Celluloid
-  # An abstraction around threads from the InternalPool which ensures we don't
-  # accidentally do things to threads which have been returned to the pool,
-  # such as, say, killing them
-  class ThreadHandle
-    def initialize(actor_system, role = nil)
-      @mutex = Mutex.new
-      @join  = ConditionVariable.new
-
-      @thread = actor_system.get_thread do
-        Thread.current.role = role
-        begin
-          yield
-        ensure
-          @mutex.synchronize do
-            @thread = nil
-            @join.broadcast
-          end
-        end
-      end
-    end
-
-    # Is the thread running?
-    def alive?
-      @mutex.synchronize { @thread.alive? if @thread }
-    end
-
-    # Forcibly kill the thread
-    def kill
-      !!@mutex.synchronize { @thread.kill if @thread }
-      self
-    end
-
-    # Join to a running thread, blocking until it terminates
-    def join(limit = nil)
-      raise ThreadError, "Target thread must not be current thread" if @thread == Thread.current
-      @mutex.synchronize { @join.wait(@mutex, limit) if @thread }
-      self
-    end
-
-    # Obtain the backtrace for this thread
-    def backtrace
-      @thread.backtrace
-    rescue NoMethodError
-      # undefined method `backtrace' for nil:NilClass
-      # Swallow this in case this ThreadHandle was terminated and @thread was
-      # set to nil
-    end
-  end
-end

data/lib/celluloid/uuid.rb

@@ -1,38 +0,0 @@
-require 'securerandom'
-
-module Celluloid
-  # Clearly Ruby doesn't have enough UUID libraries
-  # This one aims to be fast and simple with good support for multiple threads
-  # If there's a better UUID library I can use with similar multithreaded
-  # performance, I certainly wouldn't mind using a gem for this!
-  module UUID
-    values = SecureRandom.hex(9).match(/(.{8})(.{4})(.{3})(.{3})/)
-    PREFIX = "#{values[1]}-#{values[2]}-4#{values[3]}-8#{values[4]}".freeze
-    BLOCK_SIZE = 0x10000
-
-    @counter = 0
-    @counter_mutex = Mutex.new
-
-    def self.generate
-      thread = Thread.current
-
-      unless thread.uuid_limit
-        @counter_mutex.synchronize do
-          block_base = @counter
-          @counter += BLOCK_SIZE
-          thread.uuid_counter = block_base
-          thread.uuid_limit   = @counter - 1
-        end
-      end
-
-      counter = thread.uuid_counter
-      if thread.uuid_counter >= thread.uuid_limit
-        thread.uuid_counter = thread.uuid_limit = nil
-      else
-        thread.uuid_counter += 1
-      end
-
-      "#{PREFIX}-#{sprintf("%012x", counter)}".freeze
-    end
-  end
-end