joblin 0.1.0

data/lib/joblin/uniqueness/strategy/until_and_while_executing.rb

@@ -0,0 +1,35 @@
+module Joblin::Uniqueness
+  module Strategy
+    # Implements two locks - one while enqueued and one while performing
+    class UntilAndWhileExecuting < Base
+      locks_on :enqueue, :perform
+
+      def on_enqueue
+        # Obtain lock
+        lock!(:enqueue)
+
+        # Proceed with enqueuing the job, wrapping it in a batch
+        runtime_lock.on_enqueue do
+          yield
+        end
+      end
+
+      def on_perform
+        # Obtain Runtime lock
+        runtime_lock.on_perform do
+          # Release Queue lock
+          unlock()
+
+          # Run the job
+          yield
+        end
+      end
+
+      private
+
+      def runtime_lock
+        @runtime_lock ||= Strategy::WhileExecuting.new(lock_context)
+      end
+    end
+  end
+end

data/lib/joblin/uniqueness/strategy/until_executed.rb

@@ -0,0 +1,20 @@
+module Joblin::Uniqueness
+  module Strategy
+    class UntilExecuted < Base
+      locks_on :enqueue, :perform
+
+      def on_enqueue
+        lock!(:enqueue)
+
+        wrap_in_batch do
+          yield
+        end
+      end
+
+      def on_perform
+        lock!(:perform)
+        yield
+      end
+    end
+  end
+end

data/lib/joblin/uniqueness/strategy/until_executing.rb

@@ -0,0 +1,20 @@
+module Joblin::Uniqueness
+  module Strategy
+    class UntilExecuting < Base
+      locks_on :enqueue
+
+      def on_enqueue
+        lock!(:enqueue)
+        yield
+      end
+
+      def on_perform
+        unlock
+        yield
+      end
+
+      # TODO Define behavior when an error occurs during perform().
+      # SUJ's behavior is to relock, but this has some edge-cases (like how do we handle if another job already took the lock?)
+    end
+  end
+end

data/lib/joblin/uniqueness/strategy/until_expired.rb

@@ -0,0 +1,16 @@
+module Joblin::Uniqueness
+  module Strategy
+    class UntilExpired < UntilExecuted
+      locks_on :enqueue, :perform
+
+      def on_enqueue
+        lock!(:enqueue)
+        yield
+      end
+
+      def on_perform
+        lock!(:perform)
+      end
+    end
+  end
+end

data/lib/joblin/uniqueness/strategy/while_executing.rb

@@ -0,0 +1,26 @@
+module Joblin::Uniqueness
+  module Strategy
+    class WhileExecuting < Base
+      locks_on :perform
+
+      RUN_SUFFIX = ":RUN"
+
+      def on_enqueue
+        wrap_in_batch do
+          yield
+        end
+      end
+
+      def on_perform
+        lock!(:perform)
+        yield
+      end
+
+      protected
+
+      def key
+        super + RUN_SUFFIX
+      end
+    end
+  end
+end

data/lib/joblin/uniqueness/strategy.rb

@@ -0,0 +1,27 @@
+module Joblin::Uniqueness
+  module Strategy
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+
+    autoload :UntilExpired
+    autoload :UntilExecuted
+    autoload :UntilExecuting
+    autoload :UntilAndWhileExecuting
+    autoload :WhileExecuting
+
+    class << self
+      def lookup(strategy)
+        matching_strategy(strategy.to_s.camelize) ||
+          Joblin::Uniqueness.config.lock_strategies[strategy] ||
+          raise(ArgumentError, "strategy: #{strategy} is not found. Is it declared in the configuration?")
+      end
+
+      private
+
+      def matching_strategy(const)
+        const_get(const, false) if const_defined?(const, false)
+      end
+    end
+  end
+end

data/lib/joblin/uniqueness/unique_job_common.rb

@@ -0,0 +1,79 @@
+
+module Joblin::Uniqueness
+  module UniqueJobCommon
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :unique_job_options, instance_writer: false
+    end
+
+    class_methods do
+      # ensure_uniqueness(
+      #   strategy: :until_executed, # :until_executed, :until_executing, :until_expired, :until_and_while_executing, :while_executing
+      #   on_conflict: :raise, # :raise, :log, :reject, :reschedule, { enqueue: ..., perform: ... }, proc
+      #   lock_ttl: 7.days, # seconds
+      #   lock_timeout: 0, # seconds
+
+      #   scope: :per_queue, # :global, :per_queue, string ("<class>-<queue>"), proc
+      #   hash: ->{ { ... } },
+
+      #   # In the case of UntilExecuted and WhileExecuting, how should the execution lock be released in an error condition?
+      #   #  :any - Release the lock when the Job's (implicit) Batch is :complete
+      #   #  :death - Release the lock when the Job's Batch receives the :death callback
+      #   #  :stagnant - Release the lock when the Job's Batch receives the :stagnant callback
+      #   #  :expire - Do not release the lock until it expires
+      #   unlock_on_failure: :stagnant,
+      # )
+      def ensure_uniqueness(**kwargs)
+        if self.unique_job_options.present?
+          raise ArgumentError, "ensure_uniqueness can only be called once per job class"
+        end
+
+        begin
+          require "sidekiq_unique_jobs"
+        rescue LoadError
+          raise LoadError, "sidekiq-unique-jobs is required for ensure_uniqueness"
+        end
+
+        OnConflict.validate!(kwargs[:on_conflict], kwargs[:strategy]) if kwargs[:on_conflict].present?
+
+        kwargs[:scope] ||= :per_queue
+        kwargs[:ttl] ||= 30.days.to_i
+        kwargs[:timeout] ||= 0
+        kwargs[:limit] ||= 1
+
+        self.unique_job_options = kwargs
+
+        include UniqueJobMethods
+      end
+    end
+
+    module UniqueJobMethods
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def unlock!(jid = nil, args: nil, kwargs: nil, queue: nil)
+          queue = self.try(:default_queue_name) || try(:queue)
+          raise ArgumentError, "Must specify queue:" unless queue.is_a?(String) || queue.is_a?(Symbol)
+
+          temp_context = LockContext.new({ job_clazz: self, jid: jid, queue: queue, args: args, kwargs: kwargs })
+          strategy = temp_context.lock_strategy
+          locksmith = strategy.send(:locksmith)
+
+          if jid
+            locksmith.unlock!()
+          else
+            locksmith.locked_jids.each do |jid|
+              unlock!(jid, args: args, kwargs: kwargs, queue: queue)
+            end
+          end
+        end
+
+        # def unlock_all!(queue: :all)
+        #   # TODO Public API to manually remove all locks for this class
+        # end
+      end
+
+    end
+  end
+end

data/lib/joblin/version.rb

@@ -0,0 +1,3 @@
+module Joblin
+  VERSION = "0.1.0".freeze
+end

data/lib/joblin.rb

@@ -0,0 +1,37 @@
+
+require "active_support"
+require "active_support/core_ext"
+require "active_support/lazy_load_hooks"
+
+require "rediconn"
+
+require "joblin/engine"
+
+require "joblin/lazy_access"
+require "joblin/batching/batch"
+require "joblin/uniqueness/job_uniqueness"
+
+module Joblin
+  Batch = Joblin::Batching::Batch
+
+  ActiveSupport.on_load(:active_record) do
+  end
+
+  class << self
+    def redis_pool
+      require 'rediconn'
+      @redis_pool ||= RediConn::RedisConnection.create(env_prefix: "BEARCAT")
+    end
+
+    def redis(&blk)
+      redis_pool.lazy_with(&blk)
+    end
+
+    def logger
+      return @logger if defined? @logger
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::WARN
+      @logger
+    end
+  end
+end