burstflow 0.2.0 → 0.2.1

data/lib/burstflow/manager.rb

@@ -1,123 +1,122 @@
 module Burstflow
-class Manager
 
-  attr_accessor :workflow
+  class Manager
 
-  def initialize(workflow)
-    @workflow = workflow
-  end
-
-  #workflow management
+    attr_accessor :workflow
 
-  def start_workflow!
-    workflow.with_lock do
-      workflow.runnig!
-
-      workflow.initial_jobs.each do |job|
-        enqueue_job!(job)
-      end
+    def initialize(workflow)
+      @workflow = workflow
     end
-  end
 
-  def resume_workflow! job_id, data
-    workflow.with_lock do
-      workflow.resumed!
+    # workflow management
+
+    def start_workflow!
+      workflow.with_lock do
+        workflow.runnig!
 
-      job = workflow.job(job_id)
-      resume_job!(job, data)
+        workflow.initial_jobs.each do |job|
+          enqueue_job!(job)
+        end
+      end
     end
-  end
 
+    def resume_workflow!(job_id, data)
+      workflow.with_lock do
+        workflow.resumed!
 
-  #Mark job enqueued and enqueue it
-  def enqueue_job!(job)
-    job.run_callbacks :enqueue do
-      job.enqueue!
-      job.save! do
-        Burstflow::Worker.perform_later(workflow.id, job.id)
+        job = workflow.job(job_id)
+        resume_job!(job, data)
       end
     end
-  end
 
-  #Enqueue job for resuming
-  def resume_job!(job, data)
-    job.save! do
-      Burstflow::Worker.perform_later(workflow.id, job.id, data)
+    # Mark job enqueued and enqueue it
+    def enqueue_job!(job)
+      job.run_callbacks :enqueue do
+        job.enqueue!
+        job.save! do
+          Burstflow::Worker.perform_later(workflow.id, job.id)
+        end
+      end
     end
-  end
 
-
-  #Mark job suspended and forget it until resume
-  def suspend_job!(job)
-    job.run_callbacks :suspend do
-      job.suspend!
+    # Enqueue job for resuming
+    def resume_job!(job, data)
       job.save! do
-        analyze_workflow_state(job)
+        Burstflow::Worker.perform_later(workflow.id, job.id, data)
       end
     end
-  end
 
-
-  #Mark job finished and make further actions 
-  def finish_job!(job)
-    job.finish!
-    job.save! do
-      analyze_workflow_state(job)
+    # Mark job suspended and forget it until resume
+    def suspend_job!(job)
+      job.run_callbacks :suspend do
+        job.suspend!
+        job.save! do
+          analyze_workflow_state(job)
+        end
+      end
     end
-  end
-
-  #Mark job failed and make further actions 
-  def fail_job!(job, exception)
-    job.run_callbacks :failure do
-      job.fail! exception
-      workflow.add_error(job)
-      workflow.save!
 
+    # Mark job finished and make further actions
+    def finish_job!(job)
+      job.finish!
       job.save! do
         analyze_workflow_state(job)
       end
-    end    
-  end
-
-  #Mark job finished or suspended depends on result or output
-  def job_performed!(job, result)
-    if result == Burstflow::Job::SUSPEND || job.output == Burstflow::Job::SUSPEND
-      suspend_job!(job)
-    else
-      finish_job!(job)
     end
-  rescue => e
-    raise Burstflow::Workflow::InternalError.new(workflow, e.message)
-  end
 
-private
+    # Mark job failed and make further actions
+    def fail_job!(job, exception)
+      job.run_callbacks :failure do
+        job.fail! exception
+        workflow.add_error(job)
+        workflow.save!
 
-  #analyze job completition, current workflow state and perform futher actions
-  def analyze_workflow_state job
-    unless ActiveRecord::Base.connection.open_transactions > 0
-      raise Burstflow::Workflow::InternalError.new(workflow, "analyze_workflow_state must be called in transaction with lock!")
+        job.save! do
+          analyze_workflow_state(job)
+        end
+      end
     end
 
-    if job.succeeded? && job.outgoing.any? && !workflow.has_errors?
-      return enqueue_outgoing_jobs(job)
-    else
-      if workflow.has_scheduled_jobs?
-        #do nothing
-        #scheduled jobs will perform finish action
+    # Mark job finished or suspended depends on result or output
+    def job_performed!(job, result)
+      if result == Burstflow::Job::SUSPEND || job.output == Burstflow::Job::SUSPEND
+        suspend_job!(job)
       else
-        workflow.complete!
+        finish_job!(job)
       end
+    rescue StandardError => e
+      raise Burstflow::Workflow::InternalError.new(workflow, e.message)
     end
-  end
 
-  #enqueue outgoing jobs if all requirements are met
-  def enqueue_outgoing_jobs(job)
-    job.outgoing.each do |job_id|
-      out = workflow.job(job_id)
+    private
+
+      # analyze job completition, current workflow state and perform futher actions
+      def analyze_workflow_state(job)
+        unless ActiveRecord::Base.connection.open_transactions > 0
+          raise Burstflow::Workflow::InternalError.new(workflow, 'analyze_workflow_state must be called in transaction with lock!')
+        end
+
+        if job.succeeded? && job.outgoing.any? && !workflow.has_errors?
+          return enqueue_outgoing_jobs(job)
+        else
+          if workflow.has_scheduled_jobs?
+            # do nothing
+            # scheduled jobs will perform finish action
+          else
+            workflow.complete!
+          end
+        end
+      end
+
+      # enqueue outgoing jobs if all requirements are met
+      def enqueue_outgoing_jobs(job)
+        job.outgoing.each do |job_id|
+          out = workflow.job(job_id)
+
+          enqueue_job!(out) if out.ready_to_start?
+        end
+      end
 
-      enqueue_job!(out) if out.ready_to_start?
-    end
   end
 
 end
-end

data/lib/burstflow/railtie.rb

@@ -1,6 +1,9 @@
-
 module Burstflow
+
   class Railtie < Rails::Engine #:nodoc:
+
     engine_name 'burstflow'
+
   end
-end
+
+end

data/lib/burstflow/version.rb

@@ -1,3 +1,5 @@
 module Burstflow
-  VERSION = '0.2.0'
+
+  VERSION = '0.2.1'.freeze
+
 end

data/lib/burstflow/worker.rb

@@ -27,33 +27,33 @@ class Burstflow::Worker < ::ActiveJob::Base
     set_incoming_payloads(job)
   end
 
-  def perform(workflow_id, job_id, resume_data = nil)
+  def perform(_workflow_id, _job_id, resume_data = nil)
     result = if resume_data.nil?
-      job.start!
-      job.save!
-  
-      job.perform_now
-    else
-      job.resume!
-      job.save!
-      
-      job.resume_now(resume_data)
+               job.start!
+               job.save!
+
+               job.perform_now
+             else
+               job.resume!
+               job.save!
+
+               job.resume_now(resume_data)
     end
 
     @manager.job_performed!(job, result)
   end
 
-private
-
-  def set_incoming_payloads job
-    job.payloads = job.incoming.map do |job_id|
-      incoming = workflow.job(job_id)
-      {
-        id: incoming.id,
-        class: incoming.klass.to_s,
-        value: incoming.output
-      }
+  private
+
+    def set_incoming_payloads(job)
+      job.payloads = job.incoming.map do |job_id|
+        incoming = workflow.job(job_id)
+        {
+          id: incoming.id,
+          class: incoming.klass.to_s,
+          value: incoming.output
+        }
+      end
     end
-  end
 
 end

data/lib/burstflow/workflow.rb

@@ -3,205 +3,213 @@ require 'active_record'
 require 'burstflow/manager'
 
 module Burstflow
-class Workflow < ActiveRecord::Base
-  require 'burstflow/workflow/exception'
-  require 'burstflow/workflow/builder'
-  require 'burstflow/workflow/configuration'
-  require 'burstflow/workflow/callbacks'
-  
-  self.table_name_prefix = 'burstflow_'
 
-  INITIAL   = 'initial'.freeze
-  RUNNING   = 'running'.freeze
-  FINISHED  = 'finished'.freeze
-  FAILED    = 'failed'.freeze
-  SUSPENDED = 'suspended'.freeze
+  class Workflow < ActiveRecord::Base
 
-  STATUSES = [INITIAL, RUNNING, FINISHED, FAILED, SUSPENDED].freeze
+    require 'burstflow/workflow/exception'
+    require 'burstflow/workflow/builder'
+    require 'burstflow/workflow/configuration'
+    require 'burstflow/workflow/callbacks'
 
-  include Burstflow::Workflow::Configuration
-  include Burstflow::Workflow::Callbacks
+    self.table_name_prefix = 'burstflow_'
 
-  attr_accessor :manager, :cache
-  define_flow_attributes :jobs_config, :failures
+    INITIAL   = 'initial'.freeze
+    RUNNING   = 'running'.freeze
+    FINISHED  = 'finished'.freeze
+    FAILED    = 'failed'.freeze
+    SUSPENDED = 'suspended'.freeze
 
-  after_initialize do
-    @cache = {}
+    STATUSES = [INITIAL, RUNNING, FINISHED, FAILED, SUSPENDED].freeze
 
-    self.status ||= INITIAL
-    self.id ||= SecureRandom.uuid
-    self.jobs_config ||= {}.with_indifferent_access
-    self.failures ||= []
+    include Burstflow::Workflow::Configuration
+    include Burstflow::Workflow::Callbacks
 
-    @manager = Burstflow::Manager.new(self)
-  end
+    attr_accessor :manager, :cache
+    define_flow_attributes :jobs_config, :failures
 
-  STATUSES.each do |name|
-    define_method "#{name}?".to_sym do
-      self.status == name
-    end
-  end
+    after_initialize do
+      @cache = {}
 
-  def attributes
-    {
-      id: self.id,
-      jobs_config: self.jobs_config,
-      type: self.class.to_s,
-      status: status,
-      failures: failures
-    }
-  end
+      self.status ||= INITIAL
+      self.id ||= SecureRandom.uuid
+      self.jobs_config ||= {}.with_indifferent_access
+      self.failures ||= []
 
-  def self.build(*args)
-    new.tap do |wf|
-      builder = Burstflow::Workflow::Builder.new(wf, *args, &configuration)
-      wf.flow = {'jobs_config' => builder.as_json}
+      @manager = Burstflow::Manager.new(self)
     end
-  end
 
-  def reload(*)
-    self.cache = {}
-    super
-  end
-
-  def start!
-    manager.start_workflow!
-    self
-  end
+    STATUSES.each do |name|
+      define_method "#{name}?".to_sym do
+        self.status == name
+      end
+    end
 
-  def resume!(job_id, data)
-    manager.resume_workflow!(job_id, data)
-    self
-  end
+    def attributes
+      {
+        id: self.id,
+        jobs_config: self.jobs_config,
+        type: self.class.to_s,
+        status: status,
+        failures: failures
+      }
+    end
 
-  def jobs
-    Enumerator.new do |y|
-      jobs_config.keys.each do |id|
-        y << job(id)
+    def self.build(*args)
+      new.tap do |wf|
+        builder = Burstflow::Workflow::Builder.new(wf, *args, &configuration)
+        wf.flow = { 'jobs_config' => builder.as_json }
       end
     end
-  end
 
-  def job_hash(id)
-    jobs_config[id].deep_dup
-  end
+    def reload(*)
+      self.cache = {}
+      super
+    end
 
-  def job(id)
-    Burstflow::Job.from_hash(self, job_hash(id))
-  end
+    def start!
+      manager.start_workflow!
+      self
+    end
 
-  def set_job(job)
-    jobs_config[job.id] = job.as_json
-  end
+    def resume!(job_id, data)
+      manager.resume_workflow!(job_id, data)
+      self
+    end
 
-  def initial_jobs
-    cache[:initial_jobs] ||= jobs.select(&:initial?)
-  end
+    def jobs
+      Enumerator.new do |y|
+        jobs_config.keys.each do |id|
+          y << job(id)
+        end
+      end
+    end
 
-  def add_error job_orexception
-    context = {
-      created_at: Time.now.to_i
-    }
-    if job_orexception.is_a?(::Exception)
-      context[:message]     = job_orexception.message
-      context[:klass]       = job_orexception.class.to_s
-      context[:backtrace]   = job_orexception.backtrace.first(10)
-      context[:cause]       = job_orexception.cause
-    else
-      context[:job] = job_orexception.id
+    def job_hash(id)
+      jobs_config[id].deep_dup
     end
 
-    failures.push(context)
-  end
+    def job(id)
+      Burstflow::Job.from_hash(self, job_hash(id))
+    end
 
-  def has_errors?
-    failures.any?
-  end
+    def set_job(job)
+      jobs_config[job.id] = job.as_json
+    end
 
-  def has_scheduled_jobs?
-    cache[:has_scheduled_jobs] ||= jobs.any? do |job|
-      job.scheduled? || (job.initial? && !job.enqueued?)
+    def initial_jobs
+      cache[:initial_jobs] ||= jobs.select(&:initial?)
     end
-  end
 
-  def has_suspended_jobs?
-    cache[:has_suspended_jobs] ||= jobs.any?(&:suspended?)
-  end
+    def add_error(job_orexception)
+      context = {
+        created_at: Time.now.to_i
+      }
+      if job_orexception.is_a?(::Exception)
+        context[:message]     = job_orexception.message
+        context[:klass]       = job_orexception.class.to_s
+        context[:backtrace]   = job_orexception.backtrace.first(10)
+        context[:cause]       = job_orexception.cause
+      else
+        context[:job] = job_orexception.id
+      end
 
-  def complete!
-    if has_errors?
-      failed!
-    elsif has_suspended_jobs?
-      suspended!
-    else
-      finished!
+      failures.push(context)
     end
-  end
 
-  def first_job
-    all_jobs.min_by{|n| n.started_at || Time.now.to_i }
-  end
+    def has_errors?
+      failures.any?
+    end
 
-  def last_job
-    all_jobs.max_by{|n| n.finished_at || 0 } if finished?
-  end
+    def has_scheduled_jobs?
+      cache[:has_scheduled_jobs] ||= jobs.any? do |job|
+        job.scheduled? || (job.initial? && !job.enqueued?)
+      end
+    end
 
-  def started_at
-    first_job&.started_at
-  end
+    def has_suspended_jobs?
+      cache[:has_suspended_jobs] ||= jobs.any?(&:suspended?)
+    end
 
-  def finished_at
-    last_job&.finished_at
-  end
+    def complete!
+      if has_errors?
+        failed!
+      elsif has_suspended_jobs?
+        suspended!
+      else
+        finished!
+      end
+    end
 
-  def runnig!
-    raise InternalError.new(self, "Can't start: workflow already running") if (running? || suspended?)
-    raise InternalError.new(self, "Can't start: workflow already failed") if failed?
-    raise InternalError.new(self, "Can't start: workflow already finished") if finished?
-    self.status = RUNNING
-    save!
-  end
+    def first_job
+      all_jobs.min_by{|n| n.started_at || Time.now.to_i }
+    end
 
-  def failed!
-    run_callbacks :failure do
-      raise InternalError.new(self, "Can't fail: workflow already failed") if failed?
-      raise InternalError.new(self, "Can't fail: workflow already finished") if finished?
-      raise InternalError.new(self, "Can't fail: workflow in not runnig") if !(running? || suspended?)
-      self.status = FAILED
-      save!
+    def last_job
+      all_jobs.max_by{|n| n.finished_at || 0 } if finished?
     end
-  end
 
-  def finished!
-    run_callbacks :finish do
-      raise InternalError.new(self, "Can't finish: workflow already finished") if finished?
-      raise InternalError.new(self, "Can't finish: workflow already failed") if failed?
-      raise InternalError.new(self, "Can't finish: workflow in not runnig") if !running?
-      self.status = FINISHED
-      save!
-    end 
-  end
+    def started_at
+      first_job&.started_at
+    end
 
-  def suspended!
-    run_callbacks :suspend do
-      raise InternalError.new(self, "Can't suspend: workflow already finished") if finished?
-      raise InternalError.new(self, "Can't suspend: workflow already failed") if failed?
-      raise InternalError.new(self, "Can't suspend: workflow in not runnig") if !running?
-      self.status = SUSPENDED
-      save!
+    def finished_at
+      last_job&.finished_at
     end
-  end
 
-  def resumed!
-    run_callbacks :resume do
-      raise InternalError.new(self, "Can't resume: workflow already running") if running?
-      raise InternalError.new(self, "Can't resume: workflow already finished") if finished?
-      raise InternalError.new(self, "Can't resume: workflow already failed") if failed?
-      raise InternalError.new(self, "Can't resume: workflow in not suspended") if !suspended?
+    def runnig!
+      raise InternalError.new(self, "Can't start: workflow already running") if running? || suspended?
+      raise InternalError.new(self, "Can't start: workflow already failed") if failed?
+      raise InternalError.new(self, "Can't start: workflow already finished") if finished?
+
       self.status = RUNNING
       save!
     end
+
+    def failed!
+      run_callbacks :failure do
+        raise InternalError.new(self, "Can't fail: workflow already failed") if failed?
+        raise InternalError.new(self, "Can't fail: workflow already finished") if finished?
+        raise InternalError.new(self, "Can't fail: workflow in not runnig") unless running? || suspended?
+
+        self.status = FAILED
+        save!
+      end
+    end
+
+    def finished!
+      run_callbacks :finish do
+        raise InternalError.new(self, "Can't finish: workflow already finished") if finished?
+        raise InternalError.new(self, "Can't finish: workflow already failed") if failed?
+        raise InternalError.new(self, "Can't finish: workflow in not runnig") unless running?
+
+        self.status = FINISHED
+        save!
+      end
+    end
+
+    def suspended!
+      run_callbacks :suspend do
+        raise InternalError.new(self, "Can't suspend: workflow already finished") if finished?
+        raise InternalError.new(self, "Can't suspend: workflow already failed") if failed?
+        raise InternalError.new(self, "Can't suspend: workflow in not runnig") unless running?
+
+        self.status = SUSPENDED
+        save!
+      end
+    end
+
+    def resumed!
+      run_callbacks :resume do
+        raise InternalError.new(self, "Can't resume: workflow already running") if running?
+        raise InternalError.new(self, "Can't resume: workflow already finished") if finished?
+        raise InternalError.new(self, "Can't resume: workflow already failed") if failed?
+        raise InternalError.new(self, "Can't resume: workflow in not suspended") unless suspended?
+
+        self.status = RUNNING
+        save!
+      end
+    end
+
   end
 
 end
-end