dwf 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d6ec140cc691fd53ceb5d495add6e3a76ce6a7b6daf2bfbde982e6e40a19987
-  data.tar.gz: 66911fc7ec1a54e38aaaca160ee455b2463f1888ecbbf981c64a17e9d790c1a2
+  metadata.gz: 131525481d493d4765a33fa9b5d34524f74f221b05399b1a39b2cc47d439aa65
+  data.tar.gz: 4483fe6f6e98e45579d65362c2ba3f0298303522d103647c0a3d04085580af16
 SHA512:
-  metadata.gz: 240a6603023b3edc79b69d1793e8805e86ec298f2927df7bd3a1342ad241fb3a0b619a6aa50266348003c20f751fdd58dc91a68dead319916ca351a09bee5f0f
-  data.tar.gz: 4af1937daa29fab5f2fd818f22a64bea90d35074a0ca70109e4a36cbaa754fae199799167385f78579a854152563c1e8074c6ff91ad931e544b20c67bf7de054
+  metadata.gz: 9a5e357a59d77faa86eaa54552f19b2ad06b82af8a72bc80a2c66fd8ba56584391c08878c0e0b16cf32df6e6dc564d01bf60b0c16b2bcafe7649b6522643db48
+  data.tar.gz: 056e815c2beed08ca7e8fccc0c22afb291c849f9195b1bd5d7469d22096b62a37a8a457a21eeaa949f436e034586217e3aacf4e7d6cf44e52f325c88126c8b6c

data/.github/workflows/test.yaml

@@ -13,12 +13,16 @@ jobs:
 
     runs-on: ubuntu-latest
 
+    strategy:
+      matrix:
+        ruby-version: ["2.5", "2.6", "2.7", "3.0"]
+
     steps:
       - uses: actions/checkout@v2
       - name: Set up Ruby
         uses: ruby/setup-ruby@477b21f02be01bcb8030d50f37cfec92bfa615b6
         with:
-          ruby-version: 3.0.0
+          ruby-version: ${{ matrix.ruby-version }}
       - name: Install dependencies
         run: bundle install
       - name: Run tests

data/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 All notable changes to this project will be documented in this file.
+
+## 0.1.12
+### Added
+#### Dynamic workflows
+There might be a case when you have to contruct the workflow dynamically depend on the input
+As an example, let's write a workflow which puts from 1 to 100 into the terminal parallely . Additionally after finish all job, it will puts the finshed word into the terminal
+```ruby
+class FirstMainItem < Dwf::Item
+  def perform
+    puts "#{self.class.name}: running #{params}"
+  end
+end
+
+SecondMainItem = Class.new(FirstMainItem)
+
+class TestWf < Dwf::Workflow
+  def configure
+    items = (1..100).to_a.map do |number|
+      run FirstMainItem, params: number
+    end
+    run SecondMainItem, after: items, params: "finished"
+  end
+end
+
+```
+We can achieve that because run method returns the id of the created job, which we can use for chaining dependencies.
+Now, when we create the workflow like this:
+```ruby
+wf = TestWf.create
+# wf.callback_type = Dwf::Workflow::SK_BATCH
+wf.start!
+```
+
+## 0.1.12
+### Added
+#### Subworkflow for all callback types
+same with `0.1.11`
 ## 0.1.11
 ### Added
 #### Subworkflow - Only support sidekiq pro

data/README.md

@@ -199,6 +199,36 @@ Main flow: ThirtItem running
 Main flow: ThirtItem finish
 ```
 
+## Dynamic workflows
+There might be a case when you have to contruct the workflow dynamically depend on the input
+As an example, let's write a workflow which puts from 1 to 100 into the terminal parallelly . Additionally after finish all job, it will puts the finshed word into the terminal
+```ruby
+class FirstMainItem < Dwf::Item
+  def perform
+    puts "#{self.class.name}: running #{params}"
+  end
+end
+
+SecondMainItem = Class.new(FirstMainItem)
+
+class TestWf < Dwf::Workflow
+  def configure
+    items = (1..100).to_a.map do |number|
+      run FirstMainItem, params: number
+    end
+    run SecondMainItem, after: items, params: "finished"
+  end
+end
+
+```
+We can achieve that because run method returns the id of the created job, which we can use for chaining dependencies.
+Now, when we create the workflow like this:
+```ruby
+wf = TestWf.create
+# wf.callback_type = Dwf::Workflow::SK_BATCH
+wf.start!
+```
+
 # Todo
 - [x] Make it work
 - [x] Support pass params

data/dwf.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'byebug', '~> 11.1.3'
   spec.add_development_dependency 'mock_redis', '~> 0.27.2'
   spec.add_dependency 'redis', '~> 4.2.0'
+  spec.add_dependency 'redis-mutex', '~> 4.0.2'
   spec.add_development_dependency 'rspec', '~> 3.2'
   spec.add_dependency 'sidekiq', '~> 6.2.0'
   spec.add_development_dependency 'simplecov'

data/lib/dwf/callback.rb

@@ -45,6 +45,7 @@ module Dwf
       )
       batch.jobs do
         jobs.each do |job|
+          job.reload
           job.persist_and_perform_async! if job.ready_to_start?
         end
       end
@@ -67,10 +68,8 @@ module Dwf
       end.compact
     end
 
-    def with_lock(workflow_id, job_name)
-      client.check_or_lock(workflow_id, job_name)
-      yield
-      client.release_lock(workflow_id, job_name)
+    def with_lock(workflow_id, job_name, &block)
+      client.check_or_lock(workflow_id, job_name, &block)
     end
 
     def start_with_batch(node)

data/lib/dwf/client.rb

@@ -1,4 +1,5 @@
 require_relative 'errors'
+require 'redis-mutex'
 
 module Dwf
   class Client
@@ -63,14 +64,9 @@ module Dwf
       redis.hset("dwf.jobs.#{job.workflow_id}.#{job.klass}", job.id, job.as_json)
     end
 
-    def check_or_lock(workflow_id, job_name)
+    def check_or_lock(workflow_id, job_name, &block)
       key = "wf_enqueue_outgoing_jobs_#{workflow_id}-#{job_name}"
-
-      if key_exists?(key)
-        sleep 2
-      else
-        set(key, 'running')
-      end
+      RedisMutex.with_lock(key, sleep: 0.3, block: 2, &block)
     end
 
     def release_lock(workflow_id, job_name)
@@ -175,7 +171,9 @@ module Dwf
     end
 
     def redis
-      @redis ||= Redis.new(config.redis_opts)
+      @redis ||= Redis.new(config.redis_opts).tap do |instance|
+        RedisClassy.redis = instance
+      end
     end
   end
 end

data/lib/dwf/item.rb

@@ -49,8 +49,8 @@ module Dwf
       assign_attributes(item.to_hash)
     end
 
-    def perform_async
-      Dwf::Worker.set(queue: queue || client.config.namespace)
+    def perform_async(options = {})
+      Dwf::Worker.set(options.merge(queue: queue || client.config.namespace))
         .perform_async(workflow_id, name)
     end
 
@@ -124,11 +124,13 @@ module Dwf
       return workflow.enqueue_outgoing_jobs if leaf?
 
       outgoing.each do |job_name|
-        client.check_or_lock(workflow_id, job_name)
-        out = client.find_node(job_name, workflow_id)
-        out.persist_and_perform_async! if out.ready_to_start?
-        client.release_lock(workflow_id, job_name)
+        client.check_or_lock(workflow_id, job_name) do
+          out = client.find_node(job_name, workflow_id)
+          out.persist_and_perform_async! if out.ready_to_start?
+        end
       end
+    rescue RedisMutex::LockError
+      perform_async(wait: 2)
     end
 
     def to_hash

data/lib/dwf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dwf
-  VERSION = '0.1.12'
+  VERSION = '0.1.13'
 end

data/lib/dwf/workflow.rb

@@ -178,10 +178,10 @@ module Dwf
       return unless sub_workflow?
 
       outgoing.each do |job_name|
-        client.check_or_lock(parent_id, job_name)
-        node = client.find_node(job_name, parent_id)
-        node.persist_and_perform_async! if node.ready_to_start?
-        client.release_lock(parent_id, job_name)
+        client.check_or_lock(parent_id, job_name) do
+          node = client.find_node(job_name, parent_id)
+          node.persist_and_perform_async! if node.ready_to_start?
+        end
       end
     end
 

data/spec/dwf/client_spec.rb

@@ -170,24 +170,18 @@ describe Dwf::Client, client: true do
 
       before do
         allow(client).to receive(:set)
-        redis.set("wf_enqueue_outgoing_jobs_#{workflow_id}-#{job_name}", 'running')
-        client.check_or_lock(workflow_id, job_name)
-      end
-
-      it { expect(client).not_to have_received(:set) }
-    end
-
-    context 'job is not running' do
-      let(:job_name) { 'ahihi' }
-
-      before do
-        allow(redis).to receive(:set)
-        client.check_or_lock(workflow_id, job_name)
+        allow(RedisMutex).to receive(:with_lock)
+        client.check_or_lock(workflow_id, job_name) {}
       end
 
       it do
-        expect(redis).to have_received(:set)
-          .with("wf_enqueue_outgoing_jobs_#{workflow_id}-#{job_name}", 'running')
+        expect(RedisMutex)
+          .to have_received(:with_lock)
+          .with(
+            "wf_enqueue_outgoing_jobs_#{workflow_id}-#{job_name}",
+            sleep: 0.3,
+            block: 2
+          )
       end
     end
   end

data/spec/dwf/item_spec.rb

@@ -175,14 +175,10 @@ describe Dwf::Item, item: true do
         item.enqueue_outgoing_jobs
       end
 
-      context 'outgoing jobs ready to start' do
-        let(:started_at) { nil }
-        it { expect(a_item).to have_received(:persist_and_perform_async!) }
-      end
-
-      context 'outgoing jobs havent ready to start' do
-        let(:started_at) { Time.now.to_i }
-        it { expect(a_item).not_to have_received(:persist_and_perform_async!) }
+      it do
+        expect(client_double).to have_received(:check_or_lock) do |&block|
+          expect(block).to be_kind_of Proc
+        end
       end
     end
 

data/spec/dwf/workflow_spec.rb

@@ -360,23 +360,17 @@ describe Dwf::Workflow, workflow: true do
     let(:item) do
       Dwf::Item.new(
         workflow_id: SecureRandom.uuid,
-        id: SecureRandom.uuid,
-        started_at: started_at
+        id: SecureRandom.uuid
       )
     end
     before do
-      allow(item).to receive(:persist_and_perform_async!)
       workflow.enqueue_outgoing_jobs
     end
 
-    context 'outgoing jobs ready to start' do
-      let(:started_at) { nil }
-      it { expect(item).to have_received(:persist_and_perform_async!) }
-    end
-
-    context 'outgoing jobs havent ready to start' do
-      let(:started_at) { Time.now.to_i }
-      it { expect(item).not_to have_received(:persist_and_perform_async!) }
+    it do
+      expect(client).to have_received(:check_or_lock) do |&block|
+        expect(block).to be_kind_of Proc
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dwf
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - dthtien
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-10 00:00:00.000000000 Z
+date: 2021-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: redis-mutex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.2
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement