operationable 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8b18274511419a5544c45629e90002fa62e716ef
-  data.tar.gz: 00835b124deae21aa613dc9afb568d40fab14a85
+  metadata.gz: 2acea623e67938b58cb568d705062a86d5005ce2
+  data.tar.gz: 6145faa763a9fe92e19852bf5bb91c2d95c4bb11
 SHA512:
-  metadata.gz: ba9e5eecb9fefe67536e074b2dacdbe2dcf2b55f9013571670a74ebc1654f503e759658ea0adce124e026cab4a5e55bc415c1fe4eb89e4a6e628c4a29f2d0bb7
-  data.tar.gz: aa36fdabae4857d160e744be4198429f0e0b9ace7c8447c79934d0ae3a7a782aec9a12a0b2e0337381685036ebd7753d5d0849e4220ad95fec3266fb649dbc47
+  metadata.gz: ef5a0e1e38e6978caa2f72d63ec45305ae6d39721957d841d20921459ca310d9018ea8de5a03e472f6dd8fdd7833d15e87c3ddeeb693850513da264e520cce72
+  data.tar.gz: e2bbd17615a9a4285b9be47939d6d73a4386f311f29387e50db200bfa0490724062193c411c5ecec6d65f8c25e442532136acde3bc307ff74e0b1aadd103a8ea

data/lib/jobs/operation_job.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 class OperationJob < ActiveJob::Base
-  include Operationable::Status
+  include Operationable::Persisters::Memory
   # include Operationable::Persister
 
   queue_as do

data/lib/operationable.rb

@@ -12,8 +12,10 @@ require 'operationable/callback'
 require 'operationable/operation'
 require 'operationable/serializer'
 require 'operationable/specification'
-require 'operationable/persister'
-require 'operationable/status'
+
+require 'operationable/persisters/base'
+require 'operationable/persisters/database'
+require 'operationable/persisters/memory'
 
 require 'operationable/runners/base'
 require 'operationable/runners/serial'

data/lib/operationable/persisters/base.rb

@@ -0,0 +1,20 @@
+module Operationable
+  module Persisters
+    module Base
+      STATUS_INIT = 'init'
+      STATUS_QUEUED = 'queued'
+      STATUS_WORKING = 'working'
+      STATUS_COMPLETED = 'completed'
+      STATUS_FAILED = 'failed'
+      STATUS_KILLED = 'killed'
+      STATUSES = [
+        STATUS_INIT,
+        STATUS_QUEUED,
+        STATUS_WORKING,
+        STATUS_COMPLETED,
+        STATUS_FAILED,
+        STATUS_KILLED
+      ].freeze
+    end
+  end
+end

data/lib/operationable/persisters/database.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Operationable
+  module Persisters
+    module Database
+      class << self
+        def persist(callbacks, initiator_id, params, name)
+          ::Operation.create(
+          callbacks: callbacks.map { |callback|
+            {
+              status: Operationable::Persisters::Base::STATUS_INIT,
+              name: callback[:callback_method_name],
+              queue: callback[:queue]
+            }
+          },
+          initiator_id: initiator_id,
+          params: params,
+          name: name
+          )
+        end
+
+        def working(id, name)
+          update(id, name, Operationable::Persisters::Base::STATUS_WORKING)
+        end
+
+        def completed(id, name)
+          update(id, name, Operationable::Persisters::Base::STATUS_COMPLETED)
+        end
+
+        def around_call(id, name, block)
+          working(id, name)
+          block.call
+          completed(id, name)
+        end
+
+        private
+
+        def update(id, name, status)
+          op = ::Operation.find(id)
+          callbacks = op.callbacks.map do |cb|
+            cb['status'] = status if cb['name'] === name
+            cb
+          end
+
+          op.callbacks = callbacks
+          op.save
+        end
+      end
+    end
+  end
+end

data/lib/operationable/persisters/memory.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+# codebase has been taken from abandoned resque-status gem, that not compatible with ActiveJob and Rails now
+module Operationable
+  module Persisters
+    module Memory
+      extend Forwardable
+      extend ActiveSupport::Concern
+
+      autoload :Hash, 'resque/plugins/status/hash'
+
+      # The error class raised when a job is killed
+      class Killed < RuntimeError; end
+      class NotANumber < RuntimeError; end
+
+      attr_reader :uuid, :options
+
+      def create_status_hash(job)
+        Resque::Plugins::Status::Hash.create(self.job_id, arguments.first)
+      end
+
+      def uuid
+        self.job_id
+      end
+
+      def options
+        arguments.first
+      end
+
+      # Run by the Resque::Worker when processing this job. It wraps the <tt>perform</tt>
+      # method ensuring that the final status of the job is set regardless of error.
+      # If an error occurs within the job's work, it will set the status as failed and
+      # re-raise the error.
+      def safe_perform(job, block)
+        working
+
+        block.call
+
+        if status && status.failed?
+          on_failure(status.message) if respond_to?(:on_failure)
+          return
+        elsif status && !status.completed?
+          completed
+        end
+        on_success if respond_to?(:on_success)
+      rescue Killed
+        Resque::Plugins::Status::Hash.killed(uuid)
+        on_killed if respond_to?(:on_killed)
+      rescue => e
+        failed("The task failed because of an error: #{e}")
+        if respond_to?(:on_failure)
+          on_failure(e)
+        else
+          raise e
+        end
+      end
+
+      # Set the jobs status. Can take an array of strings or hashes that are merged
+      # (in order) into a final status hash.
+      def status=(new_status)
+        Resque::Plugins::Status::Hash.set(uuid, *new_status)
+      end
+
+      # get the Resque::Plugins::Status::Hash object for the current uuid
+      def status
+        Resque::Plugins::Status::Hash.get(uuid)
+      end
+
+      def name
+        "#{self.class.name}(#{options.inspect unless options.empty?})"
+      end
+
+      # Checks against the kill list if this specific job instance should be killed
+      # on the next iteration
+      def should_kill?
+        Resque::Plugins::Status::Hash.should_kill?(uuid)
+      end
+
+      # set the status of the job for the current itteration. <tt>num</tt> and
+      # <tt>total</tt> are passed to the status as well as any messages.
+      # This will kill the job if it has been added to the kill list with
+      # <tt>Resque::Plugins::Status::Hash.kill()</tt>
+      def at(num, total, *messages)
+        if total.to_f <= 0.0
+          raise(NotANumber, "Called at() with total=#{total} which is not a number")
+        end
+        tick({
+          'num' => num,
+          'total' => total
+        }, *messages)
+      end
+
+      def working
+        set_status({'status' => Operationable::Persisters::Base::STATUS_WORKING})
+      end
+
+      # sets the status of the job for the current itteration. You should use
+      # the <tt>at</tt> method if you have actual numbers to track the iteration count.
+      # This will kill the job if it has been added to the kill list with
+      # <tt>Resque::Plugins::Status::Hash.kill()</tt>
+      def tick(*messages)
+        kill! if should_kill?
+        set_status({'status' => Operationable::Persisters::Base::STATUS_WORKING}, *messages)
+      end
+
+      # set the status to 'failed' passing along any additional messages
+      def failed(*messages)
+        set_status({'status' => Operationable::Persisters::Base::STATUS_FAILED}, *messages)
+      end
+
+      # set the status to 'completed' passing along any addional messages
+      def completed(*messages)
+        set_status({
+          'status' => Operationable::Persisters::Base::STATUS_COMPLETED,
+          'message' => "Completed at #{Time.now}"
+        }, *messages)
+      end
+
+      # kill the current job, setting the status to 'killed' and raising <tt>Killed</tt>
+      def kill!
+        set_status({
+          'status' => Operationable::Persisters::Base::STATUS_KILLED,
+          'message' => "Killed at #{Time.now}"
+        })
+        raise Killed
+      end
+
+      private
+
+      def set_status(*args)
+        self.status = [status, {'name'  => self.name}, args].flatten
+      end
+    end
+  end
+end

data/lib/operationable/runners/base.rb

@@ -14,6 +14,10 @@ module Operationable
         initialize_callbacks
       end
 
+      def persist_operation
+        @persist_operation ||= ::Operationable::Persisters::Database.persist(check_callbacks, user.id, props, operation_class_name)
+      end
+
       def check_status?
         true
       end

data/lib/operationable/version.rb

@@ -1,3 +1,3 @@
 module Operationable
-  VERSION = "0.2.7"
+  VERSION = "0.2.8"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: operationable
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Kirill Suhodolov
@@ -119,13 +119,14 @@ files:
 - lib/operationable/builder.rb
 - lib/operationable/callback.rb
 - lib/operationable/operation.rb
-- lib/operationable/persister.rb
+- lib/operationable/persisters/base.rb
+- lib/operationable/persisters/database.rb
+- lib/operationable/persisters/memory.rb
 - lib/operationable/runners/base.rb
 - lib/operationable/runners/separate.rb
 - lib/operationable/runners/serial.rb
 - lib/operationable/serializer.rb
 - lib/operationable/specification.rb
-- lib/operationable/status.rb
 - lib/operationable/version.rb
 - lib/operations/create.rb
 - lib/operations/destroy.rb

data/lib/operationable/persister.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-module Operationable
-  module Persister    
-    def persist_operation
-      @persist_operation ||= ::Operationable::Persister.persist(check_callbacks, user.id, props, operation_class_name)
-    end
-
-    class << self
-      def persist(callbacks, initiator_id, params, name)
-        ::Operation.create(
-          callbacks: callbacks.map { |callback|
-            {
-              status: ::Operation::STATUS_INIT,
-              name: callback[:callback_method_name],
-              queue: callback[:queue]
-            }
-          },
-          initiator_id: initiator_id,
-          params: params,
-          name: name
-        )
-      end
-
-      def working(id, name)
-        update(id, name, ::Operation::STATUS_WORKING)
-      end
-
-      def completed(id, name)
-        update(id, name, ::Operation::STATUS_COMPLETED)
-      end
-
-      def around_call(id, name, block)
-        working(id, name)
-        block.call
-        completed(id, name)
-      end
-
-      private
-
-      def update(id, name, status)
-        op = ::Operation.find(id)
-        callbacks = op.callbacks.map do |cb|
-          cb['status'] = status if cb['name'] === name
-          cb
-        end
-
-        op.callbacks = callbacks
-        op.save
-      end
-    end
-  end
-end

data/lib/operationable/status.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-# codebase has been taken from abandoned resque-status gem, that not compatible with ActiveJob and Rails now
-module Operationable
-  module Status
-    extend Forwardable
-    extend ActiveSupport::Concern
-
-    STATUS_QUEUED = 'queued'
-    STATUS_WORKING = 'working'
-    STATUS_COMPLETED = 'completed'
-    STATUS_FAILED = 'failed'
-    STATUS_KILLED = 'killed'
-    STATUSES = [
-      STATUS_QUEUED,
-      STATUS_WORKING,
-      STATUS_COMPLETED,
-      STATUS_FAILED,
-      STATUS_KILLED
-    ].freeze
-
-    autoload :Hash, 'resque/plugins/status/hash'
-
-    # The error class raised when a job is killed
-    class Killed < RuntimeError; end
-    class NotANumber < RuntimeError; end
-
-    attr_reader :uuid, :options
-
-    def create_status_hash(job)
-      Resque::Plugins::Status::Hash.create(self.job_id, arguments.first)
-    end
-
-    def uuid
-      self.job_id
-    end
-
-    def options
-      arguments.first
-    end
-
-    # Run by the Resque::Worker when processing this job. It wraps the <tt>perform</tt>
-    # method ensuring that the final status of the job is set regardless of error.
-    # If an error occurs within the job's work, it will set the status as failed and
-    # re-raise the error.
-    def safe_perform(job, block)
-      working
-
-      block.call
-
-      if status && status.failed?
-        on_failure(status.message) if respond_to?(:on_failure)
-        return
-      elsif status && !status.completed?
-        completed
-      end
-      on_success if respond_to?(:on_success)
-    rescue Killed
-      Resque::Plugins::Status::Hash.killed(uuid)
-      on_killed if respond_to?(:on_killed)
-    rescue => e
-      failed("The task failed because of an error: #{e}")
-      if respond_to?(:on_failure)
-        on_failure(e)
-      else
-        raise e
-      end
-    end
-
-    # Set the jobs status. Can take an array of strings or hashes that are merged
-    # (in order) into a final status hash.
-    def status=(new_status)
-      Resque::Plugins::Status::Hash.set(uuid, *new_status)
-    end
-
-    # get the Resque::Plugins::Status::Hash object for the current uuid
-    def status
-      Resque::Plugins::Status::Hash.get(uuid)
-    end
-
-    def name
-      "#{self.class.name}(#{options.inspect unless options.empty?})"
-    end
-
-    # Checks against the kill list if this specific job instance should be killed
-    # on the next iteration
-    def should_kill?
-      Resque::Plugins::Status::Hash.should_kill?(uuid)
-    end
-
-    # set the status of the job for the current itteration. <tt>num</tt> and
-    # <tt>total</tt> are passed to the status as well as any messages.
-    # This will kill the job if it has been added to the kill list with
-    # <tt>Resque::Plugins::Status::Hash.kill()</tt>
-    def at(num, total, *messages)
-      if total.to_f <= 0.0
-        raise(NotANumber, "Called at() with total=#{total} which is not a number")
-      end
-      tick({
-        'num' => num,
-        'total' => total
-      }, *messages)
-    end
-
-    def working
-      set_status({'status' => STATUS_WORKING})
-    end
-
-    # sets the status of the job for the current itteration. You should use
-    # the <tt>at</tt> method if you have actual numbers to track the iteration count.
-    # This will kill the job if it has been added to the kill list with
-    # <tt>Resque::Plugins::Status::Hash.kill()</tt>
-    def tick(*messages)
-      kill! if should_kill?
-      set_status({'status' => STATUS_WORKING}, *messages)
-    end
-
-    # set the status to 'failed' passing along any additional messages
-    def failed(*messages)
-      set_status({'status' => STATUS_FAILED}, *messages)
-    end
-
-    # set the status to 'completed' passing along any addional messages
-    def completed(*messages)
-      set_status({
-        'status' => STATUS_COMPLETED,
-        'message' => "Completed at #{Time.now}"
-      }, *messages)
-    end
-
-    # kill the current job, setting the status to 'killed' and raising <tt>Killed</tt>
-    def kill!
-      set_status({
-        'status' => STATUS_KILLED,
-        'message' => "Killed at #{Time.now}"
-      })
-      raise Killed
-    end
-
-    private
-
-    def set_status(*args)
-      self.status = [status, {'name'  => self.name}, args].flatten
-    end
-  end
-end