solid-jobs 0.1.3 → 0.4.0

data/lib/solid_jobs/{rails.rb → railtie.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "active_job"
+require_relative "rails_adapter"
 
 if defined?(Rails::Railtie)
   module SolidJobs
@@ -13,4 +13,3 @@ if defined?(Rails::Railtie)
     end
   end
 end
-

data/lib/solid_jobs/recovery.rb

@@ -5,12 +5,12 @@ require "socket"
 
 module SolidJobs
   class Recovery < Service::Base
-    RESERVED_PATTERN = "*:reserved:*"
+    CLAIMED_PATTERN = "#{Keyspace::PREFIX}:node:*:claimed:*".freeze
     RESTORE_ONE = <<~LUA.freeze
       local payload = redis.call("rpop", KEYS[1])
       if payload then
-        local job = cjson.decode(payload)
-        redis.call("rpush", "queue:" .. job["queue"], payload)
+        local envelope = cjson.decode(payload)
+        redis.call("rpush", "#{Keyspace::PREFIX}:channel:" .. envelope["channel"], payload)
         return payload
       end
     LUA
@@ -18,14 +18,15 @@ module SolidJobs
     def call
       recovered = 0
       scan_keys.each do |key|
-        identity = key.split(":reserved:", 2).first
+        node_key = key.split(":claimed:", 2).first
+        identity = node_key.delete_prefix("#{Keyspace::PREFIX}:node:")
         next if alive?(identity)
 
         while @config.redis_pool.call("EVAL", RESTORE_ONE, 1, key)
           recovered += 1
         end
         @config.redis_pool.call("DEL", key)
-        @config.redis_pool.call("DEL", "#{identity}:reservations")
+        @config.redis_pool.call("DEL", Keyspace.claims(identity))
       end
       recovered
     end
@@ -36,7 +37,7 @@ module SolidJobs
       hostname, pid = identity.split(":", 3)
       return false if hostname == Socket.gethostname && !process_alive?(Integer(pid))
 
-      beat = @config.redis_pool.call("HGET", identity, "beat")
+      beat = @config.redis_pool.call("HGET", Keyspace.node(identity), "beat")
       beat && Time.now.to_f - Float(beat) < Heartbeat::TTL
     end
 
@@ -54,7 +55,7 @@ module SolidJobs
       keys = []
       loop do
         cursor, found = @config.redis_pool.call(
-          "SCAN", cursor, "MATCH", RESERVED_PATTERN, "COUNT", 100,
+          "SCAN", cursor, "MATCH", CLAIMED_PATTERN, "COUNT", 100,
         )
         keys.concat(found)
         break if cursor == "0"

data/lib/solid_jobs/task.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module SolidJobs
+  module Task
+    def self.included(base)
+      base.extend(TaskMethods)
+      base.include(InstanceMethods)
+      base.task_options
+    end
+
+    module InstanceMethods
+      attr_accessor :task_id
+      attr_writer :_context
+
+      def _context
+        @_context ||= {}
+      end
+
+      def logger
+        SolidJobs.config.logger
+      end
+
+      def interrupted?
+        _context[:interrupted]&.call || false
+      end
+    end
+
+    module TaskMethods
+      def task_options(options = nil)
+        if options
+          merged = current_task_options.merge(Utilities.stringify_keys(options))
+          @task_options = Utilities.shareable_copy(merged)
+        else
+          @task_options ||= Utilities.shareable_copy(SolidJobs.config.default_task_options)
+        end
+      end
+
+      def current_task_options
+        task_options
+      end
+
+      def retry_delay(&block)
+        define_singleton_method(:retry_delay_callback, &block) if block
+        method(:retry_delay_callback) if respond_to?(:retry_delay_callback)
+      end
+
+      def after_final_failure(&block)
+        define_singleton_method(:final_failure_callback, &block) if block
+        method(:final_failure_callback) if respond_to?(:final_failure_callback)
+      end
+
+      def enqueue(*arguments)
+        publish("task" => self, "arguments" => arguments)
+      end
+
+      def enqueue_many(argument_sets, chunk_size: Publisher::DEFAULT_CHUNK_SIZE)
+        Publisher.new.publish_many(
+          current_task_options.merge(
+            "task" => self,
+            "arguments" => argument_sets,
+            "chunk_size" => chunk_size,
+          ),
+        )
+      end
+
+      def enqueue_after(delay, *arguments)
+        schedule_at(Time.now.to_f + Float(delay), *arguments)
+      end
+
+      def schedule_at(time, *arguments)
+        timestamp = time.is_a?(Time) ? time.to_f : Float(time)
+        publish("task" => self, "arguments" => arguments, "run_at" => timestamp)
+      end
+
+      def execute(*arguments)
+        Lab.execute(current_task_options.merge("task" => self, "arguments" => arguments))
+      end
+
+      def with_options(options)
+        Submission.new(self, options)
+      end
+
+      def captured
+        Lab.captured_for(self)
+      end
+
+      def clear_captured
+        captured.clear
+      end
+
+      def execute_next
+        envelope = captured.shift
+        raise NoCapturedTask, "No captured task for #{name}" unless envelope
+
+        Lab.execute(envelope)
+      end
+
+      private
+
+      def publish(envelope)
+        Publisher.new.publish(current_task_options.merge(envelope))
+      end
+    end
+
+    class Submission
+      def initialize(task, options)
+        @task = task
+        @options = Utilities.stringify_keys(options)
+      end
+
+      def enqueue(*arguments)
+        return @task.execute(*arguments) if @options.delete("execute")
+
+        if (delay = @options.delete("delay"))
+          enqueue_after(delay, *arguments)
+        elsif (time = @options.delete("run_at"))
+          schedule_at(time, *arguments)
+        else
+          publish(arguments)
+        end
+      end
+
+      def enqueue_after(delay, *arguments)
+        schedule_at(Time.now.to_f + Float(delay), *arguments)
+      end
+
+      def schedule_at(time, *arguments)
+        timestamp = time.is_a?(Time) ? time.to_f : Float(time)
+        publish(arguments, "run_at" => timestamp)
+      end
+
+      private
+
+      def publish(arguments, extra = {})
+        Publisher.new.publish(
+          @task.current_task_options.merge(@options).merge(
+            extra,
+            "task" => @task,
+            "arguments" => arguments,
+          ),
+        )
+      end
+    end
+  end
+
+  class NoCapturedTask < Error; end
+end

data/lib/solid_jobs/{scheduler.rb → timer.rb}

@@ -3,8 +3,8 @@
 require "json"
 
 module SolidJobs
-  class Scheduler
-    SETS = %w[retry schedule].freeze
+  class Timer
+    COLLECTIONS = [Keyspace::RETRIES, Keyspace::PLANNED].freeze
     POP_DUE = <<~LUA.freeze
       local jobs = redis.call("zrange", KEYS[1], "-inf", ARGV[1], "byscore", "limit", 0, 1)
       if jobs[1] then
@@ -15,14 +15,14 @@ module SolidJobs
 
     def initialize(config)
       @config = config
-      @client = Client.new(config: config)
+      @publisher = Publisher.new(config: config)
     end
 
     def enqueue_due(now = Time.now.to_f)
       count = 0
-      SETS.each do |set|
-        while (raw = pop_due(set, now))
-          @client.push(JSON.parse(raw))
+      COLLECTIONS.each do |collection|
+        while (raw = pop_due(collection, now))
+          @publisher.publish(JSON.parse(raw))
           count += 1
         end
       end
@@ -45,8 +45,8 @@ module SolidJobs
 
     private
 
-    def pop_due(set, now)
-      @config.redis_pool.call("EVAL", POP_DUE, 1, set, now)
+    def pop_due(collection, now)
+      @config.redis_pool.call("EVAL", POP_DUE, 1, collection, now)
     end
 
     def randomized_interval

data/lib/solid_jobs/utilities.rb

@@ -5,20 +5,14 @@ module SolidJobs
     module_function
 
     def stringify_keys(value)
-      case value
-      when Hash
-        value.each_with_object({}) do |(key, nested), result|
-          result[key.to_s] = stringify_keys(nested)
-        end
-      when Array
-        value.map { |nested| stringify_keys(nested) }
-      else
-        value
-      end
+      return stringify_hash_keys(value).transform_values { |nested| stringify_keys(nested) } if value.is_a?(Hash)
+      return value.map { |nested| stringify_keys(nested) } if value.is_a?(Array)
+
+      value
     end
 
     def stringify_hash_keys(hash)
-      hash.each_with_object({}) { |(key, value), result| result[key.to_s] = value }
+      hash.transform_keys(&:to_s)
     end
 
     def shareable_copy(value)

data/lib/solid_jobs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidJobs
-  VERSION = "0.1.3"
+  VERSION = "0.4.0"
 end

data/lib/solid_jobs.rb

@@ -7,25 +7,26 @@ require "solid_redis"
 require_relative "solid_jobs/version"
 require_relative "solid_jobs/errors"
 require_relative "solid_jobs/utilities"
+require_relative "solid_jobs/keyspace"
 require_relative "solid_jobs/ractor_support"
 require_relative "solid_jobs/startup_barrier"
-require_relative "solid_jobs/middleware/chain"
-require_relative "solid_jobs/config"
-require_relative "solid_jobs/client"
-require_relative "solid_jobs/testing"
-require_relative "solid_jobs/job"
-require_relative "solid_jobs/worker"
-require_relative "solid_jobs/fetch"
-require_relative "solid_jobs/retry_service"
-require_relative "solid_jobs/scheduler"
-require_relative "solid_jobs/processor"
+require_relative "solid_jobs/interceptor_registry"
+require_relative "solid_jobs/blueprint"
+require_relative "solid_jobs/publisher"
+require_relative "solid_jobs/lab"
+require_relative "solid_jobs/task"
+require_relative "solid_jobs/executor"
+require_relative "solid_jobs/claim"
+require_relative "solid_jobs/failure_policy"
+require_relative "solid_jobs/timer"
+require_relative "solid_jobs/engine"
 require_relative "solid_jobs/heartbeat"
 require_relative "solid_jobs/recovery"
 require_relative "solid_jobs/integrity_check"
-require_relative "solid_jobs/server"
-require_relative "solid_jobs/api"
-require_relative "solid_jobs/active_job" if defined?(::ActiveJob::Base)
-require_relative "solid_jobs/rails" if defined?(::Rails::Railtie)
+require_relative "solid_jobs/conductor"
+require_relative "solid_jobs/catalog"
+require_relative "solid_jobs/rails_adapter" if defined?(::ActiveJob::Base)
+require_relative "solid_jobs/railtie" if defined?(::Rails::Railtie)
 
 module SolidJobs
   CONFIG_KEY = :solid_jobs_config
@@ -35,7 +36,7 @@ module SolidJobs
   # Configuration is Ractor-local: every thread and fiber inside a Ractor
   # shares it, while each Ractor keeps its own isolated configuration.
   def config
-    Ractor.current[CONFIG_KEY] ||= Config.new
+    Ractor.current[CONFIG_KEY] ||= Blueprint.new
   end
 
   def configure
@@ -50,29 +51,29 @@ module SolidJobs
 
   def reset!
     Ractor.current[CONFIG_KEY]&.close
-    Ractor.current[CONFIG_KEY] = Config.new
+    Ractor.current[CONFIG_KEY] = Blueprint.new
   end
 
   def testing!(mode, &block)
-    Testing.testing!(mode, &block)
+    Lab.testing!(mode, &block)
   end
 
-  def enqueue(job_class, args, queue: "default", **options)
-    Client.push(
+  def enqueue(task, arguments, channel: "default", **options)
+    Publisher.publish(
       options.merge(
-        "class" => job_class,
-        "args" => args,
-        "queue" => queue,
+        "task" => task,
+        "arguments" => arguments,
+        "channel" => channel,
       ),
     )
   end
 
-  def enqueue_bulk(job_class, arguments, queue: "default", **options)
-    Client.push_bulk(
+  def enqueue_many(task, argument_sets, channel: "default", **options)
+    Publisher.publish_many(
       options.merge(
-        "class" => job_class,
-        "args" => arguments,
-        "queue" => queue,
+        "task" => task,
+        "arguments" => argument_sets,
+        "channel" => channel,
       ),
     )
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid-jobs
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Nicolas Vandenbogaerde
@@ -105,8 +105,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-description: Ractor-local job clients and workers with Sidekiq-compatible Redis payloads,
-  queues, scheduling, and retries.
+description: A Ractor-local Redis task runtime with its own envelope, channels, claims,
+  interceptors, scheduling, and failure handling.
 executables:
 - solid-jobs
 extensions: []
@@ -119,29 +119,30 @@ files:
 - exe/solid-jobs
 - lib/active_job/queue_adapters/solid_jobs_adapter.rb
 - lib/solid_jobs.rb
-- lib/solid_jobs/active_job.rb
-- lib/solid_jobs/api.rb
-- lib/solid_jobs/cli.rb
-- lib/solid_jobs/client.rb
-- lib/solid_jobs/config.rb
+- lib/solid_jobs/blueprint.rb
+- lib/solid_jobs/catalog.rb
+- lib/solid_jobs/claim.rb
+- lib/solid_jobs/conductor.rb
+- lib/solid_jobs/console.rb
+- lib/solid_jobs/engine.rb
 - lib/solid_jobs/errors.rb
-- lib/solid_jobs/fetch.rb
+- lib/solid_jobs/executor.rb
+- lib/solid_jobs/failure_policy.rb
 - lib/solid_jobs/heartbeat.rb
 - lib/solid_jobs/integrity_check.rb
-- lib/solid_jobs/job.rb
-- lib/solid_jobs/middleware/chain.rb
-- lib/solid_jobs/processor.rb
+- lib/solid_jobs/interceptor_registry.rb
+- lib/solid_jobs/keyspace.rb
+- lib/solid_jobs/lab.rb
+- lib/solid_jobs/publisher.rb
 - lib/solid_jobs/ractor_support.rb
-- lib/solid_jobs/rails.rb
+- lib/solid_jobs/rails_adapter.rb
+- lib/solid_jobs/railtie.rb
 - lib/solid_jobs/recovery.rb
-- lib/solid_jobs/retry_service.rb
-- lib/solid_jobs/scheduler.rb
-- lib/solid_jobs/server.rb
 - lib/solid_jobs/startup_barrier.rb
-- lib/solid_jobs/testing.rb
+- lib/solid_jobs/task.rb
+- lib/solid_jobs/timer.rb
 - lib/solid_jobs/utilities.rb
 - lib/solid_jobs/version.rb
-- lib/solid_jobs/worker.rb
 homepage: https://github.com/nicolasva/solid-jobs
 licenses:
 - MIT

data/lib/solid_jobs/active_job.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module SolidJobs
-  module ActiveJob
-    class Wrapper
-      include SolidJobs::Job
-      solid_jobs_options retry: true
-
-      def perform(job_data)
-        ::ActiveJob::Base.execute(job_data.merge("provider_job_id" => jid))
-      end
-    end
-    JobWrapper = Wrapper
-  end
-end
-