updater 0.2.1 → 0.2.2

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.2.2

data/lib/updater/update.rb

@@ -12,7 +12,7 @@ module Updater
     property :ident, Yaml
     property :method, String
     property :finder, String
-    property :args, Object
+    property :args, Object, :lazy=>false
     property :time, Integer
     property :name, String
     property :lock_name, String
@@ -130,7 +130,13 @@ module Updater
         hash[:ident] = ident_for(target,finder,finder_args)
         hash[:finder] = finder || :get
         hash[:time] = time
-        create(hash.merge(options))
+        ret = create(hash.merge(options))
+        Process.kill('USR1',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
@@ -192,12 +198,32 @@ module Updater
         all(:time.gt=>time.now.to_i)
       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
+      
       #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)
+        options = {:lock_name=>nil,:limit=>limit, :order=>[:time.asc]}.merge(options)
         current.all(options)
       end
       
@@ -208,24 +234,28 @@ module Updater
       #Gets a single gob form the queue, locks and runs it.
       def work_off(worker)
         updates = worker_set
-        if updates.empty?
-          return queue_time
-        end
-        
-        #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
+        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
+        worker.clear_locks
+        return queue_time
       end
       
       def queue_time
-        nxt = self.first(:time.not=>nil, :order=>[:time.desc])
+        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

data/lib/updater/worker.rb

@@ -19,24 +19,19 @@ module Updater
     
     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
-        clear_locks
-      end
+      @t = run_job_loop
       
-      trap('TERM') { terminate_with t }
-      trap('INT')  { terminate_with t }
+      trap('TERM') { terminate_with @t }
+      trap('INT')  { terminate_with @t }
       
       trap('USR1') do
-        say "Wakeup Signal Caught"
-        t.run
+        old_proc = trap('USR1','IGNORE')
+        run_loop
+        trap('USR1',old_proc)
       end
       
+      Thread.pass
+     
       sleep unless $exit
     end
     
@@ -49,12 +44,49 @@ module Updater
       Update.all(:lock_name=>@name).update(:lock_name=>nil) 
     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!"
+        clear_locks
+      end
+    end
+  
     def terminate_with(t)
       say "Exiting..."
       $exit = true
-      t.run
+      t.run if t.alive?
       say "Forcing Shutdown" unless status = t.join(15) #Nasty inline assignment
       clear_locks
       exit status ? 0 : 1

data/spec/worker_spec.rb

@@ -17,6 +17,43 @@ describe Worker do
     Worker.new.name.should be_a String
   end
   
+  describe "loop thread control:" do
+    
+    class Foo
+      include DataMapper::Resource
+      
+      property :id, Serial
+      property :name, String
+      
+      def bar(*args)
+        Foo.bar(:instance,*args)
+      end
+      
+    end
+    
+    Foo.auto_migrate!
+    
+    specify "The loop should run when the worker is started" do
+      pending
+      worker = Worker.new(:quiet=>true, :name=>"testing")
+      Update.should_receive(:work_off).with(worker).once.and_return(nil)
+      t = Thread.new do
+        worker.start
+      end
+      t.run
+      worker.stop
+      t.kill unless t.join(0.1) #you've got 0.1 seconds to finish or die
+    end
+    
+    specify "The loop should run with USR1 signal" do
+      pending
+      t = Thread.new do
+        worker.start
+      end
+    end
+    
+  end
+  
 end
 
 describe "working off jobs:" do
@@ -63,6 +100,8 @@ describe "working off jobs:" do
     it "should return the number of seconds till the next job if there are no jobs to be run" do
       Timecop.freeze(Time.now)
       u1 = Update.at(Time.now + 30, Foo,:bar,[:arg1])
+      Update.at(Time.now + 35, Foo,:bar,[:arg1])
+      Update.at(Time.now + 1000, Foo,:bar,[:arg1])
       Update.work_off(Worker.new(:name=>"first", :quiet=>true)).should == 30
     end
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: updater
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors: 
 - John F. Miller
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-21 00:00:00 -07:00
+date: 2009-10-24 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency