updater 0.2.0

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2009 John F. Miller
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+This file includes code derived from the delayed_job gem which is 
+distributed under the same licence.  delayed_job is Copyright (c) 
+2005 Tobias Luetke.

data/README

@@ -0,0 +1,7 @@
+updater
+=======
+
+This plugin provides database driven delayed exicution of DataMapper model
+classes.  It can call class method on any class availible class or it can find
+an instance of a class from a database and exicute any method on that instance.
+Error handleing is also provided. 

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+
+VERSION_FILE = File.join(File.dirname(__FILE__), 'VERSION')
+
+GEM_NAME = "updater"
+GEM_VERSION = File.read(VERSION_FILE).strip
+AUTHOR = "John F. Miller"
+EMAIL = "emperor@antarestrader.com"
+HOMEPAGE = "http://blog.antarestrader.com"
+SUMMARY = "Plugin for the delayed calling of methods particularly DataMapper model instance and class methods."
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM_NAME
+  s.version = GEM_VERSION
+  s.date = File.ctime(VERSION_FILE)
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", "VERSION"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_dependency('datamapper', '>= 0.9.11')
+  s.add_development_dependency('rspec', '>= 1.2.6')
+  s.add_development_dependency('timecop', '>= 0.2.1')
+  s.add_development_dependency('chronic', '>= 0.2.3')
+  s.require_path = 'lib'
+  s.bindir = 'bin'
+  s.files = %w(LICENSE README Rakefile VERSION) + Dir.glob("{lib,spec,bin}/**/*")
+  
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.warning = false
+end
+
+desc "run all tests"
+task :default => [:spec]
+
+desc "Create a gemspec file"
+task :gemspec do
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/bin/updater

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+puts "starting update deamon..."
+
+require 'rubygems'
+require 'yaml'
+require 'updater'
+equire 'updater/worker'
+
+
+dbconfig = YAML.load_file('config/database.yml')
+
+DataMapper.setup(dbconfig['development'])
+
+
+
+
+
+
+

data/lib/updater/tasks.rb

@@ -0,0 +1,6 @@
+namespace :updater do
+  desc "Do something for updater"
+  task :default do
+    puts "updater doesn't do anything"
+  end
+end

data/lib/updater/update.rb

@@ -0,0 +1,257 @@
+module Updater
+
+  #the basic class that drives updater
+  class Update
+    # Contains the Error class after an error is caught in +run+. Not stored to the database.
+    attr_reader :error
+    
+    include DataMapper::Resource
+    
+    property :id, Serial
+    property :target, Class
+    property :ident, Yaml
+    property :method, String
+    property :finder, String
+    property :args, Object
+    property :time, Integer
+    property :name, String
+    property :lock_name, String
+    
+    #will be called if an error occurs
+    belongs_to :failure, :model=>'Update', :child_key=>[:failure_id], :nullable=>true
+    
+    # Returns the Class or instance that will recieve the method call.  See +Updater.at+ for 
+    # information about how a target is derived.
+    def target
+      return @target if @ident.nil?
+      @target.send(@finder||:get, @ident)
+    end
+    
+    # Send the method with args to the target.
+    def run(job=nil)
+      t = target #do not trap errors here
+      final_args = job ? sub_args(job,args.dup) : args
+      begin
+        t.send(@method.to_sym,*final_args)
+      rescue => e
+        @error = e
+        failure.run(self) if failure
+        destroy unless nil == time
+        return false
+      end
+      destroy unless nil == time
+      true
+    end
+    
+    def sub_args(job,a)
+      a.map {|e| :__job__ == e ? job : e}
+    end
+    
+    #atempt to lock this record for the worker
+    def lock(worker)
+      return true if locked? && locked_by == worker.name
+      #all this to make sure the check and the lock are simultanious:
+      cnt = repository.update({properties[:lock_name]=>worker.name},self.class.all(:id=>self.id,:lock_name=>nil))
+      if 0 != cnt
+        @lock_name = worker.name
+        true
+      else
+        worker.say( "Worker #{worker.name} Failed to aquire lock on job #{id}" )
+        false
+      end
+    end
+    
+    def locked?
+      not @lock_name.nil?
+    end
+    
+    def locked_by
+      @lock_name
+    end
+    
+    #Like run but first aquires a lock for the worker.  Will return the result of run or nil
+    #if the record could not be locked
+    def run_with_lock(worker)
+      run if lock(worker)
+    end
+    
+    class << self
+      
+      # Request that the target be sent the method with args at the given time.
+      #
+      # == Parameters
+      # time <Integer | Object responding to to_i>,  by default the number of seconds sence the epoch.  
+      #What 'time'  references  can be set by sending the a substitute class to the time= method.
+      #
+      # target  <Class | instance> .  If target is a class then 'method' will be sent to that class (unless the 
+      # finder option is used.  Otherwise, the target will be assumed to be the result of 
+      # (target.class).get(target.id).  The finder method (:get by default) and the finder_args 
+      # (target.id by default) can be set in the options.  A DataMapper instance passed as the target
+      # will "just work."  Any object can be found in this mannor is known as a 'conforming instance'.
+      # 
+      # method <Symbol>.  The method that will be sent to the calculated target.
+      #
+      # args <Array> a list of arguments to be sent to with the method call.  Note: 'args' must be seirialiable
+      # with Marshal.dump.  Defaults to []
+      #
+      # options <Hash>  Addational options that will be used to configure the request.  see Options 
+      # section below.
+      #
+      # == Options
+      #
+      # :finder <Symbol> This method will be sent to the stored target class (either target or target.class) 
+      # inorder to extract the instance on which to preform the request.  By default :get is used.  For
+      # example to use on an ActiveRecord class 
+      #    :finder=>:find
+      #
+      # :finder_args <Array> | <Object>.  This is passed to the finder function.  By default it is 
+      # target.id.  Note that by setting :finder_args you will force Updater to calculate in instance
+      # as the computed target even if you pass a Class as the target.
+      #
+      # :name <String> A string sent by the requesting class to identify the request.  'name' must be 
+      # unique for a given computed target.  Names cannot be used effectivally when a Class has non-
+      # conforming instances as there is no way predict the results of a finder call.  'name' can be used
+      # in conjunction with the +for+ method to manipulate requests effecting an object or class after
+      # they are set.  See +for+ for examples
+      #
+      # :failure <Updater> an other request to be run if this request raises an error.  Usually the 
+      # failure request will be created with the +chane+ method.
+      #
+      # == Examples
+      #
+      #    Updater.at(Chronic.parse('tomorrow'),Foo,:bar,[]) # will run Foo.bar() tomorrow at midnight
+      #    
+      #    f = Foo.create
+      #    u = Updater.at(Chronic.parse('2 hours form now'),f,:bar,[]) # will run Foo.get(f.id).bar in 2 hours
+      def at(time,target,method,args=[],options={})
+        finder, finder_args = [:finder,:finder_args].map {|key| options.delete(key)}
+        hash = {:method=>method.to_s,:args=>args}
+        hash[:target] = target_for(target)
+        hash[:ident] = ident_for(target,finder,finder_args)
+        hash[:finder] = finder || :get
+        hash[:time] = time
+        create(hash.merge(options))
+      end
+      
+      # like +at+ but with time as time.now.  Generally this will be used to run a long running operation in
+      # asyncronously in a differen process.  See +at+ for details
+      def immidiate(*args)
+        at(time.now,*args)
+      end
+      
+      # like +at+ but without a time to run.  This is used to create requests that run in responce to the 
+      # failure of other requests.  See +at+ for details
+      def chain(*args)
+        at(nil,*args)
+      end
+      
+      # Retrieves all updates for a conforming target possibly limiting the results to the named
+      # request.
+      #
+      # == Parameters
+      #
+      # target <Class | Object> a class or conforming object that postentially is the calculated target
+      # of a request.
+      #
+      # name(optional) <String>  If a name is sent, the first request with fot this target with this name
+      # will be returned.
+      #
+      # ==Returns
+      #
+      # <Array[Updater]> unless name is given then only a single [Updater] instance. 
+      def for(target,name=nil)
+        ident = ident_for(target)
+        target = target_for(target)
+        if name
+          first(:target=>target,:ident=>ident,:name=>name)
+        else
+          all(:target=>target,:ident=>ident)
+        end
+      end
+      
+      #The time class used by Updater.  See time= 
+      def time
+        @@time ||= Time
+      end
+      
+      # By default Updater will use the system time (Time class) to get the current time.  The application
+      # that Updater was developed for used a game clock that could be paused or restarted.  This method
+      # allows us to substitute a custom class for Time.  This class must respond with in interger or Time to
+      # the #now method.
+      def time=(klass)
+        @@time = klass
+      end
+      
+      #A filter for all requests that are ready to run, that is they requested to be run before or at time.now
+      def current
+        all(:time.lte=>time.now.to_i)
+      end
+      
+      #A filter for all requests that are not yet ready to run, that is time is after time.now
+      def delayed
+        all(:time.gt=>time.now.to_i)
+      end
+      
+      #This returns a set of update requests.
+      #The first parameter is the maximum number to return (get a few other workers may be in compitition)
+      #The second optional parameter is a list of options to be past to DataMapper.
+      def worker_set(limit = 5, options={})
+        #TODO: add priority to this.
+        options = {:limit=>limit, :order=>[:time.desc]}.merge(options)
+        current.all(options)
+      end
+      
+      ####################
+      # Worker Functions #
+      ####################
+      
+      #Gets a single gob form the queue, locks and runs it.
+      def work_off(worker)
+        updates = worker_set
+        
+        #concept copied form delayed_job.  If there are a number of 
+        #different processes working on the queue, the niave approch
+        #would result in every instance trying to lock the same record.
+        #by shuffleing our results we greatly reduce the chances that
+        #multilpe workers try to lock the same process
+        updates = updates.to_a.sort_by{rand()}
+        updates.each do |u|
+          t = u.run_with_lock(worker)
+          return queue_time unless nil == t
+        end
+      end
+      
+      def queue_time
+        nxt = self.first(:time.not=>nil, :order=>[:time.desc])
+        return nil unless nxt
+        return 0 if nxt.time <= time.now.to_i
+        return nxt.time - time.now.to_i
+      end
+      
+      
+      
+    private
+      
+      # Computes the stored class an instance or class
+      def target_for(inst)
+        return inst if inst.kind_of? Class
+        inst.class
+      end
+      
+      # Compute the agrument sent to the finder method
+      def ident_for(target,finder=nil,args=nil)
+        if !(target.kind_of?(Class)) || finder
+          args || target.id
+        end
+        #Otherwize the target is the class and ident should be nil
+      end
+    
+    end
+    
+    #:nodoc:
+    def inspect
+      "#<Updater id=#{id} target=#{target.inspect} time=#{time}>"
+    end
+  end
+  
+end

data/lib/updater/worker.rb

@@ -0,0 +1,61 @@
+# This file based the file of the same name in the delayed_job gem by
+# Tobias Luetke (Coypright (c) 2005) under the MIT License.
+
+require 'benchmark'
+
+module Updater
+
+  #This class repeatedly searches the database for active jobs and runs them
+  class Worker
+    cattr_accessor :logger
+    attr_accessor :pid
+    attr_accessor :name
+    
+    def initialize(options={})
+      @quiet = options[:quiet]
+      @name = options[:name] || "host:#{Socket.gethostname} pid:#{Process.pid}" rescue "pid:#{Process.pid}"
+      @pid = Process.pid
+    end
+    
+    def start
+      say "*** Starting job worker #{@name}"
+      t = Thread.new do
+        loop do
+          delay = Update.work_off(self)
+          break if $exit
+          sleep delay
+          break if exit
+        end
+      end
+      
+      trap('TERM') { terminate_with t }
+      trap('INT')  { terminate_with t }
+      
+      trap('USR1') do
+        say "Wakeup Signal Caught"
+        t.run
+      end
+      
+      sleep unless $exit
+    end
+    
+    def say(text)
+      puts text unless @quiet
+      logger.info text if logger      
+    end
+    
+  private
+  
+    def terminate_with(t)
+      say "Exiting..."
+      $exit = true
+      t.run
+      say "Forcing Shutdown" unless status = t.join(15) #Nasty inline assignment
+      Update.clear_locks(self)
+      exit status ? 0 : 1
+    end
+    
+    
+  end
+  
+end

data/lib/updater.rb

@@ -0,0 +1,10 @@
+require "rubygems"
+
+require 'dm-core'
+require 'dm-types'
+
+module Updater
+  VERSION = File.read(File.join(File.dirname(__FILE__),'..','VERSION')).strip
+end
+
+require 'updater/update.rb'

data/spec/lock_spec.rb

@@ -0,0 +1,73 @@
+require File.join( File.dirname(__FILE__),  "spec_helper" )
+
+include Updater
+
+describe "Update Locking:" do
+  
+  class Foo
+    include DataMapper::Resource
+    
+    property :id, Serial
+    property :name, String
+    
+    def bar(*args)
+      Foo.bar(:instance,*args)
+    end
+    
+  end
+  
+  Foo.auto_migrate!
+  
+  before :each do
+    @u = Update.immidiate(Foo,:bar,[])
+    @w = Worker.new(:name=>"first", :quiet=>true)
+  end
+  
+  it "An unlocked record should lock" do
+    @u.lock(@w).should be_true
+    @u.locked?.should be_true
+    @u.locked_by.should == @w.name
+  end
+  
+  it "A locked record should NOT lock" do
+    @u.lock(@w).should be_true
+    @u.lock(Worker.new(:quiet=>true)).should be_false
+  end
+  
+  it "A record that failed to lock should not change" do
+    @u.lock(@w).should be_true
+    @u.lock(Worker.new(:quiet=>true)).should be_false
+    @u.locked_by.should == @w.name
+  end
+  
+  it "A record should report as locked if locked by the same worker twice" do
+    @u.lock(@w).should be_true
+    @u.lock(@w).should be_true
+  end
+  
+  describe "#run_with_lock" do
+    
+    it "should run an unlocked record" do
+      u = Update.immidiate(Foo,:bar,[:arg1,:arg2])
+      Foo.should_receive(:bar).with(:arg1,:arg2)
+      u.run_with_lock(@w).should be_true
+    end
+    
+    it "should NOT run an already locked record" do
+      u = Update.immidiate(Foo,:bar,[:arg1,:arg2])
+      u.lock(Worker.new)
+      Foo.should_not_receive(:bar)
+      u.run_with_lock(@w).should be_nil
+    end
+    
+    it "should return false if the update ran but there was an error" do
+      u = Update.immidiate(Foo,:bar,[:arg1,:arg2])
+      Foo.should_receive(:bar).with(:arg1,:arg2).and_raise(RuntimeError)
+      u.run_with_lock(@w).should be_false
+    end
+    
+  end
+  
+  it "#clear_locks should lear all locks from a worker"
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require "rubygems"
+
+ROOT = File.join(File.dirname(__FILE__), '..')
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib')
+
+require "spec" # Satisfies Autotest and anyone else not using the Rake tasks
+require "dm-core"
+
+require 'updater'
+require 'updater/worker'
+
+DataMapper.setup(:default, 'sqlite3::memory:')
+DataMapper.auto_migrate!
+
+require 'timecop'
+require 'chronic'
+

data/spec/update_spec.rb

@@ -0,0 +1,185 @@
+require File.join( File.dirname(__FILE__),  "spec_helper" )
+
+include Updater
+
+describe Update do
+  
+  class Foo
+    include DataMapper::Resource
+    
+    property :id, Serial
+    property :name, String
+    
+    def bar(*args)
+      Foo.bar(:instance,*args)
+    end
+    
+  end
+  
+  Foo.auto_migrate!
+  
+  before(:each) do
+    Foo.all.destroy!
+  end
+  
+  it "should include DataMapper::Resource" do
+    DataMapper::Model.descendants.to_a.should include(Update)
+  end
+  
+  it "should have a version matching the VERSION file" do
+    Updater::VERSION.should == File.read(File.join(ROOT,'VERSION')).strip
+  end
+  
+  describe "adding an immidiate update request" do
+    
+    it "with a class target" do
+      u = Update.immidiate(Foo,:bar,[])
+      u.target.should == Foo
+      Update.current.should include(u)
+      Update.delayed.should_not include(u)
+    end
+    
+    it "with an conforming instance target" do
+      f = Foo.create
+      u = Update.immidiate(f,:bar,[])
+      u.target.should == f
+      Update.current.should include(u)
+      Update.delayed.should_not include(u)
+    end
+    
+    it "with an custome finder" do
+      f = Foo.create(:name=>'baz')
+      u = Update.immidiate(Foo,:bar,[],:finder=>:first, :finder_args=>{:name=>'baz'})
+      u.target.should == f
+      Update.current.should include(u)
+      Update.delayed.should_not include(u)
+    end
+    
+  end
+  
+  describe "chained request" do
+    
+    it "should not be in current or delayed queue" do
+      u = Update.chain(Foo,:bar,[:error])
+      u.time.should be_nil
+      Update.current.should_not include(u)
+      Update.delayed.should_not include(u)
+    end
+    
+  end
+  
+  describe "named request" do
+    
+    it "should be found by name when target is an instance" do
+      f = Foo.create(:name=>'Honey')
+      u = Update.immidiate(f,:bar,[:named],:name=>'Now')
+      u.name.should ==("Now")
+      Update.for(f, "Now").should ==(u)
+    end
+    
+    it "should be found by name when target is a class" do
+      u = Update.immidiate(Foo,:bar,[:named],:name=>'Now')
+      u.name.should ==("Now")
+      Update.for(Foo, "Now").should ==(u)
+    end
+    
+    it "should return all updates for a given target" do
+      u1 = Update.immidiate(Foo,:bar,[:arg1,:arg2])
+      u2 = Update.immidiate(Foo,:bar,[:arg3,:arg4])
+      Update.for(Foo).should include(u1,u2)
+    end
+
+    
+  end
+  
+  describe "adding an delayed update request" do
+    
+    it "with a class target" do
+      u = Update.at(Chronic.parse('tomorrow'),Foo,:bar,[])
+      u.target.should == Foo
+      Update.current.should_not include(u)
+      Update.delayed.should include(u)
+    end
+    
+    it "with an conforming instance target" do
+      f = Foo.create
+      u = Update.at(Chronic.parse('tomorrow'),f,:bar,[])
+      u.target.should == f
+      Update.current.should_not include(u)
+      Update.delayed.should include(u)
+    end
+    
+    it "with an custome finder" do
+      f = Foo.create(:name=>'baz')
+      u = Update.at(Chronic.parse('tomorrow'),Foo,:bar,[],:finder=>:first, :finder_args=>{:name=>'baz'})
+      u.target.should == f
+      Update.current.should_not include(u)
+      Update.delayed.should include(u)
+    end
+    
+  end
+  
+  describe "running an update" do
+    
+    before :each do
+      Update.all.destroy!
+    end
+    
+    it "should call the named method with a class target" do
+      u = Update.immidiate(Foo,:bar,[:arg1,:arg2])
+      Foo.should_receive(:bar).with(:arg1,:arg2)
+      u.run
+    end
+    
+    it "should call the named method with an conforming instance target" do
+      f = Foo.create
+      u = Update.immidiate(f,:bar,[:arg1,:arg2])
+      Foo.should_receive(:bar).with(:instance,:arg1,:arg2)
+      u.run
+    end
+    
+    it "should delete the record once it is run" do
+      u = Update.immidiate(Foo,:bar,[:arg1,:arg2])
+      Foo.should_receive(:bar).with(:arg1,:arg2)
+      u.run
+      u.should_not be_saved #NOTE: not a theological statment
+    end
+    
+    it "should delete the record if there is a failure" do
+      u = Update.immidiate(Foo,:bar,[:arg1,:arg2])
+      Foo.should_receive(:bar).with(:arg1,:arg2).and_raise(RuntimeError)
+      u.run
+      u.should_not be_saved #NOTE: not a theological statment
+    end
+    
+    it "should not delete the record if it is a chain record" do
+      u = Update.chain(Foo,:bar,[:arg1,:arg2])
+      Foo.should_receive(:bar).with(:arg1,:arg2).and_raise(RuntimeError)
+      u.run
+      u.should be_saved
+    end
+    
+    describe "Error Handeling" do
+      it "should return false when run" do
+        u = Update.immidiate(Foo,:bar,[:arg1,:arg2])
+        Foo.should_receive(:bar).with(:arg1,:arg2).and_raise(RuntimeError)
+        u.run.should be_false
+      end
+      
+      it "should trap errors" do
+        u = Update.immidiate(Foo,:bar,[:arg1,:arg2])
+        Foo.should_receive(:bar).with(:arg1,:arg2).and_raise(RuntimeError)
+        lambda {u.run}.should_not raise_error
+      end
+      
+      it "should run the failure task" do
+        err = Update.chain(Foo,:bar,[:error])
+        u = Update.immidiate(Foo,:bar,[:arg1,:arg2],:failure=>err)
+        Foo.should_receive(:bar).with(:arg1,:arg2).and_raise(RuntimeError)
+        Foo.should_receive(:bar).with(:error)
+        u.run
+      end
+    end
+  end
+  
+end

data/spec/worker_spec.rb

@@ -0,0 +1,72 @@
+require File.join( File.dirname(__FILE__),  "spec_helper" )
+
+include Updater
+
+describe Worker do
+  
+  it "should not print anything when quiet" do
+    w = Worker.new :quiet=>true
+    out = StringIO.new
+    $stdout = out
+    w.say "hello world"
+    $stdout = STDOUT
+    out.string.should be_empty
+  end
+  
+  it "should have a name" do
+    Worker.new.name.should be_a String
+  end
+  
+end
+
+describe "working off jobs:" do
+  
+  class Foo
+    include DataMapper::Resource
+    
+    property :id, Serial
+    property :name, String
+    
+    def bar(*args)
+      Foo.bar(:instance,*args)
+    end
+    
+  end
+  
+  describe "Update#work_off" do
+    
+    before :each do
+      Update.all.destroy!
+    end 
+  
+    it "should run and immidiate job"do
+      u = Update.immidiate(Foo,:bar,[:arg1,:arg2])
+      Foo.should_receive(:bar).with(:arg1,:arg2)
+      Update.work_off(Worker.new)
+    end
+    
+    it "should aviod conflicts among mutiple workers" do
+      u1 = Update.immidiate(Foo,:bar,[:arg1])
+      u2 = Update.immidiate(Foo,:baz,[:arg2])
+      Foo.should_receive(:bar).with(:arg1)
+      Foo.should_receive(:baz).with(:arg2)
+      Update.work_off(Worker.new(:name=>"first", :quiet=>true))
+      Update.work_off(Worker.new(:name=>"second", :quiet=>true))
+    end
+    
+    it "should return 0 if there are more jobs waiting" do
+      u1 = Update.immidiate(Foo,:bar,[:arg1])
+      u2 = Update.immidiate(Foo,:baz,[:arg2])
+      Update.work_off(Worker.new(:name=>"first", :quiet=>true)).should == 0
+    end
+    
+    it "should return the number of seconds till the next job if there are no jobs to be run"
+    
+    it "should return nil if the job queue is empty" do
+      u1 = Update.immidiate(Foo,:bar,[:arg1])
+      Update.work_off(Worker.new(:name=>"first", :quiet=>true)).should be_nil
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: updater
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- John F. Miller
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: datamapper
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.11
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.6
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: timecop
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: chronic
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.3
+    version: 
+description: Plugin for the delayed calling of methods particularly DataMapper model instance and class methods.
+email: emperor@antarestrader.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- VERSION
+files: 
+- LICENSE
+- README
+- Rakefile
+- VERSION
+- lib/updater.rb
+- lib/updater/update.rb
+- lib/updater/tasks.rb
+- lib/updater/worker.rb
+- spec/worker_spec.rb
+- spec/lock_spec.rb
+- spec/update_spec.rb
+- spec/spec_helper.rb
+- bin/updater
+has_rdoc: true
+homepage: http://blog.antarestrader.com
+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: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Plugin for the delayed calling of methods particularly DataMapper model instance and class methods.
+test_files: []
+