angael 0.0.1

data/.gitignore

@@ -0,0 +1,11 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+doc
+tmp
+rerun.txt
+Gemfile.lock
+.bundle
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in angael.gemspec
+gemspec

data/README.md

@@ -0,0 +1,54 @@
+# Angael
+
+Angael is a lightweight library for running repetitive background processes.
+
+## Documentation
+
+Angael's model of running background processes involves two classes: a worker and a manager.
+
+Theoretically you do not need to modify Angael's built in manager (Angael::Manager).
+It already has the basic logic for starting and stopping the workers.
+
+Since workers are very different depending on the task at hand, Angael doesn't
+include a Worker class. Instead there is just a module (Angael::Worker) which 
+you can include into your own class.
+When you include Angael::Worker your class is expected to define a method called
+`work`. This method will be called repeatedly until the the worker is stopped.
+Also note, Angael::Worker defines an initialize method. If you require your own
+initializer, take care that you either call super or you set the appropriate
+instance variables.
+
+## Example
+
+
+```
+class MailMan
+  include Angael::Worker
+  def work
+    deliver_letters
+  end
+
+  def deliver_letters
+    # Your cool code
+  end
+end
+
+mail_man_manager = Angael::Manager.new(MailMan)
+
+# This will loop forever until it receives a SIGINT or SIGTERM.
+mail_man_manager.start!
+
+```
+
+## Setup
+
+Gemfile
+
+    gem 'angael', :git => 'git://github.com/thoughtless/angael.git'
+
+`bundle install`
+
+
+## Contribute
+
+See [http://github.com/thoughtless/angael](http://github.com/thoughtless/angael)

data/angael.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "angael/version"
+
+Gem::Specification.new do |s|
+  s.name        = "angael"
+  s.version     = Angael::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Paul Cortens"]
+  s.email       = ["paul@thoughtless.ca"]
+  s.homepage    = "http://github.com/thoughtless/angael"
+  s.summary     = %q{Lightweight library for running repetitive background processes.}
+  #s.description = %q{TODO: Write a gem description}
+
+  s.rubyforge_project = "angael"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency('rspec', '2.6.0')
+  s.add_development_dependency('rspec-process-mocks')
+end

data/lib/angael.rb

@@ -0,0 +1,5 @@
+module Angael; end
+
+require 'angael/version'
+require 'angael/worker'
+require 'angael/manager'

data/lib/angael/manager.rb

@@ -0,0 +1,78 @@
+module Angael
+  # A Manager has a number of of worker objects. Starting the Manager simply
+  # calls #start! on each worker, then it goes into an infinite loop, waiting
+  # for SIGINT or SIGTERM. When either of those is received, the manager will
+  # call #stop! on each Worker.
+  class Manager
+    attr_reader :workers
+
+    # Creates a new manager.
+    #
+    # @worker_class [Class] The class to use for the workers. Must respond
+    #   to #new, #start!, and #stop!
+    # @worker_count [Integer] The number of workers to manager. Default is 1.
+    # @worker_args [Array] An array of arguments that will be passed to
+    #   worker_class.new. The arguments will be splatted
+    #   (i.e. `worker_class.new(*worker_args)`). Default is an empty Array, i.e.
+    #   no arguments.
+    # @opts [Hash] Additional options:
+    #   :logger => A logger object, which should follow the Logger class in the
+    #     standard library. Default nil, as in no logging.
+    #   :log_level => The log level, as defined by the Logger class in the
+    #     standard library. One of:
+    #       Logger::FATAL
+    #       Logger::ERROR
+    #       Logger::WARN
+    #       Logger::INFO  # Default
+    #       Logger::DEBUG
+    def initialize(worker_class, worker_count=1, worker_args=[], opts={})
+      @workers = []
+      worker_count.times { workers << worker_class.new(*worker_args) }
+      @logger = opts[:logger]
+      if @logger
+        @log_level = opts[:log_level] || begin
+          require 'logger' # Only require it if it is absolutely neccessary.
+          Logger::INFO
+        end
+      end
+    end
+
+
+    # Starts workers by calling Worker#start! Loops forever waiting for SIGINT
+    # or SIGTERM, at which time it calls Worker#stop! on each worker.
+    def start!
+      workers.each { |w| w.start! }
+
+      loop do
+        trap("INT") do
+          stop!
+        end
+        trap("TERM") do
+          stop!
+        end
+        sleep 1
+      end
+    end
+
+
+
+    #########
+    private #
+    #########
+
+    def stop!
+      log("SIGINT Received")
+      workers.each { |w|
+        log("Calling #stop! for worker #{w.inspect}")
+        w.stop!
+        log("Finished call to #stop! for worker #{w.inspect}")
+      }
+      exit 0
+    end
+
+    def log(msg)
+      @logger.add(@log_level, "#{Time.now.utc} - #{self.class} (pid #{$$}): #{msg}") if @logger
+    end
+
+  end
+end

data/lib/angael/version.rb

@@ -0,0 +1,3 @@
+module Angael
+  VERSION = "0.0.1"
+end

data/lib/angael/worker.rb

@@ -0,0 +1,191 @@
+require 'timeout'
+module Angael
+  # Usage
+  #     include Angael::Worker
+  #     def work
+  #       # Do something interesting, without raising an exception.
+  #     end
+  # You can also add some optional behavior by defining the following methods:
+  #    #after_fork - This is run once, immediately after the child process is forked
+  #    #fork_child - This actually does the forking. You can overwrite this method
+  #                  to do wrap the child process in a block. This is useful for
+  #                  exception handling. Be sure to actually fork or you may break
+  #                  something important.
+  module Worker
+    class ChildProcessNotStoppedError < StandardError; end
+
+    attr_reader :pid
+
+    # Options:
+    #   :batch_timeout - After this number of seconds, other workers will be able
+    #                    to work on the jobs reserved by #process_jobs.
+    #   :batch_timeout_buffer - This is the number of seconds between when the
+    #                           worker stops processing jobs and when other workers
+    #                           can start processing the jobs that this worker had
+    #                           resered. This should be set to the maximum length
+    #                           of time a single job should take, plus the maximum
+    #                           expected discrepancy between the system clocks on
+    #                           all the worker servers.
+    #   :logger => A logger object, which should follow the Logger class in the
+    #     standard library. Default nil, as in no logging.
+    #   :log_level => The log level, as defined by the Logger class in the
+    #     standard library. One of:
+    #       Logger::FATAL
+    #       Logger::ERROR
+    #       Logger::WARN
+    #       Logger::INFO  # Default
+    #       Logger::DEBUG
+    def initialize(attrs={})
+      @timeout = attrs[:timeout] || 60 # Seconds
+      @batch_size = attrs[:batch_size] || 1
+      @batch_timeout = attrs[:batch_timeout] || @batch_size * 5 # Seconds
+      @batch_timeout_buffer = attrs[:batch_timeout_buffer] || 5 # Seconds
+      @logger = attrs[:logger]
+      if @logger
+        @log_level = attrs[:log_level] || begin
+          require 'logger' # Only require it if it is absolutely neccessary.
+          Logger::INFO
+        end
+      end
+    end
+
+
+    # Loops forever, taking jobs off the queue. SIGINT will stop it after
+    # allowing any jobs already taken from the queue to be processed.
+    def start!
+      trap("CHLD") do
+        log("trapped SIGCHLD. Child PID #{pid}.")
+
+        # @stopping is set by #stop!. If it is true, then the child process was
+        # expected to die. If it is false/nil, then this is unexpected.
+        log("Child process died unexpectedly") unless @stopping
+        # Reap the child process so that #started? will return false. But we can't
+        # block because this may be called for a Worker when a different Worker's
+        # child is the process that died.
+        wait_for_child(:dont_block => true) if pid
+      end
+
+      @pid = fork_child do
+        log("Started")
+
+        if respond_to?(:after_fork)
+          log("Running after fork callback")
+          after_fork
+          log("Finished running after fork callback")
+        end
+
+        @interrupted = false
+        trap("INT") do
+          log("SIGINT Received")
+          @interrupted = true
+        end
+        trap("TERM") do
+          log("SIGTERM Received")
+          @interrupted = true
+        end
+
+        loop do
+          if @interrupted
+            log("Child process exiting gracefully")
+            exit 0
+          end
+          work
+        end
+      end
+    end
+
+    def stop!
+      unless started?
+        log("Called stop for worker with PID #{pid} but it is not started")
+        return false
+      end
+
+      # Some internal state so that other parts of our code know that we
+      # intentionally stopped the child process.
+      @stopping = true
+
+      begin
+        log("Sending SIGINT to child process with pid #{pid}.")
+        Timeout::timeout(@timeout) do
+          Process.kill('INT', pid)
+          wait_for_child
+        end
+      rescue Timeout::Error
+        begin
+          log("Child process with pid #{pid} did not stop with #@timeout seconds of SIGINT. Sending SIGKILL to child process.")
+          # This only leaves 1 second for the SIGKILL to take effect. I don't
+          # know if that is enough time (or maybe too much time).
+          Timeout::timeout(1) do
+            Process.kill('KILL', pid)
+            wait_for_child
+          end
+        rescue Timeout::Error
+          if pid_running?
+            msg = "Unable to kill child process with PID: #{pid}"
+            log(msg)
+            raise ChildProcessNotStoppedError, msg
+          end
+        end
+      end
+      @stopping = false
+    end
+
+    def started?
+      !!(pid && pid_running?)
+    end
+    def stopped?
+      !started?
+    end
+
+    #########
+    private #
+    #########
+
+
+    # The worker will call this method over and over in a loop.
+    def work
+      raise "implement this in a class that includes this module"
+    end
+
+
+    def log(msg)
+      @logger.add(@log_level, "#{Time.now.utc} - #{self.class} (pid #{$$}): #{msg}") if @logger
+    end
+
+
+    # Note: if the pid is running, but this process doesn't have permissions to
+    #       access it, then this will return false.
+    def pid_running?
+      begin
+        Process.kill(0, pid) == 1
+      rescue Errno::ESRCH, Errno::EPERM
+        false
+      end
+    end
+
+    # Will just return if the child process is not running.
+    def wait_for_child(opts={})
+      begin
+        log("Waiting for child with pid #{pid}.")
+        if opts[:dont_block]
+          # When this is called as the result of a SIGCHLD
+          # we need to pass in Process::WNOHANG as the 2nd argument, otherwise when
+          # there are multiple workers, some workers will trap SIGCHLD when other
+          # workers' child processes die. Without this argument, those workers will
+          # hang forever, which also hangs the worker manager.
+          Process.wait(pid, Process::WNOHANG)
+        else
+          Process.wait(pid)
+        end
+      rescue Errno::ECHILD
+        # The child process has already been reaped.
+      end
+    end
+
+    # This is the standard/default way of doing it. Overwrite this if you want
+    # to wrap it in an exception handler, for example.
+    def fork_child(&block)
+      Process.fork &block
+    end
+  end
+end

data/spec/lib/angael/manager_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Angael::Manager do
+  describe ".new" do
+    subject { Angael::Manager.new(Angael::TestSupport::SampleWorker, 2) }
+    it "should have 2 workers when 2 is passed in to the initializer" do
+      should have(2).workers
+    end
+
+    it "should call new on the passed in job class" do
+      Angael::TestSupport::SampleWorker.should_receive(:new).exactly(2).times
+      Angael::Manager.new(Angael::TestSupport::SampleWorker, 2)
+    end
+
+    it "should call new on the passed in job class with the passed in arguments" do
+      args = [1, 2, 3]
+      Angael::TestSupport::SampleWorker.should_receive(:new).with(*args).exactly(2).times
+      Angael::Manager.new(Angael::TestSupport::SampleWorker, 2, args)
+    end
+  end
+
+  describe "#start!" do
+    subject { Angael::Manager.new(Angael::TestSupport::SampleWorker, 2) }
+    it "should start all its workers" do
+      subject.workers.each do |w|
+        w.should_receive_in_child_process(:start!)
+      end
+
+      pid = Process.fork do
+        subject.start!
+      end
+
+      # Need to sleep to allow time for temp files used by should_receive_in_child_process to flush
+      sleep 0.1
+
+      # Clean up
+      Process.kill('KILL', pid)
+      Process.wait(pid)
+    end
+
+
+    %w(INT TERM).each do |sig|
+      context "when it receives a SIG#{sig}" do
+        it "should call #stop! on each Worker" do
+          subject.workers.each do |w|
+            w.stub(:start!) # We don't care about the sub-process, so don't start it.
+
+            w.should_receive_in_child_process(:stop!)
+          end
+
+          pid = Process.fork do
+            subject.start!
+          end
+          sleep 0.1 # Give the process a chance to start.
+          Process.kill(sig, pid)
+          sleep 0.1 # Give the TempFile a chance to flush
+
+          # Clean up
+          Process.wait(pid)
+        end
+      end
+    end
+  end
+end

data/spec/lib/angael/worker_spec.rb

@@ -0,0 +1,276 @@
+require 'spec_helper'
+require 'tempfile'
+
+
+describe Angael::Worker do
+  subject { Angael::TestSupport::SampleWorker.new }
+
+  describe "#start!" do
+    before { subject.stub(:work => nil) }
+    after { subject.stop! if subject.started? }
+
+    it "should set #pid" do
+      subject.pid.should be_nil
+      subject.start!
+      subject.pid.should_not be_nil
+    end
+
+    it "should create a process that has the pid of #pid" do
+      subject.start!
+      pid_running?(subject.pid).should be_true
+    end
+
+    it "should be started" do
+      subject.should_not be_started
+      subject.start!
+      subject.should be_started
+    end
+
+    it "should be doing work" do
+      # TODO: Update #should_receive_in_child_process to allow for a
+      #       #more_than_once option, then use that instead of setting this all
+      #       up manually.
+
+      # I'm using this temp file to ensure we are actually doing something. I
+      # can't just use should_receive because the "work" is done in a different
+      # process.
+      file = Tempfile.new('work-stub')
+      subject.stub(:work) do
+        @work_counter ||= 1
+        msg = "I am working. My PID is #{$$}. Run number #@work_counter"
+        file.puts msg
+      end
+
+      subject.start!
+
+      # Check that work was done (i.e. there is something in the file).
+      sleep 0.1
+      file.rewind
+      lines = file.readlines.size
+      lines.should > 0
+
+      # Check that more work was done (i.e. there is more in the file than
+      # last time we checked).
+      old_lines = lines
+      sleep 0.3
+      file.rewind
+      lines = file.readlines.size
+      lines.should > old_lines
+    end
+
+    context "child process dies unexpectedly" do
+      before { subject.start! }
+      it "should not be started" do
+        Process.kill('KILL', subject.pid)
+        sleep 0.1 # Wait for SIGKILL to take effect.
+        subject.should_not be_started
+      end
+
+      it "should still have #pid set to the child process's pid" do
+        pid = subject.pid
+        Process.kill('KILL', subject.pid)
+        subject.pid.should == pid
+      end
+    end
+
+  end
+
+
+
+  describe "#stop!" do
+    before { subject.stub(:work => nil) }
+    after { subject.stop! }
+
+    context "is stopped" do
+      it "should return false" do
+        subject.should_not be_started
+        subject.stop!.should be_false
+      end
+
+      it "should not send a SIGINT to the child process" do
+        should_not_receive_and_run(Process, :kill, 'INT', subject.pid)
+        subject.stop!
+      end
+    end
+
+    context "is started" do
+      it "should send a SIGINT to the child process" do
+        subject.start!
+        should_receive_and_run(Process, :kill, 'INT', subject.pid)
+        subject.stop!
+      end
+
+      context "child process does die within the worker's timeout" do
+        subject { @worker ||= Angael::TestSupport::SampleWorker.new(:timeout => 2) }
+        before do
+          subject.stub(:work) { nil }
+          subject.start!
+        end
+        it "should be stopped" do
+          subject.stop!
+          subject.should be_stopped
+        end
+
+        it "should not have a child process with the pid #pid" do
+          subject.stop!
+          pid_running?(subject.pid).should be_false
+        end
+
+        it "should not send a SIGKILL to the child process" do
+          should_not_receive_and_run(Process, :kill, 'KILL', subject.pid)
+          subject.stop!
+        end
+
+        it "should have the (now dead) child process' PID as #pid" do
+          pid = subject.pid
+          subject.stop!
+          subject.pid.should == pid
+        end
+      end
+
+      context "child process does not die within the worker's timeout" do
+        subject { @worker ||= Angael::TestSupport::SampleWorker.new(:timeout => 1) }
+        before do
+          subject.stub(:work) { sleep 1000 }
+          subject.start!
+          sleep 1 # Leave some time for the child process to enter the sleep.
+        end
+
+        it "should be stopped" do
+          subject.stop!
+          subject.should be_stopped
+        end
+
+        it "should not have a child process with the pid #pid" do
+          subject.stop!
+          pid_running?(subject.pid).should be_false
+        end
+
+        it "should send a SIGKILL to the child process" do
+          should_receive_and_run(Process, :kill, 'KILL', subject.pid)
+          subject.stop!
+        end
+
+        context "child process does not die after receiving SIGKILL" do
+          before do
+            Process.instance_eval { alias :_original_kill :kill }
+            # This ensures that SIGKILL doesn't kill the child process, but
+            # all other signals are processed.
+            Process.stub(:kill) do |*args|
+              if args == ['KILL', subject.pid]
+                nil
+              else
+                Process._original_kill(*args)
+              end
+            end
+          end
+          after do
+            # Clean up
+            Process._original_kill('KILL', subject.pid)
+            sleep 0.1 # Wait for SIGKILL to take effect.
+            pid_running?(subject.pid).should be_false
+          end
+
+          it "should raise an error with the child process' pid in the message" do
+            pid_running?(subject.pid).should be_true
+            lambda do
+              subject.stop!
+            end.should raise_error(Angael::Worker::ChildProcessNotStoppedError, /#{subject.pid}/)
+
+            # Confirm the PID is still running
+            pid_running?(subject.pid).should be_true
+          end
+        end
+      end
+    end
+  end
+
+
+  # Note: Be very careful when trying to refactor these tests. The exact timing
+  #       of signals is not very easy to predict. The specs in this describe
+  #       block have been carefully tested (with many test runs) to make sure
+  #       they are very unlikely to fail for random timing reasons. If you must
+  #       change these specs, make sure you run the whole test suite several
+  #       times to make sure all the specs consistently pass.
+  describe "child process handling of signals" do
+    context "when started" do
+      before { subject.stub(:work) }
+
+      %w(INT TERM).each do |sig|
+        context "when child process receives SIG#{sig}" do
+          it "should exit gracefully (i.e. with status 0)" do
+            subject.start!
+            # Don't let the worker reap its child process because we need to
+            # get at the PID and status here.
+            subject.stub(:wait_for_child)
+            sleep 0.1 # Make sure there was enough time for the child process to start.
+            Process.kill(sig, subject.pid)
+            pid, status = Process.wait2(subject.pid)
+            status.should == 0
+          end
+
+          it "should reap the child process" do
+            # As a general rule, I would only expect this method to be called
+            # once. However, signal behavior is difficult to predict. In some
+            # of our test runs, it is called more than once. If we do receive
+            # multiple SIGCHLD signals (which would be what causes this method
+            # to be called multiple times) there are no ill side effects. Thus
+            # I think it is quite safe to allow this method to be called more
+            # than once.
+            #   -- Paul Cortens (2011-05-18)
+            subject.should_receive(:wait_for_child).at_least(:once)
+
+            subject.start!
+            sleep 0.1 # Make sure there was enough time for the child process to start.
+            Process.kill(sig, subject.pid)
+
+            # We need to wait this long to make sure the child process had time
+            # to respond to the signal. If this is decreased to 'sleep 0.1' then
+            # the tests will sometimes fail because there wasn't enough time for
+            # the trap block to run #wait_for_child.
+            sleep 0.5
+
+            # Clean up zombie child processes.
+            Process.wait(subject.pid)
+          end
+        end
+      end
+    end
+  end
+
+
+
+  ###########
+  # Helpers #
+  ###########
+
+  # Note: if the pid is running, but this process doesn't have permissions to
+  #       access it, then this will return false.
+  def pid_running?(pid)
+    begin
+      Process.kill(0, pid) == 1
+    rescue Errno::ESRCH, Errno::EPERM
+      false
+    end
+  end
+
+  # These methods let me set an expectation that amethod should be called, but
+  # also allow that method to actually be called.
+  def stub_and_run(object, method, *args)
+    unstubbed_method = "_unstubbed_#{method}".to_sym
+    method = method.to_sym
+    # This is a bit ugly, but because alias is not a method, but a keyword, we
+    # need to use eval like this. For more details see this thread:
+    #    http://www.ruby-forum.com/topic/135598
+    object.instance_eval "alias #{unstubbed_method.inspect} #{method.inspect}"
+    object.stub(method) { |*args| object.send(unstubbed_method, *args) }
+  end
+  def should_receive_and_run(object, method, *args)
+    stub_and_run(object, method, *args)
+    object.should_receive(method).with(*args)
+  end
+  def should_not_receive_and_run(object, method, *args)
+    stub_and_run(object, method, *args)
+    object.should_not_receive(method).with(*args)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'bundler'
+Bundler.require(:default, :development)
+require 'rspec' # => required for RubyMine to be able to run specs
+
+Dir[File.expand_path(File.dirname(__FILE__) + '/support/**/*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+
+  config.mock_with :rspec
+  require 'rspec/process_mocks' # This line must be after 'config.mock_with :rspec'
+
+  # gets rid of the bacetrace that we don't care about
+  config.backtrace_clean_patterns = [/\.rvm\/gems\//]
+
+end

data/spec/support/test_worker.rb

@@ -0,0 +1,10 @@
+module Angael
+  module TestSupport
+    class SampleWorker
+      include Angael::Worker
+      def work
+        # Do Nothing
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: angael
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Paul Cortens
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-28 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec-process-mocks
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: 
+email: 
+- paul@thoughtless.ca
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- angael.gemspec
+- lib/angael.rb
+- lib/angael/manager.rb
+- lib/angael/version.rb
+- lib/angael/worker.rb
+- spec/lib/angael/manager_spec.rb
+- spec/lib/angael/worker_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_worker.rb
+has_rdoc: true
+homepage: http://github.com/thoughtless/angael
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: angael
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Lightweight library for running repetitive background processes.
+test_files: []
+