quiq 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '087c9f77d2ec6838e562f95595c17620f00089367bcacd513dded5b35f4348da'
-  data.tar.gz: b8939bc5606d8677b78aa56b98a2c530a07f22d1c5a91d5433e5750041f56cf6
+  metadata.gz: f90fff6709ecb676daed0452eb08a59829a574b6a0d7b5819c9efe210a022453
+  data.tar.gz: 8391e3cc14ff6dc6ee97370f114bc314655714c983f04176cae17b1c251bbfb6
 SHA512:
-  metadata.gz: 8502ee18454f56f2a7ff26d5c528b32a4cf5c417752a5d68e241d9662c7d7b94196067ffdcdd0591cbea6557c50263e4a4209f441e49aa971b8a2d68a9936aac
-  data.tar.gz: dc3e2e731796bc8834b453b1ab957a1a2307b59cd2613c5175ca3a6a001bb43d5c59d85f6aa020e36a8df26dbe2d493c23a14bc86719a747f5d2022b1abbb57a
+  metadata.gz: 87eceeb1209250a2932c1ef82c766c0fd9e333ede059ffffaebad9dca2e503d9ff9ff550f3a2424dd2db97bcbd090bf81cdede5d7ab589439bab3e6bc1f70f65
+  data.tar.gz: d3cc1741271ac08ef7abdc4e77262b411f0ae712c6415a62153227855094ff8e23ad35644496149cb6c914064395c5fe9dc7f1cfbb9afb2e74a5de468db97f5a

data/.github/workflows/ruby.yml

@@ -0,0 +1,20 @@
+name: Ruby
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby 7.6
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: 2.7.x
+    - name: Build and test with Rake
+      run: |
+        gem install bundler
+        bundle install --jobs 4 --retry 3
+        bundle exec rake spec

data/.gitignore

@@ -11,3 +11,5 @@
 
 # rspec failure tracking
 .rspec_status
+.ruby-version
+.ruby-gemset

data/Gemfile.lock

@@ -1,9 +1,8 @@
 PATH
   remote: .
   specs:
-    quiq (0.1.0)
-      async-container (~> 0.16)
-      async-redis (~> 0.4)
+    quiq (0.2.0)
+      async-redis (~> 0.4.3)
 
 GEM
   remote: https://rubygems.org/
@@ -67,23 +66,21 @@ GEM
       console (~> 1.0)
       nio4r (~> 2.3)
       timers (~> 4.1)
-    async-container (0.16.1)
-      async (~> 1.0)
-      async-io (~> 1.26)
-      process-group
     async-io (1.27.3)
       async (~> 1.14)
-    async-redis (0.4.1)
+    async-pool (0.2.0)
+      async (~> 1.8)
+    async-redis (0.4.3)
       async (~> 1.8)
       async-io (~> 1.10)
-      protocol-redis (~> 0.2.0)
+      async-pool (~> 0.2)
+      protocol-redis (~> 0.4.0)
     builder (3.2.4)
     concurrent-ruby (1.1.5)
-    console (1.8.0)
+    console (1.8.1)
     crass (1.0.6)
     diff-lcs (1.3)
     erubi (1.9.0)
-    ffi (1.12.2)
     globalid (0.4.2)
       activesupport (>= 4.2.0)
     i18n (1.8.2)
@@ -103,11 +100,7 @@ GEM
     nio4r (2.5.2)
     nokogiri (1.10.7)
       mini_portile2 (~> 2.4.0)
-    process-group (1.2.1)
-      process-terminal (~> 0.2.0)
-    process-terminal (0.2.0)
-      ffi
-    protocol-redis (0.2.0)
+    protocol-redis (0.4.2)
     rack (2.1.1)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
@@ -178,4 +171,4 @@ DEPENDENCIES
   rspec (~> 3.0)
 
 BUNDLED WITH
-   2.1.2
+   2.1.4

data/README.md

@@ -1,8 +1,12 @@
 # Quiq
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/quiq`. To experiment with that code, run `bin/console` for an interactive prompt.
+Quiq is a distributed task queue backed by Redis to process jobs in background.
 
-TODO: Delete this and the text above, and describe your gem
+It relies on asynchronous IOs to process multiple jobs simultaneously. The event loop is provided by the [Async](https://github.com/socketry/async) library and many other gems of the [Socketry](https://github.com/socketry) family.
+
+It can be used without Rails, but will play nicely with [ActiveJob](https://guides.rubyonrails.org/active_job_basics.html) even though it's not supported officialy (more details [here](#activejob-support)).
+
+The library is in a very early stage, it is **not suitable for production** yet.
 
 ## Installation
 
@@ -22,7 +26,102 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+To launch the workers, you can use the `quiq` command.
+
+```
+Usage: quiq [options]
+    -p, --path PATH                  Location of the workers to load
+    -q, --queues NAMES               Comma-separated list of queues to poll
+    -l, --log-level LEVEL            The logging level
+    -v, --version                    Output version and exit
+    -h, --help                       Show this message
+```
+
+This is how to use it with a Rails application using [ActiveJob](https://guides.rubyonrails.org/active_job_basics.html)
+
+    $ bundle exec quiq -p ./config/environment.rb -q critical,medium,low -l WARN
+
+## Configuration
+
+Here is an example of a configuration within a Rails application:
+
+```ruby
+Quiq.configure do |config|
+  config.redis = 'redis://localhost:6379'
+  config.logger = Rails.logger
+end
+```
+
+### ActiveJob support
+
+As there is no official support for Quiq in ActiveJob, you must monkey patch it to use it as you would do with any other background jobs system. You can find a complete example here: [testapp/config/initializers/quiq.rb](https://github.com/sailor/quiq/blob/master/testapp/config/initializers/quiq.rb)
+
+```ruby
+module ActiveJob
+  module QueueAdapters
+    class QuiqAdapter
+      def enqueue(job)
+        Quiq::Client.push(job)
+      end
+
+      def enqueue_at(job, timestamp)
+        Quiq::Client.push(job, scheduled_at: timestamp)
+      end
+
+      class JobWrapper
+        class << self
+          def perform(job_data)
+            Base.execute job_data
+          end
+        end
+      end
+    end
+  end
+end
+```
+
+## Jobs
+
+As it is using the [Async](https://github.com/socketry/async) gem, we can use the many features provided by this library.
+
+You can access the underlying `Async::Task` by using `Quiq.current_task`.
+
+A very dumb example:
+
+```ruby
+class TestJob < ApplicationJob
+  def perform(data, wait)
+    puts "Receiving new job: #{data}"
+    Quiq.current_task.sleep wait # Non blocking call
+    puts "Time to wake up after #{wait} seconds"
+  end
+end
+```
+
+More interesting use case. If you combine `quiq` with the [async-http](https://github.com/socketry/async-http) gem, you'll be able to make asynchronous HTTP calls:
+
+```ruby
+require 'uri'
+require 'async/http/internet'
+
+class HttpJob < ApplicationJob
+  def perform(url)
+    uri = URI(url)
+
+    client = Async::HTTP::Internet.new
+    response = client.get(url)
+    Quiq.logger.info response.read
+  end
+end
+```
+
+### Scheduled jobs
+
+Since Quiq supports ActiveJob interface you can use the same approach to schedule jobs for the future.
+
+```ruby
+TestJob.set(wait: 5.seconds).perform_later(1, 2)
+```
 
 ## Development
 
@@ -30,16 +129,34 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-## Contributing
+## Benchmarks
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/sailor/quiq.
+To benchmark the system you can use the `quiqload` binary. To launch it, execute:
+
+    $ time bin/quiqload -n 10_000 -w 1
+
+```
+Usage: quiqload [options]
+    -n, --number JOBS                Number of jobs to enqueue
+    -w, --wait DURATION              Idle time within each job (in seconds)
+    -h, --help                       Show this message
+```
 
-## TODO
+## Todo
 
 - [ ] Graceful shutdown
-- [ ] Add a customizable logger
-- [ ] Implement a DLQ
-- [ ] Support job scheduled in the future
+- [x] Customizable logger
+- [x] Dead-letter queue
+- [x] Scheduler
+- [ ] Specs
+- [ ] Retry system
+- [ ] Batches support
+- [x] Load testing script
+- [ ] Admin user interface
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sailor/quiq.
 
 ## License
 

data/bin/quiq

@@ -4,19 +4,25 @@
 require_relative '../lib/quiq'
 require 'optparse'
 
-options = {}
+options = { path: Dir.pwd, queues: %w[default], log_level: Logger::DEBUG }
 OptionParser.new do |opts|
   opts.banner = 'Usage: quiq [options]'
 
-  opts.on('-p', '--path [PATH|DIR]", "Location of the workers to require') do |path|
-    options[:path] = path
+  opts.on('-p', '--path PATH', 'Location of the workers to load') do |path|
+    options[:path] = File.expand_path(path)
   end
 
-  opts.on('-q', '--queues [NAMES]", "Comma-separated list of queues to fetch jobs from') do |queues|
-    options[:queues] = queues.split(',')
+  opts.on('-q', '--queues NAMES', Array,
+          'Comma-separated list of queues to poll') do |queues|
+    options[:queues] = queues
   end
 
-  opts.on '-v', '--version', 'Output version and exit' do |arg|
+  opts.on('-l', '--log-level LEVEL', %i[debug info warn error],
+          'The logging level') do |level|
+    options[:log_level] = level
+  end
+
+  opts.on '-v', '--version', 'Output version and exit' do
     puts "Quiq #{Quiq::VERSION}"
     exit
   end
@@ -28,9 +34,9 @@ OptionParser.new do |opts|
 end.parse!
 
 begin
-  Quiq.run(options)
-rescue
-  warn $!.message
-  warn $!.backtrace.join("\n")
+  Quiq.boot(options)
+rescue StandardError => e
+  warn e.message
+  warn e.backtrace.join("\n")
   exit 1
 end

data/bin/quiqload

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Usage: time RUBYOPT="-W0" bin/quiqload
+
+require_relative '../lib/quiq'
+require_relative '../testapp/config/environment.rb'
+require 'optparse'
+
+options = { number: 10_000, wait: 1 }
+OptionParser.new do |opts|
+  opts.banner = 'Usage: quiqload [options]'
+
+  opts.on('-n', '--number JOBS', Integer, 'Number of jobs to enqueue') do |number|
+    options[:number] = number.to_i
+  end
+
+  opts.on('-w', '--wait DURATION', Integer,
+          'Idle time within each job (in seconds)') do |wait|
+    options[:wait] = wait.to_i
+  end
+
+  opts.on_tail('-h', '--help', 'Show this message') do
+    puts opts
+    exit
+  end
+end.parse!
+
+Quiq.logger.info("Enqueuing #{options[:number]} jobs")
+options[:number].times { |i| TestJob.perform_later(i, options[:wait]) }
+
+Thread.new do
+  loop do
+    queue_size = Async do
+      queue = Quiq::Queue.processing_name('default')
+      Quiq.redis.llen queue
+    end.wait
+
+    if queue_size.zero?
+      Quiq.logger.info("Done processing #{options[:number]} jobs")
+      break
+    end
+
+    sleep 0.1
+  end
+end.join

data/lib/quiq.rb

@@ -7,39 +7,43 @@ require_relative 'quiq/client'
 require 'async/redis'
 
 module Quiq
-  class << self
-    attr_accessor :configuration
+  extend self
+
+  def configuration
+    Config.instance
   end
 
-  def self.configure
-    self.configuration ||= Config.instance
+  def configure
     yield(configuration) if block_given?
   end
 
-  def self.redis
-    configuration.redis
+  def redis
+    configuration.redis.client
   end
 
-  def self.run(options)
-    configure if configuration.nil?
-    configuration.queues = options[:queues] || ['default']
+  def boot(options)
+    configuration.parse_options(**options)
 
-    # Lookup for workers in the given path or the current directory
-    path = options[:path] || Dir.pwd
+    # Load the workers source code
+    path = configuration.path
     if File.directory?(path)
       Dir.glob(File.join(path, '*.rb')).each { |file| require file }
     else
       require path
     end
 
-    Server.instance.run
+    Server.instance.run!
   end
 
-  def self.queues
+  def queues
     configuration.queues
   end
 
-  def self.current_task
+  def current_task
     Async::Task.current
   end
+
+  def logger
+    configuration.logger
+  end
 end

data/lib/quiq/client.rb

@@ -5,15 +5,18 @@ require 'uri'
 
 module Quiq
   class Client
-    def push(job)
-      serialized = JSON.dump(job.serialize)
-      Async do
-        Quiq.redis.lpush("queue:#{job.queue_name}", serialized)
+    def push(job, scheduled_at)
+      serialized_job = JSON.dump(job.serialize)
+
+      if scheduled_at
+        Async { Scheduler.enqueue_at(serialized_job, scheduled_at) }
+      else
+        Async { Queue.push(job.queue_name, serialized_job) }
       end
     end
 
-    def self.push(job)
-      new.push(job)
+    def self.push(job, scheduled_at: nil)
+      new.push(job, scheduled_at)
     end
   end
 end

data/lib/quiq/config.rb

@@ -1,29 +1,35 @@
 # frozen_string_literal: true
 
+require 'logger'
 require 'singleton'
-require 'uri'
+require_relative 'redis'
 
 module Quiq
   class Config
     include Singleton
 
-    attr_accessor :queues
+    attr_reader :queues, :path
+    attr_writer :logger
+
+    def redis=(server)
+      @redis = Redis.new(server)
+    end
 
-    # Return a connection to the local
-    # Redis instance if not configured
     def redis
-      @redis ||= begin
-        endpoint = Async::Redis.local_endpoint
-        Async::Redis::Client.new(endpoint)
+      @redis ||= Redis.new
+    end
+
+    def logger
+      @logger ||= begin
+        level = @log_level || Logger::DEBUG
+        ::Logger.new(STDOUT, level: level)
       end
     end
 
-    # Only accepts a redis connection uri for now
-    # Note the client used is far from being production ready
-    def redis=(server)
-      uri = URI(server)
-      endpoint = Async::IO::Endpoint.tcp(uri.host, uri.port)
-      @redis = Async::Redis::Client.new(endpoint)
+    def parse_options(path:, queues:, log_level:)
+      @path = path
+      @queues = queues
+      @log_level = log_level
     end
   end
 end

data/lib/quiq/job.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Quiq
+  class Job
+    def initialize(raw, queue)
+      @raw = raw
+      @queue = queue
+    end
+
+    def run
+      Async do
+        begin
+          # First parse the raw message from redis
+          payload = JSON.parse(@raw)
+
+          # Then load the definition of the job + its arguments
+          klass = Object.const_get(payload['job_class'])
+          args = payload['arguments']
+
+          # Then run the task
+          klass.new.perform(*args)
+        rescue JSON::ParserError => e
+          Quiq.logger.warn("Invalid format: #{e}")
+          send_to_dlq(@raw, e)
+        rescue StandardError => e
+          Quiq.logger.debug("Sending message to DLQ: #{e}")
+          send_to_dlq(payload, e)
+        ensure
+          # Remove the job from the processing list
+          Queue.delete(@queue.processing, @raw)
+        end
+      end
+    end
+
+    private
+
+    def send_to_dlq(payload, exception)
+      if payload.is_a?(Hash)
+        payload['error'] = exception.to_s
+        payload['backtrace'] = exception.backtrace
+        message = JSON.dump(payload)
+      else
+        message = @raw
+      end
+
+      Queue.send_to_dlq(message)
+    end
+  end
+end

data/lib/quiq/queue.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Quiq
+  class Queue
+    PREFIX = 'queue'
+    PROCESSING_SUFFIX = 'processing'
+    DEAD_LETTER_QUEUE = 'dead'
+
+    attr_reader :name, :processing
+
+    def initialize(name)
+      @name = self.class.formatted_name(name)
+      @processing = self.class.processing_name(name)
+    end
+
+    def push(job)
+      pushed = Quiq.redis.lpush(@name, job)
+      return unless pushed <= 0
+
+      Quiq.logger.error("Could not push to the queue: #{@name}")
+      false
+    end
+
+    def pop
+      Quiq.redis.brpoplpush(@name, @processing, 0)
+    end
+
+    # Insert elements that weren't fully processed at the tail of the queue to avoid loss
+    # @note that they should be enqueued at the head of the queue, but Redis lacks a LPOPRPUSH command
+    def purge_processing!
+      Async do
+        Quiq.redis.pipeline do |pipe|
+          loop do
+            job = pipe.sync.call('RPOPLPUSH', @processing, @name)
+            Quiq.logger.warn("Requeuing job #{job} in #{@name}") unless job.nil?
+            break if job.nil?
+          end
+          pipe.close
+        end
+      end.wait
+    end
+
+    def self.push(queue, job)
+      @queue = new(queue)
+      @queue.push(job)
+    end
+
+    def self.delete(queue, job)
+      Quiq.redis.lrem(queue, 0, job)
+    end
+
+    def self.formatted_name(name)
+      "#{PREFIX}:#{name}"
+    end
+
+    def self.processing_name(name)
+      "#{PREFIX}:#{name}:#{PROCESSING_SUFFIX}"
+    end
+
+    def self.send_to_dlq(job)
+      @dlq ||= Queue.new(DEAD_LETTER_QUEUE)
+      @dlq.push(job)
+    end
+  end
+end

data/lib/quiq/redis.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Quiq
+  class Redis
+    DEFAULT_REDIS_URL = 'redis://localhost:6379'
+
+    attr_reader :client
+
+    def initialize(server = DEFAULT_REDIS_URL)
+      uri = URI(server)
+      endpoint = Async::IO::Endpoint.tcp(uri.host, uri.port)
+      @client = Async::Redis::Client.new(endpoint)
+    end
+  end
+end

data/lib/quiq/scheduler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Quiq
+  class Scheduler
+    include Singleton
+
+    SCHEDULER_KEY = 'quiq:schedule'
+
+    def start
+      # Set the process name
+      Process.setproctitle('quiq scheduler')
+
+      Async do
+        loop do
+          sleep 0.2
+
+          # TODO: use ZRANGEBYSCORE instead to batch enqueuing
+          job, scheduled_at = Quiq.redis.zrange(
+            SCHEDULER_KEY, 0, 0, with_scores: true
+          )
+
+          enqueue(job) if job && scheduled_at.to_f <= Time.now.to_f
+        end
+      ensure
+        Quiq.redis.close
+      end
+    end
+
+    def self.enqueue_at(job, scheduled_at)
+      Quiq.redis.zadd(SCHEDULER_KEY, scheduled_at, job)
+    end
+
+    private
+
+    # Push the job in its queue and remove from scheduler_queue
+    def enqueue(job)
+      begin
+        payload = JSON.parse(job)
+      rescue JSON::ParserError => e
+        Quiq.logger.warn("Invalid format: #{e}")
+        Queue.send_to_dlq(job)
+      end
+
+      # TODO: wrap those 2 calls in a transaction
+      Queue.push(payload['queue_name'], job)
+      Quiq.redis.zrem(SCHEDULER_KEY, job)
+    end
+  end
+end

data/lib/quiq/server.rb

@@ -1,31 +1,28 @@
 # frozen_string_literal: true
 
 require 'singleton'
-require 'async/container'
 require 'async/redis'
 require_relative 'worker'
+require_relative 'scheduler'
 
 module Quiq
-  class Server < Async::Container::Controller
+  class Server
     include Singleton
 
-    # Called by Server.instance.run
-    def setup(container)
-      @queues = Quiq.queues.map { |q| "queue:#{q}" }
-
-      container.async do
-        loop do
-          job = fetch_one
-          Worker.new(job).run
-        end
-      ensure
-        Quiq.redis.close
+    def run!
+      # Launch one worker per queue
+      Quiq.queues.each do |queue|
+        fork { Worker.new(queue).start }
       end
-    end
 
-    def fetch_one
-      # BRPOP returns a tuple made of the queue name then the args
-      Quiq.redis.brpop(*@queues).last
+      # Launch scheduler for jobs to be performed at certain time
+      fork { Scheduler.instance.start }
+
+      # Set the process name
+      Process.setproctitle("quiq master #{Quiq.configuration.path}")
+
+      # TODO: handle graceful shutdowns
+      Process.waitall
     end
   end
 end

data/lib/quiq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quiq
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/quiq/worker.rb

@@ -1,21 +1,27 @@
 # frozen_string_literal: true
 
-require 'json'
+require_relative 'job'
+require_relative 'queue'
 
 module Quiq
   class Worker
-    def initialize(job)
-      # TODO: handle deserialization errors
-      @job = JSON.parse(job) rescue nil
+    def initialize(queue)
+      @queue = Queue.new(queue)
     end
 
-    def run
-      return if @job.nil?
+    def start
+      # Set the process name
+      Process.setproctitle("quiq worker #{@queue.name}")
 
+      # Reschedule jobs that get terminated before completion
+      # Beware that the jobs must be idempotent!
+      @queue.purge_processing!
+
+      # Then start processing enqueued jobs
       Async do
-        klass = Object.const_get(@job['job_class'])
-        args = @job['arguments']
-        klass.new.perform(*args)
+        loop { Job.new(@queue.pop, @queue).run }
+      ensure
+        Quiq.redis.close
       end
     end
   end

data/quiq.gemspec

@@ -7,8 +7,11 @@ Gem::Specification.new do |spec|
   spec.version       = Quiq::VERSION
   spec.authors       = ['Salim Semaoune']
 
-  spec.summary       = 'amazing summary'
-  spec.description   = 'gorgeous description'
+  spec.summary       = 'Distributed task queue written in Ruby, backed by Redis and using event loops to handle concurrency.'
+  spec.description   = <<-EOS
+    Quiq is a distributed task queue backed by Redis to process jobs in background.
+    It relies on asynchronous IOs to process multiple jobs simultaneously. The event loop is provided by the Async library and many other gems of the Socketry family.
+  EOS
   spec.homepage      = 'https://github.com/sailor/quiq'
   spec.license       = 'MIT'
   spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
@@ -22,7 +25,6 @@ Gem::Specification.new do |spec|
   spec.executables   = ['quiq']
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'async-container', '~> 0.16'
-  spec.add_dependency 'async-redis', '~> 0.4'
+  spec.add_dependency 'async-redis', '~> 0.4.3'
   spec.add_development_dependency 'rspec', '~> 3.2'
 end

data/testapp/Gemfile

@@ -7,6 +7,7 @@ ruby '2.7.0'
 
 gem 'bootsnap', '>= 1.4.2', require: false
 gem 'quiq', path: '..'
+gem 'async-http'
 gem 'rails', '~> 6.0.2', '>= 6.0.2.1'
 
 group :development do

data/testapp/Gemfile.lock

@@ -2,8 +2,7 @@ PATH
   remote: ..
   specs:
     quiq (0.1.0)
-      async-container (~> 0.16)
-      async-redis (~> 0.4)
+      async-redis (~> 0.4.3)
 
 GEM
   remote: https://rubygems.org/
@@ -67,21 +66,27 @@ GEM
       console (~> 1.0)
       nio4r (~> 2.3)
       timers (~> 4.1)
-    async-container (0.16.1)
-      async (~> 1.0)
-      async-io (~> 1.26)
-      process-group
+    async-http (0.50.2)
+      async (~> 1.23)
+      async-io (~> 1.27.0)
+      async-pool (~> 0.2)
+      protocol-http (~> 0.13.0)
+      protocol-http1 (~> 0.10.0)
+      protocol-http2 (~> 0.10.0)
     async-io (1.27.3)
       async (~> 1.14)
-    async-redis (0.4.1)
+    async-pool (0.2.0)
+      async (~> 1.8)
+    async-redis (0.4.3)
       async (~> 1.8)
       async-io (~> 1.10)
-      protocol-redis (~> 0.2.0)
+      async-pool (~> 0.2)
+      protocol-redis (~> 0.4.0)
     bootsnap (1.4.5)
       msgpack (~> 1.0)
     builder (3.2.4)
     concurrent-ruby (1.1.5)
-    console (1.8.0)
+    console (1.8.1)
     crass (1.0.6)
     erubi (1.9.0)
     ffi (1.12.1)
@@ -109,11 +114,14 @@ GEM
     nio4r (2.5.2)
     nokogiri (1.10.7)
       mini_portile2 (~> 2.4.0)
-    process-group (1.2.1)
-      process-terminal (~> 0.2.0)
-    process-terminal (0.2.0)
-      ffi
-    protocol-redis (0.2.0)
+    protocol-hpack (1.4.2)
+    protocol-http (0.13.1)
+    protocol-http1 (0.10.1)
+      protocol-http (~> 0.13)
+    protocol-http2 (0.10.4)
+      protocol-hpack (~> 1.4)
+      protocol-http (~> 0.2)
+    protocol-redis (0.4.2)
     rack (2.1.1)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
@@ -169,6 +177,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  async-http
   bootsnap (>= 1.4.2)
   listen (>= 3.0.5, < 3.2)
   quiq!

data/testapp/app/jobs/http_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'async/http/internet'
+
+class HttpJob < ApplicationJob
+  def perform(url)
+    uri = URI(url)
+
+    client = Async::HTTP::Internet.new
+    response = client.get(url)
+    Quiq.logger.info response.read
+  end
+end

data/testapp/app/jobs/test_job.rb

@@ -2,8 +2,8 @@
 
 class TestJob < ApplicationJob
   def perform(data, wait)
-    puts "Receiving new data: #{data}"
+    puts "[Worker ##{$$}] Receiving new job: #{data}"
     Quiq.current_task.sleep wait
-    puts "Time to wake up after #{wait} seconds"
+    puts "[Worker ##{$$}] Time to wake up after #{wait} seconds"
   end
 end

data/testapp/config/initializers/quiq.rb

@@ -9,7 +9,7 @@ module ActiveJob
       end
 
       def enqueue_at(job, timestamp)
-        raise NotImplementedError, 'Support for schedule jobs is coming soon.'
+        Quiq::Client.push(job, scheduled_at: timestamp)
       end
 
       class JobWrapper
@@ -25,4 +25,5 @@ end
 
 Quiq.configure do |config|
   config.redis = 'redis://localhost:6379'
+  # config.logger = Rails.logger
 end

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: quiq
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Salim Semaoune
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-02 00:00:00.000000000 Z
+date: 2020-02-12 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: async-container
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.16'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.16'
 - !ruby/object:Gem::Dependency
   name: async-redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: 0.4.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -52,13 +38,16 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
-description: gorgeous description
+description: |2
+      Quiq is a distributed task queue backed by Redis to process jobs in background.
+      It relies on asynchronous IOs to process multiple jobs simultaneously. The event loop is provided by the Async library and many other gems of the Socketry family.
 email: 
 executables:
 - quiq
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
@@ -70,10 +59,15 @@ files:
 - Rakefile
 - bin/console
 - bin/quiq
+- bin/quiqload
 - bin/setup
 - lib/quiq.rb
 - lib/quiq/client.rb
 - lib/quiq/config.rb
+- lib/quiq/job.rb
+- lib/quiq/queue.rb
+- lib/quiq/redis.rb
+- lib/quiq/scheduler.rb
 - lib/quiq/server.rb
 - lib/quiq/version.rb
 - lib/quiq/worker.rb
@@ -86,6 +80,7 @@ files:
 - testapp/app/controllers/application_controller.rb
 - testapp/app/controllers/concerns/.keep
 - testapp/app/jobs/application_job.rb
+- testapp/app/jobs/http_job.rb
 - testapp/app/jobs/test_job.rb
 - testapp/app/models/concerns/.keep
 - testapp/bin/bundle
@@ -140,5 +135,6 @@ requirements: []
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: amazing summary
+summary: Distributed task queue written in Ruby, backed by Redis and using event loops
+  to handle concurrency.
 test_files: []