faktory_worker_ruby 0.8.0 → 1.0.3

data/lib/faktory/connection.rb

@@ -7,7 +7,7 @@ module Faktory
       def create(options={})
         size = Faktory.worker? ? (Faktory.options[:concurrency] + 2) : 5
         ConnectionPool.new(:timeout => options[:pool_timeout] || 1, :size => size) do
-          Faktory::Client.new
+          Faktory::Client.new(**options)
         end
       end
     end

data/lib/faktory/io.rb

@@ -0,0 +1,51 @@
+require "io/wait"
+
+# this is the necessary magic to get a line-oriented protocol to
+# respect a read timeout. unfortunately Ruby sockets do not provide any
+# timeout support directly, delegating that to the IO reactor.
+module Faktory
+  class TimeoutError < Timeout::Error; end
+
+  module ReadTimeout
+    CRLF = "\r\n"
+    BUFSIZE = 16_384
+
+    # Ruby's TCP sockets do not implement timeouts.
+    # We have to implement them ourselves by using
+    # nonblocking IO and IO.select.
+    def initialize(**opts)
+      @buf = "".dup
+      @timeout = opts[:timeout] || 5
+    end
+
+    def gets
+      while (crlf = @buf.index(CRLF)).nil?
+        @buf << read_timeout(BUFSIZE)
+      end
+
+      @buf.slice!(0, crlf + 2)
+    end
+
+    def read(nbytes)
+      result = @buf.slice!(0, nbytes)
+      result << read_timeout(nbytes - result.bytesize) while result.bytesize < nbytes
+      result
+    end
+
+    private
+    def read_timeout(nbytes)
+      loop do
+        result = @sock.read_nonblock(nbytes, exception: false)
+        if result == :wait_readable
+          raise Faktory::TimeoutError unless @sock.wait_readable(@timeout)
+        elsif result == :wait_writable
+          raise Faktory::TimeoutError unless @sock.wait_writeable(@timeout)
+        elsif result == nil
+          raise Errno::ECONNRESET
+        else
+          return result
+        end
+      end
+    end
+  end
+end

data/lib/faktory/job.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true
+require 'faktory/tracking'
+
 module Faktory
 
   ##
@@ -20,6 +22,9 @@ module Faktory
   # Note that perform_async is a class method, perform is an instance method.
   module Job
     attr_accessor :jid
+    attr_accessor :bid
+
+    include Faktory::Trackable
 
     def self.included(base)
       raise ArgumentError, "You cannot include Faktory::Job in an ActiveJob: #{base.name}" if base.ancestors.any? {|c| c.name == 'ActiveJob::Base' }
@@ -28,6 +33,16 @@ module Faktory
       base.faktory_class_attribute :faktory_options_hash
     end
 
+    def self.set(options)
+      Setter.new(options)
+    end
+
+    def batch
+      if bid
+        @batch ||= Faktory::Batch.new(bid)
+      end
+    end
+
     def logger
       Faktory.logger
     end
@@ -42,7 +57,7 @@ module Faktory
       end
 
       def perform_async(*args)
-        @opts['jobtype'.freeze].client_push(@opts.merge!('args'.freeze => args))
+        client_push(@opts.merge('args'.freeze => args))
       end
 
       # +interval+ must be a timestamp, numeric or something that acts
@@ -53,34 +68,53 @@ module Faktory
         ts = (int < 1_000_000_000 ? now + int : int)
         at = Time.at(ts).utc.to_datetime.rfc3339(9)
 
-        @opts.merge! 'args'.freeze => args, 'at'.freeze => at
+        item = @opts.merge('args'.freeze => args, 'at'.freeze => at)
+
         # Optimization to enqueue something now that is scheduled to go out now or in the past
-        @opts.delete('at'.freeze) if ts <= now
-        @opts['jobtype'.freeze].client_push(@opts)
+        item.delete('at'.freeze) if ts <= now
+
+        client_push(item)
       end
       alias_method :perform_at, :perform_in
+
+      def client_push(item) # :nodoc:
+        # stringify
+        item.keys.each do |key|
+          item[key.to_s] = item.delete(key)
+        end
+        item["jid"] ||= SecureRandom.hex(12)
+        item["queue"] ||= "default"
+
+        pool = Thread.current[:faktory_via_pool] || item["pool"] || Faktory.server_pool
+        item.delete("pool")
+
+        # the payload hash is shallow copied by `merge` calls BUT we don't deep clone
+        # the 'custom' child hash which can be problematic if we mutate it within middleware.
+        # Proactively dup it first.
+        item["custom"] = item["custom"].dup if item["custom"]
+
+        Faktory.client_middleware.invoke(item, pool) do
+          pool.with do |c|
+            c.push(item)
+          end
+        end
+      end
     end
 
     module ClassMethods
 
       def set(options)
-        Setter.new(options.merge!('jobtype'.freeze => self))
+        Setter.new(options.merge('jobtype'.freeze => self))
       end
 
       def perform_async(*args)
-        client_push('jobtype'.freeze => self, 'args'.freeze => args)
+        set(get_faktory_options).perform_async(*args)
       end
 
       # +interval+ must be a timestamp, numeric or something that acts
       #   numeric (like an activesupport time interval).
       def perform_in(interval, *args)
-        int = interval.to_f
-        now = Time.now.to_f
-        ts = (int < 1_000_000_000 ? now + int : int)
-        item = { 'jobtype'.freeze => self, 'args'.freeze => args }
-
-        item['at'] = Time.at(ts).utc.to_datetime.rfc3339(9) if ts > now
-        client_push(item)
+        set(get_faktory_options).perform_in(interval, *args)
       end
       alias_method :perform_at, :perform_in
 
@@ -102,23 +136,6 @@ module Faktory
         self.faktory_options_hash ||= Faktory.default_job_options
       end
 
-      def client_push(item) # :nodoc:
-        pool = Thread.current[:faktory_via_pool] || get_faktory_options['pool'.freeze] || Faktory.server_pool
-        item = get_faktory_options.merge(item)
-        # stringify
-        item.keys.each do |key|
-          item[key.to_s] = item.delete(key)
-        end
-        item["jid"] ||= SecureRandom.hex(12)
-        item["queue"] ||= "default"
-
-        Faktory.client_middleware.invoke(item, pool) do
-          pool.with do |c|
-            c.push(item)
-          end
-        end
-      end
-
       def faktory_class_attribute(*attrs)
         instance_reader = true
         instance_writer = true

data/lib/faktory/launcher.rb

@@ -11,7 +11,7 @@ module Faktory
     def initialize(options)
       merged_options = Faktory.options.merge(options)
       @manager = Faktory::Manager.new(merged_options)
-      @done = false
+      @current_state = nil
       @options = merged_options
     end
 
@@ -22,7 +22,7 @@ module Faktory
 
     # Stops this instance from processing any more jobs,
     def quiet
-      @done = true
+      @current_state = 'quiet'
       @manager.quiet
     end
 
@@ -32,13 +32,17 @@ module Faktory
     def stop
       deadline = Time.now + @options[:timeout]
 
-      @done = true
+      @current_state = 'terminate'
       @manager.quiet
       @manager.stop(deadline)
     end
 
     def stopping?
-      @done
+      @current_state == 'terminate'
+    end
+
+    def quiet?
+      @current_state == 'quiet'
     end
 
     PROCTITLES = []
@@ -50,12 +54,13 @@ module Faktory
       PROCTITLES << proc { title }
       PROCTITLES << proc { "[#{Processor.busy_count} of #{@options[:concurrency]} busy]" }
       PROCTITLES << proc { "stopping" if stopping? }
+      PROCTITLES << proc { "quiet" if quiet? }
 
       loop do
         $0 = PROCTITLES.map {|p| p.call }.join(" ")
 
         begin
-          result = Faktory.server {|c| c.beat }
+          result = Faktory.server {|c| c.beat(@current_state) }
           case result
           when "OK"
             # all good

data/lib/faktory/logging.rb

@@ -29,7 +29,7 @@ module Faktory
     def self.job_hash_context(job_hash)
       # If we're using a wrapper class, like ActiveJob, use the "wrapped"
       # attribute to expose the underlying thing.
-      klass = job_hash['custom']['wrapped'] || job_hash["jobtype"]
+      klass = job_hash.dig('custom', 'wrapped') || job_hash["jobtype"]
       "#{klass} JID-#{job_hash['jid']}"
     end
 

data/lib/faktory/manager.rb

@@ -123,6 +123,9 @@ module Faktory
       cleanup.each do |processor|
         processor.kill
       end
+      cleanup.each do |processor|
+        processor.thread.join(1)
+      end
     end
 
   end

data/lib/faktory/middleware/batch.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+#
+# Simple middleware to save the current batch and restore it when the job executes.
+#
+module Faktory::Middleware::Batch
+  class Client
+    def call(payload, pool)
+      b = Thread.current[:faktory_batch]
+      if b
+        payload["custom"] ||= {}
+        payload["custom"]["bid"] = b.bid
+      end
+      yield
+    end
+  end
+
+  class Worker
+    def call(jobinst, payload)
+      jobinst.bid = payload.dig("custom", "bid")
+      yield
+    end
+  end
+end
+
+Faktory.configure_client do |config|
+  config.client_middleware do |chain|
+    chain.add Faktory::Middleware::Batch::Client
+  end
+end
+
+Faktory.configure_worker do |config|
+  config.client_middleware do |chain|
+    chain.add Faktory::Middleware::Batch::Client
+  end
+  config.worker_middleware do |chain|
+    chain.add Faktory::Middleware::Batch::Worker
+  end
+end

data/lib/faktory/mutate.rb

@@ -0,0 +1,91 @@
+require 'faktory/client'
+
+##
+#
+# Faktory's MUTATE API allows you to scan the sorted sets
+# within Redis (retries, scheduled, dead) and take action
+# (delete, enqueue, kill) on entries.
+#
+# require 'faktory/mutate'
+# cl = Faktory::Client.new
+# cl.discard(Faktory::RETRIES) do |filter|
+#   filter.with_type("QuickBooksSyncJob")
+#   filter.matching("*uid:12345*"))
+# end
+module Faktory
+
+  # Valid targets
+  RETRIES = "retries"
+  SCHEDULED = "scheduled"
+  DEAD = "dead"
+
+  module Mutator
+    class Filter
+      attr_accessor :hash
+
+      def initialize
+        @hash = {}
+      end
+
+      # This must be the exact type of the job, no pattern matching
+      def with_type(jobtype)
+        @hash[:jobtype] = jobtype
+      end
+
+      # This is a regexp that will be passed as is to Redis's SCAN.
+      # Notably you should surround it with * to ensure it matches
+      # substrings within the job payload.
+      # See https://redis.io/commands/scan for details.
+      def matching(regexp)
+        @hash[:regexp] = regexp
+      end
+
+      # One or more JIDs to target:
+      # filter.jids << 'abcdefgh1234'
+      # filter.jids = ['abcdefgh1234', '1234567890']
+      def jids
+        @hash[:jids] ||= []
+      end
+      def jids=(ary)
+        @hash[:jids] = Array(ary)
+      end
+    end
+
+    def discard(target, &block)
+      filter = Filter.new
+      block.call(filter) if block
+      mutate('discard', target, filter)
+    end
+
+    def kill(target, &block)
+      filter = Filter.new
+      block.call(filter) if block
+      mutate('kill', target, filter)
+    end
+
+    def requeue(target, &block)
+      filter = Filter.new
+      block.call(filter) if block
+      mutate('requeue', target, filter)
+    end
+
+    def clear(target)
+      mutate('discard', target, nil)
+    end
+
+    private
+
+    def mutate(cmd, target, filter)
+      payload = {:cmd => cmd,:target => target}
+      payload[:filter] = filter.hash if filter && !filter.hash.empty?
+
+      transaction do
+        command("MUTATE", JSON.dump(payload))
+        ok
+      end
+    end
+
+  end
+end
+
+Faktory::Client.send(:include, Faktory::Mutator)

data/lib/faktory/processor.rb

@@ -88,6 +88,7 @@ module Faktory
           @@busy_count = @@busy_count + 1
         end
         begin
+          @job = work.job
           process(work)
         ensure
           @@busy_lock.synchronize do
@@ -148,10 +149,11 @@ module Faktory
           end
         end
         work.acknowledge
-      rescue Faktory::Shutdown
-        # Had to force kill this job because it didn't finish
-        # within the timeout.  Don't acknowledge the work since
-        # we didn't properly finish it.
+      rescue Faktory::Shutdown => shut
+        # Had to force kill this job because it didn't finish within
+        # the timeout.  Fail it so we can release any locks server-side
+        # and immediately restart it.
+        work.fail(shut)
       rescue Exception => ex
         handle_exception(ex, { :context => "Job raised exception", :job => work.job })
         work.fail(ex)

data/lib/faktory/rails.rb

@@ -23,9 +23,19 @@ module Faktory
         if ::Rails::VERSION::MAJOR < 5
           raise "Your current version of Rails, #{::Rails::VERSION::STRING}, is not supported"
         end
-        
+
         Faktory.options[:reloader] = Faktory::Rails::Reloader.new
       end
+
+      begin
+        # https://github.com/rails/rails/pull/41248
+        if defined?(::Mail::SMTP)
+          ::Mail::SMTP::DEFAULTS[:read_timeout] ||= 5
+          ::Mail::SMTP::DEFAULTS[:open_timeout] ||= 5
+        end
+      rescue => ex
+        # ignore
+      end
     end
 
     class Reloader

data/lib/faktory/testing.rb

@@ -94,9 +94,9 @@ module Faktory
       end
     end
 
-    def open
+    def open(*args)
       unless Faktory::Testing.enabled?
-        real_open
+        real_open(*args)
       end
     end
   end