celluloid 0.12.0 → 0.13.0

data/lib/celluloid/fsm.rb

@@ -84,30 +84,71 @@ module Celluloid
     #
     # Note: making additional state transitions will cancel delayed transitions
     def transition(state_name, options = {})
+      new_state = validate_and_sanitize_new_state(state_name)
+      return unless new_state
+
+      if handle_delayed_transitions(new_state, options[:delay])
+        return @delayed_transition
+      end
+
+      transition_with_callbacks!(new_state)
+    end
+
+    # Immediate state transition with no sanity checks, or callbacks. "Dangerous!"
+    def transition!(state_name)
+      @state = state_name
+    end
+
+    protected
+
+    def validate_and_sanitize_new_state(state_name)
       state_name = state_name.to_sym
-      current_state = self.class.states[@state]
 
-      return if current_state && current_state.name == state_name
+      return if current_state_name == state_name
 
       if current_state and not current_state.valid_transition? state_name
         valid = current_state.transitions.map(&:to_s).join(", ")
         raise ArgumentError, "#{self.class} can't change state from '#{@state}' to '#{state_name}', only to: #{valid}"
       end
 
-      new_state = self.class.states[state_name]
+      new_state = states[state_name]
 
       unless new_state
-        return if state_name == self.class.default_state
+        return if state_name == default_state
         raise ArgumentError, "invalid state for #{self.class}: #{state_name}"
       end
 
-      if options[:delay]
+      new_state
+    end
+
+    def transition_with_callbacks!(state_name)
+      transition! state_name.name
+      state_name.call(self)
+    end
+
+    def states
+      self.class.states
+    end
+
+    def default_state
+      self.class.default_state
+    end
+
+    def current_state
+      states[@state]
+    end
+
+    def current_state_name
+      current_state && current_state.name || ''
+    end
+
+    def handle_delayed_transitions(new_state, delay)
+      if delay
         raise UnattachedError, "can't delay unless attached" unless @actor
         @delayed_transition.cancel if @delayed_transition
 
-        @delayed_transition = @actor.after(options[:delay]) do
-          transition! new_state.name
-          new_state.call(self)
+        @delayed_transition = @actor.after(delay) do
+          transition_with_callbacks!(new_state)
         end
 
         return @delayed_transition
@@ -117,14 +158,6 @@ module Celluloid
         @delayed_transition.cancel
         @delayed_transition = nil
       end
-
-      transition! new_state.name
-      new_state.call(self)
-    end
-
-    # Immediate state transition with no sanity checks. "Dangerous!"
-    def transition!(state_name)
-      @state = state_name
     end
 
     # FSM states as declared by Celluloid::FSM.state

data/lib/celluloid/future.rb

@@ -4,8 +4,11 @@ module Celluloid
   # Celluloid::Future objects allow methods and blocks to run in the
   # background, their values requested later
   class Future
+    attr_reader :address
+    
     # Create a future bound to a given receiver, or with a block to compute
     def initialize(*args, &block)
+      @address = Celluloid.uuid
       @mutex = Mutex.new
       @ready = false
       @result = nil
@@ -13,7 +16,7 @@ module Celluloid
 
       if block
         @call = SyncCall.new(self, :call, args)
-        InternalPool.get do
+        Celluloid.internal_pool.get do
           begin
             @call.dispatch(block)
           rescue
@@ -74,7 +77,7 @@ module Celluloid
       if result
         result.value
       else
-        raise "Timed out"
+        raise TimeoutError, "Timed out"
       end
     end
     alias_method :call, :value

data/lib/celluloid/internal_pool.rb

@@ -2,61 +2,79 @@ require 'thread'
 
 module Celluloid
   # Maintain a thread pool FOR SPEED!!
-  module InternalPool
-    @pool = []
-    @mutex = Mutex.new
+  class InternalPool
+    attr_accessor :busy_size, :idle_size, :max_idle
 
-    # TODO: should really adjust this based on usage
-    @max_idle = 16
+    def initialize
+      @pool = []
+      @mutex = Mutex.new
+      @busy_size = @idle_size = 0
 
-    class << self
-      attr_accessor :max_idle
-
-      # Get a thread from the pool, running the given block
-      def get(&block)
-        @mutex.synchronize do
-          begin
-            if @pool.empty?
-              thread = create
-            else
-              thread = @pool.shift
-            end
-          end until thread.status # handle crashed threads
-
-          thread[:queue] << block
-          thread
-        end
-      end
+      # TODO: should really adjust this based on usage
+      @max_idle = 16
+    end
 
-      # Return a thread to the pool
-      def put(thread)
-        @mutex.synchronize do
-          if @pool.size >= @max_idle
-            thread[:queue] << nil
+    # Get a thread from the pool, running the given block
+    def get(&block)
+      @mutex.synchronize do
+        begin
+          if @pool.empty?
+            thread = create
           else
-            @pool << thread
+            thread = @pool.shift
+            @idle_size -= 1
           end
+        end until thread.status # handle crashed threads
+
+        @busy_size += 1
+        thread[:celluloid_queue] << block
+        thread
+      end
+    end
+
+    # Return a thread to the pool
+    def put(thread)
+      @mutex.synchronize do
+        if @pool.size >= @max_idle
+          thread[:celluloid_queue] << nil
+        else
+          clean_thread_locals(thread)
+          @pool << thread
+          @idle_size += 1
+          @busy_size -= 1
         end
       end
+    end
 
-      # Create a new thread with an associated queue of procs to run
-      def create
-        queue = Queue.new
-        thread = Thread.new do
-          while proc = queue.pop
-            begin
-              proc.call
-            rescue => ex
-              Logger.crash("thread crashed", ex)
-            end
-
-            put thread
+    # Create a new thread with an associated queue of procs to run
+    def create
+      queue = Queue.new
+      thread = Thread.new do
+        while proc = queue.pop
+          begin
+            proc.call
+          rescue => ex
+            Logger.crash("thread crashed", ex)
           end
+
+          put thread
         end
+      end
 
-        thread[:queue] = queue
-        thread
+      thread[:celluloid_queue] = queue
+      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
   end
-end
+
+  self.internal_pool = InternalPool.new
+end

data/lib/celluloid/legacy.rb

@@ -0,0 +1,46 @@
+module Celluloid
+  class ActorProxy
+    # method_missing black magic to call bang predicate methods asynchronously
+    def method_missing(meth, *args, &block)
+      # bang methods are async calls
+      if meth.match(/!$/)
+        Logger.deprecate("'bang method'-style async syntax is deprecated and will be removed in Celluloid 1.0." +
+          "Call async methods with 'actor.async.method'.")
+
+        unbanged_meth = meth.to_s
+        unbanged_meth.slice!(-1, 1)
+        Actor.async @mailbox, unbanged_meth, *args, &block
+      else
+        Actor.call  @mailbox, meth, *args, &block
+      end
+    end
+  end
+
+  module InstanceMethods
+    # Process async calls via method_missing
+    def method_missing(meth, *args, &block)
+      # bang methods are async calls
+      if meth.to_s.match(/!$/)
+        Logger.deprecate("'bang method'-style async syntax is deprecated and will be removed in Celluloid 1.0." +
+          "Call async methods with 'actor.async.method'.")
+
+        unbanged_meth = meth.to_s.sub(/!$/, '')
+        args.unshift unbanged_meth
+
+        call = AsyncCall.new(:__send__, args, block)
+        begin
+          Thread.current[:celluloid_actor].mailbox << call
+        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
+
+        return
+      end
+
+      super
+    end
+  end
+end

data/lib/celluloid/links.rb

@@ -27,11 +27,6 @@ module Celluloid
       @links.each { |_, actor| yield(actor) }
     end
 
-    # Send an event message to all actors
-    def send_event(event)
-      each { |actor| actor.mailbox << event }
-    end
-
     # Generate a string representation
     def inspect
       links = self.map(&:inspect).join(',')

data/lib/celluloid/logger.rb

@@ -37,10 +37,10 @@ module Celluloid
       end
     end
 
-    # Format an exception message
-    def format_exception(exception)
-      str = "#{exception.class}: #{exception.to_s}\n"
-      str << exception.backtrace.join("\n")
+    # Note a deprecation
+    def deprecate(message)
+      trace = caller.join("\n\t")
+      warn "DEPRECATION WARNING: #{message}\n\t#{trace}"
     end
 
     # Define an exception handler
@@ -49,5 +49,15 @@ module Celluloid
       @exception_handlers << block
       nil
     end
+
+    # Format an exception message
+    def format_exception(exception)
+      str = "#{exception.class}: #{exception.to_s}\n\t"
+      if exception.backtrace
+        str << exception.backtrace.join("\n\t")
+      else
+        str << "EMPTY BACKTRACE\n\t"
+      end
+    end
   end
 end

data/lib/celluloid/logging/incident.rb

@@ -0,0 +1,21 @@
+module Celluloid
+  # Wraps all events and context for a single incident.
+  class Incident
+    attr_accessor :pid
+    attr_accessor :events, :triggering_event
+
+    def initialize(events, triggering_event=nil)
+      @events = events
+      @triggering_event = triggering_event
+      @pid = $$
+    end
+
+    # Merge two incidents together. This may be useful if two incidents occur at the same time.
+    def merge(*other_incidents)
+      merged_events = other_incidents.flatten.inject(events) do |events, incident|
+        events += incident.events
+      end
+      Incident.new(merged_events.sort, triggering_event)
+    end
+  end
+end

data/lib/celluloid/logging/incident_logger.rb

@@ -0,0 +1,129 @@
+require 'logger'
+module Celluloid
+  # A logger that holds all messages in circular buffers, then flushes the buffers
+  # when an event occurs at a configurable severity threshold.
+  #
+  # Unlike ruby's Logger, this class only supports a single progname.
+  class IncidentLogger
+    module Severity
+      include ::Logger::Severity
+
+      TRACE = -1
+
+      def severity_to_string(severity)
+        case severity
+        when TRACE   then 'TRACE'
+        when DEBUG   then 'DEBUG'
+        when INFO    then 'INFO'
+        when WARN    then 'WARN'
+        when ERROR   then 'ERROR'
+        when FATAL   then 'FATAL'
+        when UNKNOWN then 'UNKNOWN'
+        end
+      end
+
+    end
+    include Severity
+
+    # The progname (facility) for this instance.
+    attr_accessor :progname
+
+    # The logging level. Messages below this severity will not be logged at all.
+    attr_accessor :level
+
+    # The incident threshold. Messages at or above this severity will generate an
+    # incident and be published to incident reporters.
+    attr_accessor :threshold
+
+    # The buffer size limit. Each log level will retain this number of messages
+    # at maximum.
+    attr_accessor :sizelimit
+
+    attr_accessor :buffers
+
+    # Create a new IncidentLogger.
+    def initialize(progname=nil, options={})
+      @progname = progname || "default"
+      @level = options[:level] || DEBUG
+      @threshold = options[:threshold] || ERROR
+      @sizelimit = options[:sizelimit] || 100
+
+      @buffer_mutex = Mutex.new
+      @buffers = Hash.new do |progname_hash, progname| 
+        @buffer_mutex.synchronize do
+          progname_hash[progname] = Hash.new do |severity_hash, severity|
+            severity_hash[severity] = RingBuffer.new(@sizelimit)
+          end
+        end
+      end
+
+      # When the IncidentLogger itself encounters an error, it falls back to logging to stderr
+      @fallback_logger = ::Logger.new(STDERR)
+      @fallback_logger.progname = "FALLBACK"
+    end
+
+    # add an event.
+    def add(severity, message=nil, progname=nil, &block)
+      progname ||= @progname
+      severity ||= UNKNOWN
+
+      if severity < @level
+        return event.id
+      end
+
+      if message.nil? && !block_given?
+        message = progname
+        progname = @progname
+      end
+
+      event = LogEvent.new(severity, message, progname, &block)
+
+      @buffers[progname][severity] << event
+
+      if severity >= @threshold
+        begin
+          Celluloid::Notifications.notifier.async.publish(incident_topic, create_incident(event))
+        rescue => ex
+          @fallback_logger.error(ex)
+        end
+      end
+      event.id
+    end
+    alias :log :add
+
+    # See docs for Logger#info
+    def trace   (progname=nil, &block); add(TRACE,   nil, progname, &block); end
+    def debug   (progname=nil, &block); add(DEBUG,   nil, progname, &block); end
+    def info    (progname=nil, &block); add(INFO,    nil, progname, &block); end
+    def warn    (progname=nil, &block); add(WARN,    nil, progname, &block); end
+    def error   (progname=nil, &block); add(ERROR,   nil, progname, &block); end
+    def fatal   (progname=nil, &block); add(FATAL,   nil, progname, &block); end
+    def unknown (progname=nil, &block); add(UNKNOWN, nil, progname, &block); end
+
+    def flush
+      messages = []
+      @buffer_mutex.synchronize do
+        @buffers.each do |progname, severities|
+          severities.each do |severity, buffer|
+            messages += buffer.flush
+          end
+        end
+      end
+      messages.sort
+    end
+    
+    def clear
+      @buffer_mutex.synchronize do
+        @buffers.each { |buffer| buffer.clear }
+      end
+    end
+
+    def create_incident(event=nil)
+      Incident.new(flush, event)
+    end
+
+    def incident_topic
+      "log.incident.#{@progname}"
+    end
+  end
+end

data/lib/celluloid/logging/incident_reporter.rb

@@ -0,0 +1,48 @@
+require 'logger'
+module Celluloid
+  # Subscribes to log incident topics to report on them.
+  class IncidentReporter
+    include Celluloid
+    include Celluloid::Notifications
+
+    # get the time from the event
+    class Formatter < ::Logger::Formatter
+      def call(severity, time, progname, msg)
+        super(severity, msg.time, progname, msg.message)
+      end
+    end
+
+    def initialize(*args)
+      subscribe(/log\.incident/, :report)
+      @logger = ::Logger.new(*args)
+      @logger.formatter = Formatter.new
+      @silenced = false
+    end
+
+    def report(topic, incident)
+      return if @silenced
+
+      header = "INCIDENT"
+      header << " AT #{incident.triggering_event.time}" if incident.triggering_event
+      @logger << header
+      @logger << "\n"
+      @logger << "====================\n"
+      incident.events.each do |event|
+        @logger.add(event.severity, event, event.progname)
+      end
+      @logger << "====================\n"
+    end
+
+    def silence
+      @silenced = true
+    end
+
+    def unsilence
+      @silenced = false
+    end
+
+    def silenced?
+      @silenced
+    end
+  end
+end

data/lib/celluloid/logging/log_event.rb

@@ -0,0 +1,20 @@
+module Celluloid
+  # Wraps a single log event.
+  class LogEvent
+    attr_accessor :id, :severity, :message, :progname, :time
+
+    def initialize(severity, message, progname, time=Time.now, &block)
+      # This id should be ordered. For now relies on Celluloid::UUID to be ordered.
+      # May want to use a generation/counter strategy for independence of uuid.
+      @id = Celluloid::UUID.generate
+      @severity = severity
+      @message = block_given? ? yield : message
+      @progname = progname
+      @time = time
+    end
+
+    def <=>(other)
+      @id <=> other.id
+    end
+  end
+end

data/lib/celluloid/logging/ring_buffer.rb

@@ -0,0 +1,65 @@
+module Celluloid
+  class RingBuffer
+    def initialize(size)
+      @size = size
+      @start = 0
+      @count = 0
+      @buffer = Array.new(size)
+      @mutex = Mutex.new
+    end
+
+    def full?
+      @count == @size
+    end
+
+    def empty?
+      @count == 0
+    end
+
+    def push(value)
+      @mutex.synchronize do
+        stop = (@start + @count) % @size
+        @buffer[stop] = value
+        if full?
+          @start = (@start + 1) % @size
+        else
+          @count += 1
+        end
+        value
+      end
+    end
+    alias :<< :push
+
+    def shift
+      @mutex.synchronize do
+        remove_element
+      end
+    end
+
+    def flush
+      values = []
+      @mutex.synchronize do
+        while !empty?
+          values << remove_element
+        end
+      end
+      values
+    end
+
+    def clear
+      @buffer = Array.new(@size)
+      @start = 0
+      @count = 0
+    end
+
+    private
+
+    def remove_element
+      return nil if empty?
+      value, @buffer[@start] = @buffer[@start], nil
+      @start = (@start + 1) % @size
+      @count -= 1
+      value
+    end
+  end
+end

data/lib/celluloid/logging.rb

@@ -0,0 +1,5 @@
+require 'celluloid/logging/log_event'
+require 'celluloid/logging/incident'
+require 'celluloid/logging/ring_buffer'
+require 'celluloid/logging/incident_logger'
+require 'celluloid/logging/incident_reporter'

data/lib/celluloid/mailbox.rb

@@ -10,9 +10,10 @@ module Celluloid
     include Enumerable
 
     # A unique address at which this mailbox can be found
-    alias_method :address, :object_id
+    attr_reader :address
 
     def initialize
+      @address   = Celluloid.uuid
       @messages  = []
       @mutex     = Mutex.new
       @dead      = false

data/lib/celluloid/method.rb

@@ -1,6 +1,7 @@
 module Celluloid
   # Method handles that route through an actor proxy
   class Method
+
     def initialize(actor, name)
       raise NameError, "undefined method `#{name}'" unless actor.respond_to? name
 
@@ -8,6 +9,10 @@ module Celluloid
       @klass = @actor.class
     end
 
+    def arity
+      @actor._send_(:method, @name).arity
+    end
+
     def call(*args, &block)
       @actor._send_(@name, *args, &block)
     end