ruote 0.9.18

data/lib/openwfe/expressions/rprocdef.rb

@@ -0,0 +1,375 @@
+#
+#--
+# 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
+#
+
+require 'rufus/eval' # gem 'rufus-eval'
+
+require 'openwfe/utils'
+require 'openwfe/expressions/raw'
+
+
+module OpenWFE
+
+    #
+    # Extend this class to create a programmatic process definition.
+    #
+    # A short example :
+    # 
+    #   class MyProcessDefinition < OpenWFE::ProcessDefinition
+    #       def make
+    #           process_definition :name => "test1", :revision => "0" do
+    #               sequence do
+    #                   set :variable => "toto", :value => "nada"
+    #                   print "toto:${toto}"
+    #               end
+    #           end
+    #       end
+    #   end
+    #
+    #   li = OpenWFE::LaunchItem.new(MyProcessDefinition)
+    #   engine.launch(li)
+    # 
+    #
+    class ProcessDefinition
+
+        def self.metaclass; class << self; self; end; end
+
+        attr_reader :context
+
+        def initialize
+
+            super()
+            @context = Context.new
+        end
+
+        def method_missing (m, *args, &block)
+
+            #puts "__i_method_missing >>>#{m}<<<<"
+
+            ProcessDefinition.make_expression(
+                @context, 
+                OpenWFE::to_expression_name(m),
+                ProcessDefinition.pack_args(args), 
+                &block)
+        end
+
+        def self.method_missing (m, *args, &block)
+
+            @ccontext = Context.new \
+                if (not @ccontext) or @ccontext.discarded?
+
+            ProcessDefinition.make_expression(
+                @ccontext, 
+                OpenWFE::to_expression_name(m),
+                ProcessDefinition.pack_args(args), 
+                &block)
+        end
+
+        #
+        # builds an actual expression representation (a node in the
+        # process definition tree).
+        #
+        def self.make_expression (context, exp_name, params, &block)
+
+            string_child = nil
+            #attributes = OpenWFE::SymbolHash.new
+            attributes = Hash.new
+
+            #puts " ... params.class is #{params.class}"
+
+            if params.kind_of?(Hash)
+
+                params.each do |k, v|
+
+                    if k == '0'
+                        string_child = v.to_s
+                    else
+                        #attributes[OpenWFE::symbol_to_name(k.to_s)] = v.to_s
+                        attributes[OpenWFE::symbol_to_name(k.to_s)] = v
+                    end
+                end
+
+            elsif params
+
+                string_child = params.to_s
+            end
+
+            exp = [ exp_name, attributes, [] ]
+
+            exp.last << string_child \
+                if string_child
+
+            if context.parent_expression
+                #
+                # adding this new expression to its parent
+                #
+                context.parent_expression.last << exp
+            else
+                #
+                # an orphan, a top expression
+                #
+                context.top_expressions << exp
+            end
+
+            return exp unless block
+
+            context.push_parent_expression exp
+
+            result = block.call
+
+            exp.last << result \
+                if result and result.kind_of?(String)
+
+            context.pop_parent_expression
+
+            exp
+        end
+
+        def do_make
+
+            ProcessDefinition.do_make self
+        end
+
+        #
+        # A class method for actually "making" the process 
+        # segment raw representation
+        #
+        def self.do_make (instance=nil)
+
+            context = if @ccontext
+
+                @ccontext.discard
+                    # preventing further additions in case of reevaluation
+                @ccontext
+
+            elsif instance
+
+                instance.make
+                instance.context
+            else    
+
+                pdef = self.new
+                pdef.make
+                pdef.context
+            end
+
+            return context.top_expression if context.top_expression
+
+            name, revision = 
+                extract_name_and_revision(self.metaclass.to_s[8..-2])
+
+            top_expression = [ 
+                "process-definition", 
+                { "name" => name, "revision" => revision }, 
+                context.top_expressions 
+            ]
+
+            top_expression
+        end
+
+        #
+        # Parses the string to find the class name of the process definition
+        # and returns that class (instance).
+        #
+        def self.extract_class (ruby_proc_def_string)
+
+            ruby_proc_def_string.each_line do |l|
+
+                m = ClassNameRex.match l
+
+                return eval(m[1]) if m
+            end
+
+            nil
+        end
+
+        #
+        # Turns a String containing a ProcessDefinition ...
+        #
+        def self.eval_ruby_process_definition (code, safety_level=2)
+
+            # TODO : insert tree check
+
+            #puts "\nin:\n#{code}\n"
+
+            code, is_wrapped = wrap_code code
+
+            o = Rufus::eval_safely code, safety_level, binding()
+
+            o = extract_class(code) \
+                if (o == nil) or o.is_a?(Array)
+                #if (o == nil) or o.is_a?(SimpleExpRepresentation)
+                    #
+                    # grab the first process definition class found
+                    # in the given code
+
+            #return o.do_make \
+            #    if o.is_a?(ProcessDefinition) or o.is_a?(Class)
+            #o
+
+            result = o.do_make
+
+            #return result.first_child if is_wrapped
+            return result.last.first if is_wrapped
+
+            result
+        end
+
+        protected
+
+            ClassNameRex = Regexp.compile(
+                " *class *([a-zA-Z0-9]*) *< .*ProcessDefinition")
+            ProcessDefinitionRex = Regexp.compile(
+                "^class *[a-zA-Z0-9]* *< .*ProcessDefinition")
+            ProcessNameAndDefRex = Regexp.compile(
+                "([^0-9_]*)_*([0-9].*)$")
+            ProcessNameRex = Regexp.compile(
+                "(.*$)")
+            EndsInDefinitionRex = Regexp.compile(
+                ".*Definition$")
+
+            def self.wrap_code (code)
+
+                return [ code, false ] if ProcessDefinitionRex.match(code)
+
+                s =  "class NoName0 < ProcessDefinition"
+                s << "\n"
+                s << code
+                s << "\nend"
+
+                [ s, true ]
+            end
+
+            def self.pack_args (args)
+
+                return args[0] if args.length == 1
+
+                a = {}
+                args.each_with_index do |arg, index|
+                    if arg.is_a?(Hash)
+                        a = a.merge(arg)
+                        break
+                    end
+                    a[index.to_s] = arg
+                end
+                a
+            end
+
+            def self.extract_name_and_revision (s)
+
+                i = s.rindex("::")
+                s = s[i+2..-1] if i
+
+                m = ProcessNameAndDefRex.match s
+                return [ as_name(m[1]), as_revision(m[2]) ] if m
+
+                m = ProcessNameRex.match s
+                return [ as_name(m[1]), '0' ] if m
+
+                [ as_name(s), '0' ]
+            end
+
+            def self.as_name (s)
+
+                return s[0..-11] if EndsInDefinitionRex.match(s)
+                s
+            end
+
+            def self.as_revision (s)
+
+                s.gsub("_", ".")
+            end
+
+            class Context
+
+                attr_accessor :parent_expression, :top_expressions
+                attr_reader :previous_parent_expressions
+
+                def initialize
+                    @parent_expression = nil
+                    @top_expressions = []
+                    @previous_parent_expressions = []
+                end
+
+                def discard
+                    @discarded = true
+                end
+                def discarded?
+                    (@discarded == true)
+                end
+
+                #
+                # puts the current parent expression on top of the 'previous
+                # parent expressions' stack, the current parent expression
+                # is replaced with the supplied parent expression.
+                #
+                def push_parent_expression (exp)
+
+                    @previous_parent_expressions.push(@parent_expression) \
+                        if @parent_expression
+
+                    @parent_expression = exp
+                end
+
+                #
+                # Replaces the current parent expression with the one found
+                # on the top of the previous parent expression stack (pop).
+                #
+                def pop_parent_expression
+
+                    @parent_expression = @previous_parent_expressions.pop
+                end
+
+                #
+                # This method returns the top expression among the 
+                # top expressions...
+                #
+                def top_expression
+
+                    return nil if @top_expressions.size > 1
+
+                    exp = @top_expressions.first
+
+                    return exp if exp.first == "process-definition"
+                    nil
+                end
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/time.rb

@@ -0,0 +1,333 @@
+#
+#--
+# Copyright (c) 2006-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
+#
+
+require 'rufus/otime'
+require 'openwfe/expressions/timeout'
+
+
+module OpenWFE
+
+    #
+    # A parent class for CronExpression and SleepExpression, is never
+    # used directly.
+    # It contains a simple get_scheduler() method simplifying the scheduler
+    # localization for <sleep/> and <cron/>.
+    #
+    class TimeExpression < FlowExpression
+        include Rufus::Schedulable
+
+        #
+        # The workitem received at apply time
+        #
+        attr_accessor :applied_workitem
+
+        #
+        # The job_id in the scheduler for this expression
+        #
+        attr_accessor :scheduler_job_id
+
+        #
+        # The tags (if any) for the job in the scheduler
+        #
+        attr_accessor :scheduler_tags
+
+        #
+        # Makes sure to cancel any scheduler job associated with this
+        # expression
+        #
+        def cancel
+            #synchronize do
+
+            ldebug { "cancel()..." }
+
+            unschedule
+
+            super()
+
+            @applied_workitem
+            #end
+        end
+
+        #
+        # If the expression has been scheduled, a call to this method
+        # will make sure it's unscheduled (removed from the scheduler).
+        #
+        def unschedule
+
+            ldebug { "unschedule() @scheduler_job_id is #{@scheduler_job_id}" }
+
+            sleep get_scheduler.precision + 0.001
+                #
+                # make sure not to unschedule before the actual scheduling
+                # got done.
+
+            get_scheduler.unschedule(@scheduler_job_id) \
+                if @scheduler_job_id
+        end
+
+        protected
+
+            #
+            # looks up potential scheduler tags in the expression
+            # attributes
+            #
+            def determine_scheduler_tags
+
+                @scheduler_tags = lookup_array_attribute(
+                    :scheduler_tags, @applied_workitem) || []
+
+                @scheduler_tags << self.class.name
+            end
+    end
+
+    #
+    # A parent class for WhenExpression and WaitExpression.
+    #
+    # All the code for managing waiting for something to occur is 
+    # concentrated here.
+    #
+    class WaitingExpression < TimeExpression
+        include ConditionMixin
+        include TimeoutMixin
+
+        attr_accessor :frequency
+
+        uses_template
+
+        #
+        # By default, classes extending this class do poll for their
+        # condition every 10 seconds.
+        #
+        DEFAULT_FREQUENCY = "10s"
+
+        #
+        # Don't go under 300 milliseconds.
+        #
+        MIN_FREQUENCY = 0.300
+
+        #
+        # Classes extending this WaitingExpression have a 'conditions' class
+        # method (like 'attr_accessor').
+        #
+        def self.conditions (*attnames)
+
+            attnames = attnames.collect do |n|
+                n.to_s.to_sym
+            end
+            meta_def :condition_attributes do
+                attnames
+            end
+        end
+
+        def apply (workitem)
+
+            remove_timedout_flag workitem
+
+            @applied_workitem = workitem.dup
+
+            @frequency = lookup_attribute(
+                :frequency, workitem, :default => DEFAULT_FREQUENCY)
+            @frequency = Rufus::parse_time_string(
+                @frequency)
+            @frequency = MIN_FREQUENCY \
+                if @frequency < MIN_FREQUENCY
+
+            determine_timeout
+            determine_scheduler_tags
+
+            condition_attribute = determine_condition_attribute(
+                self.class.condition_attributes)
+
+            #
+            # register consequence
+
+            consequence = condition_attribute ? 
+                raw_children[0] : raw_children[1]
+            
+            get_expression_pool.tprepare_child(
+                self,
+                consequence,
+                0,
+                true, # please register child
+                nil   # no vars
+             ) if consequence
+
+             #
+             # go east...
+
+            store_itself
+
+            trigger
+        end
+
+        def reply (workitem)
+
+            result = workitem.get_result
+
+            if result
+                apply_consequence workitem
+            else
+                reschedule get_scheduler
+            end
+        end
+
+        #
+        # Cancels this expression (takes care of unscheduling a timeout
+        # if there is one).
+        #
+        def cancel
+
+            unschedule_timeout
+            super()
+        end
+
+        def trigger (params={})
+
+            ldebug { "trigger() #{@fei.to_debug_s} params : #{params.inspect}" }
+
+            if params[:do_timeout!]
+                #
+                # do timeout...
+                #
+                set_timedout_flag @applied_workitem
+                reply_to_parent @applied_workitem
+                return
+            end
+
+            @scheduler_job_id = nil
+
+            evaluate_condition
+        end
+
+        def reschedule (scheduler)
+
+            @scheduler_job_id = "waiting_#{fei.to_s}"
+
+            scheduler.schedule_in(
+                @frequency, 
+                { 
+                    :schedulable => self, 
+                    :job_id => @scheduler_job_id,
+                    :tags => @scheduler_tags })
+
+            ldebug { "reschedule() @scheduler_job_id is #{@scheduler_job_id}" }
+
+            to_reschedule scheduler
+        end
+
+        def reply_to_parent (workitem)
+
+            unschedule
+            unschedule_timeout
+
+            super workitem
+        end
+
+        protected
+
+            #
+            # The code for the condition evalution is here.
+            #
+            # This method is overriden by the WhenExpression.
+            #
+            def evaluate_condition
+
+                condition_attribute = determine_condition_attribute(
+                    self.class.condition_attributes)
+
+                if condition_attribute
+
+                    c = eval_condition condition_attribute, @applied_workitem
+
+                    do_reply c
+                    return
+                end
+
+                # else, condition is nested as a child
+
+                #if @children.size < 1
+                if raw_children.size < 1
+                    #
+                    # no condition attribute and no child attribute,
+                    # simply reply to parent
+                    #
+                    reply_to_parent @applied_workitem
+                    return
+                end
+
+                # trigger the first child (the condition child)
+
+                #get_expression_pool.launch_template(
+                #    self, 
+                #    @environment_id,
+                #    @condition_sub_id, 
+                #    @children[0], 
+                #    @applied_workitem)
+                get_expression_pool.tlaunch_child(
+                    self, 
+                    raw_children.first,
+                    (Time.new.to_f * 1000).to_i,
+                    @applied_workitem.dup, 
+                    false) # not registering as a child
+            end
+
+            #
+            # Used when replying to self after an attribute condition
+            # got evaluated
+            #
+            def do_reply (result)
+
+                @applied_workitem.set_result result
+                reply @applied_workitem
+            end
+
+            #
+            # This method is overriden by WhenExpression. WaitExpression
+            # doesn't override it.
+            # This default implementation simply directly replies to
+            # the parent expression.
+            #
+            def apply_consequence (workitem)
+
+                reply_to_parent workitem
+            end
+    end
+
+end
+