openwferu 0.9.16 → 0.9.17

data/lib/openwfe/engine/process_status.rb

@@ -0,0 +1,359 @@
+#
+#--
+# 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:
+# 
+# . Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.  
+# 
+# . 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.
+# 
+# . 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.
+# 
+# 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"
+#
+# John Mettraux at openwfe.org
+# 
+
+module OpenWFE
+
+    #
+    # ProcessStatus represents information about the status of a workflow
+    # process instance.
+    #
+    # The status is mainly a list of expressions and a hash of errors.
+    #
+    # Instances of this class are obtained via Engine.process_status().
+    #
+    class ProcessStatus
+
+        #
+        # the String workflow instance id of the Process.
+        #
+        attr_reader :wfid
+
+        #
+        # The list of the expressions currently active in the process instance.
+        #
+        # For instance, if your process definition is currently in a 
+        # concurrence, more than one expressions may be listed here.
+        #
+        attr_reader :expressions
+
+        #
+        # A hash whose values are ProcessError instances, the keys
+        # are FlowExpressionId instances (fei) (identifying the expressions
+        # that are concerned with the error)
+        #
+        attr_reader :errors
+
+        #
+        # The time at which the process got launched.
+        #
+        attr_reader :launch_time
+
+        #
+        # The variables hash as set in the process environment (the process
+        # scope).
+        #
+        attr_reader :variables
+
+        #
+        # Is the process currently in pause ?
+        #
+        attr_accessor :paused
+
+        #
+        # Builds an empty ProcessStatus instance.
+        #
+        def initialize
+
+            @wfid = nil
+            @expressions = []
+            @errors = {}
+            @launch_time = nil
+            @variables = nil
+        end
+
+        #
+        # Returns the workflow definition name for this process.
+        #
+        def wfname
+
+            @expressions.first.fei.wfname
+        end
+
+        alias :workflow_definition_name :wfname
+
+        #
+        # Returns the workflow definition revision for this process.
+        #
+        def wfrevision
+
+            @expressions.first.fei.wfrevision
+        end
+
+        alias :workflow_definition_revision :wfrevision
+
+        #
+        # Returns the count of concurrent branches currently active for
+        # this process. The typical 'sequential only' process will
+        # have a return value of 1 here.
+        #
+        def branches
+
+            @expressions.size
+        end
+
+        #
+        # Returns the tags currently set in this process.
+        #
+        def tags
+
+            return [] unless @variables
+
+            @variables.keys.select do |k|
+                @variables[k].is_a?(OpenWFE::RawExpression::Tag)
+            end
+        end
+
+        #
+        # Returns true if the process is in pause.
+        #
+        def paused?
+
+            #@expressions.first.paused?
+            @paused
+        end
+
+        #
+        # this method is used by Engine.get_process_status() when
+        # it prepares its results.
+        #
+        def << (item)
+
+            if item.kind_of?(FlowExpression)
+                add_expression item
+            else
+                add_error item
+            end
+        end
+
+        #
+        # A String representation, handy for debugging, quick viewing.
+        #
+        def to_s
+
+            s = []
+
+            s << "-- #{self.class.name} --"
+            s << "      wfid :        #{@wfid}"
+            s << "      launch_time : #{launch_time}"
+            s << "      tags :        #{tags.join(", ")}"
+            s << "      errors :      #{@errors.size}"
+            s << "      paused :      #{paused?}"
+
+            s << "      expressions :"
+            @expressions.each do |fexp|
+                s << "         #{fexp.fei.to_s}"
+            end
+
+            s.join "\n"
+        end
+
+        protected
+
+            def add_expression (fexp)
+                
+                if fexp.is_a?(Environment)
+                    @variables = fexp.variables if fexp.fei.expid == "0"
+                    return
+                end
+
+                set_wfid fexp.fei.parent_wfid
+
+                @launch_time = fexp.apply_time if fexp.fei.expid == '0'
+
+                exps = @expressions
+                @expressions = []
+
+                added = false
+                @expressions = exps.collect do |fe|
+                    if added or fe.fei.wfid != fexp.fei.wfid
+                        fe
+                    else
+                        if OpenWFE::starts_with(fexp.fei.expid, fe.fei.expid)
+                            added = true
+                            fexp
+                        elsif OpenWFE::starts_with(fe.fei.expid, fexp.fei.expid)
+                            added = true
+                            fe
+                        else
+                            fe
+                        end
+                    end
+                end
+                @expressions << fexp unless added
+            end
+
+            def add_error (error)
+
+                @errors[error.fei] = error
+            end
+
+            def set_wfid (wfid)
+
+                return if @wfid
+                @wfid = wfid
+            end
+    end
+
+    #
+    # Renders a nice, terminal oriented, representation of an 
+    # Engine.get_process_status() result.
+    #
+    # You usually directly benefit from this when doing
+    #
+    #     puts engine.get_process_status.to_s
+    #
+    def OpenWFE.pretty_print_process_status (ps)
+
+        # TODO : include launch_time and why is process_id so long ?
+
+        s = ""
+        s << "process_id          | name              | rev     | brn | err | paused? \n"
+        s << "--------------------+-------------------+---------+-----+-----+---------\n"
+
+        ps.keys.sort.each do |wfid|
+
+            status = ps[wfid]
+            fexp = status.expressions.first
+            ffei = fexp.fei
+
+            s << "%-19s" % wfid[0, 19]
+            s << " | "
+            s << "%-17s" % ffei.workflow_definition_name[0, 17]
+            s << " | "
+            s << "%-7s" % ffei.workflow_definition_revision[0, 7]
+            s << " | "
+            s << "%3s" % status.expressions.size.to_s[0, 3]
+            s << " | "
+            s << "%3s" % status.errors.size.to_s[0, 3]
+            s << " | "
+            s << "%5s" % status.paused?.to_s
+            s << "\n"
+        end
+        s
+    end
+
+    #
+    # This mixin is only included by the Engine class. It contains all
+    # the methods about ProcessStatus.
+    #
+    module StatusMixin
+
+        #
+        # Returns a hash of ProcessStatus instances. The keys of the hash
+        # are workflow instance ids.
+        #
+        # A ProcessStatus is a description of the state of a process instance.
+        # It enumerates the expressions where the process is currently
+        # located (waiting certainly) and the errors the process currently
+        # has (hopefully none).
+        #
+        def process_statuses (options={})
+
+            options = { :wfid_prefix => options } if options.is_a?(String)
+
+            result = {}
+
+            expressions = get_expression_storage.find_expressions options
+
+            expressions.each do |fexp|
+
+                next unless (fexp.apply_time or fexp.is_a?(Environment))
+
+                next if fexp.fei.wfid == "0" # skip the engine env
+
+                #(result[fexp.fei.parent_wfid] ||= ProcessStatus.new) << fexp
+
+                parent_wfid = fexp.fei.parent_wfid
+                
+                ps = result[parent_wfid]
+
+                if not ps
+
+                    ps = ProcessStatus.new
+
+                    ps.paused = 
+                        (get_expool.paused_instances[parent_wfid] != nil)
+
+                    result[parent_wfid] = ps
+                end
+
+                ps << fexp
+            end
+
+            result.values.each do |ps|
+                get_error_journal.get_error_log(ps.wfid).each do |error|
+                    ps << error
+                end
+            end
+
+            class << result
+                def to_s
+                    OpenWFE::pretty_print_process_status(self)
+                end
+            end
+
+            result
+        end
+
+        #
+        # list_process_status() will be deprecated at release 1.0.0
+        #
+        alias :list_process_status :process_statuses
+
+        #
+        # Returns the process status of one given process instance.
+        #
+        def process_status (wfid)
+
+            wfid = extract_wfid wfid, true
+
+            process_statuses(:wfid => wfid).values[0]
+        end
+
+        #
+        # Returns true if the process is in pause.
+        #
+        def is_paused? (wfid)
+
+            (get_expression_pool.paused_instances[wfid] != nil)
+        end
+    end
+
+end
+

data/lib/openwfe/expool/errorjournal.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2007-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -200,7 +200,7 @@ module OpenWFE
         # Will replay a given process instance at its 1 to last error.
         #
         #def replay_at_last_error (wfid, offset=0)
-        #    wfid = to_wfid(wfid)
+        #    wfid = extract_wfid(wfid)
         #    log = get_error_log(wfid)
         #    index = (-1 - offset)
         #    error = log[index]
@@ -272,7 +272,7 @@ module OpenWFE
         #
         def get_error_log (wfid)
 
-            wfid = to_wfid(wfid)
+            wfid = extract_wfid wfid, true
             @per_processes[wfid] or []
         end
 
@@ -281,7 +281,7 @@ module OpenWFE
         #
         def remove_error_log (wfid)
 
-            wfid = to_wfid(wfid)
+            wfid = extract_wfid wfid, true
             @per_processes.delete(wfid)
         end
 
@@ -349,7 +349,7 @@ module OpenWFE
         #
         def get_error_log (wfid)
 
-            path = get_path(wfid)
+            path = get_path wfid
 
             return [] unless File.exist?(path)
 
@@ -470,7 +470,7 @@ module OpenWFE
             #
             def get_path (fei_or_wfid)
 
-                @workdir + "/" + to_wfid(fei_or_wfid) + ".ejournal"
+                @workdir + "/" + extract_wfid(fei_or_wfid, true) + ".ejournal"
             end
     end
 end

data/lib/openwfe/expool/expressionpool.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2008, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -39,8 +39,6 @@
 
 require 'uri'
 require 'monitor'
-require 'open-uri'
-require 'rexml/document'
 
 require 'openwfe/utils'
 require 'openwfe/service'
@@ -48,16 +46,14 @@ require 'openwfe/logging'
 require 'openwfe/omixins'
 require 'openwfe/rudefinitions'
 require 'openwfe/flowexpressionid'
-require 'openwfe/util/lru'
-require 'openwfe/util/safe'
 require 'openwfe/util/workqueue'
 require 'openwfe/util/observable'
+require 'openwfe/expool/parser'
 require 'openwfe/expressions/environment'
-require 'openwfe/expressions/raw_xml'
-require 'openwfe/expressions/raw_prog'
-require 'openwfe/expressions/simplerep'
+require 'openwfe/expressions/raw'
 
-include OpenWFE
+require 'rufus/lru' # gem 'rufus-lru'
+require 'rufus/verbs' # gem 'rufus-lru'
 
 
 module OpenWFE
@@ -97,17 +93,22 @@ module OpenWFE
 
 
         #
-        # code loaded from a remote URI will get evaluated with 
-        # that security level
+        # The hash containing the wfid of the process instances currently
+        # paused.
         #
-        SAFETY_LEVEL = 2
+        attr_reader :paused_instances
 
+        #
+        # The constructor for the expression pool.
+        #
         def initialize (service_name, application_context)
 
             super()
-
+            
             service_init(service_name, application_context)
 
+            @paused_instances = {}
+
             @monitors = MonitorProvider.new(application_context)
 
             @observers = {}
@@ -162,10 +163,12 @@ module OpenWFE
                 unless wfdurl
 
             definition = if wfdurl.match "^field:"
+
                 wfdfield = wfdurl[6..-1]
                 launchitem.attributes.delete wfdfield
             else
-                read_uri(wfdurl)
+
+                read_uri wfdurl
             end
 
             raise "didn't find process definition at '#{wfdurl}'" \
@@ -200,7 +203,7 @@ module OpenWFE
                 # will raise an exception if there are requirements
                 # and one of them is not met
 
-            raw_expression.new_environment()
+            raw_expression.new_environment
                 #
                 # as this expression is the root of a new process instance,
                 # it has to have an environment for all the variables of 
@@ -231,7 +234,7 @@ module OpenWFE
         # and of course used by the launch_template() method.
         #
         def prepare_from_template (
-            requesting_expression, sub_id, template, params=nil)
+            requesting_expression, env_id, sub_id, template, params=nil)
 
             rawexp = if template.is_a?(RawExpression)
 
@@ -282,9 +285,15 @@ module OpenWFE
             #    "#{rawexp.fei.workflow_instance_id.to_s}"
             #end
 
-            env = rawexp.new_environment params
+            if env_id
+
+                rawexp.environment_id = env_id
+            else
                 #
                 # the new scope gets its own environment
+                #
+                rawexp.new_environment params
+            end
 
             rawexp.store_itself
 
@@ -295,10 +304,15 @@ module OpenWFE
         # launches a subprocess
         #
         def launch_template (
-            requesting_expression, sub_id, template, workitem, params=nil)
+            requesting_expression, 
+            env_id, 
+            sub_id, 
+            template, 
+            workitem, 
+            params=nil)
 
             rawexp = prepare_from_template(
-                requesting_expression, sub_id, template, params)
+                requesting_expression, env_id, sub_id, template, params)
 
             workitem.flow_expression_id = rawexp.fei
 
@@ -332,6 +346,7 @@ module OpenWFE
         def apply (exp, workitem)
 
             queue_work :do_apply, exp, workitem
+            #do_apply exp, workitem
         end
 
         #
@@ -340,6 +355,7 @@ module OpenWFE
         def reply (exp, workitem)
 
             queue_work :do_reply, exp, workitem
+            #do_reply exp, workitem
         end
 
         #
@@ -349,7 +365,7 @@ module OpenWFE
         #
         def cancel (exp)
 
-            exp, fei = fetch(exp)
+            exp, fei = fetch exp
 
             unless exp
                 ldebug { "cancel() cannot cancel missing  #{fei.to_debug_s}" }
@@ -361,7 +377,7 @@ module OpenWFE
             onotify :cancel, exp
 
             inflowitem = exp.cancel()
-            remove(exp)
+            remove exp
 
             inflowitem
         end
@@ -381,9 +397,9 @@ module OpenWFE
             wi = cancel exp
 
             if wi
-                reply_to_parent(exp, wi, false)
+                reply_to_parent exp, wi, false
             else
-                parent_exp = fetch_expression(exp.parent_id)
+                parent_exp = fetch_expression exp.parent_id
                 parent_exp.remove_child(exp.fei) if parent_exp
             end
         end
@@ -394,10 +410,15 @@ module OpenWFE
         #
         def cancel_process (exp_or_wfid)
 
-            ldebug { "cancel_process() from  #{exp_or_wfid}" }
+            wfid = extract_wfid exp_or_wfid, false
+
+            ldebug { "cancel_process() '#{wfid}'" }
+
+            root = fetch_root wfid
+
+            raise "no process to cancel '#{wfid}'" unless root
 
-            root = fetch_root(exp_or_wfid)
-            cancel(root)
+            cancel root
         end
         alias :cancel_flow :cancel_process
 
@@ -407,7 +428,7 @@ module OpenWFE
         #
         def forget (parent_exp, exp)
 
-            exp, fei = fetch(exp)
+            exp, fei = fetch exp
 
             #ldebug { "forget() forgetting  #{fei}" }
 
@@ -518,11 +539,11 @@ module OpenWFE
 
                 #ldebug { "fetch() exp is of kind #{exp.class}" }
 
-                fei = if exp.kind_of?(FlowExpression)
+                fei = if exp.is_a?(FlowExpression)
 
                     exp.fei 
 
-                elsif not exp.kind_of?(FlowExpressionId)
+                elsif not exp.is_a?(FlowExpressionId)
 
                     raise \
                         "Cannot fetch expression with key : "+
@@ -547,51 +568,40 @@ module OpenWFE
         #
         def fetch_expression (exp)
 
-            exp, fei = fetch(exp)
+            exp, fei = fetch exp
             exp
         end
 
-        #
-        # Fetches the root expression of a process (given any of its
-        # expressions or its wfid).
-        #
-        def fetch_root (exp_or_wfid)
-
-            ldebug { "fetch_root() '#{exp_or_wfid.to_s}'" }
-
-            return fetch_expression_with_wfid(exp_or_wfid) \
-                if exp_or_wfid.is_a?(String)
-
-            exp = fetch_expression(exp_or_wfid)
-
-            raise "did not find root for expression #{exp_or_wfid}" unless exp
-
-            return exp unless exp.parent_id
-
-            fetch_root(fetch_expression(exp.parent_id))
-        end
-
         #
         # Returns the engine environment (the top level environment)
         #
-        def fetch_engine_environment ()
+        def fetch_engine_environment
             synchronize do
                 #
                 # synchronize to ensure that there's 1! engine env
 
                 eei = engine_environment_id
-                ee, fei = fetch(eei)
+                ee, fei = fetch eei
 
-                if not ee
-                    ee = Environment\
-                        .new(eei, nil, nil, @application_context, nil)
-                    ee.store_itself()
-                end
+                return ee if ee
+
+                ee = Environment.new_env(
+                    eei, nil, nil, @application_context, nil)
+
+                ee.store_itself
 
                 ee
             end
         end
 
+        #
+        # Fetches the root expression of a process (or a subprocess).
+        #
+        def fetch_root (wfid)
+
+            get_expression_storage.fetch_root wfid
+        end
+
         #
         # Removes a flow expression from the pool
         # (This method is mainly called from the pool itself)
@@ -631,14 +641,15 @@ module OpenWFE
 
                 linfo { "reschedule() initiating..." }
 
-                get_expression_storage.each_of_kind(Schedulable) do |fei, fe|
+                options = { :include_classes => Rufus::Schedulable }
+
+                get_expression_storage.find_expressions(options).each do |fexp|
 
-                    #linfo { "reschedule() for  #{fei.to_debug_s}..." }
-                    linfo { "reschedule() for  #{fei.to_s}..." }
+                    linfo { "reschedule() for  #{fexp.fei.to_s}..." }
 
-                    onotify :reschedule, fei
+                    onotify :reschedule, fexp.fei
 
-                    fe.reschedule(get_scheduler)
+                    fexp.reschedule get_scheduler
                 end
 
                 linfo { "reschedule() done. (took #{t.duration} ms)" }
@@ -673,84 +684,42 @@ module OpenWFE
         # Returns the list of applied expressions belonging to a given
         # workflow instance.
         #
-        def get_process_stack (wfid)
-
-            raise "please provide a non-nil workflow instance id" \
-                unless wfid
-
-            wfid = to_wfid wfid
-
-            result = []
+        # If the unapplied optional parameter is set to true, all the
+        # expressions (even those not yet applied) that compose the process
+        # instance will be returned. Environments will be returned as well.
+        #
+        def process_stack (wfid, unapplied=false)
 
-            get_expression_storage.real_each do |fei, fexp|
+            #raise "please provide a non-nil workflow instance id" \
+            #    unless wfid
 
-                next if fexp.kind_of?(Environment)
-                next if fexp.kind_of?(RawExpression)
-                next unless fexp.apply_time
+            wfid = extract_wfid wfid, true
 
-                next if fei.parent_wfid != wfid
+            params = {
+                #:exclude_classes => [ Environment, RawExpression ],
+                #:exclude_classes => [ Environment ],
+                :parent_wfid => wfid
+            }
+            params[:applied] = true if (not unapplied)
 
-                result << fexp
-            end
-
-            ldebug do 
-                "process_stack() " +
-                "found #{result.size} exps for flow #{wfid}" 
-            end
-
-            result
+            get_expression_storage.find_expressions params
         end
 
-        alias :get_flow_stack :get_process_stack
-
         #
         # Lists all workflows (processes) currently in the expool (in
         # the engine).
         # This method will return a list of "process-definition" expressions
         # (root of flows).
         #
-        # If consider_subprocesses is set to true, "process-definition" 
-        # expressions of subprocesses will be returned as well.
-        #
-        # "wfid_prefix" allows your to query for specific workflow instance
-        # id prefixes.
-        #
-        def list_processes (consider_subprocesses=false, wfid_prefix=nil)
-
-            result = []
-
-            # collect() would look better
-
-            get_expression_storage.real_each(wfid_prefix) do |fei, fexp|
-
-                #ldebug { "list_processes() class is #{fexp.class.name}" }
-
-                next unless fexp.is_a?(DefineExpression)
-
-                next if not consider_subprocesses and fei.wfid.index(".")
-
-                #next unless fei.wfid.match("^#{wfid_prefix}") if wfid_prefix
-
-                result << fexp
-            end
-
-            result
-        end
-
-        #
-        # Returns the first expression found with the given wfid.
-        #
-        def fetch_expression_with_wfid (wfid)
-
-            #list_processes(false, wfid)[0]
+        def list_processes (options={})
 
-            ps = list_processes(false, wfid)
-
-            ldebug do 
-                "fetch_expression_with_wfid() '#{wfid}' found #{ps.size} items"
-            end
+            options[:include_classes] = DefineExpression
+                #
+                # Maybe it would be better to list root expressions instead
+                # so that expressions like 'sequence' can be used
+                # as root expressions. Later...
 
-            ps[0]
+            get_expression_storage.find_expressions options
         end
 
         #
@@ -765,7 +734,7 @@ module OpenWFE
             fei = extract_fei fei
                 # densha requires that... :(
 
-            se = OpenWFE::exception_to_s(error)
+            se = OpenWFE::exception_to_s error
 
             onotify :error, fei, message, workitem, error.class.name, se
 
@@ -786,18 +755,41 @@ module OpenWFE
             end
         end
 
+        #
+        # Gets the process definition (if necessary) and turns into
+        # into an expression tree (for storing into a RawExpression).
+        #
+        def determine_rep (param)
+
+            param = read_uri(param) if param.is_a?(URI)
+
+            DefParser.parse param
+        end
+
         protected
 
-            #--
-            # Returns true if it's the fei of a participant 
-            # (or of a subprocess ref)
             #
-            #def is_participant? (fei)
-            #    exp_name = fei.expression_name
-            #    return true if exp_name == "participant"
-            #    (get_expression_map.get_class(exp_name) == nil)
-            #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)
+
+                uri = URI.parse uri.to_s
+
+                raise "loading remote definitions is not allowed" \
+                    if (ac[:remote_definitions_allowed] != true and
+                        uri.scheme and
+                        uri.scheme != 'file')
+
+                #open(uri.to_s).read
+
+                f = Rufus::Verbs.fopen uri
+                result = f.read
+                f.close if f.respond_to?(:close)
+
+                result
+            end
 
             #
             # This method is called by the workqueue when processing
@@ -813,7 +805,7 @@ module OpenWFE
 
                 rescue Exception => e
 
-                    notify_error(e, fei, message, workitem)
+                    notify_error e, fei, message, workitem
                 end
             end
 
@@ -824,22 +816,21 @@ module OpenWFE
 
                 exp, _fei = fetch(exp) if exp.is_a?(FlowExpressionId)
 
-                check_if_paused exp
-
                 #ldebug { "apply()  '#{_fei}'" }
 
                 if not exp
 
+                    #raise "apply() cannot apply missing  #{_fei.to_debug_s}"
+                        # not very helpful anyway
+
                     lwarn do 
                         "do_apply() cannot apply missing  #{_fei.to_debug_s}"
                     end
-
                     return
-
-                    #raise "apply() cannot apply missing  #{_fei.to_debug_s}"
-                        # not very helpful anyway
                 end
 
+                check_if_paused exp
+
                 workitem.flow_expression_id = exp.fei
 
                 onotify :apply, exp, workitem
@@ -857,14 +848,18 @@ module OpenWFE
                 ldebug { "reply() to   #{fei.to_debug_s}" }
                 ldebug { "reply() from #{workitem.last_expression_id.to_debug_s}" }
 
-                check_if_paused exp
-
                 if not exp
+
                     #raise "cannot reply to missing  #{fei.to_debug_s}"
-                    lwarn { "reply() cannot reply to missing  #{fei.to_debug_s}" }
+
+                    lwarn do 
+                        "reply() cannot reply to missing  #{fei.to_debug_s}"
+                    end
                     return
                 end
 
+                check_if_paused exp
+
                 onotify :reply, exp, workitem
 
                 exp.reply(workitem)
@@ -876,10 +871,9 @@ module OpenWFE
             #
             def check_if_paused (expression)
 
-                return unless expression
+                wfid = expression.fei.parent_wfid
 
-                raise PausedError.new(expression.fei.wfid) \
-                    if expression.paused?
+                raise PausedError.new(wfid) if @paused_instances[wfid]
             end
 
             #
@@ -894,7 +888,7 @@ module OpenWFE
                 ocron = options[:cron]
                 oevery = options[:every]
 
-                fei = new_fei(nil, "schedlaunch", "0", "sequence")
+                fei = new_fei nil, "schedlaunch", "0", "sequence"
 
                 # not very happy with this code, it builds custom
                 # wrapping processes manually, maybe there is 
@@ -902,8 +896,8 @@ module OpenWFE
 
                 if oat or oin
 
-                    seq = get_expression_map.get_class(:sequence)
-                    seq = seq.new(fei, nil, nil, application_context, nil)
+                    seq = get_expression_map.get_class :sequence
+                    seq = seq.new_exp fei, nil, nil, application_context, nil
 
                     att = if oat
                         { "until" => oat }
@@ -912,10 +906,14 @@ module OpenWFE
                     end
                     att["scheduler-tags"] = "scheduled-launch"
 
-                    sle = get_expression_map.get_class(:sleep)
-                    sle = sle.new(fei.dup, fei, nil, application_context, att)
+                    sle = get_expression_map.get_class :sleep
+
+                    sle = sle.new_exp(
+                        fei.dup, fei, nil, application_context, att)
+
                     sle.fei.expression_id = "0.0"
                     sle.fei.expression_name = "sleep"
+
                     seq.children << sle.fei
                     seq.children << raw_expression.fei
 
@@ -940,8 +938,8 @@ module OpenWFE
                     att["name"] = "//cron_launch__#{fei.wfid}"
                     att["scheduler-tags"] = "scheduled-launch"
 
-                    cro = get_expression_map.get_class(:cron)
-                    cro = cro.new(fei, nil, nil, application_context, att)
+                    cro = get_expression_map.get_class :cron
+                    cro = cro.new_exp fei, nil, nil, application_context, att
 
                     cro.children << raw_expression.fei
 
@@ -991,78 +989,6 @@ module OpenWFE
                 wi
             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)
-
-                uri = uri.to_s
-                uri = uri[5..-1] if uri.match("^file:")
-                uri = URI.parse(uri)
-
-                if uri.scheme
-                    raise "loading remote definitions is not allowed" \
-                        if ac[:remote_definitions_allowed] != true
-                end
-
-                open(uri.to_s).read
-            end
-
-            #
-            # The parameter to this method might be either a process
-            # definition (in any form) or a LaunchItem.
-            #
-            # Will return a 'representation' (what is used to build
-            # a RawExpression instance).
-            #
-            def determine_representation (param)
-
-                #ldebug do 
-                #    "determine_representation() from class #{param.class.name}"
-                #end
-
-                param = read_uri(param) if param.is_a?(URI)
-
-                #ldebug do 
-                #    "determine_representation() " +
-                #    "param of class #{param.class.name}" 
-                #end
-
-                return param \
-                    if param.is_a?(SimpleExpRepresentation)
-
-                return param.do_make \
-                    if param.is_a?(ProcessDefinition) or param.is_a?(Class)
-
-                raise "cannot handle definition of class #{param.class.name}" \
-                    unless param.is_a? String
-
-                if param[0, 1] == "<"
-                    #
-                    # XML definition
-
-                    xmlRoot = REXML::Document.new(param).root
-                    class << xmlRoot
-                        def raw_expression_class
-                            XmlRawExpression
-                        end
-                    end
-                    return xmlRoot
-                end
-
-                return YAML.load(s) if param.match("^--- .")
-                    #
-                    # something that was dumped via YAML
-
-                #
-                # else it's some ruby code to eval
-
-                ProcessDefinition::eval_ruby_process_definition(
-                    param, SAFETY_LEVEL)
-            end
-
             #
             # Builds a FlowExpressionId instance for a process being
             # launched.
@@ -1099,20 +1025,16 @@ module OpenWFE
             #
             def build_raw_expression (launchitem, param)
 
-                procdef = determine_representation param
-
-                #return procdef if procdef.is_a? RawExpression
-
-                flow_name = procdef.attributes['name']
-                flow_revision = procdef.attributes['revision']
-                exp_name = procdef.name
+                procdef = determine_rep param
 
-                fei = new_fei(launchitem, flow_name, flow_revision, exp_name)
+                atts = procdef[1]
+                flow_name = atts['name'] || "noname"
+                flow_revision = atts['revision'] || "0"
+                exp_name = procdef.first
 
-                #puts procdef.raw_expression_class
-                #puts procdef.raw_expression_class.public_methods
+                fei = new_fei launchitem, flow_name, flow_revision, exp_name
 
-                procdef.raw_expression_class.new(
+                RawExpression.new_raw(
                     fei, nil, nil, @application_context, procdef)
             end
     end