celluloid 0.14.0 → 0.14.1.pre

data/lib/celluloid/actor.rb

@@ -27,7 +27,7 @@ module Celluloid
   # normal Ruby objects wrapped in threads which communicate with asynchronous
   # messages.
   class Actor
-    attr_reader :subject, :proxy, :tasks, :links, :mailbox, :thread, :name, :locals
+    attr_reader :subject, :proxy, :tasks, :links, :mailbox, :thread, :name
 
     class << self
       extend Forwardable
@@ -78,8 +78,7 @@ module Celluloid
       def all
         actors = []
         Thread.list.each do |t|
-          next unless t.celluloid?
-          next if t.task
+          next unless t.celluloid? && t.role == :actor
           actors << t.actor.proxy if t.actor && t.actor.respond_to?(:proxy)
         end
         actors
@@ -152,9 +151,8 @@ module Celluloid
       @running   = true
       @exclusive = false
       @name      = nil
-      @locals    = {}
 
-      @thread = ThreadHandle.new do
+      @thread = ThreadHandle.new(:actor) do
         setup_thread
         run
       end

data/lib/celluloid/condition.rb

@@ -3,11 +3,30 @@ module Celluloid
 
   # ConditionVariable-like signaling between tasks and actors
   class Condition
+    class Waiter
+      def initialize(condition, task, mailbox)
+        @condition = condition
+        @task = task
+        @mailbox = mailbox
+      end
+      attr_reader :condition, :task
+
+      def <<(message)
+        @mailbox << message
+      end
+
+      def wait
+        message = @mailbox.receive do |msg|
+          msg.is_a?(SignalConditionRequest) && msg.task == Thread.current
+        end
+        message.value
+      end
+    end
+
     attr_reader :owner
 
     def initialize
       @mutex = Mutex.new
-      @owner = Thread.current[:celluloid_actor]
       @tasks = []
     end
 
@@ -15,14 +34,18 @@ module Celluloid
     def wait
       raise ConditionError, "cannot wait for signals while exclusive" if Celluloid.exclusive?
 
+      if Thread.current[:celluloid_actor]
+        task = Task.current
+      else
+        task = Thread.current
+      end
+      waiter = Waiter.new(self, task, Celluloid.mailbox)
+
       @mutex.synchronize do
-        actor = Thread.current[:celluloid_actor]
-        raise ConditionError, "can't wait for conditions outside actors" unless actor
-        raise ConditionError, "can't wait unless owner" unless actor == @owner
-        @tasks << Task.current
+        @tasks << waiter
       end
 
-      result = Task.suspend :condwait
+      result = Celluloid.suspend :condwait, waiter
       raise result if result.is_a? ConditionError
       result
     end
@@ -30,10 +53,8 @@ module Celluloid
     # Send a signal to the first task waiting on this condition
     def signal(value = nil)
       @mutex.synchronize do
-        raise ConditionError, "no owner for this condition" unless @owner
-
-        if task = @tasks.shift
-          @owner.mailbox << SignalConditionRequest.new(task, value)
+        if waiter = @tasks.shift
+          waiter << SignalConditionRequest.new(waiter.task, value)
         else
           Logger.debug("Celluloid::Condition signaled spuriously")
         end
@@ -43,28 +64,11 @@ module Celluloid
     # Broadcast a value to all waiting tasks
     def broadcast(value = nil)
       @mutex.synchronize do
-        raise ConditionError, "no owner for this condition" unless @owner
-
-        @tasks.each { |task| @owner.mailbox << SignalConditionRequest.new(task, value) }
+        @tasks.each { |waiter| waiter << SignalConditionRequest.new(waiter.task, value) }
         @tasks.clear
       end
     end
 
-    # Change the owner of this condition
-    def owner=(actor)
-      @mutex.synchronize do
-        if @owner != actor
-          @tasks.each do |task|
-            ex = ConditionError.new("ownership changed")
-            @owner.mailbox << SignalConditionRequest.new(task, ex)
-          end
-          @tasks.clear
-        end
-
-        @owner = actor
-      end
-    end
-
     alias_method :inspect, :to_s
   end
 end

data/lib/celluloid/future.rb

@@ -4,38 +4,30 @@ module Celluloid
   # Celluloid::Future objects allow methods and blocks to run in the
   # background, their values requested later
   class Future
+    def self.new(*args, &block)
+      return super unless block
+
+      future = new
+      Celluloid.internal_pool.get do
+        Thread.current.role = :future
+        begin
+          call = SyncCall.new(future, :call, args)
+          call.dispatch(block)
+        rescue
+          # Exceptions in blocks will get raised when the value is retrieved
+        end
+      end
+      future
+    end
+
     attr_reader :address
-    
-    # Create a future bound to a given receiver, or with a block to compute
-    def initialize(*args, &block)
+
+    def initialize
       @address = Celluloid.uuid
       @mutex = Mutex.new
       @ready = false
       @result = nil
       @forwards = nil
-
-      if block
-        @call = SyncCall.new(self, :call, args)
-        Celluloid.internal_pool.get do
-          begin
-            @call.dispatch(block)
-          rescue
-            # Exceptions in blocks will get raised when the value is retrieved
-          end
-        end
-      else
-        @call = nil
-      end
-    end
-
-    # Execute the given method in future context
-    def execute(receiver, method, args, block)
-      @mutex.synchronize do
-        raise "already calling" if @call
-        @call = SyncCall.new(self, method, args, block)
-      end
-
-      receiver << @call
     end
 
     # Check if this future has a value yet
@@ -49,7 +41,6 @@ module Celluloid
 
       begin
         @mutex.lock
-        raise "no call requested" unless @call
 
         if @ready
           ready = true

data/lib/celluloid/internal_pool.rb

@@ -42,7 +42,7 @@ module Celluloid
         if @pool.size >= @max_idle
           thread[:celluloid_queue] << nil
         else
-          thread.recycle
+          clean_thread_locals(thread)
           @pool << thread
           @idle_size += 1
           @busy_size -= 1
@@ -69,6 +69,16 @@ module Celluloid
       thread
     end
 
+    # Clean the thread locals of an incoming thread
+    def clean_thread_locals(thread)
+      thread.keys.each do |key|
+        next if key == :celluloid_queue
+
+        # Ruby seems to lack an API for deleting thread locals. WTF, Ruby?
+        thread[key] = nil
+      end
+    end
+
     def shutdown
       @mutex.synchronize do
         @max_idle = 0

data/lib/celluloid/proxies/future_proxy.rb

@@ -17,8 +17,16 @@ module Celluloid
         # FIXME: nicer exception
         raise "Cannot use blocks with futures yet"
       end
+
       future = Future.new
-      future.execute(@mailbox, meth, args, block)
+      call = SyncCall.new(future, meth, args, block)
+
+      begin
+        @mailbox << call
+      rescue MailboxError
+        raise DeadActorError, "attempted to call a dead actor"
+      end
+
       future
     end
   end

data/lib/celluloid/stack_dump.rb

@@ -25,7 +25,7 @@ module Celluloid
     def snapshot
       Thread.list.each do |thread|
         if thread.celluloid?
-          next if thread.task
+          next unless thread.role == :actor
           @actors << snapshot_actor(thread.actor) if thread.actor
         else
           @threads << snapshot_thread(thread)

data/lib/celluloid/system_events.rb

@@ -57,6 +57,7 @@ module Celluloid
     def initialize(task, value)
       @task, @value = task, value
     end
+    attr_reader :task, :value
 
     def call
       @task.resume(@value)

data/lib/celluloid/tasks/task_fiber.rb

@@ -6,6 +6,8 @@ module Celluloid
 
     def create
       @fiber = Fiber.new do
+        # FIXME: cannot use the writer as specs run inside normal Threads
+        Thread.current[:celluloid_role] = :actor
         yield
       end
     end
@@ -30,4 +32,4 @@ module Celluloid
       # If we're getting this the task should already be dead
     end
   end
-end
+end

data/lib/celluloid/tasks/task_thread.rb

@@ -13,6 +13,7 @@ module Celluloid
 
     def create
       @thread = Celluloid.internal_pool.get do
+        Thread.current.role = :task
         begin
           ex = @resume_queue.pop
           raise ex if ex.is_a?(Task::TerminatedError)

data/lib/celluloid/thread.rb

@@ -2,20 +2,19 @@ require 'celluloid/fiber'
 
 module Celluloid
   class Thread < ::Thread
-    # FIXME: these should be replaced using APIs on Celluloid::Thread itself
-    # e.g. Thread.current[:celluloid_actor] => Thread.current.actor
-    CELLULOID_LOCALS = [
-      :celluloid_actor,
-      :celluloid_mailbox,
-      :celluloid_queue,
-      :celluloid_task,
-      :celluloid_chain_id
-    ]
-
     def celluloid?
       true
     end
 
+    # Obtain the role of this thread
+    def role
+      self[:celluloid_role]
+    end
+
+    def role=(role)
+      self[:celluloid_role] = role
+    end
+
     # Obtain the Celluloid::Actor object for this thread
     def actor
       self[:celluloid_actor]
@@ -35,58 +34,5 @@ module Celluloid
     def call_chain_id
       self[:celluloid_chain_id]
     end
-
-    #
-    # Override default thread local behavior, making thread locals actor-local
-    #
-
-    # Obtain an actor-local value
-    def [](key)
-      actor = super(:celluloid_actor)
-      if !actor || CELLULOID_LOCALS.include?(key)
-        super(key)
-      else
-        actor.locals[key]
-      end
-    end
-
-    # Set an actor-local value
-    def []=(key, value)
-      actor = self[:celluloid_actor]
-      if !actor || CELLULOID_LOCALS.include?(key)
-        super(key, value)
-      else
-        actor.locals[key] = value
-      end
-    end
-
-    # Obtain the keys to all actor-locals
-    def keys
-      actor = self[:celluloid_actor]
-      if actor
-        actor.locals.keys
-      else
-        super
-      end
-    end
-
-    # Is the given actor local set?
-    def key?(key)
-      actor = self[:celluloid_actor]
-      if actor
-        actor.locals.has_key?(key)
-      else
-        super
-      end
-    end
-
-    # Clear thread state so it can be reused via thread pools
-    def recycle
-      # This thread local mediates access to the others, so we must clear it first
-      self[:celluloid_actor] = nil
-
-      # Clearing :celluloid_queue would break the thread pool!
-      keys.each { |key| self[key] = nil unless key == :celluloid_queue }
-    end
   end
 end

data/lib/celluloid/thread_handle.rb

@@ -3,11 +3,12 @@ module Celluloid
   # accidentally do things to threads which have been returned to the pool,
   # such as, say, killing them
   class ThreadHandle
-    def initialize
+    def initialize(role = nil)
       @mutex = Mutex.new
       @join  = ConditionVariable.new
 
       @thread = Celluloid.internal_pool.get do
+        Thread.current.role = role
         begin
           yield
         ensure

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.14.0'
+  VERSION = '0.14.1.pre'
   def self.version; VERSION; end
 end

data/spec/support/actor_examples.rb

@@ -323,41 +323,6 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     end
   end
 
-  context "thread locals" do
-    let(:example_class) do
-      Class.new do
-        include included_module
-        task_class task_klass
-
-        def initialize(value)
-          Thread.current[:example_thread_local] = value
-        end
-
-        def value
-          Thread.current[:example_thread_local]
-        end
-
-        def deferred_value
-          defer do
-            Thread.current[:example_thread_local]
-          end
-        end
-      end
-    end
-
-    let(:example_value) { "foobar" }
-
-    it "preserves thread locals between tasks" do
-      actor = example_class.new(example_value)
-      actor.value.should eq example_value
-    end
-
-    it "isolates thread locals in defer blocks" do
-      actor = example_class.new(example_value)
-      actor.deferred_value.should eq nil
-    end
-  end
-
   context :linking do
     before :each do
       @kevin   = actor_class.new "Kevin Bacon" # Some six degrees action here

metadata

@@ -1,83 +1,94 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.14.1.pre
+  prerelease: 7
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-07 00:00:00.000000000 Z
+date: 2013-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: timers
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark_suite
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Celluloid enables people to build concurrent programs out of concurrent
@@ -143,25 +154,26 @@ files:
 homepage: https://github.com/celluloid/celluloid
 licenses:
 - MIT
-metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 1.8.23
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Actor-based concurrent object framework for Ruby
 test_files: []

checksums.yaml

@@ -1,7 +0,0 @@
----
-SHA1:
-  metadata.gz: 14c9f61bd8924c3c5ab4265d3a7ca3d6c43e0fcc
-  data.tar.gz: 65e57a0119a677575a6fbf1663717812f3ca5e1c
-SHA512:
-  metadata.gz: 0f92f13dde36f666893891344073856a4283c402bf259bffa6d076aec33d3c607805ca84373fba854d198b17fe27415eee41283485b7cc4957f715aff00e9f06
-  data.tar.gz: 4b1cd7b742b028163e9a1af68343b5f3489997ced697383ae9e1737d01f0d9b4f16bc3406e8ea22f8c8668533e4a1ca2cb5a3184ce4b0b5cd7481b3e33e0944d