celluloid 0.18.0.pre → 0.18.0.pre2

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

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

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

@@ -0,0 +1,113 @@
+module Celluloid
+  module Supervision
+    class Configuration
+      class Instance
+        attr_accessor :configuration
+
+        def initialize(configuration = {})
+          @state = :initializing # :ready
+          resync_accessors
+          @configuration = configuration
+          define(configuration) if configuration.any?
+        end
+
+        def export
+          @configuration.reject { |k, _v| REMOVE_AT_EXPORT.include? k }
+        end
+
+        def ready?(fail = false)
+          unless @state == :ready
+            @state = :ready if Configuration.valid? @configuration, fail
+          end
+          @state == :ready
+        end
+
+        def define(instance, fail = false)
+          raise Configuration::Error::AlreadyDefined if ready? fail
+          invoke_injection(:before_configuration)
+          @configuration = Configuration.options(instance)
+          ready?
+        end
+
+        def injection!(key, proc)
+          @configuration[:injections] ||= {}
+          @configuration[:injections][key] = proc
+        end
+
+        def injections!(_procs)
+          @configuration[:injections] = proces
+        end
+
+        def resync_accessors
+          # methods for setting and getting the usual defaults
+          Configuration.parameters(:mandatory, :optional, :plugins, :meta).each do |key|
+            self.class.instance_eval do
+              remove_method :"#{key}!" rescue nil # avoid warnings in tests
+              define_method(:"#{key}!") { |value| @configuration[key] = value }
+            end
+            self.class.instance_eval do
+              remove_method :"#{key}=" rescue nil # avoid warnings in tests
+              define_method(:"#{key}=") { |value| @configuration[key] = value }
+            end
+            self.class.instance_eval do
+              remove_method :"#{key}?" rescue nil # avoid warnings in tests
+              define_method(:"#{key}?") { !@configuration[key].nil? }
+            end
+            self.class.instance_eval do
+              remove_method :"#{key}" rescue nil # avoid warnings in tests
+              define_method(:"#{key}") { @configuration[key] }
+            end
+          end
+
+          Configuration.aliases.each do |_alias, _original|
+            ["!", :"=", :"?", :""]. each do |m|
+              self.class.instance_eval do
+                remove_method :"#{_alias}#{m}" rescue nil # avoid warnings in tests
+                alias_method :"#{_alias}#{m}", :"#{_original}#{m}"
+              end
+            end
+          end
+          true
+        end
+
+        def merge!(values)
+          @configuration = @configuration.merge(values)
+        end
+
+        def merge(values)
+          if values.is_a? Configuration
+            @configuration.merge(values.configuration)
+          elsif values.is_a? Hash
+            @configuration.merge(values)
+          else
+            raise Error::Invalid
+          end
+        end
+
+        def key?(k)
+          @configuration.key?(k)
+        end
+
+        def set(key, value)
+          @configuration[key] = value
+        end
+        alias []= set
+
+        def get(key)
+          @configuration[key]
+        end
+        alias [] get
+
+        def delete(k)
+          @configuration.delete(k)
+        end
+
+        private
+
+        def invoke_injection(_point)
+          # de puts "injection? #{point}"
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/supervision/constants.rb

@@ -0,0 +1,123 @@
+module Celluloid
+  module Supervision
+    # TODO: Do not hard-code. Allow configurable values.
+    INSTANCE_RETRY_WAIT = 3
+    INSTANCE_RETRY_LIMIT = 5
+
+    module Error
+      class NoPublicService < Celluloid::Error; end
+    end
+
+    class Configuration
+      module Error
+        class AlreadyDefined < Celluloid::Error; end
+        class InvalidSupervisor < Celluloid::Error; end
+        class InvalidValues < Celluloid::Error; end
+        class Incomplete < Celluloid::Error; end
+        class Invalid < Celluloid::Error; end
+      end
+
+      # Using class variable so that parameters can be added by plugins.
+
+      @@parameters = {
+
+        mandatory: [:type],
+
+        optional: %i[
+          as
+          args
+          block
+        ],
+
+        # TODO: Move these into Behaviors.
+        plugins: [
+          # de :size,        # Supervision::Pool
+          # de :routers,     # Supervision::Coordinator
+          # de :supervises   # Supervision::Tree
+        ],
+
+        meta: %i[
+          registry
+          branch
+          method
+        ]
+      }
+
+      @@arity = {
+        type: :args
+      }
+
+      @@aliases = {
+        name: :as,
+        kind: :type,
+        # de :pool => :size,   # TODO: Move into Behaviors.
+        # de :supervise => :supervises
+      }
+
+      @@defaults = {}
+
+      class << self
+        def save_defaults
+          @@defaults = {
+            parameters: @@parameters.each_with_object({}) { |(k, v), p| p[k] = v.dup; },
+            aliases: @@aliases.dup,
+            arity: @@arity.dup
+          }
+        end
+
+        def resync_parameters
+          @@parameters = @@defaults[:parameters].each_with_object({}) { |(k, v), p| p[k] = v.dup; }
+          @@aliases = @@defaults[:aliases].dup
+          @@arity = @@defaults[:arity].dup
+        end
+
+        def parameters(*args)
+          args.inject([]) { |parameters, p| parameters += @@parameters[p]; parameters }
+        end
+
+        def parameter!(key, value)
+          @@parameters[key] << value unless @@parameters[key].include? value
+        end
+
+        def arity
+          @@arity
+        end
+
+        def arity!(key, value)
+          @@arity[key] = value
+        end
+
+        def aliases
+          @@aliases
+        end
+
+        def alias!(aliased, original)
+          @@aliases[aliased] = original
+        end
+      end
+
+      save_defaults
+      resync_parameters
+
+      # This was originally added for `#pool` and `PoolManager
+      # `:before_initialize` was added to allow detecting `:size => N`
+      # and turning that into a pool. Other uses could be for `coordinator`
+      # appointing a `router` by detecting `:routers => N`, and many other uses.
+
+      ################ These are applied inside Supervision::Member ################
+
+      REMOVE_AT_EXPORT = %i[
+        configuration
+        behavior
+      ].freeze
+
+      INJECTIONS = %i[
+        configuration
+        before_initialization
+        after_initialization
+        before_start
+        before_restart
+      ].freeze
+    end
+  end
+end

data/lib/celluloid/supervision/container.rb

@@ -0,0 +1,144 @@
+module Celluloid
+  # Supervise actor instances in a container.
+  module Supervision
+    class Container
+      include Celluloid
+
+      trap_exit :restart_actor
+
+      class << self
+        def define(options)
+          Configuration.define(top(options))
+        end
+
+        def deploy(options)
+          Configuration.deploy(top(options))
+        end
+
+        def top(options)
+          {
+            as: options.delete(:as),
+            type: (options.delete(:type) || self),
+            branch: (options.delete(:branch) || :services),
+            supervise: options.delete(:supervise) || []
+          }
+        end
+
+        # Actors or sub-applications to be supervised
+        def blocks
+          @blocks ||= []
+        end
+
+        # Start this application (and watch it with a supervisor)
+        def run!(options = {})
+          container = new(options) do |g|
+            blocks.each do |block|
+              block.call(g)
+            end
+          end
+          container
+        end
+
+        # Run the application in the foreground with a simple watchdog
+        def run(options = {})
+          loop do
+            supervisor = run!(options)
+
+            # Take five, toplevel supervisor
+            sleep 5 while supervisor.alive? # Why 5?
+
+            Internals::Logger.error "!!! Celluloid::Supervision::Container #{self} crashed. Restarting..."
+          end
+        end
+      end
+
+      finalizer :finalize
+
+      attr_accessor :registry
+
+      # Start the container.
+      def initialize(options = {})
+        options = { registry: options } if options.is_a? Internals::Registry
+        @state = :initializing
+        @actors = [] # instances in the container
+        @registry = options.delete(:registry) || Celluloid.actor_system.registry
+        @branch = options.delete(:branch) || :services
+        yield current_actor if block_given?
+      end
+
+      execute_block_on_receiver :initialize, :supervise, :supervise_as
+
+      def add(configuration)
+        Configuration.valid?(configuration, true)
+        @actors << Instance.new(configuration.merge(registry: @registry, branch: @branch))
+        @state = :running
+        add_accessors configuration
+        Actor.current
+      end
+
+      def add_accessors(configuration)
+        if configuration[:as]
+          unless methods.include? configuration[:as]
+            self.class.instance_eval do
+              define_method(configuration[:as]) do
+                @registry[configuration[:as]]
+              end
+            end
+          end
+        end
+      end
+
+      def remove_accessors; end
+
+      def remove(actor)
+        actor = Celluloid::Actor[actor] if actor.is_a? Symbol
+        instance = find(actor)
+        instance.terminate if instance
+      end
+
+      def actors
+        @actors.map(&:actor)
+      end
+
+      def find(actor)
+        @actors.find do |instance|
+          instance.actor == actor
+        end
+      end
+
+      def [](actor_name)
+        @registry[actor_name]
+      end
+
+      # Restart a crashed actor
+      def restart_actor(actor, reason)
+        return if @state == :shutdown
+        instance = find(actor)
+        raise "a container instance went missing. This shouldn't be!" unless instance
+
+        if reason
+          exclusive { instance.restart }
+        else
+          instance.cleanup
+          @actors.delete(instance)
+        end
+      end
+
+      def shutdown
+        @state = :shutdown
+        finalize
+      end
+
+      private
+
+      def finalize
+        if @actors
+          @actors.reverse_each do |instance|
+            instance.terminate
+            @actors.delete(instance)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+module Celluloid
+  module Supervision
+    class Container
+      module Behavior
+        @@injections = {}  # Hash of Class => Hash of Injections
+        @@behaviors = {}   # Hash of identifying symbol parameter => Class
+
+        module Error
+          class Mutant < Celluloid::Error; end
+        end
+
+        class << self
+          def included(klass)
+            klass.send :extend, ClassMethods
+          end
+
+          def injections
+            @@injections
+          end
+
+          def [](identifier)
+            @@behaviors[identifier]
+          end
+
+          def []=(identifier, behavior)
+            @@behaviors[identifier] = behavior
+          end
+
+          def parameter(identifier, options)
+            found = nil
+            p = Configuration.aliases.each_with_object([identifier]) { |(a, i), invoke| invoke << a if i == identifier; }
+            case p.count { |parameter| found = parameter; options.key?(parameter) }
+            when 1
+              found
+            when 0
+
+            else
+              raise Error::Mutant, "More than one kind of identifiable behavior parameter."
+            end
+          end
+
+          # Beware of order. There may be multiple behavior injections, but their order is not determined ( yet )
+          # Right now, something like a pool-coordinator-tree supervisor mutant are absolutely expected to crash.
+          # Therefore, sorry Professor X -- we kill every Mutant. On sight, no questions asked. Zero mutant love.
+          def configure(options)
+            behavior = nil
+            injection = nil
+            @@behaviors.map do |identifier, injector|
+              if identifier = parameter(identifier, options)
+                if behavior
+                  raise Error::Mutant, "More than one type of behavior expected."
+                else
+                  if @@injections[injector].include?(:configuration)
+                    injection = @@injections[behavior = injector][:configuration]
+                    options[:behavior] ||= behavior
+                  end
+                end
+              end
+            end
+
+            options[:type] ||= behavior
+            injection || proc { @configuration }
+          end
+
+          module ClassMethods
+            def identifier!(identifier, *aliases)
+              Behavior[identifier] = self
+              Configuration.parameter! :plugins, identifier
+              aliases.each do |aliased|
+                Configuration.alias! aliased, identifier
+              end
+              Configuration.save_defaults
+            end
+
+            def behavior_injections
+              Behavior.injections[self] ||= {}
+            end
+
+            Configuration::INJECTIONS.each do |point|
+              define_method(point) do |&injector|
+                behavior_injections[point] = injector
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end