faktory_worker_ruby 1.1.1 → 1.2.0

data/lib/faktory/client.rb

@@ -1,14 +1,17 @@
-require 'socket'
-require 'json'
-require 'uri'
-require 'digest'
-require 'securerandom'
-require 'timeout'
-require 'faktory/io'
+require "socket"
+require "json"
+require "uri"
+require "cgi"
+require "digest"
+require "securerandom"
+require "timeout"
+require "faktory/io"
 
 module Faktory
   class BaseError < StandardError; end
+
   class CommandError < BaseError; end
+
   class ParseError < BaseError; end
 
   # Faktory::Client provides a low-level connection to a Faktory server
@@ -33,7 +36,6 @@ module Faktory
       Digest.hexencode(hashing)
     end
 
-
     # Called when booting the worker process to signal that this process
     # will consume jobs and send BEAT.
     def self.worker!
@@ -49,13 +51,13 @@ 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, timeout: DEFAULT_TIMEOUT)
+    def initialize(url: uri_from_env || "tcp://localhost:7419", debug: false, timeout: DEFAULT_TIMEOUT)
       super
       @debug = debug
       @location = URI(url)
       @timeout = timeout
 
-      open(@timeout)
+      open_socket(@timeout)
     end
 
     def close
@@ -162,6 +164,11 @@ module Faktory
     # Returned value will either be the JID String if successful OR
     # a symbol corresponding to an error.
     def push(job)
+      job["jid"] ||= SecureRandom.hex(12)
+      job["queue"] ||= "default"
+      raise ArgumentError, "Missing `jobtype` attribute: #{job.inspect}" unless job["jobtype"]
+      raise ArgumentError, "Missing `args` attribute: #{job.inspect}" unless job["args"]
+
       transaction do
         command "PUSH", Faktory.dump_json(job)
         ok(job["jid"])
@@ -180,14 +187,14 @@ module Faktory
 
     def ack(jid)
       transaction do
-        command("ACK", %Q[{"jid":"#{jid}"}])
+        command("ACK", %({"jid":"#{jid}"}))
         ok
       end
     end
 
     def fail(jid, ex)
       transaction do
-        command("FAIL", Faktory.dump_json({ message: ex.message[0...1000],
+        command("FAIL", Faktory.dump_json({message: ex.message[0...1000],
                           errtype: ex.class.name,
                           jid: jid,
                           backtrace: ex.backtrace}))
@@ -204,7 +211,7 @@ module Faktory
     # 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(current_state = nil, hash)
+    def beat(current_state = nil, hash = {})
       transaction do
         hash["wid"] = @@random_process_wid
         hash["current_state"] = current_state if current_state
@@ -239,9 +246,9 @@ module Faktory
       @location.scheme =~ /tls/
     end
 
-    def open(timeout = DEFAULT_TIMEOUT)
+    def open_socket(timeout = DEFAULT_TIMEOUT)
       if tls?
-        require 'openssl'
+        require "openssl"
         sock = TCPSocket.new(@location.hostname, @location.port)
         sock.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
 
@@ -259,12 +266,12 @@ module Faktory
       end
 
       payload = {
-        "wid": @@random_process_wid,
-        "hostname": Socket.gethostname,
-        "pid": $$,
-        "labels": Faktory.options[:labels] || ["ruby-#{RUBY_VERSION}"],
-        "username": @location.user,
-        "v": 2,
+        wid: @@random_process_wid,
+        hostname: Socket.gethostname,
+        pid: $$,
+        labels: Faktory.options[:labels] || ["ruby-#{RUBY_VERSION}"],
+        username: @location.user,
+        v: 2
       }
 
       hi = result
@@ -286,7 +293,7 @@ module Faktory
           iter = (hash["i"] || 1).to_i
           raise ArgumentError, "Invalid hashing" if iter < 1
 
-          payload["pwdhash"] = HASHER.(iter, pwd, salt)
+          payload["pwdhash"] = HASHER.call(iter, CGI.unescape(pwd), salt)
         end
       end
 
@@ -307,7 +314,7 @@ module Faktory
       # 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
+      open_socket(@timeout) if !@sock
 
       begin
         yield
@@ -315,9 +322,13 @@ module Faktory
         if retryable
           retryable = false
 
-          @sock.close rescue nil
+          begin
+            @sock.close
+          rescue
+            nil
+          end
           @sock = nil
-          open(@timeout)
+          open_socket(@timeout)
           retry
         else
           raise
@@ -332,15 +343,15 @@ module Faktory
       debug "< #{line}" if @debug
       raise Errno::ECONNRESET, "No response" unless line
       chr = line[0]
-      if chr == '+'
+      if chr == "+"
         line[1..-1].strip
-      elsif chr == '$'
+      elsif chr == "$"
         count = line[1..-1].strip.to_i
         return nil if count == -1
         data = read(count) if count > 0
-        line = gets # read extra linefeeds
+        _ = gets # read extra linefeeds
         data
-      elsif chr == '-'
+      elsif chr == "-"
         # Server can respond with:
         #
         # -ERR Something unexpected
@@ -358,15 +369,15 @@ module Faktory
       end
     end
 
-    def ok(retval=true)
+    def ok(retval = true)
       resp = result
       return retval if resp == "OK"
-      return resp[0].to_sym
+      resp[0].to_sym
     end
 
     def result!
       resp = result
-      return nil if resp == nil
+      return nil if resp.nil?
       raise CommandError, resp[0] if !resp.is_a?(String)
       resp
     end
@@ -374,21 +385,20 @@ module Faktory
     # FAKTORY_PROVIDER=MY_FAKTORY_URL
     # MY_FAKTORY_URL=tcp://:some-pass@some-hostname:7419
     def uri_from_env
-      prov = ENV['FAKTORY_PROVIDER']
+      prov = ENV["FAKTORY_PROVIDER"]
       if prov
         raise(ArgumentError, <<-EOM) if prov.index(":")
   Invalid FAKTORY_PROVIDER '#{prov}', it should be the name of the ENV variable that contains the URL
       FAKTORY_PROVIDER=MY_FAKTORY_URL
       MY_FAKTORY_URL=tcp://:some-pass@some-hostname:7419
-  EOM
+        EOM
         val = ENV[prov]
         return URI(val) if val
       end
 
-      val = ENV['FAKTORY_URL']
+      val = ENV["FAKTORY_URL"]
       return URI(val) if val
       nil
     end
-
   end
 end

data/lib/faktory/connection.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
-require 'connection_pool'
+
+require "connection_pool"
 
 module Faktory
   class Connection
     class << self
-      def create(options={})
+      def create(options = {})
         size = Faktory.worker? ? (Faktory.options[:concurrency] + 2) : 5
-        ConnectionPool.new(:timeout => options[:pool_timeout] || 1, :size => size) do
+        ConnectionPool.new(timeout: options[:pool_timeout] || 1, size: size) do
           Faktory::Client.new(**options)
         end
       end

data/lib/faktory/exception_handler.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
-require 'faktory'
+
+require "faktory"
 
 module Faktory
   module ExceptionHandler
-
     class Logger
-      def call(ex, ctxHash)
-        Faktory.logger.warn(Faktory.dump_json(ctxHash)) if !ctxHash.empty?
+      def call(ex, ctx_hash)
+        Faktory.logger.warn(Faktory.dump_json(ctx_hash)) if !ctx_hash.empty?
         Faktory.logger.warn "#{ex.class.name}: #{ex.message}"
         Faktory.logger.warn ex.backtrace.join("\n") unless ex.backtrace.nil?
       end
@@ -15,17 +15,14 @@ module Faktory
       Faktory.error_handlers << Faktory::ExceptionHandler::Logger.new
     end
 
-    def handle_exception(ex, ctxHash={})
+    def handle_exception(ex, ctx_hash = {})
       Faktory.error_handlers.each do |handler|
-        begin
-          handler.call(ex, ctxHash)
-        rescue => ex
-          Faktory.logger.error "!!! ERROR HANDLER THREW AN ERROR !!!"
-          Faktory.logger.error ex
-          Faktory.logger.error ex.backtrace.join("\n") unless ex.backtrace.nil?
-        end
+        handler.call(ex, ctx_hash)
+      rescue => ex
+        Faktory.logger.error "!!! ERROR HANDLER THREW AN ERROR !!!"
+        Faktory.logger.error ex
+        Faktory.logger.error ex.backtrace.join("\n") unless ex.backtrace.nil?
       end
     end
-
   end
 end

data/lib/faktory/fetch.rb

@@ -3,15 +3,15 @@
 module Faktory
   UnitOfWork = Struct.new(:job) do
     def acknowledge
-      Faktory.server {|c| c.ack(jid) }
+      Faktory.server { |c| c.ack(jid) }
     end
 
     def fail(ex)
-      Faktory.server {|c| c.fail(jid, ex) }
+      Faktory.server { |c| c.fail(jid, ex) }
     end
 
     def jid
-      job['jid']
+      job["jid"]
     end
   end
 
@@ -39,6 +39,5 @@ module Faktory
         @queues.shuffle.uniq
       end
     end
-
   end
 end

data/lib/faktory/io.rb

@@ -14,7 +14,7 @@ module Faktory
     # We have to implement them ourselves by using
     # nonblocking IO and IO.select.
     def initialize(**opts)
-      @buf = "".dup
+      @buf = +""
       @timeout = opts[:timeout] || 5
     end
 
@@ -33,6 +33,7 @@ module Faktory
     end
 
     private
+
     def read_timeout(nbytes)
       loop do
         result = @sock.read_nonblock(nbytes, exception: false)
@@ -40,7 +41,7 @@ module Faktory
           raise Faktory::TimeoutError unless @sock.to_io.wait_readable(@timeout)
         elsif result == :wait_writable
           raise Faktory::TimeoutError unless @sock.to_io.wait_writeable(@timeout)
-        elsif result == nil
+        elsif result.nil?
           raise Errno::ECONNRESET
         else
           return result

data/lib/faktory/job.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
-require 'faktory/tracking'
 
-module Faktory
+require "faktory/tracking"
 
+module Faktory
   ##
   # Include this module in your Job class and you can easily create
   # asynchronous jobs:
@@ -27,7 +27,7 @@ module Faktory
     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' }
+      raise ArgumentError, "You cannot include Faktory::Job in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
 
       base.extend(ClassMethods)
       base.faktory_class_attribute :faktory_options_hash
@@ -62,7 +62,7 @@ module Faktory
       end
 
       def perform_async(*args)
-        client_push(@opts.merge('args'.freeze => args))
+        client_push(@opts.merge("args" => args))
       end
 
       # +interval+ must be a timestamp, numeric or something that acts
@@ -70,13 +70,13 @@ module Faktory
       def perform_in(interval, *args)
         int = interval.to_f
         now = Time.now.to_f
-        ts = (int < 1_000_000_000 ? now + int : int)
+        ts = ((int < 1_000_000_000) ? now + int : int)
         at = Time.at(ts).utc.to_datetime.rfc3339(9)
 
-        item = @opts.merge('args'.freeze => args, 'at'.freeze => at)
+        item = @opts.merge("args" => args, "at" => at)
 
         # Optimization to enqueue something now that is scheduled to go out now or in the past
-        item.delete('at'.freeze) if ts <= now
+        item.delete("at") if ts <= now
 
         client_push(item)
       end
@@ -107,19 +107,20 @@ module Faktory
     end
 
     module ClassMethods
-
       def set(options)
-        Setter.new(Util.deep_merge(get_faktory_options, options, 'jobtype'.freeze => self))
+        opts = get_faktory_options.dup
+        opts["jobtype"] = self
+        Setter.new(Util.deep_merge(opts, options))
       end
 
       def perform_async(*args)
-        set(get_faktory_options).perform_async(*args)
+        set({}).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)
-        set(get_faktory_options).perform_in(interval, *args)
+        set({}).perform_in(interval, *args)
       end
       alias_method :perform_at, :perform_in
 
@@ -132,9 +133,9 @@ module Faktory
       #   backtrace - whether to save the error backtrace in the job payload to display in web UI,
       #      an integer number of lines to save, default *0*
       #
-      def faktory_options(opts={})
+      def faktory_options(opts = {})
         # stringify
-        self.faktory_options_hash = get_faktory_options.merge(Hash[opts.map{|k, v| [k.to_s, v]}])
+        self.faktory_options_hash = get_faktory_options.merge(opts.map { |k, v| [k.to_s, v] }.to_h)
       end
 
       def get_faktory_options # :nodoc:
@@ -196,7 +197,6 @@ module Faktory
           end
         end
       end
-
     end
 
     module Util
@@ -215,6 +215,5 @@ module Faktory
       end
       module_function :deep_merge
     end
-
   end
 end

data/lib/faktory/job_logger.rb

@@ -1,6 +1,5 @@
 module Faktory
   class JobLogger
-
     def call(item)
       start = Time.now
       logger.info("start".freeze)

data/lib/faktory/launcher.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # frozen_string_literal: true
-require 'faktory/manager'
+
+require "faktory/manager"
 
 module Faktory
   class Launcher
@@ -22,7 +22,7 @@ module Faktory
 
     # Stops this instance from processing any more jobs,
     def quiet
-      @current_state = 'quiet'
+      @current_state = "quiet"
       @manager.quiet
     end
 
@@ -32,17 +32,17 @@ module Faktory
     def stop
       deadline = Time.now + @options[:timeout]
 
-      @current_state = 'terminate'
+      @current_state = "terminate"
       @manager.quiet
       @manager.stop(deadline)
     end
 
     def stopping?
-      @current_state == 'terminate'
+      @current_state == "terminate"
     end
 
     def quiet?
-      @current_state == 'quiet'
+      @current_state == "quiet"
     end
 
     PROCTITLES = []
@@ -50,28 +50,28 @@ module Faktory
     private unless $TESTING
 
     def heartbeat
-      title = ['faktory-worker', Faktory::VERSION, @options[:tag]].compact.join(" ")
+      title = ["faktory-worker", Faktory::VERSION, @options[:tag]].compact.join(" ")
       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(" ")
+        $0 = PROCTITLES.map { |p| p.call }.join(" ")
 
         begin
-          result = Faktory.server {|c| c.beat(@current_state, "rss_kb" => memory_usage(::Process.pid)) }
+          result = Faktory.server { |c| c.beat(@current_state, "rss_kb" => memory_usage(::Process.pid)) }
           case result
           when "OK"
             # all good
           when "terminate"
-            ::Process.kill('TERM', $$)
+            ::Process.kill("TERM", $$)
           when "quiet"
-            ::Process.kill('TSTP', $$)
+            ::Process.kill("TSTP", $$)
           else
             Faktory.logger.warn "Got unexpected BEAT: #{result}"
           end
-        rescue => ex
+        rescue
           # best effort, try again in a few secs
         end
         sleep 10
@@ -97,7 +97,5 @@ module Faktory
     def memory_usage(pid)
       MEMORY_GRABBER.call(pid)
     end
-
-
   end
 end

data/lib/faktory/logging.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
-require 'time'
-require 'logger'
-require 'fcntl'
+
+require "time"
+require "logger"
+require "fcntl"
 
 module Faktory
   module Logging
-
     class Pretty < Logger::Formatter
       SPACE = " "
 
@@ -16,7 +16,7 @@ module Faktory
 
       def context
         c = Thread.current[:faktory_context]
-        " #{c.join(SPACE)}" if c && c.any?
+        " #{c.join(SPACE)}" if c&.any?
       end
     end
 
@@ -29,8 +29,8 @@ 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.dig('custom', 'wrapped') || job_hash["jobtype"]
-      "#{klass} JID-#{job_hash['jid']}"
+      klass = job_hash.dig("custom", "wrapped") || job_hash["jobtype"]
+      "#{klass} JID-#{job_hash["jid"]}"
     end
 
     def self.with_job_hash_context(job_hash, &block)
@@ -45,7 +45,7 @@ module Faktory
       Thread.current[:faktory_context].pop
     end
 
-    def self.initialize_logger(log_target = STDOUT)
+    def self.initialize_logger(log_target = $stdout)
       oldlogger = defined?(@logger) ? @logger : nil
       @logger = Logger.new(log_target)
       @logger.level = Logger::INFO
@@ -62,7 +62,7 @@ module Faktory
     end
 
     def self.logger=(log)
-      @logger = (log ? log : Logger.new(File::NULL))
+      @logger = (log || Logger.new(File::NULL))
     end
 
     def logger

data/lib/faktory/manager.rb

@@ -1,13 +1,11 @@
-# encoding: utf-8
 # frozen_string_literal: true
-require 'faktory/util'
-require 'faktory/processor'
-require 'faktory/fetch'
-require 'thread'
-require 'set'
 
-module Faktory
+require "faktory/util"
+require "faktory/processor"
+require "faktory/fetch"
+require "set"
 
+module Faktory
   ##
   # The Manager is the central coordination point in Faktory, controlling
   # the lifecycle of the Processors.
@@ -28,7 +26,7 @@ module Faktory
     attr_reader :threads
     attr_reader :options
 
-    def initialize(options={})
+    def initialize(options = {})
       logger.debug { options.inspect }
       @options = options
       @count = options[:concurrency] || 25
@@ -58,7 +56,7 @@ module Faktory
     end
 
     # hack for quicker development / testing environment
-    PAUSE_TIME = STDOUT.tty? ? 0.1 : 0.5
+    PAUSE_TIME = $stdout.tty? ? 0.1 : 0.5
 
     def stop(deadline)
       quiet
@@ -114,7 +112,7 @@ module Faktory
       end
 
       if cleanup.size > 0
-        jobs = cleanup.map {|p| p.job }.compact
+        jobs = cleanup.map { |p| p.job }.compact
 
         logger.warn { "Terminating #{cleanup.size} busy worker threads" }
         logger.warn { "Work still in progress #{jobs.inspect}" }
@@ -127,6 +125,5 @@ module Faktory
         processor.thread.join(1)
       end
     end
-
   end
 end

data/lib/faktory/middleware/batch.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 #
 # Simple middleware to save the current batch and restore it when the job executes.
 #

data/lib/faktory/middleware/chain.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Faktory
   # Middleware is code configured to run before/after
   # a job is processed.  It is patterned after Rack
@@ -106,7 +107,7 @@ module Faktory
         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)
+        entries.insert(i + 1, new_entry)
       end
 
       def exists?(klass)
@@ -139,7 +140,7 @@ module Faktory
 
       def initialize(klass, *args)
         @klass = klass
-        @args  = args
+        @args = args
       end
 
       def make_new

data/lib/faktory/middleware/i18n.rb

@@ -1,4 +1,5 @@
 # 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:
@@ -11,7 +12,7 @@ module Faktory::Middleware::I18n
   class Client
     def call(payload, pool)
       c = payload["custom"] ||= {}
-      c['locale'] ||= ::I18n.locale
+      c["locale"] ||= ::I18n.locale
       yield
     end
   end