faktory_worker_ruby 0.8.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7877d9a875449524da22d1e8efd6f29a23381fe0
-  data.tar.gz: 665d0631430befd3f019588366502558f7e6f9c8
+SHA256:
+  metadata.gz: 52c0a1a508d1d2451f4c350b71f0d4091e7c134b8c4b57b802023e0f1527bd1d
+  data.tar.gz: 98fedca04b49b7ab68d8ce398099cfeb92b74d4bd4d3b8951c4f2a15d8d27d10
 SHA512:
-  metadata.gz: 3b6c62d76a317adecdf96e161a42ad817a5cc4b3e23c0bab49b6217e7240a7aef2348b0ff2117b156d10eaed6f832196e38e53e75fabae154263069a2e7ee29f
-  data.tar.gz: b0d68a791832e2e916578757b93675c408461e93022483da0cd24f1dcce3d4fe5b825505f1d6c1985a0b6880958db2ede88ccf689a9e031de98aae2813327820
+  metadata.gz: e3a1766171e19dd6750a558dd93eb4734529412674aac18f18b792c716643d5d09e668f0e5ddaf5b291a0c861729a9a29a7918db6b56ac314bbd6d761ab31b6f
+  data.tar.gz: 5c1f3c6d16d42ecb2e90e82ff926d147526ce483cc5b4ac178459935e4b22c6bf4e9816038f82fa317871c53df54ee631a817ebbfc47c42f85a519e12cccee55

data/Changes.md

@@ -1,5 +1,13 @@
 # Changes
 
+## 1.0.0
+
+- Ruby 2.5+ is now required
+- Support for Faktory Enterprise, job batches and job tracking
+- Support for the MUTATE command.
+- Notify Faktory when a worker process is going quiet so that the UI shows this
+- Refactor Faktory::Client error handling for faktory#208
+
 ## 0.8.1
 
 - Fix breakage with non-ActiveJobs [#29]

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
+gem 'simplecov', require: false, group: :test
+
 gemspec

data/Gemfile.lock

@@ -1,30 +1,37 @@
 PATH
   remote: .
   specs:
-    faktory_worker_ruby (0.8.1)
-      connection_pool (~> 2.2, >= 2.2.1)
+    faktory_worker_ruby (1.0.0)
+      connection_pool (~> 2.2, >= 2.2.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activejob (5.2.1)
-      activesupport (= 5.2.1)
+    activejob (5.2.2)
+      activesupport (= 5.2.2)
       globalid (>= 0.3.6)
-    activesupport (5.2.1)
+    activesupport (5.2.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    concurrent-ruby (1.0.5)
+    concurrent-ruby (1.1.4)
     connection_pool (2.2.2)
-    globalid (0.4.1)
+    docile (1.3.1)
+    globalid (0.4.2)
       activesupport (>= 4.2.0)
-    i18n (1.1.0)
+    i18n (1.5.3)
       concurrent-ruby (~> 1.0)
+    json (2.1.0)
     minitest (5.11.3)
     minitest-hooks (1.5.0)
       minitest (> 5.3)
     rake (12.3.1)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
     thread_safe (0.3.6)
     tzinfo (1.2.5)
       thread_safe (~> 0.1)
@@ -38,6 +45,4 @@ DEPENDENCIES
   minitest (~> 5)
   minitest-hooks
   rake (~> 12)
-
-BUNDLED WITH
-   1.17.1
+  simplecov

data/faktory_worker_ruby.gemspec

@@ -14,9 +14,9 @@ Gem::Specification.new do |gem|
   gem.files         = `git ls-files | grep -Ev '^(test|myapp|examples)'`.split("\n")
   gem.test_files    = []
   gem.version       = Faktory::VERSION
-  gem.required_ruby_version = ">= 2.3.0"
+  gem.required_ruby_version = ">= 2.5.0"
 
-  gem.add_dependency                  'connection_pool', '~> 2.2', ">= 2.2.1"
+  gem.add_dependency                  'connection_pool', '~> 2.2', ">= 2.2.2"
   gem.add_development_dependency      'activejob', '>= 5.1.5'
   gem.add_development_dependency      'minitest', '~> 5'
   gem.add_development_dependency      'minitest-hooks'

data/lib/faktory.rb

@@ -52,6 +52,7 @@ module Faktory
   #     config.worker_middleware do |chain|
   #       chain.add MyServerHook
   #     end
+  #     config.default_job_options = { retry: 3 }
   #   end
   def self.configure_worker
     yield self if worker?
@@ -61,7 +62,7 @@ module Faktory
   # Configuration for Faktory client, use like:
   #
   #   Faktory.configure_client do |config|
-  #     config.faktory = { :size => 1, :url => 'myhost:7419' }
+  #     config.default_job_options = { retry: 3 }
   #   end
   def self.configure_client
     yield self unless worker?
@@ -164,3 +165,4 @@ module Faktory
 end
 
 require 'faktory/rails' if defined?(::Rails::Engine)
+require 'faktory/batch'

data/lib/faktory/batch.rb

@@ -0,0 +1,178 @@
+require "faktory/middleware/batch"
+
+module Faktory
+  ##
+  # A Batch is a set of jobs which can be tracked as a group, with
+  # callbacks that can fire after all the jobs are attempted or successful.
+  # Every batch must define at least one callback.
+  #
+  # * The "complete" callback is fired when all jobs in the batch have been attempted.
+  #   Some might have failed.
+  # * The "success" callback is fired when all jobs in the batch have succeeded. This
+  #   might never be fired if a job continues to error until it runs out of retries.
+  #
+  # **Please note that batches are only available in Faktory Enterprise.** This is
+  # the client-side code required to implement batches, it won't work without
+  # the server-side component.
+  #
+  # Simple example:
+  #
+  #   b = Faktory::Batch.new
+  #   b.description = "Process all documents for user 12345"
+  #   # a callback can be defined as just a Ruby job class
+  #   b.success = "MySuccessCallbackJob"
+  #   # or the full job hash...
+  #   b.complete = { jobtype: "MyCompleteCallbackJob", args: [12345], queue: "critical" }
+  #   b.jobs do
+  #     SomeJob.perform_async(xyz)
+  #     AnotherJob.perform_async(user_id)
+  #   end
+  #
+  # At the end of the `jobs` call, the batch is persisted to the Faktory server. It must
+  # not be modified further with one exception: jobs within the batch can "reopen" the batch
+  # in order to dynamically add more jobs or child batches.
+  #
+  # Any job within a batch may "reopen" its own batch to dynamically add more jobs.
+  # A job can get access to its batch by using the `bid` or `batch` accessor on
+  # `Faktory::Job`. You can use the `bid` accessor to test if the job is part of a batch.
+  #
+  # Reopen example:
+  #
+  #  class MyJob
+  #    include Faktory::Job
+  #
+  #    def perform
+  #      batch.jobs do
+  #        SomeOtherJob.perform_async
+  #      end if bid
+  #    end
+  #
+  # Batches may be nested without limit by setting `parent_bid` when creating a
+  # batch. Generally you create child batches if you wish that subset of jobs to have
+  # their own callback for your application logic purposes. Otherwise you can reopen the
+  # current batch and add more jobs.
+  #
+  # Batch parent/child relationship is never implicit: you must manually set
+  # `parent_bid` if you wish to define a child batch.
+  #
+  # Nested example:
+  #
+  #  class MyJob
+  #    include Faktory::Job
+  #
+  #    def perform
+  #      child = Faktory::Batch.new
+  #
+  #      # MyJob is executing as part of a previously defined batch.
+  #      # Add a new child batch to this batch.
+  #      child.parent_bid = bid
+  #      child.success = ...
+  #      child.jobs do |cb|
+  #        SomeJob.perform_async
+  #
+  #        gchild = Faktory::Batch.new
+  #        gchild.parent_bid = cb.bid
+  #        gchild.success = ...
+  #        gchild.jobs do |gcb|
+  #          ChildJob.perform_async
+  #        end
+  #      end
+  #    end
+  #  end
+  #
+  # Callbacks are guaranteed to be called hierarchically: child's success callback
+  # will not be called until gchild's success callback has executed successfully.
+  #
+  class Batch
+    attr_reader :bid
+    attr_accessor :description, :parent_bid
+
+    def initialize(bid=nil)
+      @bid = bid
+    end
+
+    def success=(val)
+      raise "Batch cannot be modified once created" if bid
+      @success = to_callback(val)
+    end
+
+    def complete=(val)
+      raise "Batch cannot be modified once created" if bid
+      @success = to_callback(val)
+    end
+
+    def jobs(&block)
+      Faktory.server do |client|
+        if @bid.nil?
+          @bid = client.create_batch(self, &block)
+        else
+          client.reopen_batch(self, &block)
+        end
+      end
+    end
+
+    def to_h
+      raise ArgumentError, "Callback required" unless defined?(@success) || defined?(@complete)
+
+      hash = {}
+      hash["parent_bid"] = parent_bid if parent_bid
+      hash["description"] = description if description
+      hash["success"] = @success if defined?(@success)
+      hash["complete"] = @complete if defined?(@complete)
+      hash
+    end
+
+    private
+
+    def to_callback(val)
+      case val
+      when String
+        basic_job.merge({ "jobtype" => val })
+      when Class
+        basic_job.merge({ "jobtype" => val })
+      when Hash
+        basic_job.merge(val)
+      else
+        raise ArgumentError, "Unknown callback #{val}"
+      end
+    end
+
+    def basic_job
+      {
+        "jid"   => SecureRandom.hex(12),
+        "args"  => [],
+        "queue" => "default",
+      }
+    end
+  end
+
+  class BatchStatus
+    def initialize(bid)
+      @bid = bid
+    end
+
+    def hash
+      @hash ||= Faktory.server{|c| c.batch_status(@bid) }
+    end
+
+    def created_at
+      hash["created_at"]
+    end
+
+    def description
+      hash["description"]
+    end
+
+    def parent_bid
+      hash["parent_bid"]
+    end
+
+    def total
+      hash["total"]
+    end
+
+    def pending
+      hash["pending"]
+    end
+  end
+end

data/lib/faktory/cli.rb

@@ -8,6 +8,11 @@ require 'optparse'
 require 'erb'
 require 'fileutils'
 
+module Faktory
+  class CLI
+  end
+end
+
 require 'faktory'
 require 'faktory/util'
 

data/lib/faktory/client.rb

@@ -5,12 +5,20 @@ require 'digest'
 require 'securerandom'
 
 module Faktory
-  class CommandError < StandardError;end
-  class ParseError < StandardError;end
-
+  class BaseError < StandardError; end
+  class CommandError < BaseError; end
+  class ParseError < BaseError; end
+
+  # Faktory::Client provides a low-level connection to a Faktory server
+  # and APIs which map to Faktory commands.
+  #
+  # Most APIs will return `true` if the operation succeeded or raise a
+  # Faktory::BaseError if there was an unexpected error.
   class Client
     @@random_process_wid = ""
 
+    DEFAULT_TIMEOUT = 5.0
+
     HASHER = proc do |iter, pwd, salt|
       sha = Digest::SHA256.new
       hashing = pwd + salt
@@ -36,10 +44,12 @@ module Faktory
     # MY_FAKTORY_URL=tcp://:somepass@my-server.example.com:7419
     #
     # Note above, the URL can contain the password for secure installations.
-    def initialize(url: uri_from_env || 'tcp://localhost:7419', debug: false)
+    def initialize(url: uri_from_env || 'tcp://localhost:7419', debug: false, timeout: DEFAULT_TIMEOUT)
       @debug = debug
       @location = URI(url)
-      open
+      @timeout = timeout
+
+      open(@timeout)
     end
 
     def close
@@ -53,23 +63,95 @@ module Faktory
     def flush
       transaction do
         command "FLUSH"
-        ok!
+        ok
+      end
+    end
+
+    def create_batch(batch, &block)
+      bid = transaction do
+        command "BATCH NEW", Faktory.dump_json(batch.to_h)
+        result!
+      end
+      batch.instance_variable_set(:@bid, bid)
+
+      old = Thread.current["faktory_batch"]
+      Thread.current["faktory_batch"] = batch
+      begin
+        # any jobs pushed in this block will implicitly have
+        # their `bid` attribute set so they are associated
+        # with the current batch.
+        yield batch
+      ensure
+        Thread.current[:faktory_batch] = old
+      end
+      transaction do
+        command "BATCH COMMIT", bid
+        ok
       end
+      bid
     end
 
+    def batch_status(bid)
+      transaction do
+        command "BATCH STATUS", bid
+        Faktory.load_json result!
+      end
+    end
+
+    def reopen_batch(b)
+      transaction do
+        command "BATCH OPEN", b.bid
+        ok
+      end
+      old = Thread.current[:faktory_batch]
+      Thread.current[:faktory_batch] = b
+      begin
+        # any jobs pushed in this block will implicitly have
+        # their `bid` attribute set so they are associated
+        # with the current batch.
+        yield b
+      ensure
+        Thread.current[:faktory_batch] = old
+      end
+      transaction do
+        command "BATCH COMMIT", b.bid
+        ok
+      end
+    end
+
+    def get_track(jid)
+      transaction do
+        command "TRACK GET", jid
+        hashstr = result!
+        JSON.parse(hashstr)
+      end
+    end
+
+    # hash must include a 'jid' element
+    def set_track(hash)
+      transaction do
+        command("TRACK SET", Faktory.dump_json(hash))
+        ok
+      end
+    end
+
+    # Push a hash corresponding to a job payload to Faktory.
+    # Hash must contain "jid", "jobtype" and "args" elements at minimum.
+    # Returned value will either be the JID String if successful OR
+    # a symbol corresponding to an error.
     def push(job)
       transaction do
-        command "PUSH", JSON.generate(job)
-        ok!
-        job["jid"]
+        command "PUSH", Faktory.dump_json(job)
+        ok(job["jid"])
       end
     end
 
+    # Returns either a job hash or falsy.
     def fetch(*queues)
       job = nil
       transaction do
         command("FETCH", *queues)
-        job = result
+        job = result!
       end
       JSON.parse(job) if job
     end
@@ -77,34 +159,42 @@ module Faktory
     def ack(jid)
       transaction do
         command("ACK", %Q[{"jid":"#{jid}"}])
-        ok!
+        ok
       end
     end
 
     def fail(jid, ex)
       transaction do
-        command("FAIL", JSON.dump({ message: ex.message[0...1000],
+        command("FAIL", Faktory.dump_json({ message: ex.message[0...1000],
                           errtype: ex.class.name,
                           jid: jid,
                           backtrace: ex.backtrace}))
-        ok!
+        ok
       end
     end
 
     # Sends a heartbeat to the server, in order to prove this
     # worker process is still alive.
     #
+    # You can pass in the current_state of the process, for example during shutdown
+    # quiet and/or terminate can be supplied.
+    #
     # Return a string signal to process, legal values are "quiet" or "terminate".
     # The quiet signal is informative: the server won't allow this process to FETCH
     # any more jobs anyways.
-    def beat
+    def beat(current_state = nil)
       transaction do
-        command("BEAT", %Q[{"wid":"#{@@random_process_wid}"}])
-        str = result
+        if current_state.nil?
+          command("BEAT", %Q[{"wid":"#{@@random_process_wid}"}])
+        else
+          command("BEAT", %Q[{"wid":"#{@@random_process_wid}", "current_state":"#{current_state}"}])
+        end
+
+        str = result!
         if str == "OK"
           str
         else
-          hash = JSON.parse(str)
+          hash = Faktory.load_json(str)
           hash["state"]
         end
       end
@@ -113,8 +203,8 @@ module Faktory
     def info
       transaction do
         command("INFO")
-        str = result
-        JSON.parse(str) if str
+        str = result!
+        Faktory.load_json(str) if str
       end
     end
 
@@ -129,9 +219,17 @@ module Faktory
       @location.scheme =~ /tls/
     end
 
-    def open
+    def open(timeout = DEFAULT_TIMEOUT)
+      # this is the read/write timeout, not open.
+      secs = Integer(timeout)
+      usecs = Integer((timeout - secs) * 1_000_000)
+      optval = [secs, usecs].pack("l_2")
       if tls?
         sock = TCPSocket.new(@location.hostname, @location.port)
+        sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+        sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval)
+        sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval)
+
         ctx = OpenSSL::SSL::SSLContext.new
         ctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER)
         ctx.ssl_version = :TLSv1_2
@@ -143,6 +241,8 @@ module Faktory
       else
         @sock = TCPSocket.new(@location.hostname, @location.port)
         @sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+        @sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval)
+        @sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval)
       end
 
       payload = {
@@ -176,11 +276,10 @@ module Faktory
         end
       end
 
-      command("HELLO", JSON.dump(payload))
-      ok!
+      command("HELLO", Faktory.dump_json(payload))
+      ok
     end
 
-
     def command(*args)
       cmd = args.join(" ")
       @sock.puts(cmd)
@@ -189,12 +288,19 @@ module Faktory
 
     def transaction
       retryable = true
+
+      # When using Faktory::Testing, you can get a client which does not actually
+      # have an underlying socket.  Now if you disable testing and try to use that
+      # client, it will crash without a socket.  This open() handles that case to
+      # transparently open a socket.
+      open(@timeout) if !@sock
+
       begin
         yield
       rescue Errno::EPIPE, Errno::ECONNRESET
         if retryable
           retryable = false
-          open
+          open(@timeout)
           retry
         else
           raise
@@ -218,7 +324,16 @@ module Faktory
         line = @sock.gets # read extra linefeeds
         data
       elsif chr == '-'
-        raise CommandError, line[1..-1]
+        # Server can respond with:
+        #
+        # -ERR Something unexpected
+        # We raise a CommandError
+        #
+        # -NOTUNIQUE Job not unique
+        # We return ["NOTUNIQUE", "Job not unique"]
+        err = line[1..-1].split(" ", 2)
+        raise CommandError, err[1] if err[0] == "ERR"
+        err
       else
         # this is bad, indicates we need to reset the socket
         # and start fresh
@@ -226,10 +341,17 @@ module Faktory
       end
     end
 
-    def ok!
+    def ok(retval=true)
       resp = result
-      raise CommandError, resp if resp != "OK"
-      true
+      return retval if resp == "OK"
+      return resp[0].to_sym
+    end
+
+    def result!
+      resp = result
+      return nil if resp == nil
+      raise CommandError, resp[0] if !resp.is_a?(String)
+      resp
     end
 
     # FAKTORY_PROVIDER=MY_FAKTORY_URL
@@ -253,4 +375,3 @@ module Faktory
 
   end
 end
-

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/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,12 +68,32 @@ 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")
+
+        Faktory.client_middleware.invoke(item, pool) do
+          pool.with do |c|
+            c.push(item)
+          end
+        end
+      end
     end
 
     module ClassMethods
@@ -68,19 +103,13 @@ module Faktory
       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 +131,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/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,85 @@
+require 'faktory/client'
+
+# 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/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

data/lib/faktory/tracking.rb

@@ -0,0 +1,41 @@
+module Faktory
+  module Trackable
+
+    ##
+    # Tracking allows a long-running Faktory job to report its progress:
+    #
+    #   def perform(...)
+    #     track_progress(10, "Calculating values")
+    #     # do some work
+    #
+    #     track_progress(20, "Sending emails")
+    #     # do some more work
+    #
+    #     track_progress(20, "Sending emails", reserve_until: 10.minutes.from_now)
+    #     # do some more work
+    #   end
+    #
+    # Note:
+    # 1. jobs should be small and fine-grained (and so fast) if possible.
+    # 2. tracking is useful for long-running jobs, tracking a fast job will only add overhead
+    # 3. tracking only works with a single job, use Batches to monitor a group of jobs
+    # 4. reserve_until allows a job to dynamically extend its reservation so it is not garbage collected by Faktory while running
+    # 5. you can only reserve up to 24 hours.
+    #
+    def track_progress(percent, desc=nil, reserve_until:nil)
+      hash = { 'jid' => jid, 'percent' => percent.to_i, 'desc' => desc }
+      hash["reserve_until"] = convert(reserve_until) if reserve_until
+      Faktory.server {|c| c.set_track(hash) }
+    end
+
+    private
+
+    def convert(ts)
+      raise ArgumentError, "Timestamp in the past: #{ts}" if Time.now > ts
+      raise ArgumentError, "Timestamp too far in the future: #{ts}" if (Time.now + 86400) < ts
+
+      tsf = ts.to_f
+      Time.at(tsf).utc.iso8601
+    end
+  end
+end

data/lib/faktory/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Faktory
-  VERSION = "0.8.1"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faktory_worker_ruby
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Mike Perham
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-21 00:00:00.000000000 Z
+date: 2020-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -19,7 +19,7 @@ dependencies:
         version: '2.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.1
+        version: 2.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '2.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.1
+        version: 2.2.2
 - !ruby/object:Gem::Dependency
   name: activejob
   requirement: !ruby/object:Gem::Requirement
@@ -106,6 +106,7 @@ files:
 - faktory_worker_ruby.gemspec
 - lib/active_job/queue_adapters/faktory_adapter.rb
 - lib/faktory.rb
+- lib/faktory/batch.rb
 - lib/faktory/cli.rb
 - lib/faktory/client.rb
 - lib/faktory/connection.rb
@@ -116,11 +117,14 @@ files:
 - lib/faktory/launcher.rb
 - lib/faktory/logging.rb
 - lib/faktory/manager.rb
+- lib/faktory/middleware/batch.rb
 - lib/faktory/middleware/chain.rb
 - lib/faktory/middleware/i18n.rb
+- lib/faktory/mutate.rb
 - lib/faktory/processor.rb
 - lib/faktory/rails.rb
 - lib/faktory/testing.rb
+- lib/faktory/tracking.rb
 - lib/faktory/util.rb
 - lib/faktory/version.rb
 - lib/faktory_worker_ruby.rb
@@ -136,15 +140,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Ruby worker for Faktory