celluloid 0.16.0 → 0.17.0

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

data/spec/celluloid/cpu_counter_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::CPUCounter do
-  describe :cores do
-    subject { described_class.cores }
-
-    let(:num_cores) { 1024 }
-
-    before do
-      described_class.stub(:`) { fail 'backtick stub called' }
-      ::IO.stub(:open).and_raise('IO.open stub called!')
-      described_class.instance_variable_set('@cores', nil)
-    end
-
-    after { ENV['NUMBER_OF_PROCESSORS'] = nil }
-
-    context 'from valid env value' do
-      before { ENV['NUMBER_OF_PROCESSORS'] = num_cores.to_s }
-      it { should eq num_cores }
-    end
-
-    context 'from invalid env value' do
-      before { ENV['NUMBER_OF_PROCESSORS'] = '' }
-      specify { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'with no env value' do
-      before { ENV['NUMBER_OF_PROCESSORS'] = nil }
-
-      context 'when /sys/devices/system/cpu/present exists' do
-        before do
-          ::IO.should_receive(:read).with('/sys/devices/system/cpu/present')
-            .and_return("dunno-whatever-#{num_cores - 1}")
-        end
-        it { should eq num_cores }
-      end
-
-      context 'when /sys/devices/system/cpu/present does NOT exist' do
-        before do
-          ::IO.should_receive(:read).with('/sys/devices/system/cpu/present')
-            .and_raise(Errno::ENOENT)
-        end
-
-        context 'when /sys/devices/system/cpu/cpu* files exist' do
-          before do
-            cpu_entries = (1..num_cores).map { |n| "cpu#{n}" }
-            cpu_entries << 'non-cpu-entry-to-ignore'
-            Dir.should_receive(:[]).with('/sys/devices/system/cpu/cpu*')
-              .and_return(cpu_entries)
-          end
-          it { should eq num_cores }
-        end
-
-        context 'when /sys/devices/system/cpu/cpu* files DO NOT exist' do
-          before do
-            Dir.should_receive(:[]).with('/sys/devices/system/cpu/cpu*')
-              .and_return([])
-          end
-
-          context 'when sysctl blows up' do
-            before { described_class.stub(:`).and_raise(Errno::EINTR) }
-            specify { expect { subject }.to raise_error }
-          end
-
-          context 'when sysctl fails' do
-            before { described_class.stub(:`).and_return(`false`) }
-            it { should be nil }
-          end
-
-          context 'when sysctl succeeds' do
-            before do
-              described_class.should_receive(:`).with('sysctl -n hw.ncpu')
-                .and_return(num_cores.to_s)
-              `true`
-            end
-            it { should eq num_cores }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/celluloid/fsm_spec.rb

@@ -1,107 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::FSM, actor_system: :global do
-  before :all do
-    class TestMachine
-      include Celluloid::FSM
-
-      def initialize
-        super
-        @fired = false
-      end
-
-      state :callbacked do
-        @fired = true
-      end
-
-      state :pre_done, :to => :done
-      state :another, :done
-
-      def fired?; @fired end
-    end
-
-    class DummyActor
-      include Celluloid
-    end
-
-    class CustomDefaultMachine
-      include Celluloid::FSM
-
-      default_state :foobar
-    end
-  end
-
-  subject { TestMachine.new }
-
-  it "starts in the default state" do
-    subject.state.should eq(TestMachine.default_state)
-  end
-
-  it "transitions between states" do
-    subject.state.should_not be :done
-    subject.transition :done
-    subject.state.should be :done
-  end
-
-  it "fires callbacks for states" do
-    subject.should_not be_fired
-    subject.transition :callbacked
-    subject.should be_fired
-  end
-
-  it "allows custom default states" do
-    CustomDefaultMachine.new.state.should be :foobar
-  end
-
-  it "supports constraints on valid state transitions" do
-    subject.transition :pre_done
-    expect { subject.transition :another }.to raise_exception ArgumentError
-  end
-
-  it "transitions to states after a specified delay" do
-    interval = Celluloid::TIMER_QUANTUM * 10
-
-    subject.attach DummyActor.new
-    subject.transition :another
-    subject.transition :done, :delay => interval
-
-    subject.state.should be :another
-    sleep interval + Celluloid::TIMER_QUANTUM
-
-    subject.state.should be :done
-  end
-
-  it "cancels delayed state transitions if another transition is made" do
-    interval = Celluloid::TIMER_QUANTUM * 10
-
-    subject.attach DummyActor.new
-    subject.transition :another
-    subject.transition :done, :delay => interval
-
-    subject.state.should be :another
-    subject.transition :pre_done
-    sleep interval + Celluloid::TIMER_QUANTUM
-
-    subject.state.should be :pre_done
-  end
-
-  context "actor is not set" do
-    context "transition is delayed" do
-      it "raises an unattached error" do
-        expect { subject.transition :another, :delay => 100 } \
-          .to raise_error(Celluloid::FSM::UnattachedError)
-      end
-    end
-  end
-
-  context "transitioning to an invalid state" do
-    it "raises an argument error" do
-      expect { subject.transition :invalid_state }.to raise_error(ArgumentError)
-    end
-
-    it "should not call transition! if the state is :default" do
-      subject.should_not_receive :transition!
-      subject.transition :default
-    end
-  end
-end

data/spec/celluloid/internal_pool_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::InternalPool do
-  it "gets threads from the pool" do
-    subject.get { sleep 1 }.should be_a Thread
-  end
-
-  it "puts threads back into the pool" do
-    subject.idle_size.should be_zero
-    subject.busy_size.should be_zero
-
-    queue = Queue.new
-    subject.get { queue.pop }
-
-    subject.idle_size.should be_zero
-    subject.busy_size.should eq 1
-
-    queue << nil
-    sleep 0.01 # hax
-
-    subject.idle_size.should eq 1
-    subject.busy_size.should eq 0
-  end
-
-  it "cleans thread locals from old threads" do
-    thread = subject.get { Thread.current[:foo] = :bar }
-
-    sleep 0.01 #hax
-    thread[:foo].should be_nil
-  end
-
-  it "doesn't fail if a third-party thread is spawned" do
-    subject.idle_size.should be_zero
-    subject.busy_size.should be_zero
-
-    subject.get { ::Thread.new { sleep 0.5 } }.should be_a(Celluloid::Thread)
-
-    sleep 0.01 # hax
-
-    subject.idle_size.should eq 1
-    subject.busy_size.should eq 0
-  end
-
-  it "doesn't leak dead threads" do
-    subject.max_idle = 0 # Instruct the pool to immediately shut down the thread.
-    subject.get { true }.should be_a(Celluloid::Thread)
-
-    sleep 0.01 # hax
-
-    subject.to_a.should have(0).items
-  end
-end

data/spec/celluloid/links_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::Links do
-  subject { Celluloid::Links.new }
-
-  let(:mailbox_mock) do
-    Class.new(Array) do
-      attr_reader :address
-      def initialize address
-        @address = address
-      end
-    end
-  end
-
-  let(:first_actor) do
-    Struct.new(:mailbox).new(mailbox_mock.new('foo123'))
-  end
-
-  let(:second_actor) do
-    Struct.new(:mailbox).new(mailbox_mock.new('bar456'))
-  end
-
-  it 'is Enumerable' do
-    subject.should be_an(Enumerable)
-  end
-
-  it 'adds actors by their mailbox address' do
-    subject.include?(first_actor).should be_false
-    subject << first_actor
-    subject.include?(first_actor).should be_true
-  end
-
-  it 'removes actors by their mailbox address' do
-    subject << first_actor
-    subject.include?(first_actor).should be_true
-    subject.delete first_actor
-    subject.include?(first_actor).should be_false
-  end
-
-  it 'iterates over all actors' do
-    subject << first_actor
-    subject << second_actor
-    subject.inject([]) { |all, a| all << a }.should == [first_actor, second_actor]
-  end
-end

data/spec/celluloid/logging/ring_buffer_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::RingBuffer do
-  subject { Celluloid::RingBuffer.new(2) }
-
-  it { should be_empty }
-  it { should_not be_full }
-
-  it 'should push and shift' do
-    subject.push('foo')
-    subject.push('foo2')
-    subject.shift.should eq('foo')
-    subject.shift.should eq('foo2')
-  end
-
-  it 'should push past the end' do
-    subject.push('foo')
-    subject.push('foo2')
-    subject.push('foo3')
-    subject.should be_full
-  end
-
-  it 'should shift the most recent' do
-    (1..5).each { |i| subject.push(i) }
-    subject.shift.should be 4
-    subject.shift.should be 5
-    subject.shift.should be_nil
-  end
-
-  it 'should return nil when shifting empty' do
-    subject.should be_empty
-    subject.shift.should be_nil
-  end
-
-  it 'should be thread-safe' do
-    #TODO how to test?
-  end
-end

data/spec/celluloid/notifications_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-describe Celluloid::Notifications, actor_system: :global do
-  class Admirer
-    include Celluloid
-    include Celluloid::Notifications
-
-    attr_reader :mourning
-    attr_reader :mourning_count
-
-    def someone_died(topic, name)
-      @mourning = name
-      @mourning_count ||= 0
-      @mourning_count += 1
-    end
-  end
-
-  class President
-    include Celluloid
-    include Celluloid::Notifications
-
-    def die
-      publish("death", "Mr. President")
-    end
-  end
-
-  it 'notifies relevant subscribers' do
-    marilyn = Admirer.new
-    jackie = Admirer.new
-
-    marilyn.subscribe("death", :someone_died)
-    jackie.subscribe("alive", :someone_died)
-
-    president = President.new
-
-    president.die
-    marilyn.mourning.should eq("Mr. President")
-    jackie.mourning.should_not eq("Mr. President")
-  end
-
-  it 'allows multiple subscriptions from the same actor' do
-    marilyn = Admirer.new
-
-    marilyn.subscribe("death", :someone_died)
-    marilyn.subscribe("death", :someone_died)
-
-    president = President.new
-
-    president.die
-    marilyn.mourning_count.should be(2)
-  end
-
-
-  it 'notifies subscribers' do
-    marilyn = Admirer.new
-    jackie = Admirer.new
-
-    marilyn.subscribe("death", :someone_died)
-    jackie.subscribe("death", :someone_died)
-
-    president = President.new
-
-    president.die
-    marilyn.mourning.should eq("Mr. President")
-    jackie.mourning.should eq("Mr. President")
-  end
-
-  it 'publishes even if there are no subscribers' do
-    president = President.new
-    president.die
-  end
-
-  it 'allows regex subscriptions' do
-    marilyn = Admirer.new
-
-    marilyn.subscribe(/(death|assassination)/, :someone_died)
-
-    president = President.new
-    president.die
-    marilyn.mourning.should eq("Mr. President")
-  end
-
-  it 'allows unsubscribing' do
-    marilyn = Admirer.new
-
-    subscription = marilyn.subscribe("death", :someone_died)
-    marilyn.unsubscribe(subscription)
-
-    president = President.new
-    president.die
-    marilyn.mourning.should be_nil
-  end
-
-  it 'prunes dead subscriptions' do
-    marilyn = Admirer.new
-    jackie = Admirer.new
-
-    marilyn.subscribe("death", :someone_died)
-    jackie.subscribe("death", :someone_died)
-
-    listeners = Celluloid::Notifications.notifier.listeners_for("death").size
-    marilyn.terminate
-    after_listeners = Celluloid::Notifications.notifier.listeners_for("death").size
-
-    after_listeners.should == listeners - 1
-  end
-
-  it 'prunes multiple subscriptions from a dead actor' do
-    marilyn = Admirer.new
-
-    marilyn.subscribe("death", :someone_died)
-    marilyn.subscribe("death", :someone_died)
-
-    listeners = Celluloid::Notifications.notifier.listeners_for("death").size
-    marilyn.terminate
-    after_listeners = Celluloid::Notifications.notifier.listeners_for("death").size
-
-    after_listeners.should eq(listeners - 2)
-  end
-end