faktory_worker_ruby 0.5.0

data/lib/faktory/middleware/chain.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+module Faktory
+  # Middleware is code configured to run before/after
+  # a job is processed.  It is patterned after Rack
+  # middleware. Middleware exists for the client side
+  # (pushing jobs to a queue) as well as the worker
+  # side (when jobs are actually executed).
+  #
+  # To add middleware to run when a job is pushed to Faktory:
+  #
+  # Faktory.configure_client do |config|
+  #   config.push_middleware do |chain|
+  #     chain.add MyClientHook
+  #   end
+  # end
+  #
+  # To run middleware when a job is executed within the worker process,
+  # add it to the worker_middleware:
+  #
+  # Faktory.configure_worker do |config|
+  #   config.worker_middleware do |chain|
+  #     chain.add MyServerHook
+  #     chain.remove ActiveRecord
+  #   end
+  # end
+  #
+  # To insert immediately preceding another entry:
+  #
+  # Faktory.configure_client do |config|
+  #   config.middleware do |chain|
+  #     chain.insert_before ActiveRecord, MyClientHook
+  #   end
+  # end
+  #
+  # To insert immediately after another entry:
+  #
+  # Faktory.configure_client do |config|
+  #   config.middleware do |chain|
+  #     chain.insert_after ActiveRecord, MyClientHook
+  #   end
+  # end
+  #
+  # This is an example of a minimal worker middleware:
+  #
+  # class MyServerHook
+  #   def call(worker_instance, job)
+  #     puts "Before work"
+  #     yield
+  #     puts "After work"
+  #   end
+  # end
+  #
+  # This is an example of a minimal client middleware, note
+  # the method must return the result or the job will not push
+  # to Redis:
+  #
+  # class MyClientHook
+  #   def call(job, conn_pool)
+  #     puts "Before push"
+  #     result = yield
+  #     puts "After push"
+  #     result
+  #   end
+  # end
+  #
+  module Middleware
+    class Chain
+      include Enumerable
+      attr_reader :entries
+
+      def initialize_copy(copy)
+        copy.instance_variable_set(:@entries, entries.dup)
+      end
+
+      def each(&block)
+        entries.each(&block)
+      end
+
+      def initialize
+        @entries = []
+        yield self if block_given?
+      end
+
+      def remove(klass)
+        entries.delete_if { |entry| entry.klass == klass }
+      end
+
+      def add(klass, *args)
+        remove(klass) if exists?(klass)
+        entries << Entry.new(klass, *args)
+      end
+
+      def prepend(klass, *args)
+        remove(klass) if exists?(klass)
+        entries.insert(0, Entry.new(klass, *args))
+      end
+
+      def insert_before(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || 0
+        entries.insert(i, new_entry)
+      end
+
+      def insert_after(oldklass, newklass, *args)
+        i = entries.index { |entry| entry.klass == newklass }
+        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
+        entries.insert(i+1, new_entry)
+      end
+
+      def exists?(klass)
+        any? { |entry| entry.klass == klass }
+      end
+
+      def retrieve
+        map(&:make_new)
+      end
+
+      def clear
+        entries.clear
+      end
+
+      def invoke(*args)
+        chain = retrieve.dup
+        traverse_chain = lambda do
+          if chain.empty?
+            yield
+          else
+            chain.shift.call(*args, &traverse_chain)
+          end
+        end
+        traverse_chain.call
+      end
+    end
+
+    class Entry
+      attr_reader :klass
+
+      def initialize(klass, *args)
+        @klass = klass
+        @args  = args
+      end
+
+      def make_new
+        @klass.new(*@args)
+      end
+    end
+  end
+end

data/lib/faktory/middleware/i18n.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+#
+# Simple middleware to save the current locale and restore it when the job executes.
+# Use it by requiring it in your initializer:
+#
+#     require 'faktory/middleware/i18n'
+#
+module Faktory::Middleware::I18n
+  # Get the current locale and store it in the message
+  # to be sent to Faktory.
+  class Client
+    def call(payload, pool)
+      c = payload["custom"] ||= {}
+      c['locale'] ||= ::I18n.locale
+      yield
+    end
+  end
+
+  # Pull the msg locale out and set the current thread to use it.
+  class Worker
+    def call(jobinst, payload)
+      I18n.locale = payload.dig("custom", "locale") || I18n.default_locale
+      yield
+    ensure
+      I18n.locale = I18n.default_locale
+    end
+  end
+end
+
+Faktory.configure_client do |config|
+  config.client_middleware do |chain|
+    chain.add Faktory::Middleware::I18n::Client
+  end
+end
+
+Faktory.configure_worker do |config|
+  config.client_middleware do |chain|
+    chain.add Faktory::Middleware::I18n::Client
+  end
+  config.worker_middleware do |chain|
+    chain.add Faktory::Middleware::I18n::Worker
+  end
+end

data/lib/faktory/processor.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+require 'faktory/util'
+require 'faktory/fetch'
+require 'faktory/job_logger'
+require 'thread'
+
+module Faktory
+  ##
+  # The Processor is a standalone thread which:
+  #
+  # 1. fetches a job
+  # 2. executes the job
+  #   a. instantiate the Worker
+  #   b. run the middleware chain
+  #   c. call #perform
+  #
+  # A Processor can exit due to shutdown (processor_stopped)
+  # or due to an error during job execution (processor_died)
+  #
+  # If an error occurs in the job execution, the
+  # Processor calls the Manager to create a new one
+  # to replace itself and exits.
+  #
+  class Processor
+
+    include Util
+
+    attr_reader :thread
+    attr_reader :job
+
+    @@busy_lock = Mutex.new
+    @@busy_count = 0
+    def self.busy_count
+      @@busy_count
+    end
+
+    def initialize(mgr)
+      @mgr = mgr
+      @down = false
+      @done = false
+      @thread = nil
+      @reloader = Faktory.options[:reloader]
+      @logging = (mgr.options[:job_logger] || Faktory::JobLogger).new
+      @fetcher = Faktory::Fetcher.new(Faktory.options)
+    end
+
+    def terminate(wait=false)
+      @done = true
+      return if !@thread
+      @thread.value if wait
+    end
+
+    def kill(wait=false)
+      @done = true
+      return if !@thread
+      # unlike the other actors, terminate does not wait
+      # for the thread to finish because we don't know how
+      # long the job will take to finish.  Instead we
+      # provide a `kill` method to call after the shutdown
+      # timeout passes.
+      @thread.raise ::Faktory::Shutdown
+      @thread.value if wait
+    end
+
+    def start
+      @thread ||= safe_thread("processor", &method(:run))
+    end
+
+    private unless $TESTING
+
+    def run
+      begin
+        while !@done
+          process_one
+        end
+        @mgr.processor_stopped(self)
+      rescue Faktory::Shutdown
+        @mgr.processor_stopped(self)
+      rescue Exception => ex
+        @mgr.processor_died(self, ex)
+      end
+    end
+
+    def process_one
+      work = fetch
+      if work
+        @@busy_lock.synchronize do
+          @@busy_count = @@busy_count + 1
+        end
+        begin
+          process(work)
+        ensure
+          @@busy_lock.synchronize do
+            @@busy_count = @@busy_count - 1
+          end
+        end
+      else
+        sleep 1
+      end
+    end
+
+    def fetch
+      begin
+        work = @fetcher.retrieve_work
+        (logger.info { "Faktory is online, #{Time.now - @down} sec downtime" }; @down = nil) if @down
+        work
+      rescue Faktory::Shutdown
+      rescue => ex
+        handle_fetch_exception(ex)
+      end
+    end
+
+    def handle_fetch_exception(ex)
+      if !@down
+        @down = Time.now
+        logger.error("Error fetching job: #{ex}")
+        ex.backtrace.each do |bt|
+          logger.error(bt)
+        end
+      end
+      sleep(1)
+      nil
+    end
+
+    def dispatch(payload)
+      Faktory::Logging.with_job_hash_context(payload) do
+        @logging.call(payload) do
+          # Rails 5 requires a Reloader to wrap code execution.  In order to
+          # constantize the worker and instantiate an instance, we have to call
+          # the Reloader.  It handles code loading, db connection management, etc.
+          # Effectively this block denotes a "unit of work" to Rails.
+          @reloader.call do
+            klass  = constantize(payload['jobtype'.freeze])
+            jobinst = klass.new
+            jobinst.jid = payload['jid'.freeze]
+            yield jobinst
+          end
+        end
+      end
+    end
+
+    def process(work)
+      payload = work.job
+      begin
+        dispatch(payload) do |jobinst|
+          Faktory.worker_middleware.invoke(jobinst, payload) do
+            jobinst.perform(*payload['args'.freeze])
+          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 Exception => ex
+        handle_exception(ex, { :context => "Job raised exception", :job => job })
+        work.fail(ex)
+        raise ex
+      end
+    end
+
+    def thread_identity
+      @str ||= Thread.current.object_id.to_s(36)
+    end
+
+    def constantize(str)
+      names = str.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+    end
+
+  end
+end

data/lib/faktory/rails.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module Faktory
+  class Rails < ::Rails::Engine
+    config.after_initialize do
+      # This hook happens after all initializers are run, just before returning
+      # from config/environment.rb back to faktory/cli.rb.
+      # We have to add the reloader after initialize to see if cache_classes has
+      # been turned on.
+      #
+      # None of this matters on the client-side, only within the Faktory executor itself.
+      #
+      Faktory.configure_exec do |_|
+        Faktory.options[:reloader] = Faktory::Rails::Reloader.new
+      end
+    end
+
+    class Reloader
+      def initialize(app = ::Rails.application)
+        @app = app
+      end
+
+      def call
+        @app.reloader.wrap do
+          yield
+        end
+      end
+
+      def inspect
+        "#<Faktory::Rails::Reloader @app=#{@app.class.name}>"
+      end
+    end
+  end if defined?(::Rails)
+end

data/lib/faktory/util.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require 'socket'
+require 'securerandom'
+require 'faktory/exception_handler'
+
+module Faktory
+  ##
+  # This module is part of Faktory core and not intended for extensions.
+  #
+  module Util
+    include ExceptionHandler
+
+    EXPIRY = 60 * 60 * 24
+
+    def watchdog(last_words)
+      yield
+    rescue Exception => ex
+      handle_exception(ex, { context: last_words })
+      raise ex
+    end
+
+    def safe_thread(name, &block)
+      Thread.new do
+        Thread.current['faktory_label'.freeze] = name
+        watchdog(name, &block)
+      end
+    end
+
+    def logger
+      Faktory.logger
+    end
+
+    def server(&block)
+      Faktory.server(&block)
+    end
+
+    def hostname
+      ENV['DYNO'] || Socket.gethostname
+    end
+
+    def process_nonce
+      @@process_nonce ||= SecureRandom.hex(6)
+    end
+
+    def identity
+      @@identity ||= "#{hostname}:#{$$}:#{process_nonce}"
+    end
+
+    def fire_event(event, reverse=false)
+      arr = Faktory.options[:lifecycle_events][event]
+      arr.reverse! if reverse
+      arr.each do |block|
+        begin
+          block.call
+        rescue => ex
+          handle_exception(ex, { context: "Exception during Faktory lifecycle event.", event: event })
+        end
+      end
+      arr.clear
+    end
+  end
+end