swarm 0.1.0

data/lib/swarm/process.rb

@@ -0,0 +1,57 @@
+require "timeout"
+
+module Swarm
+  class Process < HiveDweller
+    set_columns :process_definition_id, :workitem, :root_expression_id, :parent_expression_id
+    many_to_one :process_definition, :class_name => "Swarm::ProcessDefinition"
+    many_to_one :parent_expression, :class_name => "Swarm::Expression"
+
+    def wait_until_finished(timeout: 5)
+      Swarm::Support.wait_until(timeout: timeout) { finished? }
+    end
+
+    def launch
+      hive.queue('launch', self)
+      self
+    end
+
+    def _launch
+      root_expression = SequenceExpression.create(
+        :hive => hive,
+        :parent_id => id,
+        :position => [0],
+        :workitem => workitem,
+        :process_id => id
+      )
+      root_expression.apply
+      self.root_expression_id = root_expression.id
+      save
+    end
+
+    def root_expression
+      @root_expression ||= begin
+        reload! unless root_expression_id
+        if root_expression_id
+          Expression.fetch(root_expression_id, hive: hive)
+        end
+      end
+    end
+
+    def finished?
+      root_expression && root_expression.replied?
+    end
+
+    def node_at_position(position)
+      raise ArgumentError unless position == 0
+      process_definition.tree
+    end
+
+    def move_on_from(expression)
+      self.workitem = expression.workitem
+      save
+      if parent_expression
+        parent_expression.move_on_from(self)
+      end
+    end
+  end
+end

data/lib/swarm/process_definition.rb

@@ -0,0 +1,53 @@
+require "json"
+
+module Swarm
+  class ProcessDefinition < HiveDweller
+    class NotYetPersistedError < StandardError; end
+
+    set_columns :tree, :name, :version
+
+    class << self
+      def create_from_json(json, hive: Hive.default)
+        create(**parse_json_definition(json).merge(:hive => hive))
+      end
+
+      def create_from_pollen(pollen, hive: Hive.default)
+        json = Swarm::Pollen::Reader.new(pollen).to_json
+        create_from_json(json, hive: hive)
+      end
+
+      def parse_json_definition(json)
+        parsed = JSON.parse(json)
+        if parsed.is_a?(Array)
+          { :tree => parsed }
+        else
+          {
+            :name => parsed["name"],
+            :version => parsed["version"],
+            :tree => parsed["definition"]
+          }
+        end
+      end
+
+      def find_by_name(name)
+        detect { |definition| definition.name == name }
+      end
+    end
+
+    def create_process(workitem:, **args)
+      raise NotYetPersistedError unless id
+      Process.create(
+        args.merge({
+          :workitem => workitem,
+          :hive => hive,
+          :process_definition_id => id
+        })
+      )
+    end
+
+    def launch_process(workitem:, **args)
+      process = create_process(workitem: workitem, **args)
+      process.launch
+    end
+  end
+end

data/lib/swarm/router.rb

@@ -0,0 +1,18 @@
+module Swarm
+  class Router
+    class << self
+      def expression_class_for_node(node)
+        command = node[0]
+        expression_type = case command
+        when "if", "unless"
+          "conditional"
+        when "sequence", "concurrence", "subprocess"
+          command
+        else
+          "activity"
+        end
+        Swarm::Support.constantize("swarm/#{expression_type}_expression")
+      end
+    end
+  end
+end

data/lib/swarm/storage.rb

@@ -0,0 +1,56 @@
+module Swarm
+  class Storage
+    attr_reader :backend
+
+    def initialize(backend)
+      @backend = backend
+    end
+
+    def regex_for_type(type)
+      /^#{type}\:(.*)/
+    end
+
+    def ids_for_type(type)
+      keys = if backend.is_a?(Redis)
+        backend.keys("#{type}:*")
+      else
+        backend.keys.select { |key| key.match(regex_for_type(type)) }
+      end
+      keys.map { |key| key.gsub(regex_for_type(type), '\1') }
+    end
+
+    def serialize(value)
+      return nil if value.nil?
+      value.to_json
+    end
+
+    def deserialize(value)
+      return nil if value.nil?
+      JSON.parse(value)
+    end
+
+    def [](key)
+      deserialize(backend[key])
+    end
+
+    def []=(key, value)
+      backend[key] = serialize(value)
+    end
+
+    def delete(key)
+      if backend.respond_to?(:del)
+        backend.del(key)
+      else
+        backend.delete(key)
+      end
+    end
+
+    def truncate
+      if backend.respond_to?(:flushdb)
+        backend.flushdb
+      else
+        backend.clear
+      end
+    end
+  end
+end

data/lib/swarm/stored_workitem.rb

@@ -0,0 +1,15 @@
+module Swarm
+  class StoredWorkitem < HiveDweller
+    extend Forwardable
+
+    def_delegators :expression, :node, :command, :arguments, :process_id, :workitem
+
+    set_columns :expression_id
+    many_to_one :expression, :class_name => "Swarm::Expression"
+
+    def proceed
+      delete
+      expression.reply
+    end
+  end
+end

data/lib/swarm/support.rb

@@ -0,0 +1,81 @@
+require "securerandom"
+
+module Swarm
+  module Support
+    class << self
+      def deep_merge(hsh1, hsh2, combine_arrays: :override)
+        hsh1.merge(hsh2) { |key, v1, v2|
+          if [v1, v2].all? { |v| v.is_a?(Array) }
+            combine_arrays(v1, v2, method: combine_arrays)
+          elsif [v1, v2].all? { |v| v.is_a?(Hash) }
+            deep_merge(v1, v2)
+          else
+            v2
+          end
+        }
+      end
+
+      def symbolize_keys!(hsh)
+        hsh.keys.each do |key|
+          hsh[key.to_sym] = hsh.delete(key)
+        end
+        hsh
+      end
+
+      def symbolize_keys(hsh)
+        symbolize_keys!(hsh.dup)
+      end
+
+      def combine_arrays(v1, v2, method: :concat)
+        case method.to_s
+        when "uniq"
+          v1 | v2
+        when "concat"
+          v1.concat v2
+        when "override"
+          v2
+        else
+          raise ArgumentError, "unknown array combination method: #{method}"
+        end
+      end
+
+      def uuid_with_timestamp
+        "#{Time.now.strftime("%Y%m%d-%H%M%S")}-#{SecureRandom.uuid}"
+      end
+
+      def camelize(string)
+        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+        string = string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+      end
+
+      def constantize(string)
+        name_parts = camelize(string).split('::')
+        name_parts.shift if name_parts.first.empty?
+        constant = Object
+
+        name_parts.each do |name_part|
+          const_defined_args = [name_part]
+          const_defined_args << false unless Module.method(:const_defined?).arity == 1
+          constant_defined = constant.const_defined?(*const_defined_args)
+          constant = constant_defined ? constant.const_get(name_part) : constant.const_missing(name_part)
+        end
+        constant
+      end
+
+      def slice(hash, *keys)
+        {}.tap { |h|
+          keys.each { |k|
+            h[k] = hash[k] if hash.has_key?(k)
+          }
+        }
+      end
+
+      def wait_until(timeout: 5, initial_delay: nil)
+        sleep(initial_delay) if initial_delay.is_a?(Numeric)
+        Timeout::timeout(timeout) do
+          sleep 0.05 until yield
+        end
+      end
+    end
+  end
+end

data/lib/swarm/version.rb

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

data/lib/swarm.rb

@@ -0,0 +1,24 @@
+require "swarm/version"
+require "swarm/support"
+require "swarm/engine/base/queue"
+require "swarm/engine/volatile/queue"
+require "swarm/engine/worker"
+require "swarm/hive"
+require "swarm/hive_dweller"
+require "swarm/process_definition"
+require "swarm/process"
+require "swarm/expression"
+require "swarm/expressions/conditional_expression"
+require "swarm/expressions/concurrence_expression"
+require "swarm/expressions/sequence_expression"
+require "swarm/expressions/activity_expression"
+require "swarm/expressions/subprocess_expression"
+require "swarm/stored_workitem"
+require "swarm/participants/trace_participant"
+require "swarm/participants/storage_participant"
+require "swarm/pollen/reader"
+require "redis"
+
+module Swarm
+  # Your code goes here...
+end

data/swarm.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'swarm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "swarm"
+  spec.version       = Swarm::VERSION
+  spec.authors       = ["Ravi Gadad"]
+  spec.email         = ["ravi@gadad.net"]
+
+  spec.summary       = %q{A Ruby workflow engine}
+  spec.description   = %q{A Ruby workflow engine}
+  spec.homepage      = "https://github.com/bumbleworks/swarm"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "redis"
+  spec.add_dependency "parslet"
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "timecop", "~> 0.7"
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: swarm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ravi Gadad
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby workflow engine
+email:
+- ravi@gadad.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/swarm.rb
+- lib/swarm/engine/base/job.rb
+- lib/swarm/engine/base/queue.rb
+- lib/swarm/engine/volatile/job.rb
+- lib/swarm/engine/volatile/queue.rb
+- lib/swarm/engine/worker.rb
+- lib/swarm/engine/worker/command.rb
+- lib/swarm/evaluation/expression_evaluator.rb
+- lib/swarm/evaluation/workitem_context.rb
+- lib/swarm/expression.rb
+- lib/swarm/expressions/activity_expression.rb
+- lib/swarm/expressions/branch_expression.rb
+- lib/swarm/expressions/concurrence_expression.rb
+- lib/swarm/expressions/conditional_expression.rb
+- lib/swarm/expressions/sequence_expression.rb
+- lib/swarm/expressions/subprocess_expression.rb
+- lib/swarm/hive.rb
+- lib/swarm/hive_dweller.rb
+- lib/swarm/observers/base.rb
+- lib/swarm/participant.rb
+- lib/swarm/participants/storage_participant.rb
+- lib/swarm/participants/trace_participant.rb
+- lib/swarm/pollen/parser.rb
+- lib/swarm/pollen/reader.rb
+- lib/swarm/pollen/transformer.rb
+- lib/swarm/process.rb
+- lib/swarm/process_definition.rb
+- lib/swarm/router.rb
+- lib/swarm/storage.rb
+- lib/swarm/stored_workitem.rb
+- lib/swarm/support.rb
+- lib/swarm/version.rb
+- swarm.gemspec
+homepage: https://github.com/bumbleworks/swarm
+licenses:
+- MIT
+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.2.5
+signing_key: 
+specification_version: 4
+summary: A Ruby workflow engine
+test_files: []