resque_sqs 1.25.2

data/lib/resque_sqs/stat.rb

@@ -0,0 +1,57 @@
+module ResqueSqs
+  # The stat subsystem. Used to keep track of integer counts.
+  #
+  #   Get a stat:  Stat[name]
+  #   Incr a stat: Stat.incr(name)
+  #   Decr a stat: Stat.decr(name)
+  #   Kill a stat: Stat.clear(name)
+  module Stat
+    extend self
+    
+    # Direct access to the Redis instance.
+    def redis
+      ResqueSqs.redis
+    end
+
+    # Returns the int value of a stat, given a string stat name.
+    def get(stat)
+      redis.get("stat:#{stat}").to_i
+    end
+
+    # Alias of `get`
+    def [](stat)
+      get(stat)
+    end
+
+    # For a string stat name, increments the stat by one.
+    #
+    # Can optionally accept a second int parameter. The stat is then
+    # incremented by that amount.
+    def incr(stat, by = 1)
+      redis.incrby("stat:#{stat}", by)
+    end
+
+    # Increments a stat by one.
+    def <<(stat)
+      incr stat
+    end
+
+    # For a string stat name, decrements the stat by one.
+    #
+    # Can optionally accept a second int parameter. The stat is then
+    # decremented by that amount.
+    def decr(stat, by = 1)
+      redis.decrby("stat:#{stat}", by)
+    end
+
+    # Decrements a stat by one.
+    def >>(stat)
+      decr stat
+    end
+
+    # Removes a stat from Redis, effectively setting it to 0.
+    def clear(stat)
+      redis.del("stat:#{stat}")
+    end
+  end
+end

data/lib/resque_sqs/tasks.rb

@@ -0,0 +1,83 @@
+# require 'resque_sqs/tasks'
+# will give you the resque tasks
+
+namespace :resque_sqs do
+  task :setup
+
+  desc "Start a Resque worker"
+  task :work => [ :preload, :setup ] do
+    require 'resque_sqs'
+
+    queues = (ENV['QUEUES'] || ENV['QUEUE']).to_s.split(',')
+
+    begin
+      worker = ResqueSqs::Worker.new(*queues)
+      if ENV['LOGGING'] || ENV['VERBOSE']
+        worker.verbose = ENV['LOGGING'] || ENV['VERBOSE']
+      end
+      if ENV['VVERBOSE']
+        worker.very_verbose = ENV['VVERBOSE']
+      end
+      worker.term_timeout = ENV['RESQUE_TERM_TIMEOUT'] || 4.0
+      worker.term_child = ENV['TERM_CHILD']
+      worker.run_at_exit_hooks = ENV['RUN_AT_EXIT_HOOKS']
+    rescue ResqueSqs::NoQueueError
+      abort "set QUEUE env var, e.g. $ QUEUE=critical,high rake resque_sqs:work"
+    end
+
+    if ENV['BACKGROUND']
+      unless Process.respond_to?('daemon')
+          abort "env var BACKGROUND is set, which requires ruby >= 1.9"
+      end
+      Process.daemon(true, true)
+    end
+
+    if ENV['PIDFILE']
+      File.open(ENV['PIDFILE'], 'w') { |f| f << worker.pid }
+    end
+
+    worker.log "Starting worker #{worker}"
+
+    worker.work(ENV['INTERVAL'] || 5) # interval, will block
+  end
+
+  desc "Start multiple Resque workers. Should only be used in dev mode."
+  task :workers do
+    threads = []
+
+    ENV['COUNT'].to_i.times do
+      threads << Thread.new do
+        system "rake resque_sqs:work"
+      end
+    end
+
+    threads.each { |thread| thread.join }
+  end
+
+  # Preload app files if this is Rails
+  task :preload => :setup do
+    if defined?(Rails) && Rails.respond_to?(:application)
+      # Rails 3
+      Rails.application.eager_load!
+    elsif defined?(Rails::Initializer)
+      # Rails 2.3
+      $rails_rake_task = false
+      Rails::Initializer.run :load_application_classes
+    end
+  end
+
+  namespace :failures do
+    desc "Sort the 'failed' queue for the redis_multi_queue failure backend"
+    task :sort do
+      require 'resque_sqs'
+      require 'resque_sqs/failure/redis'
+
+      warn "Sorting #{ResqueSqs::Failure.count} failures..."
+      ResqueSqs::Failure.each(0, ResqueSqs::Failure.count) do |_, failure|
+        data = ResqueSqs.encode(failure)
+        ResqueSqs.redis.rpush(ResqueSqs::Failure.failure_queue_name(failure['queue']), data)
+      end
+      warn "done!"
+    end
+  end
+end

data/lib/resque_sqs/vendor/utf8_util/utf8_util_18.rb

@@ -0,0 +1,91 @@
+require 'strscan'
+
+module UTF8Util
+  HIGH_BIT_RANGE = /[\x80-\xff]/
+
+  # Check if this String is valid UTF-8
+  #
+  # Returns true or false.
+  def self.valid?(str)
+    sc = StringScanner.new(str)
+
+    while sc.skip_until(HIGH_BIT_RANGE)
+      sc.pos -= 1
+
+      if !sequence_length(sc)
+        return false
+      end
+    end
+
+    true
+  end
+
+  # Replace invalid UTF-8 character sequences with a replacement character
+  #
+  # Returns self as valid UTF-8.
+  def self.clean!(str)
+    sc = StringScanner.new(str)
+    while sc.skip_until(HIGH_BIT_RANGE)
+      pos = sc.pos = sc.pos-1
+
+      if !sequence_length(sc)
+        str[pos] = REPLACEMENT_CHAR
+      end
+    end
+
+    str
+  end
+
+  # Validate the UTF-8 sequence at the current scanner position.
+  #
+  # scanner - StringScanner instance so we can advance the pointer as we verify.
+  #
+  # Returns The length in bytes of this UTF-8 sequence, false if invalid.
+  def self.sequence_length(scanner)
+    leader = scanner.get_byte[0]
+
+    if (leader >> 5) == 0x6
+      if check_next_sequence(scanner)
+        return 2
+      else
+        scanner.pos -= 1
+      end
+    elsif (leader >> 4) == 0x0e
+      if check_next_sequence(scanner)
+        if check_next_sequence(scanner)
+          return 3
+        else
+          scanner.pos -= 2
+        end
+      else
+        scanner.pos -= 1
+      end
+    elsif (leader >> 3) == 0x1e
+      if check_next_sequence(scanner)
+        if check_next_sequence(scanner)
+          if check_next_sequence(scanner)
+            return 4
+          else
+            scanner.pos -= 3
+          end
+        else
+          scanner.pos -= 2
+        end
+      else
+        scanner.pos -= 1
+      end
+    end
+
+    false
+  end
+
+  private
+
+  # Read another byte off the scanner oving the scan position forward one place
+  #
+  # Returns nothing.
+  def self.check_next_sequence(scanner)
+    byte = scanner.get_byte[0]
+    (byte >> 6) == 0x2
+  end
+end

data/lib/resque_sqs/vendor/utf8_util/utf8_util_19.rb

@@ -0,0 +1,5 @@
+module UTF8Util
+  def self.clean!(str)
+    str.force_encoding("binary").encode("UTF-8", :invalid => :replace, :undef => :replace, :replace => REPLACEMENT_CHAR)
+  end
+end

data/lib/resque_sqs/vendor/utf8_util.rb

@@ -0,0 +1,20 @@
+module UTF8Util
+  # use '?' intsead of the unicode replace char, since that is 3 bytes
+  # and can increase the string size if it's done a lot
+  REPLACEMENT_CHAR = "?"
+
+  # Replace invalid UTF-8 character sequences with a replacement character
+  #
+  # Returns self as valid UTF-8.
+  def self.clean!(str)
+    return str if str.encoding.to_s == "UTF-8"
+    str.force_encoding("binary").encode("UTF-8", :invalid => :replace, :undef => :replace, :replace => REPLACEMENT_CHAR)
+  end
+
+  # Replace invalid UTF-8 character sequences with a replacement character
+  #
+  # Returns a copy of this String as valid UTF-8.
+  def self.clean(str)
+    clean!(str.dup)
+  end
+end

data/lib/resque_sqs/version.rb

@@ -0,0 +1,3 @@
+module ResqueSqs
+  Version = VERSION = '1.25.2'
+end