adrian 1.0.0

data/CONTRIBUTING.md

@@ -0,0 +1,7 @@
+# Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/README.md

@@ -0,0 +1,23 @@
+# Adrian
+
+Adrian is a work dispatcher and some queue implementations.
+Adrian does not do any real work, but is really good at delegating it.
+Adrian **does not care how** real work get's done, but **makes damn sure that it does get done**.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'adrian'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install adrian
+
+## Usage
+
+TODO: Write usage instructions here

data/lib/adrian.rb

@@ -0,0 +1,13 @@
+require 'adrian/version'
+
+module Adrian
+  autoload :ArrayQueue,           'adrian/array_queue'
+  autoload :CompositeQueue,       'adrian/composite_queue'
+  autoload :DirectoryQueue,       'adrian/directory_queue'
+  autoload :Dispatcher,           'adrian/dispatcher'
+  autoload :FileItem,             'adrian/file_item'
+  autoload :Filters,              'adrian/filters'
+  autoload :GirlFridayDispatcher, 'adrian/girl_friday_dispatcher'
+  autoload :QueueItem,            'adrian/queue_item'
+  autoload :Worker,               'adrian/worker'
+end

data/lib/adrian/array_queue.rb

@@ -0,0 +1,26 @@
+require 'adrian/queue'
+
+module Adrian
+  class ArrayQueue < Queue
+    def initialize(array = [])
+      @array = array.map { |item| wrap_item(item) }
+      @mutex = Mutex.new
+    end
+
+    def pop
+      @mutex.synchronize { @array.shift }
+    end
+
+    def push(item)
+      item = wrap_item(item)
+      @mutex.synchronize { @array << item }
+      self
+    end
+
+    protected
+
+    def wrap_item(item)
+      item.is_a?(QueueItem) ? item : QueueItem.new(item)
+    end
+  end
+end

data/lib/adrian/composite_queue.rb

@@ -0,0 +1,22 @@
+require 'adrian/queue'
+
+module Adrian
+  class CompositeQueue < Queue
+    def initialize(*queues)
+      @queues = queues.flatten
+    end
+
+    def pop
+      @queues.each do |q|
+        item = q.pop
+        return item if item
+      end
+
+      nil
+    end
+
+    def push(item)
+      raise "You can not push item to a composite queue"
+    end
+  end
+end

data/lib/adrian/directory_queue.rb

@@ -0,0 +1,85 @@
+require 'fileutils'
+
+module Adrian
+  class DirectoryQueue < Queue
+    include Filters
+
+    def self.create(options = {})
+      queue = new(options)
+      FileUtils.mkdir_p(queue.available_path)
+      FileUtils.mkdir_p(queue.reserved_path)
+      queue
+    end
+
+    attr_reader :available_path, :reserved_path
+
+    # Note:
+    # There is the possibility of an item being consumed by multiple processes when its still in the queue after its lock expires.
+    # The reason for allowing this is:
+    #   1. It's much simpler than introducing a seperate monitoring process to handle lock expiry.
+    #   2. This is an acceptable and rare event. e.g. it only happens when the process working on the item crashes without being able to release the lock
+    def initialize(options = {})
+      @available_path = options.fetch(:path)
+      @reserved_path  = options.fetch(:reserved_path, default_reserved_path)
+      filters << Filters::FileLock.new(:duration => options[:lock_duration], :reserved_path => reserved_path)
+      filters << Filters::Delay.new(:duration => options[:delay]) if options[:delay]
+    end
+
+    def pop
+      items.each do |item|
+        return item if reserve(item)
+      end
+
+      nil
+    end
+
+    def push(value)
+      item = wrap_item(value)
+      item.move(@available_path)
+      item.touch
+      self
+    end
+
+    def include?(value)
+      item = wrap_item(value)
+      items.include?(item)
+    end
+
+    protected
+
+    def wrap_item(value)
+      value.is_a?(FileItem) ? value : FileItem.new(value)
+    end
+
+    def reserve(item)
+      item.move(@reserved_path)
+      item.touch
+      true
+    rescue Errno::ENOENT => e
+      false
+    end
+
+    def items
+      items = files.map { |file| FileItem.new(file) }
+      items.reject! { |item| filter?(item) }
+      items.sort_by(&:updated_at)
+    end
+
+    def files
+      (available_files + reserved_files).select { |file| File.file?(file) }
+    end
+
+    def available_files
+      Dir.glob("#{@available_path}/*")
+    end
+
+    def reserved_files
+      Dir.glob("#{@reserved_path}/*")
+    end
+
+    def default_reserved_path
+      File.join(File.dirname(@available_path), 'cur')
+    end
+
+  end
+end

data/lib/adrian/dispatcher.rb

@@ -0,0 +1,57 @@
+require 'adrian/failure_handler'
+
+module Adrian
+  class Dispatcher
+    attr_reader :running
+
+    def initialize(options = {})
+      @failure_handler = FailureHandler.new
+      @stop_when_done  = !!options[:stop_when_done]
+      @sleep           = options[:sleep] || 0.5
+      @options         = options
+    end
+
+    def on_failure(*exceptions)
+      @failure_handler.add_rule(*exceptions, &Proc.new)
+    end
+
+    def on_done
+      @failure_handler.add_rule(nil, &Proc.new)
+    end
+
+    def start(queue, worker_class)
+      @running = true
+
+      while @running do
+        if item = queue.pop
+          delegate_work(item, worker_class)
+        else
+          if @stop_when_done
+            stop
+          else
+            sleep(@sleep) if @sleep
+          end
+        end
+      end
+    end
+
+    def stop
+      @running = false
+    end
+
+    def delegate_work(item, worker_class)
+      worker = worker_class.new(item)
+      worker.report_to(self)
+      worker.perform
+    end
+
+    def work_done(item, worker, exception = nil)
+      if handler = @failure_handler.handle(exception)
+        handler.call(item, worker, exception)
+      else
+        raise exception if exception
+      end
+    end
+
+  end
+end

data/lib/adrian/failure_handler.rb

@@ -0,0 +1,36 @@
+module Adrian
+  class FailureHandler
+    def initialize
+      @rules = []
+    end
+
+    def add_rule(*exceptions, &block)
+      exceptions.each do |exception_class|
+        @rules << Rule.new(exception_class, block)
+      end
+    end
+
+    def handle(exception)
+      if rule = @rules.find { |r| r.match(exception) }
+        rule.block
+      end
+    end
+
+    class Rule
+      attr_reader :block
+
+      def initialize(exception_class, block)
+        @exception_class = exception_class
+        @block           = block
+      end
+
+      def match(exception)
+        return @exception_class.nil? if exception.nil?
+
+        return false if @exception_class.nil?
+
+        exception.is_a?(@exception_class)
+      end
+    end
+  end
+end

data/lib/adrian/file_item.rb

@@ -0,0 +1,36 @@
+module Adrian
+  class FileItem < QueueItem
+
+    def path
+      value
+    end
+
+    def name
+      File.basename(path)
+    end
+
+    def ==(other)
+      other.respond_to?(:name) &&
+        name == other.name
+    end
+
+    def move(destination)
+      destination_path = File.join(destination, File.basename(path))
+      File.rename(path, destination_path)
+      @value = destination_path
+    end
+
+    def updated_at
+      File.mtime(path).utc if exist?
+    end
+
+    def touch(updated_at = Time.new)
+      File.utime(updated_at, updated_at, path)
+    end
+
+    def exist?
+      File.exist?(path)
+    end
+
+  end
+end

data/lib/adrian/filters.rb

@@ -0,0 +1,56 @@
+module Adrian
+  module Filters
+
+    def filters
+      @filters ||= []
+    end
+
+    def filter?(item)
+      !filters.all? { |filter| filter.allow?(item) }
+    end
+
+    class Delay
+      FIFTEEN_MINUTES = 900
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def allow?(item)
+        item.updated_at <= (Time.new - duration)
+      end
+
+      def duration
+        @options[:duration] ||= FIFTEEN_MINUTES
+      end
+
+    end
+
+    class FileLock
+      ONE_HOUR = 3_600
+
+      def initialize(options = {})
+        @options       = options
+        @reserved_path = @options.fetch(:reserved_path)
+      end
+
+      def allow?(item)
+        !locked?(item) || lock_expired?(item)
+      end
+
+      def lock_expired?(item)
+        item.updated_at <= (Time.new - duration)
+      end
+
+      def locked?(item)
+        @reserved_path == File.dirname(item.path)
+      end
+
+      def duration
+        @options[:duration] ||= ONE_HOUR
+      end
+
+    end
+
+  end
+end

data/lib/adrian/girl_friday_dispatcher.rb

@@ -0,0 +1,40 @@
+require 'girl_friday'
+
+module Adrian
+  class GirlFridayDispatcher < Dispatcher
+    def gf_queue_name
+      @options[:name] || 'adrian_queue'
+    end
+
+    def gf_queue_size
+      @options[:size]
+    end
+
+    def gf_queue
+      @gf_queue ||= GirlFriday::WorkQueue.new(gf_queue_name, :size => gf_queue_size) do |item, worker_class|
+        worker = worker_class.new(item)
+        worker.report_to(self)
+        worker.perform
+      end
+    end
+
+    def delegate_work(item, worker_class)
+      gf_queue.push([item, worker_class])
+    end
+
+    def wait_for_empty
+      gf_queue.wait_for_empty
+
+      sleep(0.5)
+
+      while gf_queue.status[gf_queue_name][:busy] != 0
+        sleep(0.5)
+      end
+    end
+
+    def stop
+      super
+      wait_for_empty
+    end
+  end
+end

data/lib/adrian/queue.rb

@@ -0,0 +1,11 @@
+module Adrian
+  class Queue
+    def pop
+      raise "#{self.class.name}#pop is not defined"
+    end
+
+    def push(item)
+      raise "#{self.class.name}#push is not defined"
+    end
+  end
+end

data/lib/adrian/queue_item.rb

@@ -0,0 +1,10 @@
+module Adrian
+  class QueueItem
+    attr_reader :value, :created_at
+
+    def initialize(value, created_at = Time.now)
+      @value      = value
+      @created_at = created_at
+    end
+  end
+end

data/lib/adrian/version.rb

@@ -0,0 +1,3 @@
+module Adrian
+  VERSION = '1.0.0'
+end

data/lib/adrian/worker.rb

@@ -0,0 +1,29 @@
+module Adrian
+  class Worker
+    attr_reader :item
+
+    def initialize(item)
+      @item = item
+    end
+
+    def report_to(boss)
+      @boss = boss
+    end
+
+    def perform
+      exception = nil
+
+      begin
+        work
+      rescue Exception => e
+        exception = e
+      end
+
+      @boss.work_done(item, self, exception) if @boss
+    end
+
+    def work
+      raise "You need to implement #{self.class.name}#work"
+    end
+  end
+end

data/test/array_queue_test.rb

@@ -0,0 +1,29 @@
+require_relative 'test_helper'
+
+describe Adrian::ArrayQueue do
+  it 'should allow construction with an array' do
+    q = Adrian::ArrayQueue.new([1,2,3])
+    q.pop.value.must_equal 1
+    q.pop.value.must_equal 2
+    q.pop.value.must_equal 3
+    q.pop.must_be_nil
+  end
+
+  it 'should allow construction without an array' do
+    q = Adrian::ArrayQueue.new
+    q.pop.must_be_nil
+  end
+
+  it 'should act as a queue' do
+    q = Adrian::ArrayQueue.new
+
+    q.push(1)
+    q.push(2)
+    q.push(3)
+
+    q.pop.value.must_equal 1
+    q.pop.value.must_equal 2
+    q.pop.value.must_equal 3
+    q.pop.must_be_nil
+  end
+end

data/test/composite_queue_test.rb

@@ -0,0 +1,36 @@
+require_relative 'test_helper'
+
+describe Adrian::CompositeQueue do
+  before do
+    @q1 = Adrian::ArrayQueue.new
+    @q2 = Adrian::ArrayQueue.new
+    @q  = Adrian::CompositeQueue.new(@q1, @q2)
+  end
+
+  describe "popping" do
+    it 'should return nil when all queues are empty' do
+      @q.pop.must_be_nil
+    end
+
+    it 'should return an item from the first queue that has items' do
+      @q1.push(1)
+      @q1.push(2)
+      @q2.push(3)
+      @q2.push(4)
+
+      @q.pop.value.must_equal(1)
+      @q.pop.value.must_equal(2)
+      @q.pop.value.must_equal(3)
+      @q.pop.value.must_equal(4)
+      @q.pop.must_be_nil
+      @q1.pop.must_be_nil
+      @q2.pop.must_be_nil
+    end
+  end
+
+  describe "pushing" do
+    it "should not be allowed" do
+      lambda { @q.push(1) }.must_raise(RuntimeError)
+    end
+  end
+end

data/test/directory_queue_test.rb

@@ -0,0 +1,141 @@
+require_relative 'test_helper'
+require 'tempfile'
+require 'tmpdir'
+require 'fileutils'
+
+describe Adrian::DirectoryQueue do
+  before do
+    @q = Adrian::DirectoryQueue.create(:path => Dir.mktmpdir('dir_queue_test'))
+  end
+
+  after do
+   FileUtils.rm_r(@q.available_path, :force => true)
+   FileUtils.rm_r(@q.reserved_path,  :force => true)
+  end
+
+  it 'should act as a queue for files' do
+    item1 = Tempfile.new('item1-').path
+    item2 = Tempfile.new('item2-').path
+    item3 = Tempfile.new('item3-').path
+
+    @q.push(item1)
+    @q.push(item2)
+    @q.push(item3)
+
+    @q.pop.must_equal Adrian::FileItem.new(item1)
+    @q.pop.must_equal Adrian::FileItem.new(item2)
+    @q.pop.must_equal Adrian::FileItem.new(item3)
+    @q.pop.must_be_nil
+  end
+
+  describe 'file backend' do
+
+    describe 'pop' do
+      before do
+        @item = Adrian::FileItem.new(Tempfile.new('item').path)
+      end
+
+      it 'provides an available file' do
+        @q.push(@item)
+        assert_equal @item, @q.pop
+      end
+
+      it 'moves the file to the reserved directory' do
+        @q.push(@item)
+        original_path = @item.path
+        item = @q.pop
+        assert_equal @item, item
+
+        assert_equal false, File.exist?(original_path)
+        assert_equal true,  File.exist?(File.join(@q.reserved_path, @item.name))
+      end
+
+      it 'reserves the file for an hour by default' do
+        @q.push(@item)
+        reserved_item = @q.pop
+        assert reserved_item
+        one_hour = 3_600
+
+        Time.stub(:new, reserved_item.updated_at + one_hour - 1) do
+          assert_equal nil, @q.pop
+        end
+
+        Time.stub(:new, reserved_item.updated_at + one_hour) do
+          assert_equal @item, @q.pop
+        end
+
+      end
+
+      it 'touches the item' do
+        @q.push(@item)
+        now  = Time.new - 100
+        item = nil
+        Time.stub(:new, now) { item = @q.pop }
+
+        assert_equal now.to_i, item.updated_at.to_i
+      end
+
+      it 'skips the file when moved by another process' do
+        def @q.files
+          [ 'no/longer/exists' ]
+        end
+        assert_equal nil, @q.pop
+      end
+
+      it "only provides normal files" do
+        not_file = Dir.mktmpdir(@q.available_path, 'directory_queue_x')
+        assert_equal nil, @q.pop
+      end
+
+    end
+
+    describe 'push' do
+      before do
+        @item = Adrian::FileItem.new(Tempfile.new('item').path)
+      end
+
+      it 'moves the file to the available directory' do
+        original_path = @item.path
+        @q.push(@item)
+
+        assert_equal false, File.exist?(original_path)
+        assert_equal true,  File.exist?(File.join(@q.available_path, @item.name))
+      end
+
+      it 'touches the item' do
+        now = Time.new - 100
+        Time.stub(:new, now) { @q.push(@item) }
+
+        assert_equal now.to_i, @item.updated_at.to_i
+      end
+
+    end
+
+    describe 'filters' do
+      it 'should add a delay filter if the :delay option is given' do
+        q = Adrian::DirectoryQueue.create(:path => Dir.mktmpdir('dir_queue_test'))
+        filter = q.filters.find {|filter| filter.is_a?(Adrian::Filters::Delay)}
+        filter.must_equal nil
+
+        q = Adrian::DirectoryQueue.create(:path => Dir.mktmpdir('dir_queue_test'), :delay => 300)
+        filter = q.filters.find {|filter| filter.is_a?(Adrian::Filters::Delay)}
+        filter.wont_equal nil
+        filter.duration.must_equal 300
+      end
+
+      it 'should add a lock filter that can be configured with the :lock_duration option' do
+        q = Adrian::DirectoryQueue.create(:path => Dir.mktmpdir('dir_queue_test'))
+        filter = q.filters.find {|filter| filter.is_a?(Adrian::Filters::FileLock)}
+        filter.wont_equal nil
+        filter.duration.must_equal 3600 # default value
+
+        q = Adrian::DirectoryQueue.create(:path => Dir.mktmpdir('dir_queue_test'), :lock_duration => 300)
+        filter = q.filters.find {|filter| filter.is_a?(Adrian::Filters::FileLock)}
+        filter.wont_equal nil
+        filter.duration.must_equal 300
+      end
+    end
+
+  end
+
+end

data/test/dispatcher_lifecycle_test.rb

@@ -0,0 +1,82 @@
+require_relative 'test_helper'
+
+describe "Adrian::Dispatcher lifecycle" do
+  class Worker < Adrian::Worker
+    def work
+      $done_items << item.value
+    end
+  end
+
+  before do
+    $done_items = []
+    @q = Adrian::ArrayQueue.new([1,2,3])
+  end
+
+  describe "stop_when_done" do
+    describe "set to true" do
+      before do
+        @dispatcher = Adrian::Dispatcher.new(:stop_when_done => true)
+      end
+
+      it "should have all the work done and stop" do
+        t = Thread.new do
+          @dispatcher.start(@q, Worker)
+        end
+
+        sleep(0.5)
+
+        @q.pop.must_be_nil
+
+        $done_items.must_equal([1,2,3])
+
+        @dispatcher.running.must_equal false
+      end
+    end
+
+    describe "set to false" do
+      before do
+        @dispatcher = Adrian::Dispatcher.new(:stop_when_done => false)
+      end
+
+      it "should have all the work done and continue" do
+        t = Thread.new do
+          @dispatcher.start(@q, Worker)
+        end
+
+        sleep(0.5)
+
+        @q.pop.must_be_nil
+
+        $done_items.must_equal([1,2,3])
+
+        @dispatcher.running.must_equal true
+        t.kill
+      end
+    end
+  end
+
+  describe "#stop" do
+    before do
+      @dispatcher = Adrian::Dispatcher.new(:sleep => 0.1)
+    end
+
+    it "should stop a running dispatcher" do
+      t = Thread.new do
+        @dispatcher.start(@q, Worker)
+      end
+
+      sleep(0.5)
+
+      @dispatcher.running.must_equal true
+      t.status.wont_equal false
+
+      @dispatcher.stop
+
+      sleep(0.5)
+
+      @dispatcher.running.must_equal false
+      t.status.must_equal false
+    end
+  end
+
+end

data/test/dispatcher_test.rb

@@ -0,0 +1,52 @@
+require_relative 'test_helper'
+
+describe Adrian::Dispatcher do
+  before do
+    $done_items = []
+    @q = Adrian::ArrayQueue.new
+    @dispatcher = Adrian::Dispatcher.new(:stop_when_done => true)
+  end
+
+  describe "work delegation" do
+    it "should instantiate an instance of the worker for each item and ask it to perform" do
+      worker = Class.new do
+        def initialize(item)
+          @item = item
+        end
+
+        def perform
+          $done_items << [@boss, @item.value]
+        end
+
+        def report_to(boss)
+          @boss = boss
+        end
+      end
+
+      @q.push(1)
+      @q.push(2)
+      @q.push(3)
+
+      @dispatcher.start(@q, worker)
+
+      $done_items.must_equal([[@dispatcher, 1], [@dispatcher, 2], [@dispatcher, 3]])
+    end
+  end
+
+  describe "work evaluation" do
+    it "should use the failure handler to handle the result" do
+      @dispatcher.on_failure(RuntimeError) do |item, worker, exception|
+        @q.push(item)
+      end
+
+      @dispatcher.work_done(1, nil)
+      @q.pop.must_be_nil
+
+      @dispatcher.work_done(1, nil, nil)
+      @q.pop.must_be_nil
+
+      @dispatcher.work_done(1, nil, RuntimeError.new)
+      @q.pop.value.must_equal 1
+    end
+  end
+end

data/test/failure_handler_test.rb

@@ -0,0 +1,44 @@
+require_relative 'test_helper'
+
+require 'adrian/failure_handler'
+
+describe Adrian::FailureHandler do
+  before do
+    @handler = Adrian::FailureHandler.new
+
+    $failure = nil
+
+    @handler.add_rule(RuntimeError)  { :runtime  }
+    @handler.add_rule(StandardError) { :standard }
+  end
+
+  it "should match rules in the order they were added" do
+    block = @handler.handle(RuntimeError.new)
+    assert block
+    block.call.must_equal :runtime
+
+    block = @handler.handle(StandardError.new)
+    assert block
+    block.call.must_equal :standard
+  end
+
+  it "should do nothing when no rules match" do
+    @handler.handle(Exception.new).must_be_nil
+  end
+
+  describe "the success rule" do
+    before do
+      @handler = Adrian::FailureHandler.new
+      @handler.add_rule(nil) { :success  }
+    end
+
+    it "should match when there is no exception" do
+      @handler.handle(RuntimeError.new).must_be_nil
+
+      block = @handler.handle(nil)
+      assert block
+      block.call.must_equal :success
+    end
+  end
+
+end

data/test/file_item_test.rb

@@ -0,0 +1,63 @@
+require_relative 'test_helper'
+require 'tempfile'
+
+describe Adrian::FileItem do
+  before do
+    @item = Adrian::FileItem.new(Tempfile.new('file_item_test').path)
+  end
+
+  it 'aliases value as path' do
+    item = Adrian::FileItem.new('path/a')
+    assert_equal 'path/a', item.value
+  end
+
+  it 'has a name from the path' do
+    item = Adrian::FileItem.new('path/name.ext')
+    assert_equal 'name.ext', item.name
+  end
+
+  it 'is equal to another item when they have the same name' do
+    item1 = Adrian::FileItem.new('path/a')
+    item2 = Adrian::FileItem.new('path/b')
+    assert(item1 != item2)
+
+    item3 = Adrian::FileItem.new('path/a')
+    assert_equal item1, item3
+  end
+
+  describe 'move' do
+    before do
+      @destination = Dir.mktmpdir('file_item_move_test')
+    end
+
+    it 'moves the file to the given directory' do
+      @item.move(@destination)
+      assert_equal true, File.exist?(File.join(@destination, @item.name))
+    end
+
+    it 'updates the path to its new location' do
+      @item.move(@destination)
+      assert_equal @destination, File.dirname(@item.path)
+    end
+
+  end
+
+  describe 'touch' do
+
+    it 'changes the update timestamp to the current time' do
+      now = Time.now - 100
+      Time.stub(:new, now) { @item.touch }
+
+      assert_equal now.to_i, @item.updated_at.to_i
+    end
+
+  end
+
+  it 'exists when the file at the given path exists' do
+    assert_equal true, @item.exist?
+    File.unlink(@item.path)
+
+    assert_equal false, @item.exist?
+  end
+
+end

data/test/filters_test.rb

@@ -0,0 +1,105 @@
+require_relative 'test_helper'
+require 'tempfile'
+require 'tmpdir'
+
+
+describe Adrian::Filters do
+  before do
+    @q    = Object.new.extend(Adrian::Filters)
+    @item = Adrian::QueueItem.new("hello")
+  end
+
+  class FakeFilter
+
+    def initialize(options = {})
+      @allow = options.fetch(:allow)
+    end
+
+    def allow?(item)
+      @allow == true
+    end
+
+  end
+
+  describe "#filter?" do
+
+    it "is true when any filter denies the item" do
+      @q.filters << FakeFilter.new(:allow => true)
+      @q.filters << FakeFilter.new(:allow => false)
+
+      assert_equal true, @q.filter?(@item)
+    end
+
+    it "is false when all filters allow the item" do
+      @q.filters << FakeFilter.new(:allow => true)
+      assert_equal false, @q.filter?(@item)
+    end
+
+  end
+
+  module Updatable
+    attr_accessor :updated_at
+  end
+
+  describe Adrian::Filters::Delay do
+    before do
+      @filter          = Adrian::Filters::Delay.new
+      @updatable_item  = Adrian::QueueItem.new("hello")
+      @updatable_item.extend(Updatable)
+      @updatable_item.updated_at = Time.new
+      @fifteen_minutes = 900
+    end
+
+    it "allows items that have not been recently updated" do
+      Time.stub(:new, @updatable_item.updated_at + @fifteen_minutes) do
+        assert_equal true, @filter.allow?(@updatable_item)
+      end
+    end
+
+    it "denies items that have been recently updated" do
+      assert_equal false, @filter.allow?(@updatable_item)
+    end
+
+    it "has a configurable recently updated duration that defaults to 15 minutes" do
+      assert_equal @fifteen_minutes, @filter.duration
+      configured_filter = Adrian::Filters::Delay.new(:duration => 1)
+
+      assert_equal 1, configured_filter.duration
+    end
+
+  end
+
+  describe Adrian::Filters::FileLock do
+    before do
+      @filter         = Adrian::Filters::FileLock.new(:reserved_path => 'path/to/locked')
+      @available_item = Adrian::FileItem.new("path/to/file")
+      @locked_item    = Adrian::FileItem.new("path/to/locked/file")
+      @one_hour       = 3_600
+    end
+
+    it "allows items that are not locked" do
+      assert_equal true, @filter.allow?(@available_item)
+    end
+
+    it "allows items with an expired lock" do
+      @locked_item.stub(:updated_at, Time.new - @one_hour) do
+        assert_equal true, @filter.allow?(@locked_item)
+      end
+    end
+
+    it "does not allow items with a fresh lock" do
+      @locked_item.stub(:updated_at, Time.new) do
+        assert_equal false, @filter.allow?(@locked_item)
+      end
+    end
+
+    it "has a configurable lock expiry duration that defaults to one hour" do
+      assert_equal @one_hour, @filter.duration
+      configured_filter = Adrian::Filters::FileLock.new(:duration => 1, :reserved_path => 'path/to/locked')
+
+      assert_equal 1, configured_filter.duration
+    end
+
+  end
+
+end

data/test/girl_friday_dispatcher_test.rb

@@ -0,0 +1,28 @@
+require_relative 'test_helper'
+
+describe Adrian::GirlFridayDispatcher do
+  before do
+    $done_items = []
+    @q = Adrian::ArrayQueue.new
+    @dispatcher = Adrian::GirlFridayDispatcher.new(:stop_when_done => true)
+  end
+
+  describe "work delegation" do
+    it "should instantiate an instance of the worker for each item and ask it to perform" do
+      worker = Class.new(Adrian::Worker) do
+        def work
+          sleep(rand)
+          $done_items << @item.value
+        end
+      end
+
+      @q.push(1)
+      @q.push(2)
+      @q.push(3)
+
+      @dispatcher.start(@q, worker)
+
+      $done_items.sort.must_equal([1, 2, 3])
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'bundler/setup'
+
+require 'debugger'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'adrian'
+
+require 'minitest/autorun'

data/test/worker_test.rb

@@ -0,0 +1,38 @@
+require_relative 'test_helper'
+
+describe Adrian::Worker do
+  describe "#perform" do
+    before { @item = 2}
+
+    it "should report back to the boss" do
+      worker_class = Class.new(Adrian::Worker) do
+        def work; item + 2; end
+      end
+
+      worker = worker_class.new(@item)
+      boss = MiniTest::Mock.new
+      worker.report_to(boss)
+
+      boss.expect(:work_done, nil, [@item, worker, nil])
+      worker.perform
+
+      boss.verify
+    end
+
+    it "should NEVER raise an exception" do
+      worker_class = Class.new(Adrian::Worker) do
+        def work; raise "STRIKE!"; end
+      end
+
+      worker = worker_class.new(@item)
+      boss = MiniTest::Mock.new
+      worker.report_to(boss)
+
+      boss.expect(:work_done, nil, [@item, worker, RuntimeError])
+
+      worker.perform
+
+      boss.verify
+    end
+  end
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: adrian
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Mick Staugaard
+- Eric Chapweske
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: girl_friday
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A work dispatcher and some queue implementations
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/adrian/array_queue.rb
+- lib/adrian/composite_queue.rb
+- lib/adrian/directory_queue.rb
+- lib/adrian/dispatcher.rb
+- lib/adrian/failure_handler.rb
+- lib/adrian/file_item.rb
+- lib/adrian/filters.rb
+- lib/adrian/girl_friday_dispatcher.rb
+- lib/adrian/queue.rb
+- lib/adrian/queue_item.rb
+- lib/adrian/version.rb
+- lib/adrian/worker.rb
+- lib/adrian.rb
+- test/array_queue_test.rb
+- test/composite_queue_test.rb
+- test/directory_queue_test.rb
+- test/dispatcher_lifecycle_test.rb
+- test/dispatcher_test.rb
+- test/failure_handler_test.rb
+- test/file_item_test.rb
+- test/filters_test.rb
+- test/girl_friday_dispatcher_test.rb
+- test/test_helper.rb
+- test/worker_test.rb
+- README.md
+- CONTRIBUTING.md
+homepage: https://github.com/staugaard/adrian
+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'
+      segments:
+      - 0
+      hash: -4434037212517463675
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4434037212517463675
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Adrian does not do any real work, but is really good at delegating it
+test_files:
+- test/array_queue_test.rb
+- test/composite_queue_test.rb
+- test/directory_queue_test.rb
+- test/dispatcher_lifecycle_test.rb
+- test/dispatcher_test.rb
+- test/failure_handler_test.rb
+- test/file_item_test.rb
+- test/filters_test.rb
+- test/girl_friday_dispatcher_test.rb
+- test/test_helper.rb
+- test/worker_test.rb