kulesa-celluloid 0.10.2

data/README.md

@@ -0,0 +1,116 @@
+![Celluloid](https://github.com/celluloid/celluloid/raw/master/logo.png)
+=========
+[![Build Status](https://secure.travis-ci.org/celluloid/celluloid.png?branch=master)](http://travis-ci.org/celluloid/celluloid)
+[![Dependency Status](https://gemnasium.com/celluloid/celluloid.png)](https://gemnasium.com/celluloid/celluloid)
+
+> "I thought of objects being like biological cells and/or individual
+> computers on a network, only able to communicate with messages"
+> _--Alan Kay, creator of Smalltalk, on the meaning of "object oriented programming"_
+
+Celluloid provides a simple and natural way to build fault-tolerant concurrent
+programs in Ruby. With Celluloid, you can build systems out of concurrent
+objects just as easily as you build sequential programs out of regular objects.
+Recommended for any developer, including novices, Celluloid should help ease
+your worries about building multithreaded Ruby programs.
+
+Much of the difficulty with building concurrent programs in Ruby arises because
+the object-oriented mechanisms for structuring code, such as classes and
+inheritance, are separate from the concurrency mechanisms, such as threads and
+locks. Celluloid combines these into a single structure, an active object
+running within a thread, called an "actor".
+
+By combining concurrency with object oriented programming, Celluloid frees you
+up from worry about where to use threads and locks. Celluloid combines them
+together into a single concurrent object oriented programming model,
+encapsulating state in concurrent objects and thus avoiding many of the
+problems associated with multithreaded programming. Celluloid provides many
+features which make concurrent programming simple, easy, and fun:
+
+* __Automatic "deadlock-free" synchronization:__ Celluloid uses a concurrent
+  object model which combines method dispatch and thread synchronization.
+  Each actor is a concurrent object running in its own thread, and every method
+  invocation is wrapped in a fiber that can be suspended whenever it calls
+  out to other actors, and resumed when the response is available. This means
+  methods which are waiting for responses from other actors, external messages,
+  or other system events (including I/O with Celluloid::IO) can be suspended
+  and will never block other methods that are ready to run. This won't prevent
+  bugs in Celluloid, bugs in other thread-safe libraries you use, and even
+  certain "dangerous" features of Celluloid from causing your program to
+  deadlock, but in general, programs built with Celluloid will be naturally
+  immune to deadlocks.
+
+* __Fault-tolerance:__ Celluloid has taken to heart many of Erlang's ideas
+  about fault-tolerance in order to enable self-healing applications.
+  The central idea: have you tried turning it off and on again? Celluloid
+  takes care of rebooting subcomponents of your application when they crash,
+  whether it's a single actor, or large (potentially multi-tiered) groups of
+  actors that are all interdependent. This means rather that worrying about
+  rescuing every last exception, you can just sit back, relax, and let parts
+  of your program crash, knowing Celluloid will automatically reboot them in
+  a clean state. Celluloid provides its own implementation of the core
+  fault-tolerance concepts in Erlang including [linking](https://github.com/celluloid/celluloid/wiki/Linking),
+  [supervisors](https://github.com/celluloid/celluloid/wiki/Supervisors),
+  and [supervision trees](https://github.com/celluloid/celluloid/wiki/Groups).
+
+* __[Futures](https://github.com/celluloid/celluloid/wiki/futures):__
+  Ever wanted to call a method "in the background" and retrieve the
+  value it returns later? Celluloid futures do just that. It's like
+  calling ahead to a restaurant to place an order, so they can work
+  on preparing your food while you're on your way to pick it up.
+  When you ask for a method's return value, it's returned immediately
+  if the method has already completed, or otherwise the current method is
+  suspended until the value becomes available.
+
+You can also build distributed systems with Celluloid using its
+[sister project DCell](https://github.com/celluloid/dcell). Evented IO similar
+to EventMachine (with a synchronous API) is available through the
+[Celluloid::IO](https://github.com/celluloid/celluloid-io) library.
+
+[Please see the Celluloid Wiki](https://github.com/celluloid/celluloid/wiki)
+for more detailed documentation and usage notes.
+
+Like Celluloid? [Join the Google Group](http://groups.google.com/group/celluloid-ruby)
+or visit us on IRC at #celluloid on freenode
+
+### Is it any good?
+
+[Yes.](http://news.ycombinator.com/item?id=3067434)
+
+### Is It "Production Ready™"?
+
+Yes, many users are now running Celluloid in production by using
+[Sidekiq](https://github.com/mperham/sidekiq)
+
+Supported Platforms
+-------------------
+
+Celluloid works on Ruby 1.9.3, JRuby 1.6, and Rubinius 2.0. JRuby or Rubinius
+are the preferred platforms as they support true thread-level parallelism when
+executing Ruby code, whereas MRI/YARV is constrained by a global interpreter
+lock (GIL) and can only execute one thread at a time.
+
+Celluloid requires Ruby 1.9 mode on all interpreters. This works out of the
+box on MRI/YARV, and requires the following flags elsewhere:
+
+* JRuby: --1.9 command line option, or JRUBY_OPTS=--1.9 environment variable
+* rbx: -X19 command line option
+
+Additional Reading
+------------------
+
+* [Concurrent Object-Oriented Programming in Python with ATOM](http://python.org/workshops/1997-10/proceedings/atom/):
+  a similar system to Celluloid written in Python
+
+Contributing to Celluloid
+-------------------------
+
+* Fork this repository on github
+* Make your changes and send me a pull request
+* If I like them I'll merge them
+* If I've accepted a patch, feel free to ask for commit access
+
+License
+-------
+
+Copyright (c) 2012 Tony Arcieri. Distributed under the MIT License. See
+LICENSE.txt for further details.

data/lib/celluloid/actor.rb

@@ -0,0 +1,279 @@
+module Celluloid
+  # Don't do Actor-like things outside Actor scope
+  class NotActorError < StandardError; end
+
+  # Trying to do something to a dead actor
+  class DeadActorError < StandardError; end
+
+  # The caller made an error, not the current actor
+  class AbortError < StandardError
+    attr_reader :cause
+
+    def initialize(cause)
+      @cause = cause
+      super "caused by #{cause.inspect}: #{cause.to_s}"
+    end
+  end
+
+  # Actors are Celluloid's concurrency primitive. They're implemented as
+  # normal Ruby objects wrapped in threads which communicate with asynchronous
+  # messages.
+  class Actor
+    extend Registry
+    attr_reader :subject, :proxy, :tasks, :links, :mailbox, :thread, :name
+
+    class << self
+      # Obtain the current actor
+      def current
+        actor = Thread.current[:actor]
+        raise NotActorError, "not in actor scope" unless actor
+        actor.proxy
+      end
+      
+      # Obtain the name of the current actor
+      def name
+        actor = Thread.current[:actor]
+        raise NotActorError, "not in actor scope" unless actor
+        actor.name
+      end
+      
+      # Invoke a method on the given actor via its mailbox
+      def call(mailbox, meth, *args, &block)
+        call = SyncCall.new(Thread.mailbox, meth, args, block)
+
+        begin
+          mailbox << call
+        rescue MailboxError
+          raise DeadActorError, "attempted to call a dead actor"
+        end
+
+        if Celluloid.actor? and not Celluloid.exclusive?
+          # The current task will be automatically resumed when we get a response
+          Task.suspend(:callwait).value
+        else
+          # Otherwise we're inside a normal thread, so block
+          response = Thread.mailbox.receive do |msg|
+            msg.respond_to?(:call) and msg.call == call
+          end
+
+          response.value
+        end
+      end
+
+      # Invoke a method asynchronously on an actor via its mailbox
+      def async(mailbox, meth, *args, &block)
+        begin
+          mailbox << AsyncCall.new(Thread.mailbox, meth, args, block)
+        rescue MailboxError
+          # Silently swallow asynchronous calls to dead actors. There's no way
+          # to reliably generate DeadActorErrors for async calls, so users of
+          # async calls should find other ways to deal with actors dying
+          # during an async call (i.e. linking/supervisors)
+        end
+      end
+
+      # Call a method asynchronously and retrieve its value later
+      def future(mailbox, meth, *args, &block)
+        future = Future.new
+        future.execute(mailbox, meth, args, block)
+        future
+      end
+
+      # Obtain all running actors in the system
+      def all
+        actors = []
+        Thread.list.each do |t|
+          actor = t[:actor]
+          actors << actor.proxy if actor
+        end
+        actors
+      end
+    end
+
+    # Wrap the given subject with an Actor
+    def initialize(subject)
+      @subject   = subject
+      @mailbox   = subject.class.mailbox_factory
+      @tasks     = Set.new
+      @links     = Links.new
+      @signals   = Signals.new
+      @receivers = Receivers.new
+      @timers    = Timers.new
+      @running   = true
+      @exclusive = false
+      @name      = nil
+
+      @thread = ThreadHandle.new do
+        Thread.current[:actor]   = self
+        Thread.current[:mailbox] = @mailbox
+        run
+      end
+      
+      @proxy = ActorProxy.new(self)
+    end
+
+    # Is this actor running in exclusive mode?
+    def exclusive?
+      @exclusive
+    end
+
+    # Execute a code block in exclusive mode.
+    def exclusive
+      @exclusive = true
+      yield
+    ensure
+      @exclusive = false
+    end
+
+    # Terminate this actor
+    def terminate
+      @running = false
+    end
+
+    # Send a signal with the given name to all waiting methods
+    def signal(name, value = nil)
+      @signals.send name, value
+    end
+
+    # Wait for the given signal
+    def wait(name)
+      @signals.wait name
+    end
+
+    # Receive an asynchronous message
+    def receive(timeout = nil, &block)
+      @receivers.receive(timeout, &block)
+    end
+
+    # Run the actor loop
+    def run
+      begin
+        while @running
+          begin
+            message = @mailbox.receive(timeout)
+          rescue ExitEvent => exit_event
+            Task.new(:exit_handler) { handle_exit_event exit_event }.resume
+            retry
+          rescue NamingRequest => ex
+            @name = ex.name
+            retry
+          rescue TerminationRequest
+            break
+          end
+
+          if message
+            handle_message message
+          else
+            # No message indicates a timeout
+            @timers.fire
+            @receivers.fire_timers
+          end
+        end
+      rescue MailboxShutdown
+        # If the mailbox detects shutdown, exit the actor
+      end
+
+      shutdown
+    rescue Exception => ex
+      handle_crash(ex)
+      raise unless ex.is_a? StandardError
+    end
+
+    # How long to wait until the next timer fires
+    def timeout
+      i1 = @timers.wait_interval
+      i2 = @receivers.wait_interval
+
+      if i1 and i2
+        i1 < i2 ? i1 : i2
+      elsif i1
+        i1
+      else
+        i2
+      end
+    end
+
+    # Schedule a block to run at the given time
+    def after(interval)
+      @timers.add(interval) do
+        Task.new(:timer) { yield }.resume
+      end
+    end
+
+    # Schedule a block to run at the given time
+    def every(interval)
+      @timers.add(interval, true) do
+        Task.new(:timer) { yield }.resume
+      end
+    end
+
+    # Sleep for the given amount of time
+    def sleep(interval)
+      if Celluloid.exclusive?
+        Kernel.sleep(interval)
+      else
+        task = Task.current
+        @timers.add(interval) { task.resume }
+        Task.suspend :sleeping
+      end
+    end
+
+    # Handle an incoming message
+    def handle_message(message)
+      case message
+      when Call
+        Task.new(:message_handler) { message.dispatch(@subject) }.resume
+      when Response
+        message.call.task.resume message
+      else
+        @receivers.handle_message(message)
+      end
+      message
+    end
+
+    # Handle exit events received by this actor
+    def handle_exit_event(exit_event)
+      exit_handler = @subject.class.exit_handler
+      if exit_handler
+        return @subject.send(exit_handler, exit_event.actor, exit_event.reason)
+      end
+
+      # Reraise exceptions from linked actors
+      # If no reason is given, actor terminated cleanly
+      raise exit_event.reason if exit_event.reason
+    end
+
+    # Handle any exceptions that occur within a running actor
+    def handle_crash(exception)
+      Logger.crash("#{@subject.class} crashed!", exception)
+      shutdown ExitEvent.new(@proxy, exception)
+    rescue => ex
+      Logger.crash("#{@subject.class}: ERROR HANDLER CRASHED!", ex)
+    end
+
+    # Handle cleaning up this actor after it exits
+    def shutdown(exit_event = ExitEvent.new(@proxy))
+      run_finalizer
+      cleanup exit_event
+    ensure
+      Thread.current[:actor]   = nil
+      Thread.current[:mailbox] = nil
+    end
+
+    # Run the user-defined finalizer, if one is set
+    def run_finalizer
+      @subject.finalize if @subject.respond_to? :finalize
+    rescue => ex
+      Logger.crash("#{@subject.class}#finalize crashed!", ex)
+    end
+
+    # Clean up after this actor
+    def cleanup(exit_event)
+      @mailbox.shutdown
+      @links.send_event exit_event
+      tasks.each { |task| task.terminate }
+    rescue => ex
+      Logger.crash("#{@subject.class}: CLEANUP CRASHED!", ex)
+    end
+  end
+end

data/lib/celluloid/actor_proxy.rb

@@ -0,0 +1,95 @@
+module Celluloid
+  # A proxy object returned from Celluloid::Actor.spawn/spawn_link which
+  # dispatches calls and casts to normal Ruby objects which are running inside
+  # of their own threads.
+  class ActorProxy
+    attr_reader :mailbox
+
+    def initialize(actor)
+      @mailbox, @thread, @klass = actor.mailbox, actor.thread, actor.subject.class.to_s
+      
+      # Cache "unbanged" versions of methods, e.g. :foobar! => :foobar
+      @unbanged_methods = {}
+    end
+
+    def _send_(meth, *args, &block)
+      Actor.call @mailbox, :__send__, meth, *args, &block
+    end
+
+    def class
+      Actor.call @mailbox, :__send__, :class
+    end
+
+    def name
+      Actor.call @mailbox, :name
+    end
+
+    def is_a?(klass)
+      Actor.call @mailbox, :is_a?, klass
+    end
+
+    def kind_of?(klass)
+      Actor.call @mailbox, :kind_of?, klass
+    end
+
+    def respond_to?(meth)
+      Actor.call @mailbox, :respond_to?, meth
+    end
+
+    def methods(include_ancestors = true)
+      Actor.call @mailbox, :methods, include_ancestors
+    end
+
+    def alive?
+      @mailbox.alive?
+    end
+
+    def to_s
+      Actor.call @mailbox, :to_s
+    end
+
+    def inspect
+      Actor.call @mailbox, :inspect
+    rescue DeadActorError
+      "#<Celluloid::Actor(#{@klass}) dead>"
+    end
+    
+    # Make an asynchronous call to an actor, for those who don't like the
+    # predicate syntax. TIMTOWTDI!
+    def async(method_name, *args, &block)
+      Actor.async @mailbox, method_name, *args, &block
+    end
+
+    # Create a Celluloid::Future which calls a given method
+    def future(method_name, *args, &block)
+      Actor.future @mailbox, method_name, *args, &block
+    end
+
+    # Terminate the associated actor
+    def terminate
+      terminate!
+      Thread.pass while alive?
+    end
+
+    # Terminate the associated actor asynchronously
+    def terminate!
+      raise DeadActorError, "actor already terminated" unless alive?
+      @mailbox.system_event TerminationRequest.new
+    end
+
+    # method_missing black magic to call bang predicate methods asynchronously
+    def method_missing(meth, *args, &block)
+      # bang methods are async calls
+      if meth.match(/!$/)
+        # This operation is idempotent and therefore thread-safe
+        # The worst case is that the string transformation on the right will
+        # run multiple times and make a little more work for the GC
+        meth = @unbanged_methods[meth] ||= meth.to_s.sub(/!$/, '').to_sym
+        
+        Actor.async @mailbox, meth, *args, &block
+      else
+        Actor.call  @mailbox, meth, *args, &block
+      end
+    end
+  end
+end

data/lib/celluloid/calls.rb

@@ -0,0 +1,105 @@
+module Celluloid
+  # Calls represent requests to an actor
+  class Call
+    attr_reader :caller, :method, :arguments, :block
+
+    def initialize(caller, method, arguments = [], block = nil)
+      @caller, @method, @arguments, @block = caller, method, arguments, block
+    end
+
+    def check_signature(obj)
+      unless obj.respond_to? @method
+        raise NoMethodError, "undefined method `#{@method}' for #{obj.inspect}"
+      end
+
+      begin
+        arity = obj.method(@method).arity
+      rescue NameError
+        # If the object claims it responds to a method, but it doesn't exist,
+        # then we have to assume method_missing will do what it says
+        @arguments.unshift(@method)
+        @method = :method_missing
+        return
+      end
+
+      if arity >= 0
+        if arguments.size != arity
+          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{arity})"
+        end
+      elsif arity < -1
+        mandatory_args = -arity - 1
+        if arguments.size < mandatory_args
+          raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{mandatory_args})"
+        end
+      end
+    end
+  end
+
+  # Synchronous calls wait for a response
+  class SyncCall < Call
+    attr_reader :task
+
+    def initialize(caller, method, arguments = [], block = nil, task = Fiber.current.task)
+      super(caller, method, arguments, block)
+      @task = task
+    end
+
+    def dispatch(obj)
+      begin
+        check_signature(obj)
+      rescue => ex
+        respond ErrorResponse.new(self, AbortError.new(ex))
+        return
+      end
+
+      begin
+        result = obj.send @method, *@arguments, &@block
+      rescue Exception => exception
+        # Exceptions that occur during synchronous calls are reraised in the
+        # context of the caller
+        respond ErrorResponse.new(self, exception)
+
+        if exception.is_a? AbortError
+          # Aborting indicates a protocol error on the part of the caller
+          # It should crash the caller, but the exception isn't reraised
+          return
+        else
+          # Otherwise, it's a bug in this actor and should be reraised
+          raise exception
+        end
+      end
+
+      respond SuccessResponse.new(self, result)
+    end
+
+    def cleanup
+      exception = DeadActorError.new("attempted to call a dead actor")
+      respond ErrorResponse.new(self, exception)
+    end
+
+    def respond(message)
+      @caller << message
+    rescue MailboxError
+      # It's possible the caller exited or crashed before we could send a
+      # response to them.
+    end
+  end
+
+  # Asynchronous calls don't wait for a response
+  class AsyncCall < Call
+    def dispatch(obj)
+      begin
+        check_signature(obj)
+      rescue Exception => ex
+        Logger.crash("#{obj.class}: async call `#{@method}' failed!", ex)
+        return
+      end
+
+      obj.send(@method, *@arguments, &@block)
+    rescue AbortError => ex
+      # Swallow aborted async calls, as they indicate the caller made a mistake
+      Logger.crash("#{obj.class}: async call `#{@method}' aborted!", ex)
+    end
+  end
+end
+

data/lib/celluloid/core_ext.rb

@@ -0,0 +1,25 @@
+require 'celluloid/fiber'
+
+# Monkeypatch Thread to allow lazy access to its Celluloid::Mailbox
+class Thread
+  attr_accessor :uuid_counter, :uuid_limit
+
+  # Retrieve the mailbox for the current thread or lazily initialize it
+  def self.mailbox
+    current[:mailbox] ||= Celluloid::Mailbox.new
+  end
+
+  # Receive a message either as an actor or through the local mailbox
+  def self.receive(timeout = nil, &block)
+    if Celluloid.actor?
+      Celluloid.receive(timeout, &block)
+    else
+      mailbox.receive(timeout, &block)
+    end
+  end
+end
+
+class Fiber
+  # Celluloid::Task associated with this Fiber
+  attr_accessor :task
+end

data/lib/celluloid/cpu_counter.rb

@@ -0,0 +1,16 @@
+require 'rbconfig'
+
+module Celluloid
+  module CPUCounter
+    case RbConfig::CONFIG['host_os'][/^[A-Za-z]+/]
+    when 'darwin'
+      @cores = Integer(`sysctl hw.ncpu`[/\d+/])
+    when 'linux'
+      @cores = File.read("/proc/cpuinfo").scan(/core id\s+: \d+/).uniq.size
+    else
+      @cores = nil
+    end
+
+    def self.cores; @cores; end
+  end
+end

data/lib/celluloid/events.rb

@@ -0,0 +1,26 @@
+module Celluloid
+  # Exceptional system events which need to be processed out of band
+  class SystemEvent < Exception; end
+  
+  # An actor has exited for the given reason
+  class ExitEvent < SystemEvent
+    attr_reader :actor, :reason
+    
+    def initialize(actor, reason = nil)
+      @actor, @reason = actor, reason
+      super reason.to_s
+    end
+  end
+  
+  # Name an actor at the time it's registered
+  class NamingRequest < SystemEvent
+    attr_reader :name
+    
+    def initialize(name)
+      @name = name
+    end
+  end
+  
+  # Request for an actor to terminate
+  class TerminationRequest < SystemEvent; end
+end

data/lib/celluloid/fiber.rb

@@ -0,0 +1,32 @@
+# Fibers are hard... let's go shopping!
+begin
+  require 'fiber'
+rescue LoadError => ex
+  if defined? JRUBY_VERSION
+    if RUBY_VERSION < "1.9.2"
+      raise LoadError, "Celluloid requires JRuby 1.9 mode. Please pass the --1.9 flag or set JRUBY_OPTS=--1.9"
+    end
+
+    # Fibers are broken on JRuby 1.6.5. This works around the issue
+    if JRUBY_VERSION[/^1\.6\.5/]
+      require 'jruby'
+      org.jruby.ext.fiber.FiberExtLibrary.new.load(JRuby.runtime, false)
+      class org::jruby::ext::fiber::ThreadFiber
+        field_accessor :state
+      end
+
+      class Fiber
+        def alive?
+          JRuby.reference(self).state != org.jruby.ext.fiber.ThreadFiberState::FINISHED
+        end
+      end
+    else
+      # Just in case subsequent JRuby releases have broken fibers :/
+      raise ex
+    end
+  elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx"
+    raise LoadError, "Celluloid requires Rubinius 1.9 mode. Please pass the -X19 flag."
+  else
+    raise ex
+  end
+end