kulesa-celluloid 0.10.2

data/lib/celluloid/pool.rb

@@ -0,0 +1,105 @@
+module Celluloid
+  # DEPRECATED: please use Celluloid::Worker instead
+  class Pool
+    include Celluloid
+    trap_exit :crash_handler
+    attr_reader :max_actors
+
+    # Takes a class of actor to pool and a hash of options:
+    #
+    # * initial_size: how many actors to eagerly create
+    # * max_size: maximum number of actors (default one actor per CPU core)
+    # * args: an array of arguments to pass to the actor's initialize
+    def initialize(klass, options = {})
+      raise ArgumentError, "A Pool has a minimum size of 2" if options[:max_size] && options[:max_size] < 2
+      opts = {
+        :initial_size => 1,
+        :max_size     => [Celluloid.cores, 2].max,
+        :args         => []
+      }.merge(options)
+
+      @klass, @args = klass, opts[:args]
+      @max_actors = opts[:max_size]
+      @idle_actors, @running_actors = 0, 0
+      @actors = []
+
+      opts[:initial_size].times do
+        @actors << spawn
+        @idle_actors += 1
+      end
+    end
+
+    # Get an actor from the pool. Actors taken from the pool must be put back
+    # with Pool#put. Alternatively, you can use get with a block form:
+    #
+    #     pool.get { |actor| ... }
+    #
+    # This will automatically return actors to the pool when the block completes
+    def get
+      if @max_actors and @running_actors == @max_actors
+        wait :ready
+      end
+
+      actor = @actors.shift
+      if actor
+        @idle_actors -= 1
+      else
+        actor = spawn
+      end
+
+      if block_given?
+        begin
+          yield actor
+        rescue => ex
+        end
+
+        put actor
+        abort ex if ex
+        nil
+      else
+        actor
+      end
+    end
+
+    # Return an actor to the pool
+    def put(actor)
+      begin
+        raise TypeError, "expecting a #{@klass} actor" unless actor.is_a? @klass
+      rescue DeadActorError
+        # The actor may have died before it was handed back to us
+        # We'll let the crash_handler deal with it in due time
+        return
+      end
+
+      @actors << actor
+      @idle_actors += 1
+    end
+
+    # Number of active actors in this pool
+    def size
+      @running_actors
+    end
+
+    # Number of idle actors in the pool
+    def idle_count
+      @idle_actors
+    end
+    alias_method :idle_size, :idle_count
+
+    # Handle crashed actors
+    def crash_handler(actor, reason)
+      @idle_actors    -= 1 if @actors.delete actor
+      @running_actors -= 1
+
+      # If we were maxed out before...
+      signal :ready if @max_actors and @running_actors + 1 == @max_actors
+    end
+
+    # Spawn an actor of the given class
+    def spawn
+      worker = @klass.new_link(*@args)
+      @running_actors += 1
+      worker
+    end
+  end
+end

data/lib/celluloid/receivers.rb

@@ -0,0 +1,70 @@
+require 'set'
+
+module Celluloid
+  # Allow methods to directly interact with the actor protocol
+  class Receivers
+    def initialize
+      @receivers = Set.new
+      @timers = Timers.new
+    end
+
+    # Receive an asynchronous message
+    def receive(timeout = nil, &block)
+      if Celluloid.exclusive?
+        Thread.mailbox.receive(timeout, &block)
+      else
+        receiver = Receiver.new block
+
+        if timeout
+          receiver.timer = @timers.add(timeout) do
+            @receivers.delete receiver
+            receiver.resume
+          end
+        end
+
+        @receivers << receiver
+        Task.suspend :receiving
+      end
+    end
+
+    # How long to wait until the next timer fires
+    def wait_interval
+      @timers.wait_interval
+    end
+
+    # Fire any pending timers
+    def fire_timers
+      @timers.fire
+    end
+
+    # Handle incoming messages
+    def handle_message(message)
+      receiver = @receivers.find { |r| r.match(message) }
+      return unless receiver
+
+      @receivers.delete receiver
+      @timers.cancel receiver.timer if receiver.timer
+      receiver.resume message
+    end
+  end
+
+  # Methods blocking on a call to receive
+  class Receiver
+    attr_accessor :timer
+
+    def initialize(block)
+      @block = block
+      @task  = Task.current
+      @timer = nil
+    end
+
+    # Match a message with this receiver's block
+    def match(message)
+      @block ? @block.call(message) : true
+    end
+
+    def resume(message = nil)
+      @task.resume message
+    end
+  end
+end

data/lib/celluloid/registry.rb

@@ -0,0 +1,35 @@
+require 'thread'
+
+module Celluloid
+  # The Registry allows us to refer to specific actors by human-meaningful names
+  module Registry
+    @@registry = {}
+    @@registry_lock = Mutex.new
+
+    # Register an Actor
+    def []=(name, actor)
+      actor_singleton = class << actor; self; end
+      unless actor_singleton.ancestors.include? ActorProxy
+        raise TypeError, "not an actor"
+      end
+
+      @@registry_lock.synchronize do
+        @@registry[name.to_sym] = actor
+      end
+      
+      actor.mailbox.system_event NamingRequest.new(name.to_sym)
+    end
+
+    # Retrieve an actor by name
+    def [](name)
+      @@registry_lock.synchronize do
+        @@registry[name.to_sym]
+      end
+    end
+
+    # List all registered actors by name
+    def registered
+      @@registry_lock.synchronize { @@registry.keys }
+    end
+  end
+end

data/lib/celluloid/responses.rb

@@ -0,0 +1,26 @@
+module Celluloid
+  # Responses to calls
+  class Response
+    attr_reader :call, :value
+
+    def initialize(call, value)
+      @call, @value = call, value
+    end
+  end
+
+  # Call completed successfully
+  class SuccessResponse < Response; end
+
+  # Call was aborted due to caller error
+  class ErrorResponse < Response
+    def value
+      if super.is_a? AbortError
+        # Aborts are caused by caller error, so ensure they capture the
+        # caller's backtrace instead of the receiver's
+        raise super.cause.exception
+      else
+        raise super
+      end
+    end
+  end
+end

data/lib/celluloid/rspec.rb

@@ -0,0 +1,2 @@
+require File.expand_path('../../../spec/support/actor_examples', __FILE__)
+require File.expand_path('../../../spec/support/mailbox_examples', __FILE__)

data/lib/celluloid/signals.rb

@@ -0,0 +1,51 @@
+module Celluloid
+  # Event signaling between methods of the same object
+  class Signals
+    attr_reader :waiting
+
+    def initialize
+      @waiting = {}
+    end
+
+    # Wait for the given signal and return the associated value
+    def wait(signal)
+      raise "cannot wait for signals while exclusive" if Celluloid.exclusive?
+
+      tasks = @waiting[signal]
+      case tasks
+      when Array
+        tasks << Task.current
+      when NilClass
+        @waiting[signal] = Task.current
+      else
+        @waiting[signal] = [tasks, Task.current]
+      end
+
+      Task.suspend :sigwait
+    end
+
+    # Send a signal to all method calls waiting for the given name
+    # Returns true if any calls were signaled, or false otherwise
+    def send(name, value = nil)
+      tasks = @waiting.delete name
+
+      case tasks
+      when Array
+        tasks.each { |task| run_task task, value }
+        true if tasks.size > 0
+      when NilClass
+        false
+      else
+        run_task tasks, value
+        true
+      end
+    end
+
+    # Run the given task, reporting errors that occur
+    def run_task(task, value)
+      task.resume(value)
+    rescue => ex
+      Logger.crash("signaling error", ex)
+    end
+  end
+end

data/lib/celluloid/supervisor.rb

@@ -0,0 +1,69 @@
+module Celluloid
+  # Supervisors are actors that watch over other actors and restart them if
+  # they crash
+  class Supervisor
+    include Celluloid
+    trap_exit :restart_actor
+
+    # Retrieve the actor this supervisor is supervising
+    attr_reader :actor
+
+    class << self
+      # Define the root of the supervision tree
+      attr_accessor :root
+
+      def supervise(klass, *args, &block)
+        new(nil, klass, *args, &block)
+      end
+
+      def supervise_as(name, klass, *args, &block)
+        new(name, klass, *args, &block)
+      end
+    end
+
+    def initialize(name, klass, *args, &block)
+      @name, @klass, @args, @block = name, klass, args, block
+      @started = false
+
+      start_actor
+    end
+
+    def finalize
+      @actor.terminate if @actor and @actor.alive?
+    end
+
+    def start_actor(start_attempts = 3, sleep_interval = 30)
+      failures = 0
+
+      begin
+        @actor = @klass.new_link(*@args, &@block)
+      rescue
+        failures += 1
+        if failures >= start_attempts
+          failures = 0
+
+          Logger.warn("#{@klass} is crashing on initialize too quickly, sleeping for #{sleep_interval} seconds")
+          sleep sleep_interval
+        end
+        retry
+      end
+
+      @started = true
+      Actor[@name] = @actor if @name
+    end
+
+    # When actors die, regardless of the reason, restart them
+    def restart_actor(actor, reason)
+      # If the actor we're supervising exited cleanly, exit the supervisor cleanly too
+      terminate unless reason
+
+      start_actor if @started
+    end
+
+    def inspect
+      str = "#<#{self.class}(#{@klass}):0x#{object_id.to_s(16)}"
+      str << " " << @args.map { |arg| arg.inspect }.join(' ') unless @args.empty?
+      str << ">"
+    end
+  end
+end

data/lib/celluloid/task.rb

@@ -0,0 +1,81 @@
+module Celluloid
+  # Trying to resume a dead task
+  class DeadTaskError < StandardError; end
+
+  # Tasks are interruptable/resumable execution contexts used to run methods
+  class Task
+    class TerminatedError < StandardError; end # kill a running fiber
+
+    attr_reader   :type
+    attr_accessor :status
+
+    # Obtain the current task
+    def self.current
+      Fiber.current.task or raise "no task for this Fiber"
+    end
+
+    # Suspend the running task, deferring to the scheduler
+    def self.suspend(status)
+      task = Task.current
+      task.status = status
+
+      result = Fiber.yield
+      raise TerminatedError, "task was terminated" if result == TerminatedError
+      task.status = :running
+
+      result
+    end
+
+    # Run the given block within a task
+    def initialize(type)
+      @type   = type
+      @status = :new
+
+      actor   = Thread.current[:actor]
+      mailbox = Thread.current[:mailbox]
+
+      @fiber = Fiber.new do
+        @status = :running
+        Thread.current[:actor]   = actor
+        Thread.current[:mailbox] = mailbox
+        Fiber.current.task = self
+        actor.tasks << self
+
+        begin
+          yield
+        rescue TerminatedError
+          # Task was explicitly terminated
+        ensure
+          actor.tasks.delete self
+        end
+      end
+    end
+
+    # Resume a suspended task, giving it a value to return if needed
+    def resume(value = nil)
+      @fiber.resume value
+      nil
+    rescue FiberError
+      raise DeadTaskError, "cannot resume a dead task"
+    rescue RuntimeError => ex
+      # These occur spuriously on 1.9.3 if we shut down an actor with running tasks
+      return if ex.message == ""
+      raise
+    end
+
+    # Terminate this task
+    def terminate
+      resume TerminatedError if @fiber.alive?
+    rescue FiberError
+      # If we're getting this the task should already be dead
+    end
+
+    # Is the current task still running?
+    def running?; @fiber.alive?; end
+
+    # Nicer string inspect for tasks
+    def inspect
+      "<Celluloid::Task:0x#{object_id.to_s(16)} @type=#{@type.inspect}, @status=#{@status.inspect}, @running=#{@fiber.alive?}>"
+    end
+  end
+end

data/lib/celluloid/thread_handle.rb

@@ -0,0 +1,35 @@
+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
+      @mutex = Mutex.new
+      @join  = ConditionVariable.new
+      
+      @thread = InternalPool.get do
+        begin
+          yield
+        ensure
+          @mutex.synchronize do
+            @thread = nil
+            @join.broadcast
+          end
+        end
+      end
+    end
+    
+    def alive?
+      @mutex.synchronize { @thread.alive? if @thread }
+    end
+    
+    def kill
+      !!@mutex.synchronize { @thread.kill if @thread }
+    end
+    
+    def join
+      @mutex.synchronize { @join.wait(@mutex) if @thread }
+      nil
+    end
+  end
+end

data/lib/celluloid/timers.rb

@@ -0,0 +1,110 @@
+module Celluloid
+  # Low precision timers implemented in pure Ruby
+  class Timers
+    def initialize
+      @timers = []
+    end
+
+    # Call the given block after the given interval
+    def add(interval, recurring = false, &block)
+      Timer.new(self, interval, recurring, block)
+    end
+
+    # Wait for the next timer and fire it
+    def wait
+      return if @timers.empty?
+
+      interval = wait_interval
+      sleep interval if interval >= Timer::QUANTUM
+      fire
+    end
+
+    # Interval to wait until when the next timer will fire
+    def wait_interval
+      @timers.first.time - Time.now unless empty?
+    end
+
+    # Fire all timers that are ready
+    def fire
+      return if @timers.empty?
+
+      time = Time.now + Timer::QUANTUM
+      while not empty? and time > @timers.first.time
+        timer = @timers.shift
+        timer.call
+      end
+    end
+
+    # Insert a timer into the active timers
+    def insert(timer)
+      @timers.insert(index(timer), timer)
+    end
+
+    # Remove a given timer from the set we're monitoring
+    def cancel(timer)
+      @timers.delete timer
+    end
+
+    # Are there any timers pending?
+    def empty?
+      @timers.empty?
+    end
+
+    # Index where a timer would be located in the sorted timers array
+    def index(timer)
+      l, r = 0, @timers.size - 1
+
+      while l <= r
+        m = (r + l) / 2
+        if timer < @timers.at(m)
+          r = m - 1
+        else
+          l = m + 1
+        end
+      end
+      l
+    end
+  end
+
+  # An individual timer set to fire a given proc at a given time
+  class Timer
+    include Comparable
+
+    # The timer system is guaranteed (at least by the specs) to be this precise
+    # during normal operation. Long blocking calls within actors will delay the
+    # firing of timers
+    QUANTUM = 0.02
+
+    attr_reader :interval, :time, :recurring
+
+    def initialize(timers, interval, recurring, block)
+      @timers, @interval, @recurring = timers, interval, recurring
+      @block = block
+
+      reset
+    end
+
+    def <=>(other)
+      @time <=> other.time
+    end
+
+    # Cancel this timer
+    def cancel
+      @timers.cancel self
+    end
+
+    # Reset this timer
+    def reset
+      @timers.cancel self if defined?(@time)
+      @time = Time.now + @interval
+      @timers.insert self
+    end
+
+    # Fire the block
+    def fire
+      reset if recurring
+      @block.call
+    end
+    alias_method :call, :fire
+  end
+end

data/lib/celluloid/uuid.rb

@@ -0,0 +1,38 @@
+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/lib/celluloid/version.rb

@@ -0,0 +1,4 @@
+module Celluloid
+  VERSION = '0.10.2'
+  def self.version; VERSION; end
+end