celluloid 0.16.0 → 0.17.0

data/lib/celluloid/call_chain.rb

@@ -1,13 +0,0 @@
-module Celluloid
-  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

data/lib/celluloid/cpu_counter.rb

@@ -1,34 +0,0 @@
-module Celluloid
-  module CPUCounter
-    class << self
-      def cores
-        @cores ||= count_cores
-      end
-
-      private
-
-      def count_cores
-        result = from_env || from_sysdev || from_sysctl
-        Integer(result.to_s[/\d+/], 10) if result
-      end
-
-      def from_env
-        result = ENV['NUMBER_OF_PROCESSORS']
-        result if result
-      end
-
-      def from_sysdev
-        ::IO.read('/sys/devices/system/cpu/present').split('-').last.to_i + 1
-      rescue Errno::ENOENT
-        result = Dir['/sys/devices/system/cpu/cpu*'].count { |n| n =~ /cpu\d+/ }
-        result unless result.zero?
-      end
-
-      def from_sysctl
-        result = `sysctl -n hw.ncpu`
-        result if $?.success?
-      rescue Errno::ENOENT
-      end
-    end
-  end
-end

data/lib/celluloid/evented_mailbox.rb

@@ -1,73 +0,0 @@
-module Celluloid
-  # An alternative implementation of Celluloid::Mailbox using Reactor
-  class EventedMailbox < Celluloid::Mailbox
-    attr_reader :reactor
-
-    def initialize(reactor_class)
-      super()
-      # @condition won't be used in the class.
-      @reactor = reactor_class.new
-    end
-
-    # Add a message to the Mailbox
-    def <<(message)
-      @mutex.lock
-      begin
-        if mailbox_full || @dead
-          dead_letter(message)
-          return
-        end
-        if message.is_a?(SystemEvent)
-          # SystemEvents are high priority messages so they get added to the
-          # head of our message queue instead of the end
-          @messages.unshift message
-        else
-          @messages << message
-        end
-
-        current_actor = Thread.current[:celluloid_actor]
-        @reactor.wakeup unless current_actor && current_actor.mailbox == self
-      rescue IOError
-        Logger.crash "reactor crashed", $!
-        dead_letter(message)
-      ensure
-        @mutex.unlock rescue nil
-      end
-      nil
-    end
-
-    # Receive a message from the Mailbox
-    def check(timeout = nil, &block)
-      # Get a message if it is available and process it immediately if possible:
-      if message = next_message(block)
-        return message
-      end
-
-      # ... otherwise, run the reactor once, either blocking or will return
-      # after the given timeout:
-      @reactor.run_once(timeout)
-
-      # No message was received:
-      return nil
-    rescue IOError
-      raise MailboxShutdown, "mailbox shutdown called during receive"
-    end
-
-    # Obtain the next message from the mailbox that matches the given block
-    def next_message(block)
-      @mutex.lock
-      begin
-        super(&block)
-      ensure
-        @mutex.unlock rescue nil
-      end
-    end
-
-    # Cleanup any IO objects this Mailbox may be using
-    def shutdown
-      super do
-        @reactor.shutdown
-      end
-    end
-  end
-end

data/lib/celluloid/fsm.rb

@@ -1,186 +0,0 @@
-module Celluloid
-  # Simple finite state machines with integrated Celluloid timeout support
-  # Inspired by Erlang's gen_fsm (http://www.erlang.org/doc/man/gen_fsm.html)
-  #
-  # Basic usage:
-  #
-  #     class MyMachine
-  #       include Celluloid::FSM # NOTE: this does NOT pull in the Celluloid module
-  #     end
-  #
-  # Inside an actor:
-  #
-  #     #
-  #     machine = MyMachine.new(current_actor)
-  module FSM
-    class UnattachedError < Celluloid::Error; end # Not attached to an actor
-
-    DEFAULT_STATE = :default # Default state name unless one is explicitly set
-
-    # Included hook to extend class methods
-    def self.included(klass)
-      klass.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-      # Obtain or set the default state
-      # Passing a state name sets the default state
-      def default_state(new_default = nil)
-        if new_default
-          @default_state = new_default.to_sym
-        else
-          defined?(@default_state) ? @default_state : DEFAULT_STATE
-        end
-      end
-
-      # Obtain the valid states for this FSM
-      def states
-        @states ||= {}
-      end
-
-      # Declare an FSM state and optionally provide a callback block to fire
-      # Options:
-      # * to: a state or array of states this state can transition to
-      def state(*args, &block)
-        if args.last.is_a? Hash
-          # Stringify keys :/
-          options = args.pop.inject({}) { |h,(k,v)| h[k.to_s] = v; h }
-        else
-          options = {}
-        end
-
-        args.each do |name|
-          name = name.to_sym
-          default_state name if options['default']
-          states[name] = State.new(name, options['to'], &block)
-        end
-      end
-    end
-
-    attr_reader :actor
-
-    # Be kind and call super if you must redefine initialize
-    def initialize(actor = nil)
-      @state = self.class.default_state
-      @delayed_transition = nil
-      @actor = actor
-      @actor ||= Celluloid.current_actor if Celluloid.actor?
-    end
-
-    # Obtain the current state of the FSM
-    attr_reader :state
-
-    # Attach this FSM to an actor. This allows FSMs to wait for and initiate
-    # events in the context of a particular actor
-    def attach(actor)
-      @actor = actor
-    end
-    alias_method :actor=, :attach
-
-    # Transition to another state
-    # Options:
-    # * delay: don't transition immediately, wait the given number of seconds.
-    #          This will return a Celluloid::Timer object you can use to
-    #          cancel the pending state transition.
-    #
-    # 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
-
-      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 = states[state_name]
-
-      unless new_state
-        return if state_name == default_state
-        raise ArgumentError, "invalid state for #{self.class}: #{state_name}"
-      end
-
-      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(delay) do
-          transition_with_callbacks!(new_state)
-        end
-
-        return @delayed_transition
-      end
-
-      if defined?(@delayed_transition) and @delayed_transition
-        @delayed_transition.cancel
-        @delayed_transition = nil
-      end
-    end
-
-    # FSM states as declared by Celluloid::FSM.state
-    class State
-      attr_reader :name, :transitions
-
-      def initialize(name, transitions = nil, &block)
-        @name, @block = name, block
-        @transitions = nil
-        @transitions = Array(transitions).map { |t| t.to_sym } if transitions
-      end
-
-      def call(obj)
-        obj.instance_eval(&@block) if @block
-      end
-
-      def valid_transition?(new_state)
-        # All transitions are allowed unless expressly
-        return true unless @transitions
-
-        @transitions.include? new_state.to_sym
-      end
-    end
-  end
-end

data/lib/celluloid/handlers.rb

@@ -1,41 +0,0 @@
-require 'set'
-
-module Celluloid
-  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)
-      if handler = @handlers.find { |h| h.match(message) }
-        handler.call message
-        handler
-      end
-    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

data/lib/celluloid/internal_pool.rb

@@ -1,159 +0,0 @@
-require 'thread'
-
-module Celluloid
-  # Maintain a thread pool FOR SPEED!!
-  class InternalPool
-    attr_accessor :max_idle
-
-    def initialize
-      @mutex = Mutex.new
-      @idle_threads = []
-      @all_threads  = []
-      @busy_size = 0
-      @idle_size = 0
-
-      # TODO: should really adjust this based on usage
-      @max_idle = 16
-      @running = true
-    end
-
-    def busy_size
-      @busy_size
-    end
-
-    def idle_size
-      @idle_size
-    end
-
-    def assert_running
-      raise Error, "Thread pool is not running" unless running?
-    end
-
-    def assert_inactive
-      if active?
-        message = "Thread pool is still active"
-        if defined?(JRUBY_VERSION)
-          Celluloid.logger.warn message
-        else
-          raise Error, message
-        end
-      end
-    end
-
-    def running?
-      @running
-    end
-
-    def active?
-      busy_size + idle_size > 0
-    end
-
-    def each
-      to_a.each {|thread| yield thread }
-    end
-
-    def to_a
-      @mutex.synchronize { @all_threads.dup }
-    end
-
-    # Get a thread from the pool, running the given block
-    def get(&block)
-      @mutex.synchronize do
-        assert_running
-
-        begin
-          if @idle_threads.empty?
-            thread = create
-          else
-            thread = @idle_threads.pop
-            @idle_size = @idle_threads.length
-          end
-        end until thread.status # handle crashed threads
-
-        thread.busy = true
-        @busy_size += 1
-        thread[:celluloid_queue] << block
-        thread
-      end
-    end
-
-    # Return a thread to the pool
-    def put(thread)
-      @mutex.synchronize do
-        thread.busy = false
-        if idle_size + 1 >= @max_idle
-          thread[:celluloid_queue] << nil
-          @busy_size -= 1
-          @all_threads.delete(thread)
-        else
-          @idle_threads.push thread
-          @busy_size -= 1
-          @idle_size = @idle_threads.length
-          clean_thread_locals(thread)
-        end
-      end
-    end
-
-    def shutdown
-      @mutex.synchronize do
-        finalize
-        @all_threads.each do |thread|
-          thread[:celluloid_queue] << nil
-        end
-        @all_threads.clear
-        @idle_threads.clear
-        @busy_size = 0
-        @idle_size = 0
-      end
-    end
-
-    def kill
-      @mutex.synchronize do
-        finalize
-        @running = false
-
-        @all_threads.shift.kill until @all_threads.empty?
-        @idle_threads.clear
-        @busy_size = 0
-        @idle_size = 0
-      end
-    end
-
-    private
-
-    # 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[:celluloid_queue] = queue
-      # @idle_threads << thread
-      @all_threads << thread
-      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
-
-    def finalize
-      @max_idle = 0
-    end
-  end
-end