rq-ruby1.8 3.4.3

data/lib/rq/logging.rb

@@ -0,0 +1,124 @@
+unless defined? $__rq_logging__
+  module RQ 
+#--{{{
+    LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? LIBDIR
+
+    require "logger"
+
+    require LIBDIR + 'util'
+    #
+    # module which adds logging methods to all RQ classes
+    #
+    module Logging
+#--{{{
+    #
+    # a module that adds an accessor to Logging objects in ored to fix a bug where
+    # not all logging devices are put into sync mode, resulting in improper log
+    # rolling.  this is a hack.
+    #
+      module LoggerExt
+#--{{{
+        attr :logdev
+#--}}}
+      end # module LoggerExt
+    #
+    # implementations of the methods shared by both classes and objects of classes
+    # which include Logging
+    #
+      module LogMethods
+#--{{{
+        def logger
+#--{{{
+          if defined?(@logger) and @logger
+            @logger
+          else
+            if Class === self
+              @logger = self.default_logger
+            else
+              @logger = self::class::logger
+            end
+            raise "@logger is undefined!" unless defined?(@logger) and @logger
+            @logger
+          end
+#--}}}
+        end
+        def logger= log
+#--{{{
+          @logger = log
+          @logger.extend LoggerExt
+          @logger.logdev.dev.sync = true
+          @logger
+#--}}}
+        end
+        def debug(*args, &block); logger.debug(*args, &block); end
+        def info(*args, &block);  logger.info(*args, &block) ; end
+        def warn(*args, &block);  logger.warn(*args, &block) ; end
+        def error(*args, &block); logger.error(*args, &block); end
+        def fatal(*args, &block); logger.fatal(*args, &block); end
+        def logerr e
+#--{{{
+          if logger.debug?
+            error{ Util::errmsg e } 
+          else
+            error{ Util::emsg e } 
+          end
+#--}}}
+        end
+#--}}}
+      end # module LogMethods
+
+      module LogClassMethods
+#--{{{
+        def default_logger
+#--{{{
+          if defined?(@default_logger) and @default_logger
+            @default_logger
+          else
+            self.default_logger = Logger::new STDERR
+            @default_logger = Logger::INFO
+            @default_logger.warn{ "<#{ self }> using default logger"}
+            @default_logger
+          end
+#--}}}
+        end
+        def default_logger= log
+#--{{{
+          @default_logger = (Logger === log ? log : Logger::new(log))
+          @default_logger.extend LoggerExt
+          @default_logger.logdev.dev.sync = true
+          @default_logger
+#--}}}
+        end
+#--}}}
+      end
+
+      EOL    = "\n"
+      DIV0   = ("." * 79) << EOL 
+      DIV1   = ("-" * 79) << EOL 
+      DIV2   = ("=" * 79) << EOL 
+      DIV3   = ("#" * 79) << EOL 
+      SEC0   = ("." * 16) << EOL 
+      SEC1   = ("-" * 16) << EOL 
+      SEC2   = ("=" * 16) << EOL 
+      SEC3   = ("#" * 16) << EOL 
+
+      class << self
+#--{{{
+        def append_features c
+#--{{{
+          ret = super
+          c.extend LogMethods
+          c.extend LogClassMethods
+          ret
+#--}}}
+        end
+#--}}}
+      end
+      include LogMethods
+#--}}}
+    end # module Logging
+#--}}}
+  end # module rq
+$__rq_logging__ = __FILE__ 
+end

data/lib/rq/mainhelper.rb

@@ -0,0 +1,189 @@
+unless defined? $__rq_mainhelper__
+  module RQ 
+#--{{{
+    LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? LIBDIR
+
+    require 'tempfile'
+
+    require LIBDIR + 'util'
+    require LIBDIR + 'logging'
+
+    #
+    # the MainHelper class abstracts some of the common functions the various
+    # Main delegates require
+    #
+    class  MainHelper
+#--{{{
+      include Util
+      include Logging
+      attr :main
+      attr :argv
+      attr :env
+      attr :program
+      attr :stdin
+      attr :job_stdin
+      attr :cmd
+      attr :options
+      attr :qpath
+      attr :mode
+      attr :quiet
+      attr :q
+      attr :fields
+      attr :dot_rq_dir
+      attr :loops
+
+      alias_method 'stdin?', 'stdin'
+      alias_method 'job_stdin?', 'job_stdin'
+      alias_method 'quiet?', 'quiet'
+      def initialize main
+#--{{{
+        @main = main
+        @logger = main.logger
+        @argv = main.argv
+        @env = main.env
+        @program = main.program
+        @stdin = main.stdin
+        @data = main.data
+        @job_stdin = main.job_stdin
+        @cmd = main.cmd
+        @options = main.options
+        @qpath = main.qpath
+        @mode = main.mode
+        @quiet = main.quiet
+        @fields = main.fields
+        @dot_rq_dir = main.dot_rq_dir
+        @loops = main.loops
+        @q = nil 
+#--}}}
+      end
+      def set_q
+#--{{{
+        raise "q <#{ @qpath }> does not exist" unless test ?d, @qpath
+        @q = JobQueue::new @qpath, 'logger' => @logger
+        if @options['snapshot']
+          ss = "#{ $0 }_#{ Process::pid }_#{ Thread::current.object_id.abs }_#{ rand Time::now.to_i  }".gsub(%r|/|o,'_')
+          qtmp = File::join Dir::tmpdir, ss
+          @q = @q.snapshot qtmp, @options['retries']
+          at_exit{ FileUtils::rm_rf qtmp }
+        end
+#--}}}
+      end
+      def loadio io, path, jobs
+#--{{{
+        while((line = io.gets))
+          if line =~ %r/^---\s*$/o
+            loaded = YAML::load io 
+            raise "no jobs in <#{ path }>" unless 
+              Array === loaded and 
+              Hash === loaded.first and Hash === loaded.last
+            loaded.each{|job| jobs << job}
+            loaded = nil
+          else
+            # line.gsub!(%r/(?:^\s+)|(?:\s+$)|(?:#.*$)/o, '')
+            line.strip!
+            next if line.empty?
+            job = Job::new
+            if((m =  %r/^\s*(?:jid\s*=\s*)?(\d+)\s*$/io.match(line)))
+              job['jid'] = Integer(m[1])
+            else
+              job['command'] = line
+            end
+            jobs << job
+          end
+        end
+#--}}}
+      end
+      def loadio io, path, jobs
+#--{{{
+        while((line = io.gets))
+          if line =~ %r/^---\s*$/o
+            loadyaml io, path, jobs
+          else
+            # line.gsub!(%r/(?:^\s+)|(?:\s+$)|(?:#.*$)/o, '')
+            line.strip!
+            next if line.empty?
+            job = Job::new
+            if((m =  %r/^\s*(?:jid\s*=\s*)?(\d+)\s*$/io.match(line)))
+              job['jid'] = Integer(m[1])
+            else
+              job['command'] = line
+            end
+            jobs << job
+          end
+        end
+#--}}}
+      end
+      def loadyaml io, path, jobs
+#--{{{
+        h = nil
+        while((line = io.gets))
+          line.strip!
+          next if line.empty?
+          case line
+            when %r/^\s*-\s*$/
+              jobs << h if h
+              h = {}
+            else
+              k, v = line.split %r/:/, 2
+              k.strip!
+              v.strip!
+              h[k] = v
+          end
+        end
+        jobs << h if h
+#--}}}
+      end
+      def dumping_yaml_tuples
+#--{{{
+        fields = nil
+        dump = lambda do |tuple|
+          puts '---'
+          if fields.nil?
+            if @fields
+              fields = field_match @fields, tuple.fields
+            else
+              fields = tuple.fields
+            end
+          end
+          dump = lambda do |tuple|
+            puts '-'
+            fields.each{|f| puts " #{ f }: #{ tuple[ f ] }"}
+          end
+          dump[tuple]
+        end
+        lambda{|tuple| dump[tuple]}
+#--}}}
+      end
+      def field_match srclist, dstlist
+#--{{{
+        fields = dstlist.select do |dst|
+          srclist.map do |src|
+            re =
+              if src =~ %r/^[a-zA-Z0-9_-]+$/
+                %r/^#{ src }/i
+              else
+                %r/#{ src }/i
+              end
+            src == dst or dst =~ re
+          end.any?
+        end.uniq
+#--}}}
+      end
+      def init_job_stdin!
+#--{{{
+        if @job_stdin == '-'
+          tmp = Tempfile::new "#{ Process::pid  }_#{ rand 42 }"
+          while((buf = STDIN.read(8192))); tmp.write buf; end
+          tmp.close
+          @job_stdin = tmp.path 
+        end
+        @job_stdin
+#--}}}
+      end
+#--}}}
+    end # class MainHelper
+#--}}}
+  end # module RQ
+$__rq_mainhelper__ = __FILE__ 
+end

data/lib/rq/orderedautohash.rb

@@ -0,0 +1,39 @@
+unless defined? $__rq_orderedautohash__
+  module RQ 
+#--{{{
+    LIBDIR = File::dirname(File::expand_path(__FILE__)) + File::SEPARATOR unless
+      defined? LIBDIR
+
+    require LIBDIR + 'orderedhash'
+
+#if false
+    class ::OrderedHash
+#--{{{
+      def initialize(*a, &b)
+#--{{{
+        super
+        @order = []
+#--}}}
+      end
+#--}}}
+    end
+#end
+
+    class OrderedAutoHash < ::OrderedHash
+#--{{{
+      def initialize(*args)
+#--{{{
+        super(*args){|a,k| a[k] = OrderedAutoHash::new(*args)}
+#--}}}
+      end
+      def class
+#--{{{
+        ::Hash
+#--}}}
+      end
+#--}}}
+    end # class OrderedAutoHash
+#--}}}
+  end # module RQ
+$__rq_orderedautohash__ = __FILE__ 
+end

data/lib/rq/orderedhash.rb

@@ -0,0 +1,240 @@
+# AUTHOR
+#    jan molic /mig/at/1984/dot/cz/
+#
+# DESCRIPTION
+#    Hash with preserved order and some array-like extensions
+#    Public domain. 
+#
+# THANKS
+#    Andrew Johnson for his suggestions and fixes of Hash[],
+#    merge, to_a, inspect and shift
+#
+# USAGE
+#    just require this file and use OrderedHash instead of Hash (examples are at the end)
+#    you can try to run this file (ruby orderedhash.rb)
+#    
+
+class OrderedHash < Hash
+
+    attr_accessor :order
+
+    class << self
+	def [] *args
+	    hsh = OrderedHash.new
+	    if Hash === args[0]
+		hsh.replace args[0]
+	    elsif (args.size % 2) != 0
+		raise ArgumentError, "odd number of elements for Hash"
+	    else
+		hsh[args.shift] = args.shift while args.size > 0
+	    end
+	    hsh
+	end
+    end
+
+    def initialize 
+	@order = []
+    end
+    
+    def store_only a,b
+	store a,b
+    end
+    
+    alias orig_store store    
+    def store a,b
+	@order.push a unless has_key? a
+	super a,b
+    end
+    alias []= store
+    
+    def == hsh2
+	return false if @order != hsh2.order
+	super hsh2
+    end
+    
+    def clear
+	@order = []
+	super
+    end
+    
+    def delete key
+	@order.delete key
+	super
+    end
+    
+    def each_key
+	@order.each { |k| yield k }
+	self
+    end
+    
+    def each_value
+	@order.each { |k| yield self[k] }
+	self
+    end
+    
+    def each
+	@order.each { |k| yield k,self[k] }
+	self
+    end
+    alias each_pair each    
+
+    def delete_if
+	@order.clone.each { |k| 
+	    delete k if yield
+	}
+	self
+    end
+    
+    def values
+	ary = []
+	@order.each { |k| ary.push self[k] }
+	ary
+    end
+    
+    def keys
+	@order
+    end
+    
+    def invert
+	hsh2 = Hash.new    
+	@order.each { |k| hsh2[self[k]] = k }
+	hsh2
+    end
+    
+    def reject &block
+	self.dup.delete_if &block
+    end
+    
+    def reject! &block
+	hsh2 = reject &block
+	self == hsh2 ? nil : hsh2
+    end
+
+    def replace hsh2
+	@order = hsh2.keys 
+	super hsh2
+    end
+    
+    def shift
+	key = @order.first
+	key ? [key,delete(key)] : super
+    end
+
+    def unshift k,v
+	unless self.include? k
+	    @order.unshift k
+	    orig_store(k,v)
+	    true
+	else
+	    false
+	end
+    end
+    
+    def push k,v
+	unless self.include? k
+	    @order.push k
+	    orig_store(k,v)
+	    true
+	else
+	    false
+	end
+    end
+    
+    def pop
+	key = @order.last
+	key ? [key,delete(key)] : nil
+    end
+    
+    def to_a
+	ary = []
+	each { |k,v| ary << [k,v] }
+	ary
+    end
+    
+    def to_s
+	self.to_a.to_s
+    end
+    
+    def inspect
+	ary = []
+	each {|k,v| ary << k.inspect + "=>" + v.inspect}
+	'{' + ary.join(", ") + '}'
+    end
+    
+    def update hsh2
+	hsh2.each { |k,v| self[k] = v }
+	self
+    end
+    alias :merge! update
+    
+    def merge hsh2
+	self.dup update(hsh2)
+    end
+    
+    def select
+	ary = []
+	each { |k,v| ary << [k,v] if yield k,v }
+	ary
+    end
+
+    attr_accessor "to_yaml_style"
+    def yaml_inline= bool
+      if respond_to?("to_yaml_style")
+        self.to_yaml_style = :inline
+      else
+        unless defined? @__yaml_inline_meth
+          @__yaml_inline_meth =
+            lambda {|opts|
+              YAML::quick_emit(object_id, opts) {|emitter|
+                emitter << '{ ' << map{|kv| kv.join ': '}.join(', ') << ' }'
+              }
+            }
+          class << self
+            def to_yaml opts = {}
+              begin
+                @__yaml_inline ? @__yaml_inline_meth[ opts ] : super
+              rescue
+                @to_yaml_style = :inline
+                super
+              end
+            end
+          end
+        end
+      end
+      @__yaml_inline = bool
+    end
+    def yaml_inline!() self.yaml_inline = true end
+    
+end
+
+if __FILE__ == $0
+
+    # You can do simply
+    hsh = OrderedHash.new
+    hsh['z'] = 1
+    hsh['a'] = 2
+    hsh['c'] = 3
+    p hsh.keys     # ['z','a','c']
+
+    # or using OrderedHash[] method
+    hsh = OrderedHash['z', 1, 'a', 2, 'c', 3] 
+    p hsh.keys     # ['z','a','c']
+
+    # but this don't preserve order
+    hsh = OrderedHash['z'=>1, 'a'=>2, 'c'=>3]
+    p hsh.keys     # ['a','c','z']
+
+    # OrderedHash has useful extensions: push, pop and unshift
+    p hsh.push('to_end', 15)  # true, key added
+    p hsh.push('to_end', 30)  # false, already - nothing happen
+    p hsh.unshift('to_begin', 50)  # true, key added
+    p hsh.unshift('to_begin', 60)  # false, already - nothing happen
+    p hsh.keys     # ["to_begin", "a", "c", "z", "to_end"]
+    p hsh.pop      # ["to_end", 15], if nothing remains, return nil
+    p hsh.keys     # ["to_begin", "a", "c", "z"]
+    p hsh.shift    # ["to_begin", 30], if nothing remains, return nil
+
+end
+
+
+# END