openwferu 0.9.5 → 0.9.6

data/examples/mano_tracker.rb

@@ -48,7 +48,7 @@
 #require 'openwfe/engine/engine'
 require 'openwfe/engine/file_persisted_engine'
 require 'openwfe/expressions/raw_prog'
-require 'openwfe/participants/storeparticipant'
+require 'openwfe/worklist/storeparticipant'
 
 
 #
@@ -58,21 +58,19 @@ require 'openwfe/participants/storeparticipant'
 class TrackerDefinition < OpenWFE::ProcessDefinition
     def make
 
-        process_definition :name => "mano_tracker", :revision => "0.2" do
-            _loop do
-                participant "${f:creative}"
-                participant "${f:analyst}"
+        _loop do
+            participant "${f:creative}"
+            participant "${f:analyst}"
 
-                _break :if => "${f:done}"
-                    #
-                    # loops until the analyst sets the value of the field
-                    # 'done' to true.
-            end
+            _break :if => "${f:done}"
                 #
-                # 'loop' and 'break' are ruby keywords, they have to be
-                # preceded by an underscore '_' to be used in their 
-                # OpenWFEru sense.
+                # loops until the analyst sets the value of the field
+                # 'done' to true.
         end
+            #
+            # 'loop' and 'break' are ruby keywords, they have to be
+            # preceded by an underscore '_' to be used in their 
+            # OpenWFEru sense.
     end
 end
 

data/lib/openwfe.rb

@@ -36,8 +36,6 @@
 # referenced as a library via a require statement.
 #
 
-require 'openwfe/workitem'
-require 'openwfe/engine'
-require 'openwfe/rudefinitions'
-require 'openwfe/participants'
+require 'openwfe/engine/engine'
+#require 'openwfe/engine/file_persisted_engine'
 

data/lib/openwfe/contextual.rb

@@ -73,8 +73,14 @@ module OpenWFE
         #
         def init_service (service_name, service_class)
 
-            @application_context[service_name.to_s] =
-                service_class.new(service_name, @application_context)
+            s = service_class.new(service_name, @application_context)
+
+            s.service_name = "#{service_class.name}::#{s.object_id}" \
+                unless service_name
+
+            @application_context[s.service_name.to_s] = s
+
+            return s
         end
 
     end

data/lib/openwfe/engine/engine.rb

@@ -45,6 +45,7 @@ require 'logger'
 require 'openwfe/workitem'
 require 'openwfe/rudefinitions'
 require 'openwfe/service'
+require 'openwfe/util/scheduler'
 require 'openwfe/util/schedulers'
 require 'openwfe/expool/expressionpool'
 require 'openwfe/expool/expstorage'
@@ -61,6 +62,9 @@ module OpenWFE
     class Engine < Service
         include OwfeServiceLocator
 
+        #
+        # Builds an OpenWFEru engine.
+        #
         def initialize ()
 
             super(S_ENGINE, {})
@@ -111,11 +115,17 @@ module OpenWFE
             launchitem = nil
 
             if launch_object.kind_of? OpenWFE::LaunchItem
+
                 launchitem = launch_object
+
             elsif launch_object.kind_of? Class
+
                 launchitem = LaunchItem.new(launch_object)
+
             elsif launch_object.kind_of? String
+
                 launchitem = OpenWFE::LaunchItem.new
+
                 if launch_object[0] == '<'
                     launchitem.workflowDefinitionUrl = "field:__definition"
                     launchitem['definition'] = launch_object
@@ -127,14 +137,39 @@ module OpenWFE
             get_expression_pool.launch(launchitem, async)
         end
 
+        #
+        # Returns the list of applied expressions belonging to a given
+        # workflow instance.
+        # May be used to determine where a process instance currently is.
+        #
+        def get_flow_position (workflow_instance_id)
+
+            get_expression_pool.get_flow_position(workflow_instance_id)
+        end
+
         #
         # This method is used to feed a workitem back to the engine (after
         # it got sent to a worklist or wherever by a participant).
         # Participant implementations themselves do call this method usually.
         #
+        # This method also accepts LaunchItem instances.
+        #
         def reply (workitem)
 
-            get_expression_pool.reply(workitem.flow_expression_id, workitem)
+            if workitem.kind_of? InFlowWorkItem
+
+                get_expression_pool.reply(workitem.flow_expression_id, workitem)
+
+            elsif workitem.kind_of? LaunchItem
+
+                get_expression_pool.launch(workitem, false)
+
+            else
+
+                raise \
+                    "engine.reply() " +
+                    "cannot handle instances of #{workitem.class}"
+            end
         end
 
         #
@@ -161,6 +196,83 @@ module OpenWFE
             get_participant_map.lookup_participant(participant_name)
         end
 
+        #
+        # Removes the first participant matching the given name from the
+        # participant map kept by the engine.
+        #
+        def unregister_participant (participant_name)
+
+            get_participant_map.unregister_participant(participant_name)
+        end
+
+        #
+        # Adds a workitem listener to this engine.
+        #
+        # The 'freq' parameters if present might indicate how frequently
+        # the resource should be polled for incoming workitems.
+        #
+        #     engine.add_workitem_listener(listener, "3m10s")
+        #        # every 3 minutes and 10 seconds
+        #
+        #     engine.add_workitem_listener(listener, "0 22 * * 1-5")
+        #        # every weekday at 10pm
+        #
+        # TODO : block handling...
+        #
+        def add_workitem_listener (listener, freq=nil)
+
+            name = nil
+
+            if listener.kind_of? Class
+
+                listener = init_service(nil, listener)
+
+                name = listener.service_name
+            else
+
+                name = listener.name if listener.respond_to? :name
+                name = "#{listener.class}::#{listener.object_id}" unless name
+
+                @application_context[name] = listener
+            end
+
+            result = nil
+
+            if freq
+
+                freq = freq.to_s.strip
+
+                result = if Scheduler.is_cron_string(freq)
+
+                    get_scheduler.schedule(freq, nil, listener, nil)
+                else
+
+                    get_scheduler.schedule_every(freq, listener, nil)
+                end
+            end
+
+            linfo { "add_workitem_listener() added '#{name}'" }
+
+            result
+        end
+
+        #
+        # Makes the current thread join the engine's scheduler thread
+        #
+        # You can thus make an engine standalone with something like :
+        #
+        #     require 'openwfe/engine/engine'
+        #
+        #     the_engine = OpenWFE::Engine.new
+        #     the_engine.join
+        #
+        # And you'll have to hit CTRL-C to make it stop.
+        #
+        def join
+
+            get_scheduler.join
+        end
+
         #
         # Stopping the engine will stop all the services in the
         # application context.
@@ -190,23 +302,27 @@ module OpenWFE
             #
 
             def build_expression_map ()
+
                 init_service(S_EXPRESSION_MAP, ExpressionMap)
             end
 
             def build_expression_pool ()
+
                 init_service(S_EXPRESSION_POOL, ExpressionPool)
             end
 
             def build_expression_storage ()
+
                 init_service(S_EXPRESSION_STORAGE, InMemoryExpressionStorage)
             end
 
             def build_participant_map ()
+
                 init_service(S_PARTICIPANT_MAP, ParticipantMap)
             end
             
             def build_scheduler ()
-                #ldebug { "build_scheduler()" }
+
                 init_service(S_SCHEDULER, SchedulerService)
             end
 

data/lib/openwfe/expool/expressionpool.rb

@@ -41,7 +41,7 @@
 
 require 'uri'
 require 'monitor'
-require 'net/http'
+require 'open-uri'
 require 'rexml/document'
 
 require 'openwfe/utils'
@@ -50,6 +50,7 @@ require 'openwfe/logging'
 require 'openwfe/rudefinitions'
 require 'openwfe/flowexpressionid'
 require 'openwfe/util/lru'
+require 'openwfe/util/safe'
 require 'openwfe/util/observable'
 require 'openwfe/expressions/environment'
 require 'openwfe/expressions/raw_xml'
@@ -128,6 +129,11 @@ module OpenWFE
             OwfeServiceLocator, 
             Observable
 
+        SAFETY_LEVEL = 2
+            #
+            # code loaded from a remote URI will get evaluated with 
+            # that security level
+
         @@last_given_instance_id = -1
             #
             # storing at class level the last workflow instance id given
@@ -176,7 +182,16 @@ module OpenWFE
 
             onotify :launch, launchitem.workflow_definition_url
 
-            raw_expression = buildRawExpression(launchitem)
+            procdef = fetch_definition(launchitem)
+
+            raw_expression = build_raw_expression(
+                launchitem.workflow_definition_url, procdef)
+
+            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 
+                # the process instance
 
             wi = build_workitem(launchitem)
 
@@ -185,13 +200,13 @@ module OpenWFE
             if async
 
                 t = OpenWFE::call_in_thread "launch()", self do
-                    raw_expression.apply(wi)
+                    apply(raw_expression, wi)
                 end
 
                 return fei, t
             end
 
-            raw_expression.apply(wi)
+            apply(raw_expression, wi)
 
             return fei
         end
@@ -207,8 +222,15 @@ module OpenWFE
             rawexp = nil
 
             if template.kind_of? FlowExpressionId
+
                 rawexp, fei = fetch(template)
+
+            elsif template.kind_of? URI
+
+                rawexp = load_rawexp_from_uri(template)
+
             else # template is of kind RawExpression
+
                 rawexp = template
             end
 
@@ -257,7 +279,7 @@ module OpenWFE
             #end
 
             env = rawexp.new_environment()
-
+                #
             params.each { |k, v| env[k] = v } if params
                 #
                 # the new scope gets its own environment
@@ -268,7 +290,7 @@ module OpenWFE
 
             fei = rawexp.fei
 
-            rawexp.apply(workitem)
+            apply(rawexp, workitem)
 
             return fei
         end
@@ -295,7 +317,7 @@ module OpenWFE
         #
         def apply (exp, workitem)
 
-            exp, fei = fetch(exp)
+            exp, fei = fetch(exp) if exp.kind_of? FlowExpressionId
 
             #ldebug { "apply()  '#{fei}' (#{fei.class})" }
 
@@ -306,10 +328,14 @@ module OpenWFE
 
             #ldebug { "apply()  #{fei.to_debug_s}" }
 
-            onotify :apply, fei, workitem
+            #exp.apply_time = OpenWFE::now()
+                #
+                # this is done in RawExpression
 
             workitem.flow_expression_id = exp.fei
 
+            onotify :apply, exp.fei, workitem
+
             exp.apply(workitem)
         end
 
@@ -510,15 +536,12 @@ module OpenWFE
         #
         def remove (exp)
 
-            #exp, fei = fetch(exp)
-
-            if exp.kind_of? FlowExpressionId
-                exp, _fei = fetch(exp)
-            end
+            exp, _fei = fetch(exp) \
+                if exp.kind_of? FlowExpressionId
 
             return if not exp
 
-            ldebug { "remove()  fe  #{exp.fei.to_debug_s}" }
+            ldebug { "remove() fe  #{exp.fei.to_debug_s}" }
 
             onotify :remove, exp.fei
 
@@ -526,13 +549,8 @@ module OpenWFE
 
                 @monitors.delete(exp.fei)
 
-                #get_expression_storage().delete(fei)
-
-                if exp.owns_its_environment?
-
-                    remove_environment(exp.environment_id)
-                end
-
+                remove_environment(exp.environment_id) \
+                    if exp.owns_its_environment?
             end
         end
 
@@ -586,12 +604,59 @@ module OpenWFE
             end
         end
 
+        #
+        # Returns the list of applied expressions belonging to a given
+        # workflow instance.
+        #
+        def get_flow_position (wfid)
+
+            raise "please provide a non-nil workflow instance id" \
+                unless wfid
+
+            result = []
+
+            get_expression_storage.real_each do |fei, fexp|
+
+                next if fexp.kind_of? Environment
+                next if fexp.kind_of? RawExpression
+                next unless fexp.apply_time
+
+                pi = fei.parent_wfid
+
+                next if pi != wfid
+
+                result << fexp
+            end
+
+            ldebug do 
+                "get_flow_position() " +
+                "found #{result.size} exps for flow #{wfid}" 
+            end
+
+            return result
+        end
+
         protected
 
-            def evaluate_definition (raw_definition, workitem)
-                expression = raw_definition.instantiate(workitem)
+            #def evaluate_definition (raw_definition, workitem)
+            #    expression = raw_definition.instantiate(workitem)
+            #end
+
+            #
+            # Prepares the RawExpression for a 'remote' process definition
+            # (a process definition pointed at via a URI).
+            #
+            def load_rawexp_from_uri (uri)
+
+                procdef = determine_representation(uri.read)
+
+                build_raw_expression(uri.to_s, procdef)
             end
 
+            #
+            # Removes an environment, especially takes care of unbinding
+            # any special value it may contain.
+            #
             def remove_environment (environment_id)
 
                 ldebug { "remove_environment()  #{environment_id.to_debug_s}" }
@@ -605,6 +670,10 @@ module OpenWFE
                 onotify :remove, environment_id
             end
 
+            #
+            # Prepares a new instance of InFlowWorkItem from a LaunchItem
+            # instance.
+            #
             def build_workitem (launchitem)
 
                 wi = InFlowWorkItem.new()
@@ -614,6 +683,40 @@ module OpenWFE
                 return wi
             end
 
+            #
+            # Given a string that contains either an XML process
+            # definition, either a Ruby process definition
+            # will return a 'representation' (what is used to build
+            # a RawExpression instance).
+            #
+            def determine_representation (string_definition)
+
+                if string_definition[0, 1] == "<"
+
+                    xmlRoot = REXML::Document.new(string_definition).root
+                    class << xmlRoot
+                        def raw_expression_class
+                            XmlRawExpression
+                        end
+                    end
+                    return xmlRoot
+                end
+
+                # else
+
+                #o = eval(string_definition)
+                o = OpenWFE::eval_safely(string_definition, SAFETY_LEVEL)
+                #o = OpenWFE::load_eval_safely(string_definition, SAFETY_LEVEL)
+                #o = OpenWFE::eval_r_safely(string_definition, SAFETY_LEVEL)
+
+                return o.do_make if o.kind_of? Class
+
+                return o
+            end
+
+            #
+            # Extracts the process definition that a launchitem points at.
+            #
             def fetch_definition (launchitem)
 
                 wfdUrl = launchitem.workflow_definition_url
@@ -627,44 +730,36 @@ module OpenWFE
                     wfdField = wfdUrl[6..-1]
                     sDefinition = launchitem.attributes[wfdField]
                 else
-                    sDefinition = NET::HTTP.get(URI.parse(wfdUrl))
+                    sDefinition = URI.parse(wfdUrl).read
                 end
 
                 #ldebug { "sDefinition is \n#{sDefinition}" }
 
                 launchitem.attributes.delete(wfdField) if wfdField
 
-                if sDefinition.kind_of? String
-
-                    xmlRoot = REXML::Document.new(sDefinition).root
-                    class << xmlRoot
-                        def rawExpressionClass 
-                            XmlRawExpression
-                        end
-                    end
-                    return xmlRoot
-                end
-
-                if sDefinition.kind_of? ProgExpRepresentation
+                return determine_representation(sDefinition) \
+                    if sDefinition.kind_of? String
 
-                    return sDefinition
-                end
+                return sDefinition \
+                    if sDefinition.kind_of? ProgExpRepresentation
 
-                if sDefinition.kind_of? ProcessDefinition
+                return sDefinition.make \
+                    if sDefinition.kind_of? ProcessDefinition
 
-                    return sDefinition.make()
-                end
+                return sDefinition.do_make \
+                    if sDefinition.kind_of? Class
 
-                if sDefinition.kind_of? Class
-
-                    return sDefinition.do_make()
-                end
+                # else...
 
                 raise \
                     "Cannot deduce process definition " +
                     "out of instance of class #{sDefinition.class}"
             end
 
+            #
+            # Builds a FlowExpressionId instance for process being
+            # launched.
+            #
             def new_fei (flow_url, flow_name, flow_revision, exp_name)
 
                 fei = FlowExpressionId.new
@@ -681,6 +776,9 @@ module OpenWFE
                 return fei
             end
 
+            #
+            # Returns a new unique workflow instance id
+            #
             def new_workflow_instance_id ()
 
                 synchronize do
@@ -700,21 +798,18 @@ module OpenWFE
             # Builds the RawExpression instance at the root of the flow
             # being launched.
             #
-            def buildRawExpression (launchitem)
-
-                procdef = fetch_definition(launchitem)
+            def build_raw_expression (url, procdef)
 
-                flow_url = launchitem.workflow_definition_url
                 flow_name = procdef.attributes['name']
                 flow_revision = procdef.attributes['revision']
                 exp_name = procdef.name
 
-                fei = new_fei(flow_url, flow_name, flow_revision, exp_name)
+                fei = new_fei(url, flow_name, flow_revision, exp_name)
 
-                #puts procdef.rawExpressionClass
-                #puts procdef.rawExpressionClass.public_methods
+                #puts procdef.raw_expression_class
+                #puts procdef.raw_expression_class.public_methods
 
-                return procdef.rawExpressionClass\
+                return procdef.raw_expression_class\
                     .new(fei, nil, nil, @application_context, procdef)
             end