openwferu 0.9.0

data/lib/worklistclient.rb

@@ -0,0 +1,276 @@
+#
+# Copyright (c) 2005-2006, 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.
+#
+# $Id: worklistclient.rb 3454 2006-10-08 16:51:00Z jmettraux $
+#
+
+#
+# "hecho en Costa Rica"
+#
+
+require 'definitions'
+require 'restclient'
+require 'codec'
+
+
+module OpenWFE
+
+    class WorklistClient < RestClient
+
+        def initialize (server, port, username, password)
+
+            super('http://'+server+':'+port.to_s(), username, password)
+        end
+
+        def initialize (url, username, password)
+
+            super(url, username, password)
+        end
+
+        #
+        # Returns the list of stores the worklist hosts
+        #
+        def listStores ()
+            r = self.get('listStores', nil, nil)
+            return decode(r)
+        end
+
+        #
+        # A synonym for listStores()
+        #
+        def getStoreNames ()
+            return listStores()
+        end
+
+        #
+        # Returns the headers of a given store.
+        #
+        def getHeaders (storeName, limit=1000)
+
+            params = {}
+            params["limit"] = limit
+
+            return decode(self.get('getHeaders', storeName, params))
+        end
+
+        def findFlowInstance (storeName, workflowInstanceId)
+
+            params = {}
+            params["id"] = workflowInstanceId
+
+            return decode(self.get('findFlowInstance', storeName, params))
+        end
+
+        #
+        # Launches a flow (on a given engine and with a given launchitem).
+        # The 'engineId' corresponds to an engine's participant name
+        # (see etc/engine/participant-map.xml)
+        #
+        def launchFlow (engineId, launchitem)
+
+            eli = OpenWFE.encode(launchitem)
+
+            params = {}
+            params[ENGINEID] = engineId
+
+            return decode(self.post('launchFlow', nil, params, eli))
+        end
+
+        #
+        # Returns a workitem (but doesn't put a lock on it, thus modifications
+        # to it cannot be communicated with saveWorkitem() or forwardWorkitem()
+        # to the worklist)
+        #
+        def getWorkitem (storeName, flowExpressionId)
+
+            return getItem('getWorkitem', storeName, flowExpressionId)
+        end
+
+        #
+        # Returns a workitem and makes sure it's locked in the worklist. Thus,
+        # the usage of the methods saveWorkitem() and forwardWorkitem() is
+        # possible.
+        #
+        def getAndLockWorkitem (storeName, flowExpressionId)
+
+            #puts "...getAndLockWorkitem() for #{flowExpressionId}"
+
+            return getItem('getAndLockWorkitem', storeName, flowExpressionId)
+        end
+
+        #
+        # Given a queryMap (a dict of keys and values), locks and returns 
+        # the first workitem matching.
+        #
+        def queryAndLockWorkitem (storeName, queryMap)
+
+            hs = getHeaders(storeName)
+            hs.each do |h|
+
+                #puts "...h.id  #{h.flowExpressionId}"
+                #h.attributes.each do |k, v|
+                #    puts "......h '#{k}' => '#{v}'"
+                #end
+
+                ok = true
+                id = nil
+
+                queryMap.each do |key, value|
+
+                    #puts "...'#{key}' => '#{h.attributes[key]}' ?= '#{value}'"
+                    ok = (ok and h.attributes[key] == value)
+                        #
+                        # the parenthesis are very important
+
+                    #puts "  .ok is #{ok}"
+                    #puts "  .id is #{h.flowExpressionId}"
+                    break if not ok
+                end
+
+                #puts "  .id is #{h.flowExpressionId}"
+
+                return getAndLockWorkitem(storeName, h.flowExpressionId) if ok
+            end
+
+            return nil
+        end
+
+        #
+        # Notifies the worklist that the given workitem has to be unlocked
+        # any local (client-side) modification to it are ignored.
+        #
+        def releaseWorkitem (workitem)
+
+            return postItem('releaseWorkitem', workitem)
+        end
+
+        #
+        # Saves back the workitem in the worklist (and releases it)
+        #
+        def saveWorkitem (workitem)
+
+            return postItem('saveWorkitem', workitem)
+        end
+
+        #
+        # Returns the workitem to the worklist so that it can resume 
+        # its flow (changes to the workitem are saved).
+        #
+        def proceedWorkitem (workitem)
+
+            return postItem('forwardWorkitem', workitem)
+        end
+
+        #
+        # A synonymous for proceedWorkitem (TODO : use ruby's alias trick)
+        #
+        def forwardWorkitem (workitem)
+
+            return proceedWorkitem(workitem)
+        end
+
+        #
+        # Returns the list of flow URLs the user owning this session may
+        # launch.
+        #
+        def listLaunchables ()
+
+            params = {}
+
+            #return decode(post('listLaunchables', nil, params, nil))
+            return decode(get('listLaunchables', nil, params))
+        end
+
+        #
+        # Delegate the workitem (transfer it to another store).
+        #
+        def delegate (workitem, targetStoreName)
+
+            ewi = OpenWFE.encode(workitem)
+
+            params = {}
+            params[TARGETSTORE] = targetStoreName
+
+            return decode(post('delegate', workitem.store, params, ewi))
+        end
+
+        #
+        # Delegate the workitem (ask the worklist to deliver it to 
+        # another participant).
+        #
+        def delegateToParticipant (workitem, targetParticipantName)
+
+            ewi = OpenWFE.encode(workitem)
+
+            params = {}
+            params[TARGETPARTICIPANT] = targetParticipantName
+
+            return decode(post('delegate', workitem.store, params, ewi))
+        end
+
+        #def queryStore (storeName, query)
+        #end
+
+
+        protected
+
+            def decode (reply)
+
+                xml = REXML::Document.new(reply.body)
+                return OpenWFE.decode(xml.root)
+            end
+
+            def getItem (restMethodName, storeName, flowExpressionId)
+
+                fei = OpenWFE.encode(flowExpressionId)
+                fei = OpenWFE.docToString(fei, false)
+
+                params = {}
+
+                wi = decode(self.post(restMethodName, storeName, params, fei))
+
+                wi.store = storeName if wi
+
+                return wi
+            end
+
+            def postItem (restMethodName, workitem)
+
+                ewi = OpenWFE.encode(workitem)
+
+                params = {}
+
+                return decode(post(restMethodName, workitem.store, params, ewi))
+            end
+
+    end
+
+end
+

data/test/dollartest.rb

@@ -0,0 +1,79 @@
+
+#
+# Testing OpenWFEru
+#
+# John Mettraux at openwfe.org
+#
+# Mon Oct  9 22:19:44 JST 2006
+#
+
+require 'test/unit'
+require 'ru/dollar'
+
+#
+# testing the 'dollar notation'
+#
+
+class DollarTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_one
+        dict = {}
+        dict['renard'] = 'goupil'
+        dict['cane'] = 'oie'
+        dict['oie blanche'] = 'poule'
+
+        dotest("le petit renard", dict, "le petit renard")
+        dotest("le petit {renard}", dict, "le petit {renard}")
+        dotest("le petit ${renard}", dict, "le petit goupil")
+        dotest("le petit ${renard} noir", dict, "le petit goupil noir")
+
+        dotest("la grande ${${cane} blanche}", dict, "la grande poule")
+
+        dotest("le ${renard} et la ${cane}", dict, "le goupil et la oie")
+            #
+            # excuse my french...
+
+        dotest("le \\${renard} encore", dict, "le \\${renard} encore")
+
+        dotest("", dict, "")
+
+        dotest("""
+""", dict, """
+""")
+        dotest(""" 
+""", dict, """ 
+""")
+    end
+
+    def test_two
+        dict = {}
+        dict['x'] = 'y'
+        dotest("${x}", dict, "y")
+        dotest("\\${x}", dict, "\\${x}")
+    end
+
+    def test_three
+        dict = {}
+        dict['A'] = 'a'
+        dict['B'] = 'b'
+        dict['ab'] = 'ok'
+        dotest("${${A}${B}}", dict, "ok")
+    end
+
+    def dotest (text, dict, target)
+        result = OpenWFEru::dsub(text, dict)
+        #puts "..>#{text}<"
+        #puts "...->"
+        #puts "..>#{result}<"
+        #puts
+        assert \
+            result == target,
+            ">#{result}< != >#{target}<"
+    end
+end

data/test/feitest.rb

@@ -0,0 +1,130 @@
+
+#
+# Testing OpenWFEru
+#
+# John Mettraux at openwfe.org
+#
+# Mon Oct  9 22:19:44 JST 2006
+#
+
+require 'test/unit'
+require 'workitem'
+require 'ru/rudefinitions'
+
+
+class FeiTest < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+
+    def test_equality
+
+        fei1 = new_fei()
+        fei2 = new_fei()
+
+        assert \
+            fei1.object_id != fei2.object_id, \
+            "feis are not two distinct feis"
+        assert \
+            fei1.hash == fei2.hash, \
+            "feis do not have the same hash"
+        assert \
+            fei1 == fei2, \
+            "feis are not equals (==)"
+        assert \
+            fei1.eql?(fei2), \
+            "feis are not equals (eql?)"
+    end
+
+    def test_inequality
+
+        fei1 = new_fei()
+
+        fei2 = new_fei()
+        fei2.expressionName = OpenWFEru::EN_ENVIRONMENT
+
+        assert \
+            fei1.object_id != fei2.object_id, \
+            "feis are not two distinct feis"
+        assert \
+            fei1.hash != fei2.hash, \
+            "feis do have the same hash"
+        assert \
+            fei1 != fei2, \
+            "feis are equals (==)"
+        assert \
+            (not fei1.eql?(fei2)), \
+            "feis are equals (eql?)"
+    end
+
+    def test_in_hash
+        h = Hash.new()
+
+        fei1 = new_fei()
+        fei2 = new_fei()
+
+        h[fei1] = 'one'
+        h[fei2] = 'two'
+
+        #puts_hash(h)
+        #puts "fei1 :   #{fei1.to_debug_s}"
+        #puts "fei2 :   #{fei2.to_debug_s}"
+
+        assert \
+            h.size() == 1,
+            "h should have one entry"
+        assert \
+            h[fei1] == h[fei2],
+            "both keys should point to the same thing"
+        assert \
+            h[fei1] == 'two',
+            "value should be 'two' (fei1)"
+        assert \
+            h[fei2] == 'two',
+            "value should be 'two' (fei2)"
+    end
+
+    def test_dup
+        fei0 = new_fei()
+        fei1 = fei0.dup()
+
+        assert \
+            fei0 == fei1,
+            "feis should be equal"
+
+        fei1.expressionName = OpenWFEru::EN_ENVIRONMENT
+
+        assert \
+            fei0 != fei1, 
+            "feis should not be equal"
+    end
+
+    protected
+
+        def new_fei ()
+            fei = OpenWFE::FlowExpressionId.new()
+            fei.owfeVersion = OpenWFEru::OPENWFE_VERSION
+            fei.engineId = 'this'
+            fei.initialEngineId = 'that'
+            fei.workflowDefinitionUrl = 'http://test/test.xml'
+            fei.workflowDefinitionName = 'test'
+            fei.workflowDefinitionRevision = '1.0'
+            fei.workflowInstanceId = '123456'
+            fei.expressionName = 'do-test'
+            fei.expressionId = '0.0'
+            return fei
+        end
+
+        def puts_hash (h)
+            puts
+            h.each do |k, v|
+                puts "   * '#{k.to_debug_s}' --> '#{v}'"
+            end
+            puts
+        end
+
+end
+

data/test/flowtestbase.rb

@@ -0,0 +1,86 @@
+
+#
+# Testing OpenWFEru
+#
+# John Mettraux at openwfe.org
+#
+# Sun Oct 29 15:41:44 JST 2006
+#
+# somewhere between Philippina and the Japan
+#
+
+require 'test/unit'
+require 'workitem'
+require 'ru/engine'
+require 'ru/rudefinitions'
+require 'ru/participants'
+require 'rutest_utils'
+
+
+class FlowTestBase < Test::Unit::TestCase
+
+    #def setup
+    #end
+
+    #def teardown
+    #end
+    
+    def default_test ()
+        assert true
+    end
+
+    protected
+
+        def dotest (flowDef, expectedTrace, sleepTime=0)
+
+            engine = OpenWFEru::Engine.new()
+
+            engine.application_context["__tracer"] = Tracer.new
+
+            engine.register_participant('test-.*', OpenWFEru::PrintParticipant.new())
+
+            # register unique tracing participant
+
+            li = OpenWFE::LaunchItem.new()
+
+            li.workflowDefinitionUrl = "field:__definition"
+
+            li.attributes['__definition'] = flowDef
+            engine.launch(li)
+
+            sleep(sleepTime)
+
+            trace = engine.application_context["__tracer"].to_s
+
+            #puts "...'#{trace}' ?= '#{expectedTrace}'"
+
+            if expectedTrace.kind_of?([].class)
+                result = true
+                expectedTrace.each do |etrace|
+                    result = result and trace == etrace
+                end
+                assert \
+                    result,
+                    "flow failed : trace doesn't correspond to any expected traces"
+            else
+                assert \
+                    trace == expectedTrace, \
+                    "flow failed : '#{trace}' != '#{expectedTrace}'"
+            end
+
+            exp_storage = \
+                engine.application_context[OpenWFEru::S_EXPRESSION_STORAGE]
+
+            if exp_storage.length != 1
+                puts
+                puts exp_storage.to_s
+                puts
+            end
+
+            assert \
+                exp_storage.length == 1,
+                "there are expressions remaining in the expression pool"
+        end
+
+end
+