ruote 0.9.19 → 0.9.20

data/lib/openwfe/expool/def_parser.rb

@@ -0,0 +1,196 @@
+#--
+# Copyright (c) 2008-2009, 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 'uri'
+require 'yaml'
+require 'openwfe/rexml'
+require 'openwfe/service'
+require 'openwfe/contextual'
+require 'openwfe/util/treechecker'
+require 'openwfe/util/xml'
+require 'openwfe/util/json'
+require 'openwfe/expressions/rprocdef'
+require 'openwfe/expressions/expression_map'
+
+require 'rufus/verbs' # sudo gem install 'rufus-verbs'
+
+
+module OpenWFE
+
+  #
+  # A process definition parser.
+  #
+  # Currently supports XML, Ruby process definitions, YAML and JSON.
+  #
+  class DefParser < Service
+    include OwfeServiceLocator
+
+    #
+    # a static version of the parse method,
+    # by default checks the tree if it's Ruby code that is passed.
+    #
+    def self.parse (pdef, use_ruby_treechecker=true)
+
+      # preparing a small ad-hoc env (app context) for this parsing
+
+      ac = { :use_ruby_treechecker => use_ruby_treechecker }
+
+      ac[:s_tree_checker] = TreeChecker.new(:s_tree_checker, ac)
+      ac[:s_def_parser] = DefParser.new(:s_def_parser, ac)
+      ac[:s_expression_map] = ExpressionMap.new
+
+      ac[:s_def_parser].parse(pdef)
+    end
+
+    #
+    # the classical initialize() of Ruote services
+    #
+    def initialize (service_name, application_context)
+      super
+    end
+
+    #
+    # This is the only point in the expression pool where an URI
+    # is read, so this is where the :remote_definitions_allowed
+    # security check is enforced.
+    #
+    def read_uri (uri)
+
+      u = URI.parse(uri.to_s)
+
+      raise(':remote_definitions_allowed is set to false') \
+        if (ac[:remote_definitions_allowed] != true and
+          u.scheme and
+          u.scheme != 'file')
+
+      f = Rufus::Verbs.fopen(u) # Rufus::Verbs is OK with redirections
+      result = f.read
+      f.close if f.respond_to?(:close)
+
+      result
+    end
+
+    #
+    # Returns the tree representation into behind the param (uri, string, ...)
+    #
+    def determine_rep (param)
+
+      param = param.is_a?(URI) ? read_uri(param) : param
+      parse(param)
+    end
+
+    #
+    # in : a process pdefinition
+    # out : a tree [ name, attributes, children ]
+    #
+    def parse (pdef)
+
+      tree = case pdef
+        when Array then pdef
+        when String then parse_string(pdef)
+        when Class then pdef.do_make
+        when ProcessDefinition then pdef.do_make
+        when SimpleExpRepresentation then pdef.do_make # legacy...
+        else
+          raise "cannot handle pdefinition of class #{pdef.class.name}"
+      end
+
+      tree = [ 'define', { 'name' => 'NoName', 'revision' => '0' }, [ tree ] ] \
+        unless get_expression_map.is_definition?(tree.first)
+          #
+          # making sure the first expression in the tree is a DefineExpression
+          # (an alias for 'process-definition')
+
+      tree
+    end
+
+    X_START = /^</
+    Y_START = /^--- /
+    J_ARRAY = /^\[.*\]$/
+      #
+      # TODO : place that somewhere in utils/
+
+    def parse_string (pdef)
+
+      pdef = pdef.strip
+
+      return parse_xml(pdef) if pdef.match(X_START)
+      return YAML.load(pdef) if pdef.match(Y_START)
+
+      #(json = (OpenWFE::Json.from_json(pdef) rescue nil)) and return json
+      return OpenWFE::Json.from_json(pdef) if pdef.match(J_ARRAY)
+
+      #
+      # else it's some ruby code to eval
+
+      get_tree_checker.check(pdef)
+
+      # no exception, green for eval...
+
+      ProcessDefinition.eval_ruby_process_definition(pdef)
+    end
+
+    #
+    # The process definition is expressed as XML, turn that into
+    # an expression tree.
+    #
+    def parse_xml (xml)
+
+      xml = REXML::Document.new(xml) \
+        if xml.is_a?(String)
+
+      xml = xml.root \
+        if xml.is_a?(REXML::Document)
+
+      if xml.is_a?(REXML::Text)
+
+        s = xml.to_s.strip
+
+        return s if s.length > 0
+
+        return nil
+      end
+
+      return nil if xml.is_a?(REXML::Comment)
+
+      # then it's a REXML::Element
+
+      rep = [
+        xml.name,
+        xml.attributes.inject({}) { |r, (k, v)| r[k] = v; r },
+        [] ]
+
+      xml.children.each do |c|
+
+        r = parse_xml(c)
+
+        rep.last << r if r
+      end
+
+      rep
+    end
+  end
+end
+

data/lib/openwfe/expool/errorjournal.rb

@@ -1,44 +1,27 @@
-#
 #--
-# Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
+# Copyright (c) 2007-2009, John Mettraux, jmettraux@gmail.com
 #
-# . Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
+# 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:
 #
-# . Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
 #
-# . Neither the name of the "OpenWFE" nor the names of its contributors may be
-#   used to endorse or promote products derived from this software without
-#   specific prior written permission.
+# 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.
 #
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
+# Made in Japan.
 #++
-#
-
-#
-# "made in Japan"
-#
-# John Mettraux at openwfe.org
-#
 
-require 'find'
-require 'fileutils'
 
 require 'openwfe/service'
 require 'openwfe/omixins'
@@ -81,6 +64,8 @@ module OpenWFE
     #
     attr_reader :stacktrace
 
+    alias :backtrace :stacktrace
+
     #
     # The error class (String) of the top level error
     #
@@ -132,7 +117,7 @@ module OpenWFE
     # same error as this one.
     #
     def == (other)
-      return false unless other.is_a?(ProcessError)
+      return false unless other.is_a?(OpenWFE::ProcessError)
       return to_s == other.to_s
         #
         # a bit costly but as it's only used by resume_process()...
@@ -145,6 +130,7 @@ module OpenWFE
   # or YamlErrorJournal.
   #
   class ErrorJournal < Service
+
     include OwfeServiceLocator
     include FeiMixin
 
@@ -152,31 +138,42 @@ module OpenWFE
 
       super
 
-      get_expression_pool.add_observer :error do |event, *args|
+      @observers = []
+
+      @observers << get_expression_pool.add_observer(:error) do |evt, *args|
         #
         # logs each error occurring in the expression pool
 
         begin
 
-          record_error(ProcessError.new(*args))
+          record_error(OpenWFE::ProcessError.new(*args))
 
         rescue Exception => e
-          lwarn { "(failed to record error : #{e})" }
-          lwarn { "*** process error : \n" + args.join("\n") }
+          lwarn { "(failed to record error : #{e})\n#{e.backtrace.join("\n")}" }
+          lwarn { "*** process error : \n#{args.join("\n")}" }
         end
       end
 
-      get_expression_pool.add_observer :terminate do |event, *args|
+      @observers << get_expression_pool.add_observer(:terminate) do |evt, *args|
         #
         # removes error log when a process terminates
 
         fei = args[0].fei
 
-        remove_error_log fei.wfid \
-          if fei.is_in_parent_process?
+        remove_error_log(fei.wfid) if fei.is_in_parent_process?
       end
     end
 
+    #
+    # Stops this journal, takes care of 'unobserving' the expression pool
+    #
+    def stop
+
+      super
+
+      @observers.each { |o| get_expression_pool.remove_observer(o) }
+    end
+
     #
     # Returns true if the given wfid (or fei) (process instance id)
     # has had errors.
@@ -192,6 +189,8 @@ module OpenWFE
     #
     def replay_at_error (error)
 
+      error = error.as_owfe_error if error.respond_to?(:as_owfe_error)
+
       remove_errors(
         error.fei.parent_wfid,
         error)
@@ -215,18 +214,12 @@ module OpenWFE
     #
     def ErrorJournal.reduce_error_list (errors)
 
-      h = {}
-
-      errors.each do |e|
-        h[e.fei] = e
-          #
-          # last errors do override previous errors for the
-          # same fei
-      end
-
-      h.values.sort do |error_a, error_b|
+      errors.inject({}) { |h, e|
+        h[e.fei] = e; h
+          # last errors do override previous errors for the same fei
+      }.values.sort { |error_a, error_b|
         error_a.date <=> error_b.date
-      end
+      }
     end
   end
 
@@ -252,8 +245,8 @@ module OpenWFE
     #
     def get_error_log (wfid)
 
-      wfid = extract_wfid wfid, true
-      @per_processes[wfid] or []
+      wfid = extract_wfid(wfid, true)
+      @per_processes[wfid] || []
     end
 
     #
@@ -261,7 +254,7 @@ module OpenWFE
     #
     def remove_error_log (wfid)
 
-      wfid = extract_wfid wfid, true
+      wfid = extract_wfid(wfid, true)
       @per_processes.delete(wfid)
     end
 
@@ -274,10 +267,10 @@ module OpenWFE
 
       errors = Array(errors)
 
-      log = get_error_log wfid
+      log = get_error_log(wfid)
 
       errors.each do |e|
-        log.delete e
+        log.delete(e)
       end
     end
 
@@ -298,165 +291,4 @@ module OpenWFE
           # not that unreadable after all...
       end
   end
-
-  #
-  # A Journal that only keep track of error in process execution.
-  #
-  class YamlErrorJournal < ErrorJournal
-
-    attr_reader :workdir
-
-    def initialize (service_name, application_context)
-
-      require 'openwfe/storage/yamlcustom'
-        # making sure this file has been required at this point
-        # this yamlcustom thing prevents the whole OpenWFE ecosystem
-        # to get serialized :)
-
-      super
-
-      @workdir = get_work_directory + "/ejournal"
-      #@workdir = File.expand_path @workdir
-
-      FileUtils.makedirs(@workdir) unless File.exist?(@workdir)
-    end
-
-    #
-    # Returns a list (older first) of the errors for a process
-    # instance identified by its fei or wfid.
-    #
-    # Will return an empty list if there a no errors for the process
-    # instances.
-    #
-    def get_error_log (wfid)
-
-      path = get_path wfid
-
-      return [] unless File.exist?(path)
-
-      read_error_log_from path
-    end
-
-    #
-    # Copies the error log of a process instance to a give path (and
-    # filename).
-    #
-    # Could be useful when one has to perform replay operations and wants
-    # to keep a copy of the original error[s].
-    #
-    def copy_error_log_to (wfid, path)
-
-      original_path = get_path wfid
-      FileUtils.copy_file original_path, path
-    end
-
-    #
-    # Reads an error log from a specific file (possibly as copied over
-    # via copy_error_log_to()).
-    #
-    def read_error_log_from (path)
-
-      raise "no error log file at #{path}" unless File.exist?(path)
-
-      File.open(path) do |f|
-        s = YAML.load_stream f
-        s.documents
-      end
-    end
-
-    #
-    # Removes the error log of a specific process instance.
-    # Could be a good idea after a succesful replay operation.
-    #
-    # 'wfid' may be either a workflow instance id (String) either
-    # a FlowExpressionId instance.
-    #
-    def remove_error_log (wfid)
-
-      path = get_path wfid
-
-      File.delete(path) if File.exist?(path)
-    end
-
-    #
-    # Removes a list of errors from this error journal.
-    #
-    def remove_errors (wfid, errors)
-
-      errors = Array(errors)
-
-      # load all errors
-
-      log = get_error_log wfid
-
-      # remove the given errors
-
-      errors.each do |e|
-        log.delete e
-      end
-
-      # rewrite error file
-
-      path = get_path wfid
-
-      if log.size > 0
-
-        File.open(path, "w") do |f|
-          log.each do |e|
-            f.puts e.to_yaml
-          end
-        end
-      else
-
-        File.delete path
-      end
-    end
-
-    #
-    # Reads all the error logs currently stored.
-    # Returns a hash wfid --> error list.
-    #
-    def get_error_logs
-
-      result = {}
-
-      Find.find(@workdir) do |path|
-
-        next unless path.match(/\.ejournal$/)
-
-        log = read_error_log_from path
-        result[log.first.fei.wfid] = log
-      end
-
-      result
-    end
-
-    protected
-
-      #
-      # logs the error as a yaml string in an error log file
-      # (there is one error log file per workflow instance).
-      #
-      def record_error (error)
-
-        path = get_path error.fei
-
-        dirpath = File.dirname path
-
-        FileUtils.mkdir_p(dirpath) unless File.exist?(dirpath)
-
-        File.open path, "a+" do |f|
-          f.puts error.to_yaml
-        end
-      end
-
-      #
-      # Returns the path to the error log file of a specific process
-      # instance.
-      #
-      def get_path (fei_or_wfid)
-
-        @workdir + "/" + extract_wfid(fei_or_wfid, true) + ".ejournal"
-      end
-  end
 end