updater 0.9.4 → 0.10.0

data/lib/updater/thread_worker.rb~

@@ -1,92 +0,0 @@
-# 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 ThreadWorker
-    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 = run_job_loop
-      
-      trap('TERM') { terminate_with @t }
-      trap('INT')  { terminate_with @t }
-      
-      trap('USR1') do
-        old_proc = trap('USR1','IGNORE')
-        run_loop
-        trap('USR1',old_proc)
-      end
-      
-      Thread.pass
-     
-      sleep unless $exit
-    end
-    
-    def say(text)
-      puts text unless @quiet
-      logger.info text if logger      
-    end
-
-    def stop
-      raise RuntimeError unless @t
-      terminate_with @t
-    end
-    
-    def run_loop
-      if @t.alive?
-        @t.wakeup #calling run here is a Bad Idea
-      else
-        say " ~~ Restarting Job Loop"
-        @t = run_job_loop
-      end
-    end
-    
-  private
-  
-    def run_job_loop
-      Thread.new do
-        loop do
-          begin
-            delay = Update.work_off(self)
-            break if $exit
-            if delay 
-              sleep delay 
-            else
-              sleep
-            end
-            break if $exit
-          rescue
-            say "Caught exception in Job Loop"
-            sleep 0.1
-            retry
-          end
-        end
-        say "Worker thread exiting!"
-        Update.clear_locks(self)
-      end
-    end
-  
-    def terminate_with(t)
-      say "Exiting..."
-      $exit = true
-      t.run if t.alive?
-      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/update_dm.rb

@@ -1,298 +0,0 @@
-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, :lazy=>false
-    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
-        ret = create(hash.merge(options))
-        Process.kill('USR2',pid) if pid
-        ret
-      rescue Errno::ESRCH
-        @pid = nil
-        puts "PID invalid"
-        #log this as well
-      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, :lock_name=>nil)
-      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
-      
-      #how many jobs will happen in the next n seconds
-      def future(n)
-        ct = time.now.to_i
-        all(:time.gt=>ct,:time.lt=>ct+n)
-      end
-      
-      #Sets the process id of the worker process if known.  If this 
-      #is set then an attempt will be made to signal the worker any
-      #time a new update is made.
-      #
-      #If pid is not set, or is set to nil then the scheduleing program 
-      #is responcible for waking-up a potentially sleeping worker process
-      #in another way.
-      def pid=(p)
-        return @pid = nil unless p #tricky assignment in return
-        @pid = Integer("#{p}")
-        Process::kill 0, @pid
-        @pid
-      rescue Errno::ESRCH, ArgumentError
-        raise ArgumentError "PID was invalid"
-      end
-      
-      def pid
-        @pid
-      end
-      
-      ####################
-      # Worker Functions #
-      ####################
-      
-      #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 = {:lock_name=>nil,:limit=>limit, :order=>[:time.asc]}.merge(options)
-        current.all(options)
-      end
-
-      #Gets a single job form the queue, locks and runs it.
-      def work_off(worker)
-        updates = worker_set
-        unless updates.empty?
-          #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)
-            break unless nil == t
-          end
-        end
-      rescue DataObjects::ConnectionError
-        sleep 0.1
-        retry
-      ensure
-        clear_locks(worker)
-        return queue_time
-      end
-      
-      def queue_time
-        nxt = self.first(:time.not=>nil,:lock_name=>nil, :order=>[:time.asc])
-        return nil unless nxt
-        return 0 if nxt.time <= time.now.to_i
-        return nxt.time - time.now.to_i
-      end
-      
-      def clear_locks(worker)
-        all(:lock_name=>worker.name).update(:lock_name=>nil)
-      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/spec/lock_spec.rb

@@ -1,64 +0,0 @@
-require File.join( File.dirname(__FILE__),  "spec_helper" )
-
-include Updater
-
-require  File.join( File.dirname(__FILE__),  "fooclass" )
-
-describe "Update Locking:" do
-  
-  
-  class Worker
-    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 say(text)
-      puts text
-      nil
-    end
-  end    
-  
-  before :each do
-    Foo.all.destroy!
-    @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
-   
-  it "#clear_locks should clear all locks from a worker" do
-    @v = Update.immidiate(Foo,:bar,[:arg1,:arg2])
-    @u.lock(@w)
-    @v.lock(@w)
-    @u.locked?.should be_true
-    Update.clear_locks(@w)
-    @u.reload.locked?.should be_false
-    @v.reload.locked?.should be_false
-  end
-  
-end

data/spec/spec_helper.rb~

@@ -1,23 +0,0 @@
-require "rubygems"
-
-ROOT = File.join(File.dirname(__FILE__), '..')
-$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib')
-
-require "rspec" # Satisfies Autotest and anyone else not using the Rake tasks
-require "dm-core"
-require  'dm-migrations'
-
-require 'updater'
-#require 'updater/thread_worker'
-require 'updater/fork_worker'
-require 'updater/orm/datamapper'
-
-Updater::Update.orm = Updater::ORM::DataMapper
-
-DataMapper.setup(:default, 'sqlite3::memory:')
-DataMapper.auto_migrate!
-
-require 'timecop'
-require 'chronic'
-
-