celluloid 0.16.0 → 0.17.0

data/lib/celluloid/notifications.rb

@@ -1,83 +0,0 @@
-module Celluloid
-  module Notifications
-    def self.notifier
-      Actor[:notifications_fanout] or raise DeadActorError, "notifications fanout actor not running"
-    end
-
-    def publish(pattern, *args)
-      Celluloid::Notifications.notifier.publish(pattern, *args)
-    end
-
-    def subscribe(pattern, method)
-      Celluloid::Notifications.notifier.subscribe(Actor.current, pattern, method)
-    end
-
-    def unsubscribe(*args)
-      Celluloid::Notifications.notifier.unsubscribe(*args)
-    end
-
-    class Fanout
-      include Celluloid
-      trap_exit :prune
-
-      def initialize
-        @subscribers = []
-        @listeners_for = {}
-      end
-
-      def subscribe(actor, pattern, method)
-        subscriber = Subscriber.new(actor, pattern, method).tap do |s|
-          @subscribers << s
-        end
-        link actor
-        @listeners_for.clear
-        subscriber
-      end
-
-      def unsubscribe(subscriber)
-        @subscribers.reject! { |s| s.matches?(subscriber) }
-        @listeners_for.clear
-      end
-
-      def publish(pattern, *args)
-        listeners_for(pattern).each { |s| s.publish(pattern, *args) }
-      end
-
-      def listeners_for(pattern)
-        @listeners_for[pattern] ||= @subscribers.select { |s| s.subscribed_to?(pattern) }
-      end
-
-      def listening?(pattern)
-        listeners_for(pattern).any?
-      end
-
-      def prune(actor, reason=nil)
-        @subscribers.reject! { |s| s.actor == actor }
-        @listeners_for.clear
-      end
-    end
-
-    class Subscriber
-      attr_accessor :actor, :pattern, :method
-
-      def initialize(actor, pattern, method)
-        @actor = actor
-        @pattern = pattern
-        @method = method
-      end
-
-      def publish(pattern, *args)
-        actor.async method, pattern, *args
-      end
-
-      def subscribed_to?(pattern)
-        !pattern || @pattern === pattern.to_s
-      end
-
-      def matches?(subscriber_or_pattern)
-        self === subscriber_or_pattern ||
-          @pattern && @pattern === subscriber_or_pattern
-      end
-    end
-  end
-end

data/lib/celluloid/pool_manager.rb

@@ -1,146 +0,0 @@
-require 'set'
-
-module Celluloid
-  # Manages a fixed-size pool of workers
-  # Delegates work (i.e. methods) and supervises workers
-  # Don't use this class directly. Instead use MyKlass.pool
-  class PoolManager
-    include Celluloid
-    trap_exit :__crash_handler__
-    finalizer :__shutdown__
-
-    def initialize(worker_class, options = {})
-      @size = options[:size] || [Celluloid.cores || 2, 2].max
-      raise ArgumentError, "minimum pool size is 2" if @size < 2
-
-      @worker_class = worker_class
-      @args = options[:args] ? Array(options[:args]) : []
-
-      @idle = @size.times.map { worker_class.new_link(*@args) }
-
-      # FIXME: Another data structure (e.g. Set) would be more appropriate
-      # here except it causes MRI to crash :o
-      @busy = []
-    end
-
-    def __shutdown__
-      terminators = (@idle + @busy).map do |actor|
-        begin
-          actor.future(:terminate)
-        rescue DeadActorError
-        end
-      end
-
-      terminators.compact.each { |terminator| terminator.value rescue nil }
-    end
-
-    def _send_(method, *args, &block)
-      worker = __provision_worker__
-
-      begin
-        worker._send_ method, *args, &block
-      rescue DeadActorError # if we get a dead actor out of the pool
-        wait :respawn_complete
-        worker = __provision_worker__
-        retry
-      rescue Exception => ex
-        abort ex
-      ensure
-        if worker.alive?
-          @idle << worker
-          @busy.delete worker
-        end
-      end
-    end
-
-    def name
-      _send_ @mailbox, :name
-    end
-
-    def is_a?(klass)
-      _send_ :is_a?, klass
-    end
-
-    def kind_of?(klass)
-      _send_ :kind_of?, klass
-    end
-
-    def methods(include_ancestors = true)
-      _send_ :methods, include_ancestors
-    end
-
-    def to_s
-      _send_ :to_s
-    end
-
-    def inspect
-      _send_ :inspect
-    end
-
-    def size
-      @size
-    end
-
-    def size=(new_size)
-      new_size = [0, new_size].max
-
-      if new_size > size
-        delta = new_size - size
-        delta.times { @idle << @worker_class.new_link(*@args) }
-      else
-        (size - new_size).times do
-          worker = __provision_worker__
-          unlink worker
-          @busy.delete worker
-          worker.terminate
-        end
-      end
-      @size = new_size
-    end
-
-    def busy_size
-      @busy.length
-    end
-
-    def idle_size
-      @idle.length
-    end
-
-    # Provision a new worker
-    def __provision_worker__
-      Task.current.guard_warnings = true
-      while @idle.empty?
-        # Wait for responses from one of the busy workers
-        response = exclusive { receive { |msg| msg.is_a?(Response) } }
-        Thread.current[:celluloid_actor].handle_message(response)
-      end
-
-      worker = @idle.shift
-      @busy << worker
-
-      worker
-    end
-
-    # Spawn a new worker for every crashed one
-    def __crash_handler__(actor, reason)
-      @busy.delete actor
-      @idle.delete actor
-      return unless reason
-
-      @idle << @worker_class.new_link(*@args)
-      signal :respawn_complete
-    end
-
-    def respond_to?(method, include_private = false)
-      super || @worker_class.instance_methods.include?(method.to_sym)
-    end
-
-    def method_missing(method, *args, &block)
-      if respond_to?(method)
-        _send_ method, *args, &block
-      else
-        super
-      end
-    end
-  end
-end

data/lib/celluloid/probe.rb

@@ -1,73 +0,0 @@
-require 'celluloid'
-
-$CELLULOID_MONITORING = true
-
-module Celluloid
-  class Probe
-    include Celluloid
-    include Celluloid::Notifications
-
-    NOTIFICATIONS_TOPIC_BASE = 'celluloid.events.%s'
-    INITIAL_EVENTS = Queue.new
-
-    class << self
-      def run
-        # spawn the actor if not found
-        supervise_as(:probe_actor) unless Actor[:probe_actor] && Actor[:probe_actor].alive?
-      end
-
-      def actor_created(actor)
-        trigger_event(:actor_created, actor)
-      end
-
-      def actor_named(actor)
-        trigger_event(:actor_named, actor)
-      end
-
-      def actor_died(actor)
-        trigger_event(:actor_died, actor)
-      end
-
-      def actors_linked(a, b)
-        a = find_actor(a)
-        b = find_actor(b)
-        trigger_event(:actors_linked, a, b)
-      end
-
-      private
-
-      def trigger_event(name, *args)
-        return unless $CELLULOID_MONITORING
-        probe_actor = Actor[:probe_actor]
-        if probe_actor
-          probe_actor.async.dispatch_event(name, args)
-        else
-          INITIAL_EVENTS << [name, args]
-        end
-      end
-
-      def find_actor(obj)
-        if obj.__send__(:class) == Actor
-          obj
-        elsif owner = obj.instance_variable_get(OWNER_IVAR)
-          owner
-        end
-      end
-    end
-
-    def initialize
-      async.first_run
-    end
-
-    def first_run
-      until INITIAL_EVENTS.size == 0
-        event = INITIAL_EVENTS.pop
-        dispatch_event(*event)
-      end
-    end
-
-    def dispatch_event(cmd, args)
-      publish(NOTIFICATIONS_TOPIC_BASE % cmd, args)
-    end
-  end
-end

data/lib/celluloid/properties.rb

@@ -1,24 +0,0 @@
-module Celluloid
-  # 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
-
-      ancestors.first.send(:define_singleton_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

data/lib/celluloid/proxies/abstract_proxy.rb

@@ -1,20 +0,0 @@
-module Celluloid
-  # Base class of all Celluloid proxies
-  class AbstractProxy < BasicObject
-    # Used for reflecting on proxy objects themselves
-    def __class__; AbstractProxy; end
-
-    # Needed for storing proxies in data structures
-    needed = [:object_id, :__id__, :hash] - instance_methods
-    if needed.any?
-      include ::Kernel.dup.module_eval {
-        undef_method(*(instance_methods - needed))
-        self
-      }
-
-      # rubinius bug?  These methods disappear when we include hacked kernel
-      define_method :==, ::BasicObject.instance_method(:==) unless instance_methods.include?(:==)
-      alias_method(:equal?, :==) unless instance_methods.include?(:equal?)
-    end
-  end
-end

data/lib/celluloid/proxies/actor_proxy.rb

@@ -1,38 +0,0 @@
-module Celluloid
-  # A proxy which controls the Actor lifecycle
-  class ActorProxy < AbstractProxy
-    attr_reader :thread, :mailbox
-
-    # Used for reflecting on proxy objects themselves
-    def __class__; ActorProxy; end
-
-    def initialize(thread, mailbox)
-      @thread = thread
-      @mailbox = mailbox
-    end
-
-    def inspect
-      # TODO: use a system event to fetch actor state: tasks?
-      "#<Celluloid::ActorProxy(#{@mailbox.address}) alive>"
-    rescue DeadActorError
-      "#<Celluloid::ActorProxy(#{@mailbox.address}) dead>"
-    end
-
-    def alive?
-      @mailbox.alive?
-    end
-
-    # Terminate the associated actor
-    def terminate
-      terminate!
-      Actor.join(self)
-      nil
-    end
-
-    # Terminate the associated actor asynchronously
-    def terminate!
-      ::Kernel.raise DeadActorError, "actor already terminated" unless alive?
-      @mailbox << TerminationRequest.new
-    end
-  end
-end

data/lib/celluloid/proxies/async_proxy.rb

@@ -1,31 +0,0 @@
-module Celluloid
-  # A proxy which sends asynchronous calls to an actor
-  class AsyncProxy < AbstractProxy
-    attr_reader :mailbox
-
-    # Used for reflecting on proxy objects themselves
-    def __class__; AsyncProxy; end
-
-    def initialize(mailbox, klass)
-      @mailbox, @klass = mailbox, klass
-    end
-
-    def inspect
-      "#<Celluloid::AsyncProxy(#{@klass})>"
-    end
-
-    def method_missing(meth, *args, &block)
-      if @mailbox == ::Thread.current[:celluloid_mailbox]
-        args.unshift meth
-        meth = :__send__
-      end
-
-      if block_given?
-        # FIXME: nicer exception
-        raise "Cannot use blocks with async yet"
-      end
-
-      @mailbox << AsyncCall.new(meth, args, block)
-    end
-  end
-end

data/lib/celluloid/proxies/block_proxy.rb

@@ -1,29 +0,0 @@
-module Celluloid
-  class BlockProxy
-    def initialize(call, mailbox, block)
-      @call = call
-      @mailbox = mailbox
-      @block = block
-      @execution = :sender
-    end
-    attr_writer :execution
-    attr_reader :call, :block
-
-    def to_proc
-      if @execution == :sender
-        lambda do |*values|
-          if task = Thread.current[:celluloid_task]
-            @mailbox << BlockCall.new(self, Actor.current.mailbox, values)
-            # TODO: if respond fails, the Task will never be resumed
-            task.suspend(:invokeblock)
-          else
-            # FIXME: better exception
-            raise "No task to suspend"
-          end
-        end
-      else
-        @block
-      end
-    end
-  end
-end