celluloid 0.17.4 → 0.18.0

data/lib/celluloid/internals/handlers.rb

@@ -0,0 +1,42 @@
+require "set"
+
+module Celluloid
+  module Internals
+    class Handlers
+      def initialize
+        @handlers = Set.new
+      end
+
+      def handle(*patterns, &block)
+        patterns.each do |pattern|
+          handler = Handler.new pattern, block
+          @handlers << handler
+        end
+      end
+
+      # Handle incoming messages
+      def handle_message(message)
+        handler = @handlers.find { |h| h.match(message) }
+        handler.call(message) if handler
+        handler
+      end
+    end
+
+    # Methods blocking on a call to receive
+    class Handler
+      def initialize(pattern, block)
+        @pattern = pattern
+        @block = block
+      end
+
+      # Match a message with this receiver's block
+      def match(message)
+        @pattern === message
+      end
+
+      def call(message)
+        @block.call message
+      end
+    end
+  end
+end

data/lib/celluloid/internals/links.rb

@@ -0,0 +1,38 @@
+module Celluloid
+  module Internals
+    # Linked actors send each other system events
+    class Links
+      include Enumerable
+
+      def initialize
+        @links = {}
+      end
+
+      # Add an actor to the current links
+      def <<(actor)
+        @links[actor.mailbox.address] = actor
+      end
+
+      # Do links include the given actor?
+      def include?(actor)
+        @links.key? actor.mailbox.address
+      end
+
+      # Remove an actor from the links
+      def delete(actor)
+        @links.delete actor.mailbox.address
+      end
+
+      # Iterate through all links
+      def each
+        @links.each { |_, actor| yield(actor) }
+      end
+
+      # Generate a string representation
+      def inspect
+        links = map(&:inspect).join(",")
+        "#<#{self.class}[#{links}]>"
+      end
+    end
+  end
+end

data/lib/celluloid/internals/logger.rb

@@ -0,0 +1,104 @@
+module Celluloid
+  module Internals
+    module Logger
+      class WithBacktrace
+        def initialize(backtrace)
+          @backtrace = backtrace
+        end
+
+        def debug(string)
+          # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+          # rubocop:disable Style/GlobalVars
+          Celluloid.logger.debug(decorate(string)) if $CELLULOID_DEBUG
+          # rubocop:enable Style/GlobalVars
+        end
+
+        def info(string)
+          Celluloid.logger.info(decorate(string))
+        end
+
+        def warn(string)
+          Celluloid.logger.warn(decorate(string))
+        end
+
+        def error(string)
+          Celluloid.logger.error(decorate(string))
+        end
+
+        def decorate(string)
+          [string, @backtrace].join("\n\t")
+        end
+      end
+
+      @exception_handlers = []
+
+      module_function
+
+      def with_backtrace(backtrace)
+        yield WithBacktrace.new(backtrace) if Celluloid.logger
+      end
+
+      # Send a debug message
+      def debug(string)
+        # !!! DO NOT INTRODUCE ADDITIONAL GLOBAL VARIABLES !!!
+        # rubocop:disable Style/GlobalVars
+        Celluloid.logger.debug(string) if Celluloid.logger && $CELLULOID_DEBUG
+        # rubocop:enable Style/GlobalVars
+      end
+
+      # Send a info message
+      def info(string)
+        Celluloid.logger.info(string) if Celluloid.logger
+      end
+
+      # Send a warning message
+      def warn(string)
+        Celluloid.logger.warn(string) if Celluloid.logger
+      end
+
+      # Send an error message
+      def error(string)
+        Celluloid.logger.error(string) if Celluloid.logger
+      end
+
+      # Handle a crash
+      def crash(string, exception)
+        if Celluloid.log_actor_crashes
+          string << "\n" << format_exception(exception)
+          error string
+        end
+
+        @exception_handlers.each do |handler|
+          begin
+            handler.call(exception)
+          rescue => ex
+            error "EXCEPTION HANDLER CRASHED:\n" << format_exception(ex)
+          end
+        end
+      end
+
+      # Note a deprecation
+      def deprecate(message)
+        trace = caller.join("\n\t")
+        warn "DEPRECATION WARNING: #{message}\n\t#{trace}"
+      end
+
+      # Define an exception handler
+      # NOTE: These should be defined at application start time
+      def exception_handler(&block)
+        @exception_handlers << block
+        nil
+      end
+
+      # Format an exception message
+      def format_exception(exception)
+        str = "#{exception.class}: #{exception}\n\t"
+        str << if exception.backtrace
+                 exception.backtrace.join("\n\t")
+               else
+                 "EMPTY BACKTRACE\n\t"
+               end
+      end
+    end
+  end
+end

data/lib/celluloid/internals/method.rb

@@ -0,0 +1,34 @@
+module Celluloid
+  module Internals
+    # Method handles that route through an actor proxy
+    class Method
+      def initialize(proxy, name)
+        raise NoMethodError, "undefined method `#{name}'" unless proxy.respond_to? name
+
+        @proxy = proxy
+        @name = name
+        @klass = @proxy.class
+      end
+
+      def arity
+        @proxy.method_missing(:method, @name).arity
+      end
+
+      def name
+        @proxy.method_missing(:method, @name).name
+      end
+
+      def parameters
+        @proxy.method_missing(:method, @name).parameters
+      end
+
+      def call(*args, &block)
+        @proxy.__send__(@name, *args, &block)
+      end
+
+      def inspect
+        "#<Celluloid::Internals::Method #{@klass}##{@name}>"
+      end
+    end
+  end
+end

data/lib/celluloid/internals/properties.rb

@@ -0,0 +1,32 @@
+module Celluloid
+  module Internals
+    # Properties define inheritable attributes of classes, somewhat similar to
+    # Rails cattr_*/mattr_* or class_attribute
+    module Properties
+      def property(name, opts = {})
+        default   = opts.fetch(:default, nil)
+        multi     = opts.fetch(:multi, false)
+        ivar_name = "@#{name}".to_sym
+
+        singleton = class << ancestors.first; self; end
+        begin
+          singleton.send(:remove_method, name)
+        rescue
+          nil
+        end
+        singleton.send(:define_method, name) do |value = nil, *extra|
+          if value
+            value = value ? [value, *send(name), *extra].uniq : [] if multi
+            instance_variable_set(ivar_name, value)
+          elsif instance_variables.include?(ivar_name)
+            instance_variable_get(ivar_name)
+          elsif superclass.respond_to? name
+            superclass.send(name)
+          else
+            default
+          end
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/internals/receivers.rb

@@ -0,0 +1,64 @@
+require "set"
+require "timers"
+
+module Celluloid
+  module Internals
+    # Allow methods to directly interact with the actor protocol
+    class Receivers
+      def initialize(timers)
+        @receivers = Set.new
+        @timers = timers
+      end
+
+      # Receive an asynchronous message
+      def receive(timeout = nil, &block)
+        if Celluloid.exclusive?
+          Celluloid.mailbox.receive(timeout, &block)
+        else
+          receiver = Receiver.new block
+
+          if timeout
+            receiver.timer = @timers.after(timeout) do
+              @receivers.delete receiver
+              receiver.resume
+            end
+          end
+
+          @receivers << receiver
+          Task.suspend :receiving
+        end
+      end
+
+      # Handle incoming messages
+      def handle_message(message)
+        receiver = @receivers.find { |r| r.match(message) }
+        return unless receiver
+
+        @receivers.delete receiver
+        receiver.timer.cancel if receiver.timer
+        receiver.resume message
+        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
+end

data/lib/celluloid/internals/registry.rb

@@ -0,0 +1,102 @@
+module Celluloid
+  module Internals
+    # The Registry allows us to refer to specific actors by human-meaningful names
+    class Registry
+      def initialize
+        @root = nil     # keep root out of the standard list of registered names
+        @actors = {}    # hash of name => actor
+        @index = {}     # hash of name => branch
+        @branches = {}  # hash of branch => [ actors ]
+        @registry = Mutex.new
+      end
+
+      # Register an Actor
+      def []=(name, actor)
+        if name == :root
+          @registry.synchronize do
+            @root = actor
+          end
+        else
+          actor_singleton = class << actor; self; end
+          raise TypeError, "not an actor" unless actor_singleton.ancestors.include? Proxy::Abstract
+
+          #           if actor.class.ancestors.include? Supervision::Container
+          #             puts "Supervisor: #{actor.links.inspect}"
+          #           end
+          @registry.synchronize do
+            @actors[name.to_sym] = actor
+          end
+          actor.mailbox << NamingRequest.new(name.to_sym)
+        end
+      end
+
+      def add(name, actor, branch = :services)
+        set(name, actor)
+        @registry.synchronize do
+          unless @branches.key? branch
+            @branches[branch] = []
+            self.class.instance_eval do
+              begin
+                remove_method(branch)
+              rescue
+                nil
+              end
+              define_method(branch) { @branches[branch] }
+            end
+            @branches[branch] << name
+          end
+          @index[name.to_sym] = branch
+        end
+      end
+
+      # Retrieve an actor by name
+      def [](name)
+        return @root if name == :root
+        @registry.synchronize do
+          @actors[name.to_sym]
+        end
+      end
+
+      def branch(name)
+        @registry.synchronize do
+          @index.select { |_a, b| b == name }
+        end
+      end
+
+      alias get []
+      alias set []=
+
+      def delete(name)
+        @registry.synchronize do
+          @index.delete name.to_sym
+          @actors.delete name.to_sym
+        end
+      end
+
+      def include?(name)
+        names.include? name
+      end
+
+      # List all registered actors by name
+      def names
+        @registry.synchronize { @actors.keys }
+      end
+
+      def index
+        @registry.synchronize { @index }
+      end
+
+      # removes and returns all registered actors as a hash of `name => actor`
+      # can be used in testing to clear the registry
+      def clear
+        hash = nil
+        @registry.synchronize do
+          hash = @actors.dup
+          @actors.clear
+          @index.clear
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/celluloid/internals/responses.rb

@@ -0,0 +1,46 @@
+module Celluloid
+  module Internals
+    # Responses to calls
+    class Response
+      attr_reader :call, :value
+
+      def initialize(call, value)
+        @call = call
+        @value = value
+      end
+
+      def dispatch
+        @call.task.resume self
+      end
+
+      # Call completed successfully
+      class Success < Response; end
+
+      # Call was aborted due to sender error
+      class Error < Response
+        def value
+          ex = super
+          ex = ex.cause if ex.is_a? Celluloid::AbortError
+
+          if ex.backtrace
+            ex.backtrace << "(celluloid):0:in `remote procedure call'"
+            ex.backtrace.concat(caller)
+          end
+
+          raise ex
+        end
+      end
+
+      class Block
+        def initialize(call, result)
+          @call = call
+          @result = result
+        end
+
+        def dispatch
+          @call.task.resume(@result)
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/internals/signals.rb

@@ -0,0 +1,24 @@
+module Celluloid
+  module Internals
+    # Event signaling between methods of the same object
+    class Signals
+      def initialize
+        @conditions = {}
+      end
+
+      # Wait for the given signal and return the associated value
+      def wait(name)
+        raise "cannot wait for signals while exclusive" if Celluloid.exclusive?
+
+        @conditions[name] ||= Condition.new
+        @conditions[name].wait
+      end
+
+      # Send a signal to all method calls waiting for the given name
+      def broadcast(name, value = nil)
+        condition = @conditions.delete(name)
+        condition.broadcast(value) if condition
+      end
+    end
+  end
+end

data/lib/celluloid/internals/stack/dump.rb

@@ -0,0 +1,12 @@
+module Celluloid
+  module Internals
+    class Stack
+      class Dump < Stack
+        def initialize(threads)
+          super(threads)
+          snapshot(true)
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/internals/stack/states.rb

@@ -0,0 +1,72 @@
+module Celluloid
+  module Internals
+    class Stack
+      module DisplayBacktrace
+        def display_backtrace(backtrace, output, indent = nil)
+          backtrace ||= ["EMPTY BACKTRACE"]
+          backtrace.each do |line|
+            output << indent if indent
+            output << "\t" << line << "\n"
+          end
+          output << "\n\n"
+        end
+      end
+
+      class TaskState < Struct.new(:task_class, :type, :meta, :status, :backtrace); end
+
+      class CellState < Struct.new(:subject_id, :subject_class)
+        def dump
+          "Celluloid::Cell 0x#{subject_id.to_s(16)}: #{subject_class}"
+        end
+      end
+
+      class ThreadState < Struct.new(:thread_id, :backtrace, :role)
+        include DisplayBacktrace
+        def dump
+          string = ""
+          string << "Thread 0x#{thread_id.to_s(16)} (#{role}):\n"
+          display_backtrace backtrace, string if backtrace
+          string
+        end
+      end
+
+      class ActorState
+        include DisplayBacktrace
+        attr_accessor :name, :id, :cell
+        attr_accessor :status, :tasks
+        attr_accessor :backtrace
+
+        def dump
+          string = ""
+          string << "Celluloid::Actor 0x#{id.to_s(16)}"
+          string << " [#{name}]" if name
+          string << "\n"
+
+          if cell
+            string << cell.dump
+            string << "\n"
+          end
+
+          if status == :idle
+            string << "State: Idle (waiting for messages)\n"
+            display_backtrace backtrace, string if backtrace
+          else
+            string << "State: Running (executing tasks)\n"
+            display_backtrace backtrace, string if backtrace
+            string << "\tTasks:\n"
+
+            tasks.each_with_index do |task, i|
+              string << "\t  #{i + 1}) #{task.task_class}[#{task.type}]: #{task.status}\n"
+              if task.backtrace
+                string << "\t      #{task.meta.inspect}\n"
+                display_backtrace task.backtrace, string, "\t"
+              end
+            end
+          end
+          string << "\n" unless backtrace
+          string
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/internals/stack/summary.rb

@@ -0,0 +1,12 @@
+module Celluloid
+  module Internals
+    class Stack
+      class Summary < Stack
+        def initialize(threads)
+          super(threads)
+          snapshot
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/internals/stack.rb

@@ -0,0 +1,74 @@
+module Celluloid
+  module Internals
+    class Stack
+      attr_accessor :actors, :threads
+
+      def initialize(threads)
+        @group = threads
+        @actors  = []
+        @threads = []
+      end
+
+      def snapshot(backtrace = nil)
+        @group.each do |thread|
+          if thread.role == :actor
+            @actors << snapshot_actor(thread.actor, backtrace) if thread.actor
+          else
+            @threads << snapshot_thread(thread, backtrace)
+          end
+        end
+      end
+
+      def snapshot_actor(actor, backtrace = nil)
+        state = ActorState.new
+        state.id = actor.object_id
+
+        # TODO: delegate to the behavior
+        state.cell = snapshot_cell(actor.behavior) if actor.behavior.is_a?(Cell)
+
+        tasks = actor.tasks
+        if tasks.empty?
+          state.status = :idle
+        else
+          state.status = :running
+          state.tasks = tasks.to_a.map { |t| TaskState.new(t.class, t.type, t.meta, t.status, t.backtrace) }
+        end
+
+        state.backtrace = actor.thread.backtrace if backtrace && actor.thread
+        state
+      end
+
+      def snapshot_cell(behavior)
+        state = CellState.new
+        state.subject_id = behavior.subject.object_id
+        state.subject_class = behavior.subject.class
+        state
+      end
+
+      def snapshot_thread(thread, backtrace = nil)
+        if backtrace
+          backtrace = begin
+                        thread.backtrace
+                      rescue NoMethodError # for Rubinius < 2.5.2.c145
+                        []
+                      end
+        end
+        ThreadState.new(thread.object_id, backtrace, thread.role)
+      end
+
+      def print(output = STDERR)
+        @actors.each do |actor|
+          output.print actor.dump
+        end
+
+        @threads.each do |thread|
+          output.print thread.dump
+        end
+      end
+    end
+  end
+end
+
+require "celluloid/internals/stack/states"
+require "celluloid/internals/stack/dump"
+require "celluloid/internals/stack/summary"