celluloid-pool 0.10.0.pre4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c55777df2d193b1653956397ba4526b28904008d
+  data.tar.gz: eae50db2ee716efc701bb49463579332487d13a0
+SHA512:
+  metadata.gz: d1a4e00cfae73050b102f77ad35b29cc2b50ff5df6b124ad62cb34399ae155c9b2278c10baf2ce65c4e7266d0d84a463ce822956c6afd5abe14b26e2b5780e4a
+  data.tar.gz: 76ffaea263828668fc2fab44f5ec7244f91a39181d51425da935b92c6ef202c991e1da781abf55dca8ca3ccad54ba8f1ba2a5da04a4d6b7d989d7326b37c71de

data/.gitignore

@@ -0,0 +1,4 @@
+log/*
+coverage/*
+Gemfile.lock
+pkg/*

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "culture"]
+	path = culture
+	url = http://github.com/celluloid/culture.git

data/.rspec

@@ -0,0 +1,5 @@
+--color
+--format documentation
+--order random
+--warnings
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,3 @@
+inherit_from:
+  - culture/rubocop/rubocop.yml
+

data/.travis.yml

@@ -0,0 +1,32 @@
+script: bundle exec rake
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.2.0
+  - jruby
+  - ruby-head
+  - jruby-head
+  - rbx-2
+
+matrix:
+  allow_failures:
+    - rvm: rbx-2
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - env: CELLULOID_BACKPORTED=true
+
+env:
+  matrix:
+    - CELLULOID_BACKPORTED=true
+    - CELLULOID_BACKPORTED=false
+  global:
+    - NUMBER_OF_PROCESSORS=2
+
+notifications:
+  irc: "irc.freenode.org#celluloid"
+
+before_install:
+  - if [ "$TRAVIS_RUBY_VERSION" == "rbx-2" ] ; then export BUNDLE_JOBS=1 ; else export BUNDLE_JOBS=4; fi
+
+sudo: false
+install: bundle install --without=development

data/CHANGES.md

@@ -0,0 +1,4 @@
+0.8.5 (2015.04.06)
+-----
+* Initial release of very old code *as gem* separate of Celluloid.
+* Implemented `:injections` into `SupervisionGroup::Member` to resolve previous attachment requirements.

data/Gemfile

@@ -0,0 +1,24 @@
+require File.expand_path("../culture/sync", __FILE__)
+source "https://rubygems.org"
+
+gemspec #de development_group: :gem_build_tools
+
+group :development do
+  gem "pry"
+  # de gem 'guard'
+  # de gem 'guard-rspec'
+  # de gem 'rb-fsevent', '~> 0.9.1' if RUBY_PLATFORM =~ /darwin/
+end
+
+group :test do
+  gem "dotenv", "~> 2.0"
+  gem "nenv"
+  gem "benchmark_suite"
+  gem "rspec", "~> 3.2"
+end
+
+group :gem_build_tools do
+  gem "rake"
+end
+
+Celluloid::Sync.gems(self)

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Chris Heald
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,7 @@
+## Actor pools for Celluloid.
+
+[![Gem Version](https://badge.fury.io/rb/celluloid-pool.svg)](http://badge.fury.io/rb/celluloid-pool)
+
+Documentation coming.
+
+> This gem is in prerelease.

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+Dir["tasks/**/*.rake"].each { |task| load task }
+
+default_tasks = ["spec"]
+default_tasks << "rubocop" unless ENV["CI"]
+task default: default_tasks
+
+task ci: %w(spec benchmark)

data/celluloid-pool.gemspec

@@ -0,0 +1,19 @@
+# coding: utf-8
+require File.expand_path("../culture/sync", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "celluloid-pool"
+  gem.version       = "0.10.0.pre4"
+  gem.authors       = ["Tony Arcieri", "Tim Carey-Smith", "digitalextremist //"]
+  gem.email         = ["tony.arcieri@gmail.com", "code@extremist.digital"]
+
+  gem.summary       = "An implementation of an actor pool, based on the Celluloid concurrent object framework."
+  gem.description   = "An implementation of an actor pool, based on the Celluloid concurrent object framework."
+  gem.homepage      = "http://github.com/celluloid/celluloid-pool"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|examples|spec|features)/}) }
+  gem.require_paths = ["lib"]
+
+  Celluloid::Sync.gems(gem)
+end

data/lib/celluloid/pool.rb

@@ -0,0 +1,6 @@
+require "celluloid" unless defined? Celluloid
+
+require "celluloid/supervision"
+
+require "celluloid/supervision/container/pool"
+require "celluloid/supervision/container/behavior/pool"

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

@@ -0,0 +1,61 @@
+require "set"
+
+module Celluloid
+  module ClassMethods
+    # Create a new pool of workers. Accepts the following options:
+    #
+    # * size: how many workers to create. Default is worker per CPU core
+    # * args: array of arguments to pass when creating a worker
+    #
+    def pool(config={})
+      Celluloid.services.supervise(config.merge(type: Supervision::Container::Pool, args: [{workers: self}]))
+      Celluloid.services.actors.last
+    end
+
+    # Same as pool, but links to the pool manager
+    def pool_link(klass, config={})
+      Supervision::Container::Pool.new_link(
+        config.merge(args: [{workers: klass}]),
+      )
+    end
+  end
+
+  module Supervision
+    class Container
+      def pool(klass, config={})
+        Celluloid.services.supervise(config.merge(type: Container::Pool, args: [{workers: klass}]))
+        Celluloid.services.actors.last
+      end
+
+      class Instance
+        attr_accessor :pool, :pool_size
+      end
+
+      class << self
+        # Register a pool of actors to be launched on group startup
+        def pool(klass, *args, &_block)
+          blocks << lambda do |container|
+            container.pool(klass, Configuration.options(args))
+          end
+        end
+      end
+
+      class Pool
+        include Behavior
+
+        identifier! :size, :pool
+
+        configuration do
+          puts "configuring pool"
+          @supervisor = Container::Pool
+          @method = "pool_link"
+          @pool = true
+          @pool_size = @cofiguration[:size]
+          @configuration
+        end
+      end
+
+      
+    end
+  end
+end

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

@@ -0,0 +1,183 @@
+module Celluloid
+  module Supervision
+    class Container
+      # 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 Pool
+
+        include Celluloid
+
+        trap_exit :__crash_handler__
+        finalizer :__shutdown__
+
+        def initialize(options={})
+          @idle = []
+          @busy = []
+          @workers = options[:workers]
+          @args = {}
+          @size = 0
+
+          #de options = Supervision::Configuration.options(options)
+          @size = options[:size] || [Celluloid.cores || 2, 2].max
+          @args = options[:args] ? Array(options[:args]) : []
+
+          fail ArgumentError, "minimum pool size is 2" if @size < 2
+
+          # Do this last since it can suspend and/or crash
+          @idle = @size.times.map { @workers.new_link(*@args) }
+        end
+
+        def __shutdown__
+          # TODO: these can be nil if initializer crashes
+          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
+
+              # Broadcast that worker is done processing and
+              # waiting idle
+              signal :worker_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
+
+        attr_reader :size
+
+        def size=(new_size)
+          new_size = [0, new_size].max
+
+          if new_size > size
+            delta = new_size - size
+            delta.times { @idle << @workers.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?(Internals::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 << @workers.new_link(*@args)
+          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
+          @workers.instance_method(meth.to_sym)
+        end
+      end
+    end
+  end
+end

data/tasks/benchmarks.rake

@@ -0,0 +1,16 @@
+require "timeout"
+
+desc "Run Celluloid benchmarks"
+task :benchmark do
+  begin
+    Timeout.timeout(120) do
+      glob = File.expand_path("../../benchmarks/*.rb", __FILE__)
+      Dir[glob].each { |benchmark| load benchmark }
+    end
+  rescue Exception, Timeout::Error => ex
+    puts "ERROR: Couldn't complete benchmark: #{ex.class}: #{ex}"
+    puts "  #{ex.backtrace.join("\n  ")}"
+
+    exit 1 unless ENV["CI"] # Hax for running benchmarks on Travis
+  end
+end

data/tasks/rspec.rake

@@ -0,0 +1,7 @@
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+RSpec::Core::RakeTask.new(:rcov) do |task|
+  task.rcov = true
+end

data/tasks/rubocop.rake

@@ -0,0 +1,4 @@
+unless ENV["CI"]
+  require "rubocop/rake_task"
+  RuboCop::RakeTask.new
+end

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification
+name: celluloid-pool
+version: !ruby/object:Gem::Version
+  version: 0.10.0.pre4
+platform: ruby
+authors:
+- Tony Arcieri
+- Tim Carey-Smith
+- digitalextremist //
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: bundler
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rubocop
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: coveralls
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: celluloid
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: celluloid-essentials
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: celluloid-supervision
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: celluloid-fsm
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: celluloid-extras
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: timers
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: rspec-logsplit
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An implementation of an actor pool, based on the Celluloid concurrent object framework.
+email:
+- tony.arcieri@gmail.com
+- code@extremist.digital
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .gitmodules
+- .rspec
+- .rubocop.yml
+- .travis.yml
+- CHANGES.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- celluloid-pool.gemspec
+- lib/celluloid/pool.rb
+- lib/celluloid/supervision/container/behavior/pool.rb
+- lib/celluloid/supervision/container/pool.rb
+- tasks/benchmarks.rake
+- tasks/rspec.rake
+- tasks/rubocop.rake
+homepage: http://github.com/celluloid/celluloid-pool
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.6
+signing_key:
+specification_version: 4
+summary: An implementation of an actor pool, based on the Celluloid concurrent object framework.
+test_files: []