celluloid 0.18.0.pre → 0.18.0.pre2

data/lib/celluloid/group.rb

@@ -3,14 +3,14 @@ module Celluloid
     attr_accessor :group
 
     def initialize
-      @pid = $$
+      @pid = $PROCESS_ID
       @mutex = Mutex.new
       @group = []
       @running = true
     end
 
     def assert_active
-      fail Celluloid::NotActive unless active?
+      raise Celluloid::NotActive unless active?
     end
 
     def assert_inactive
@@ -18,7 +18,7 @@ module Celluloid
       if RUBY_PLATFORM == "java"
         Celluloid.logger.warn "Group is still active"
       else
-        fail Celluloid::StillActive
+        raise Celluloid::StillActive
       end
     end
 
@@ -27,7 +27,7 @@ module Celluloid
     end
 
     def forked?
-      @pid != $$
+      @pid != $PROCESS_ID
     end
 
     def to_a
@@ -40,7 +40,11 @@ module Celluloid
     def purge(thread)
       @mutex.synchronize do
         @group.delete(thread)
-        thread.kill rescue nil
+        begin
+          thread.kill
+        rescue
+          nil
+        end
       end
     end
 
@@ -53,15 +57,15 @@ module Celluloid
     end
 
     def get
-      fail NotImplementedError
+      raise NotImplementedError
     end
 
     def create
-      fail NotImplementedError
+      raise NotImplementedError
     end
 
     def shutdown
-      fail NotImplementedError
+      raise NotImplementedError
     end
   end
 end

data/lib/celluloid/group/pool.rb

@@ -1,5 +1,3 @@
-require "thread"
-
 module Celluloid
   class Group
     class Pool < Group
@@ -12,7 +10,7 @@ module Celluloid
         super
         @mutex = Mutex.new
         @idle_threads = []
-        @group  = []
+        @group = []
         @busy_size = 0
         @idle_size = 0
 

data/lib/celluloid/group/spawner.rb

@@ -1,5 +1,3 @@
-require "thread"
-
 module Celluloid
   class Group
     class Spawner < Group
@@ -11,7 +9,7 @@ module Celluloid
 
       def get(&block)
         assert_active
-        fail ArgumentError.new("No block sent to Spawner.get()") unless block_given?
+        raise ArgumentError, "No block sent to Spawner.get()" unless block_given?
         instantiate block
       end
 
@@ -52,9 +50,7 @@ module Celluloid
             Internals::Logger.crash("thread crashed", ex)
             Thread.current[:celluloid_thread_state] = :error
           ensure
-            unless Thread.current[:celluloid_thread_state] == :error
-              Thread.current[:celluloid_thread_state] = :finished
-            end
+            Thread.current[:celluloid_thread_state] = :finished unless Thread.current[:celluloid_thread_state] == :error
             @mutex.synchronize { @group.delete Thread.current }
             Thread.exit
           end

data/lib/celluloid/internals/call_chain.rb

@@ -0,0 +1,15 @@
+module Celluloid
+  module Internals
+    class CallChain
+      def self.current_id=(value)
+        Thread.current[:celluloid_chain_id] = value
+        task = Thread.current[:celluloid_task]
+        task.chain_id = value if task
+      end
+
+      def self.current_id
+        Thread.current[:celluloid_chain_id]
+      end
+    end
+  end
+end

data/lib/celluloid/internals/cpu_counter.rb

@@ -0,0 +1,62 @@
+module Celluloid
+  module Internals
+    module CPUCounter
+      class << self
+        def cores
+          @cores ||= count_cores
+        end
+
+        def count_cores
+          from_result(from_env || from_sysdev || from_java || from_proc || from_win32ole || from_sysctl) || 1
+        end
+
+        def from_env
+          result = ENV["NUMBER_OF_PROCESSORS"]
+          result if result && !result.empty?
+        rescue
+        end
+
+        def from_sysdev
+          ::IO.read("/sys/devices/system/cpu/present").split("-").last.to_i + 1
+        rescue Errno::ENOENT
+          begin
+            result = Dir["/sys/devices/system/cpu/cpu*"].count { |n| n =~ /cpu\d+/ }
+            result unless result.zero?
+          rescue
+          end
+        rescue
+        end
+
+        def from_java
+          Java::Java.lang.Runtime.getRuntime.availableProcessors if defined? Java::Java
+        rescue
+        end
+
+        def from_proc
+          File.read("/proc/cpuinfo").scan(/^processor\s*:/).size if File.exist?("/proc/cpuinfo")
+        rescue
+        end
+
+        def from_win32ole
+          require "win32ole"
+          WIN32OLE.connect("winmgmts://").ExecQuery("select * from Win32_ComputerSystem").NumberOfProcessors
+        rescue LoadError
+        rescue
+        end
+
+        def from_sysctl
+          Integer `sysctl -n hw.ncpu 2>/dev/null`
+        rescue
+        end
+
+        def from_result(result)
+          if result
+            i = Integer(result.to_s[/\d+/], 10)
+            return i if i > 0
+          end
+        rescue
+        end
+      end
+    end
+  end
+end

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