async-job 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 895f34561c4da96884e09c180b33ab7ed4ac52b5c72e10af70403deea920200e
-  data.tar.gz: 8af66add606e0eebb5abfb5d35a67d1e41547c86227054a56fd1dbf1e2f90929
+  metadata.gz: 1e330cf8c0430796e25264e8c892f70423f1fa0ffbc645a19198774f51ef4893
+  data.tar.gz: 3c1ac69a6bde193876717c65dace5e97803b66ab9471d5baeffc33bb1762701a
 SHA512:
-  metadata.gz: 5bd937f27dd026b2c6c3e44c2a2d801cd936c477fd1e514d0c34f07d0bc4db6cf7c3583ea26348a85277b33cc59bbd90ec1626bf67eb8bdac1b85eaca6b588ee
-  data.tar.gz: 94a26598b246051666bf68c9cd1f11785ca75f32c43fb9d74349ad193650cd03df9cc7069d2b46f128b11cd50fc35383b0018d31acdceb833d013090ce711fc3
+  metadata.gz: 956e76aadce5f21fd099ba72d38914f4a4a6981a1d4382eee34a7bc37a0d79cb7bedb6b93000146a752fdc829945a93c72ef873fc3012acda5f6ea50d58128ae
+  data.tar.gz: 8fb1c37bc2f065c08a08dbdc25f04dbfe2aab5d67eb57c297a50fb5665e9840014fe1c3bd7257fc2dfa463919507fdf450dcaa71d1c17dc5cde0441b949c108b

data/lib/async/job/backend/inline/server.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative '../../coder'
+
+module Async
+	module Job
+		module Backend
+			module Inline
+				class Server
+					def initialize(delegate)
+						@delegate = delegate
+					end
+					
+					def call(job)
+						scheduled_at = Coder::Time(job["scheduled_at"])
+						
+						Async do
+							if scheduled_at
+								sleep(scheduled_at - Time.now)
+							end
+							
+							@delegate.call(job)
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/job/backend/inline.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'inline/server'
+
+module Async
+	module Job
+		module Backend
+			module Inline
+				def self.new(delegate)
+					return Server.new(delegate)
+				end
+			end
+		end
+	end
+end

data/lib/async/job/backend/redis/server.rb

@@ -9,16 +9,21 @@ require_relative 'processing_queue'
 require_relative 'ready_queue'
 
 require 'securerandom'
+require_relative '../../coder'
 
 module Async
 	module Job
 		module Backend
 			module Redis
 				class Server
-					def initialize(client, prefix)
+					def initialize(delegate, client, prefix: 'async-job', coder: Coder::DEFAULT, resolution: 10)
+						@delegate = delegate
+						
 						@id = SecureRandom.uuid
 						@client = client
 						@prefix = prefix
+						@coder = coder
+						@resolution = resolution
 						
 						@job_store = JobStore.new(@client, "#{@prefix}:jobs")
 						
@@ -31,37 +36,39 @@ module Async
 					def start
 						Console.info(self, "Starting server...")
 						# Start the delayed queue, which will move jobs to the ready queue when they are ready:
-						@delayed_queue.start(@ready_queue)
+						@delayed_queue.start(@ready_queue, resolution: @resolution)
 						
 						# Start the processing queue, which will move jobs to the ready queue when they are abandoned:
 						@processing_queue.start
+						
+						while true
+							self.dequeue
+						end
 					end
 					
-					def enqueue(job)
-						@ready_queue.add(job, @job_store)
+					def call(job)
+						scheduled_at = Coder::Time(job["scheduled_at"])
+						
+						if scheduled_at
+							@delayed_queue.add(@coder.dump(job), scheduled_at, @job_store)
+						else
+							@ready_queue.add(@coder.dump(job), @job_store)
+						end
 					end
 					
-					def schedule(job, timestamp)
-						@delayed_queue.add(job, timestamp, @job_store)
-					end
+					protected
 					
-					def process(&block)
+					def dequeue
 						id = @processing_queue.fetch
 						begin
-							job = @job_store.get(id)
-							yield id, job
+							job = @coder.load(@job_store.get(id))
+							@delegate.call(job)
 							@processing_queue.complete(id)
 						rescue => error
 							@processing_queue.retry(id)
 							raise
 						end
 					end
-					
-					def each(&block)
-						while true
-							process(&block)
-						end
-					end
 				end
 			end
 		end

data/lib/async/job/backend/redis.rb

@@ -10,13 +10,9 @@ module Async
 	module Job
 		module Backend
 			module Redis
-				def self.new(**options)
-					endpoint = options.fetch(:endpoint) {Async::Redis.local_endpoint}
-					prefix = options.fetch(:prefix) {"async:job"}
-					
+				def self.new(delegate, endpoint: Async::Redis.local_endpoint, **options)
 					client = Async::Redis::Client.new(endpoint)
-					
-					return Async::Job::Backend::Redis::Server.new(client, prefix)
+					return Server.new(delegate, client, **options)
 				end
 			end
 		end

data/lib/async/job/buffer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'async/queue'
+
+module Async
+	module Job
+		class Buffer
+			def initialize(delegate = nil)
+				@jobs = Async::Queue.new
+				@delegate = delegate
+			end
+			
+			attr :jobs
+			
+			def call(job)
+				@jobs.enqueue(job)
+				@delegate&.call(job)
+			end
+			
+			def pop
+				@jobs.dequeue
+			end
+		end
+	end
+end

data/lib/async/job/builder.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+module Async
+	module Job
+		class Builder
+			Pipeline = Struct.new(:producer, :consumer, :delegate)
+			
+			def self.build(delegate = nil, &block)
+				builder = self.new(delegate)
+				
+				builder.instance_eval(&block)
+				
+				return builder.build
+			end
+			
+			def initialize(delegate = nil)
+				@enqueue = []
+				@dequeue = []
+				@delegate = delegate
+				
+				@queue = nil
+			end
+			
+			def enqueue(middleware)
+				@enqueue << middleware
+			end
+			
+			def queue(queue, *arguments, **options)
+				# The delegate is the output side of the queue, e.g. a Queuedelegate or similar wrapper.
+				# The queue itself is instantiated with the delegate.
+				@queue = ->(delegate){queue.new(delegate, *arguments, **options)}
+			end
+			
+			def dequeue(middleware)
+				@dequeue << middleware
+			end
+			
+			def delegate(delegate)
+				@delegate = delegate
+			end
+			
+			def build(&block)
+				# To construct the queue, we need the delegate.
+				delegate = @delegate
+				
+				# We then wrap the delegate with the middleware in reverse order:
+				@dequeue.reverse_each do |middleware|
+					delegate = middleware.new(delegate)
+				end
+				
+				# We can now construct the queue with the delegate:
+				producer = consumer = @queue.call(delegate)
+				
+				# We now construct the queue producer:
+				@enqueue.reverse_each do |middleware|
+					producer = middleware.new(queue)
+				end
+				
+				if block_given?
+					producer = yield(producer)
+				end
+				
+				return Pipeline.new(producer, consumer, @delegate)
+			end
+		end
+	end
+end

data/lib/async/job/coder/json.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'json'
+
+module Async
+	module Job
+		module Coder
+			class JSON
+				def initialize
+				end
+				
+				def dump(job)
+					::JSON.dump(job)
+				end
+				
+				def load(data)
+					::JSON.parse(data, symbolize_names: true)
+				end
+				
+				DEFAULT = self.new
+			end
+		end
+	end
+end

data/lib/async/job/coder/marshal.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'msgpack'
+
+module Async
+	module Job
+		module Coder
+			class Marshal
+				def dump(job)
+					::Marshal.dump(job)
+				end
+				
+				def load(data)
+					::Marshal.load(data)
+				end
+				
+				DEFAULT = self.new
+			end
+		end
+	end
+end

data/lib/async/job/coder/message_pack.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'msgpack'
+
+module Async
+	module Job
+		module Coder
+			class MessagePack
+				def initialize
+					@factory = ::MessagePack::Factory.new
+					
+					@factory.register_type(0x01, Symbol)
+					
+					@factory.register_type(0x02, Time,
+						packer: ::MessagePack::Time::Packer,
+						unpacker: ::MessagePack::Time::Unpacker
+					)
+				end
+				
+				def dump(job)
+					@factory.pack(job)
+				end
+				
+				def load(data)
+					@factory.unpack(data)
+				end
+				
+				DEFAULT = self.new
+			end
+		end
+	end
+end

data/lib/async/job/coder.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'coder/json'
+
+module Async
+	module Job
+		module Coder
+			DEFAULT = JSON::DEFAULT
+			
+			# Type-cast for time values. See <https://bugs.ruby-lang.org/issues/20298> for background.
+			# @parameter value [Time || Integer || String || nil]
+			def self.Time(value)
+				case value
+				when ::Time
+					value
+				when Integer
+					::Time.at(value)
+				when String
+					::Time.new(value)
+				when nil
+					nil
+				else
+					value.to_time
+				end
+			end
+		end
+	end
+end

data/lib/async/job/generic.rb

@@ -10,13 +10,13 @@ module Async
 				self.new(...).enqueue
 			end
 			
-			def initialize(id, perform_at: nil)
+			def initialize(id, scheduled_at: nil)
 				@id = id
-				@perform_at = perform_at
+				@scheduled_at = scheduled_at
 			end
 			
 			attr :id
-			attr :perform_at
+			attr :scheduled_at
 			
 			def serialize
 				raise NotImplementedError

data/lib/async/job/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module Job
-		VERSION = "0.2.1"
+		VERSION = "0.4.0"
 	end
 end

data/lib/async/job.rb

@@ -5,3 +5,4 @@
 
 require_relative 'job/version'
 require_relative 'job/backend'
+require_relative 'job/builder'

data/readme.md

@@ -6,7 +6,11 @@ Provides an asynchronous job server.
 
 ## Usage
 
-The current implementation is incomplete, but with `redis` running on localhost, you can run several instances of `client.rb` and `server.rb` to show the general operation.
+Please see the [project documentation](https://socketry.github.io/async-job/) for more details.
+
+  - [Getting Started](https://socketry.github.io/async-job/guides/getting-started/index) - This guide gives you an overview of the `async-job` gem and explains the core concepts.
+
+  - [Redis Backend](https://socketry.github.io/async-job/guides/redis-backend/index) - This guide gives a brief overview of the implementation of the Redis backend.
 
 ## Contributing
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-job
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -37,7 +37,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-02-24 00:00:00.000000000 Z
+date: 2024-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -75,12 +75,20 @@ extra_rdoc_files: []
 files:
 - lib/async/job.rb
 - lib/async/job/backend.rb
+- lib/async/job/backend/inline.rb
+- lib/async/job/backend/inline/server.rb
 - lib/async/job/backend/redis.rb
 - lib/async/job/backend/redis/delayed_queue.rb
 - lib/async/job/backend/redis/job_store.rb
 - lib/async/job/backend/redis/processing_queue.rb
 - lib/async/job/backend/redis/ready_queue.rb
 - lib/async/job/backend/redis/server.rb
+- lib/async/job/buffer.rb
+- lib/async/job/builder.rb
+- lib/async/job/coder.rb
+- lib/async/job/coder/json.rb
+- lib/async/job/coder/marshal.rb
+- lib/async/job/coder/message_pack.rb
 - lib/async/job/generic.rb
 - lib/async/job/version.rb
 - license.md
@@ -89,7 +97,7 @@ homepage:
 licenses:
 - MIT
 metadata:
-  documentation_uri: https://socketry.github.io/async-job
+  documentation_uri: https://socketry.github.io/async-job/
 post_install_message:
 rdoc_options: []
 require_paths: