jongleur 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1db9f251078cde21dde04e7c3c1c39c9ad6507ac
-  data.tar.gz: '0609f7301f92b48d44f9c7f62d5a5456b927945e'
+  metadata.gz: 5601cb9eab89d7222a573523813c5ab64a5beba1
+  data.tar.gz: a147ad7182a1e4aa06ce2bfb9de56a50cf573903
 SHA512:
-  metadata.gz: 1a849e5637bd3aa31f3cc9f80ebf335ee9691f2d54033bde1ace51b05fa86a4f78abb995ef647e1cb025f0050697bef151421d0530db3c1486d8baaf23df5766
-  data.tar.gz: eb9d2f5f43b0fa02ff67620f1b4731de57491d70e437e80c9f0f58153d765d7118ba0a6280022846ec903cb02b1c43431ddf1c0b5ddd6f92c8e1d51f0d0c12f6
+  metadata.gz: abd107a4109aecdabf779b775e0628c3a92ce6efd87129ecece67b6e672be2296eb3c6a8eeda55cd2e9884c3cbd0e72e34d5f66a23d249d95ea56c787de736c0
+  data.tar.gz: 141c79dbda2a86b74fdcbd2cbf25fa993576189b4655bceece1b9f304aac0899e7fd794b2226ac493b0ed31f21b3b95b923c95469e9e8e6f21519172f3e4ad82

data/CHANGELOG.md

@@ -25,3 +25,8 @@ All notable changes to this project will be documented in this file.
 
 ### Changed
 - Re-written specs to use async callback
+
+## [1.1.1] - 05-Jan-2019
+
+### Changed
+- Moved invocation of task executions out of Signal Trap context

data/README.md

@@ -12,9 +12,9 @@ Jongleur is particularly useful for implementing workflows modelled as a [DAG](h
 This gem has been built using the [POSIX/UNIX process model](https://support.sas.com/documentation/onlinedoc/sasc/doc750/html/lr2/zid-6574.htm). 
 It will work on Linux and Mac OS but not on Windows.  
 
-Jongleur has been tested with MRuby 2.4.3, 2.4.4, 2.5.0 and 2.5.1. I would also expect it to work with other Ruby implementations too, such as JRuby or Rubinius though it hasn't yet been tested on those.
+Jongleur has been tested with MRuby 2.4.3, 2.4.4, 2.5.0 and 2.5.1. I would also expect it to work with other Ruby implementations too, though it hasn't yet been tested on those.
 
-## Pre-requisites
+## Depndencies
 
 This gem depends on the [Graphviz](https://www.graphviz.org/) package for drawing graphs. If this isn't already installed on your system please install with
 
@@ -45,32 +45,41 @@ In either case, call `require jongleur` before using the gem.
 
 ## What does it do?
 
-In a nutshell, Jongleur keeps track of a number of tasks and executes them as separate OS processes according to their precedence criteria. For instance, if there are 3 tasks A, B and C, and task C depends on A and B, Jongleur will start executing A and B in separate processes (i.e.. in parallel) and will wait until they are both finished before it executes C in a separate process. 
+In a nutshell, Jongleur keeps track of a number of tasks and executes them as separate OS processes according to their precedence criteria. For instance, if there are 3 tasks A, B and C, and task C depends on A and B, Jongleur will start executing A and B in separate processes (i.e. in parallel) and will wait until they are both finished before it executes C in a separate process. 
 
 Jongleur is ideal for running workflows represented as DAGs, but is also useful for simply running tasks in parallel or for whenever you need some multi-processing capability. 
 
 ## Concepts
 
+### Directed Acyclic Graph (DAG)
+A graph that is directed and without cycles connecting the other edges.  DAGs are very useful for representing different kinds of information models, such as task scheduling and business process workflows.  
+
 ### Task Graph
 
 To run Jongleur, you will need to define the tasks to run and their precedence. A _Task Graph_ is a 
-representation of the tasks to be run by Jongleur and it usually (but not exclusively) represents a DAG, as in the examples below:
+representation of the tasks to be run by Jongleur and it usually (but not exclusively) represents a DAG, as in the example below:
+
+![DAG example](https://upload.wikimedia.org/wikipedia/commons/6/61/Polytree.svg)
 
-![DAG examples](https://upload.wikimedia.org/wikipedia/commons/f/fa/Dag_graf.JPG)
 
 A _Task Graph_ is defined as a Hash in the following format:
 
 `{task-name => list[names-of-dependent-tasks]}`
 
 
-So the first graph would be defined as:
+So the graph above can be defined as:
 
 ```
 my_graph = {
-  s: [:q, :r, :t],
-  q: [:r],
-  r: [],
-  t: []
+  A: [:C, :D],
+  B: [:D, :E],
+  D: [:F, :G],
+  E: [],
+  C: [],
+  G: [:I],
+  H: [:I],
+  F: [],
+  I: []
 }
 
 ```
@@ -78,12 +87,11 @@ my_graph = {
 where they Hash key is the class name of a Task and the Hash value is an Array of other Tasks that can be 
 run only after this Task is finished. So in the above example:
 
-* Tasks Q, R and T can only start after task S has finished.
-* Task R can only start after Q has finished.
-* Tasks T and T have no dependants. No other task need wait for them.
-
-__N.B:__ Since the _Task Graph_ is a Hash, any duplicate key entries will be overridden. For instance, if this Task Graph
+* Tasks C and D can only start after task A has finished.
+* Task I can only start after G and H have finished.
+* Tasks C, E, F and I have no dependants. No other tasks need wait for them.
 
+__N.B:__ Since the _Task Graph_ is a Hash, any duplicate key entries will be overridden. For instance:
 ```
 my_task_graph = { A: [:B, :C], B: [:D] }
 ```

data/lib/jongleur/api.rb

@@ -131,6 +131,7 @@ module Jongleur
 
       Implementation.process_message 'Starting workflow...'
       trap_quit_signals
+      @finished_tasks_queue = []
       start_processes
 
       trap(:CHLD) do
@@ -146,6 +147,7 @@ module Jongleur
               t.success_status = status.success?
               t.finish_time = finish_time
               dead_task_name = t.name
+              @finished_tasks_queue << { name: dead_task_name, done: status.success?, pid: dead_pid}
             end
             msg = "finished task: %s, process: %i, exit_status: %i, success: %s"
             Implementation.process_message msg % [dead_task_name,
@@ -153,12 +155,7 @@ module Jongleur
                                                   status.exitstatus,
                                                   status.success?]
 
-            if status.success?
-              Implementation.run_descendants(dead_task_name)
-            else
-              msg = "Task #{dead_task_name} with process id #{dead_pid} was not succesfully completed."
-              Implementation.process_message(msg)
-            end
+
           end
 
           # it's possible for the last CHLD signal to arrive after our trap
@@ -167,9 +164,19 @@ module Jongleur
           # the oncoming exception so we don't get a crash.
         rescue Errno::ECHILD
         end
-      end
+      end #trap
 
       loop do
+        # run task's descendants as soon as task appears on 'finished' queue
+        while task = @finished_tasks_queue.pop
+          if task[:done]
+            Implementation.run_descendants(task[:name])
+          else
+            msg = "Task #{task[:name]} with process id #{task[:pid]} was not succesfully completed."
+            Implementation.process_message(msg)
+          end
+        end
+
         # We exit once all the child processes and their descendants are accounted for
         if Implementation.running_tasks.empty?
           Implementation.process_message 'Workflow finished'

data/lib/jongleur/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Jongleur
-  VERSION = '1.1.0'
+  VERSION = '1.1.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jongleur
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Fred Heath
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-31 00:00:00.000000000 Z
+date: 2019-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphviz