pigeon 0.8.0 → 0.9.0

data/Rakefile

@@ -28,13 +28,3 @@ end
 task :test => :check_dependencies
 
 task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "pigeon #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/VERSION

@@ -1 +1 @@
-0.8.0
+0.9.0

data/lib/pigeon/engine.rb

@@ -1,5 +1,6 @@
 require 'eventmachine'
 require 'socket'
+require 'fiber'
 
 class Pigeon::Engine
   # == Submodules ===========================================================
@@ -23,6 +24,7 @@ class Pigeon::Engine
     :boolean => true
   option_accessor :debug,
     :boolean => true
+  option_accessor :log_rotation
   option_accessor :engine_log_name,
     :default => 'engine.log'
   option_accessor :engine_logger
@@ -44,6 +46,7 @@ class Pigeon::Engine
     :default => false
     
   attr_reader :id
+  attr_reader :state
 
   # == Constants ============================================================
   
@@ -53,6 +56,12 @@ class Pigeon::Engine
     after_start
     before_stop
     after_stop
+    before_resume
+    after_resume
+    before_standby
+    after_standby
+    before_shutdown
+    after_shutdown
   ].collect(&:to_sym).freeze
 
   # == Class Methods ========================================================
@@ -166,6 +175,14 @@ class Pigeon::Engine
         # No such process exception
         pid = nil
       end
+      
+      begin
+        while (Process.kill(0, pid))
+          sleep(1)
+        end
+      rescue Errno::ESRCH
+        # No such process, already terminated
+      end
 
       pid_file.remove!
     end
@@ -200,7 +217,7 @@ class Pigeon::Engine
       f = File.open(File.expand_path(self.engine_log_name, self.log_dir), 'a')
       f.sync = true
 
-      Pigeon::Logger.new(f)
+      Pigeon::Logger.new(f, self.log_rotation)
     end
   end
 
@@ -210,7 +227,7 @@ class Pigeon::Engine
       f = File.open(File.expand_path(self.query_log_name, self.log_dir), 'a')
       f.sync = true
     
-      Pigeon::Logger.new(f)
+      Pigeon::Logger.new(f, self.log_rotation)
     end
   end
   
@@ -243,20 +260,22 @@ class Pigeon::Engine
   def initialize(options = nil)
     @id = Pigeon::Support.unique_id
 
-    @options = options || { }
+    wrap_chain(:initialize) do
+      @options = options || { }
     
-    @task_lock = Mutex.new
-    @task_locks = { }
+      @task_lock = Mutex.new
+      @task_locks = { }
 
-    @task_register_lock = Mutex.new
-    @registered_tasks = { }
+      @task_register_lock = Mutex.new
+      @registered_tasks = { }
     
-    self.logger ||= self.engine_logger
-    self.logger.level = Pigeon::Logger::DEBUG if (self.debug?)
+      self.logger ||= self.engine_logger
+      self.logger.level = Pigeon::Logger::DEBUG if (self.debug?)
     
-    @dispatcher = { }
+      @dispatcher = { }
     
-    run_chain(:after_initialize)
+      @state = :initialized
+    end
   end
 
   # Returns the hostname of the system this engine is running on.
@@ -269,15 +288,15 @@ class Pigeon::Engine
   def run
     assign_process_name!
 
-    run_chain(:before_start)
-
-    STDOUT.sync = true
+    wrap_chain(:start) do
+      STDOUT.sync = true
 
-    logger.info("Engine \##{id} Running")
-    
-    run_chain(:after_start)
+      logger.info("Engine \##{id} Running")
     
-    switch_to_effective_user! if (self.class.user)
+      switch_to_effective_user! if (self.class.user)
+
+      @state = :running
+    end
   end
 
   # Used to periodically execute a task or block. When giving a task name,
@@ -339,11 +358,10 @@ class Pigeon::Engine
   # Shuts down the engine. Will also trigger the before_stop and after_stop
   # events.
   def terminate
-    run_chain(:before_stop)
-
-    EventMachine.stop_event_loop
-
-    run_chain(:after_stop)
+    wrap_chain(:stop) do
+      EventMachine.stop_event_loop
+      @state = :terminated
+    end
   end
   
   # Used to dispatch a block for immediate processing on a background thread.
@@ -359,6 +377,43 @@ class Pigeon::Engine
       EventMachine.next_tick(&block)
     end
   end
+
+  def resume!
+    case (@state)
+    when :running
+      # Ignored since already running.
+    when :terminated
+      # Invalid operation, should produce error.
+    else
+      wrap_chain(:resume) do
+        @state = :running
+      end
+    end
+  end
+  
+  def standby!
+    case (@state)
+    when :standby
+      # Already in standby state, ignored.
+    when :terminated
+      # Invalid operation, should produce error.
+    else
+      wrap_chain(:standby) do
+        @state = :standby
+      end
+    end
+  end
+  
+  def shutdown!
+    case (@state)
+    when :terminated
+      # Already terminated, ignored.
+    else
+      wrap_chain(:shutdown) do
+        self.terminate
+      end
+    end
+  end
   
   class << self
     CHAINS.each do |chain_name|
@@ -377,14 +432,8 @@ class Pigeon::Engine
       end
     end
 
-    def run_chain(chain_name, instance)
-      chain = instance_variable_get(:"@_#{chain_name}_chain")
-
-      return unless (chain)
-
-      chain.each do |proc|
-        instance.instance_eval(&proc)
-      end
+    def chain_procs(chain_name)
+      instance_variable_get(:"@_#{chain_name}_chain")
     end
   end
 
@@ -421,8 +470,42 @@ class Pigeon::Engine
   end
 
 protected
+  def wrap_chain(chain_name)
+    Fiber.new do
+      run_chain(:"before_#{chain_name}")
+      yield if (block_given?)
+      run_chain(:"after_#{chain_name}")
+    end.resume
+  end
+  
   def run_chain(chain_name)
-    self.class.run_chain(chain_name, self)
+    callbacks = { }
+    fiber = Fiber.current
+    
+    if (procs = self.class.chain_procs(chain_name))
+      procs.each do |proc|
+        case (proc.arity)
+        when 1
+          callback = lambda {
+            callbacks.delete(callback)
+            
+            if (callbacks.empty?)
+              fiber.resume
+            end
+          }
+          
+          callbacks[callback] = true
+
+          instance_exec(callback, &proc)
+        else
+          instance_eval(&proc)
+        end
+      end
+      
+      if (callbacks.any?)
+        Fiber.yield
+      end
+    end
   end
   
   def switch_to_effective_user!

data/lib/pigeon/launcher.rb

@@ -46,43 +46,47 @@ class Pigeon::Launcher
   end
   
   def run(pid)
-    puts "#{@engine.name} now running. [%d]" % pid
-    puts "Use ^C to terminate."
+    log "#{@engine.name} now running. [%d]" % pid
+    log "Use ^C to terminate."
   end
   
   def start(pid)
-    puts "#{@engine.name} now running. [%d]" % pid
+    log "#{@engine.name} now running. [%d]" % pid
   end
   
   def stop(pid)
     if (pid)
-      puts "#{@engine.name} shut down. [%d]" % pid
+      log "#{@engine.name} shut down. [%d]" % pid
     else
-      puts "#{@engine.name} was not running."
+      log "#{@engine.name} was not running."
     end
   end
   
   def status(pid)
     if (pid)
-      puts "#{@engine.name} running. [%d]" % pid
+      log "#{@engine.name} running. [%d]" % pid
     else
-      puts "#{@engine.name} is not running."
+      log "#{@engine.name} is not running."
     end
   end
   
   def restart(pid, old_pid)
     if (old_pid)
-      puts "#{@engine.name} terminated. [%d]" % old_pid
+      log "#{@engine.name} terminated. [%d]" % old_pid
     end
 
-    puts "#{@engine.name} now running. [%d]" % pid
+    log "#{@engine.name} now running. [%d]" % pid
   end
   
   def shutdown(pid)
-    puts "Shutting down."
+    log "Shutting down."
   end
 
   def usage
-    puts "Usage: #{File.basename($0)} [start|stop|restart|status|run]"
+    log "Usage: #{File.basename($0)} [start|stop|restart|status|run]"
+  end
+  
+  def log(message)
+    puts message
   end
 end

data/lib/pigeon.rb

@@ -19,4 +19,5 @@ end
 # issue where requiring it later causes a run-time Interrupt exception.
 require 'pigeon/logger'
 
+# The fastthread library is not essential, so loading errors can be ignored.
 require 'fastthread' rescue nil

data/pigeon.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "pigeon"
-  s.version = "0.8.0"
+  s.version = "0.9.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["tadman"]
-  s.date = "2012-04-04"
+  s.date = "2012-10-15"
   s.description = "Pigeon is a simple way to get started building an EventMachine engine that's intended to run as a background job."
   s.email = "github@tadman.ca"
   s.extra_rdoc_files = [
@@ -52,7 +52,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/twg/pigeon"
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.17"
+  s.rubygems_version = "1.8.24"
   s.summary = "Simple daemonized EventMachine engine framework with plug-in support"
 
   if s.respond_to? :specification_version then

data/test/helper.rb

@@ -8,10 +8,10 @@ require 'timeout'
 
 require 'rubygems'
 
-if (Gem.available?('eventmachine'))
+begin
   gem 'eventmachine'
-else
-  raise "EventMachine gem is not installed."
+rescue => e
+  raise "EventMachine gem is not installed or could not be loaded: [#{e.class}] #{e}"
 end
 
 require 'pigeon'
@@ -37,37 +37,30 @@ class Test::Unit::TestCase
 
   def engine
     exception = nil
+    
+    Pigeon::Engine.launch do |new_engine|
+      @engine = new_engine
 
-    @engine_thread = Thread.new do
-      Thread.abort_on_exception = true
-
-      # Create a thread for the engine to run on
-      begin
-        Pigeon::Engine.launch do |new_engine|
-          @engine = new_engine
-          
-          Thread.new do
-            # Execute the test code in a separate thread to avoid blocking
-            # the EventMachine loop.
-            begin
-              yield
-            rescue Object => exception
-            ensure
-              begin
-                @engine.terminate
-              rescue Object
-                # Shutting down may trigger an exception from time to time
-                # if the engine itself has failed.
-              end
-            end
+      # Execute the test code in a separate thread to avoid blocking
+      # the EventMachine loop.
+      Thread.new do
+        begin
+          Thread.abort_on_exception = true
+          yield
+        rescue Object => exception
+        ensure
+          begin
+            # Regardless what happened, always terminate the engine.
+            @engine.terminate
+          rescue Object => e
+            # Shutting down may trigger an exception from time to time
+            # if the engine itself has failed.
+            STDERR.puts("Exception: [#{e.class}] #{e}")
           end
         end
-      rescue Object => exception
       end
     end
     
-    @engine_thread.join
-    
     if (exception)
       raise exception
     end

data/test/unit/pigeon_backlog_test.rb

@@ -11,15 +11,26 @@ class PigeonQueueTest < Test::Unit::TestCase
   end
   
   def test_queue_cycling
-    queue = Pigeon::Queue.new
+    engine do
+      queue = Pigeon::Queue.new
+    
+      task = Pigeon::Task.new
+    
+      queue << task
+      
+      assert_eventually(1) do
+        !queue.empty?
+      end
     
-    task = Pigeon::Task.new
+      assert_equal 1, queue.length
+      assert !queue.empty?
     
-    queue << task
+      found_task = queue.pop
     
-    assert_equal 1, queue.length
-    assert !queue.empty?
+      assert_equal task, found_task
     
-    found_task = queue.pop
+      assert_equal 0, queue.length
+      assert queue.empty?
+    end
   end
 end

data/test/unit/pigeon_engine_test.rb

@@ -55,6 +55,22 @@ class CallbackTestEngine < Pigeon::Engine
   end
 end
 
+class ShutdownCallbackTestEngine < Pigeon::Engine
+  attr_accessor :callbacks
+  
+  after_start do
+    @callbacks = [ ]
+  end
+  
+  before_shutdown do |callback|
+    @callbacks << callback
+  end
+
+  before_shutdown do |callback|
+    @callbacks << callback
+  end
+end
+
 class TestPigeonEngine < Test::Unit::TestCase
   def test_default_options
     assert TestEngine.engine_logger
@@ -173,4 +189,43 @@ class TestPigeonEngine < Test::Unit::TestCase
     
     assert_equal nil, running_pid
   end
+  
+  def test_shutdown_engine_with_blocking_callback
+    e = nil
+    
+    Thread.new do
+      Thread.abort_on_exception = true
+      
+      ShutdownCallbackTestEngine.launch do |_e|
+        e = _e
+      end
+    end
+      
+    assert_eventually(5) do
+      e
+    end
+    
+    assert e, "Engine variable was not bound"
+    assert_equal [ ], e.callbacks
+    
+    assert_eventually(5) do
+      e.state == :running
+    end
+
+    e.shutdown!
+    
+    assert e.callbacks
+    assert !e.callbacks.empty?
+    assert_equal :running, e.state
+    
+    assert_equal 2, e.callbacks.length
+    
+    e.callbacks[0].call
+
+    assert_equal :running, e.state
+
+    e.callbacks[1].call
+
+    assert_equal :terminated, e.state
+  end
 end

data/test/unit/pigeon_launcher_test.rb

@@ -1,5 +1,11 @@
 require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
 
+class Pigeon::Launcher
+  def log(*args)
+    # Disabled for testing.
+  end
+end
+
 class PigeonLauncherTest < Test::Unit::TestCase
   def test_default_launcher
     pid = Pigeon::Launcher.launch

data/test/unit/pigeon_processor_test.rb

@@ -3,6 +3,7 @@ require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
 class PigeonProcessorTest < Test::Unit::TestCase
   class TaggedTask < Pigeon::Task
     attr_accessor :tag
+    attr_reader :last_task
     
     def initialize(tag, options = nil)
       super(options)
@@ -37,29 +38,36 @@ class PigeonProcessorTest < Test::Unit::TestCase
   end
   
   def test_simple_filter
-    queue = Pigeon::Queue.new
+    engine do
+      queue = Pigeon::Queue.new
     
-    processor = Pigeon::Processor.new(queue) do |task|
-      (task.tag % 2) == 1
-    end
+      processor = Pigeon::Processor.new(queue) do |task|
+        (task.tag % 2) == 1
+      end
     
-    assert_equal false, processor.task?
+      assert_equal false, processor.task?
     
-    queue << TaggedTask.new(0)
+      queue << TaggedTask.new(0)
     
-    assert_equal false, processor.task?
-    assert_equal 1, queue.length
+      assert_eventually(1) do
+        queue.length == 1
+      end
+    
+      assert_equal false, processor.task?
+      assert_equal 1, queue.length
 
-    queue << TaggedTask.new(1)
+      queue << TaggedTask.new(1)
     
-    assert_equal true, processor.task?
-    assert_equal 1, queue.length
+      assert_eventually(1) do
+        queue.length == 1
+      end
+
+      assert_equal 1, queue.length
     
-    assert_eventually(5) do
-      !processor.task?
+      assert_eventually(5) do
+        !processor.task?
+      end
     end
-    
-    assert_equal 1, queue.length
   end
 
   def test_on_backlog
@@ -137,6 +145,10 @@ class PigeonProcessorTest < Test::Unit::TestCase
         queue << TaggedTask.new(n)
       end
     
+      assert_eventually(2) do
+        queue.length == count
+      end
+    
       assert_equal count, queue.length
     
       processors = (0..9).to_a.collect do

data/test/unit/pigeon_scheduler_test.rb

@@ -53,12 +53,13 @@ class PigeonSchedulerTest < Test::Unit::TestCase
 
   def test_add
     queue = Pigeon::Queue.new
-    
     scheduler = Pigeon::Scheduler.new(queue)
+    
+    assert scheduler.processors.length > 0
 
     count = 1000
-    
     backlog = [ ]
+
     count.times do |n|
       scheduler.add(TaggedTask.new(n * 2 + 1))
       backlog << TaggedTask.new(n * 2)
@@ -66,8 +67,6 @@ class PigeonSchedulerTest < Test::Unit::TestCase
     
     scheduler.add(backlog)
     
-    assert !queue.empty?
-    
     assert_eventually(5) do
       queue.empty?
     end

data/test/unit/pigeon_task_test.rb

@@ -44,35 +44,27 @@ class FailingTask < Pigeon::Task
 end
 
 class PigeonTaskTest < Test::Unit::TestCase
-  def setup
-    @engine = Pigeon::Engine.new
-
-    Pigeon::Engine.register_engine(@engine)
-  end
-  
-  def teardown
-    Pigeon::Engine.unregister_engine(@engine)
-  end
-  
   def test_empty_task
-    task = Pigeon::Task.new
+    engine do
+      task = Pigeon::Task.new
     
-    reported = 0
+      reported = 0
     
-    task.run! do
-      reported = 1
-    end
+      task.run! do
+        reported = 1
+      end
 
-    assert_eventually(5) do
-      task.finished? and reported > 0
-    end
+      assert_eventually(5) do
+        task.finished? and reported > 0
+      end
     
-    assert_equal 1, reported
-    assert_equal :finished, task.state
+      assert_equal 1, reported
+      assert_equal :finished, task.state
 
-    assert_equal nil, task.exception
+      assert_equal nil, task.exception
     
-    assert_equal @engine.object_id, task.engine.object_id
+      assert_equal @engine.object_id, task.engine.object_id
+    end
   end
 
   def test_alternate_engine
@@ -83,61 +75,65 @@ class PigeonTaskTest < Test::Unit::TestCase
   end
   
   def test_example_task
-    task = ExampleTask.new
-    
-    callbacks = [ ]
-    
-    task.run! do |state|
-      callbacks << state
+    engine do
+      task = ExampleTask.new
+    
+      callbacks = [ ]
+    
+      task.run! do |state|
+        callbacks << state
+      end
+    
+      assert_eventually(5) do
+        task.finished?
+      end
+    
+      assert_equal nil, task.exception
+    
+      assert_equal :finished, task.state
+
+      expected_triggers = [
+        :after_initialized,
+        :initialized,
+        :state1,
+        :state2,
+        :state3,
+        :state4,
+        :finished,
+        :after_finished
+      ]
+    
+      assert_equal expected_triggers, task.triggers
+
+      expected_callbacks = [
+        :initialized,
+        :state1,
+        :state2,
+        :state3,
+        :state4,
+        :finished
+      ]
+
+      assert_equal expected_callbacks, callbacks
     end
-    
-    assert_eventually(5) do
-      task.finished?
-    end
-    
-    assert_equal nil, task.exception
-    
-    assert_equal :finished, task.state
-
-    expected_triggers = [
-      :after_initialized,
-      :initialized,
-      :state1,
-      :state2,
-      :state3,
-      :state4,
-      :finished,
-      :after_finished
-    ]
-    
-    assert_equal expected_triggers, task.triggers
-
-    expected_callbacks = [
-      :initialized,
-      :state1,
-      :state2,
-      :state3,
-      :state4,
-      :finished
-    ]
-
-    assert_equal expected_callbacks, callbacks
   end
 
   def test_failing_task
-    task = FailingTask.new
-    
-    reported = false
-    
-    task.run! do
-      reported = true
-    end
-    
-    assert_eventually(5) do
-      task.failed? and reported
-    end
+    engine do
+      task = FailingTask.new
+  
+      reported = false
+  
+      task.run! do
+        reported = true
+      end
+  
+      assert_eventually(5) do
+        task.failed? and reported
+      end
 
-    assert task.exception?
+      assert task.exception?
+    end
   end
   
   def test_with_context
@@ -156,19 +152,21 @@ class PigeonTaskTest < Test::Unit::TestCase
   end
 
   def test_block_notification
-    task = Pigeon::Task.new
+    engine do
+      task = Pigeon::Task.new
 
-    states_triggered = [ ]
+      states_triggered = [ ]
 
-    task.run! do |state|
-      states_triggered << state
-    end
+      task.run! do |state|
+        states_triggered << state
+      end
     
-    assert_eventually(5) do
-      task.finished?
-    end
+      assert_eventually(5) do
+        task.finished?
+      end
     
-    assert_equal [ :initialized, :finished ], states_triggered
+      assert_equal [ :initialized, :finished ], states_triggered
+    end
   end
 
   def test_priority_order

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pigeon
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-04 00:00:00.000000000 Z
+date: 2012-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &2152583160 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152583160
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Pigeon is a simple way to get started building an EventMachine engine
   that's intended to run as a background job.
 email: github@tadman.ca
@@ -83,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Simple daemonized EventMachine engine framework with plug-in support