ruote 0.9.20 → 2.1.1

data/lib/ruote/part/storage_participant.rb

@@ -0,0 +1,140 @@
+#--
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+require 'ruote/part/local_participant'
+
+
+module Ruote
+
+  class StorageParticipant
+
+    include LocalParticipant
+    include Enumerable
+
+    attr_accessor :context
+
+    def initialize (options={})
+
+      @store_name = options['store_name']
+    end
+
+    # No need for a separate thread when delivering to this participant.
+    #
+    def do_not_thread; true; end
+
+    def consume (workitem)
+
+      doc = workitem.to_h
+
+      doc.merge!(
+        'type' => 'workitems',
+        '_id' => to_id(doc['fei']),
+        'participant_name' => doc['participant_name'],
+        'wfid' => doc['fei']['wfid'])
+
+      doc['store_name'] = @store_name if @store_name
+
+      @context.storage.put(doc)
+    end
+
+    # Makes sure to remove the workitem from the in-memory hash.
+    #
+    def cancel (fei, flavour)
+
+      doc = fetch(fei)
+
+      r = @storage.delete(doc)
+
+      cancel(fei, flavour) if r != nil
+    end
+
+    def [] (fei)
+
+      doc = fetch(fei)
+
+      doc ? Ruote::WorkItem.new(doc) : nil
+    end
+
+    def fetch (fei)
+
+      @context.storage.get('workitems', to_id(fei))
+    end
+
+    # Removes the workitem from the in-memory hash and replies to the engine.
+    #
+    def reply (workitem)
+
+      doc = fetch(workitem.fei.to_h)
+
+      r = @context.storage.delete(doc)
+
+      return reply(workitem) if r != nil
+
+      reply_to_engine(workitem)
+    end
+
+    # Returns the count of workitems stored in this participant.
+    #
+    def size
+
+      fetch_all.size
+    end
+
+    # Iterates over the workitems stored in here.
+    #
+    def each (&block)
+
+      fetch_all.each { |hwi| block.call(Ruote::Workitem.new(hwi)) }
+    end
+
+    # A convenience method (especially when testing), returns the first
+    # (only ?) workitem in the participant.
+    #
+    def first
+
+      hwi = fetch_all.first
+
+      hwi ? Ruote::Workitem.new(hwi) : nil
+    end
+
+    protected
+
+    def fetch_all
+
+      key = @store_name ? /^wi\_#{@store_name}::/ : nil
+
+      @context.storage.get_many('workitems', key)
+    end
+
+    def to_id (fei)
+
+      sid = Ruote.to_storage_id(fei)
+
+      sid = @store_name ? "#{store_name}::#{sid}" : sid
+
+      "wi_#{sid}"
+    end
+  end
+end
+

data/lib/{openwfe/util/irb.rb → ruote/part/template.rb}

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2007-2009, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -23,49 +23,41 @@
 #++
 
 
-require 'irb'
-require 'irb/completion'
-
-#--
-# borrowing ideas from
-#
-# http://groups.google.com/group/ruby-talk-google/browse_frm/thread/60ef4f8cff701e14/26ae883a7cc1da7f
-#++
-
-
-module OpenWFE
+module Ruote
 
   #
-  # Binds the SIGINT signal so that a console is opened with the bindings
-  # specified in 'args'.
+  # This mixin expects that the class that includes it has a @template
+  # or a @block_template instance variable.
   #
-  def OpenWFE.trap_int_irb (*args)
-    trap 'INT' do
-      OpenWFE.start_irb_session(*args)
-      #OpenWFE.trap_int_irb(*args) if $openwfe_irb
-      OpenWFE.trap_int_irb(*args)
-    end
-  end
+  module TemplateMixin
 
-  protected
+    def render_template (flow_expression, workitem)
 
-    def OpenWFE.start_irb_session (*args)
+      template = if @block_template
 
-      IRB::setup nil unless $openwfe_irb
+        case @block_template.arity
+          when 1 then @block_template.call(workitem)
+          when 2 then @block_template.call(workitem, flow_expression)
+          else @block_template.call(workitem, flow_expression, self)
+        end
 
-      ws = IRB::WorkSpace.new *args
+      elsif @template
 
-      $openwfe_irb = IRB::Irb.new ws
+        @template.is_a?(File) ? @template.read : @template.to_s
 
-      IRB::conf[:MAIN_CONTEXT] = $openwfe_irb.context
+      else
 
-      trap 'INT' do
-        $openwfe_irb.signal_handle
+        nil
       end
 
-      $openwfe_irb.eval_input
+      raise(
+        ArgumentError.new('no @template or @block_template found')
+      ) unless template
 
-      puts "\nbye!"
+      workitem = workitem.to_h if workitem.respond_to?(:to_h)
+
+      Ruote.dosub(template, flow_expression, workitem)
     end
+  end
 end
 

data/lib/ruote/participant.rb

@@ -0,0 +1,6 @@
+
+require 'ruote/part/hash_participant'
+require 'ruote/part/storage_participant'
+require 'ruote/part/no_op_participant'
+require 'ruote/part/null_participant'
+

data/lib/ruote/receiver/base.rb

@@ -0,0 +1,73 @@
+#--
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote
+
+  #
+  # The core methods for the Receiver class (sometimes a Mixin is easier
+  # to integrate).
+  #
+  # (The engine itself includes this mixin)
+  #
+  module ReceiverMixin
+
+    def receive (item)
+
+      reply(item)
+    end
+
+    def reply (workitem)
+
+      workitem = workitem.to_h if workitem.respond_to?(:to_h)
+
+      @storage.put_msg(
+        'receive',
+        'fei' => workitem['fei'],
+        'workitem' => workitem,
+        'participant_name' => workitem['participant_name'],
+        'receiver' => sign)
+    end
+
+    def sign
+
+      self.class.to_s
+    end
+  end
+
+  #
+  # A receiver is meant to receive workitems and feed them back into the
+  # engine (the storage actually).
+  #
+  class Receiver
+    include ReceiverMixin
+
+    def initialize (storage, options={})
+
+      @storage = storage
+      @options = options
+    end
+  end
+end
+

data/lib/ruote/storage/base.rb

@@ -0,0 +1,210 @@
+#--
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+require 'ruote/util/time'
+
+
+module Ruote
+
+  #
+  # Base methods for storage implementations.
+  #
+  module StorageBase
+
+    def reserve (doc)
+
+      #(delete(doc) != true)
+      delete(doc).nil?
+    end
+
+    #--
+    # configurations
+    #++
+
+    def get_configuration (key)
+
+      get('configurations', key)
+    end
+
+    #--
+    # messages
+    #++
+
+    def put_msg (action, options)
+
+      # merge! is way faster than merge (no object creation probably)
+
+      msg = options.merge!(
+        'type' => 'msgs',
+        '_id' => "#{$$}-#{Thread.current.object_id}-#{Time.now.to_f.to_s}",
+        'action' => action)
+
+      msg.delete('_rev')
+        # in case of message replay
+
+      put(msg)
+        #, :update_rev => true)
+
+      #(@local_msgs ||= []) << options
+    end
+
+    #def get_local_msgs
+    #  if @local_msgs
+    #    r = @local_msgs
+    #    @local_msgs = nil
+    #    r
+    #  else
+    #    []
+    #  end
+    #end
+
+    def get_msgs
+
+      get_many(
+        'msgs', nil, :limit => 300
+      ).sort { |a, b|
+        a['put_at'] <=> b['put_at']
+      }
+    end
+
+    #--
+    # expressions
+    #++
+
+    def find_root_expression (wfid)
+
+      get_many('expressions', /#{wfid}$/).sort { |a, b|
+        a['fei']['expid'] <=> b['fei']['expid']
+      }.select { |e|
+        e['parent_id'].nil?
+      }.first
+    end
+
+    #--
+    # trackers
+    #++
+
+    def get_trackers
+
+      get('variables', 'trackers') ||
+        { '_id' => 'trackers', 'type' => 'variables', 'trackers' => {} }
+    end
+
+    #--
+    # ats and crons
+    #++
+
+    def get_schedules (delta, now)
+
+      if delta < 1.0
+
+        at = now.strftime('%Y%m%d%H%M%S')
+        get_many('schedules', /-#{at}$/)
+
+      elsif delta < 60.0
+
+        at = now.strftime('%Y%m%d%H%M')
+        scheds = get_many('schedules', /-#{at}\d\d$/)
+        filter_schedules(scheds, now)
+
+      else # load all the schedules
+
+        scheds = get_many('schedules')
+        filter_schedules(scheds, now)
+      end
+    end
+
+    def put_schedule (flavour, owner_fei, s, msg)
+
+      at = if s.is_a?(Time) # at or every
+        at
+      elsif Rufus::Scheduler.is_cron_string(s) # cron
+        Rufus::CronLine.new(s).next_time(Time.now + 1)
+      else # at or every
+        Ruote.s_to_at(s)
+      end
+      at = at.utc
+
+      if at <= Time.now.utc && flavour == 'at'
+        put_msg(msg.delete('action'), msg)
+        return
+      end
+
+      sat = at.strftime('%Y%m%d%H%M%S')
+      i = "#{flavour}-#{Ruote.to_storage_id(owner_fei)}-#{sat}"
+
+      put(
+        '_id' => i,
+        'type' => 'schedules',
+        'flavour' => flavour,
+        'original' => s,
+        'at' => Ruote.time_to_utc_s(at),
+        'owner' => owner_fei,
+        'msg' => msg)
+
+      i
+    end
+
+    def delete_schedule (schedule_id)
+
+      s = get('schedules', schedule_id)
+      delete(s) if s
+    end
+
+    #--
+    # engine variables
+    #++
+
+    def get_engine_variable (k)
+
+      get_engine_variables['variables'][k]
+    end
+
+    def put_engine_variable (k, v)
+
+      vars = get_engine_variables
+      vars['variables'][k] = v
+
+      put_engine_variable(k, v) unless put(vars).nil?
+    end
+
+    protected
+
+    def get_engine_variables
+
+      get('variables', 'variables') || {
+        'type' => 'variables', '_id' => 'variables', 'variables' => {} }
+    end
+
+    # Returns all the ats whose due date arrived (now or earlier)
+    #
+    def filter_schedules (scheds, now)
+
+      now = Ruote.time_to_utc_s(now)
+
+      scheds.select { |sched| sched['at'] <= now }
+    end
+  end
+end
+