celluloid 0.18.0.pre → 0.18.0

data/lib/celluloid/supervision/container/injections.rb

@@ -0,0 +1,8 @@
+module Celluloid
+  module Supervision
+    class Container
+      class Injection
+      end
+    end
+  end
+end

data/lib/celluloid/supervision/container/instance.rb

@@ -0,0 +1,116 @@
+module Celluloid
+  # Supervise collections of actors as a group
+  module Supervision
+    class Container
+      class Instance
+        attr_reader :name, :actor
+
+        # @option options [#call, Object] :args ([]) arguments array for the
+        #   actor's constructor (lazy evaluation if it responds to #call)
+        def initialize(configuration = {})
+          @type = configuration.delete(:type)
+          @registry = configuration.delete(:registry)
+          @branch = configuration.delete(:branch) || :services
+          @configuration = configuration
+
+          # allows injections inside initialize, start, and restart
+          @injections = configuration.delete(:injections) || {}
+          invoke_injection(:before_initialize)
+
+          # Stringify keys :/
+          # de @configuration = configuration.each_with_object({}) { |(k,v), h| h[k.to_s] = v }
+
+          @name = @configuration[:as]
+          @block = @configuration[:block]
+          @args = prepare_args(@configuration[:args])
+          @method = @configuration[:method] || "new_link"
+          add_accessors
+          invoke_injection(:after_initialize)
+          start
+        end
+
+        def start
+          invoke_injection(:before_start)
+          @actor = @type.send(@method, *@args, &@block)
+          @registry.add(@name, @actor, @branch) if @name
+          invoke_injection(:after_start)
+        rescue Celluloid::TaskTimeout => ex
+          Internals::Logger.error("TaskTimeout at start of supervised instance of #{@type}")
+          raise ex
+          # TODO: Implement timeout/retry(?)
+        rescue => ex
+          Internals::Logger.error("Error ( #{ex.class} ) at start of supervised instance of #{@type}")
+          raise ex
+        end
+
+        def restart
+          # no need to reset @actor, as this is called in an `exclusive {}` block
+          # @actor = nil
+          # cleanup
+          invoke_injection(:before_restart)
+          start
+          invoke_injection(:after_restart)
+        end
+
+        def terminate
+          @actor.terminate if @actor
+          cleanup
+        rescue DeadActorError
+        end
+
+        def cleanup
+          @registry.delete(@name) if @name
+        end
+
+        private
+
+        def add_accessors
+          remove_accessors
+          if @configuration[:accessors].is_a? Array
+            # TODO: Decide which level to keep, and only keep that.
+            #       Do we provide access by Celluloid.accessor
+            #       Do we provide access by Celluloid.actor_system.accessor
+            @configuration[:accessors].each do |name|
+              Celluloid.instance_exec(@configuration[:as], name) do |actor, _where|
+                define_method(name) do
+                  Celluloid.actor_system[actor]
+                end
+              end
+              Celluloid::Actor::System.instance_exec(@configuration[:as], name) do |actor, _where|
+                define_method(name) do
+                  Celluloid.actor_system[actor]
+                end
+              end
+            end
+          end
+        end
+
+        def remove_accessors
+          if @configuration[:accessors].is_a? Array
+            @configuration[:accessors].each do |name|
+              Celluloid.instance_eval do
+                remove_method(name) rescue nil # avoid warnings in tests
+              end
+              Celluloid::Actor::System.instance_eval do
+                remove_method(name) rescue nil # avoid warnings in tests
+              end
+            end
+          end
+        end
+
+        def invoke_injection(name)
+          return unless @injections
+          block = @injections[name]
+          instance_eval(&block) if block.is_a? Proc
+        end
+
+        # Executes args if it has the method #call, and converts the return
+        # value to an Array. Otherwise, it just converts it to an Array.
+        def prepare_args(args)
+          args = args.call if args.respond_to?(:call)
+          Array(args)
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/supervision/container/pool.rb

@@ -0,0 +1,210 @@
+module Celluloid
+  module Supervision
+    class Container
+      # Manages a fixed-size pool of actors
+      # Delegates work (i.e. methods) and supervises actors
+      # Don't use this class directly. Instead use MyKlass.pool
+      class Pool
+        include Celluloid
+
+        trap_exit :__crash_handler__
+        finalizer :__shutdown__
+
+        attr_reader :size, :actors
+
+        def initialize(options = {})
+          @idle = []
+          @busy = []
+          @klass = options[:actors]
+          @actors = Set.new
+          @mutex = Mutex.new
+
+          @size = options[:size] || [Celluloid.cores || 2, 2].max
+          @args = options[:args] ? Array(options[:args]) : []
+
+          # Do this last since it can suspend and/or crash
+          @idle = @size.times.map { __spawn_actor__ }
+        end
+
+        def __shutdown__
+          return unless defined?(@actors) && @actors
+          # TODO: these can be nil if initializer crashes
+          terminators = @actors.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)
+          actor = __provision_actor__
+          begin
+            actor._send_ method, *args, &block
+          rescue DeadActorError # if we get a dead actor out of the pool
+            wait :respawn_complete
+            actor = __provision_actor__
+            retry
+          rescue ::Exception => ex
+            abort ex
+          ensure
+            if actor.alive?
+              @idle << actor
+              @busy.delete actor
+
+              # Broadcast that actor is done processing and
+              # waiting idle
+              signal :actor_idle
+            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=(new_size)
+          new_size = [0, new_size].max
+          if new_size > size
+            delta = new_size - size
+            delta.times { @idle << __spawn_actor__ }
+          else
+            (size - new_size).times do
+              actor = __provision_actor__
+              unlink actor
+              @busy.delete actor
+              @actors.delete actor
+              actor.terminate
+            end
+          end
+          @size = new_size
+        end
+
+        def busy_size
+          @mutex.synchronize { @busy.length }
+        end
+
+        def idle_size
+          @mutex.synchronize { @idle.length }
+        end
+
+        def __idle?(actor)
+          @mutex.synchronize { @idle.include? actor }
+        end
+
+        def __busy?(actor)
+          @mutex.synchronize { @busy.include? actor }
+        end
+
+        def __busy
+          @mutex.synchronize { @busy }
+        end
+
+        def __idle
+          @mutex.synchronize { @idle }
+        end
+
+        def __state(actor)
+          return :busy if __busy?(actor)
+          return :idle if __idle?(actor)
+          :missing
+        end
+
+        # Instantiate an actor, add it to the actor Set, and return it
+        def __spawn_actor__
+          actor = @klass.new_link(*@args)
+          @mutex.synchronize { @actors.add(actor) }
+          @actors.add(actor)
+          actor
+        end
+
+        # Provision a new actor ( take it out of idle, move it into busy, and avail it )
+        def __provision_actor__
+          Task.current.guard_warnings = true
+          @mutex.synchronize do
+            while @idle.empty?
+              # Wait for responses from one of the busy actors
+              response = exclusive { receive { |msg| msg.is_a?(Internals::Response) } }
+              Thread.current[:celluloid_actor].handle_message(response)
+            end
+
+            actor = @idle.shift
+            @busy << actor
+            actor
+          end
+        end
+
+        # Spawn a new worker for every crashed one
+        def __crash_handler__(actor, reason)
+          @busy.delete actor
+          @idle.delete actor
+          @actors.delete actor
+          return unless reason
+          @idle << __spawn_actor__
+          signal :respawn_complete
+        end
+
+        def respond_to?(meth, include_private = false)
+          # NOTE: use method() here since this class
+          # shouldn't be used directly, and method() is less
+          # likely to be "reimplemented" inconsistently
+          # with other Object.*method* methods.
+
+          found = method(meth)
+          if include_private
+            found ? true : false
+          else
+            if found.is_a?(UnboundMethod)
+              found.owner.public_instance_methods.include?(meth) ||
+                found.owner.protected_instance_methods.include?(meth)
+            else
+              found.receiver.public_methods.include?(meth) ||
+                found.receiver.protected_methods.include?(meth)
+            end
+          end
+        rescue NameError
+          false
+        end
+
+        def method_missing(method, *args, &block)
+          if respond_to?(method)
+            _send_ method, *args, &block
+          else
+            super
+          end
+        end
+
+        # Since Pool allocates worker objects only just before calling them,
+        # we can still help Celluloid::Call detect passing invalid parameters to
+        # async methods by checking for those methods on the worker class
+        def method(meth)
+          super
+        rescue NameError
+          @klass.instance_method(meth.to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/supervision/service.rb

@@ -0,0 +1,27 @@
+module Celluloid
+  module Supervision
+    module Service
+      class Root < Container
+        class << self
+          def define
+            super({
+              supervise: Celluloid.actor_system.root_configuration,
+              as: :root_supervisor,
+              accessors: [:root],
+              branch: :root,
+              type: self
+            })
+          end
+
+          def deploy(instances)
+            super(supervise: instances, branch: :root, as: :root, type: self)
+          end
+        end
+        def provider
+          Celluloid.root_services
+        end
+      end
+      class Public < Container; end
+    end
+  end
+end

data/lib/celluloid/supervision/supervise.rb

@@ -0,0 +1,34 @@
+# collect together all instances of the `supervise` method
+module Celluloid
+  class << self
+    def supervise(config = {}, &block)
+      supervisor = Supervision.router(config)
+      supervisor.supervise(config, &block)
+    end
+  end
+  module ClassMethods
+    def supervise(config = {}, &block)
+      Celluloid.supervise(config.merge(type: self), &block)
+    end
+  end
+  module Supervision
+    class << self
+      def router(_config = {})
+        # TODO: Actually route.
+        Celluloid.services # for now, hardcode .services
+      end
+    end
+    class Container
+      class << self
+        def supervise(config, &block)
+          blocks << lambda do |container|
+            container.add(config, &block)
+          end
+        end
+      end
+      def supervise(config, &block)
+        add(Configuration.options(config, block: block))
+      end
+    end
+  end
+end

data/lib/celluloid/supervision/validation.rb

@@ -0,0 +1,40 @@
+module Celluloid
+  module Supervision
+    class Configuration
+      class << self
+        def valid?(configuration, fails = false)
+          parameters(:mandatory).each do |k|
+            unless configuration.key? k
+              if fails
+                raise Error::Incomplete, "Missing `:#{k}` in supervision configuration."
+              else
+                return false
+              end
+            end
+          end
+          arity.each do |klass, args|
+            next if configuration[args].is_a? Proc
+            __a = configuration[args] && configuration[args].count || 0
+            __arity = configuration[klass].allocate.method(:initialize).arity
+            unless (__arity < 0 && __a >= __arity.abs - 1) || __a == __arity.abs
+              if fails
+                raise ArgumentError, "#{__a} vs. #{__arity}"
+              else
+                return false
+              end
+            end
+          end
+          true
+        end
+
+        def options(config = {}, options = {})
+          configuration = config.merge(options)
+          return configuration if configuration.is_a? Configuration
+          configuration[:configuration] = Container::Behavior.configure(configuration)
+          valid?(configuration, true)
+          configuration
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/supervision/version.rb

@@ -0,0 +1,5 @@
+module Celluloid
+  module Supervision
+    VERSION = "0.20.6".freeze
+  end
+end