workflow_rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 378c7aa6543eccd7a1706b1b4248d045fb68d705
+  data.tar.gz: 2520ebcac7a53516bb207ef4365e17b346528e18
+SHA512:
+  metadata.gz: 1949842e74f1007bf3b422f586e7dc2c118ae96702949a019ad677766c6536c5ce547ad4566adc76ba3a11ac11f9e3b2bc520d03ecf72667ee1e6e2fd9a5d504
+  data.tar.gz: cafba682c685829de508f3bb0c9ccf6b159f0ad4613b00b218df7c6da1d1b051eedf563b48e8c4d0962547eb5416ac1652f9568cb19704090dea361a75f4d2fc

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.4
+before_install: gem install bundler -v 1.13.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in workflow_rb.gemspec
+gemspec

data/README.md

@@ -0,0 +1,36 @@
+# WorkflowRb
+
+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/workflow_rb`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'workflow_rb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install workflow_rb
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/workflow_rb.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "workflow_rb"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/workflow_rb/models/event_publication.rb

@@ -0,0 +1,10 @@
+module WorkflowRb
+  class EventPublication
+    attr_accessor :id
+    attr_accessor :workflow_id
+    attr_accessor :step_id
+    attr_accessor :event_name
+    attr_accessor :event_key
+    attr_accessor :event_data
+  end
+end

data/lib/workflow_rb/models/event_subscription.rb

@@ -0,0 +1,9 @@
+module WorkflowRb
+  class EventSubscription
+    attr_accessor :id
+    attr_accessor :workflow_id
+    attr_accessor :step_id
+    attr_accessor :event_name
+    attr_accessor :event_key
+  end
+end

data/lib/workflow_rb/models/execution_pointer.rb

@@ -0,0 +1,19 @@
+module WorkflowRb
+
+  class ExecutionPointer
+    attr_accessor :step_id
+    attr_accessor :active
+    attr_accessor :persistence_data
+    attr_accessor :start_time
+    attr_accessor :end_time
+    attr_accessor :sleep_until
+    attr_accessor :event_name
+    attr_accessor :event_key
+    attr_accessor :event_published
+    attr_accessor :event_data
+    attr_accessor :concurrent_fork
+    attr_accessor :path_terminator
+
+  end
+
+end

data/lib/workflow_rb/models/execution_result.rb

@@ -0,0 +1,25 @@
+module WorkflowRb
+
+  class ExecutionResult
+    attr_accessor :proceed
+    attr_accessor :outcome_value
+    attr_accessor :persistence_data
+    attr_accessor :sleep_for
+
+    def self.NextStep
+      result = ExecutionResult.new
+      result.proceed = true
+      result.outcome_value = nil
+      result
+    end
+
+    def self.Outcome(value)
+      result = ExecutionResult.new
+      result.proceed = true
+      result.outcome_value = value
+      result
+    end
+
+  end
+
+end

data/lib/workflow_rb/models/io_mapping.rb

@@ -0,0 +1,6 @@
+module WorkflowRb
+  class IOMapping
+    attr_accessor :property
+    attr_accessor :value
+  end
+end

data/lib/workflow_rb/models/step_body.rb

@@ -0,0 +1,9 @@
+
+module WorkflowRb
+
+  class StepBody
+    def run(context)
+    end
+  end
+
+end

data/lib/workflow_rb/models/step_execution_context.rb

@@ -0,0 +1,9 @@
+module WorkflowRb
+
+  class StepExecutionContext
+    attr_accessor :workflow
+    attr_accessor :step
+    attr_accessor :persistence_data
+  end
+
+end

data/lib/workflow_rb/models/step_outcome.rb

@@ -0,0 +1,9 @@
+
+module WorkflowRb
+
+  class StepOutcome
+    attr_accessor :value
+    attr_accessor :next_step
+  end
+
+end

data/lib/workflow_rb/models/subscription_step.rb

@@ -0,0 +1,15 @@
+require 'workflow_rb/models/workflow_step'
+require 'workflow_rb/models/subscription_step_body'
+
+module WorkflowRb
+  class SubscriptionStep < WorkflowStep
+    attr_accessor :event_name
+    attr_accessor :event_key
+
+    def initialize
+      super
+      @body = SubscriptionStepBody
+    end
+
+  end
+end

data/lib/workflow_rb/models/subscription_step_body.rb

@@ -0,0 +1,11 @@
+require 'workflow_rb/models/step_body'
+require 'workflow_rb/models/execution_result'
+
+module WorkflowRb
+  class SubscriptionStepBody < StepBody
+    attr_accessor :event_data
+    def run(context)
+      WorkflowRb::ExecutionResult.NextStep
+    end
+  end
+end

data/lib/workflow_rb/models/workflow_definition.rb

@@ -0,0 +1,17 @@
+module WorkflowRb
+
+  class WorkflowDefinition
+    attr_accessor :id
+    attr_accessor :version
+    attr_accessor :data_class
+    attr_accessor :initial_step
+    attr_accessor :steps
+
+    def initialize
+      @steps = []
+    end
+
+
+  end
+
+end

data/lib/workflow_rb/models/workflow_instance.rb

@@ -0,0 +1,30 @@
+module WorkflowRb
+
+  class WorkflowInstance
+    attr_accessor :id
+    attr_accessor :definition_id
+    attr_accessor :version
+    attr_accessor :description
+    attr_accessor :execution_pointers
+    attr_accessor :next_execution
+    attr_accessor :status
+    attr_accessor :data
+    attr_accessor :create_time
+    attr_accessor :complete_time
+
+    def initialize
+      @execution_pointers = []
+
+    end
+
+  end
+
+  class WorkflowStatus
+    RUNNABLE = 0
+    SUSPENDED = 1
+    COMPLETE = 2
+    TERMINATED = 3
+  end
+
+
+end

data/lib/workflow_rb/models/workflow_step.rb

@@ -0,0 +1,21 @@
+module WorkflowRb
+
+  class WorkflowStep
+    attr_accessor :id
+    attr_accessor :name
+
+    attr_accessor :body
+    attr_accessor :outcomes
+    attr_accessor :inputs
+    attr_accessor :outputs
+
+    def initialize
+      @outcomes = []
+      @inputs = []
+      @outputs = []
+    end
+
+
+  end
+
+end

data/lib/workflow_rb/services/memory_persistence_provider.rb

@@ -0,0 +1,66 @@
+require 'securerandom'
+require 'workflow_rb/models/workflow_instance'
+
+module WorkflowRb
+
+  class MemoryPersistenceProvider
+
+    def initialize
+      @instances = []
+      @subscriptions = []
+      @unpublished_events = []
+      @semaphore = Mutex.new
+    end
+
+    def create_new_workflow(workflow)
+      workflow.id = SecureRandom.uuid
+      @instances << workflow
+      workflow.id
+    end
+
+    def persist_workflow(workflow)
+      @semaphore.synchronize do
+        @instances.delete_if {|item| item.id == workflow.id }
+        @instances << workflow
+      end
+    end
+
+    def get_workflow_instance(id)
+      @instances.select {|item| item.id == id}.first
+    end
+
+    def get_runnable_instances
+      @instances.select {|item| item.next_execution and (item.next_execution <= Time.new) and (item.status == WorkflowStatus::RUNNABLE)}
+          .map {|item| item.id}
+    end
+
+    def create_subscription(subscription)
+      subscription.id = SecureRandom.uuid
+      @subscriptions << subscription
+      subscription.id
+    end
+
+    def get_subscriptions(event_name, event_key)
+      @subscriptions.select { |sub| sub.event_name == event_name and sub.event_key == event_key }
+    end
+
+    def terminate_subscription(id)
+      @semaphore.synchronize do
+        @subscriptions.delete_if { |sub| sub.id == id }
+      end
+    end
+
+    def create_unpublished_event(pub)
+      @unpublished_events << pub
+    end
+
+    def remove_unpublished_event(id)
+      @unpublished_events.delete_if { |pub| pub.id == id }
+    end
+
+    def get_unpublished_events
+      @unpublished_events
+    end
+
+  end
+end

data/lib/workflow_rb/services/single_node_lock_provider.rb

@@ -0,0 +1,28 @@
+require 'thread'
+
+module WorkflowRb
+  class SingleNodeLockProvider
+
+    def initialize
+      @semaphore = Mutex.new
+      @named_locks = []
+    end
+
+    def acquire_lock(id)
+      @semaphore.synchronize do
+        if @named_locks.include?(id)
+          return false
+        end
+        @named_locks << id
+        return true
+      end
+    end
+
+    def release_lock(id)
+      @semaphore.synchronize do
+        @named_locks.delete(id)
+      end
+    end
+
+  end
+end

data/lib/workflow_rb/services/single_node_queue_provider.rb

@@ -0,0 +1,36 @@
+require 'thread'
+
+module WorkflowRb
+  class SingleNodeQueueProvider
+
+    def initialize
+      @process_queue = Queue.new
+      @publish_queue = Queue.new
+    end
+
+    def queue_for_processing(id)
+      @process_queue << id
+    end
+
+    def dequeue_for_processing
+      begin
+        return @process_queue.pop(true)
+      rescue
+        return nil
+      end
+    end
+
+    def queue_for_publish(pub)
+      @publish_queue << pub
+    end
+
+    def dequeue_for_publish
+      begin
+        return @publish_queue.pop(true)
+      rescue
+        return nil
+      end
+    end
+
+  end
+end

data/lib/workflow_rb/services/workflow_builder.rb

@@ -0,0 +1,172 @@
+require 'workflow_rb'
+
+module WorkflowRb
+  class WorkflowBuilder
+
+    attr_accessor :initial_step
+    attr_accessor :steps
+
+    def initialize
+      @steps = []
+    end
+
+    def build(id, version, data_class)
+      result = WorkflowDefinition.new
+      result.id = id
+      result.version = version
+      result.data_class = data_class
+      result.steps = @steps
+      result.initial_step = @initial_step
+      result
+    end
+
+    def add_step(step)
+      step.id = @steps.length
+      @steps << step
+    end
+
+    def start_with(body, &setup)
+      new_step = WorkflowStep.new
+      new_step.body = body
+
+      if body.kind_of?(Class)
+        new_step.name = body.name
+      end
+
+      add_step(new_step)
+      @initial_step = new_step.id
+      new_builder = StepBuilder.new(self, new_step)
+      if setup
+        setup.call(new_builder)
+      end
+      new_builder
+    end
+
+    def start_step(&body)
+      start_with(body)
+    end
+
+  end
+
+  class StepBuilder
+
+    attr_accessor :step
+
+    def initialize(workflow_builder, step)
+      @workflow_builder = workflow_builder
+      @step = step
+    end
+
+    def name(name)
+      @step.name = name
+    end
+
+    # Adds a new step to the workflow
+    #
+    # @param body [Class] the step body implementation class
+    def then(body, &setup)
+      new_step = WorkflowStep.new
+      new_step.body = body
+
+      @workflow_builder.add_step(new_step)
+      new_builder = StepBuilder.new(@workflow_builder, new_step)
+
+      if body.kind_of?(Class)
+        new_step.name = body.name
+      end
+
+      if setup
+        setup.call(new_builder)
+      end
+
+      new_outcome = StepOutcome.new
+      new_outcome.next_step = new_step.id
+      new_outcome.value = nil
+      @step.outcomes << new_outcome
+
+      new_builder
+    end
+
+    def then_step(&body)
+      self.then(body)
+    end
+
+    def when(value)
+      new_outcome = StepOutcome.new
+      new_outcome.value = value
+      @step.outcomes << new_outcome
+      new_builder = OutcomeBuilder.new(@workflow_builder, new_outcome)
+      new_builder
+    end
+
+    # Map workflow instance data to a property on the step
+    #
+    # @param step_property [Symbol] the attribute on the step body class
+    def input(step_property, &value)
+      mapping = IOMapping.new
+      mapping.property = step_property
+      mapping.value = value
+      @step.inputs << mapping
+      self
+    end
+
+    def output(data_property, &value)
+      mapping = IOMapping.new
+      mapping.property = data_property
+      mapping.value = value
+      @step.outputs << mapping
+      self
+    end
+
+    def wait_for(event_name, event_key)
+      new_step = SubscriptionStep.new
+      new_step.event_name = event_name
+      new_step.event_key = event_key
+
+      @workflow_builder.add_step(new_step)
+      new_builder = StepBuilder.new(@workflow_builder, new_step)
+      new_step.name = 'WaitFor'
+
+      new_outcome = StepOutcome.new
+      new_outcome.next_step = new_step.id
+      new_outcome.value = nil
+      @step.outcomes << new_outcome
+
+      new_builder
+    end
+
+  end
+
+  class OutcomeBuilder
+
+    attr_accessor :outcome
+
+    def initialize(workflow_builder, outcome)
+      @workflow_builder = workflow_builder
+      @outcome = outcome
+    end
+
+    def then(body, &setup)
+      new_step = WorkflowStep.new
+      new_step.body = body
+
+      @workflow_builder.add_step(new_step)
+      new_builder = StepBuilder.new(@workflow_builder, new_step)
+
+      if setup
+        setup.call(new_builder)
+      end
+
+      @outcome.next_step = new_step.id
+      new_builder
+    end
+
+    def then_step(&body)
+      self.then(body)
+    end
+
+  end
+
+
+end
+

data/lib/workflow_rb/services/workflow_executor.rb

@@ -0,0 +1,146 @@
+require 'workflow_rb/services/workflow_registry'
+require 'workflow_rb/models/execution_pointer'
+require 'workflow_rb/models/workflow_instance'
+require 'workflow_rb/models/step_execution_context'
+require 'workflow_rb/models/subscription_step'
+
+module WorkflowRb
+
+
+  class WorkflowExecutor
+
+
+    public
+      def initialize(registry, persistence, host, logger)
+        @registry = registry
+        @persistence = persistence
+        @host = host
+        @logger = logger
+      end
+
+      def execute(workflow)
+        @logger.debug("Executing workflow #{workflow.id}")
+        exe_pointers = workflow.execution_pointers.select { |x| x.active }
+        definition = @registry.get_definition(workflow.definition_id, workflow.version)
+        if not definition
+          raise Exception "Workflow definition #{workflow.definition_id}"
+        end
+
+        exe_pointers.each do |pointer|
+          step = definition.steps.select { |x| x.id == pointer.step_id }.first
+          if not step
+            raise Exception "Step #{pointer.step_id} not found in definition"
+          end
+
+          if (step.kind_of?(SubscriptionStep)) and (not pointer.event_published)
+            pointer.event_name = step.event_name
+            pointer.event_key = step.event_key
+            pointer.active = false
+            @host.subscribe_event(workflow.id, step.id, step.event_name, step.event_key)
+            next
+          end
+
+
+          if not pointer.start_time
+            pointer.start_time = Time.new
+          end
+
+          execution_context = StepExecutionContext.new
+          execution_context.persistence_data = pointer.persistence_data
+          execution_context.workflow = workflow
+          execution_context.step = step
+
+
+          if step.body.kind_of?(Proc)
+            body_class = Class.new(StepBody) do
+              def initialize(body)
+                @body = body
+              end
+              def run(context)
+                @body.call(context)
+              end
+            end
+            body_obj = body_class.new(step.body)
+          else
+            if step.body <= StepBody
+              body_obj = step.body.new
+            end
+          end
+
+          if not body_obj
+            raise "Cannot construct step body #{step.body}"
+          end
+
+          step.inputs.each do |input|
+            io_value = input.value.call(workflow.data)
+            body_obj.send("#{input.property}=", io_value)
+          end
+
+          if (body_obj.kind_of?(SubscriptionStepBody)) and (pointer.event_published)
+            body_obj.event_data = pointer.event_data
+          end
+
+          result = body_obj.run(execution_context)
+
+          if (result.proceed)
+
+            step.outputs.each do |output|
+              io_value = output.value.call(body_obj)
+              workflow.data.send("#{output.property}=", io_value)
+            end
+
+            pointer.active = false
+            pointer.end_time = Time.new
+            fork_counter = 1
+            pointer.path_terminator = true
+
+            step.outcomes.select {|x| x.value == result.outcome_value}.each do |outcome|
+              new_pointer = ExecutionPointer.new
+              new_pointer.active = true
+              new_pointer.step_id = outcome.next_step
+              new_pointer.concurrent_fork = fork_counter * pointer.concurrent_fork
+              workflow.execution_pointers << new_pointer
+              pointer.path_terminator = false
+              fork_counter += 1
+            end
+          else
+            pointer.persistence_data = result.persistence_data
+            pointer.sleep_until = result.sleep_until
+          end
+
+        end
+        determine_next_execution(workflow)
+        @persistence.persist_workflow(workflow)
+      end
+
+    private
+      def determine_next_execution(workflow)
+        workflow.next_execution = nil
+        workflow.execution_pointers.select {|item| item.active }.each do |pointer|
+          if not pointer.sleep_until
+            workflow.next_execution = Time.new
+            return
+          end
+          workflow.next_execution = [pointer.sleep_until, workflow.next_execution ? workflow.next_execution : pointer.sleep_until].min
+        end
+
+        if not workflow.next_execution
+          forks = 1
+          terminals = 0
+          workflow.execution_pointers.each do |pointer|
+            forks = [forks, pointer.concurrent_fork].max
+            if pointer.path_terminator
+              terminals += 1
+            end
+          end
+          if forks <= terminals
+            workflow.status = WorkflowStatus::COMPLETE
+            workflow.complete_time = Time.new
+          end
+        end
+      end
+
+
+  end
+
+end

data/lib/workflow_rb/services/workflow_host.rb

@@ -0,0 +1,276 @@
+require 'securerandom'
+require 'logger'
+require 'etc'
+require 'workflow_rb'
+require 'workflow_rb/services/memory_persistence_provider'
+require 'workflow_rb/services/single_node_queue_provider'
+require 'workflow_rb/services/single_node_lock_provider'
+
+module WorkflowRb
+  class WorkflowHost
+
+    def initialize
+      @persistence = MemoryPersistenceProvider.new
+      @queue_provider = SingleNodeQueueProvider.new
+      @lock_provider = SingleNodeLockProvider.new
+      @registry = WorkflowRegistry.new
+      @is_shutdown = true;
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::WARN
+      @thread_count = Etc.nprocessors
+      @threads = []
+      @poll_interval = 5
+      @poll_tick = 0
+    end
+
+    def use_logger(logger)
+      @logger = logger
+    end
+
+    def use_persistence(persistence)
+      @persistence = persistence
+    end
+
+    def register_workflow(workflow_class)
+      builder = WorkflowRb::WorkflowBuilder.new
+      workflow_obj = workflow_class.new
+      workflow_obj.build(builder)
+      definition = builder.build(workflow_class::ID, workflow_class::VERSION, workflow_class::DATA_CLASS)
+      @registry.register_workflow(definition)
+    end
+
+    def start_workflow(definition_id, version, data = nil)
+      wf_def = @registry.get_definition(definition_id, version)
+
+      wf = WorkflowInstance.new
+      wf.definition_id = definition_id
+      wf.version = version
+      wf.next_execution = Time.new
+      wf.create_time = Time.new
+      wf.status = WorkflowStatus::RUNNABLE
+
+      if data
+        wf.data = data
+      else
+        if wf_def.data_class
+          wf.data = wf_def.data_class.new
+        end
+      end
+
+      ep = ExecutionPointer.new
+      ep.active = true
+      ep.step_id = wf_def.initial_step
+      ep.concurrent_fork = 1
+      wf.execution_pointers << ep
+
+      id = @persistence.create_new_workflow(wf)
+      @queue_provider.queue_for_processing(id)
+      id
+    end
+
+    def start
+      if (@is_shutdown)
+        @is_shutdown = false;
+        @logger.info('Starting worker thread pool')
+
+        @thread_count.times do
+          @threads << Thread.new { run_workflows }
+        end
+
+        @threads << Thread.new { run_publications }
+        @threads << Thread.new { house_keeping }
+
+      end
+    end
+
+    def stop
+      @is_shutdown = true;
+      @logger.info('Stopping worker thread pool')
+      @threads.each do |thread|
+        thread.join(10)
+      end
+    end
+
+    def subscribe_event(workflow_id, step_id, event_name, event_key)
+      @logger.info("Subscribing to event #{event_name} #{event_key} for workflow #{workflow_id} step #{step_id}")
+      sub = EventSubscription.new
+      sub.workflow_id = workflow_id
+      sub.step_id = step_id
+      sub.event_name = event_name
+      sub.event_key = event_key
+      @persistence.create_subscription(sub)
+    end
+
+    def publish_event(event_name, event_key, event_data)
+      if @is_shutdown
+        raise Exception 'Host is not running'
+      end
+      @logger.info("Publishing event #{event_name} #{event_key}")
+      subs = @persistence.get_subscriptions(event_name, event_key)
+      subs.each do |sub|
+        pub = EventPublication.new
+        pub.id = SecureRandom.uuid
+        pub.event_data = event_data
+        pub.event_key = event_key
+        pub.event_name = event_name
+        pub.step_id = sub.step_id
+        pub.workflow_id = sub.workflow_id
+        @queue_provider.queue_for_publish(pub)
+        @persistence.terminate_subscription(sub.id)
+      end
+    end
+
+    def suspend_workflow(id)
+      if @lock_provider.acquire_lock(id)
+        begin
+          workflow = @persistence.get_workflow_instance(id)
+          if workflow.status == WorkflowStatus::RUNNABLE
+            workflow.status = WorkflowStatus::SUSPENDED
+            @persistence.persist_workflow(workflow)
+            return true
+          else
+            return false
+          end
+        rescue Exception => e
+          @logger.error("#{e.message} #{e.backtrace}")
+        ensure
+          @lock_provider.release_lock(id)
+        end
+      else
+        false
+      end
+    end
+
+    def resume_workflow(id)
+      if @lock_provider.acquire_lock(id)
+        begin
+          workflow = @persistence.get_workflow_instance(id)
+          if workflow.status == WorkflowStatus::SUSPENDED
+            workflow.status = WorkflowStatus::RUNNABLE
+            @persistence.persist_workflow(workflow)
+            return true
+          else
+            return false
+          end
+        rescue Exception => e
+          @logger.error("#{e.message} #{e.backtrace}")
+        ensure
+          @lock_provider.release_lock(id)
+        end
+      else
+        false
+      end
+    end
+
+    def terminate_workflow(id)
+      if @lock_provider.acquire_lock(id)
+        begin
+          workflow = @persistence.get_workflow_instance(id)
+          workflow.status = WorkflowStatus::TERMINATED
+          @persistence.persist_workflow(workflow)
+          return true
+        rescue Exception => e
+          @logger.error("#{e.message} #{e.backtrace}")
+        ensure
+          @lock_provider.release_lock(id)
+        end
+      else
+        false
+      end
+    end
+
+    private
+
+    def run_workflows
+      executor = WorkflowExecutor.new(@registry, @persistence, self, @logger)
+      while not @is_shutdown
+        begin
+          workflow_id = @queue_provider.dequeue_for_processing
+          if (workflow_id)
+
+            if @lock_provider.acquire_lock(workflow_id)
+              begin
+              workflow = @persistence.get_workflow_instance(workflow_id)
+              executor.execute(workflow)
+              ensure
+                @lock_provider.release_lock(workflow_id)
+              end
+
+              if workflow.next_execution
+                if (workflow.status == WorkflowStatus::RUNNABLE) and (workflow.next_execution <= Time.new)
+                  @queue_provider.queue_for_processing(workflow_id)
+                end
+              end
+            else
+              @logger.info("Workflow #{workflow_id} is locked")
+            end
+          else
+            sleep(0.2) #no work
+          end
+        rescue Exception => e
+          @logger.error("#{e.message} #{e.backtrace}")
+        end
+      end
+    end
+
+    def run_publications
+      while not @is_shutdown
+        begin
+          pub = @queue_provider.dequeue_for_publish
+          if (pub)
+            if @lock_provider.acquire_lock(pub.workflow_id)
+              begin
+                workflow = @persistence.get_workflow_instance(pub.workflow_id)
+                pointers = workflow.execution_pointers.select { |ep| ep.event_name == pub.event_name and ep.event_key == pub.event_key and not ep.event_published}
+                pointers.each do |pointer|
+                  pointer.event_data = pub.event_data
+                  pointer.event_published = true
+                  pointer.active = true
+                end
+                workflow.next_execution = Time.new
+                @persistence.persist_workflow(workflow)
+              rescue Exception => e
+                @logger.error(e)
+                @persistence.create_unpublished_event(pub)
+              ensure
+                @lock_provider.release_lock(pub.workflow_id)
+                @queue_provider.queue_for_processing(pub.workflow_id)
+              end
+
+              if workflow.next_execution
+                if (workflow.status == WorkflowStatus::RUNNABLE) and (workflow.next_execution <= Time.new)
+                  @queue_provider.queue_for_processing(pub.workflow_id)
+                end
+              end
+            else
+              @logger.info("Workflow #{workflow_id} is locked")
+            end
+          else
+            sleep(0.5) #no work
+          end
+        rescue Exception => e
+          @logger.error("#{e.message} #{e.backtrace}")
+        end
+      end
+    end
+
+    def house_keeping
+      while (!@is_shutdown)
+        begin
+          if (@poll_tick >= @poll_interval)
+            @poll_tick = 0
+            @logger.debug('Polling for runnable instances')
+            @persistence.get_runnable_instances.each do |item|
+              @queue_provider.queue_for_processing(item)
+            end
+          end
+          @poll_tick += 1
+          sleep(1)
+        rescue Exception => e
+          @logger.error("#{e.message} #{e.backtrace}")
+        end
+      end
+    end
+
+  end
+end

data/lib/workflow_rb/services/workflow_registry.rb

@@ -0,0 +1,24 @@
+module WorkflowRb
+
+  class WorkflowRegistry
+
+    def initialize
+      @registry = []
+    end
+
+    def get_definition(id, version)
+      @registry.each do |item|
+        if (item.id == id) and (item.version == version)
+          return item
+        end
+      end
+
+    end
+
+    def register_workflow(definition)
+      @registry << definition
+    end
+
+  end
+
+end

data/lib/workflow_rb/version.rb

@@ -0,0 +1,3 @@
+module WorkflowRb
+  VERSION = "0.1.0"
+end

data/lib/workflow_rb.rb

@@ -0,0 +1,21 @@
+require 'workflow_rb/version'
+require 'workflow_rb/services/workflow_executor'
+require 'workflow_rb/services/workflow_registry'
+require 'workflow_rb/services/workflow_host'
+require 'workflow_rb/services/workflow_builder'
+require 'workflow_rb/models/workflow_instance'
+require 'workflow_rb/models/execution_result'
+require 'workflow_rb/models/workflow_definition'
+require 'workflow_rb/models/workflow_step'
+require 'workflow_rb/models/step_outcome'
+require 'workflow_rb/models/step_body'
+require 'workflow_rb/models/io_mapping'
+require 'workflow_rb/models/subscription_step'
+require 'workflow_rb/models/subscription_step_body'
+require 'workflow_rb/models/event_publication'
+require 'workflow_rb/models/event_subscription'
+
+module WorkflowRb
+  # Your code goes here...
+end
+

data/workflow_rb.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'workflow_rb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "workflow_rb"
+  spec.version       = WorkflowRb::VERSION
+  spec.authors       = ["Daniel Gerlag"]
+  spec.email         = ["daniel@gerlag.ca"]
+
+  spec.summary       = %q{Lightweight workflow library}
+  spec.homepage      = "http://github.com/danielgerlag/workflow_rb"
+
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: workflow_rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Gerlag
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-12-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email:
+- daniel@gerlag.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/workflow_rb.rb
+- lib/workflow_rb/models/event_publication.rb
+- lib/workflow_rb/models/event_subscription.rb
+- lib/workflow_rb/models/execution_pointer.rb
+- lib/workflow_rb/models/execution_result.rb
+- lib/workflow_rb/models/io_mapping.rb
+- lib/workflow_rb/models/step_body.rb
+- lib/workflow_rb/models/step_execution_context.rb
+- lib/workflow_rb/models/step_outcome.rb
+- lib/workflow_rb/models/subscription_step.rb
+- lib/workflow_rb/models/subscription_step_body.rb
+- lib/workflow_rb/models/workflow_definition.rb
+- lib/workflow_rb/models/workflow_instance.rb
+- lib/workflow_rb/models/workflow_step.rb
+- lib/workflow_rb/services/memory_persistence_provider.rb
+- lib/workflow_rb/services/single_node_lock_provider.rb
+- lib/workflow_rb/services/single_node_queue_provider.rb
+- lib/workflow_rb/services/workflow_builder.rb
+- lib/workflow_rb/services/workflow_executor.rb
+- lib/workflow_rb/services/workflow_host.rb
+- lib/workflow_rb/services/workflow_registry.rb
+- lib/workflow_rb/version.rb
+- workflow_rb.gemspec
+homepage: http://github.com/danielgerlag/workflow_rb
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.7
+signing_key: 
+specification_version: 4
+summary: Lightweight workflow library
+test_files: []