background_worker 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 061e6c0338c031523b85a90f084aaf996c00cbe9e668428931a98ae3b5a12f36
-  data.tar.gz: 36304e141265bc21d2d756d2af7aab6645fbfa9596d5ab5bfe2c115132f685a8
+  metadata.gz: 6354bdc8bc64824ab09d3b2666d1bfcab6c6b02f7b5c5e2cab58902e840eaf7b
+  data.tar.gz: 49f0ffc416005df1da66eb112852dc0eb8246978f3e477fdefdccda9eef3e0f5
 SHA512:
-  metadata.gz: f799063ea369646eea2956427aa7bc0cd551229649e9e3cb1b324a8bd1edec162c7d0852dbf0c7ce724d0332c702208097c5a975827d050742c0df11e5e3709a
-  data.tar.gz: 6d4487e464251517e318fe59be864d87da48f324aabce3b6d8964971f55fa1a4a3b5dc7f66913fe6ee5654614a72d6fb978887a84829e0afe656313b6d693ca6
+  metadata.gz: 306de71726dc7d080ce55e51617e926d84cc99b7abec077381ea820e4e2434c63c023e3ed97ac60f0bd15bf230af9533fb0b411544436e9ac4099bf7e2057d15
+  data.tar.gz: f5d75d708b036479a944632f6c38a8be872125ce6c7b8459b72f3f9266a9a2c2cd027aad93a1d59d8ff82d665dec05ef9101bf61b32cc83ab10bcd70a3e214be

data/CHANGELOG.md

@@ -1,7 +1,17 @@
 # Change Log
+
 All notable changes to this project will be documented in this file.  
 This project adheres to [Semantic Versioning](http://semver.org/).  
-This changelog adheres to [Keep a CHANGELOG](http://keepachangelog.com/).  
+This changelog adheres to [Keep a CHANGELOG](http://keepachangelog.com/).
+
+## 0.9.0
+
+- [PLAT-749] Rename `uid` as `job_id` and make it a base property of job.
+- [PLAT-759] Add callbacks
+- [PLAT-761] Extract logging concern
+- [PLAT-760] Extract status concern
+- [PLAT-762] Perform now and later will return job object
+- [PLAT-780] Fix callbacks
 
 ## 0.8.1
 
@@ -32,14 +42,20 @@ This changelog adheres to [Keep a CHANGELOG](http://keepachangelog.com/).
 - [TT-6292] Support Rails 5.2 built-in redis cache, remove legacy supports
 
 ## 0.2.1
+
 ### Fixed
+
 - [RU-123] Worker disconnecting within transactions in rails 4+
 
 ## 0.2.0
+
 ### Added
+
 - [RU-79] Release connections after execution for Rails 4
 
 ## 0.1.0
+
 ### Added
+
 - [TT-1392] Changelog file
 - [TT-2141] Only verify connections for Rails 3

data/lib/background_worker/base.rb

@@ -1,91 +1,57 @@
-require 'background_worker/uid'
+require "active_support/callbacks"
 require 'background_worker/persistent_state'
 require 'background_worker/worker_execution'
+require 'background_worker/logging'
+require 'background_worker/state'
 
 module BackgroundWorker
   class Base
-    attr_accessor :uid, :state
+    include ActiveSupport::Callbacks
+    include BackgroundWorker::Logging
+    include BackgroundWorker::State
+    attr_accessor :job_id, :options
+    define_callbacks :perform
+    define_callbacks :enqueue
 
     def initialize(options = {})
-      @uid = options[:uid]
+      @options = options.symbolize_keys
+      @job_id = @options[:job_id] || SecureRandom.uuid
 
-      # Store state persistently, to enable status checkups & progress reporting
-      @state = BackgroundWorker::PersistentState.new(@uid, options.except(:uid))
       log("Created #{self.class}")
-      log("Options are: #{options.inspect}")
+      log("Options are: #{@options.inspect}")
     end
 
-    def perform
-      raise AbstractError, 'Must be implemented in Job Class'
-    end
-
-    # Report progress...
-    def report_progress(message)
-      state.message = message
-      state.save
-    end
-
-    # Report a minor progress -- may get called a lot, so don't save it so often
-    def report_minor_progress(message)
-      state.message = message
-
-      # Only report minor events once per second
-      @last_report ||= Time.now - 2
-      time_elapsed =  Time.now - @last_report
-      return unless time_elapsed > 1
-
-      @last_report = Time.now
-      state.save
-    end
-
-    def report_successful(message = 'Finished successfully')
-      state.set_completed(message, :successful)
-    end
-
-    def report_failed(message = 'Failed', detailed_message = nil)
-      state.detailed_message = detailed_message
-      state.set_completed(message, :failed)
-    end
-
-    def logger
-      BackgroundWorker.logger
+    def perform_now(options)
+      run_callbacks :perform do
+        perform(options)
+      end
     end
 
-    def log(message, options = {})
-      severity = options.fetch(:severity, :info)
-      logger.send(severity, "uid=#{uid} #{message}")
+    def enqueue(klass)
+      run_callbacks :enqueue do
+        BackgroundWorker.enqueue(klass, options.merge(job_id: job_id))
+      end
     end
 
     class << self
       attr_reader :queue
-      def get_state_of(worker_id)
-        BackgroundWorker::PersistentState.get_state_of(worker_id)
-      end
 
       # Public method to do in background...
       def perform_later(options = {})
-        opts = options.symbolize_keys
-
-        opts[:uid] ||= BackgroundWorker::Uid.new(to_s).generate
-
-        # Store into shared-cache before kicking job off
-        BackgroundWorker::PersistentState.new(opts[:uid], opts.except(:uid))
-
+        worker = new(options)
         # Enqueue to the background queue
-        BackgroundWorker.enqueue(self, opts)
-
-        opts[:uid]
+        worker.enqueue(self)
+        worker
       end
 
       # This method is called by the job runner
-      #
-      # It will just call your preferred method in the worker.
       def perform_now(options = {})
         BackgroundWorker.verify_active_connections! if BackgroundWorker.config.backgrounded
 
         worker = new(options)
         execution = WorkerExecution.new(worker, options)
         execution.call
+        worker
       ensure
         BackgroundWorker.release_connections! if BackgroundWorker.config.backgrounded
       end
@@ -93,6 +59,22 @@ module BackgroundWorker
       def queue_as(queue = nil)
         @queue = queue&.to_sym || :default
       end
+
+      def before_perform(*filters, &blk)
+        set_callback(:perform, :before, *filters, &blk)
+      end
+
+      def after_perform(*filters, &blk)
+        set_callback(:perform, :after, *filters, &blk)
+      end
+
+      def before_enqueue(*filters, &blk)
+        set_callback(:enqueue, :before, *filters, &blk)
+      end
+
+      def after_enqueue(*filters, &blk)
+        set_callback(:enqueue, :after, *filters, &blk)
+      end
     end
   end
 end

data/lib/background_worker/logging.rb

@@ -0,0 +1,16 @@
+require 'active_support/concern'
+
+module BackgroundWorker
+  module Logging
+    extend ActiveSupport::Concern
+
+    def logger
+      BackgroundWorker.logger
+    end
+
+    def log(message, options = {})
+      severity = options.fetch(:severity, :info)
+      logger.send(severity, "job_id=#{job_id} #{message}")
+    end
+  end
+end

data/lib/background_worker/persistent_state.rb

@@ -7,12 +7,12 @@ module BackgroundWorker
   class PersistentState
     attr_accessor :message, :detailed_message, :status, :completed, :data
 
-    def initialize(worker_uid, data)
+    def initialize(job_id, data)
       @message = 'Waiting for task to queue...'
       @status = :processing
       @completed = false
 
-      @worker_uid = worker_uid
+      @job_id = job_id
       @data = data
       save
     end
@@ -27,13 +27,13 @@ module BackgroundWorker
 
     # Save persistently (well for an hour at least)
     def save
-      Rails.cache.write(@worker_uid, generate_persistent_hash, expires_in: 1.hour)
+      Rails.cache.write(@job_id, generate_persistent_hash, expires_in: 1.hour)
     end
 
     # Get a report out the queue
     # (was .get_report, then .progress)
-    def self.get_state_of(worker_uid)
-      Rails.cache.read(worker_uid)
+    def self.get_state_of(job_id)
+      Rails.cache.read(job_id)
     end
 
     private

data/lib/background_worker/state.rb

@@ -0,0 +1,47 @@
+require 'active_support/concern'
+
+module BackgroundWorker
+  module State
+    extend ActiveSupport::Concern
+    attr_accessor :state
+
+    # Report progress...
+    def report_progress(message)
+      state.message = message
+      state.save
+    end
+
+    # Report a minor progress -- may get called a lot, so don't save it so often
+    def report_minor_progress(message)
+      state.message = message
+
+      # Only report minor events once per second
+      @last_report ||= Time.now - 2
+      time_elapsed =  Time.now - @last_report
+      return unless time_elapsed > 1
+
+      @last_report = Time.now
+      state.save
+    end
+
+    def report_successful(message = 'Finished successfully')
+      state.set_completed(message, :successful)
+    end
+
+    def report_failed(message = 'Failed', detailed_message = nil)
+      state.detailed_message = detailed_message
+      state.set_completed(message, :failed)
+    end
+
+    def state
+      # Store state persistently, to enable status checkups & progress reporting
+      @state ||= BackgroundWorker::PersistentState.new(job_id, @options)
+    end
+
+    module ClassMethods
+      def get_state_of(job_id)
+        BackgroundWorker::PersistentState.get_state_of(job_id)
+      end
+    end
+  end
+end

data/lib/background_worker/version.rb

@@ -1,3 +1,3 @@
 module BackgroundWorker
-  VERSION = '0.8.1'
+  VERSION = '0.9.0'
 end

data/lib/background_worker/worker_execution.rb

@@ -3,13 +3,12 @@ module BackgroundWorker
     attr_reader :worker, :method_name, :options
 
     def initialize(worker, options)
-      fail ArgumentError, "'uid' is required to identify worker" unless options[:uid].present?
       @worker = worker
       @options = options
     end
 
     def call
-      worker.perform(options)
+      worker.perform_now(options)
       report_implicitly_successful unless completed?
 
     rescue StandardError => e

data/spec/base_spec.rb

@@ -44,3 +44,51 @@ describe BackgroundWorker::Base do
     end
   end
 end
+
+describe BackgroundWorker::Base do
+  describe 'callbacks' do
+    let(:cache) { double(write: nil, read: nil, reconnect: nil, store: nil) }
+    let(:model_class) { Model = Class.new(ActiveRecord::Base) }
+
+    let(:worker_class) {
+      Class.new(BackgroundWorker::Base) do
+        def perform(opts)
+          Rails.cache.store(opts[:value])
+        end
+
+        before_perform do
+          Rails.cache.store('before_perform_action')
+        end
+
+        after_perform do
+          Rails.cache.store('after_perform_action')
+        end
+
+        before_enqueue do
+          Rails.cache.store('before_enqueue_action')
+        end
+
+        after_enqueue do
+          Rails.cache.store('after_enqueue_action')
+        end
+      end
+    }
+
+    before do
+      stub_const 'Model', model_class
+      stub_const 'Rails', double(cache: cache, env: 'production')
+      BackgroundWorker.configure(backgrounded: false)
+    end
+
+    it 'should call perform callbacks' do
+      Model.transaction do
+        worker_class.perform_later(value: 42)
+      end
+      expect(cache).to have_received(:store).with('before_enqueue_action')
+      expect(cache).to have_received(:store).with('before_perform_action')
+      expect(cache).to have_received(:store).with(42)
+      expect(cache).to have_received(:store).with('after_perform_action')
+      expect(cache).to have_received(:store).with('after_enqueue_action')
+    end
+  end
+end

data/spec/support/coverage_loader.rb

@@ -1,3 +1,3 @@
 require 'coverage/kit'
 
-Coverage::Kit.setup(minimum_coverage: 82.30)
+Coverage::Kit.setup(minimum_coverage: 84.60)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: background_worker
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Michael Noack
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-23 00:00:00.000000000 Z
+date: 2022-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -152,15 +152,15 @@ files:
 - lib/background_worker.rb
 - lib/background_worker/base.rb
 - lib/background_worker/config.rb
+- lib/background_worker/logging.rb
 - lib/background_worker/persistent_state.rb
-- lib/background_worker/uid.rb
+- lib/background_worker/state.rb
 - lib/background_worker/version.rb
 - lib/background_worker/worker_execution.rb
 - spec/base_spec.rb
 - spec/schema.rb
 - spec/spec_helper.rb
 - spec/support/coverage_loader.rb
-- spec/uid_spec.rb
 homepage: http://github.com/sealink/background_worker
 licenses:
 - MIT
@@ -189,4 +189,3 @@ test_files:
 - spec/schema.rb
 - spec/spec_helper.rb
 - spec/support/coverage_loader.rb
-- spec/uid_spec.rb

data/lib/background_worker/uid.rb

@@ -1,24 +0,0 @@
-# Generates a unique identifier for a particular job identified by class_name/method
-module BackgroundWorker
-  class Uid
-    attr_reader :class_name
-
-    def initialize(class_name)
-      @class_name = class_name
-    end
-
-    def generate
-      "#{generate_uid_name}:#{generate_uid_hash}"
-    end
-
-    private
-
-    def generate_uid_hash
-      ::Digest::MD5.hexdigest("#{class_name}:#{rand(1 << 64)}:#{Time.now}")
-    end
-
-    def generate_uid_name
-      "#{class_name.underscore}".split('/').join(':')
-    end
-  end
-end

data/spec/uid_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-describe BackgroundWorker::Uid do
-  let(:class_name) { 'CopyWorker' }
-  let(:uid_object) { BackgroundWorker::Uid.new(class_name) }
-
-  context '#generate' do
-    subject(:uid) { uid_object.generate }
-    it { is_expected.to match(/copy_worker:[0-9a-f]{16}/) }
-  end
-end