rq 0.1.7 → 3.0.0

data/lib/{rq-0.1.7 → rq-3.0.0}/configfile.rb

@@ -1,18 +1,22 @@
 unless defined? $__rq_configfile__
   module RQ 
-#{{{
+#--{{{
     LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
       defined? LIBDIR
 
     require 'yaml'
 
-    class ConfigFile
-#{{{
+    #
+    # the ConfigFile class is a thin class that munges yaml input and populates
+    # itself
+    #
+    class ConfigFile < ::Hash
+#--{{{
       DEFAULT_CONFIG = LIBDIR + 'defaultconfig.txt'
 
       class << self
         def gen_template(arg = nil)
-#{{{
+#--{{{
           @data ||= IO::read(DEFAULT_CONFIG)
           case arg 
             when IO 
@@ -23,16 +27,16 @@ unless defined? $__rq_configfile__
               STDOUT.write @data 
           end
           self
-#}}}
+#--}}}
         end
         def load_default
-#{{{
+#--{{{
           @data ||= IO::read(DEFAULT_CONFIG)
           @default ||= YAML::load(munge(@data)) || {}
-#}}}
+#--}}}
         end
         def any(basename, *dirnames)
-#{{{
+#--{{{
           config = nil
           dirnames.each do |dirname|
             path = File::join dirname, basename 
@@ -42,17 +46,17 @@ unless defined? $__rq_configfile__
             end
           end
           config || self::new('default') 
-#}}}
+#--}}}
         end
         def munge buf
-#{{{
+#--{{{
           buf.gsub(%r/\t/o,'  ')
-#}}}
+#--}}}
         end
       end
       attr :path
       def initialize path
-#{{{
+#--{{{
         @path = nil 
         yaml = nil
         if path.nil? or path and path =~ /^\s*default/io
@@ -63,16 +67,16 @@ unless defined? $__rq_configfile__
           @path = path
         end
         self.update yaml
-#}}}
+#--}}}
       end
       def to_hash
-#{{{
+#--{{{
         {}.update self
-#}}}
+#--}}}
       end
-#}}}
+#--}}}
     end # class ConfigFile
-#}}}
+#--}}}
   end # module RQ
 $__rq_configfile__ = __FILE__ 
 end

data/lib/{rq-0.1.7 → rq-3.0.0}/configurator.rb

@@ -1,16 +1,20 @@
 unless defined? $__rq_configurator__
   module RQ 
-#{{{
+#--{{{
     LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
       defined? LIBDIR
 
     require LIBDIR + 'mainhelper'
 
+    # 
+    # a Configurator adds key/value pairs to a queue's configuration.  these
+    # key/value pairs are not currently used, but will be in a future release 
+    # 
     class  Configurator < MainHelper
-#{{{
-#}}}
+#--{{{
+#--}}}
       def configure
-    #{{{
+#--{{{
         set_q
         attributes = {}
         unless @argv.empty?
@@ -27,10 +31,10 @@ unless defined? $__rq_configurator__
           end
         end
         y attributes
-    #}}}
+#--}}}
       end
     end # class Configurator
-#}}}
+#--}}}
   end # module RQ
 $__rq_configurator__ = __FILE__ 
 end

data/lib/rq-3.0.0/creator.rb

@@ -0,0 +1,46 @@
+unless defined? $__rq_creator__
+  module RQ 
+#--{{{
+    LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? LIBDIR
+
+    require LIBDIR + 'mainhelper'
+
+    #
+    # a queue is a directory
+    #
+    # the Creator class is responsible for initializing the queue directory and
+    # all supporting files.  these include:
+    # * the sqlite database (binary)
+    # * the sqlite database schema description file (text)
+    # * the empty sentinel file used for locking (text - empty)
+    #
+    # it is an error to attempt to initialize a queue which already exists
+    #
+    class  Creator < MainHelper
+#--{{{
+      def create 
+#--{{{
+        raise "q <#{ @qpath }> exists!" if test ?e, @qpath
+        @q = JobQueue::create @qpath, 'logger' => @logger
+
+        unless quiet?
+          puts '---'
+          puts "q: #{ @q.path }"
+          puts "db: #{ @q.db.path }"
+          puts "schema: #{ @q.db.schema }"
+          puts "lock: #{ @q.db.lockfile }"
+          puts "bin: #{ @q.bin }"
+          puts "stdin: #{ @q.stdin }"
+          puts "stdout: #{ @q.stdout }"
+          puts "stderr: #{ @q.stderr }"
+        end
+        self
+#--}}}
+      end
+#--}}}
+    end # class Creator
+#--}}}
+  end # module RQ
+$__rq_creator__ = __FILE__ 
+end

data/lib/rq-3.0.0/cron.rb

@@ -0,0 +1,125 @@
+unless defined? $__rq_cron__
+  module RQ 
+#--{{{
+    LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? LIBDIR
+
+    require LIBDIR + 'mainhelper'
+
+    #
+    # a class for managing crontab entries and to start/stop rq
+    #
+    class Cron < MainHelper
+#--{{{
+      def initialize *a, &b
+#--{{{
+        super
+        ruby = Util::which_ruby
+        this = Util::realpath( File.expand_path( $0 ) )
+        q = qpath
+
+        @cmd = "#{ ruby } #{ this } #{ q }"
+        @md5 = lambda{|mode| Digest::MD5::hexdigest "#{ @cmd } #{ mode }" }
+#--}}}
+      end
+      def cron 
+#--{{{
+        which = @argv.shift || 'start'
+        which = which.strip.downcase
+        #abort "arg not add|start|shutdown|stop" unless %w( start shutdown stop ).include? which
+        msg = "cron_#{ which }"
+        begin
+          send msg
+        rescue NoMethodError
+          raise ArgumentError, which
+        end
+        self
+#--}}}
+      end
+      def cron_add
+#--{{{
+        lines = `crontab -l`.split "\n"
+
+        found = nil
+
+        re = %r/###\s*md5:#{ @md5[:start] }/
+
+        lines.each do |line|
+          line.strip!
+          next if line[ %r/^\s*#/ ]
+          min, hour, dom, mon, dow, entry = line.split %r/\s+/, 6
+          next unless entry
+          entry.strip!
+          entry.gsub! %r/#[^'"]$/, ''
+          entry.strip!
+          found = re.match entry
+          break if found
+        end
+
+        unless found
+          tmp = Tempfile::new Process::pid.to_s
+          lines.each{|line| tmp << "#{ line }\n"}
+          opts = @options.map{|kv| "'--#{ kv.join('=') }'" }.join(' ')
+          entry = "*/15 * * * * #{ @cmd } start #{ opts } ###md5:#{ @md5[:start] }\n"
+          tmp << entry 
+          tmp.close
+          system("crontab #{ tmp.path }") or abort("failed to cronify!")
+          tmp.close!
+          puts entry
+        end
+#--}}}
+      end
+      def cron_start
+#--{{{
+        cron_add
+        main.start
+#--}}}
+      end
+      def cron_delete
+#--{{{
+        lines = `crontab -l`.split "\n"
+
+        re = %r/###\s*md5:#{ @md5[:start] }/
+        found = [] 
+
+        lines.each_with_index do |line, idx|
+          line.strip!
+          next if line[ %r/^\s*#/ ]
+          min, hour, dom, mon, dow, entry = line.split %r/\s+/, 6
+          next unless entry
+          entry.strip!
+          entry.gsub! %r/#[^'"]$/, ''
+          entry.strip!
+          found << idx if(re.match entry)
+        end
+
+        unless found.empty?
+          deleted = lines[*found]
+          lines.delete_at *found
+          tmp = Tempfile::new Process::pid.to_s
+          lines.each{|line| tmp << "#{ line }\n"}
+          tmp.close
+          system("crontab #{ tmp.path }") or abort("failed to cronify!")
+          tmp.close!
+          puts deleted
+        end
+#--}}}
+      end
+      def cron_shutdown
+#--{{{
+        cron_delete
+        main.shutdown
+#--}}}
+      end
+      def cron_stop
+#--{{{
+        cron_delete
+        main.stop
+#--}}}
+      end
+#--}}}
+    end # class Cron 
+#--}}}
+  end # module RQ
+$__rq_cron__ = __FILE__ 
+end

data/lib/rq-3.0.0/deleter.rb

@@ -0,0 +1,51 @@
+unless defined? $__rq_deleter__
+  module RQ 
+#--{{{
+    LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? LIBDIR
+
+    require LIBDIR + 'mainhelper'
+
+    #
+    # the Deleter class reads the command line, stdin, or an infile to determine
+    # the job ids (jid) of jobs to be deleted from the queue.  jids may be
+    # specified on the command line or parsed from stdin or the infile.  any
+    # input line matching 'jid : number' or 'number' is taken to be a line
+    # indicating a jid to delete.
+    #
+    class  Deleter < MainHelper
+#--{{{
+      def delete
+#--{{{
+        set_q
+
+        whats = @argv
+
+        if whats.empty? and stdin?
+          pat = %r/^(?:\s*jid\s*:)?\s*(\d+)\s*$|^\s*(all)\s*$/io
+          while((line = stdin.gets))
+            match = pat.match line
+            next unless match
+            whats << (match[1] || match[2])
+          end
+        end
+
+        #whats.map!{|what| what =~ %r/^\s*\d+\s*$/o ? Integer(what) : what}
+
+        raise "nothing to delete" if whats.empty?
+
+        if @options['quiet'] 
+          @q.delete(*whats)
+        else
+          @q.delete(*whats, &dumping_yaml_tuples)
+        end
+
+        @q.vacuum
+#--}}}
+      end
+#--}}}
+    end # class Deleter
+#--}}}
+  end # module RQ
+$__rq_deleter__ = __FILE__ 
+end

data/lib/rq-3.0.0/executor.rb

@@ -0,0 +1,40 @@
+unless defined? $__rq_executor__
+  module RQ 
+#--{{{
+    LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? LIBDIR
+
+    require LIBDIR + 'mainhelper'
+
+    #
+    # the Executor is for expert use only and executes arbitrary sql on the
+    # queue's db.  the reason one should not do this directly with the sqlite
+    # command line program is that it will not respect the locking subsystem
+    # used in RQ - the Executor method will
+    #
+    class  Executor < MainHelper
+#--{{{
+    def execute
+#--{{{
+      set_q
+      sql = @argv.join ' '
+      if sql.empty? and stdin? 
+        debug{ "reading sql from stdin" }
+        while((buf = stdin.gets))
+          buf.strip!
+          buf.gsub! %r/#.*$/o, ''
+          next if buf.empty?
+          sql << "#{ buf } "
+        end
+      end
+      abort "no sql to execute" if sql.empty?
+      @q.qdb.transaction_retries = 0
+      @q.transaction{@q.execute(sql, &dumping_yaml_tuples)}
+#--}}}
+    end
+#--}}}
+    end # class Executor
+#--}}}
+  end # module RQ
+$__rq_executor__ = __FILE__ 
+end

data/lib/{rq-0.1.7 → rq-3.0.0}/feeder.rb

@@ -1,31 +1,45 @@
 unless defined? $__rq_feeder__
   module RQ 
-#{{{
+#--{{{
     LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
       defined? LIBDIR
 
+    require 'fileutils'
+
     require LIBDIR + 'mainhelper'
     require LIBDIR + 'job'
     require LIBDIR + 'jobrunner'
     require LIBDIR + 'jobrunnerdaemon'
     require LIBDIR + 'jobqueue'
 
+
+#
+# TODO - resolve elapsed time bug with throttle/sleep
+#
+
+    #
+    # the Feeder class is responsible for running jobs from a queue - or
+    # 'feeding' from that queue.  the mode of operation is essentially to run
+    # jobs as quickly as possible, return them to the queue, and then to run
+    # more jobs if any exist.  if no jobs exist the Feeder will periodically
+    # poll the queue to see if any new jobs have arrived.
+    #
     class  Feeder < MainHelper
-#{{{
+#--{{{
       DEFAULT_MIN_SLEEP = 42
       DEFAULT_MAX_SLEEP = 240
       DEFAULT_FEED      = 2
 
       class << self
-#{{{
+#--{{{
         attr :min_sleep, true
         attr :max_sleep, true
         attr :feed, true
-#}}}
+#--}}}
       end
 
       def feed
-    #{{{
+#--{{{
         daemon do
           gen_pidfile
           @main.init_logging
@@ -37,12 +51,19 @@ unless defined? $__rq_feeder__
           @started = Util::timestamp
           @min_sleep = Integer(@options['min_sleep'] || defval('min_sleep'))
           @max_sleep = Integer(@options['max_sleep'] || defval('max_sleep'))
-          @max_feed = Integer(@options['feed'] || defval('feed'))
+          @max_feed = Integer(@options['max_feed'] || defval('feed'))
           @children = Hash::new 
-          @jrd = JobRunnerDaemon::daemon
+          @jrd = JobRunnerDaemon::daemon @q
 
           install_signal_handlers
 
+          if @daemon and not @quiet
+            STDOUT.puts "pid <#{ Process::pid }> started"
+            STDOUT.flush
+          end
+
+          install_redirects
+
           info{ "** STARTED **" }
           info{ "version <#{ RQ::VERSION }>" }
           info{ "cmd <#{ @cmd }>" }
@@ -50,11 +71,15 @@ unless defined? $__rq_feeder__
           info{ "pidfile <#{ @pidfile.path }>" }
           info{ "jobrunnerdaemon uri <#{ @jrd.uri }> pid <#{ @jrd.pid }>" }
           info{ "qpath <#{ @qpath }>" }
-          info{ "mode <#{ @mode }>" }
+          debug{ "mode <#{ @mode }>" }
+          debug{ "max_feed <#{ @max_feed }>" }
           debug{ "min_sleep <#{ @min_sleep }>" }
           debug{ "max_sleep <#{ @max_sleep }>" }
 
-          fill_morgue
+          transaction do
+            fill_morgue
+            reap_zombie_ios
+          end
 
           loop do
             handle_signal if $rq_signaled
@@ -68,25 +93,22 @@ unless defined? $__rq_feeder__
             end
           end
         end
-    #}}}
+#--}}}
       end
       def daemon
-    #{{{
+#--{{{
         if @options['daemon']
           fork do
             Process::setsid
-            fork do
-              Dir::chdir(Util.realpath('~'))
-              File::umask 0
-              open('/dev/null','r+') do |f|
-                STDIN.reopen f 
-                STDOUT.reopen f 
-                STDERR.reopen f 
+            pid =
+              fork do
+                Dir::chdir(Util.realpath('~'))
+                File::umask 0
+                @daemon = true
+                yield
+                exit EXIT_SUCCESS
               end
-              @daemon = true
-              yield
-              exit EXIT_SUCCESS
-            end
+            # STDOUT.puts "#{ pid }"
             exit!
           end
           exit!
@@ -95,89 +117,210 @@ unless defined? $__rq_feeder__
           yield
           exit EXIT_SUCCESS
         end
-    #}}}
+#--}}}
       end
       def gen_pidfile name = nil
-    #{{{
-        name ||= gen_feeder_name(@options['name'] || @qpath)
-        @pidfile = 
+#--{{{
+        gen_pidfilepath
+
+        begin
+          FileUtils::mkdir_p(File::dirname(@pidfilepath))
+        rescue
+          nil
+        end
+
+        locked = nil 
+        no_other_feeder = nil 
+
+        2.times do
+          locked = false
+          no_other_feeder = false 
+
+          @pidfile = 
+            begin
+              open @pidfilepath, File::CREAT | File::EXCL | File::RDWR
+            rescue
+              open @pidfilepath, File::RDWR
+            end
+
+          ret = @pidfile.posixlock(File::LOCK_EX | File::LOCK_NB)
+          locked = (ret == 0)
+
           begin
-            open name, File::CREAT | File::EXCL | File::RDWR
-          rescue
-            open name, File::RDWR
+            pid = Integer(IO::read(@pidfilepath)) rescue nil
+
+            unless pid
+              no_other_feeder = true 
+              break
+            end
+
+            if Util::alive?(pid)
+              no_other_feeder = Process::pid == pid ? true : false
+                #no_other_feeder = false 
+              #else
+                #no_other_feeder = false 
+              #end
+              break
+            else
+              no_other_feeder = true 
+              STDERR.puts "WARNING : process <#{ pid }> died holding lock on <#{ @pidfilepath }>"
+              STDERR.puts "WARNING : attempting autorecovery!"
+              break if locked
+              STDERR.puts "WARNING : your NFS locking setup is FUBAR - iptables or firewall issues!"
+              STDERR.puts "WARNING : attempting autorecovery!"
+              FileUtils::rm_f @pidfilepath 
+              4.times{ sleep rand }
+            end
+
+          rescue Exception => e
+            STDERR.puts "WARNING : #{ e.message } (#{ e.class })"
           end
-        unless @pidfile and @pidfile.posixlock(File::LOCK_EX | File::LOCK_NB)
-          pid = IO::read(name) rescue nil
-          pid ||= 'unknown'
+        end
+
+
+        unless(locked and no_other_feeder)
+          pid = Integer(IO::read(@pidfilepath)) rescue 'UNKNOWN' 
           if @options['quiet']
             exit EXIT_FAILURE
           else
-            raise "process <#{ pid }> is already feeding from this queue"
+            abort "process <#{ pid }> is already feeding from this queue"
           end
         else
+          @pidfile.chmod 0600 rescue nil
           @pidfile.rewind
           @pidfile.sync = true
           @pidfile.print Process::pid
           @pidfile.truncate @pidfile.pos
-          at_exit{ FileUtils::rm_f name rescue nil }
+          @pidfile.flush
+
+          at_exit do 
+            FileUtils::rm_f @pidfilepath rescue nil
+            @pidfile.posixlock File::LOCK_UN rescue nil
+            @pidfile.close rescue nil
+          end
         end
-    #}}}
+#--}}}
       end
-      def gen_feeder_name path 
-    #{{{
+      def gen_pidfilepath
+#--{{{
+        # @pidfilepath ||= gen_feeder_name
+        @pidfilepath ||= File::join(@dot_rq_dir, 'pid') 
+#--}}}
+      end
+      def gen_feeder_name path = nil
+#--{{{
+        path ||= (@options['name'] || @qpath)
         path = Util::realpath(path).gsub(%r|/|o, '_')
-        File::join(Util::realpath('~'), ".#{ path }.feeder")
-    #}}}
+        #File::join(Util::realpath('~'), ".#{ path }.feeder")
+        basename = ".#{ Util::host }_#{ path }.feeder".gsub(%r/_+/,'_')
+        dirname = Util::realpath '~'
+        File::join dirname, basename
+#--}}}
       end
       def install_signal_handlers
-#{{{
-        if @daemon
+#--{{{
+        if @daemon or ENV['RQ_SIGNALS']
           $rq_signaled = false
           $rq_sighup = false
           $rq_sigterm = false
           $rq_sigint = false
           trap('SIGHUP') do
             $rq_signaled = $rq_sighup = 'SIGHUP' 
-            warn{ "signal <SIGHUP>" }
-            warn{ "finishing running jobs before handling signal" }
+            if nothing_running?
+              warn{ "signal <SIGHUP>" }
+              handle_signal
+            else
+              warn{ "finishing running jobs before handling signal" }
+            end
           end
           trap('SIGTERM') do
             $rq_signaled = $rq_sigterm = 'SIGTERM' 
-            warn{ "signal <SIGTERM>" }
-            warn{ "finishing running jobs before handling signal" }
+            if nothing_running?
+              warn{ "signal <SIGTERM>" }
+              handle_signal
+            else
+              warn{ "finishing running jobs before handling signal" }
+            end
           end
           trap('SIGINT') do
             $rq_signaled = $rq_sigint = 'SIGINT' 
-            warn{ "signal <SIGINT>" }
-            warn{ "finishing running jobs before handling signal" }
+            if nothing_running?
+              warn{ "signal <SIGINT>" }
+              handle_signal
+            else
+              warn{ "finishing running jobs before handling signal" }
+            end
           end
           @jrd.install_signal_handlers
+        else
+          %w(SIGHUP SIGTERM SIGINT).each do |sig|
+            trap(sig) do
+              warn{ "signal <#{ sig }>" }
+              warn{ "not cleaning up - only daemon mode cleans up!" }
+              exit
+            end
+          end
+        end
+#--}}}
+      end
+      def install_redirects
+#--{{{
+        if @daemon
+          open('/dev/null','r+') do |f|
+            STDIN.reopen f 
+            STDOUT.reopen f 
+            STDERR.reopen f 
+          end
         end
-#}}}
+#--}}}
       end
       def fill_morgue
-    #{{{
-        debug{ "filling morgue" }
-        sql = <<-sql
-          select * from jobs where state = 'running' and runner = '#{ Util::hostname }' and started <= '#{ @started }'
-        sql
-        db = @q.qdb
+#--{{{
+        debug{ "filling morgue..." }
         transaction do
-          tuples = db.execute sql
-          tuples.each do |tuple|
-            jid = tuple['jid']
-            if jid
-              sql = "update jobs set state='dead' where jid='#{ jid }'"
-              db.execute sql
-              info{ "burried job <#{ jid }>" }
+          deadjobs = @q.getdeadjobs @started
+          deadjobs.each do |job|
+            @q.jobisdead job
+            unless job['restartable']
+              info{ "burried job <#{ job['jid'] }>" }
+            else
+              warn{ "dead job <#{ job['jid'] }> will be restarted" }
             end
           end
         end
         debug{ "filled morgue" }
-    #}}}
+#--}}}
+      end
+      def reap_zombie_ios 
+#--{{{
+        debug{ "reaping zombie ios" }
+        begin
+          transaction do
+            stdin, stdout, stderr = @q.stdin, @q.stdout, @q.stderr
+            jids = @q.execute("select jid from jobs").map{|tuple| Integer tuple.first}
+            jids = jids.inject({}){|h,jid| h.update jid => true}
+            %w[ stdin stdout stderr ].each do |d|
+              Dir::glob(File::join(@q.send(d), "*")).each do |iof|
+                begin
+                  jid = Integer iof[%r/\d+\s*$/]
+                  unless jids[jid]
+                    debug{ "removing zombie io <#{ iof }>" }
+                    FileUtils::rm_rf iof
+                  end
+                rescue
+                  next
+                end
+              end
+            end
+          end
+        rescue Exception => e # because this is a non-essential function
+          warn{ e }
+        end
+        debug{ "reaped" }
+#--}}}
       end
       def handle_signal
-#{{{
+#--{{{
         if $rq_sigterm or $rq_sigint
           reap_jobs(reap_only = true) until nothing_running? 
           info{ "** STOPPING **" }
@@ -189,15 +332,22 @@ unless defined? $__rq_feeder__
         if $rq_sighup
           reap_jobs(reap_only = true) until nothing_running? 
           info{ "** RESTARTING **" }
-          @jrd.shutdown rescue nil
-          Util::uncache __FILE__ 
-          @pidfile.posixlock File::LOCK_UN
-          Util::exec @cmd
+          info{ "** ARGV <#{ @cmd }> **" }
+          begin
+            @jrd.shutdown rescue nil
+            Util::uncache __FILE__ 
+            @pidfile.posixlock File::LOCK_UN
+            Util::exec @cmd
+          rescue Exception => e
+            fatal{"** FAILED TO RESTART! **"}
+            fatal{ e }
+            exit EXIT_FAILURE
+          end
         end
-#}}}
+#--}}}
       end
       def throttle rate = @min_sleep 
-    #{{{
+#--{{{
         if Numeric === rate and rate > 0 
           if defined? @last_throttle_time and @last_throttle_time
             elapsed = Time.now - @last_throttle_time
@@ -211,10 +361,11 @@ unless defined? $__rq_feeder__
           @last_throttle_time = Time.now 
         end
         yield
-    #}}}
+#--}}}
       end
       def start_jobs
-    #{{{
+#--{{{
+        debug{ "starting jobs..." }
         n_started = 0 
         transaction do
           until busy?
@@ -225,10 +376,10 @@ unless defined? $__rq_feeder__
         end
         debug{ "<#{ n_started }> jobs started" }
         n_started
-    #}}}
+#--}}}
       end
       def start_job job
-    #{{{
+#--{{{
         jid, command = job['jid'], job['command']
 
       #
@@ -238,6 +389,9 @@ unless defined? $__rq_feeder__
         job['started'] = Util::timestamp Time::now
         job['runner'] = Util::hostname 
 
+        job['stdout'] = @q.stdout4 jid
+        job['stderr'] = @q.stderr4 jid
+
         jr = @jrd.runner job
         cid = jr.cid
     
@@ -252,15 +406,16 @@ unless defined? $__rq_feeder__
         end
     
         cid
-    #}}}
+#--}}}
       end
       def nothing_running?
-    #{{{
+#--{{{
         @children.size == 0
-    #}}}
+#--}}}
       end
       def reap_jobs reap_only = false, blocking = true
-    #{{{
+#--{{{
+        debug{ "reaping jobs..." }
         reaped = []
 
         cid = status = nil
@@ -270,7 +425,7 @@ unless defined? $__rq_feeder__
             cid, status = @jrd.waitpid2 -1, Process::WUNTRACED 
           else
             loop do
-              debug{ "not busy wait loop" }
+              debug{ "not busy - busywait loop" }
               cid, status = @jrd.waitpid2 -1, Process::WNOHANG | Process::WUNTRACED 
               break if cid
               start_jobs unless $rq_signaled
@@ -299,6 +454,7 @@ unless defined? $__rq_feeder__
               start_jobs unless reap_only or $rq_signaled
     
               if @children.size == 0 or loopno > 42
+                sleep 8 if loopno > 42 # wow - we are CRANKING through jobs so BACK OFF!!
                 break
               else
                 sleep 0.1
@@ -311,14 +467,12 @@ unless defined? $__rq_feeder__
             end
           end
         end
-    
         debug{ "<#{ reaped.size }> jobs reaped" }
-    
         reaped
-    #}}}
+#--}}}
       end
       def finish_job job, status
-    #{{{
+#--{{{
         job['finished'] = Util::timestamp(Time::now)
         job['elapsed'] = Util::stamptime(job['finished']) - Util::stamptime(job['started'])
         t = status.exitstatus rescue nil 
@@ -329,10 +483,10 @@ unless defined? $__rq_feeder__
         else
           warn{ "finished - jid <#{ job['jid'] }> pid <#{ job['pid'] }> exit_status <#{ job['exit_status'] }>" }
         end
-    #}}}
+#--}}}
       end
       def transaction
-    #{{{
+#--{{{
         ret = nil
         if @in_transaction
           ret = yield
@@ -345,23 +499,23 @@ unless defined? $__rq_feeder__
           end
         end
         ret
-    #}}}
+#--}}}
       end
       def busy?
-    #{{{
+#--{{{
         @children.size >= @max_feed
-    #}}}
+#--}}}
       end
       def relax
-    #{{{
+#--{{{
         seconds = rand(@max_sleep - @min_sleep + 1) + @min_sleep
         debug{ "relaxing <#{ seconds }>" }
         sleep seconds
-    #}}}
+#--}}}
       end
-#}}}
+#--}}}
     end # class Feeder
-#}}}
+#--}}}
   end # module RQ
 $__rq_feeder__ = __FILE__ 
 end