distributed_job 1.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8aa1822c85ccb44521e470a312b430b9409dd537add85122045f7cd71d075ed
-  data.tar.gz: a781158c7699303544cb78185a200059da25013830f677a44a704b6a0c115af8
+  metadata.gz: 8bda4273dc59888e0269d7d14d69180e9a67bdb793e9c7f9f24bcc9f88a1b8fd
+  data.tar.gz: 8a3108b573a9e46e78d57979dfab70906459947651c1b2cda1391f66aa8e0f93
 SHA512:
-  metadata.gz: 6885d739ae86c615588dfd85ca1b4d0b0b3e4bcdf8cca1ddf1aebcb806a703c1980ca2d1e6f758d22b38a24a3859d5673fa47e7b2438db4635a4e24351bff4eb
-  data.tar.gz: ffbea863763a62d8f22a2e8c2f2b8555a910fc908801e9a93157703a3a2e7e6fbd9bee3b90e6c35971d430b8b720781b02c1d116159e1ea2c3cb00b9fa57b7d4
+  metadata.gz: e553072546911dffba6bd7f40e9f4eb6c7fe4f0a0338437ffc21cdc8e442c91cb0b51fa2afbcf070e257d2caaade5954867710e14e7919fde335aaebb8ec3867
+  data.tar.gz: 86ae97dd953642cc225f6b4280776c84dfc080cc4af90d8519352f6d4faf0a26ab736df372cac734a1884382a0173e9a44784371858b5e5f137bf68b2b6193d0

data/.gitignore

@@ -6,6 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+Gemfile.lock
 
 # rspec failure tracking
 .rspec_status

data/.rubocop.yml

@@ -3,6 +3,9 @@ AllCops:
   TargetRubyVersion: 2.5 
   SuggestExtensions: false
 
+Gemspec/RequireMFA:
+  Enabled: false
+
 Metrics/MethodLength:
   Enabled: false
 
@@ -17,3 +20,6 @@ Style/Documentation:
 
 Style/NumericPredicate:
   Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # CHANGELOG
 
+## v3.0.1
+
+* Fix pipelining with regards to redis-rb 4.6.0
+
+## v3.0.0
+
+* Split `DistributedJob` in `DistributedJob::Client` and `DistributedJob::Job`
+* Add native namespace support and drop support for `Redis::Namespace`
+
+## v2.0.0
+
+* `#push_each` no longer returns an enum when no block is given
+* Renamed `#parts` to `#open_parts`
+
 ## v1.0.0
 
 * Initial release

data/README.md

@@ -1,5 +1,8 @@
 # DistributedJob
 
+[![Build](https://github.com/mrkamel/distributed_job/workflows/test/badge.svg)](https://github.com/mrkamel/distributed_job/actions?query=workflow%3Atest+branch%3Amaster)
+[![Gem Version](https://badge.fury.io/rb/distributed_job.svg)](http://badge.fury.io/rb/distributed_job)
+
 Easily keep track of distributed jobs consisting of an arbitrary number of
 parts spanning multiple workers using redis. Can be used with any kind of
 backround job processing queue.
@@ -26,10 +29,22 @@ Getting started is very easy. A `DistributedJob` allows to keep track of a
 distributed job, i.e. a job which is split into multiple units running in
 parallel and in multiple workers.
 
-To create a distributed job and add parts, i.e. units of work, to it, simply:
+First, create a `DistributedJob::Client`:
+
+```ruby
+  DistributedJobClient = DistributedJob::Client.new(redis: Redis.new)
+```
+
+You can specify a `namespace` to be additionally used for redis keys and set a
+`default_ttl` for keys (Default is `86_400`, i.e. one day), which will be used
+every time when keys in redis are updated to guarantee that the distributed
+job metadata is cleaned up properly from redis at some point in time.
+
+Afterwards, to create a distributed job and add parts, i.e. units of work, to
+it, simply do:
 
 ```ruby
-  distributed_job = DistributedJob.new(redis: Redis.new, token: SecureRandom.hex)
+  distributed_job = DistributedJobClient.build(token: SecureRandom.hex)
 
   distributed_job.push_each(Date.parse('2021-01-01')..Date.today) do |date, part|
     SomeBackgroundJob.perform_async(date, distributed_job.token, part)
@@ -38,35 +53,40 @@ To create a distributed job and add parts, i.e. units of work, to it, simply:
   distributed_job.token # can be used to query the status of the distributed job
 ```
 
-The `token` can be used to keep query the status of the distributed job, e.g.
+The `part` which is passed to the block is some id for one particular part of
+the distributed job. It must be used in a respective background job to mark
+this part finished after it has been successfully processed. Therefore, when
+all those background jobs have successfully finished, all parts will be marked
+as finished, such that the distributed job will finally be finished as well.
+
+The `token` can also be used to query the status of the distributed job, e.g.
 on a job summary page or similar. You can show some progress bar in the browser
 or in the terminal, etc:
 
 ```ruby
 # token is given via URL or via some other means
-distributed_job = Distributed.new(redis: Redis.new, token: params[:token])
+distributed_job = DistributedJobClient.build(token: params[:token])
 
 distributed_job.total # total number of parts
 distributed_job.count # number of unfinished parts
-distributed_job.finished?
+distributed_job.finished? # whether or not all parts are finished
+distributed_job.open_parts # returns all not yet finished part id's
 ```
 
-Within the background job, you use the passed token and part to query and
-update the status of the distributed job and part accordingly. Please note
+Within the background job, you must use the passed `token` and `part` to query
+and update the status of the distributed job and part accordingly. Please note
 that you can use whatever background job processing tool you like most.
 
 ```ruby
 class SomeBackgroundJob
   def perform(whatever, token, part)
-    distributed_job = DistributedJob.new(redis: Redis.new, token: token)
+    distributed_job = DistributedJobClient.build(redis: Redis.new, token: token)
 
     return if distributed_job.stopped?
 
     # ...
 
-    distributed_job.done(part)
-
-    if distributed_job.finished?
+    if distributed_job.done(part)
       # perform e.g. cleanup or the some other job
     end
   rescue
@@ -78,10 +98,17 @@ end
 ```
 
 The `#stop` and `#stopped?` methods can be used to globally stop a distributed
-job in case of errors. Contrary, the `#done` method tells the `DistributedJob` that the
-specified part has successfully finished. Finally, the `#finished?` method
-returns true when all parts of the distributed job are finished, which is useful
-to start cleanup jobs or to even start another subsequent distributed job.
+job in case of errors. Contrary, the `#done` method tells the distributed job
+that the specified part has successfully finished. The `#done` method returns
+true when all parts of the distributed job have finished, which is useful to
+start cleanup jobs or to even start another subsequent distributed job.
+
+That's it.
+
+## Reference docs
+
+Please find the reference docs at
+[http://www.rubydoc.info/github/mrkamel/distributed_job](http://www.rubydoc.info/github/mrkamel/distributed_job)
 
 ## Development
 

data/distributed_job.gemspec

@@ -29,5 +29,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'rubocop'
-  spec.add_dependency 'redis'
+  spec.add_dependency 'redis', '>= 4.1.0'
 end

data/lib/distributed_job/client.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module DistributedJob
+  # A `DistributedJob::Client` allows to easily manage distributed jobs. The
+  # main purpose of the client object is to configure settings to all
+  # distributed jobs or a group of distributed jobs like e.g. the redis
+  # connection and an optional namespace to be used to prefix all redis keys.
+  #
+  # @example
+  #   DistributedJobClient = DistributedJob::Client.new(redis: Redis.new)
+  #
+  #   distributed_job = DistributedJobClient.build(token: SecureRandom.hex)
+  #
+  #   # Add job parts and queue background jobs
+  #   distributed_job.push_each(Date.parse('2021-01-01')..Date.today) do |date, part|
+  #     SomeBackgroundJob.perform_async(date, distributed_job.token, part)
+  #   end
+  #
+  #   distributed_job.token # can be used to query the status of the distributed job
+
+  class Client
+    attr_reader :redis, :namespace, :default_ttl
+
+    # Creates a new `DistributedJob::Client`.
+    #
+    # @param redis [Redis] The redis connection instance
+    # @param namespace [String] An optional namespace used to prefix redis keys
+    # @param default_ttl [Integer] The default number of seconds the jobs will
+    #   stay available in redis. This value is used to automatically expire and
+    #   clean up the jobs in redis. Default is 86400, i.e. one day. The ttl is
+    #   used everytime the job is modified in redis.
+    #
+    # @example
+    #   DistributedJobClient = DistributedJob::Client.new(redis: Redis.new)
+
+    def initialize(redis:, namespace: nil, default_ttl: 86_400)
+      @redis = redis
+      @namespace = namespace
+      @default_ttl = default_ttl
+    end
+
+    # Builds a new `DistributedJob::Job` instance.
+    #
+    # @param token [String] Some token to be used to identify the job. You can
+    #   e.g. use SecureRandom.hex to generate one.
+    # @param ttl [Integer] The number of seconds the job will stay available
+    #   in redis. This value is used to automatically expire and clean up the
+    #   job in redis. Default is `default_ttl`, i.e. one day. The ttl is used
+    #   everytime the job is modified in redis.
+
+    def build(token:, ttl: default_ttl)
+      Job.new(client: self, token: token, ttl: ttl)
+    end
+  end
+end

data/lib/distributed_job/job.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+module DistributedJob
+  # A `DistributedJob::Job` instance allows to keep track of a distributed job, i.e.
+  # a job which is split into multiple units running in parallel and in multiple
+  # workers using redis.
+  #
+  # @example Creating a distributed job
+  #   distributed_job = DistributedJobClient.build(token: SecureRandom.hex)
+  #
+  #   # Add job parts and queue background jobs
+  #   distributed_job.push_each(Date.parse('2021-01-01')..Date.today) do |date, part|
+  #     SomeBackgroundJob.perform_async(date, distributed_job.token, part)
+  #   end
+  #
+  #   distributed_job.token # can be used to query the status of the distributed job
+  #
+  # @example Processing a distributed job part
+  #   class SomeBackgroundJob
+  #     def perform(whatever, token, part)
+  #       distributed_job = DistributedJobClient.build(token: token)
+  #
+  #       return if distributed_job.stopped?
+  #
+  #       # ...
+  #
+  #       if distributed_job.done(part)
+  #         # perform e.g. cleanup or the some other job
+  #       end
+  #     rescue
+  #       distributed_job.stop
+  #
+  #       raise
+  #     end
+  #   end
+
+  class Job
+    attr_reader :client, :token, :ttl
+
+    # Initializes a new distributed job.
+    #
+    # @param client [DistributedJob::Client] The client instance
+    # @param token [String] Some token to be used to identify the job. You can
+    #   e.g. use SecureRandom.hex to generate one.
+    # @param ttl [Integer] The number of seconds this job will stay available
+    #   in redis. This value is used to automatically expire and clean up the
+    #   job in redis. Default is 86400, i.e. one day. The ttl is used everytime
+    #   the job is modified in redis.
+    #
+    # @example
+    #   DistributedJobClient = DistributedJob::Client.new(redis: Redis.new)
+    #
+    #   distributed_job = DistributedJob::Job.new(client: DistributedJobClient, token: SecureRandom.hex)
+    #
+    #   # However, the preferred way to build a distributed job is:
+    #
+    #   distributed_job = DistributedJobClient.build(token: SecureRandom.hex)
+
+    def initialize(client:, token:, ttl: 86_400)
+      @client = client
+      @token = token
+      @ttl = ttl
+    end
+
+    # Pass an enum to be used to iterate all the units of work of the distributed
+    # job. The distributed job needs to know all of them to keep track of the
+    # overall number and status of the parts. Passing an enum is much better
+    # compared to pushing the parts manually, because the distributed job needs
+    # to be closed before the last part of the distributed job is enqueued into
+    # some job queue. Otherwise it could potentially happen that the last part is
+    # already processed in the job queue before it is pushed to redis, such that
+    # the last job doesn't know that the distributed job is finished.
+    #
+    # @param enum [#each_with_index] The enum which can be iterated to get all
+    #   job parts
+    #
+    # @example
+    #   distributed_job.push_each(Date.parse('2021-01-01')..Date.today) do |date, part|
+    #     # e.g. SomeBackgroundJob.perform_async(date, distributed_job.token, part)
+    #   end
+    #
+    # @example ActiveRecord
+    #   distributed_job.push_each(User.select(:id).find_in_batches) do |batch, part|
+    #     # e.g. SomeBackgroundJob.perform_async(batch.first.id, batch.last.id, distributed_job.token, part)
+    #   end
+
+    def push_each(enum)
+      previous_object = nil
+      previous_index = nil
+
+      enum.each_with_index do |current_object, current_index|
+        push(current_index)
+
+        yield(previous_object, previous_index.to_s) if previous_index
+
+        previous_object = current_object
+        previous_index = current_index
+      end
+
+      close
+
+      yield(previous_object, previous_index.to_s) if previous_index
+    end
+
+    # Returns all parts of the distributed job which are not yet finished.
+    #
+    # @return [Enumerator] The enum which allows to iterate all parts
+
+    def open_parts
+      redis.sscan_each("#{redis_key}:parts")
+    end
+
+    # Removes the specified part from the distributed job, i.e. from the set of
+    # unfinished parts. Use this method when the respective job part has been
+    # successfully processed, i.e. finished.
+    #
+    # @param part [String] The job part
+    # @returns [Boolean] Returns true when there are no more unfinished parts
+    #   left or false otherwise
+    #
+    # @example
+    #   class SomeBackgroundJob
+    #     def perform(whatever, token, part)
+    #       distributed_job = DistributedJobClient.build(token: token)
+    #
+    #       # ...
+    #
+    #       distributed_job.done(part)
+    #     end
+    #   end
+
+    def done(part)
+      @done_script ||= <<~SCRIPT
+        local key, part, ttl = ARGV[1], ARGV[2], tonumber(ARGV[3])
+
+        if redis.call('srem', key .. ':parts', part) == 0 then return end
+
+        redis.call('expire', key .. ':parts', ttl)
+        redis.call('expire', key .. ':state', ttl)
+
+        return redis.call('scard', key .. ':parts')
+      SCRIPT
+
+      redis.eval(@done_script, argv: [redis_key, part.to_s, ttl]) == 0 && closed?
+    end
+
+    # Returns the total number of pushed parts, no matter if finished or not.
+    #
+    # @example
+    #   distributed_job.total # => e.g. 13
+
+    def total
+      redis.hget("#{redis_key}:state", 'total').to_i
+    end
+
+    # Returns the number of pushed parts which are not finished.
+    #
+    # @example
+    #   distributed_job.count # => e.g. 8
+
+    def count
+      redis.scard("#{redis_key}:parts")
+    end
+
+    # Returns true if there are no more unfinished parts.
+    #
+    # @example
+    #   distributed_job.finished? #=> true/false
+
+    def finished?
+      closed? && count.zero?
+    end
+
+    # Allows to stop a distributed job. This is useful if some error occurred in
+    # some part, i.e. background job, of the distributed job and you then want to
+    # stop all other not yet finished parts. Please note that only jobs can be
+    # stopped which ask the distributed job actively whether or not it was
+    # stopped.
+    #
+    # @returns [Boolean] Always returns true
+    #
+    # @example
+    #   class SomeBackgroundJob
+    #     def perform(whatever, token, part)
+    #       distributed_job = DistributedJobClient.build(token: token)
+    #
+    #       return if distributed_job.stopped?
+    #
+    #       # ...
+    #
+    #       distributed_job.done(part)
+    #     rescue
+    #       distributed_job.stop
+    #
+    #       raise
+    #     end
+    #   end
+
+    def stop
+      redis.multi do |transaction|
+        transaction.hset("#{redis_key}:state", 'stopped', 1)
+
+        transaction.expire("#{redis_key}:state", ttl)
+        transaction.expire("#{redis_key}:parts", ttl)
+      end
+
+      true
+    end
+
+    # Returns true when the distributed job was stopped or false otherwise.
+    #
+    # @returns [Boolean] Returns true or false
+    #
+    # @example
+    #   class SomeBackgroundJob
+    #     def perform(whatever, token, part)
+    #       distributed_job = DistributedJobClient.build(token: token)
+    #
+    #       return if distributed_job.stopped?
+    #
+    #       # ...
+    #
+    #       distributed_job.done(part)
+    #     rescue
+    #       distributed_job.stop
+    #
+    #       raise
+    #     end
+    #   end
+
+    def stopped?
+      redis.hget("#{redis_key}:state", 'stopped') == '1'
+    end
+
+    private
+
+    def redis
+      client.redis
+    end
+
+    def namespace
+      client.namespace
+    end
+
+    def close
+      redis.multi do |transaction|
+        transaction.hset("#{redis_key}:state", 'closed', 1)
+
+        transaction.expire("#{redis_key}:state", ttl)
+        transaction.expire("#{redis_key}:parts", ttl)
+      end
+
+      true
+    end
+
+    def closed?
+      redis.hget("#{redis_key}:state", 'closed') == '1'
+    end
+
+    def push(part)
+      @push_script ||= <<~SCRIPT
+        local key, part, ttl = ARGV[1], ARGV[2], tonumber(ARGV[3])
+
+        if redis.call('sadd', key .. ':parts', part) == 1 then
+          redis.call('hincrby', key .. ':state', 'total', 1)
+        end
+
+        redis.call('expire', key .. ':parts', ttl)
+        redis.call('expire', key .. ':state', ttl)
+      SCRIPT
+
+      redis.eval(@push_script, argv: [redis_key, part.to_s, ttl])
+    end
+
+    def redis_key
+      @redis_key ||= [namespace, 'distributed_jobs', token].compact.join(':')
+    end
+  end
+end

data/lib/distributed_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-class DistributedJob
-  VERSION = '1.0.0'
+module DistributedJob
+  VERSION = '3.0.1'
 end

data/lib/distributed_job.rb

@@ -1,275 +1,8 @@
 # frozen_string_literal: true
 
 require 'distributed_job/version'
+require 'distributed_job/client'
+require 'distributed_job/job'
 require 'redis'
 
-# A distributed job instance allows to keep track of distributed jobs, i.e.
-# jobs which are split into multiple units running in parallel and in multiple
-# workers using redis.
-#
-# @example Creating a distributed job
-#   distributed_job = DistributedJob.new(redis: Redis.new, token: SecureRandom.hex)
-#
-#   distributed_job.push_each(Date.parse('2021-01-01')..Date.today) do |date, part|
-#     SomeBackgroundJob.perform_async(date, distributed_job.token, part)
-#   end
-#
-#   distributed_job.token # can be used to query the status of the distributed job
-#
-# @example Processing a distributed job part
-#   class SomeBackgroundJob
-#     def perform(whatever, token, part)
-#       distributed_job = DistributedJob.new(redis: Redis.new, token: token)
-#
-#       return if distributed_job.stopped?
-#
-#       # ...
-#
-#       distributed_job.done(part)
-#
-#       if distributed_job.finished?
-#         # perform e.g. cleanup or the some other job
-#       end
-#     rescue
-#       distributed_job.stop
-#
-#       raise
-#     end
-#   end
-
-class DistributedJob
-  attr_reader :redis, :token, :ttl
-
-  # Initializes a new distributed job.
-  #
-  # @param redis [Redis] The redis connection instance
-  # @param token [String] Some token to be used to identify the job. You can
-  #   e.g. use SecureRandom.hex to generate one.
-  # @param ttl [Integer] The number of seconds this job will stay available
-  #   in redis. This value is used to automatically expire and clean up the
-  #   job in redis. Default is 86400, i.e. one day. The ttl is used everytime
-  #   the job is modified in redis.
-  #
-  # @example
-  #   distributed_job = DistributedJob.new(redis: Redis.new, token: SecureRandom.hex)
-
-  def initialize(redis:, token:, ttl: 86_400)
-    @redis = redis
-    @token = token
-    @ttl = ttl
-  end
-
-  # Pass an enum to be used to iterate all the units of work of the distributed
-  # job. The distributed job needs to know all of them to keep track of the
-  # overall number and status of the parts. Passing an enum is much better
-  # compared to pushing the parts manually, because the distributed job needs
-  # to be closed before the last part of the distributed job is enqueued into
-  # some job queue. Otherwise it could potentially happen that the last part is
-  # already processed in the job queue before it is pushed to redis, such that
-  # the last job doesn't know that the distributed job is finished.
-  #
-  # @param enum [#each_with_index] The enum which can be iterated to get all
-  #   job parts
-  #
-  # @example
-  #   distributed_job.push_each(Date.parse('2021-01-01')..Date.today) do |date, part|
-  #     # e.g. SomeBackgroundJob.perform_async(date, distributed_job.token, part)
-  #   end
-  #
-  # @example ActiveRecord
-  #   distributed_job.push_each(User.select(:id).find_in_batches) do |batch, part|
-  #     # e.g. SomeBackgroundJob.perform_async(batch.first.id, batch.last.id, distributed_job.token, part)
-  #   end
-
-  def push_each(enum)
-    return enum_for(:push_each, enum) unless block_given?
-
-    previous_object = nil
-    previous_index = nil
-
-    enum.each_with_index do |current_object, current_index|
-      push(current_index)
-
-      yield(previous_object, previous_index.to_s) if previous_index
-
-      previous_object = current_object
-      previous_index = current_index
-    end
-
-    close
-
-    yield(previous_object, previous_index.to_s) if previous_index
-  end
-
-  # Returns all pushed parts of the distributed job
-  #
-  # @return [Enumerator] The enum which allows to iterate all parts
-
-  def parts
-    redis.sscan_each("#{redis_key}:parts")
-  end
-
-  # Removes the specified part from the distributed job, i.e. from the set of
-  # unfinished parts. Use this method when the respective job part has been
-  # successfully processed, i.e. finished.
-  #
-  # @param part [String] The job part
-  # @returns [Boolean] Returns true when there are no more unfinished parts
-  #   left or false otherwise
-  #
-  # @example
-  #   class SomeBackgroundJob
-  #     def perform(whatever, token, part)
-  #       distributed_job = DistributedJob.new(redis: Redis.new, token: token)
-  #
-  #       # ...
-  #
-  #       distributed_job.done(part)
-  #     end
-  #   end
-
-  def done(part)
-    @done_script ||= <<~SCRIPT
-      local key, part, ttl = ARGV[1], ARGV[2], tonumber(ARGV[3])
-
-      if redis.call('srem', key .. ':parts', part) == 0 then return end
-
-      redis.call('expire', key .. ':parts', ttl)
-      redis.call('expire', key .. ':state', ttl)
-
-      return redis.call('scard', key .. ':parts')
-    SCRIPT
-
-    redis.eval(@done_script, argv: [redis_script_key, part.to_s, ttl]) == 0 && closed?
-  end
-
-  # Returns the total number of pushed parts, no matter if finished or not.
-  #
-  # @example
-  #   distributed_job.total # => e.g. 13
-
-  def total
-    redis.hget("#{redis_key}:state", 'total').to_i
-  end
-
-  # Returns the number of pushed parts which are not finished.
-  #
-  # @example
-  #   distributed_job.count # => e.g. 8
-
-  def count
-    redis.scard("#{redis_key}:parts")
-  end
-
-  # Returns true if there are no more unfinished parts.
-  #
-  # @example
-  #   distributed_job.finished? #=> true/false
-
-  def finished?
-    closed? && count.zero?
-  end
-
-  # Allows to stop a distributed job. This is useful if some error occurred in
-  # some part, i.e. background job, of the distributed job and you then want to
-  # stop all other not yet finished parts. Please note that only jobs can be
-  # stopped which ask the distributed job actively whether or not it was
-  # stopped.
-  #
-  # @returns [Boolean] Always returns true
-  #
-  # @example
-  #   class SomeBackgroundJob
-  #     def perform(whatever, token, part)
-  #       distributed_job = DistributedJob.new(redis: Redis.new, token: token)
-  #
-  #       return if distributed_job.stopped?
-  #
-  #       # ...
-  #
-  #       distributed_job.done(part)
-  #     rescue
-  #       distributed_job.stop
-  #
-  #       raise
-  #     end
-  #   end
-
-  def stop
-    redis.multi do
-      redis.hset("#{redis_key}:state", 'stopped', 1)
-
-      redis.expire("#{redis_key}:state", ttl)
-      redis.expire("#{redis_key}:parts", ttl)
-    end
-
-    true
-  end
-
-  # Returns true when the distributed job was stopped or false otherwise.
-  #
-  # @returns [Boolean] Returns true or false
-  #
-  # @example
-  #   class SomeBackgroundJob
-  #     def perform(whatever, token, part)
-  #       distributed_job = DistributedJob.new(redis: Redis.new, token: token)
-  #
-  #       return if distributed_job.stopped?
-  #
-  #       # ...
-  #
-  #       distributed_job.done(part)
-  #     rescue
-  #       distributed_job.stop
-  #
-  #       raise
-  #     end
-  #   end
-
-  def stopped?
-    redis.hget("#{redis_key}:state", 'stopped') == '1'
-  end
-
-  private
-
-  def close
-    redis.multi do
-      redis.hset("#{redis_key}:state", 'closed', 1)
-
-      redis.expire("#{redis_key}:state", ttl)
-      redis.expire("#{redis_key}:parts", ttl)
-    end
-
-    true
-  end
-
-  def closed?
-    redis.hget("#{redis_key}:state", 'closed') == '1'
-  end
-
-  def push(part)
-    @push_script ||= <<~SCRIPT
-      local key, part, ttl = ARGV[1], ARGV[2], tonumber(ARGV[3])
-
-      if redis.call('sadd', key .. ':parts', part) == 1 then
-        redis.call('hincrby', key .. ':state', 'total', 1)
-      end
-
-      redis.call('expire', key .. ':parts', ttl)
-      redis.call('expire', key .. ':state', ttl)
-    SCRIPT
-
-    redis.eval(@push_script, argv: [redis_script_key, part.to_s, ttl])
-  end
-
-  def redis_key
-    @redis_key ||= "distributed_jobs:#{token}"
-  end
-
-  def redis_script_key
-    return "#{redis.namespace}:#{redis_key}" if redis.respond_to?(:namespace)
-
-    redis_key
-  end
-end
+module DistributedJob; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: distributed_job
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - Benjamin Vetter
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-10-20 00:00:00.000000000 Z
+date: 2022-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.1.0
 description: Keep track of distributed jobs spanning multiple workers using redis
 email:
 - benjamin.vetter@wlw.de
@@ -63,10 +63,8 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -75,6 +73,8 @@ files:
 - distributed_job.gemspec
 - docker-compose.yml
 - lib/distributed_job.rb
+- lib/distributed_job/client.rb
+- lib/distributed_job/job.rb
 - lib/distributed_job/version.rb
 homepage: https://github.com/mrkamel/distributed_job
 licenses:
@@ -83,7 +83,7 @@ metadata:
   homepage_uri: https://github.com/mrkamel/distributed_job
   source_code_uri: https://github.com/mrkamel/distributed_job
   changelog_uri: https://github.com/mrkamel/distributed_job/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -98,8 +98,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: Keep track of distributed jobs using redis
 test_files: []

data/.travis.yml

@@ -1,6 +0,0 @@
----
-language: ruby
-cache: bundler
-rvm:
-  - 2.6.6
-before_install: gem install bundler -v 2.1.4

data/Gemfile.lock

@@ -1,57 +0,0 @@
-PATH
-  remote: .
-  specs:
-    distributed_job (1.0.0)
-      redis
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    ast (2.4.2)
-    diff-lcs (1.4.4)
-    parallel (1.21.0)
-    parser (3.0.2.0)
-      ast (~> 2.4.1)
-    rainbow (3.0.0)
-    rake (12.3.3)
-    redis (4.5.1)
-    regexp_parser (2.1.1)
-    rexml (3.2.5)
-    rspec (3.10.0)
-      rspec-core (~> 3.10.0)
-      rspec-expectations (~> 3.10.0)
-      rspec-mocks (~> 3.10.0)
-    rspec-core (3.10.1)
-      rspec-support (~> 3.10.0)
-    rspec-expectations (3.10.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.10.0)
-    rspec-mocks (3.10.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.10.0)
-    rspec-support (3.10.2)
-    rubocop (1.22.1)
-      parallel (~> 1.10)
-      parser (>= 3.0.0.0)
-      rainbow (>= 2.2.2, < 4.0)
-      regexp_parser (>= 1.8, < 3.0)
-      rexml
-      rubocop-ast (>= 1.12.0, < 2.0)
-      ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.12.0)
-      parser (>= 3.0.1.1)
-    ruby-progressbar (1.11.0)
-    unicode-display_width (2.1.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  distributed_job!
-  rake (~> 12.0)
-  rspec (~> 3.0)
-  rubocop
-
-BUNDLED WITH
-   2.1.4