pigeon 0.5.2 → 0.6.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Scott Tadman
+Copyright (c) 2009-2011 Scott Tadman, The Working Group Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/VERSION

@@ -1 +1 @@
-0.5.2
+0.6.0

data/lib/pigeon.rb

@@ -18,3 +18,5 @@ end
 # NOTE: This file needs to be directly loaded due to some kind of peculiar
 # issue where requiring it later causes a run-time Interrupt exception.
 require 'pigeon/logger'
+
+require 'fastthread' rescue nil

data/lib/pigeon/engine.rb

@@ -132,8 +132,12 @@ class Pigeon::Engine
   end
 
   def self.start(options = nil)
-    pid = Pigeon::Support.daemonize do
-      launch(options)
+    logger = self.engine_logger
+    
+    pid = Pigeon::Support.daemonize(logger) do
+      launch({
+        :logger => logger
+      }.merge(options || { }))
     end
 
     pid_file.create!(pid)

data/lib/pigeon/launcher.rb

@@ -3,23 +3,23 @@ require 'optparse'
 class Pigeon::Launcher
   # == Class Methods ========================================================
   
-  def self.launch(engine, options)
+  def self.launch(engine = Pigeon::Engine, *arguments)
+    arguments = %w[ start ] if (arguments.empty?)
+    
+    new(engine).handle_args(*arguments)
   end
     
   # == Instance Methods =====================================================
     
   def initialize(with_engine = Pigeon::Engine)
     @engine = with_engine
-    @options = { }
+    
+    yield(self) if (block_given?)
   end
   
   def handle_args(*args)
     op = OptionParser.new
     
-    op.on("-s", "--supervise") do
-      @options[:supervise] = true
-    end
-    
     command = op.parse(*args.flatten).first
 
     begin

data/lib/pigeon/processor.rb

@@ -20,7 +20,7 @@ class Pigeon::Processor
   def initialize(queue = nil, context = nil, &filter)
     @id = Pigeon::Support.unique_id
     @lock = Mutex.new
-    @filter = filter || lambda { |task| true }
+    @filter = filter
     @context = context
     
     if (queue)
@@ -40,7 +40,7 @@ class Pigeon::Processor
     if (@queue = queue)
       @claim = lambda do |task|
         @lock.synchronize do
-          if (!@task and @filter.call(task))
+          if (!@task and (!@filter or @filter.call(task)))
             @task = queue.claim(task)
 
             before_task(@task)
@@ -59,7 +59,7 @@ class Pigeon::Processor
   # Returns true if the given task would be accepted by the filter defined
   # for this processor.
   def accept?(task)
-    @filter.call(task)
+    !@filter or @filter.call(task)
   end
   
   # Returns true if a task is currently being processed, false otherwise.

data/lib/pigeon/queue.rb

@@ -1,3 +1,5 @@
+require 'monitor'
+
 class Pigeon::Queue
   # == Constants ============================================================
   
@@ -44,15 +46,13 @@ class Pigeon::Queue
   # and order them, so it should take two arguments and return the relative
   # difference (-1, 0, 1) like Array#sort would work.
   def initialize(&block)
-    @filter_lock = Mutex.new
-    @observer_lock = Mutex.new
-
-    @claimable_task = { }
     @filters = self.class.filters.dup
+    @filters.extend(MonitorMixin)
     @observers = { }
+    @observers.extend(MonitorMixin)
+    @claimable_task = { }
     @processors = [ ]
     @next_task = { }
-    @insert_backlog = [ ]
     
     if (block_given?)
       @sort_by = block
@@ -69,7 +69,7 @@ class Pigeon::Queue
     raise BlockRequired unless (block_given?)
 
     @sort_by = block
-    @filter_lock.synchronize do
+    @filters.synchronize do
       @tasks = Pigeon::SortedArray.new(&@sort_by) + @tasks
       
       @next_task = { }
@@ -82,10 +82,10 @@ class Pigeon::Queue
   def observe(filter_name = nil, &block)
     raise BlockRequired unless (block_given?)
     
-    @observer_lock.synchronize do
-      @observers[filter_name] ||= [ ]
+    @observers.synchronize do
+      set = @observers[filter_name] ||= [ ]
 
-      @observers[filter_name] << block
+      set << block
     end
 
     task = assign_next_task(filter_name)
@@ -95,7 +95,7 @@ class Pigeon::Queue
   # Proc must be passed in, as a block with an identical function will not
   # be considered equivalent.
   def remove_observer(filter_name = nil, &block)
-    @observer_lock.synchronize do
+    @observers.synchronize do
       set = @observers[filter_name]
 
       set and set.delete(block)
@@ -104,7 +104,7 @@ class Pigeon::Queue
   
   # Adds a processor to the queue and adds an observer claim method.
   def add_processor(processor, &claim)
-    @observer_lock.synchronize do
+    @observers.synchronize do
       @processors << processor
     end
 
@@ -113,7 +113,7 @@ class Pigeon::Queue
   
   # Removes a processor from the queue and removes an observer claim method.
   def remove_processor(processor, &claim)
-    @observer_lock.synchronize do
+    @observers.synchronize do
       @processors.delete(processor)
     end
 
@@ -125,7 +125,7 @@ class Pigeon::Queue
   def filter(filter_name, &block)
     raise BlockRequired unless (block_given?)
 
-    @filter_lock.synchronize do
+    @filters.synchronize do
       @filters[filter_name] = block
     end
     
@@ -141,69 +141,64 @@ class Pigeon::Queue
     # If there is an insert operation already in progress, put this task in
     # the backlog for subsequent processing.
     
-    if (@observer_lock.locked?)
-      @insert_backlog << task
-      return task
+    Pigeon::Engine.execute_in_main_thread do
+      self.execute_add_task!(task)
     end
     
-    active_task = task
-    
-    while (active_task) do
-      # Set the claimable task flag for this task since it is not yet in the
-      # actual task queue.
-      @claimable_task[active_task] = true
-    
-      unless (@observers.empty?)
-        @observer_lock.synchronize do
-          @observers.each do |filter_name, list|
-            # Check if this task matches the filter restrictions, and if it
-            # does then call the observer chain in order.
-            if (@filters[filter_name].call(active_task))
-              @observers[filter_name].each do |proc|
-                case (proc.arity)
-                when 2
-                  proc.call(self, active_task)
-                else
-                  proc.call(active_task)
-                end
+    task
+  end
 
-                # An observer callback has the opportunity to claim a task,
-                # and if it does, the claimable task flag will be false. Loop
-                # only while the task is claimable.
-                break unless (@claimable_task[active_task])
+  def execute_add_task!(task)
+    # Set the claimable task flag for this task since it is not yet in the
+    # actual task queue.
+    @claimable_task[task] = true
+  
+    unless (@observers.empty?)
+      @observers.synchronize do
+        @observers.each do |filter_name, list|
+          # Check if this task matches the filter restrictions, and if it
+          # does then call the observer chain in order.
+          if (@filters[filter_name].call(task))
+            @observers[filter_name].each do |proc|
+              case (proc.arity)
+              when 2
+                proc.call(self, task)
+              else
+                proc.call(task)
               end
+
+              # An observer callback has the opportunity to claim a task,
+              # and if it does, the claimable task flag will be false. Loop
+              # only while the task is claimable.
+              break unless (@claimable_task[task])
             end
           end
         end
       end
+    end
 
-        # If this task wasn't claimed by an observer then insert it in the
-        # main task queue.
-      if (@claimable_task.delete(active_task))
-        @filter_lock.synchronize do
-          @tasks << active_task
+    # If this task wasn't claimed by an observer then insert it in the
+    # main task queue.
+    if (@claimable_task.delete(task))
+      @filters.synchronize do
+        @tasks << task
+        
+        # Update the next task slots for all of the unassigned filters and
+        # trigger observer callbacks as required.
+        @next_task.each do |filter_name, next_task|
+          next if (next_task)
           
-          # Update the next task slots for all of the unassigned filters and
-          # trigger observer callbacks as required.
-          @next_task.each do |filter_name, next_task|
-            next if (next_task)
-            
-            if (@filters[filter_name].call(active_task))
-              @next_task[filter_name] = active_task
-            end
+          if (@filters[filter_name].call(task))
+            @next_task[filter_name] = task
           end
         end
       end
-        
-      active_task = @insert_backlog.shift
     end
-
-    task
   end
   
   # Iterates over each of the tasks in the queue.
   def each
-    @filter_lock.synchronize do
+    @filters.synchronize do
       tasks = @tasks.dup
     end
     
@@ -217,17 +212,21 @@ class Pigeon::Queue
   # can also be used to further restrict the qualifying tasks.
   def peek(filter_name = nil, &block)
     if (block_given?)
-      @filter_lock.synchronize do
+      @filters.synchronize do
         @tasks.find(&block)
       end
-    else
+    elsif (filter_name)
       @next_task[filter_name] ||= begin
-        @filter_lock.synchronize do
+        @filters.synchronize do
           filter_proc = @filters[filter_name]
       
           filter_proc and @tasks.find(&filter_proc)
         end
       end
+    else
+      @filters.synchronize do
+        @tasks.first
+      end
     end
   end
   
@@ -235,13 +234,13 @@ class Pigeon::Queue
   # only remove tasks matching that filter's conditions. An optional block
   # can also be used to further restrict the qualifying tasks.
   def pull(filter_name = nil, &block)
-    unless (block_given?)
+    if (!block_given? and filter_name)
       block = @filters[filter_name]
     end
     
-    @filter_lock.synchronize do
-      tasks = @tasks.select(&block)
-      
+    @filters.synchronize do
+      tasks = block ? @tasks.select(&block) : @tasks
+
       @tasks -= tasks
       
       @next_task.each do |filter_name, next_task|
@@ -260,16 +259,18 @@ class Pigeon::Queue
   # be removed from the queue and must be re-inserted if it is to be scheduled
   # again.
   def pop(filter_name = nil, &block)
-    @filter_lock.synchronize do
+    @filters.synchronize do
       task =
         if (block_given?)
           @tasks.find(&block)
-        else
+        elsif (filter_name)
           @next_task[filter_name] || begin
             filter_proc = @filters[filter_name]
 
             filter_proc and @tasks.find(&filter_proc)
           end
+        else
+          @tasks.first
         end
     
       if (task)
@@ -289,7 +290,7 @@ class Pigeon::Queue
   # Claims a task. This is used to indicate that the task will be processed
   # without having to be inserted into the queue.
   def claim(task)
-    @filter_lock.synchronize do
+    @filters.synchronize do
       if (@claimable_task[task])
         @claimable_task[task] = false
       elsif (@tasks.delete(task))
@@ -307,9 +308,9 @@ class Pigeon::Queue
   end
 
   # Returns true if the task is queued, false otherwise.
-  def exist?(task)
-    @filter_lock.synchronize do
-      @tasks.exist?(task)
+  def include?(task)
+    @filters.synchronize do
+      @tasks.include?(task)
     end
   end
   
@@ -318,7 +319,7 @@ class Pigeon::Queue
   # otherwise. An optional block can further restrict qualifying tasks.
   def empty?(filter_name = nil, &block)
     if (block_given?)
-      @filter_lock.synchronize do
+      @filters.synchronize do
         !@tasks.find(&block)
       end
     else
@@ -332,7 +333,7 @@ class Pigeon::Queue
   def length(filter_name = nil, &block)
     filter_proc = @filters[filter_name] 
   
-    @filter_lock.synchronize do
+    @filters.synchronize do
       filter_proc ? @tasks.count(&filter_proc) : nil
     end
   end
@@ -341,7 +342,7 @@ class Pigeon::Queue
   
   # Copies the list of queued tasks to a new Array.
   def to_a
-    @filter_lock.synchronize do
+    @filters.synchronize do
       @tasks.dup
     end
   end
@@ -356,7 +357,7 @@ protected
       return task
     end
     
-    @filter_lock.synchronize do
+    @filters.synchronize do
       @next_task[filter_name] ||= @tasks.find(&filter)
     end
   end

data/lib/pigeon/support.rb

@@ -4,22 +4,70 @@ module Pigeon::Support
   # Uses the double-fork method to create a fully detached background
   # process. Returns the process ID of the created process. May throw an
   # exception if these processes could not be created.
-  def daemonize
+  def daemonize(logger = nil)
+    delay = 10
     rfd, wfd = IO.pipe
     
     forked_pid = fork do
-      daemon_pid = fork do
-        yield
+      rfd.close
+
+      supervisor_pid = fork do
+        relaunch = true
+        
+        while (relaunch)
+          daemon_pid = fork do
+            begin
+              yield
+            rescue Object => e
+              if (logger)
+                logger.error("Terminated with Exception: [#{e.class}] #{e}")
+                logger.error(e.backtrace.join("\n"))
+
+                Thread.list.each do |thread|
+                  logger.error("Stack trace of current threads")
+                  logger.error(thread.inspect)
+                  
+                  if (thread.backtrace)
+                    logger.error("\t" + thread.backtrace.join("\n\t"))
+                  end
+                end
+              end
+            end
+          end
+          
+          begin
+            Process.wait(daemon_pid)
+
+            # A non-zero exit status indicates some sort of error, so the
+            # process will be relaunched after a short delay.
+            relaunch = ($? != 0)
+
+          rescue Interrupt
+            relaunch = false
+          end
+          
+          if (relaunch)
+            logger.info("Will relaunch in %d seconds" % delay)
+
+            sleep(delay)
+          else
+            logger.info("Terminated normally")
+          end
+        end
       end
+
+      wfd.puts(supervisor_pid)
       
-      wfd.puts daemon_pid
       wfd.flush
       wfd.close
     end
 
+    wfd.close
+
     Process.wait(forked_pid)
 
     daemon_pid = rfd.readline
+    rfd.close
     
     daemon_pid.to_i
   end

data/pigeon.gemspec

@@ -5,15 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = %q{pigeon}
-  s.version = "0.5.2"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["tadman"]
-  s.date = %q{2011-04-07}
-  s.default_executable = %q{launcher.example}
+  s.authors = [%q{tadman}]
+  s.date = %q{2011-05-12}
   s.description = %q{Pigeon is a simple way to get started building an EventMachine engine that's intended to run as a background job.}
   s.email = %q{github@tadman.ca}
-  s.executables = ["launcher.example"]
+  s.executables = [%q{launcher.example}]
   s.extra_rdoc_files = [
     "LICENSE",
     "README.rdoc"
@@ -53,8 +52,8 @@ Gem::Specification.new do |s|
     "test/unit/pigeon_test.rb"
   ]
   s.homepage = %q{http://github.com/twg/pigeon}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.0}
+  s.require_paths = [%q{lib}]
+  s.rubygems_version = %q{1.8.1}
   s.summary = %q{Simple daemonized EventMachine engine framework with plug-in support}
   s.test_files = [
     "test/helper.rb",

data/test/helper.rb

@@ -34,4 +34,42 @@ class Test::Unit::TestCase
       end
     end
   end
+
+  def engine
+    exception = nil
+
+    @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
+          end
+        end
+      rescue Object => exception
+      end
+    end
+    
+    @engine_thread.join
+    
+    if (exception)
+      raise exception
+    end
+  end
 end

data/test/unit/pigeon_launcher_test.rb

@@ -4,10 +4,10 @@ class PigeonLauncherTest < Test::Unit::TestCase
   def test_default_launcher
     pid = Pigeon::Launcher.launch
     
-    assert pid
+    assert pid, "PID should be returned from launcher call"
     assert Pigeon::Engine.running?
     
-    Pigeon::Launcher.stop
+    Pigeon::Engine.stop
     
     assert !Pigeon::Engine.running?
   end

data/test/unit/pigeon_processor_test.rb

@@ -77,72 +77,78 @@ class PigeonProcessorTest < Test::Unit::TestCase
   end
   
   def test_reassigning_queues
-    queue_a = Pigeon::Queue.new
-    queue_b = Pigeon::Queue.new
+    engine do
+      queue_a = Pigeon::Queue.new
+      queue_b = Pigeon::Queue.new
     
-    processor = Pigeon::Processor.new(queue_a)
+      processor = Pigeon::Processor.new(queue_a)
     
-    task_a = TaggedTask.new(0)
-    assert !task_a.finished?
+      task_a = TaggedTask.new(0)
+      assert !task_a.finished?
     
-    queue_a << task_a
+      queue_a << task_a
     
-    assert_eventually(1) do
-      task_a.finished?
-    end
+      assert_eventually(1) do
+        task_a.finished?
+      end
     
-    processor.queue = queue_b
+      processor.queue = queue_b
     
-    task_b = TaggedTask.new(1)
-    assert !task_b.finished?
+      task_b = TaggedTask.new(1)
+      assert !task_b.finished?
 
-    queue_b << task_b
+      queue_b << task_b
 
-    assert_eventually(1) do
-      task_b.finished?
-    end
+      assert_eventually(1) do
+        task_b.finished?
+      end
     
-    task_c = TaggedTask.new(2)
+      task_c = TaggedTask.new(2)
 
-    queue_a << task_c
+      queue_a << task_c
 
-    sleep(1)
+      sleep(1)
     
-    assert_equal false, task_c.finished?
+      assert_equal false, task_c.finished?
+    end
   end
   
   def test_can_unassign_queue_from_processor
-    queue = Pigeon::Queue.new
-    processor = Pigeon::Processor.new(queue)
+    engine do
+      queue = Pigeon::Queue.new
+      processor = Pigeon::Processor.new(queue)
     
-    assert_equal queue, processor.queue
-    assert_equal [ processor ], queue.processors
+      assert_equal queue, processor.queue
+      assert_equal [ processor ], queue.processors
     
-    processor.queue = nil
+      processor.queue = nil
     
-    assert_equal nil, processor.queue
-    assert_equal [ ], queue.processors
+      assert_equal nil, processor.queue
+      assert_equal [ ], queue.processors
+    end
   end
 
   def test_multiple_processors
-    queue = Pigeon::Queue.new
-    count = 10000
+    engine do
+      queue = Pigeon::Queue.new
+      count = 10000
     
-    count.times do |n|
-      queue << TaggedTask.new(n)
-    end
+      count.times do |n|
+        queue << TaggedTask.new(n)
+      end
     
-    assert_equal count, queue.length
+      assert_equal count, queue.length
     
-    processors = (0..9).to_a.collect do
-      Pigeon::Processor.new(queue)
-    end
+      processors = (0..9).to_a.collect do
+        Pigeon::Processor.new(queue)
+      end
     
-    assert_eventually(10) do
-      queue.empty?
-    end
+      assert_eventually(10) do
+        queue.empty?
+      end
     
-    assert_equal 0, processors.select(&:task?).length
-    assert_equal 0, queue.length
+      assert_equal 0, processors.select(&:task?).length
+      assert_equal 0, queue.length
+    end
   end
 end

data/test/unit/pigeon_queue_test.rb

@@ -13,16 +13,6 @@ class PigeonQueueTest < Test::Unit::TestCase
       "<#{@tag}>"
     end
   end
-  
-  def setup
-    @engine = Pigeon::Engine.new
-
-    Pigeon::Engine.register_engine(@engine)
-  end
-  
-  def teardown
-    Pigeon::Engine.unregister_engine(@engine)
-  end
 
   def test_empty_state
     queue = Pigeon::Queue.new
@@ -36,170 +26,222 @@ class PigeonQueueTest < Test::Unit::TestCase
   end
   
   def test_cycling
-    queue = Pigeon::Queue.new
+    engine do
+      queue = Pigeon::Queue.new
     
-    task = Pigeon::Task.new
+      task = Pigeon::Task.new
     
-    assert_equal task, queue << task
+      assert_equal task, queue << task
+      
+      assert_eventually do
+        queue.peek == task
+      end
     
-    assert queue.peek
-    assert_equal 1, queue.length
-    assert !queue.empty?
+      assert queue.peek
+      assert_equal 1, queue.length
+      assert !queue.empty?
     
-    found_task = queue.pop
+      found_task = queue.pop
     
-    assert_equal task, found_task
+      assert_equal task, found_task
     
-    assert_equal 0, queue.length
-    assert queue.empty?
+      assert_equal 0, queue.length
+      assert queue.empty?
+    end
   end
     
   def test_filtering
-    queue = Pigeon::Queue.new
+    engine do
+      queue = Pigeon::Queue.new
 
-    tasks = (0..9).to_a.collect do |n|
-      queue << TaggedTask.new(n)
-    end
+      tasks = (0..9).to_a.collect do |n|
+        queue << TaggedTask.new(n)
+      end
+      
+      assert_eventually do
+        queue.length == 10
+      end
     
-    assert_equal (0..9).to_a, tasks.to_a.collect(&:tag)
+      assert_equal (0..9).to_a, tasks.to_a.collect(&:tag)
     
-    assert_equal tasks[0], queue.peek
+      assert_equal tasks[0], queue.peek
 
-    selected_task = queue.peek do |task|
-      task.tag > 0
-    end
+      selected_task = queue.peek do |task|
+        task.tag > 0
+      end
 
-    assert_equal tasks[1], selected_task
+      assert_equal tasks[1], selected_task
     
-    queue.filter(:over_7) do |task|
-      task.tag > 7
-    end
+      queue.filter(:over_7) do |task|
+        task.tag > 7
+      end
 
-    assert_equal tasks[8], queue.peek(:over_7)
-    assert_equal 2, queue.length(:over_7)
+      assert_equal tasks[8], queue.peek(:over_7)
+      assert_equal 2, queue.length(:over_7)
     
-    pulled_task = queue.pop(:over_7)
+      pulled_task = queue.pop(:over_7)
     
-    assert_equal 9, queue.length
+      assert_equal 9, queue.length
 
-    assert_equal tasks[9], queue.peek(:over_7)
-    assert_equal 1, queue.length(:over_7)
+      assert_equal tasks[9], queue.peek(:over_7)
+      assert_equal 1, queue.length(:over_7)
     
-    queue.pop(:over_7)
+      queue.pop(:over_7)
 
-    assert_equal nil, queue.peek(:over_7)
-    assert_equal 0, queue.length(:over_7)
-    assert_equal true, queue.empty?(:over_7)
+      assert_equal nil, queue.peek(:over_7)
+      assert_equal 0, queue.length(:over_7)
+      assert_equal true, queue.empty?(:over_7)
     
-    new_task = queue << TaggedTask.new(10)
+      new_task = queue << TaggedTask.new(10)
     
-    assert_equal new_task, queue.peek(:over_7)
-    assert_equal 1, queue.length(:over_7)
-    assert_equal false, queue.empty?(:over_7)
+      assert_eventually do
+        queue.include?(new_task)
+      end
+    
+      assert_equal new_task, queue.peek(:over_7)
+      assert_equal 1, queue.length(:over_7)
+      assert_equal false, queue.empty?(:over_7)
     
-    queue.claim(new_task)
+      queue.claim(new_task)
     
-    assert_equal nil, queue.peek(:over_7)
-    assert_equal 0, queue.length(:over_7)
-    assert_equal true, queue.empty?(:over_7)
+      assert_equal nil, queue.peek(:over_7)
+      assert_equal 0, queue.length(:over_7)
+      assert_equal true, queue.empty?(:over_7)
+    end
   end
 
   def test_observe
-    queue = Pigeon::Queue.new
+    engine do
+      queue = Pigeon::Queue.new
     
-    tasks = (0..9).to_a.collect do |n|
-      queue << TaggedTask.new(n)
-    end
+      tasks = (0..9).to_a.collect do |n|
+        queue << TaggedTask.new(n)
+      end
     
-    queue.filter(:odd) do |task|
-      task.tag % 2 == 1
-    end
+      queue.filter(:odd) do |task|
+        task.tag % 2 == 1
+      end
+      
+      assert_eventually(2) do
+        queue.length == 10
+      end
     
-    assert_equal tasks[1], queue.peek(:odd)
-    assert_equal 5, queue.length(:odd)
+      assert_equal tasks[1], queue.peek(:odd)
+      assert_equal 5, queue.length(:odd)
     
-    assert_equal [ tasks[1], tasks[3], tasks[5], tasks[7], tasks[9] ], queue.pull(:odd)
+      assert_equal [ tasks[1], tasks[3], tasks[5], tasks[7], tasks[9] ], queue.pull(:odd)
     
-    assert_equal 5, queue.length
-    assert_equal 0, queue.length(:odd)
+      assert_equal 5, queue.length
+      assert_equal 0, queue.length(:odd)
     
-    added_odd = nil
+      added_odd = nil
     
-    queue.observe(:odd) do |task|
-      added_odd = task
-    end
+      queue.observe(:odd) do |task|
+        added_odd = task
+      end
     
-    queue << TaggedTask.new(10)
+      new_task = queue << TaggedTask.new(10)
+      
+      assert_eventually(2) do
+        queue.include?(new_task)
+      end
     
-    assert_equal nil, added_odd
+      assert_equal nil, added_odd
 
-    odd_1 = queue << TaggedTask.new(11)
+      odd_1 = queue << TaggedTask.new(11)
+      
+      assert_eventually(2) do
+        queue.include?(odd_1)
+      end
     
-    assert_equal odd_1, added_odd
+      assert_equal odd_1, added_odd
 
-    claimed_task = nil
-    has_run = false
+      claimed_task = nil
+      has_run = false
     
-    queue.observe(:odd) do |task|
-      claimed_task = queue.claim(task)
-      has_run = true
-    end
+      queue.observe(:odd) do |task|
+        claimed_task = queue.claim(task)
+        has_run = true
+      end
     
-    # Observer callbacks are not triggered on existing data, only on new
-    # insertions.
-    assert_equal false, has_run
-    assert_equal nil, claimed_task
-    assert_equal 7, queue.length
-    assert_equal 1, queue.length(:odd)
-
-    queue << TaggedTask.new(12)
+      # Observer callbacks are not triggered on existing data, only on new
+      # insertions.
+      assert_equal false, has_run
+      assert_equal nil, claimed_task
+      assert_equal 7, queue.length
+      assert_equal 1, queue.length(:odd)
+
+      new_task = queue << TaggedTask.new(12)
+      
+      assert_eventually(2) do
+        queue.include?(new_task)
+      end
     
-    assert_equal nil, claimed_task
-    assert_equal 8, queue.length
-    assert_equal 1, queue.length(:odd)
+      assert_equal nil, claimed_task
+      assert_equal 8, queue.length
+      assert_equal 1, queue.length(:odd)
 
-    odd_2 = queue << TaggedTask.new(13)
+      odd_2 = queue << TaggedTask.new(13)
+      
+      assert_eventually(2) do
+        claimed_task == odd_2
+      end
     
-    # Adding a task that matches the filter triggers the callback.
-    assert_equal odd_2, claimed_task
-    assert_equal true, has_run
+      # Adding a task that matches the filter triggers the callback.
+      assert_equal odd_2, claimed_task
+      assert_equal true, has_run
     
-    # Clear out all of the odd entries.
-    queue.pull(:odd)
+      # Clear out all of the odd entries.
+      queue.pull(:odd)
     
-    claimed_task = nil
-    has_run = false
+      claimed_task = nil
+      has_run = false
 
-    queue << TaggedTask.new(14)
+      new_task = queue << TaggedTask.new(14)
+      
+      assert_eventually(2) do
+        queue.include?(new_task)
+      end
 
-    assert_equal nil, claimed_task
-    assert_equal false, has_run
+      assert_equal nil, claimed_task
+      assert_equal false, has_run
 
-    odd_2 = queue << TaggedTask.new(15)
+      odd_2 = queue << TaggedTask.new(15)
+
+      assert_eventually(2) do
+        odd_2 == claimed_task
+      end
     
-    assert_equal odd_2, claimed_task
-    assert_equal true, has_run
+      assert_equal odd_2, claimed_task
+      assert_equal true, has_run
 
-    assert_equal 8, queue.length
-    assert_equal 0, queue.length(:odd)
+      assert_equal 8, queue.length
+      assert_equal 0, queue.length(:odd)
+    end
   end
   
   def test_can_add_during_observe
-    queue = Pigeon::Queue.new
+    engine do
+      queue = Pigeon::Queue.new
     
-    queue.observe do |task|
-      if (task.tag < 10)
-        queue.claim(task)
+      queue.observe do |task|
+        if (task.tag < 10)
+          queue.claim(task)
 
-        queue << TaggedTask.new(task.tag + 1)
+          queue << TaggedTask.new(task.tag + 1)
+        end
       end
-    end
     
-    queue << TaggedTask.new(0)
+      new_task = queue << TaggedTask.new(0)
+      
+      assert_eventually(2) do
+        queue.peek
+      end
 
-    assert queue.peek
-    assert_equal 10, queue.peek.tag
-    assert_equal 1, queue.length
-    assert queue.peek
+      assert queue.peek
+      assert_equal 10, queue.peek.tag
+      assert_equal 1, queue.length
+      assert queue.peek
+    end
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: pigeon
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors: 
 - tadman
@@ -10,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-07 00:00:00 -04:00
-default_executable: launcher.example
+date: 2011-05-12 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
@@ -66,7 +65,6 @@ files:
 - test/unit/pigeon_sorted_array_test.rb
 - test/unit/pigeon_task_test.rb
 - test/unit/pigeon_test.rb
-has_rdoc: true
 homepage: http://github.com/twg/pigeon
 licenses: []
 
@@ -90,7 +88,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.0
+rubygems_version: 1.8.1
 signing_key: 
 specification_version: 3
 summary: Simple daemonized EventMachine engine framework with plug-in support