operationable 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ddf02b693334196d4ea8e365bfdaa0959336836
-  data.tar.gz: 9197bf207f0f242669cb049d39d6184135f96be4
+  metadata.gz: 8b18274511419a5544c45629e90002fa62e716ef
+  data.tar.gz: 00835b124deae21aa613dc9afb568d40fab14a85
 SHA512:
-  metadata.gz: fd9773af6e30769ed6b6b794f39e1cad32ce3c68b7610c62ca7ebb905e059d8fb48d48925d70363ce05f211c3f479cdd333d5dc4aefda14cea1d13e64503f052
-  data.tar.gz: 9f55de492294bf5c22c9eaeb27c538757fef8cae4e01022928d0fb7c9ab446ca84a8ef3e66ccc8f004561a78f9e4dfb3c6221b701e951a8076076ac26d239640
+  metadata.gz: ba9e5eecb9fefe67536e074b2dacdbe2dcf2b55f9013571670a74ebc1654f503e759658ea0adce124e026cab4a5e55bc415c1fe4eb89e4a6e628c4a29f2d0bb7
+  data.tar.gz: aa36fdabae4857d160e744be4198429f0e0b9ace7c8447c79934d0ae3a7a782aec9a12a0b2e0337381685036ebd7753d5d0849e4220ad95fec3266fb649dbc47

data/Gemfile

@@ -2,4 +2,6 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem "rails", ">= 4.2.0"
+gem 'rails', '>= 4.2.0'
+gem 'resque-status', '>= 0.5.0'
+gem 'resque', '1.25.0'

data/lib/jobs/operation_job.rb

@@ -1,14 +1,29 @@
 # frozen_string_literal: true
 class OperationJob < ActiveJob::Base
+  include Operationable::Status
+  # include Operationable::Persister
+
   queue_as do
-    arguments.first[:queue]
+    arguments.first[:q_options][:queue]
+  end
+
+  after_enqueue do |job|
+    create_status_hash(job)
   end
 
-  def perform(options, props)
-    "Operationable::Runners::#{options[:type].capitalize}".constantize.call(options, props)
+  around_perform do |job, block|
+    safe_perform(job, block)
   end
 
-  after_perform do
+  after_perform :clear_runtime
+
+  def perform(q_options:, props:)
+    "Operationable::Runners::#{q_options[:type].capitalize}".constantize.call(q_options: q_options, props: props)
+  end
+
+  private
+
+  def clear_runtime
     ActiveRecord::Base.clear_active_connections!
     GC.start
   end

data/lib/models/operation.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# == Schema Information
+#
+# Table name: operations
+#
+#  id           :integer          not null, primary key
+#  name         :string
+#  initiator_id :integer
+#  params       :json
+#  callbacks    :json
+#  created_at   :datetime         not null
+#  updated_at   :datetime         not null
+#
+
+class Operation < ActiveRecord::Base
+end

data/lib/operationable.rb

@@ -1,20 +1,27 @@
 require 'rails'
+require 'active_job'
+require 'active_record'
 require 'active_support/dependencies'
+require 'forwardable'
+require 'resque'
+require 'resque-status'
 
 require "operationable/version"
-
 require 'operationable/builder'
 require 'operationable/callback'
 require 'operationable/operation'
 require 'operationable/serializer'
 require 'operationable/specification'
 require 'operationable/persister'
+require 'operationable/status'
 
 require 'operationable/runners/base'
 require 'operationable/runners/serial'
 require 'operationable/runners/separate'
 
 require 'jobs/operation_job'
+require 'models/operation'
+
 require 'operations/create'
 require 'operations/destroy'
 require 'operations/update'
@@ -25,6 +32,5 @@ module Operationable
     class Callback < ::Operationable::Callback; end
     class Specification < ::Operationable::Specification; end
     class Serializer < ::Operationable::Serializer; end
-    class Persister < ::Operationable::Persister; end
   end
 end

data/lib/operationable/persister.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 module Operationable
-  class Persister
+  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(

data/lib/operationable/runners/base.rb

@@ -12,20 +12,41 @@ module Operationable
         @callbacks = []
 
         initialize_callbacks
+      end
+
+      def check_status?
+        true
+      end
 
-        # TODO: No sense, due to performance deterioration, better use postgres/mysql database
-        # persist_operation
+      def persist?
+        true
       end
 
       def run
       end
 
-      private
+      def ensure_enqueue
+
+      end
+
+      def job_method
+        "#{job_class}".constantize.method(perform_method)
+      end
+
+      def job_class
+        'OperationJob'
+      end
 
-      def persist_operation
-        @persist_operation ||= ::Operationable::Persister.persist(check_callbacks, user.id, props, operation_class_name)
+      def job_sync_execute_method
+        :perform_now
       end
 
+      def job_async_execute_method
+        :perform_later
+      end
+
+      private
+
       def props
         serializer_instance.serialize
       end
@@ -87,7 +108,7 @@ module Operationable
       end
 
       def perform_method
-        sync? ? :perform_now : :perform_later
+        sync? ? job_sync_execute_method : job_async_execute_method
       end
 
       def sync?

data/lib/operationable/runners/separate.rb

@@ -7,10 +7,13 @@ module Operationable
       end
 
       def process(callback_method_name:, queue: nil)
-        (queue.blank? ? self.class : OperationJob.method(perform_method)).call(options(callback_method_name, queue), props)
+        (queue.blank? ? self.class : job_method).call(
+          q_options: q_options(callback_method_name, queue),
+          props: props
+        )
       end
 
-      def options(callback_method_name, queue)
+      def q_options(callback_method_name, queue)
         { type: 'separate',
           callback_class_name: callback_class_name,
           callback_method_name: callback_method_name,
@@ -18,17 +21,16 @@ module Operationable
           op_id: persist_operation.id }
       end
 
-      def self.call(options, props)
-        options[:callback_class_name].constantize.new(props).method(options[:callback_method_name]).call
+      def self.call(q_options:, props:)
+        q_options[:callback_class_name].constantize.new(props).method(q_options[:callback_method_name]).call
       end
 
       # TODO: No sense, due to performance deterioration, better use postgres/mysql database
-      # def self.call(options, props)
-      #   ::Operationable::Persister.around_call(options[:op_id], options[:callback_method_name], -> {
-      #     options[:callback_class_name].constantize.new(props).method(options[:callback_method_name]).call
+      # def self.call(q_options, props)
+      #   ::Operationable::Persister.around_call(q_options[:op_id], q_options[:callback_method_name], -> {
+      #     q_options[:callback_class_name].constantize.new(props).method(q_options[:callback_method_name]).call
       #   })
       # end
-
     end
   end
 end

data/lib/operationable/runners/serial.rb

@@ -7,26 +7,29 @@ module Operationable
       end
 
       def process
-        (queue.blank? ? self.class : OperationJob.method(perform_method)).call(options, props)
+        (queue.blank? ? self.class : job_method).call(
+          q_options: q_options,
+          props: props
+        )
       end
 
-      def self.call(options, props)
-        instance = options[:callback_class_name].constantize.new(props)
-        options[:callback_names].each { |method_name| instance.method(method_name).call }
+      def self.call(q_options:, props:)
+        instance = q_options[:callback_class_name].constantize.new(props)
+        q_options[:callback_names].each { |method_name| instance.method(method_name).call }
       end
 
       # TODO: No sense, due to performance deterioration, better use postgres/mysql database
-      # def self.call(options, props)
-      #   instance = options[:callback_class_name].constantize.new(props)
+      # def self.call(q_options, props)
+      #   instance = q_options[:callback_class_name].constantize.new(props)
       #
-      #   options[:callback_names].each do |method_name|
-      #     ::Operationable::Persister.around_call(options[:op_id], method_name, -> {
+      #   q_options[:callback_names].each do |method_name|
+      #     ::Operationable::Persister.around_call(q_options[:op_id], method_name, -> {
       #       instance.method(method_name).call
       #     })
       #   end
       # end
 
-      def options
+      def q_options
         { type: 'serial',
           callback_class_name: callback_class_name,
           callback_names: callback_names,

data/lib/operationable/status.rb

@@ -0,0 +1,145 @@
+# 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

data/lib/operationable/version.rb

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

data/operationable.gemspec

@@ -23,6 +23,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.1.0'
 
   spec.add_dependency             'activejob', '>= 4.2.0'
+  spec.add_dependency             'resque-status', '>= 0.5.0'
+  spec.add_dependency             'resque', '1.25.0'
 
   spec.add_development_dependency "bundler", "~> 1.13"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: operationable
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors:
 - Kirill Suhodolov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-10 00:00:00.000000000 Z
+date: 2017-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -25,6 +25,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: resque-status
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.25.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.25.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -86,6 +114,7 @@ files:
 - bin/console
 - bin/setup
 - lib/jobs/operation_job.rb
+- lib/models/operation.rb
 - lib/operationable.rb
 - lib/operationable/builder.rb
 - lib/operationable/callback.rb
@@ -96,6 +125,7 @@ files:
 - 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