ruote 0.9.20 → 2.1.1

data/lib/ruote/util/serializer.rb

@@ -0,0 +1,103 @@
+#--
+# 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
+
+  #
+  # To get a YAML serializer :
+  #
+  #   serializer = Serializer.new(:yaml)
+  #
+  # A marshal + base64 one :
+  #
+  #   serializer = Serializer.new(:marshal64)
+  #
+  # A marshal only one :
+  #
+  #   serializer = Serializer.new(:marshal)
+  #
+  # For the rest, it's the classical :
+  #
+  #   data = serializer.encode(object)
+  #
+  #   object = serializer.decode(data)
+  #
+  class Serializer
+
+    #--
+    # prepare / encode / decode lambda pairs
+    #++
+
+    # plain marshal serialization
+    #
+    MARSHAL = [
+      lambda { },
+      lambda { |o| Marshal.dump(o) },
+      lambda { |s| Marshal.load(s) }
+    ]
+
+    # marshal serialization with base64 encoding
+    #
+    MARSHAL64 = [
+      lambda { require 'base64' },
+      lambda { |o| Base64.encode64(Marshal.dump(o)) },
+      lambda { |s| Marshal.load(Base64.decode64(s)) }
+    ]
+
+    # YAML serialization
+    #
+    YAML = [
+      lambda { require 'yaml' },
+      lambda { |o| ::YAML.dump(o) },
+      lambda { |s| ::YAML.load(s) }
+    ]
+
+    #JASH = ...
+
+    # The flavour map
+    #
+    FLAVOURS = {
+      :marshal => MARSHAL, :marshal64 => MARSHAL64, :yaml => YAML
+    }
+
+    def initialize (flavour)
+
+      @flavour = FLAVOURS[flavour] || MARSHAL64
+
+      @flavour[0].call # initializes the flavour
+    end
+
+    def encode (o)
+
+      @flavour[1].call(o)
+    end
+
+    def decode (s)
+
+      @flavour[2].call(s)
+    end
+  end
+end
+

data/lib/ruote/util/time.rb

@@ -0,0 +1,90 @@
+#--
+# 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 'rufus/scheduler'
+
+
+unless DateTime.instance_methods.include?(:to_time)
+  #
+  # Ruby 1.9.1 has it, but not 1.8.x, so adding it...
+  #
+  class DateTime
+    def to_time
+      new_offset(0).instance_eval {
+        Time.utc(year, mon, mday, hour, min, sec + sec_fraction)
+      }.getlocal
+    end
+  end
+end
+
+
+module Ruote
+
+  # Produces the UTC string representation of a Time
+  #
+  # like "2009/11/23 11:11:50.947109 UTC"
+  #
+  def self.time_to_utc_s (t)
+
+    "#{t.utc.strftime('%Y/%m/%d %H:%M:%S')}.#{sprintf('%06d', t.usec)} UTC"
+  end
+
+  # Returns a parsable representation of the UTC time now.
+  #
+  # like "2009/11/23 11:11:50.947109 UTC"
+  #
+  def self.now_to_utc_s
+
+    time_to_utc_s(Time.now)
+  end
+
+  # Turns a date or a duration to a Time object pointing AT a point in time...
+  #
+  # (my prose is weak)
+  #
+  def self.s_to_at (s)
+
+    at = if s.index(' ')
+      #
+      # date
+
+      Rufus.to_ruby_time(s)# rescue nil
+
+    else
+      #
+      # duration
+
+      duration = s.to_f rescue Rufus.parse_time_string(s)
+
+      Time.now.utc.to_f + duration
+    end
+
+    case at
+      when DateTime then at.to_time.utc
+      when Float then Time.at(at).utc
+      else at
+    end
+  end
+end
+

data/lib/ruote/util/tree.rb

@@ -0,0 +1,58 @@
+#--
+# 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
+
+  # Turning a tree into a numbered string view
+  #
+  #   require 'ruote/util/tree'
+  #   require 'ruote/parser/ruby_dsl'
+  #
+  #   pdef = Ruote.process_definition :name => 'def0' do
+  #     sequence do
+  #       alpha
+  #       bravo
+  #     end
+  #   end
+  #
+  #   p pdef
+  #     # => ["define", {"name"=>"def0"}, [["sequence", {}, [["alpha", {}, []], ["bravo", {}, []]]]]]
+  #
+  #   puts Ruote.tree_to_s(pdef)
+  #     # =>
+  #     #    0  define {"name"=>"def0"}
+  #     #      0_0  sequence {}
+  #     #        0_0_0  alpha {}
+  #     #        0_0_1  bravo {}
+  #
+  def Ruote.tree_to_s (tree, expid='0')
+
+    d = expid.split('_').size - 1
+    s = "#{' ' * d * 2}#{expid}  #{tree[0]} #{tree[1].inspect}\n"
+    tree[2].each_with_index { |t, i| s << tree_to_s(t, "#{expid}_#{i}") }
+    s
+  end
+end
+

data/lib/{openwfe → ruote}/util/treechecker.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2008-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,28 +23,23 @@
 #++
 
 
-require 'openwfe/service'
 #require 'rufus/treechecker'
+  # is loaded only when needed
 
+require 'fileutils'
 
-module OpenWFE
+
+module Ruote
 
   #
   # The TreeChecker service is used to check incoming external ruby code
   # and raise a security error if it contains potentially evil code.
   #
-  class TreeChecker < Service
-
-    #
-    # builds the treechecker. Will return immediately (and not build)
-    # if the :use_ruby_treechecker option is set to false. By default
-    # the treechecker is used.
-    #
-    def initialize (service_name, application_context)
+  class TreeChecker
 
-      super
+    def initialize (context)
 
-      (ac[:use_ruby_treechecker] == false) and return
+      (context['use_ruby_treechecker'] == false) and return
 
       require 'rufus/treechecker' # gem 'rufus-treechecker'
         # load only when needed
@@ -70,10 +65,10 @@ module OpenWFE
         exclude_access_to(
           IO, File, FileUtils, Process, Signal, Thread, ThreadGroup)
 
-        exclude_class_tinkering :except => OpenWFE::ProcessDefinition
+        #exclude_class_tinkering :except => Ruote::ProcessDefinition
           #
           # excludes defining/opening any class except
-          # OpenWFE::ProcessDefinition
+          # Ruote::ProcessDefinition
 
         exclude_call_to :instance_variable_get, :instance_variable_set
       end
@@ -103,6 +98,5 @@ module OpenWFE
       @cchecker.check(ruby_code) if @checker
     end
   end
-
 end
 

data/lib/ruote/worker.rb

@@ -0,0 +1,375 @@
+#--
+# 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/fei'
+
+
+module Ruote
+
+  VERSION = '2.1.1'
+
+  class Worker
+
+    EXP_ACTIONS = %w[ reply cancel fail receive ]
+      # 'apply' is comprised in 'launch'
+      # 'receive' is a ParticipantExpression alias for 'reply'
+
+    PROC_ACTIONS = %w[ cancel_process kill_process ]
+
+    attr_reader :storage
+    attr_reader :context
+
+    attr_reader :run_thread
+    attr_reader :running
+
+    def initialize (storage)
+
+      @storage = storage
+
+      @subscribers = []
+      @context = Ruote::Context.new(@storage, self)
+
+      @last_time = Time.at(0.0).utc # 1970...
+
+      @running = true
+      @run_thread = nil
+
+      @msgs = []
+      @sleep_time = 0.001
+    end
+
+    def run
+
+      while(@running) do
+        step
+      end
+    end
+
+    def run_in_thread
+
+      Thread.abort_on_exception = true
+        # TODO : remove me at some point
+
+      @running = true
+
+      @run_thread = Thread.new { run }
+    end
+
+    def subscribe (actions, subscriber)
+
+      @subscribers << [ actions, subscriber ]
+    end
+
+    def shutdown
+
+      @running = false
+      @run_thread.join if @run_thread
+    end
+
+    # This method is public, since it's used by the DispatchPool when
+    # reporting an error that occurred in the dispatch/consume thread of
+    # a participant.
+    #
+    def handle_exception (msg, fexp, ex)
+
+      wfid = msg['wfid'] || (msg['fei']['wfid'] rescue nil)
+      fei = msg['fei'] || (fexp.h.fei rescue nil)
+
+      # debug only
+
+      if ARGV.include?('-d')
+
+        puts "\n== worker intercepted error =="
+        puts
+        p ex
+        ex.backtrace[0, 10].each { |l| puts l }
+        puts "..."
+        puts
+        puts "-- msg --"
+        msg.keys.sort.each { |k|
+          puts "    #{k.inspect} =>\n#{msg[k].inspect}"
+        }
+        puts "-- . --"
+        puts
+      end
+
+      # on_error ?
+
+      if not(fexp) && fei
+        fexp = Ruote::Exp::FlowExpression.fetch(@context, fei)
+      end
+
+      return if fexp && fexp.handle_on_error
+
+      # emit 'msg'
+
+      @storage.put_msg(
+        'error_intercepted',
+        'message' => ex.inspect,
+        'wfid' => wfid,
+        'msg' => msg)
+
+      # fill error in the error journal
+
+      @storage.put(
+        'type' => 'errors',
+        '_id' => "err_#{Ruote.to_storage_id(fei)}",
+        'message' => ex.inspect,
+        'trace' => ex.backtrace.join("\n"),
+        'msg' => msg
+      ) if fei
+    end
+
+    protected
+
+    def step
+
+      now = Time.now.utc
+      delta = now - @last_time
+
+      if delta >= 0.8
+        #
+        # at most once per second, deal with 'ats' and 'crons'
+
+        @last_time = now
+
+        @storage.get_schedules(delta, now).each do|sche|
+          trigger(sche)
+        end
+      end
+
+      # msgs
+
+      @msgs = @storage.get_msgs if @msgs.empty?
+
+      processed = 0
+      collisions = 0
+
+      while msg = @msgs.shift
+
+        r = process(msg)
+
+        if r != false
+          processed += 1
+        else
+          collisions += 1
+        end
+
+        if collisions > 2
+          @msgs = @msgs[(@msgs.size / 2)..-1] || []
+        end
+
+        #@msgs.concat(@storage.get_local_msgs)
+
+        #print r == false ? '*' : '.'
+
+        break if Time.now.utc - @last_time >= 0.8
+      end
+
+      #puts processed.to_s
+
+      if processed == 0
+        @sleep_time += 0.001
+        @sleep_time = 0.499 if @sleep_time > 0.499
+        sleep(@sleep_time)
+      else
+        @sleep_time = 0.001
+      end
+    end
+
+    def trigger (schedule)
+
+      msg = Ruote.fulldup(schedule['msg'])
+
+      return false unless @storage.reserve(schedule)
+
+      @storage.put_msg(msg.delete('action'), msg)
+
+      true
+    end
+
+    def process (msg)
+
+      return false if cannot_handle(msg)
+
+      return false unless @storage.reserve(msg)
+
+      fexp = nil
+
+      begin
+
+        action = msg['action']
+
+        if msg['tree']
+          #
+          # warning here, it could be a reply, with a 'tree' key...
+
+          launch(msg)
+
+        elsif EXP_ACTIONS.include?(action)
+
+          Ruote::Exp::FlowExpression.do_action(@context, msg)
+
+        elsif action == 'dispatch'
+
+          #dispatch(msg)
+          @context.dispatch_pool.dispatch(msg)
+
+        elsif PROC_ACTIONS.include?(action)
+
+          self.send(action, msg)
+
+        #else
+          # msg got deleted, might still be interesting for a subscriber
+        end
+
+        notify(msg)
+
+      rescue Exception => ex
+
+        handle_exception(msg, fexp, ex)
+      end
+
+      true
+    end
+
+    def notify (msg)
+
+      @subscribers.each do |actions, subscriber|
+
+        if actions == :all || actions.include?(msg['action'])
+          subscriber.notify(msg)
+        end
+      end
+    end
+
+    def cannot_handle (msg)
+
+      return false if msg['action'] != 'dispatch'
+
+      @context.engine.nil? && msg['for_engine_worker?']
+    end
+
+    # Works for both the 'launch' and the 'apply' msgs.
+    #
+    def launch (msg)
+
+      tree = msg['tree']
+      variables = msg['variables']
+
+      exp_class = @context.expmap.expression_class(tree.first)
+
+      # msg['wfid'] only : it's a launch
+      # msg['fei'] : it's a sub launch (a supplant ?)
+
+      exp_hash = {
+        'fei' => msg['fei'] || {
+          'engine_id' => @context['engine_id'] || 'engine',
+          'wfid' => msg['wfid'],
+          'expid' => '0' },
+        'parent_id' => msg['parent_id'],
+        'original_tree' => tree,
+        'variables' => variables,
+        'applied_workitem' => msg['workitem'],
+        'forgotten' => msg['forgotten']
+      }
+
+      if not exp_class
+
+        exp_class, tree = lookup_subprocess_or_participant(exp_hash)
+
+      elsif msg['action'] == 'launch' && exp_class == Ruote::Exp::DefineExpression
+        def_name, tree = Ruote::Exp::DefineExpression.reorganize(tree)
+        variables[def_name] = [ '0', tree ] if def_name
+        exp_class = Ruote::Exp::SequenceExpression
+      end
+
+      raise_unknown_expression_error(exp_hash) unless exp_class
+
+      exp = exp_class.new(@context, exp_hash.merge!('original_tree' => tree))
+      exp.initial_persist
+      exp.do_apply
+    end
+
+    def raise_unknown_expression_error (exp_hash)
+
+      exp_hash['state'] = 'failed'
+      exp_hash['has_error'] = true
+
+      Ruote::Exp::RawExpression.new(@context, exp_hash).persist_or_raise
+        # undigested expression is stored
+
+      raise "unknown expression '#{exp_hash['original_tree'].first}'"
+    end
+
+    def lookup_subprocess_or_participant (exp_hash)
+
+      tree = exp_hash['original_tree']
+
+      key, value = Ruote::Exp::FlowExpression.new(
+        @context, exp_hash.merge('name' => 'temporary')
+      ).iterative_var_lookup(tree[0])
+
+      sub = value
+      part = @context.plist.lookup_info(key)
+
+      sub = key if (not sub) && (not part) && Ruote.is_uri?(key)
+        # for when a variable points to the URI of a[n external] subprocess
+
+      if sub or part
+
+        tree[1]['ref'] = key
+        tree[1]['original_ref'] = tree[0] if key != tree[0]
+
+        tree[0] = sub ? 'subprocess' : 'participant'
+
+        [ sub ?
+            Ruote::Exp::SubprocessExpression :
+            Ruote::Exp::ParticipantExpression,
+          tree ]
+      else
+
+        [ nil, tree ]
+      end
+    end
+
+    def cancel_process (msg)
+
+      root = @storage.find_root_expression(msg['wfid'])
+
+      return unless root
+
+      flavour = (msg['action'] == 'kill_process') ? 'kill' : nil
+
+      @storage.put_msg(
+        'cancel',
+        'fei' => root['fei'],
+        'wfid' => msg['wfid'], # indicates this was triggered by cancel_process
+        'flavour' => flavour)
+    end
+
+    alias :kill_process :cancel_process
+  end
+end
+