super-poller 0.1.0

data/Rakefile

@@ -0,0 +1,34 @@
+require "rubygems"
+require "rake/gempackagetask"
+
+task :default => :test
+
+require "rake/testtask"
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+spec = Gem::Specification.new do |s|
+  s.name              = "super-poller"
+  s.version           = "0.1.0"
+  s.summary           = "Tools for dealing with queues."
+  s.description       = "Small modular library for dealing with queues and pollers."
+  s.author            = "Tom Lea"
+  s.email             = "contrib@tomlea.co.uk"
+  s.homepage          = "http://tomlea.co.uk"
+  s.has_rdoc          = true
+
+  s.files             = %w(Rakefile super_poller.gemspec) + Dir.glob("{bin,test,lib}/**/*")
+  s.executables       = FileList["bin/*"].map { |f| File.basename(f) }
+
+  s.require_paths     = ["lib"]
+  s.rubyforge_project = "super-poller"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, "w") {|f| f << spec.to_ruby }
+end

data/bin/queue

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+script = ARGV.shift
+
+if File.exist?("#{File.dirname(__FILE__)}/scripts/queue_#{script}")
+  load "#{File.dirname(__FILE__)}/scripts/queue_#{script}"
+else
+  STDERR.puts "Available Commands:"
+  Dir.glob("#{File.dirname(__FILE__)}/scripts/queue_*") do |f|
+    STDERR.puts "  " + File.basename(f).gsub(/^queue_/, "")
+  end
+end

data/bin/scripts/queue_choose

@@ -0,0 +1,17 @@
+require "super_poller"
+queue = SuperPoller::QueueUrl.parse(ARGV.shift).to_queue
+
+memo = {:memo => Time.now.to_f}
+queue.push(memo)
+
+SuperPoller::NoneBlockingPoller.new(queue, lambda{|msg|
+  skip = false
+  begin
+    exit if msg == memo
+    p msg
+    print "Kill? > "
+    skip = gets =~ /^[Yy]/
+  ensure
+    queue.push(msg) unless skip or msg == memo
+  end
+}).start!

data/bin/scripts/queue_copy

@@ -0,0 +1,4 @@
+require "super_poller"
+in_queue, out_queue = [nil,nil].map{|url| SuperPoller::QueueUrl.parse(ARGV.shift).to_queue }
+
+SuperPoller::QueueItterator.new(in_queue).each(&out_queue.method(:push))

data/bin/scripts/queue_flush

@@ -0,0 +1,3 @@
+require "super_poller"
+queue = SuperPoller::QueueUrl.parse(ARGV.shift).to_queue
+SuperPoller::NoneBlockingPoller.new(queue, lambda{|msg| }).start!

data/bin/scripts/queue_grep

@@ -0,0 +1,51 @@
+require "super_poller"
+require 'optparse'
+
+options = {}
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage queue grep QUEUE_URL [options]"
+  opts.on("-f STRING", "--ruby-filter STRING", "Set ruby filter") do |v|
+    options[:ruby_filter] = v
+  end
+
+  opts.on("-a STRING", "--ruby-action STRING", "Set ruby action") do |v|
+    options[:ruby_action] = v
+  end
+
+  opts.on("-d", "--delete", "Delete all matches") do |v|
+    options[:ruby_action] = ":delete"
+  end
+
+  opts.on("-c QUEUE", "--copy QUEUE", "Copy all matches") do |v|
+    options[:ruby_action] = "SuperPoller::QueueUrl.parse(#{v.to_s.inspect}).to_queue.push(msg)"
+  end
+
+  opts.on("-m QUEUE", "--move QUEUE", "Move all matches") do |v|
+    options[:ruby_action] = "SuperPoller::QueueUrl.parse(#{v.to_s.inspect}).to_queue.push(msg); :delete"
+  end
+
+  opts.on("-t TYPE", "--message-type TYPE", "Select messages of a given type") do |v|
+    options[:ruby_filter] = "#{v.to_s.inspect} == msg[:name].to_s rescue false"
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit 1
+  end
+end
+
+opts.parse!
+
+unless queue_url = ARGV.shift
+  puts opts
+  exit 1
+end
+
+queue = SuperPoller::QueueUrl.parse(queue_url).to_queue
+
+eval "def matcher_matches?(msg); #{ options[:ruby_filter] || "true" }; end"
+eval "def action(msg); #{ options[:ruby_action] || "p msg" }; end"
+
+SuperPoller::QueueItterator.new(queue).each do |msg|
+  action(msg) if matcher_matches? msg
+end

data/bin/scripts/queue_interactive_move

@@ -0,0 +1,13 @@
+require "super_poller"
+queue_one = SuperPoller::QueueUrl.parse(ARGV.shift).to_queue
+queue_two = SuperPoller::QueueUrl.parse(ARGV.shift).to_queue
+
+SuperPoller::QueueItterator.new(queue_one).each do |msg|
+  p msg
+  print "Move to #{queue_two}? > "
+
+  if gets =~ /^[Yy]/
+    queue_two.push(msg)
+    :delete
+  end
+end

data/bin/scripts/queue_move

@@ -0,0 +1,4 @@
+require "super_poller"
+in_queue, out_queue = [nil,nil].map{|url| SuperPoller::QueueUrl.parse(ARGV.shift).to_queue }
+
+SuperPoller::NoneBlockingPoller.new(in_queue, out_queue.method(:push)).start!

data/bin/scripts/queue_scan

@@ -0,0 +1,3 @@
+require "super_poller"
+queue = SuperPoller::QueueUrl.parse(ARGV.shift).to_queue
+SuperPoller::QueueItterator.new(queue).each(&method(:p))

data/lib/super_poller/aggregating_error_logger.rb

@@ -0,0 +1,33 @@
+class SuperPoller::AggregatingErrorLogger
+  def initialize(stats_file, queue)
+    @stats_file, @queue = stats_file, queue
+  end
+
+  def call(error, failed_message)
+    update_error_queue(error, failed_message)
+    update_error_stats(error, failed_message[:name] || :unknown)
+  end
+
+protected
+  def update_error_queue(error, failed_message)
+    error_class_name = error.class.name.to_sym
+    error_description = {:class => error_class_name, :message => error.message}
+    @queue.push(failed_message.merge(:error => error_description))
+  end
+
+  def update_error_stats(error, message_name)
+    stats = load_stats
+    error_class_name = error.class.name.to_sym
+    stats_for_name = (stats[message_name] ||= {})
+    stats_for_name[error_class_name] ||= 0
+    stats_for_name[error_class_name] += 1
+
+    File.open(@stats_file, "w") do |file|
+      file << YAML.dump(stats)
+    end
+  end
+
+  def load_stats
+    File.exists?(@stats_file) && YAML.load(File.read(@stats_file)) || {}
+  end
+end

data/lib/super_poller/buffered_handler.rb

@@ -0,0 +1,28 @@
+class SuperPoller::BufferedHandler < SuperPoller::Handler
+  class << self
+    def buffer_size(size)
+      @max_buffer_size = size
+    end
+
+    def max_buffer_size
+      @max_buffer_size || []
+    end
+  end
+
+  def initialize
+    @buffer = []
+  end
+
+  def call(msg)
+    @buffer.push msg
+    if @buffer.size >= self.class.max_buffer_size
+      handle_batch @buffer
+      @buffer = []
+    end
+  end
+
+  def handle_batch(batch)
+    raise NotImplementedError, "You must define a batch handler."
+  end
+
+end

data/lib/super_poller/error_reporter.rb

@@ -0,0 +1,12 @@
+class SuperPoller::ErrorReporter
+  def initialize(message_handler, error_handler = nil, &block)
+    @message_handler = message_handler
+    @error_handler = error_handler || block
+  end
+  
+  def call(*args)
+    @message_handler.call(*args)
+  rescue Object => e
+    @error_handler.call(e, *args)
+  end
+end

data/lib/super_poller/handler.rb

@@ -0,0 +1,22 @@
+class SuperPoller::Handler
+  autoload :TestCase, "super_poller/test_case"
+  
+  class << self
+    def handles(*new_message_names)
+      @message_names = (message_names + new_message_names).uniq
+    end
+
+    def message_names
+      @message_names || []
+    end
+  end
+
+  def can_handle?(message)
+    self.class.message_names.include? message[:name].to_sym
+  end
+
+  def call(message)
+    raise NotImplementedError, "You must define a call handler."
+  end
+
+end

data/lib/super_poller/none_blocking_poller.rb

@@ -0,0 +1,13 @@
+class SuperPoller::NoneBlockingPoller < SuperPoller::Poller
+  EmptyQueue = Class.new(Exception)
+
+  def start!
+    super
+  rescue EmptyQueue
+  end
+
+protected
+  def get_message
+    @queue.fetch or raise EmptyQueue
+  end
+end

data/lib/super_poller/poller.rb

@@ -0,0 +1,24 @@
+class SuperPoller::Poller
+  def initialize(queue, message_handler)
+    @message_handler, @queue = message_handler, queue
+  end
+
+  def poll
+    @message_handler.call(get_message)
+  end
+
+  def start!
+    poll while true
+  end
+
+protected
+  def get_message
+    @queue.pop
+  rescue Interrupt
+    raise
+  rescue Object => e
+    STDERR.puts "Error while fetching from the queue: #{e.class}: #{e.message}"
+    sleep 10
+    retry
+  end
+end

data/lib/super_poller/queue_itterator.rb

@@ -0,0 +1,30 @@
+class SuperPoller::QueueItterator
+  def initialize(queue)
+    @queue = queue
+  end
+
+  def each(&block)
+    @memo = {:memo => Time.now.to_f}
+    @queue.push @memo
+    while @memo
+      begin
+        break unless msg = @queue.fetch
+        if msg == @memo
+          msg = @memo = nil
+        else
+          msg = nil if :delete == block.call(msg)
+        end
+      ensure
+        @queue.push msg if msg
+      end
+    end
+  ensure
+    destroy_the_memo
+  end
+
+  def destroy_the_memo
+    while @memo and msg = @queue.fetch and msg != @memo
+      @queue.push(msg)
+    end
+  end
+end

data/lib/super_poller/queue_url.rb

@@ -0,0 +1,18 @@
+require "uri"
+
+class SuperPoller::QueueUrl < URI::Generic
+  def self.parse(url)
+    url = "starling://localhost:22122/#{url}" if url =~ /^[a-zA-Z0-9_-]+$/
+    new(*URI.parse(url).send(:component_ary))
+  end
+
+  def to_queue
+    raise URI::InvalidURIError unless respond_to? "to_#{scheme}_queue"
+    send("to_#{scheme}_queue")
+  end
+
+protected
+  def to_starling_queue
+    SuperPoller::StarlingQueue.new(path, "#{host}:#{port}")
+  end
+end

data/lib/super_poller/router.rb

@@ -0,0 +1,29 @@
+class SuperPoller::Router
+  RoutingError = Class.new(Exception)
+
+  def initialize()
+    @handlers = []
+  end
+
+  def add_handler(handler)
+    @handlers.push handler
+    @handlers.uniq!
+    self
+  end
+
+  alias << add_handler
+
+  def call(message)
+    handler = best_handler_for_message(message)
+    handler.call(message[:body])
+  end
+
+protected
+
+  def best_handler_for_message(messsage)
+    @handlers.each do |handler|
+      return handler if handler.can_handle? messsage
+    end
+    raise RoutingError, "No handler found"
+  end
+end

data/lib/super_poller/starling_queue.rb

@@ -0,0 +1,20 @@
+require "starling"
+
+class SuperPoller::StarlingQueue
+  def initialize(queue_name, *args)
+    @queue_name = queue_name.to_s
+    @queue = Starling.new(*args)
+  end
+
+  def pop
+    @queue.get(@queue_name)
+  end
+
+  def push(v)
+    @queue.set(@queue_name, v)
+  end
+
+  def fetch
+    @queue.fetch(@queue_name)
+  end
+end

data/lib/super_poller/test_case.rb

@@ -0,0 +1,13 @@
+class SuperPoller::Handler::TestCase < (defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase)
+
+  def handler
+    @handler ||= self.class.name.gsub(/Test$/, "").constantize.new
+  end
+
+  def self.should_handle(name)
+    should "handle a #{name.inspect} message" do
+      assert handler.can_handle?(:name => name)
+    end
+  end
+
+end

data/lib/super_poller.rb

@@ -0,0 +1,12 @@
+module SuperPoller
+  autoload :Handler, "super_poller/handler"
+  autoload :BufferedHandler, "super_poller/buffered_handler"
+  autoload :Router, "super_poller/router"
+  autoload :ErrorReporter, "super_poller/error_reporter"
+  autoload :StarlingQueue, "super_poller/starling_queue"
+  autoload :Poller, "super_poller/poller"
+  autoload :AggregatingErrorLogger, "super_poller/aggregating_error_logger"
+  autoload :NoneBlockingPoller, "super_poller/none_blocking_poller"
+  autoload :QueueUrl, "super_poller/queue_url"
+  autoload :QueueItterator, "super_poller/queue_itterator"
+end

data/super_poller.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{super_poller}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Your name"]
+  s.date = %q{2009-09-28}
+  s.email = %q{you@example.com}
+  s.files = ["test/aggregating_error_logger_test.rb", "test/buffered_handler_test.rb", "test/error_reporter_test.rb", "test/handler_test.rb", "test/poller_test.rb", "test/router_test.rb", "test/starling_queue_test.rb", "test/test_helper.rb", "lib/super_poller", "lib/super_poller/aggregating_error_logger.rb", "lib/super_poller/buffered_handler.rb", "lib/super_poller/error_reporter.rb", "lib/super_poller/handler.rb", "lib/super_poller/poller.rb", "lib/super_poller/router.rb", "lib/super_poller/starling_queue.rb", "lib/super_poller/test_case.rb", "lib/super_poller.rb"]
+  s.homepage = %q{http://example.com}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{What this thing does}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/aggregating_error_logger_test.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+
+class AggregatingErrorLoggerTest < Test::Unit::TestCase
+  include SuperPoller
+  attr_reader :queued_message
+
+  def log_contents
+    YAML.load(File.open(@path))
+  end
+
+  context "With an error logger" do
+    setup do
+      @log_file = Tempfile.new("AggregatingErrorLoggerTest")
+      @path = @log_file.path
+      @queue = Queue.new
+      @logger = AggregatingErrorLogger.new(@path, @queue)
+    end
+
+    context "with a exception and message passed in, it" do
+      setup do
+        @exception = Exception.new("The house is on fire")
+        @message = {:name => :foo, :body => "hello"}
+        @logger.call(@exception, @message)
+        @queued_message = @queue.pop(nonblocking = true)
+      end
+
+      should "add errors to the error queue" do
+        assert_equal :foo, queued_message[:name]
+        assert_equal "hello", queued_message[:body]
+      end
+
+      should "add error info to the queued message" do
+        assert_equal( {:class => :Exception, :message => "The house is on fire"}, queued_message[:error])
+      end
+
+      should "log errors to the log file" do
+        assert_equal( {:foo  => {:Exception => 1} }, log_contents)
+      end
+
+      should "aggregate duplicate errors" do
+        @logger.call(@exception, @message)
+        assert_equal( {:foo  => {:Exception => 2} }, log_contents)
+      end
+
+      should "separate different exceptions" do
+        @logger.call(ArgumentError.new(""), @message)
+        assert_equal( {:foo  => {:Exception => 1, :ArgumentError => 1} }, log_contents)
+      end
+
+      should "separate errors for different message names" do
+        @logger.call(@exception, {:name => :bar, :body => "hello"})
+        assert_equal( {:foo => {:Exception => 1}, :bar => {:Exception => 1} }, log_contents)
+      end
+
+      should "reset the counts to 0 if we delete the log file" do
+        assert_equal( {:foo  => {:Exception => 1} }, log_contents)
+        File.delete(@path)
+        @logger.call(@exception, {:name => :bar, :body => "hello"})
+        assert_equal( {:bar  => {:Exception => 1} }, log_contents)
+      end
+
+    end
+  end
+end

data/test/buffered_handler_test.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class BufferedHandlerTest < Test::Unit::TestCase
+  include SuperPoller
+  def self.should_submit_batches_for_messages(args = {})
+    context "that receives #{args[:messages]} messages" do
+      setup{ args[:messages].times{@handler.call(:your_mum)} }
+
+      before_should "handle #{args[:batches]} batches" do
+        @handler.expects(:handle_batch).with([:your_mum] * args[:batch_size]).times(args[:batches])
+      end
+    end
+  end
+
+  context "With a buffered handler with a buffer size of 10" do
+    setup{ @handler = Class.new(BufferedHandler){ buffer_size 10 }.new }
+
+    should_submit_batches_for_messages :batch_size => 10, :messages => 0, :batches => 0
+
+    should_submit_batches_for_messages :batch_size => 10, :messages => 9, :batches => 0
+    should_submit_batches_for_messages :batch_size => 10, :messages => 10, :batches => 1
+    should_submit_batches_for_messages :batch_size => 10, :messages => 11, :batches => 1
+
+    should_submit_batches_for_messages :batch_size => 10, :messages => 19, :batches => 1
+    should_submit_batches_for_messages :batch_size => 10, :messages => 20, :batches => 2
+    should_submit_batches_for_messages :batch_size => 10, :messages => 21, :batches => 2
+  end
+
+  context "With a buffered handler with a buffer size of 8" do
+    setup{ @handler = Class.new(BufferedHandler){ buffer_size 8 }.new }
+
+    should_submit_batches_for_messages :batch_size => 8, :messages => 7, :batches => 0
+    should_submit_batches_for_messages :batch_size => 8, :messages => 8, :batches => 1
+
+    should_submit_batches_for_messages :batch_size => 8, :messages => 16, :batches => 2
+  end
+
+  context "With a buffered handler with a buffer size of 0" do
+    setup{ @handler = Class.new(BufferedHandler){ buffer_size 0 }.new }
+
+    should_submit_batches_for_messages :batch_size => 1, :messages => 0, :batches => 0
+    should_submit_batches_for_messages :batch_size => 1, :messages => 1, :batches => 1
+  end
+
+end

data/test/error_reporter_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class ErrorReporterTest < Test::Unit::TestCase
+  include SuperPoller
+  
+  should "catch errors and report them to the provided error handler" do
+    has_caught = false
+    raiser = proc{|msg| raise "Error doing a #{msg}" }
+    handler = proc{|e, message| has_caught = (e.message == "Error doing a Hello" and message == "Hello") }
+
+    ErrorReporter.new(raiser, handler).call("Hello")
+
+    assert has_caught
+  end
+
+  should "catch errors and report them to the provided error handling block" do
+    has_caught = false
+    raiser = proc{|msg| raise "Error doing a #{msg}" }
+
+    ErrorReporter.new(raiser){|e, message| has_caught = (e.message == "Error doing a Hello" and message == "Hello") }.call("Hello")
+
+    assert has_caught
+  end
+
+  should "not catch errors if they don't happen" do
+    ErrorReporter.new(stub("handler", :call)){|*args| flunk "Should not have tried to raise!" }.call("Hello")
+  end
+end

data/test/handler_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class HandlerTest < Test::Unit::TestCase
+  include SuperPoller
+
+  context "With handlers for :foo and :bar messages" do
+    setup do
+      @foo_handler = Class.new(Handler){ handles :foo }.new
+      @bar_handler = Class.new(Handler){ handles :bar }.new
+    end
+
+    should "only foo_handler should handle a message named :foo" do
+      assert @foo_handler.can_handle?({:name => :foo})
+      assert !@bar_handler.can_handle?({:name => :foo})
+    end
+
+    should "only bar_handler should handle a message named :bar" do
+      assert !@foo_handler.can_handle?({:name => :bar})
+      assert @bar_handler.can_handle?({:name => :bar})
+    end
+
+    should "accept strings or symbols as names" do
+      assert @foo_handler.can_handle?({:name => "foo"})
+    end
+
+  end
+  
+end

data/test/poller_test.rb

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class PollerTest < Test::Unit::TestCase
+  include SuperPoller
+  
+  def setup
+    @queue = Queue.new
+    @message_handler = stub("message_handler")
+    @poller = Poller.new(@queue, @message_handler)
+  end
+  
+  should "pull things from the queue to the message_handler" do
+    @queue.push "Oh Hi!"
+    @message_handler.expects(:call).with("Oh Hi!").once
+    @poller.poll
+  end
+
+  should "pull more than one thing from the queue to the message_handler" do
+    @queue.push "First"
+    @queue.push "Second"
+
+    @message_handler.expects(:call).with("First").once
+    @message_handler.expects(:call).with("Second").once
+    
+    2.times{ @poller.poll }
+  end
+end

data/test/router_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class RouterTest < Test::Unit::TestCase
+  include SuperPoller
+
+  context "With a router that has two handlers" do
+
+    setup do
+      @router = Router.new
+      @foo_handler = Class.new(Handler){ handles :foo }.new
+      @bar_handler = Class.new(Handler){ handles :bar }.new
+      @router << @foo_handler << @bar_handler
+    end
+    
+    should "route foo messages to the correct handler" do
+      @foo_handler.expects(:call).with("test body").once
+      @bar_handler.expects(:call).never
+      @router.call({:name => :foo, :body => "test body"})
+    end
+
+    should "route bar messages to the correct handler" do
+      @foo_handler.expects(:call).never
+      @bar_handler.expects(:call).with("test body").once
+      @router.call({:name => :bar, :body => "test body"})
+    end
+
+    should "raise RoutingError if handler not found" do
+      assert_raise(Router::RoutingError){ @router.call(:name => :your_mum) }
+    end
+
+  end
+end

data/test/starling_queue_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+class StarlingQueueTest < Test::Unit::TestCase
+  include SuperPoller
+
+  STARLING_QUEUE_PATH = '/tmp/reevoo_superpoller_starling'
+  STARLING_PID_PATH = '/tmp/reevoo_superpoller_starling.pid'
+  STARLING_PORT = '13891'
+
+  context "with a running starling" do
+    setup do
+      FileUtils.rm_r STARLING_QUEUE_PATH if File.exists? STARLING_QUEUE_PATH
+      FileUtils.rm_r STARLING_PID_PATH if File.exists? STARLING_PID_PATH
+      system("starling -p #{STARLING_PORT} -P #{STARLING_PID_PATH} -q #{STARLING_QUEUE_PATH} -d 2>&1")
+      sleep 1
+    end
+
+    teardown do
+      system("kill -9 `cat #{STARLING_PID_PATH}`")
+    end
+
+    should "write to and read from a queue in the correct order" do
+      queue = StarlingQueue.new("TEST_QUEUE", ["localhost:#{STARLING_PORT}"])
+      queue.push("first")
+      queue.push("second")
+      assert_equal "first", queue.pop
+      assert_equal "second", queue.pop
+    end
+
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require "test/unit"
+require "shoulda"
+require "mocha"
+require "tempfile"
+require "starling"
+
+require File.join(File.dirname(__FILE__), *%w[.. lib  super_poller])

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: super-poller
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Tom Lea
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-09 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Small modular library for dealing with queues and pollers.
+email: contrib@tomlea.co.uk
+executables: 
+- queue
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- super_poller.gemspec
+- bin/queue
+- bin/scripts/queue_choose
+- bin/scripts/queue_copy
+- bin/scripts/queue_flush
+- bin/scripts/queue_grep
+- bin/scripts/queue_interactive_move
+- bin/scripts/queue_move
+- bin/scripts/queue_scan
+- test/aggregating_error_logger_test.rb
+- test/buffered_handler_test.rb
+- test/error_reporter_test.rb
+- test/handler_test.rb
+- test/poller_test.rb
+- test/router_test.rb
+- test/starling_queue_test.rb
+- test/test_helper.rb
+- lib/super_poller/aggregating_error_logger.rb
+- lib/super_poller/buffered_handler.rb
+- lib/super_poller/error_reporter.rb
+- lib/super_poller/handler.rb
+- lib/super_poller/none_blocking_poller.rb
+- lib/super_poller/poller.rb
+- lib/super_poller/queue_itterator.rb
+- lib/super_poller/queue_url.rb
+- lib/super_poller/router.rb
+- lib/super_poller/starling_queue.rb
+- lib/super_poller/test_case.rb
+- lib/super_poller.rb
+has_rdoc: true
+homepage: http://tomlea.co.uk
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: super-poller
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Tools for dealing with queues.
+test_files: []
+