solid-jobs 0.1.0

data/lib/solid_jobs/api.rb

@@ -0,0 +1,457 @@
+# frozen_string_literal: true
+
+require "json"
+
+module SolidJobs
+  class Stats
+    attr_reader :config
+
+    def initialize(config: SolidJobs.config)
+      @config = config
+    end
+
+    def processed
+      integer("stat:processed")
+    end
+
+    def failed
+      integer("stat:failed")
+    end
+
+    def enqueued
+      queues.sum(&:size)
+    end
+
+    def scheduled_size
+      integer_command("ZCARD", "schedule")
+    end
+
+    def retry_size
+      integer_command("ZCARD", "retry")
+    end
+
+    def dead_size
+      integer_command("ZCARD", "dead")
+    end
+
+    def processes_size
+      integer_command("SCARD", "processes")
+    end
+
+    def workers_size
+      ProcessSet.new(config: config).sum(&:busy)
+    end
+
+    def reset
+      config.redis_pool.call("DEL", "stat:processed", "stat:failed")
+      self
+    end
+
+    private
+
+    def queues
+      Queue.all(config: config)
+    end
+
+    def integer(key)
+      Integer(config.redis_pool.call("GET", key) || 0)
+    end
+
+    def integer_command(*command)
+      Integer(config.redis_pool.call(*command))
+    end
+  end
+
+  class Queue
+    include Enumerable
+
+    attr_reader :name
+
+    def self.all(config: SolidJobs.config)
+      Array(config.redis_pool.call("SMEMBERS", "queues")).sort.map do |name|
+        new(name, config: config)
+      end
+    end
+
+    def initialize(name, config: SolidJobs.config)
+      @name = String(name)
+      @config = config
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      Array(@config.redis_pool.call("LRANGE", key, 0, -1)).reverse_each do |raw|
+        yield JobRecord.new(raw, config: @config, container: self)
+      end
+    end
+
+    def size
+      Integer(@config.redis_pool.call("LLEN", key))
+    end
+    alias_method :length, :size
+
+    def latency
+      raw = @config.redis_pool.call("LINDEX", key, -1)
+      return 0.0 unless raw
+
+      payload = JSON.parse(raw)
+      enqueued_at = payload["enqueued_at"] || payload["created_at"]
+      return 0.0 unless enqueued_at
+
+      [Time.now.to_f - Float(enqueued_at) / 1_000, 0.0].max
+    end
+
+    def clear
+      @config.redis_pool.call("DEL", key)
+      self
+    end
+
+    def delete
+      @config.redis_pool.pipelined do |pipeline|
+        pipeline.call("DEL", key)
+        pipeline.call("SREM", "queues", name)
+      end
+      self
+    end
+
+    def paused?
+      Array(@config.redis_pool.call("SISMEMBER", "paused", name)).first.to_i == 1
+    end
+
+    def pause
+      @config.redis_pool.call("SADD", "paused", name)
+      self
+    end
+
+    def unpause
+      @config.redis_pool.call("SREM", "paused", name)
+      self
+    end
+
+    private
+
+    def key
+      "queue:#{name}"
+    end
+  end
+
+  class JobRecord
+    attr_reader :item, :score
+
+    def initialize(raw, score: nil, config: SolidJobs.config, container: nil)
+      @raw = raw
+      @item = JSON.parse(raw)
+      @score = Float(score) if score
+      @config = config
+      @container = container
+    end
+
+    def jid
+      item["jid"]
+    end
+
+    def queue
+      item["queue"]
+    end
+
+    def klass
+      item["class"]
+    end
+
+    def args
+      item["args"]
+    end
+
+    def created_at
+      milliseconds_time(item["created_at"])
+    end
+
+    def enqueued_at
+      milliseconds_time(item["enqueued_at"])
+    end
+
+    def at
+      Time.at(score) if score
+    end
+
+    def delete
+      case @container
+      when SortedSet
+        @config.redis_pool.call("ZREM", @container.name, @raw)
+      when Queue
+        @config.redis_pool.call("LREM", "queue:#{@container.name}", 1, @raw)
+      else
+        false
+      end
+    end
+
+    def retry
+      delete
+      Client.new(config: @config).push(item)
+    end
+
+    private
+
+    def milliseconds_time(value)
+      Time.at(Float(value) / 1_000) if value
+    end
+  end
+
+  class SortedSet
+    include Enumerable
+
+    attr_reader :name
+
+    def initialize(name, config: SolidJobs.config)
+      @name = name
+      @config = config
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      values = Array(@config.redis_pool.call("ZRANGE", name, 0, -1, "WITHSCORES"))
+      values.each_slice(2) do |raw, score|
+        yield JobRecord.new(raw, score: score, config: @config, container: self)
+      end
+    end
+
+    def size
+      Integer(@config.redis_pool.call("ZCARD", name))
+    end
+    alias_method :length, :size
+
+    def clear
+      @config.redis_pool.call("DEL", name)
+      self
+    end
+
+    def fetch(*jids)
+      wanted = jids.flatten
+      select { |job| wanted.include?(job.jid) }
+    end
+  end
+
+  class ScheduledSet < SortedSet
+    def initialize(config: SolidJobs.config)
+      super("schedule", config: config)
+    end
+  end
+
+  class RetrySet < SortedSet
+    def initialize(config: SolidJobs.config)
+      super("retry", config: config)
+    end
+
+    def retry_all
+      each.to_a.each(&:retry)
+    end
+  end
+
+  class DeadSet < SortedSet
+    def initialize(config: SolidJobs.config)
+      super("dead", config: config)
+    end
+
+    def retry_all
+      each.to_a.each(&:retry)
+    end
+  end
+
+  class Process
+    attr_reader :identity
+
+    def initialize(identity, config: SolidJobs.config)
+      @identity = identity
+      @config = config
+      fields = Array(@config.redis_pool.call("HGETALL", identity))
+      @attributes = fields.each_slice(2).to_h
+      @info = JSON.parse(@attributes.fetch("info", "{}"))
+    end
+
+    def hostname
+      @info["hostname"]
+    end
+
+    def pid
+      Integer(@info["pid"] || 0)
+    end
+
+    def queues
+      @info["queues"] || []
+    end
+
+    def busy
+      Integer(@attributes["busy"] || 0)
+    end
+
+    def concurrency
+      Integer(@attributes["concurrency"] || 0)
+    end
+
+    def quiet?
+      @attributes["quiet"] == "true"
+    end
+
+    def beat
+      Time.at(Float(@attributes["beat"])) if @attributes["beat"]
+    end
+
+    def quiet!
+      signal("TSTP")
+    end
+
+    def stop!
+      signal("TERM")
+    end
+
+    def dump_threads
+      signal("TTIN")
+    end
+
+    def workers
+      fields = Array(@config.redis_pool.call("HGETALL", "#{identity}:work"))
+      fields.each_slice(2).map do |processor_id, raw|
+        Work.new(identity, processor_id, raw)
+      end
+    end
+
+    private
+
+    def signal(name)
+      @config.redis_pool.call("LPUSH", "#{identity}-signals", name)
+      true
+    end
+  end
+
+  class ProcessSet
+    include Enumerable
+
+    def initialize(config: SolidJobs.config)
+      @config = config
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      Array(@config.redis_pool.call("SMEMBERS", "processes")).each do |identity|
+        process = Process.new(identity, config: @config)
+        if process.beat
+          yield process
+        else
+          @config.redis_pool.call("SREM", "processes", identity)
+        end
+      end
+    end
+
+    def size
+      count
+    end
+  end
+
+  class Work
+    attr_reader :process_id, :processor_id
+
+    def initialize(process_id, processor_id, raw)
+      @process_id = process_id
+      @processor_id = processor_id
+      @attributes = JSON.parse(raw)
+    end
+
+    def queue
+      @attributes["queue"]
+    end
+
+    def payload
+      @attributes["payload"]
+    end
+
+    def run_at
+      Time.at(Float(@attributes["run_at"]))
+    end
+
+    def reservation_id
+      @attributes["reservation_id"]
+    end
+
+    def attempt
+      Integer(@attributes["attempt"] || 1)
+    end
+  end
+
+  class Reservation
+    attr_reader :attributes
+
+    def initialize(raw)
+      @attributes = JSON.parse(raw)
+    end
+
+    %w[job_id reservation_id process_id worker_id queue].each do |name|
+      define_method(name) { attributes[name] }
+    end
+
+    def attempt
+      Integer(attributes["attempt"])
+    end
+
+    def reserved_at
+      Time.at(Float(attributes["reserved_at"]))
+    end
+  end
+
+  class ReservationSet
+    include Enumerable
+
+    def initialize(config: SolidJobs.config)
+      @config = config
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      keys.each do |key|
+        Array(@config.redis_pool.call("HVALS", key)).each do |raw|
+          yield Reservation.new(raw)
+        end
+      end
+    end
+
+    def find_job(job_id)
+      find { |reservation| reservation.job_id == job_id }
+    end
+
+    private
+
+    def keys
+      cursor = "0"
+      found = []
+      loop do
+        cursor, batch = @config.redis_pool.call(
+          "SCAN", cursor, "MATCH", "*:reservations", "COUNT", 100,
+        )
+        found.concat(batch)
+        break if cursor == "0"
+      end
+      found
+    end
+  end
+
+  class Workers
+    include Enumerable
+
+    def initialize(config: SolidJobs.config)
+      @processes = ProcessSet.new(config: config)
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      @processes.each { |process| process.workers.each { |work| yield work } }
+    end
+
+    def size
+      count
+    end
+  end
+end

data/lib/solid_jobs/cli.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "yaml"
+
+module SolidJobs
+  class CLI
+    SIGNALS = %w[INT TERM TSTP TTIN INFO].freeze
+
+    def initialize
+      @options = {queues: []}
+    end
+
+    def run(arguments = ARGV)
+      parse(arguments)
+      load_configuration
+      load_application
+      apply_options
+      server = Server.new(config: SolidJobs.config).start
+      read_io, write_io = IO.pipe
+      handlers = install_signal_handlers(write_io)
+      wait_for_shutdown(server, read_io)
+      server.stop
+      0
+    ensure
+      handlers&.each { |signal, handler| Signal.trap(signal, handler) }
+      read_io&.close
+      write_io&.close
+    end
+
+    def parse(arguments)
+      parser.parse!(arguments)
+      @options
+    end
+
+    def parser
+      @parser ||= OptionParser.new do |options|
+        options.banner = "Usage: solid-jobs [options]"
+        options.on("-r", "--require PATH", "Require an application file") { |value| @options[:require] = value }
+        options.on("-C", "--config PATH", "Load YAML configuration") { |value| @options[:config] = value }
+        options.on("-c", "--concurrency N", Integer, "Processor Ractor count") { |value| @options[:concurrency] = value }
+        options.on("-q", "--queue QUEUE", "Queue name or name,weight") { |value| @options[:queues] << queue(value) }
+        options.on("-e", "--environment NAME", "Application environment") { |value| @options[:environment] = value }
+        options.on("-t", "--timeout SECONDS", Float, "Graceful shutdown timeout") { |value| @options[:timeout] = value }
+        options.on("-v", "--version", "Print version") do
+          puts "solid-jobs #{VERSION}"
+          exit
+        end
+        options.on("-h", "--help", "Print help") do
+          puts options
+          exit
+        end
+      end
+    end
+
+    private
+
+    def load_configuration
+      return unless @options[:config]
+
+      values = YAML.safe_load_file(@options[:config], permitted_classes: [Symbol], aliases: true) || {}
+      values = values.fetch(@options[:environment], values) if @options[:environment]
+      @options[:concurrency] ||= values["concurrency"]
+      @options[:timeout] ||= values["timeout"]
+      @options[:queues] = Array(values["queues"]).map { |value| queue(value) } if @options[:queues].empty?
+      if (url = values.dig("redis", "url") || values["redis_url"])
+        SolidJobs.config.redis = SolidRedis::Config.new(url: url)
+      end
+    end
+
+    def load_application
+      return unless @options[:require]
+
+      require File.expand_path(@options[:require])
+    end
+
+    def apply_options
+      ENV["RAILS_ENV"] = ENV["RACK_ENV"] = @options[:environment] if @options[:environment]
+      SolidJobs.config.concurrency = @options[:concurrency] if @options[:concurrency]
+      SolidJobs.config.queues = @options[:queues] unless @options[:queues].empty?
+      SolidJobs.config.shutdown_timeout = @options[:timeout] if @options[:timeout]
+    end
+
+    def install_signal_handlers(write_io)
+      SIGNALS.to_h do |signal|
+        previous = Signal.trap(signal) do
+          write_io.write_nonblock("#{signal}\n", exception: false)
+        end
+        [signal, previous]
+      rescue ArgumentError
+        [signal, "DEFAULT"]
+      end
+    end
+
+    def wait_for_shutdown(server, read_io)
+      loop do
+        if IO.select([read_io], nil, nil, 0.5)
+          signal = read_io.gets&.strip
+          return if handle_signal(server, signal)
+        end
+        remote = server.remote_signal
+        return if remote && handle_signal(server, remote)
+      end
+    end
+
+    def handle_signal(server, signal)
+      case signal
+      when "INT", "TERM"
+        true
+      when "TSTP"
+        server.quiet
+        false
+      when "TTIN", "INFO"
+        dump_threads
+        false
+      else
+        false
+      end
+    end
+
+    def dump_threads
+      Thread.list.each do |thread|
+        SolidJobs.config.logger.info(
+          "Thread #{thread.object_id}: #{Array(thread.backtrace).join("\n")}",
+        )
+      end
+    end
+
+    def queue(value)
+      name, weight = value.to_s.split(",", 2)
+      weight ? [name, Integer(weight)] : name
+    end
+  end
+end
+