distributed_job 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d9474eeee925618320f8a541274a66b68c20648a6ab7e33bd1cc302e97108e9
-  data.tar.gz: d2cf52dc713aca183eda21d4022001533e35d7846fa3fcf76aee9434cbe21089
+  metadata.gz: 62f2efef7acceccdd2dc3339969cb9eed235f5e8df8367cdb88ddafdf00bc386
+  data.tar.gz: 90c9eb945bc7a3b0f4ec7526e2c87b953a866f7ea56972ecfe01dc296c325516
 SHA512:
-  metadata.gz: 5a4e788012c9b9c3bf9afe5d20a3ff835c0260aeca0e90bffd9de80441fb342ca1a30550baf974bbb5efcd85707c31e10b187e4281eab65a1f111cfcd4de6817
-  data.tar.gz: ce00582676f135a1a11f92f59e7cf50147b7ac1ddb8427368d1dc0b7095e40d047a6ef662f5ecf5e1c765acf64c8783bcb7a4e1d8b821d7b74b91adbd19b290b
+  metadata.gz: 7e919014940a31859cf709a00f1be04d8b4cc015f7cd068808645474687c47ca55f77f4c5b608f511137a7c3c5c1fefca1a8c99989ca51f911f4fd9d893b6c50
+  data.tar.gz: d02553e6c36caffdfdfa78940ccfdce1478a41e4750facee08b5829540b362582fb740e6cc612f853b545ed73e69ebfbbb1e7480d756c4a2fd4da4889962909b

data/.gitignore

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

data/.rubocop.yml

@@ -17,3 +17,6 @@ Style/Documentation:
 
 Style/NumericPredicate:
   Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 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

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
-  distributed_job = DistributedJob.new(redis: Redis.new, token: SecureRandom.hex)
+  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 = 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)
@@ -44,13 +59,13 @@ 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 be used to keep query the status of the distributed job, e.g.
+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
@@ -58,14 +73,14 @@ 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?
 
@@ -85,10 +100,18 @@ 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. 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.
+
+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/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,281 @@
+# 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?
+  #
+  #       # ...
+  #
+  #       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 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
+        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 = 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
+        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_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 = '2.0.0'
+module DistributedJob
+  VERSION = '3.0.0'
 end

data/lib/distributed_job.rb

@@ -1,273 +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)
-    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 = 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: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Benjamin Vetter
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-10-20 00:00:00.000000000 Z
+date: 2021-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -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:

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 (2.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