taskflow-mongoid 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f6207e24297a546ecaf6ac571ef038ff85df29d
-  data.tar.gz: 897ccc7e04641d6506b106ce269513b85498bb44
+  metadata.gz: 1d7fcb6e49960147821299b3fadcfa8cb29c4ea6
+  data.tar.gz: 3aab13db0e1dc980bc0c2d7ca759d78025f27bdf
 SHA512:
-  metadata.gz: 62153a6ef8a35f7840b01d3fdd4cb7466c5bce59a6a7bc53763b4dc0a0f15628d07f016f88964148ca844fb62b9f67c1b1a13fec644b9d32086ddd93eeeec6a6
-  data.tar.gz: 0910446837c77db561162c8ccbb20bc4e6c506d4ca466526caf0969163ec34a14eb65a8804619f280a8f85c05efa7933c8503021aa1b9c6b9bb11470e6ffa6f1
+  metadata.gz: e3265a9cd061760cb56d2e43ce5417b86043834ccb8f7850387eb483aa77d8e6d97f689eef9e616937c853db7d5109819c09885c79ebb1443db4da6fd41fc529
+  data.tar.gz: 9184401ef5b052ecd3761fcb2c50ce7379a1bbdcda05f3d65f141a1938c049bda11dfab4693b07bd4f589f652b174368b4fdd1b4471a362cc04678561cba4bd2

data/README.md

@@ -1,8 +1,6 @@
 # Taskflow
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/taskflow`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Taskflow is a cool rails plugin for creating and schedule task flows. NOTE: taskflow is based sidekiq, and use ActiveRecord/Mongoid as its database adapter, choose the right gem(another version taskflow is also available on my github) for your project.
 
 ## Installation
 
@@ -22,7 +20,8 @@ Or install it yourself as:
 
 ## Usage
 
-example:
+Let's see an example first, the 'PlayFlow' has 7 task in total. When we start the flow, the t1(PendingTask) runs first, after t1 finishes, t2,t3,t4 would run in parallel; When t4 is done, the t5(OkTask) begins, when t2,t3,t5 are all done, the SummaryTask start to run, then run the last OkTask.
+
 ```ruby
 class PlayFlow < Taskflow::Flow
     NAME = "Play FLow"
@@ -141,6 +140,134 @@ Taskflow::Worker JID-d7d0c92da5ab820bc1f66651 INFO: finished-task finished
 Taskflow::Worker JID-d7d0c92da5ab820bc1f66651 INFO: done: 0.021 sec
 ```
 
+
+## Documentations
+### Taskflow state diagram
+flow state
+![output](https://raw.githubusercontent.com/qjpcpu/taskflow-mongoid/master/images/flow-state.png)
+
+### the Taskflow::Flow
+First, you should create your taskflow by inherit `Taskflow::Flow`, and you *must implement the `configure` method* to tell taskflow engine the detail info.
+
+In `configure` method, you can use the keyword `run` to define task:
+
+```ruby
+# the keyword run
+run Task_Class, name: 'task_name'
+# task1 would run before another_task_obj
+run Task_Class, name: 'task1',:before=>another_task_obj
+# task2 would run after another_task_obj
+run Task_Class, name: 'task2',:after=>another_task_obj
+# the wait_task would run after task3,task4,task5 all done
+run Task_Class, name: 'wait_task',:after=>[task3,task4,task5]
+# pass some parameter to task, the params would set as task's input
+run Task_Class, name: 'params_task',params: { :param1=>'abc' }
+```
+
+You can use `after` or `before` to specify the schedule order for certain task, if there's no after or before, the current task would just run after the previous task.
+
+#### 0. config taskflow
+You can config taskflow worker run in which sidekiq queue(default is `default`), forexample in `config/environments/production.rb`:
+```ruby
+Taskflow.configure do |config|
+    config.worker_options = { queue: 'workflow' }
+end
+```
+
+#### 1. launch taskflow
+```ruby
+# the params would be set as taskflow's input field
+Taskflow::Flow.launch 'PlayFlow',:params=>{word: 'hello'},:launched_by=>'Jason',:workflow_description=>'description'
+# check whether can launch taskflow, if there's already a taskflow which has the some taskflow_klass and params, return false
+Taskflow::Flow.can_launch? 'PlayFlow',:params=>{word: 'hello'},:launched_by=>'Jason',:workflow_description=>'description'
+```
+
+#### 2. taskflow control
+```ruby
+# Taskflow::Flow#stop! stop taskflow
+flow.stop!
+flow.stop! 'tom' # => stopped by tom
+# Taskflow::Flow#resume, resume paused flow
+flow.resume
+```
+
+### the Taskflow::Task
+Define your own taskflow task. Inherit the class `Taskflow::Task`, and *implement go method*.
+
+```ruby
+def go(logger)
+# write your task code here
+end
+```
+
+#### 1.Sidekiq logger
+the parameter `logger` of `Taskflow::Task#go` is sidekiq logger, so you can use it to log to sidekiq log file for debug.
+
+#### 2.taskflow logger
+There's another logger in `Taskflow::Task#go` : `tflogger`, `tflogger` can write log information to database. for example:
+
+```ruby
+def go(logger)
+  tflogger.info 'the info message would write to database'
+  tflogger.error 'this error message would write to database,too'
+end
+```
+
+#### 3. input & output
+There's a very cool feature. Every task has its own `input` and `ouput`.
+```ruby
+def go(logger)
+  puts input # => the input hash
+  puts input[:some_key] # => get the input value of the key 'some_key'
+  puts upstream.first.ouput # => get the first upstream's ouput, also is a hash
+end
+```
+
+You have the `set/append_xxx` to modify the input and output.
+```ruby
+def go(log)
+  set_output :some_key=>'value' # => set the output to { :some_key=> 'value'}
+  append_output :some_key2=>'value2' # => add { :some_key2=>'value2' } to output
+end
+```
+
+#### 4. data
+Every task has its own data. After the task is done, the data would be cleanned.
+```ruby
+def go(log)
+  puts data # => print data
+  puts data[:key] # => access data
+  set_data :key=>'value'
+  append_data :key=>'value'
+end
+```
+
+#### 5. relationship
+In the task, you can access its upstream and downstream.
+```ruby
+def go(log)
+  upstream.each{|task| puts task.name }
+  upstream.each{|task| puts task.output }
+  puts downstream.first.name
+end
+```
+
+#### 6. task control
+```ruby
+task.resume # => resume paused task
+task.wakeup(hash_data) # => wakeup suspend task with some hash data
+task.wakeup # => just wakeup
+task.skip # => skip paused task
+```
+And, in `Taskflow::Task#go`, you can use keyword `suspend` to suspend current task, then the task result would convert to `suspend`,state would be `paused`.
+```ruby
+def go(log)
+  log.info 'before suspend'
+  suspend  # => the task would be suspend right now.
+  log.info 'never print me'
+end
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/taskflow/version.rb

@@ -1,3 +1,3 @@
 module Taskflow
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/taskflow/worker.rb

@@ -1,7 +1,6 @@
 # coding: utf-8
 class Taskflow::Worker
     include ::Sidekiq::Worker
-    sidekiq_options :retry => false
 
     def perform(task_flow_id,job_id,opts={})
         flow = Taskflow::Flow.find task_flow_id
@@ -28,63 +27,63 @@ class Taskflow::Worker
         rescue=>exception
             task.error = {
                 class: exception.class.to_s,
-                        message: exception.to_s,
-                        backtrace: exception.backtrace
-                    }
-                    task.state = 'paused'
-                    task.result = 'error'
-                    task.ended_at = Time.now
-                    task.save
-                end
-                update_flow flow.reload
-                flow.schedule
-                end
+                message: exception.to_s,
+                backtrace: exception.backtrace
+            }
+            task.state = 'paused'
+            task.result = 'error'
+            task.ended_at = Time.now
+            task.save
+        end
+        update_flow flow.reload
+        flow.schedule
+    end
 
-                private
-                def check_flow_state(flow)
-                    if flow.state == 'stopped' || flow.halt_by
-                        throw :control, :flow_halt
-                    end
-                end
-                def check_task_state(task)
-                    case task.state
-                    when 'pending'
-                        task.update_attributes state: 'running'
-                    when 'running'
-                        throw :control, :already_running
-                    when 'paused'
-                        throw :control, :suspend if task.result == 'suspend'
-                    when 'stopped'
-                        throw :control, :already_stopped
-                    when 'skipped'
-                        throw :control,:skip
-                    else
-                        raise "Unkown task state #{task.state}"
-                    end
-                end
+    private
+    def check_flow_state(flow)
+        if flow.state == 'stopped' || flow.halt_by
+            throw :control, :flow_halt
+        end
+    end
+    def check_task_state(task)
+        case task.state
+        when 'pending'
+            task.update_attributes state: 'running'
+        when 'running'
+            throw :control, :already_running
+        when 'paused'
+            throw :control, :suspend if task.result == 'suspend'
+        when 'stopped'
+            throw :control, :already_stopped
+        when 'skipped'
+            throw :control,:skip
+        else
+            raise "Unkown task state #{task.state}"
+        end
+    end
 
-                def update_flow(flow)
-                    return if flow.halt_by || flow.state == 'stopped'
-                    flow.progress = flow.tasks.map(&:progress).sum / flow.tasks.size
-                    if flow.halt_by
-                        flow.state = 'stopped'
-                    elsif flow.tasks.all?{|t| %w(stopped skipped).include? t.state }
-                        flow.state = 'stopped'
-                    elsif flow.tasks.any?{|t| t.state == 'paused' }
-                        flow.state = 'paused'
-                        flow.result = flow.tasks.find_by(state: 'paused').result
-                    else
-                        flow.state = 'running'
-                    end
-                    if flow.state == 'stopped'
-                        flow.result = flow.tasks.all?{|t| t.result == 'success' } ? 'success' : 'warning'
-                        flow.ended_at = Time.now
-                        if flow.next_config
-                            logger.info "Auto boot next flow, #{flow.next_config}"
-                            Taskflow::Flow.launch flow.next_config[:name],flow.next_config[:config]
-                        end
-                    end
-                    flow.save
-                end
+    def update_flow(flow)
+        return if flow.halt_by || flow.state == 'stopped'
+        flow.progress = flow.tasks.map(&:progress).sum / flow.tasks.size
+        if flow.halt_by
+            flow.state = 'stopped'
+        elsif flow.tasks.all?{|t| %w(stopped skipped).include? t.state }
+            flow.state = 'stopped'
+        elsif flow.tasks.any?{|t| t.state == 'paused' }
+            flow.state = 'paused'
+            flow.result = flow.tasks.find_by(state: 'paused').result
+        else
+            flow.state = 'running'
+        end
+        if flow.state == 'stopped'
+            flow.result = flow.tasks.all?{|t| t.result == 'success' } ? 'success' : 'warning'
+            flow.ended_at = Time.now
+            if flow.next_config
+                logger.info "Auto boot next flow, #{flow.next_config}"
+                Taskflow::Flow.launch flow.next_config[:name],flow.next_config[:config]
+            end
+        end
+        flow.save
+    end
 
-                end
+end

data/lib/taskflow.rb

@@ -7,5 +7,14 @@ require 'taskflow/logger'
 require 'taskflow/record'
 
 module Taskflow
-    # Your code goes here...
+
+    def self.worker_options=(opts)
+        orig = HashWithIndifferentAccess.new(Worker.sidekiq_options_hash || {})
+        Worker.sidekiq_options_hash = orig.merge(opts).merge(retry: false)
+    end
+    
+    def self.configure
+        yield self
+    end
 end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: taskflow-mongoid
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - qujianping
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-07-05 00:00:00.000000000 Z
+date: 2015-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,6 +81,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- images/flow-state.png
 - lib/taskflow.rb
 - lib/taskflow/flow.rb
 - lib/taskflow/logger.rb