forkomatic 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov"
+  gem "rdoc"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Jon Durbin
+
+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.rdoc

@@ -0,0 +1,19 @@
+= forkomatic
+
+Description goes here.
+
+== Contributing to forkomatic
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Jon Durbin. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "forkomatic"
+  gem.homepage = "http://github.com/gdi/forkomatic"
+  gem.license = "MIT"
+  gem.summary = %Q{Easily run multiple processes continuously in parallel.}
+  gem.description = %Q{Easily create parallel processes to do work.  The process count can be dynamic (between min_children and max_children), can loop continuously (by setting max_iterations => nil), etc}
+  gem.email = "jond@greenviewdata.com"
+  gem.authors = ["Jon Durbin"]
+  gem.version = '0.0.1'
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "forkomatic #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/forkomatic.rb

@@ -0,0 +1,145 @@
+class Forkomatic
+  class Job
+    attr_accessor :pid
+
+    def initialize
+      self.pid = nil
+    end
+
+    def work!
+      sleep 1
+    end
+  end
+
+  attr_accessor :max_children
+  attr_accessor :work_interval
+  attr_accessor :max_iterations
+  attr_accessor :jobs
+  attr_accessor :wait_for_children
+
+  # Initialize the runners.
+  def initialize(args)
+    params = {}
+    if args.is_a?(String)
+      # Load config from a file.
+      params = load_config(args)
+    elsif args.is_a?(Integer)
+      # Given an integer, forkomatic will only run N runners 1 time.
+      params[:wait_for_children] = true
+      params[:max_children] = args
+      params[:work_interval] = 0
+      params[:max_iterations] = 1
+    elsif args.is_a?(Hash)
+      # Specify the parameters directly.
+      params = args
+    end
+    t = params
+    params.inject({}) {|t, (key, val)| t[key.to_sym] = val; t}
+    self.jobs = []
+    self.max_children = params[:max_children] || 1
+    self.work_interval = params[:work_interval].nil? || params[:work_interval] < 0 ? 0 : params[:work_interval]
+    self.max_iterations = params[:max_iterations]
+    self.wait_for_children = params[:wait_for_children].nil? ? true : params[:wait_for_children]
+  end
+
+  # Load a configuration from a file.
+  def load_config(config_file)
+    params = {}
+    # Allowed options.
+    options = ['max_children', 'work_interval', 'max_iterations', 'wait_for_children']
+    begin
+      # Try to read the config file, and store the values.
+      data = File.open(config_file, "r").read.split(/\n/)
+      data.each do |line|
+        if line =~ /^\s*([a-zA-Z_]+)\s+([0-9]+)/
+          config_item = $1
+          config_value = $2
+          # Make sure option is valid.
+          if options.map(&:downcase).include?(config_item.downcase)
+            params[config_item.to_sym] = config_value.to_i
+          end
+        end
+      end
+    rescue => e
+      puts "Error loading config file: #{e.to_s}"
+    end
+    params
+  end
+
+  # Kill all child processes and shutdown.
+  def shutdown(all)
+    child_pids.each do |pid|
+      begin
+        Process.kill("TERM", pid)
+      rescue => e
+        puts e.to_s
+      end
+    end
+    exit if all
+  end
+
+  # Do work.
+  def run
+    Signal.trap("INT")  { shutdown(true) }
+    iteration = 0
+    while (@max_iterations.nil? || iteration < @max_iterations) do
+      iteration += 1
+      current_jobs = build_jobs(available)
+      current_jobs.each do |job|
+        pid = Process.fork do
+          job.work!
+        end
+        job.pid = pid
+        @jobs.push(job)
+      end
+      sleep @work_interval if @work_interval > 0
+    end
+    Process.waitall if @wait_for_children
+  end
+
+  # Create workers.
+  def build_jobs(count)
+    (1..count).each.collect {Forkomatic::Job.new}
+  end
+
+  # Reap child processes that finished.
+  def reap(pid)
+    return true if pid.nil?
+    begin
+      return true if Process.waitpid(pid, Process::WNOHANG)
+    rescue Errno::ECHILD
+      return true
+    rescue => e
+      puts "ERROR: #{e.to_s}"
+    end
+    return false
+  end
+
+  # Try to reap all child processes.
+  def reap_all
+    finished = []
+    @jobs.each do |job|
+      if reap(job.pid)
+        finished.push(job.pid)
+      end
+    end
+    @jobs.delete_if {|job| finished.include?(job.pid)}
+  end
+
+  # See how many children are available.
+  def available
+    # Initialize if need be.
+    return @max_children if @jobs.nil? || @jobs.empty?
+    # Reap children runners without waiting.
+    reap_all
+    @max_children - @jobs.length
+  end
+
+  # Get a list of current process IDs.
+  def child_pids
+    reap_all
+    pids = []
+    @jobs.each {|job| pids.push(job.pid) if job.pid}
+    pids
+  end
+end

data/spec/fixtures/config.txt

@@ -0,0 +1 @@
+max_children 2

data/spec/lib/forkomatic_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Forkomatic do
+  before do
+    @forkomatic = Forkomatic.new({:max_children => 5, :wait_for_children => false, :max_iterations => 1})
+  end
+
+  describe '.new' do
+    it "should create a forkomatic from the params" do
+      @forkomatic.should be_a_kind_of(Forkomatic)
+    end
+    it "should set max_iterations to 1" do
+      @forkomatic.max_iterations.should == 1
+    end
+    it "should create a forkomatic intialized with an integer" do
+      @forkomatic.available.should == 5
+    end
+    it "should create a forkomatic initialized with a hash" do
+      @test = Forkomatic.new({'max_runners' => 1})
+      @test.available.should == 1
+    end
+    it "should create a forkomatic initalized with a file path to a configuration" do
+      @test = Forkomatic.new(File.dirname(__FILE__) + '/../fixtures/config.txt')
+      @test.available.should == 2
+    end
+    it "should not wait for children if :wait_for_children is false" do
+      @forkomatic.wait_for_children.should == false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'forkomatic'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/test/continuous_test.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'forkomatic'
+
+class Tester < Forkomatic
+  class Tester::Job < Forkomatic::Job
+    # Add a data accessor...
+    attr_accessor :data
+
+    # Overload the initialize function to include this worker's data section.
+    def initialize(data)
+      self.data = data
+    end
+
+    # Overload the work! function.
+    def work!
+      puts @data
+      sleep rand(5)
+    end
+  end
+
+  # Overload the build_jobs function to give each job useful work and data to work with.
+  def build_jobs(count)
+    puts "Existing children : #{child_pids.length}"
+    puts "New this iteration: #{count}"
+    (1..count).each.collect { Tester::Job.new(rand(20)) }
+  end
+end
+
+# Create a new forkomatic instance with 3 child workers.
+f = Tester.new({:max_children => 10, :work_interval => 1})
+# Do the work
+f.run

data/test/parallel_search.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'forkomatic'
+
+$range = 1000000
+$data = (1..$range).each.collect
+$search_key = rand($range)
+$found = false
+
+class Tester < Forkomatic
+  class Tester::Job < Forkomatic::Job
+    # Beginning and end index to search
+    attr_accessor :start
+    attr_accessor :stop
+
+    # Overload the initialize function to include this worker's data section.
+    def initialize(start, stop)
+      self.start = start
+      self.stop = stop
+    end
+
+    # Overload the work! function.
+    def work!
+      (@start..@stop).each {|i| return if $found; d = $data[i]; $found = true and puts "Found #{d}" if d == $search_key }
+    end
+  end
+
+  # Overload the build_jobs function to give each job useful work and data to work with.
+  def build_jobs(count)
+    (1..count).each.collect {|i| Tester::Job.new((i - 1) * ($range / count), i * ($range / count) - 1) }
+  end
+end
+
+# Time execution with 1 child.
+(1..4).each do |i|
+  start = Time.now
+  f = Tester.new(i)
+  f.run
+  stop = Time.now
+  puts "Forks: #{i}, Execution time: #{(stop - start) * 1000}ms"
+end

data/test/simple_test.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'forkomatic'
+
+class Tester < Forkomatic
+  class Tester::Job < Forkomatic::Job
+    # Add a data accessor...
+    attr_accessor :data
+
+    # Overload the initialize function to include this worker's data section.
+    def initialize(data, start, stop)
+      self.data = (start..stop).collect {|i| data[i]}
+    end
+
+    # Overload the work! function.
+    def work!
+      @data.each {|d| puts d}
+    end
+  end
+
+  # Overload the build_jobs function to give each job useful work and data to work with.
+  def build_jobs(count)
+    data = (1..100).each.collect
+    i = 0
+    (1..count).each.collect { i += 1; Tester::Job.new(data, i * (20 / count), (i + 1) * (20 / count) - 1)}
+  end
+end
+
+# Create a new forkomatic instance with 20 child workers.
+f = Tester.new(20)
+# Do the work
+f.run

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification 
+name: forkomatic
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jon Durbin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-01 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  name: bundler
+  version_requirements: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 6
+        - 4
+        version: 1.6.4
+  name: jeweler
+  version_requirements: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rcov
+  version_requirements: *id003
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rdoc
+  version_requirements: *id004
+  prerelease: false
+description: Easily create parallel processes to do work.  The process count can be dynamic (between min_children and max_children), can loop continuously (by setting max_iterations => nil), etc
+email: jond@greenviewdata.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- lib/forkomatic.rb
+- spec/fixtures/config.txt
+- spec/lib/forkomatic_spec.rb
+- spec/spec_helper.rb
+- test/continuous_test.rb
+- test/parallel_search.rb
+- test/simple_test.rb
+has_rdoc: true
+homepage: http://github.com/gdi/forkomatic
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Easily run multiple processes continuously in parallel.
+test_files: []
+