workflow_rb 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db6ec565f41bd3aa0fb7185eb61d1bd564507b23
-  data.tar.gz: 8819c1ff1c35e6805d9087ade26b5b6551cd5027
+  metadata.gz: cad4fe51a2b9a5d596418840c27400df4da2e0d8
+  data.tar.gz: 6b9803669daf8bb48231d2769b7e3a359d537d28
 SHA512:
-  metadata.gz: 047385eea283a299a6fd81b661207a412bb7dc1072487d6b679d673cb5f5df2f25711aefb7fc1a103897ee55ba5d3bbe0c0eb24e5f1ccb34b66ed182dff52b3b
-  data.tar.gz: 1673696f3d5fcb15ef57c32995854aefe70fdd25b023599f041674ebda50ae97ee2a5b8b0f6c510d59cbf6a18ccad222a6ca42f51a57a202e92ce28465185a77
+  metadata.gz: 0b08c328a31421b6fa0ad8bb7db5255b63a674fb3bddc278985ce659a348191f9fd6a0b70ed401df94e5388019e1c6a54bf17ab7f5232d80ccf52d3877472dd2
+  data.tar.gz: c5b62ff87e2671574c86219ac4cc1f0cb7ece19e0c8924cf26ff36ee21c98e53fa8c7443a3fb302f70fb4265605a38dc13a9f5c8848190a3c216aabf64383185

data/.gitignore

@@ -8,4 +8,4 @@
 /spec/reports/
 /tmp/
 /.idea
-/workflow_rb-0.1.0.gem
+/*.gem

data/README.md

@@ -81,67 +81,72 @@ Each running workflow is persisted to the chosen persistence provider between ea
 
 The first time a particular step within the workflow is called, the persistence_data property on the context object is *nil*.  The *ExecutionResult* produced by the *run* method can either cause the workflow to proceed to the next step by providing an outcome value, instruct the workflow to sleep for a defined period or simply not move the workflow forward.  If no outcome value is produced, then the step becomes re-entrant by setting persistence_data, so the workflow host will call this step again in the future buy will populate the persistence_data with it's previous value.
 
-For example, this step will initially run with *nil* persistence_data and put the workflow to sleep for 12 hours, while setting the persistence_data to *'something'*.  12 hours later, the step will be called again but context.persistence_data will now contain the object constructed in the previous iteration, and will now produce an outcome value of *nil*, causing the workflow to move forward.
-
-```C#
-public class SleepStep : StepBody
-{
-    public override ExecutionResult Run(IStepExecutionContext context)
-    {
-        if (context.PersistenceData == null)
-            return ExecutionResult.Sleep(Timespan.FromHours(12), new Object());
-        else
-            return ExecutionResult.Next();
-    }
-}
+For example, this step will initially run with *nil* persistence_data and put the workflow to sleep for 1 hour, while setting the persistence_data to *'something'*.  1 hour later, the step will be called again but context.persistence_data will now contain the object constructed in the previous iteration, and will now produce an outcome value of *nil*, causing the workflow to move forward.
+
+```ruby
+class MySleepStep < WorkflowRb::StepBody
+  def run(context)
+    if context.persistence_data
+      WorkflowRb::ExecutionResult.NextStep
+    else
+      WorkflowRb::ExecutionResult.Sleep(Time.now + 3600, 'something')
+    end
+  end
+end
 ```
 
 ### Passing data between steps
 
-Each step is intented to be a blackbox, therefore they support inputs and outputs.  These inputs and outputs can be mapped to a data class that defines the custom data relevant to each workflow instance.
-
-The following sample shows how to define inputs and outputs on a step, it then shows how define a workflow with a typed class for internal data and how to map the inputs and outputs to properties on the custom data class.
-
-```C#
-//Our workflow step with inputs and outputs
-public class AddNumbers : StepBody
-{
-    public int Input1 { get; set; }
-
-    public int Input2 { get; set; }
-
-    public int Output { get; set; }
-
-    public override ExecutionResult Run(IStepExecutionContext context)
-    {
-        Output = (Input1 + Input2);
-        return ExecutionResult.Next();
-    }
-}
-
-//Our class to define the internal data of our workflow
-public class MyDataClass
-{
-    public int Value1 { get; set; }
-    public int Value2 { get; set; }
-    public int Value3 { get; set; }
-}
-
-//Our workflow definition with strongly typed internal data and mapped inputs & outputs
-public class PassingDataWorkflow : IWorkflow<MyDataClass>
-{  
-    public void Build(IWorkflowBuilder<MyDataClass> builder)
-    {
-        builder            
-            .StartWith<AddNumbers>()
-                .Input(step => step.Input1, data => data.Value1)
-                .Input(step => step.Input2, data => data.Value2)
-                .Output(data => data.Value3, step => step.Output)
-            .Then<CustomMessage>()
-                .Input(step => step.Message, data => "The answer is " + data.Value3.ToString());
-    }
-    ...
-}
+Each step is intended to be a black-box, therefore they support inputs and outputs.  These inputs and outputs can be mapped to a data class that defines the custom data relevant to each workflow instance.
+
+The following sample shows how to define inputs and outputs on a step, it then shows how define a workflow with a typed class for internal data and how to map the inputs and outputs to attributes on the custom data class.
+
+```ruby
+# Define some steps
+class AddNumbers < WorkflowRb::StepBody
+  attr_accessor :input1
+  attr_accessor :input2
+  attr_accessor :answer
+
+  def run(context)
+    @answer = @input1 + @input2
+    WorkflowRb::ExecutionResult.NextStep
+  end
+end
+
+class CustomMessage < WorkflowRb::StepBody
+  attr_accessor :message
+
+  def run(context)
+    puts @message
+    WorkflowRb::ExecutionResult.NextStep
+  end
+end
+
+# Define a class to hold workflow data
+class MyData
+  attr_accessor :value1
+  attr_accessor :value2
+  attr_accessor :value3
+end
+
+
+# Define a workflow to put the steps together
+class DataSample_Workflow
+  ID = 'data-sample'
+  VERSION = 1
+  DATA_CLASS = MyData
+
+  def build(builder)
+    builder
+        .start_with(AddNumbers)
+          .input(:input1) {|data| data.value1}
+          .input(:input2) {|data| data.value2}
+          .output(:value3) {|step| step.answer}
+        .then(CustomMessage)
+          .input(:message) {|data| "The answer is #{data.value3}"}
+  end
+end
 
 ```
 
@@ -149,79 +154,80 @@ public class PassingDataWorkflow : IWorkflow<MyDataClass>
 
 A workflow can take a different path depending on the outcomes of preceeding steps.  The following example shows a process where first a random number of 0 or 1 is generated and is the outcome of the first step.  Then, depending on the outcome value, the workflow will either fork to (TaskA + TaskB) or (TaskC + TaskD)
 
-```C#
-public class MultipleOutcomeWorkflow : IWorkflow
-{
-    public void Build(IWorkflowBuilder<object> builder)
-    {
-        builder
-            .StartWith<RandomOutput>(x => x.Name("Random Step"))
-                .When(0)
-                    .Then<TaskA>()
-                    .Then<TaskB>()                        
-                    .End<RandomOutput>("Random Step")
-                .When(1)
-                    .Then<TaskC>()
-                    .Then<TaskD>()
-                    .End<RandomOutput>("Random Step");
-    }
-}
+```ruby
+class RandomStep < WorkflowRb::StepBody
+  def run(context)
+    WorkflowRb::ExecutionResult.Outcome(rand(2))
+  end
+end
+
+class ForkSample_Workflow
+  ID = 'fork-sample'
+  VERSION = 1
+  DATA_CLASS = nil
+
+  def build(builder)
+    step1 = builder.start_with(RandomStep)
+    step1.when(0)
+      .then(TaskA)
+      .then(TaskB)
+
+    step1.when(1)
+      .then(TaskC)
+      .then(TaskD)
+
+  end
+end
 ```
 
 ### Events
 
-A workflow can also wait for an external event before proceeding.  In the following example, the workflow will wait for an event called *"MyEvent"* with a key of *0*.  Once an external source has fired this event, the workflow will wake up and continute processing, passing the data generated by the event onto the next step.
-
-```C#
-public class EventSampleWorkflow : IWorkflow<MyDataClass>
-{
-    public void Build(IWorkflowBuilder<MyDataClass> builder)
-    {
-        builder
-            .StartWith(context =>
-            {
-                Console.WriteLine("workflow started");
-                return ExecutionResult.Next();
-            })
-            .WaitFor("MyEvent", "0")
-                .Output(data => data.Value, step => step.EventData)
-            .Then<CustomMessage>()
-                .Input(step => step.Message, data => "The data from the event is " + data.Value);
-    }
-}
+A workflow can also wait for an external event before proceeding.  In the following example, the workflow will wait for an event called *"my-event"* with a key of *0*.  Once an external source has fired this event, the workflow will wake up and continue processing, passing the data generated by the event onto the next step.
+
+```ruby
+class EventSample_Workflow
+  ID = 'event-sample'
+  VERSION = 1
+  DATA_CLASS = MyData
+
+  def build(builder)
+    builder
+        .start_with(HelloWorld)
+          .wait_for('my-event', '0')
+          .output(:my_value) { |step| step.event_data }
+        .then(CustomMessage)
+          .input(:message) {|data| "The event data is #{data.my_value}"}
+  end
+end
+
 ...
-//External events are published via the host
-//All workflows that have subscribed to MyEvent 0, will be passed "hello"
-host.PublishEvent("MyEvent", "0", "hello");
+# External events are published via the host
+# All workflows that have subscribed to my-event 0, will be passed "hello"
+host.publish_event('my-event', '0', 'hello')
 ```
 
 ### Host
 
 The workflow host is the service responsible for executing workflows.  It does this by polling the persistence provider for workflow instances that are ready to run, executes them and then passes them back to the persistence provider to by stored for the next time they are run.  It is also responsible for publishing events to any workflows that may be waiting on one.
 
-#### Setup
 
-Use the *AddWorkflow* extension method for *IServiceCollection* to configure the workflow host upon startup of your application.
-By default, it is configured with *MemoryPersistenceProvider* and *SingleNodeConcurrencyProvider* for testing purposes.  You can also configure a DB persistence provider at this point.
+#### Usage
 
-```C#
-services.AddWorkflow();
-```
+When your application starts, instantiate a *WorkflowHost*, register your workflow definitions and start it  
 
-#### Usage
 
-When your application starts, grab the workflow host from the built-in dependency injection framework *IServiceProvider*.  Make sure you call *RegisterWorkflow*, so that the workflow host knows about all your workflows, and then call *Start()* to fire up the thread pool that executes workflows.  Use the *StartWorkflow* method to initiate a new instance of a particular workflow.
+```ruby
+host = WorkflowRb::WorkflowHost.new
 
+# register our workflows with the host
+host.register_workflow(HelloWorld_Workflow)
 
-```C#
-var host = serviceProvider.GetService<IWorkflowHost>();            
-host.RegisterWorkflow<HelloWorldWorkflow>();
-host.Start();
+# start the host
+host.start
 
-host.StartWorkflow("HelloWorld", 1, null);
+# start a new workflow
+host.start_workflow('hello world', 1)
 
-Console.ReadLine();
-host.Stop();
 ```
 
 
@@ -231,10 +237,10 @@ Since workflows are typically long running processes, they will need to be persi
 There are several persistence providers available as seperate Nuget packages.
 
 * MemoryPersistenceProvider *(Default provider, for demo and testing purposes)*
-* [MongoDB](src/providers/WorkflowCore.Persistence.MongoDB)
-* [SQL Server](src/providers/WorkflowCore.Persistence.SqlServer)
-* [PostgreSQL](src/providers/WorkflowCore.Persistence.PostgreSQL)
-* [Sqlite](src/providers/WorkflowCore.Persistence.Sqlite)
+* [MongoDB](workflow_rb-mongo)
+* SQL Server *(coming soon...)*
+* PostgreSQL *(coming soon...)*
+* Sqlite *(coming soon...)*
 * Redis *(coming soon...)*
 
 ### Multi-node clusters
@@ -244,31 +250,28 @@ By default, the WorkflowHost service will run as a single node using the built-i
 #### Queue Providers
 
 * SingleNodeQueueProvider *(Default built-in provider)*
-* [RabbitMQ](src/providers/WorkflowCore.QueueProviders.RabbitMQ)
+* RabbitMQ *(coming soon...)*
 * Apache ZooKeeper *(coming soon...)*
 * 0MQ *(coming soon...)*
 
 #### Distributed lock managers
 
 * SingleNodeLockProvider *(Default built-in provider)*
-* [Redis Redlock](src/providers/WorkflowCore.LockProviders.Redlock)
+* Redis Redlock *(coming soon...)*
 * Apache ZooKeeper *(coming soon...)*
 
 
 ## Samples
 
-[Hello World](src/samples/WorkflowCore.Sample01)
-
-[Multiple outcomes](src/samples/WorkflowCore.Sample06)
-
-[Passing Data](src/samples/WorkflowCore.Sample03)
+[Hello World](samples/sample01.rb)
 
-[Events](src/samples/WorkflowCore.Sample04)
+[Multiple outcomes](samples/sample06.rb)
 
-[Deferred execution & re-entrant steps](src/samples/WorkflowCore.Sample05)
+[Passing Data](samples/sample02.rb)
 
-[Looping](src/samples/WorkflowCore.Sample02)
+[Events](samples/sample04.rb)
 
+[Deferred execution & re-entrant steps](samples/sample05.rb)
 
 ## Authors
 

data/lib/workflow_rb/version.rb

@@ -1,3 +1,3 @@
 module WorkflowRb
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: workflow_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Daniel Gerlag
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-10 00:00:00.000000000 Z
+date: 2016-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler