rq-ruby1.8 3.4.3

data/lib/rq/backer.rb

@@ -0,0 +1,31 @@
+unless defined? $__rq_backer__
+  module RQ 
+#--{{{
+    LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? LIBDIR
+
+    require LIBDIR + 'mainhelper'
+
+    #
+    # a Backer object makes an (optionally) timestamped hot backup/snapshot of a
+    # queue using a timestamp of milli second resolution.
+    #
+    class  Backer < MainHelper
+#--{{{
+      def backup 
+#--{{{
+        set_q
+        bak = @argv.shift
+        bak ||= "#{ @qpath }.#{ Util::timestamp.gsub(/[:\s\.-]/,'_') }.bak"
+        raise "<#{ bak }> exists" if bak and test(?e, bak)
+        debug{ "bak <#{ bak }>" }
+        @q.lock{ FileUtils::cp_r @qpath, bak }
+        info{ "created backup <#{ bak }>" }
+#--}}}
+      end
+#--}}}
+    end # class Backer
+#--}}}
+  end # module RQ
+$__rq_backer__ = __FILE__ 
+end

data/lib/rq/configfile.rb

@@ -0,0 +1,82 @@
+unless defined? $__rq_configfile__
+  module RQ 
+#--{{{
+    LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? LIBDIR
+
+    require 'yaml'
+
+    #
+    # 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 
+              arg.write @data
+            when String
+              open(arg, 'w'){|f| f.write @data}
+            else
+              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 
+            if test ?e, path
+              config = self::new(path)
+              break
+            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
+          yaml = self.class.load_default 
+          @path = 'DEFAULT' 
+        else path
+          yaml = YAML::load(self.class.munge(open(path).read))
+          @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/configurator.rb

@@ -0,0 +1,40 @@
+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?
+          kv_pat = %r/^\s*([^\s]+)\s*=+\s*([^\s]+)\s*$/o
+          @q.transaction do
+            @argv.each do |arg|
+              match = kv_pat.match arg
+              if match 
+                k, v = match[1], match[2] 
+                @q[k] = v
+              end
+            end
+            attributes = @q.attributes
+          end
+        end
+        y attributes
+#--}}}
+      end
+    end # class Configurator
+#--}}}
+  end # module RQ
+$__rq_configurator__ = __FILE__ 
+end

data/lib/rq/creator.rb

@@ -0,0 +1,54 @@
+unless defined? $__rq_creator__
+  module RQ 
+#--{{{
+    LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? LIBDIR
+
+    require 'fileutils'
+    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 }"
+          puts "data: #{ @q.data }"
+        end
+
+        rqmailer = File.join(File.dirname(@program), 'rqmailer')
+        if test ?e, rqmailer
+          FileUtils.cp rqmailer, @q.bin
+        end
+
+        self
+#--}}}
+      end
+#--}}}
+    end # class Creator
+#--}}}
+  end # module RQ
+$__rq_creator__ = __FILE__ 
+end

data/lib/rq/cron.rb

@@ -0,0 +1,144 @@
+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
+          opts = @options.map{|kv| "'--#{ kv.join('=') }'" }.join(' ')
+          entries = [
+            "*/15 * * * * #{ @cmd } start #{ opts } ###md5:#{ @md5[:start] }\n",
+            "0 0 * * * #{ @cmd } rotate ###md5:#{ @md5[:start] }\n",
+          ]
+          tmp = Tempfile::new Process::pid.to_s
+          lines.each{|line| tmp << "#{ line }\n"}
+          entries.each do |entry|
+            tmp << entry 
+          end
+          tmp.close
+          system("crontab #{ tmp.path }") or abort("failed to cronify!")
+          tmp.close!
+          entries.each do |entry|
+            puts entry
+          end
+        end
+#--}}}
+      end
+      def cron_tab
+#--{{{
+        opts = @options.map{|kv| "'--#{ kv.join('=') }'" }.join(' ')
+        entries = [
+          "*/15 * * * * #{ @cmd } start #{ opts } ###md5:#{ @md5[:start] }\n",
+          "0 0 * * * #{ @cmd } rotate ###md5:#{ @md5[:start] }\n",
+        ]
+        puts entries
+#--}}}
+      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
+
+p found
+
+        unless found.empty?
+          deleted = [] 
+          found.each{|idx| deleted << lines[idx]; lines.delete_at(idx)} 
+          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/defaultconfig.txt

@@ -0,0 +1,5 @@
+#
+# rq config
+#
+
+key : value

data/lib/rq/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/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