burstflow 0.1.1 → 0.2.0

data/lib/burst/worker.rb

@@ -1,42 +0,0 @@
-class Burst::Worker < ::ActiveJob::Base
-
-  def perform(workflow_id, job_id, resume_data = nil)
-    setup(workflow_id, job_id)
-
-    job.payloads = incoming_payloads
-
-    result = if resume_data.nil?
-               @manager.start_job!(job)
-             else
-               @manager.resume_job!(job, resume_data)
-    end
-
-    @manager.job_performed!(job, result)
-  rescue StandardError => e
-    @manager.fail_job!(job)
-    raise e
-  end
-
-
-  private
-
-    attr_reader :workflow, :job
-
-    def setup(workflow_id, job_id)
-      @workflow = Burst::Workflow.find(workflow_id)
-      @job = @workflow.get_job(job_id)
-      @manager = @workflow.manager
-    end
-
-    def incoming_payloads
-      job.incoming.map do |job_id|
-        incoming = workflow.get_job(job_id)
-        {
-          id: incoming.id,
-          class: incoming.klass.to_s,
-          payload: incoming.output
-        }
-      end
-    end
-
-end

data/lib/burst/workflow.rb

@@ -1,148 +0,0 @@
-class Burst::Workflow < ActiveRecord::Base
-
-  self.table_name_prefix = 'burst_'
-
-  INITIAL   = 'initial'.freeze
-  RUNNING   = 'running'.freeze
-  FINISHED  = 'finished'.freeze
-  FAILED    = 'failed'.freeze
-  SUSPENDED = 'suspended'.freeze
-
-  include Burst::WorkflowHelper
-  include Burst::Builder
-
-  attr_accessor :manager, :job_cache
-  define_flow_attributes :jobs, :klass
-
-  after_initialize do
-    initialize_builder
-
-    @job_cache = {}
-
-    self.id ||= SecureRandom.uuid
-    self.jobs ||= {}.with_indifferent_access
-    self.klass ||= self.class.to_s
-
-    @manager = Burst::Manager.new(self)
-  end
-
-  def attributes
-    {
-      id: self.id,
-      jobs: self.jobs,
-      klass: self.klass,
-      status: status
-    }
-  end
-
-  def self.build(*args)
-    wf = new
-    wf.configure(*args)
-    wf.resolve_dependencies
-    wf
-  end
-
-  def reload(options = nil)
-    self.job_cache = {}
-    super
-  end
-
-  def start!
-    save!
-    manager.start
-  end
-
-  def resume!(job_id, data)
-    manager.resume!(get_job(job_id), data)
-  end
-
-  def status
-    if failed?
-      FAILED
-    elsif suspended?
-      SUSPENDED
-    elsif running?
-      RUNNING
-    elsif finished?
-      FINISHED
-    else
-      INITIAL
-    end
-  end
-
-  def initial?
-    status == INITIAL
-  end
-
-  def finished?
-    all_jobs.all?(&:finished?)
-  end
-
-  def started?
-    !!started_at
-  end
-
-  def running?
-    started? && !finished?
-  end
-
-  def failed?
-    all_jobs.any?(&:failed?)
-  end
-
-  def suspended?
-    !failed? && all_jobs.any?(&:suspended?)
-  end
-
-  def all_jobs
-    Enumerator.new do |y|
-      jobs.keys.each do |id|
-        y << get_job(id)
-      end
-    end
-  end
-
-  def get_job(id)
-    if job = @job_cache[id]
-      job
-    else
-      job = Burst::Job.from_hash(self, jobs[id].deep_dup)
-      @job_cache[job.id] = job
-      job
-    end
-  end
-
-  def set_job(job)
-    jobs[job.id] = job.as_json
-  end
-
-  def initial_jobs
-    all_jobs.select(&:initial?)
-  end
-
-  def find_job(id_or_klass)
-    id = if jobs.key?(id_or_klass)
-           id_or_klass
-         else
-           find_id_by_klass(id_or_klass)
-    end
-
-    get_job(id)
-  end
-
-  def get_job_hash(id)
-    jobs[id]
-  end
-
-  private
-
-    def find_id_by_klass(klass)
-      finded = jobs.select do |_, job|
-        job[:klass].to_s == klass.to_s
-      end
-
-      raise 'Duplicat job detected' if finded.count > 1
-      finded.first.second[:id]
-    end
-
-end

data/spec/cases_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-
-describe Burst::Manager do
-  class JobHandler
-
-    attr_accessor :jobs
-
-    def initialize
-      @jobs = []
-    end
-
-    def add(json)
-      @jobs.push json
-    end
-
-    def find_job(klass)
-      @jobs.detect do |json|
-        json['klass'].to_s == klass.to_s
-      end
-    end
-
-  end
-
-  around :each do |ex|
-    begin
-      $job_handler = JobHandler.new
-      ex.run
-    ensure
-      $job_handler = nil
-    end
-  end
-
-  class TestCaseJob < Burst::Job
-
-    def perform
-      # puts "#{self.class.to_s}"
-      set_output(self.class.to_s)
-      $job_handler.add as_json.with_indifferent_access.merge(payloads: payloads)
-    end
-
-  end
-
-  class CaseJob1 < TestCaseJob; end
-  class CaseJob2 < TestCaseJob; end
-  class CaseJob3 < TestCaseJob; end
-  class CaseAsyncJob < TestCaseJob
-
-    def perform
-      suspend
-      $job_handler.add as_json.with_indifferent_access.merge(payloads: payloads)
-    end
-
-  end
-
-  class CaseW1 < Burst::Workflow
-
-    configure do |*_args|
-      id1 = run CaseJob1, id: 'job1', params: { p1: 1 }
-      run CaseJob2, id: 'job2', after: id1, params: { p2: 2 }
-      run CaseJob3, after: [CaseJob1, 'job2']
-    end
-
-  end
-
-
-  it 'case1 no async job state' do
-    w = CaseW1.build
-
-    perform_enqueued_jobs do
-      w.start!
-    end
-
-    w.reload
-
-    expect(w.started?).to eq true
-    expect(w.failed?).to eq false
-    expect(w.finished?).to eq true
-    expect(w.running?).to eq false
-    expect(w.status).to eq Burst::Workflow::FINISHED
-
-    expect($job_handler.jobs.count).to eq 3
-    expect($job_handler.find_job(CaseJob1)).to include(output: 'CaseJob1', params: { p1: 1 })
-
-    expect($job_handler.find_job(CaseJob2)).to include(output: 'CaseJob2', params: { p2: 2 })
-    expect($job_handler.find_job(CaseJob2)[:payloads]).to include(id: 'job1', class: 'CaseJob1', payload: 'CaseJob1')
-
-    expect($job_handler.find_job(CaseJob3)).to include(output: 'CaseJob3')
-    expect($job_handler.find_job(CaseJob3)[:payloads]).to include(id: 'job1', class: 'CaseJob1', payload: 'CaseJob1')
-    expect($job_handler.find_job(CaseJob3)[:payloads]).to include(id: 'job2', class: 'CaseJob2', payload: 'CaseJob2')
-  end
-
-  class CaseW2 < Burst::Workflow
-
-    configure do |*_args|
-      id1 = run CaseJob1, id: 'job1', params: { p1: 1 }
-      run CaseAsyncJob, id: 'job2', after: id1, params: { p2: 2 }
-      run CaseJob3, after: [CaseJob1, 'job2']
-    end
-
-  end
-
-  it 'case2 with async job state' do
-    w = CaseW2.build
-
-    perform_enqueued_jobs do
-      w.start!
-    end
-
-    w.reload
-
-    expect(w.started?).to eq true
-    expect(w.failed?).to eq false
-    expect(w.finished?).to eq false
-    expect(w.running?).to eq true
-    expect(w.suspended?).to eq true
-    expect(w.status).to eq Burst::Workflow::SUSPENDED
-
-    expect($job_handler.jobs.count).to eq 2
-    expect($job_handler.find_job(CaseJob1)).to include(output: 'CaseJob1', params: { p1: 1 })
-
-    expect($job_handler.find_job(CaseAsyncJob)).to include(output: Burst::Job::SUSPEND, params: { p2: 2 })
-    expect($job_handler.find_job(CaseAsyncJob)[:payloads]).to include(id: 'job1', class: 'CaseJob1', payload: 'CaseJob1')
-
-    w = CaseW2.find(w.id)
-
-    perform_enqueued_jobs do
-      w.resume!('job2', 'result')
-    end
-
-    w.reload
-
-    expect($job_handler.jobs.count).to eq 3
-    expect($job_handler.find_job(CaseJob1)).to include(output: 'CaseJob1', params: { p1: 1 })
-
-    # expect($job_handler.find_job(AsyncJob)).to include(output: 'result', params: {p2: 2})
-    expect($job_handler.find_job(CaseAsyncJob)[:payloads]).to include(id: 'job1', class: 'CaseJob1', payload: 'CaseJob1')
-
-    expect($job_handler.find_job(CaseJob3)).to include(output: 'CaseJob3')
-    expect($job_handler.find_job(CaseJob3)[:payloads]).to include(id: 'job1', class: 'CaseJob1', payload: 'CaseJob1')
-    expect($job_handler.find_job(CaseJob3)[:payloads]).to include(id: 'job2', class: 'CaseAsyncJob', payload: 'result')
-  end
-
-  describe 'dynamic jobs with payloads' do
-    class DynJob1 < TestCaseJob
-
-      def perform
-        configure do
-          run DynJob2, params: { a: 1 }
-          run DynJob2, params: { a: 2 }
-          run DynJob2, params: { a: 3 }
-        end
-        super
-      end
-
-    end
-
-    class DynJob2 < TestCaseJob; end
-    class DynJob3 < TestCaseJob; end
-
-    class DynFlow1 < Burst::Workflow
-
-      configure do |*_args|
-        run DynJob1
-        run DynJob3, after: DynJob1
-      end
-
-    end
-
-    it 'create intemediate jobs' do
-      w = DynFlow1.build
-
-      perform_enqueued_jobs do
-        w.start!
-      end
-
-      expect($job_handler.jobs.count).to eq 5
-      expect($job_handler.jobs.last['payloads'].count).to eq 4
-    end
-  end
-end