bumbleworks 0.0.48 → 0.0.50

data/.gitignore

@@ -14,4 +14,7 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
-.bash_color
+.bash_color
+*.sublime-*
+default.vim
+default.vim.lock

data/lib/bumbleworks.rb

@@ -3,17 +3,18 @@ require "bumbleworks/version"
 require "bumbleworks/configuration"
 require "bumbleworks/support"
 require "bumbleworks/process_definition"
+require "bumbleworks/process"
 require "bumbleworks/task"
 require "bumbleworks/participant_registration"
 require "bumbleworks/ruote"
 require "bumbleworks/hash_storage"
-require "bumbleworks/simple_logger"
-require "bumbleworks/storage_participant"
-require "bumbleworks/local_participant"
-require "bumbleworks/participant"
 require "bumbleworks/error_handler"
+require "bumbleworks/entity"
+require "bumbleworks/participant"
+
+# default implementations
+require "bumbleworks/simple_logger"
 require "bumbleworks/error_logger"
-require "bumbleworks/error_handler_participant"
 
 module Bumbleworks
   class UnsupportedMode < StandardError; end
@@ -23,7 +24,6 @@ module Bumbleworks
 
   class << self
     extend Forwardable
-    attr_accessor :env
 
     Configuration.defined_settings.each do |setting|
       def_delegators :configuration, setting, "#{setting.to_s}="
@@ -136,7 +136,8 @@ module Bumbleworks
     #
     def launch!(process_definition_name, *args)
       extract_entity_from_fields!(args.first || {})
-      Bumbleworks::Ruote.launch(process_definition_name, *args)
+      pid = Bumbleworks::Ruote.launch(process_definition_name, *args)
+      Bumbleworks::Process.new(pid)
     end
 
   private
@@ -149,7 +150,7 @@ module Bumbleworks
           raise InvalidEntity, "Entity#id must be non-null" unless fields[:entity_id]
         end
       rescue NoMethodError => e
-        raise InvalidEntity, "Entity must respond to #id and #class.name"
+        raise InvalidEntity, "Entity must respond to #identifier (or #id) and #class.name"
       end
     end
   end

data/lib/bumbleworks/configuration.rb

@@ -115,9 +115,11 @@ module Bumbleworks
     # default: 5 seconds
     define_setting :timeout
 
-    # When errors occur during the exection of a process, errors are captured and dispatched to
-    # the registerd error handlers.  an error handler derives from the Bumbleworks::ErrorHandler
-    # and will receive the error information through the #on_error method.
+    # When errors occur during the execution of a process, errors are captured and dispatched to
+    # the registered error handlers.  An error handler must take a single initialization argument
+    # (the workitem at the point of error), and implement the #on_error method.  You can subclass the
+    # Bumbleworks::ErrorHandler class for the initializer and workitem entity storage.  The default
+    # handler (Bumbleworks::ErrorLogger) will simply send the configured logger an ERROR log entry.
     #
     # class MySpecialHandler < Bumbleworks::ErrorHandler
     #   def on_error
@@ -126,11 +128,12 @@ module Bumbleworks
     # end
     #
     # For exclusive use:
-    #   Bumbleworks.error_handlers = [MySpeicalHandler, MySpecialHandler2]
+    #   Bumbleworks.error_handlers = [MySpecialHandler, MySpecialHandler2]
     #
     # To append to exisiting handlers:
-    #   Bumbleworks.error_handlers << MySpeicalHandler
+    #   Bumbleworks.error_handlers << MySpecialHandler
     #
+    # default: Bumbleworks::ErrorLogger
     define_setting :error_handlers
 
     # If #store_history is true, all messages will be logged in the storage under a special

data/lib/bumbleworks/entity.rb

@@ -0,0 +1,88 @@
+module Bumbleworks
+  module Entity
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    def launch_process(process_name, options = {})
+      identifier_column = self.class.processes[process_name.to_sym][:column]
+      if (options[:force] == true || (process_identifier = self.send(identifier_column)).nil?)
+        workitem_fields = process_fields(process_name.to_sym)
+        variables = process_variables(process_name.to_sym)
+        process_identifier = Bumbleworks.launch!(process_name.to_s, workitem_fields, variables).wfid
+        persist_process_identifier(identifier_column.to_sym, process_identifier)
+      end
+      Bumbleworks::Process.new(process_identifier)
+    end
+
+    def persist_process_identifier(identifier_column, process_identifier)
+      if self.respond_to?(:update)
+        update(identifier_column => process_identifier)
+      else
+        raise "Entity must define #persist_process_identifier method if missing #update method."
+      end
+    end
+
+    def processes_by_name
+      return {} unless self.class.processes
+      process_names = self.class.processes.keys
+      process_names.inject({}) do |memo, name|
+        pid = self.send(self.class.processes[name][:column])
+        memo[name] = pid ? Bumbleworks::Process.new(pid) : nil
+        memo
+      end
+    end
+
+    def processes
+      processes_by_name.values.compact
+    end
+
+    def cancel_all_processes!
+      processes.each do |process|
+        process.cancel!
+      end
+    end
+
+    def tasks(nickname = nil)
+      finder = Bumbleworks::Task.for_entity(self)
+      finder = finder.by_nickname(nickname) if nickname
+      finder
+    end
+
+    def process_fields(process_name = nil)
+      { :entity => self }
+    end
+
+    def process_variables(process_name = nil)
+      {}
+    end
+
+    def subscribed_events
+      processes.values.compact.map(&:subscribed_events).flatten.uniq
+    end
+
+    def is_waiting_for?(event)
+      subscribed_events.include? event.to_s
+    end
+
+    module ClassMethods
+      attr_reader :processes
+
+      def process(process_name, options = {})
+        options[:column] ||= process_identifier_column(process_name)
+        (@processes ||= {})[process_name.to_sym] = options
+      end
+
+      def entity_type
+        Bumbleworks::Support.tokenize(name)
+      end
+
+      def process_identifier_column(process_name)
+        identifier_column = "#{process_name}_process_identifier"
+        identifier_column.gsub!(/^#{entity_type}_/, '')
+        identifier_column.gsub!(/process_process/, 'process')
+        identifier_column.to_sym
+      end
+    end
+  end
+end

data/lib/bumbleworks/participant.rb

@@ -1,11 +1,10 @@
-require "bumbleworks/local_participant"
+require "bumbleworks/participant/storage_participant"
+require "bumbleworks/participant/local_participant"
+require "bumbleworks/participant/base"
+require "bumbleworks/participant/error_handler"
+require "bumbleworks/participant/entity_interactor"
 
 module Bumbleworks
-  class Participant
-    include LocalParticipant
-
-    def on_cancel
-      # default no-op method
-    end
+  module Participant
   end
 end

data/lib/bumbleworks/participant/base.rb

@@ -0,0 +1,11 @@
+module Bumbleworks
+  module Participant
+    class Base
+      include LocalParticipant
+
+      def on_cancel
+        # default no-op method
+      end
+    end
+  end
+end

data/lib/bumbleworks/participant/entity_interactor.rb

@@ -0,0 +1,29 @@
+module Bumbleworks
+  module Participant
+    class EntityInteractor < Bumbleworks::Participant::Base
+      def on_workitem
+        method_name = workitem.fields['params']['method'] ||
+          workitem.fields['params']['to'] ||
+          workitem.fields['params']['for']
+        result_field = workitem.fields['params']['and_save_as']
+        arguments = workitem.fields['params']['arguments'] ||
+          workitem.fields['params']['with']
+        result = call_method(method_name, :save_as => result_field, :args => arguments)
+        reply
+      end
+
+      def call_method(method_name, options = {})
+        result = if options[:args]
+          options[:args] = [options[:args]] if options[:args].is_a?(Hash)
+          entity.send(method_name, *options[:args])
+        else
+          entity.send(method_name)
+        end
+        if result && options[:save_as]
+          workitem.fields[options[:save_as]] = result
+        end
+        result
+      end
+    end
+  end
+end

data/lib/bumbleworks/participant/error_handler.rb

@@ -0,0 +1,14 @@
+module Bumbleworks
+  module Participant
+    class ErrorHandler < Bumbleworks::Participant::Base
+      def on_workitem
+        return if (error_handlers = Bumbleworks.error_handlers).empty?
+
+        error_handlers.each do |error_handler|
+          error_handler.new(workitem).on_error
+        end
+        reply
+      end
+    end
+  end
+end

data/lib/bumbleworks/participant/local_participant.rb

@@ -0,0 +1,11 @@
+require "ruote/part/local_participant"
+require "bumbleworks/workitem_entity_storage"
+
+module Bumbleworks
+  module Participant
+    module LocalParticipant
+      include ::Ruote::LocalParticipant
+      include WorkitemEntityStorage
+    end
+  end
+end

data/lib/bumbleworks/participant/storage_participant.rb

@@ -0,0 +1,11 @@
+module Bumbleworks
+  module Participant
+    class StorageParticipant < ::Ruote::StorageParticipant
+      def on_workitem
+        return_value = super
+        Bumbleworks::Task.new(self[workitem.sid]).on_dispatch
+        return return_value
+      end
+    end
+  end
+end

data/lib/bumbleworks/process.rb

@@ -0,0 +1,64 @@
+module Bumbleworks
+  class Process
+    attr_reader :id
+
+    def initialize(wfid)
+      @id = wfid
+    end
+
+    alias_method :wfid, :id
+
+    def ==(other)
+      wfid == other.wfid
+    end
+
+    def tasks
+      Bumbleworks::Task.for_process(wfid)
+    end
+
+    def trackers
+      Bumbleworks.dashboard.get_trackers.values.select { |attrs|
+        attrs['msg']['fei'] && attrs['msg']['fei']['wfid'] == id
+      }
+    end
+
+    def all_subscribed_tags
+      events = trackers.inject({}) do |memo, t|
+        if t['wfid'].nil?
+          (memo[:global] ||= []).concat t['conditions']['tag']
+        else
+          (memo[t['wfid']] ||= []).concat t['conditions']['tag']
+        end
+        memo
+      end
+    end
+
+    def subscribed_events
+      all_subscribed_tags[:global]
+    end
+
+    def is_waiting_for?(event)
+      subscribed_events.include? event.to_s
+    end
+
+    def kill!
+      Bumbleworks.kill_process!(wfid)
+    end
+
+    def cancel!
+      Bumbleworks.cancel_process!(wfid)
+    end
+
+    def process_status
+      Bumbleworks.dashboard.process(id)
+    end
+
+    def method_missing(method, *args)
+      ps = process_status
+      if ps.respond_to?(method)
+        return ps.send(method, *args)
+      end
+      super
+    end
+  end
+end

data/lib/bumbleworks/ruote.rb

@@ -56,7 +56,7 @@ module Bumbleworks
         while dashboard.process(wfid)
           if (Time.now - start_time) > options[:timeout]
             error_type = options[:method] == :cancel ? CancelTimeout : KillTimeout
-            raise error_type, "Process #{options[:method]} taking too long - #{dashboard.processes.count} processes remain.  Errors: #{dashboard.errors}"
+            raise error_type, "Process #{options[:method]} for wfid '#{wfid}' taking too long.  Errors: #{dashboard.errors(wfid)}"
           end
           sleep 0.1
         end
@@ -100,14 +100,22 @@ module Bumbleworks
 
       def register_participants(&block)
         dashboard.register(&block) if block
+        register_entity_interactor
         register_error_handler
         set_catchall_if_needed
         dashboard.participant_list
       end
 
+      def register_entity_interactor
+        unless dashboard.participant_list.any? { |part| part.regex == "^(ask|tell)_entity$" }
+          entity_interactor = ::Ruote::ParticipantEntry.new(["^(ask|tell)_entity$", ["Bumbleworks::Participant::EntityInteractor", {}]])
+          dashboard.participant_list = dashboard.participant_list.unshift(entity_interactor)
+        end
+      end
+
       def register_error_handler
         unless dashboard.participant_list.any? { |part| part.regex == '^error_handler_participant$' }
-          error_handler_participant = ::Ruote::ParticipantEntry.new(['^error_handler_participant$', ["Bumbleworks::ErrorHandlerParticipant", {}]])
+          error_handler_participant = ::Ruote::ParticipantEntry.new(['^error_handler_participant$', ["Bumbleworks::Participant::ErrorHandler", {}]])
           dashboard.participant_list = dashboard.participant_list.unshift(error_handler_participant)
           dashboard.on_error = 'error_handler_participant'
         end
@@ -122,8 +130,8 @@ module Bumbleworks
       def set_catchall_if_needed
         last_participant = dashboard.participant_list.last
         unless last_participant && last_participant.regex == "^.+$" &&
-            ["Ruote::StorageParticipant", "Bumbleworks::StorageParticipant"].include?(last_participant.classname)
-          catchall = ::Ruote::ParticipantEntry.new(["^.+$", ["Bumbleworks::StorageParticipant", {}]])
+            ["Ruote::StorageParticipant", "Bumbleworks::Participant::StorageParticipant"].include?(last_participant.classname)
+          catchall = ::Ruote::ParticipantEntry.new(["^.+$", ["Bumbleworks::Participant::StorageParticipant", {}]])
           dashboard.participant_list = dashboard.participant_list.push(catchall)
         end
       end

data/lib/bumbleworks/support.rb

@@ -24,11 +24,9 @@ module Bumbleworks
       constant = Object
 
       name_parts.each do |name_part|
-        constant_defined = if Module.method(:const_defined?).arity == 1
-          constant.const_defined?(name_part)
-        else
-          constant.const_defined?(name_part, false)
-        end
+        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

data/lib/bumbleworks/task.rb

@@ -1,5 +1,5 @@
-require "bumbleworks/tasks/base"
 require "bumbleworks/workitem_entity_storage"
+require "bumbleworks/task/base"
 require "bumbleworks/task/finder"
 
 module Bumbleworks
@@ -80,9 +80,11 @@ module Bumbleworks
     end
 
     def extend_module
-      extend Bumbleworks::Tasks::Base
-      extend task_module if nickname
-    rescue NameError
+      extend Bumbleworks::Task::Base
+      begin
+        extend task_module if nickname
+      rescue NameError
+      end
     end
 
     def task_module

data/lib/bumbleworks/{tasks → task}/base.rb

@@ -1,5 +1,5 @@
 module Bumbleworks
-  module Tasks
+  class Task
     module Base
       def before_update(params); end
       def after_update(params); end

data/lib/bumbleworks/task/finder.rb

@@ -5,7 +5,14 @@ module Bumbleworks
 
       def initialize(queries = [], task_class = Bumbleworks::Task)
         @queries = queries
+        @queries << proc { |wi| wi['fields']['params']['task'] }
         @task_class = task_class
+        @task_filters = []
+        @wfids = nil
+      end
+
+      def available
+        unclaimed.completable
       end
 
       def by_nickname(nickname)
@@ -46,13 +53,33 @@ module Bumbleworks
         self
       end
 
+      def for_processes(processes)
+        process_ids = (processes || []).map { |p|
+          p.is_a?(Bumbleworks::Process) ? p.wfid : p
+        }
+        @wfids = process_ids
+        self
+      end
+
+      def for_process(process)
+        for_processes([process])
+      end
+
       def all
-        workitems = Bumbleworks.dashboard.storage_participant.send(:do_select, {}) { |wi|
+        return [] if @wfids == []
+        workitems = Bumbleworks.dashboard.context.storage.get_many('workitems', @wfids).select { |wi|
           @queries.all? { |q| q.call(wi) }
+        }.collect { |wi|
+          ::Ruote::Workitem.new(wi)
         }
         from_workitems(workitems)
       end
 
+      def completable
+        @task_filters << proc { |task| task.completable? }
+        self
+      end
+
       def each(&block)
         all.each(&block)
       end
@@ -76,10 +103,19 @@ module Bumbleworks
 
     private
 
+      def filter_tasks(tasks)
+        @task_filters.empty? ? tasks :
+          tasks.select { |task|
+            @task_filters.all? { |f| f.call(task) }
+          }
+      end
+
       def from_workitems(workitems)
-        workitems.map { |wi|
-          @task_class.new(wi) if wi.params['task']
+        tasks = workitems.map { |wi|
+          @task_class.new(wi)
         }.compact
+
+        filter_tasks(tasks)
       end
     end
   end