celluloid 0.16.0 → 0.17.3

data/lib/celluloid/logging/incident_logger.rb

@@ -1,129 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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/method.rb

@@ -1,32 +0,0 @@
-module Celluloid
-  # Method handles that route through an actor proxy
-  class Method
-
-    def initialize(proxy, name)
-      raise NameError, "undefined method `#{name}'" unless proxy.respond_to? name
-
-      @proxy, @name = proxy, 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::Method #{@klass}##{@name}>"
-    end
-  end
-end

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