rubinius-actor 0.0.1 → 0.0.2

data/examples/ten_workers.rb

@@ -0,0 +1,41 @@
+require 'rubinius/actor'
+
+Ready = Struct.new(:this)
+Work = Struct.new(:msg)
+
+@supervisor = Rubinius::Actor.spawn do
+  supervisor = Rubinius::Actor.current
+  work_loop = Proc.new do
+    loop do
+      work = Rubinius::Actor.receive
+      puts("Processing: #{work.msg}")
+      supervisor << Ready[Rubinius::Actor.current]
+    end
+  end
+
+  Rubinius::Actor.trap_exit = true
+  ready_workers = []
+  10.times do |x|
+    # start 10 worker actors
+    ready_workers << Rubinius::Actor.spawn_link(&work_loop)
+  end
+  loop do
+    Rubinius::Actor.receive do |f|
+      f.when(Ready) do |who|
+        # SNIP
+      end
+      f.when(Work) do |work|
+        ready_workers.pop << work
+      end
+      f.when(Rubinius::Actor::DeadActorError) do |exit|
+        print "Actor exited with message: #{exit.reason}\n"
+        ready_workers << Rubinius::Actor.spawn_link(&work_loop)
+      end
+    end
+  end
+end
+
+10.times do |idx|
+  @supervisor << Work[idx]
+end
+sleep 1

data/lib/rubinius/actor.rb

@@ -31,395 +31,397 @@
 
 require 'rubinius/core-api'
 
-class Rubinius::Actor
-  class DeadActorError < RuntimeError
-    attr_reader :actor
-    attr_reader :reason
-    def initialize(actor, reason)
-      super(reason)
-      @actor = actor
-      @reason = reason
+module Rubinius
+  class Actor
+    class DeadActorError < RuntimeError
+      attr_reader :actor
+      attr_reader :reason
+      def initialize(actor, reason)
+        super(reason)
+        @actor = actor
+        @reason = reason
+      end
     end
-  end
 
-  ANY = Object.new
-  def ANY.===(other)
-    true
-  end
+    ANY = Object.new
+    def ANY.===(other)
+      true
+    end
 
-  class << self
-    alias_method :private_new, :new
-    private :private_new
+    class << self
+      alias_method :private_new, :new
+      private :private_new
 
-    @@registered_lock = Rubinius::Channel.new
-    @@registered = {}
-    @@registered_lock << nil
+      @@registered_lock = Rubinius::Channel.new
+      @@registered = {}
+      @@registered_lock << nil
   
-    def current
-      Thread.current[:__current_actor__] ||= private_new
-    end
+      def current
+        Thread.current[:__current_actor__] ||= private_new
+      end
 
-    # Spawn a new Actor that will run in its own thread
-    def spawn(*args, &block)
-      raise ArgumentError, "no block given" unless block
-      spawned = Rubinius::Channel.new
-      Thread.new do
-        private_new do |actor|
-          Thread.current[:__current_actor__] = actor
-          spawned << actor
-          block.call *args
+      # Spawn a new Actor that will run in its own thread
+      def spawn(*args, &block)
+        raise ArgumentError, "no block given" unless block
+        spawned = Rubinius::Channel.new
+        Thread.new do
+          private_new do |actor|
+            Thread.current[:__current_actor__] = actor
+            spawned << actor
+            block.call *args
+          end
         end
+        spawned.receive
       end
-      spawned.receive
-    end
-    alias_method :new, :spawn
-
-    # Atomically spawn an actor and link it to the current actor
-    def spawn_link(*args, &block)
-      current = self.current
-      link_complete = Rubinius::Channel.new
-      spawn do
-        begin
-          Actor.link(current)
-        ensure
-          link_complete << Actor.current
+      alias_method :new, :spawn
+
+      # Atomically spawn an actor and link it to the current actor
+      def spawn_link(*args, &block)
+        current = self.current
+        link_complete = Rubinius::Channel.new
+        spawn do
+          begin
+            Actor.link(current)
+          ensure
+            link_complete << Actor.current
+          end
+          block.call *args
         end
-        block.call *args
+        link_complete.receive
       end
-      link_complete.receive
-    end
 
-    # Polls for exit notifications
-    def check_for_interrupt
-      current._check_for_interrupt
-      self
-    end
+      # Polls for exit notifications
+      def check_for_interrupt
+        current._check_for_interrupt
+        self
+      end
 
-    # Waits until a matching message is received in the current actor's
-    # mailbox, and executes the appropriate action.  May be interrupted by
-    # exit notifications.
-    def receive #:yields: filter
-      filter = Filter.new
-      if block_given?
-        yield filter
-      else
-        filter.when(ANY) { |m| m }
+      # Waits until a matching message is received in the current actor's
+      # mailbox, and executes the appropriate action.  May be interrupted by
+      # exit notifications.
+      def receive #:yields: filter
+        filter = Filter.new
+        if block_given?
+          yield filter
+        else
+          filter.when(ANY) { |m| m }
+        end
+        current._receive(filter)
       end
-      current._receive(filter)
-    end
 
-    # Send a "fake" exit notification to another actor, as if the current
-    # actor had exited with +reason+
-    def send_exit(recipient, reason)
-      recipient.notify_exited(current, reason)
-      self
-    end
+      # Send a "fake" exit notification to another actor, as if the current
+      # actor had exited with +reason+
+      def send_exit(recipient, reason)
+        recipient.notify_exited(current, reason)
+        self
+      end
     
-    # Link the current Actor to another one.
-    def link(actor)
-      current = self.current
-      current.notify_link actor
-      actor.notify_link current
-      self
-    end
+      # Link the current Actor to another one.
+      def link(actor)
+        current = self.current
+        current.notify_link actor
+        actor.notify_link current
+        self
+      end
     
-    # Unlink the current Actor from another one
-    def unlink(actor)
-      current = self.current
-      current.notify_unlink actor
-      actor.notify_unlink current
-      self
-    end
-
-    # Actors trapping exit do not die when an error occurs in an Actor they
-    # are linked to.  Instead the exit message is sent to their regular
-    # mailbox in the form [:exit, actor, reason].  This allows certain
-    # Actors to supervise sets of others and restart them in the event
-    # of an error.  Setting the trap flag may be interrupted by pending
-    # exit notifications.
-    #
-    def trap_exit=(value)
-      current._trap_exit = value
-      self
-    end
+      # Unlink the current Actor from another one
+      def unlink(actor)
+        current = self.current
+        current.notify_unlink actor
+        actor.notify_unlink current
+        self
+      end
 
-    # Is the Actor trapping exit?
-    def trap_exit
-      current._trap_exit
-    end
-    alias_method :trap_exit?, :trap_exit
+      # Actors trapping exit do not die when an error occurs in an Actor they
+      # are linked to.  Instead the exit message is sent to their regular
+      # mailbox in the form [:exit, actor, reason].  This allows certain
+      # Actors to supervise sets of others and restart them in the event
+      # of an error.  Setting the trap flag may be interrupted by pending
+      # exit notifications.
+      #
+      def trap_exit=(value)
+        current._trap_exit = value
+        self
+      end
 
-    # Lookup a locally named service
-    def lookup(name)
-      raise ArgumentError, "name must be a symbol" unless Symbol === name
-      @@registered_lock.receive
-      begin
-        @@registered[name]
-      ensure
-        @@registered_lock << nil
+      # Is the Actor trapping exit?
+      def trap_exit
+        current._trap_exit
       end
-    end
-    alias_method :[], :lookup
+      alias_method :trap_exit?, :trap_exit
 
-    # Register an Actor locally as a named service
-    def register(name, actor)
-      raise ArgumentError, "name must be a symbol" unless Symbol === name
-      unless actor.nil? or actor.is_a?(Actor)
-        raise ArgumentError, "only actors may be registered"
+      # Lookup a locally named service
+      def lookup(name)
+        raise ArgumentError, "name must be a symbol" unless Symbol === name
+        @@registered_lock.receive
+        begin
+          @@registered[name]
+        ensure
+          @@registered_lock << nil
+        end
       end
+      alias_method :[], :lookup
 
-      @@registered_lock.receive
-      begin
-        if actor.nil?
-          @@registered.delete(name)
-        else
-          @@registered[name] = actor
+      # Register an Actor locally as a named service
+      def register(name, actor)
+        raise ArgumentError, "name must be a symbol" unless Symbol === name
+        unless actor.nil? or actor.is_a?(Actor)
+          raise ArgumentError, "only actors may be registered"
+        end
+
+        @@registered_lock.receive
+        begin
+          if actor.nil?
+            @@registered.delete(name)
+          else
+            @@registered[name] = actor
+          end
+        ensure
+          @@registered_lock << nil
         end
-      ensure
-        @@registered_lock << nil
       end
-    end
-    alias_method :[]=, :register
+      alias_method :[]=, :register
 
-    def _unregister(actor) #:nodoc:
-      @@registered_lock.receive
-      begin
-        @@registered.delete_if { |n, a| actor.equal? a }
-      ensure
-        @@registered_lock << nil
+      def _unregister(actor) #:nodoc:
+        @@registered_lock.receive
+        begin
+          @@registered.delete_if { |n, a| actor.equal? a }
+        ensure
+          @@registered_lock << nil
+        end
       end
     end
-  end
 
-  def initialize
-    @lock = Rubinius::Channel.new
+    def initialize
+      @lock = Rubinius::Channel.new
 
-    @filter = nil
-    @ready = Rubinius::Channel.new
-    @action = nil
-    @message = nil
+      @filter = nil
+      @ready = Rubinius::Channel.new
+      @action = nil
+      @message = nil
 
-    @mailbox = []
-    @interrupts = []
-    @links = []
-    @alive = true
-    @exit_reason = nil
-    @trap_exit = false
-    @thread = Thread.current
+      @mailbox = []
+      @interrupts = []
+      @links = []
+      @alive = true
+      @exit_reason = nil
+      @trap_exit = false
+      @thread = Thread.current
 
-    @lock << nil
+      @lock << nil
 
-    if block_given?
-      watchdog { yield self }
-    else
-      Thread.new { watchdog { @thread.join } }
+      if block_given?
+        watchdog { yield self }
+      else
+        Thread.new { watchdog { @thread.join } }
+      end
     end
-  end
 
-  def send(message)
-    @lock.receive
-    begin
-      return self unless @alive
-      if @filter
-        @action = @filter.action_for(message)
-        if @action
-          @filter = nil
-          @message = message
-          @ready << nil
+    def send(message)
+      @lock.receive
+      begin
+        return self unless @alive
+        if @filter
+          @action = @filter.action_for(message)
+          if @action
+            @filter = nil
+            @message = message
+            @ready << nil
+          else
+            @mailbox << message
+          end
         else
           @mailbox << message
         end
-      else
-        @mailbox << message
+      ensure
+        @lock << nil
       end
-    ensure
-      @lock << nil
+      self
     end
-    self
-  end
-  alias_method :<<, :send
-
-  def _check_for_interrupt #:nodoc:
-    check_thread
-    @lock.receive
-    begin
-      raise @interrupts.shift unless @interrupts.empty?
-    ensure
-      @lock << nil
+    alias_method :<<, :send
+
+    def _check_for_interrupt #:nodoc:
+      check_thread
+      @lock.receive
+      begin
+        raise @interrupts.shift unless @interrupts.empty?
+      ensure
+        @lock << nil
+      end
     end
-  end
 
-  def _receive(filter) #:nodoc:
-    check_thread
+    def _receive(filter) #:nodoc:
+      check_thread
 
-    action = nil
-    message = nil
-    timed_out = false
+      action = nil
+      message = nil
+      timed_out = false
 
-    @lock.receive
-    begin
-      raise @interrupts.shift unless @interrupts.empty?
+      @lock.receive
+      begin
+        raise @interrupts.shift unless @interrupts.empty?
 
-      for i in 0...(@mailbox.size)
-        message = @mailbox[i]
-        action = filter.action_for(message)
-        if action
-          @mailbox.delete_at(i)
-          break
+        for i in 0...(@mailbox.size)
+          message = @mailbox[i]
+          action = filter.action_for(message)
+          if action
+            @mailbox.delete_at(i)
+            break
+          end
         end
-      end
 
-      unless action
-        @filter = filter
-        @lock << nil
-        begin
-          if filter.timeout?
-            timed_out = @ready.receive_timeout(filter.timeout) == false
-          else
-            @ready.receive
+        unless action
+          @filter = filter
+          @lock << nil
+          begin
+            if filter.timeout?
+              timed_out = @ready.receive_timeout(filter.timeout) == false
+            else
+              @ready.receive
+            end
+          ensure
+            @lock.receive
           end
-        ensure
-          @lock.receive
-        end
 
-        if !timed_out and @interrupts.empty?
-          action = @action
-          message = @message
-        else
-          @mailbox << @message if @action
-        end
+          if !timed_out and @interrupts.empty?
+            action = @action
+            message = @message
+          else
+            @mailbox << @message if @action
+          end
 
-        @action = nil
-        @message = nil
+          @action = nil
+          @message = nil
 
-        raise @interrupts.shift unless @interrupts.empty?
+          raise @interrupts.shift unless @interrupts.empty?
+        end
+      ensure
+        @lock << nil
       end
-    ensure
-      @lock << nil
-    end
 
-    if timed_out
-      filter.timeout_action.call
-    else
-      action.call message
+      if timed_out
+        filter.timeout_action.call
+      else
+        action.call message
+      end
     end
-  end
  
-  # Notify this actor that it's now linked to the given one; this is not
-  # intended to be used directly except by actor implementations.  Most
-  # users will want to use Actor.link instead.
-  #
-  def notify_link(actor)
-    @lock.receive
-    alive = nil
-    exit_reason = nil
-    begin
-      alive = @alive
-      exit_reason = @exit_reason
-      @links << actor if alive and not @links.include? actor
-    ensure
-      @lock << nil
+    # Notify this actor that it's now linked to the given one; this is not
+    # intended to be used directly except by actor implementations.  Most
+    # users will want to use Actor.link instead.
+    #
+    def notify_link(actor)
+      @lock.receive
+      alive = nil
+      exit_reason = nil
+      begin
+        alive = @alive
+        exit_reason = @exit_reason
+        @links << actor if alive and not @links.include? actor
+      ensure
+        @lock << nil
+      end
+      actor.notify_exited(self, exit_reason) unless alive
+      self
     end
-    actor.notify_exited(self, exit_reason) unless alive
-    self
-  end
   
-  # Notify this actor that it's now unlinked from the given one; this is
-  # not intended to be used directly except by actor implementations.  Most
-  # users will want to use Actor.unlink instead.
-  #
-  def notify_unlink(actor)
-    @lock.receive
-    begin
-      return self unless @alive
-      @links.delete(actor)
-    ensure
-      @lock << nil
+    # Notify this actor that it's now unlinked from the given one; this is
+    # not intended to be used directly except by actor implementations.  Most
+    # users will want to use Actor.unlink instead.
+    #
+    def notify_unlink(actor)
+      @lock.receive
+      begin
+        return self unless @alive
+        @links.delete(actor)
+      ensure
+        @lock << nil
+      end
+      self
     end
-    self
-  end
   
-  # Notify this actor that one of the Actors it's linked to has exited;
-  # this is not intended to be used directly except by actor implementations.
-  # Most users will want to use Actor.send_exit instead.
-  #
-  def notify_exited(actor, reason)
-    to_send = nil
-    @lock.receive
-    begin
-      return self unless @alive
-      @links.delete(actor)
-      ex = DeadActorError.new(actor, reason)
-      if @trap_exit
-        to_send = ex
-      elsif reason
-        @interrupts << ex
-        if @filter
-          @filter = nil
-          @ready << nil
+    # Notify this actor that one of the Actors it's linked to has exited;
+    # this is not intended to be used directly except by actor implementations.
+    # Most users will want to use Actor.send_exit instead.
+    #
+    def notify_exited(actor, reason)
+      to_send = nil
+      @lock.receive
+      begin
+        return self unless @alive
+        @links.delete(actor)
+        ex = DeadActorError.new(actor, reason)
+        if @trap_exit
+          to_send = ex
+        elsif reason
+          @interrupts << ex
+          if @filter
+            @filter = nil
+            @ready << nil
+          end
         end
+      ensure
+        @lock << nil
       end
-    ensure
-      @lock << nil
+      send to_send if to_send
+      self
     end
-    send to_send if to_send
-    self
-  end
 
-  def watchdog
-    reason = nil
-    begin
-      yield
-    rescue Exception => reason
-    ensure
-      links = nil
-      Actor._unregister(self)
-      @lock.receive
+    def watchdog
+      reason = nil
       begin
-        @alive = false
-        @mailbox = nil
-        @interrupts = nil
-        @exit_reason = reason
-        links = @links
-        @links = nil
+        yield
+      rescue Exception => reason
       ensure
-        @lock << nil
-      end
-      links.each do |actor|
+        links = nil
+        Actor._unregister(self)
+        @lock.receive
         begin
-          actor.notify_exited(self, reason)
-        rescue Exception
+          @alive = false
+          @mailbox = nil
+          @interrupts = nil
+          @exit_reason = reason
+          links = @links
+          @links = nil
+        ensure
+          @lock << nil
+        end
+        links.each do |actor|
+          begin
+            actor.notify_exited(self, reason)
+          rescue Exception
+          end
         end
       end
     end
-  end
-  private :watchdog
+    private :watchdog
 
-  def check_thread
-    unless Thread.current == @thread
-      raise ThreadError, "illegal cross-actor call"
+    def check_thread
+      unless Thread.current == @thread
+        raise ThreadError, "illegal cross-actor call"
+      end
     end
-  end
-  private :check_thread
+    private :check_thread
   
-  def _trap_exit=(value) #:nodoc:
-    check_thread
-    @lock.receive
-    begin
-      raise @interrupts.shift unless @interrupts.empty?
-      @trap_exit = !!value
-    ensure
-      @lock << nil
+    def _trap_exit=(value) #:nodoc:
+      check_thread
+      @lock.receive
+      begin
+        raise @interrupts.shift unless @interrupts.empty?
+        @trap_exit = !!value
+      ensure
+        @lock << nil
+      end
     end
-  end
   
-  def _trap_exit #:nodoc:
-    check_thread
-    @lock.receive
-    begin
-      @trap_exit
-    ensure
-      @lock << nil
+    def _trap_exit #:nodoc:
+      check_thread
+      @lock.receive
+      begin
+        @trap_exit
+      ensure
+        @lock << nil
+      end
     end
   end
 end

data/rubinius-actor.gemspec

@@ -2,12 +2,12 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rubinius-actor}
-  s.version = "0.0.1"
+  s.version = "0.0.2"
   s.authors = ["Evan Phoenix", "MenTaLguY"]
   s.date = Time.now
   s.description = "Rubinius's Actor implementation"
   s.email = ["evan@fallingsnow.net", "mental@rydia.net"]
-  s.files = Dir['{lib}/**/*'] + Dir['{*.txt,*.gemspec,Rakefile}']
+  s.files = Dir['{lib,examples}/**/*'] + Dir['{*.txt,*.gemspec,Rakefile}']
   s.homepage = "http://github.com/rubinius/rubinius-actor"
   s.require_paths = ["lib"]
   s.summary = "Rubinius's Actor implementation"

metadata

@@ -1,41 +1,34 @@
 --- !ruby/object:Gem::Specification 
 name: rubinius-actor
 version: !ruby/object:Gem::Version 
-  hash: 29
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
-- Evan Phoenix
-- MenTaLguY
+  - Evan Phoenix
+  - MenTaLguY
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-06-16 00:00:00 Z
+date: 2011-06-16 00:00:00 -05:00
+default_executable: 
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rubinius-core-api
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: rubinius-core-api
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :runtime
+    version_requirements: *id001
 description: Rubinius's Actor implementation
 email: 
-- evan@fallingsnow.net
-- mental@rydia.net
+  - evan@fallingsnow.net
+  - mental@rydia.net
 executables: []
 
 extensions: []
@@ -43,10 +36,12 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/rubinius/actor/filter.rb
-- lib/rubinius/actor.rb
-- README.txt
-- rubinius-actor.gemspec
+  - lib/rubinius/actor.rb
+  - lib/rubinius/actor/filter.rb
+  - examples/ten_workers.rb
+  - README.txt
+  - rubinius-actor.gemspec
+has_rdoc: true
 homepage: http://github.com/rubinius/rubinius-actor
 licenses: []
 
@@ -54,29 +49,23 @@ post_install_message:
 rdoc_options: []
 
 require_paths: 
-- lib
+  - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.5
+rubygems_version: 1.5.1
 signing_key: 
 specification_version: 3
 summary: Rubinius's Actor implementation