openwferu 0.9.10.653 → 0.9.11

data/lib/openwfe/rest/xmlcodec.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2005-2007, John Mettraux, org
+# Copyright (c) 2005-2007, John Mettraux, OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -51,13 +51,13 @@ module OpenWFE
     #
     # Ugly XML codec for OpenWFE workitems
     #
-    class XmlCodec
+    module XmlCodec
 
         #
         # Takes as input some XML element and returns is decoded 
         # (as an instance)
         #
-        def decode (xmlElt)
+        def XmlCodec.decode (xmlElt)
 
             return nil unless xmlElt
 
@@ -73,6 +73,7 @@ module OpenWFE
 
             #puts "decode() xmlElt.name is >#{xmlElt.name}<"
 
+            return decode_session_id(xmlElt) if xmlElt.name == 'session'
             return decode_list(xmlElt) if xmlElt.name == STORES
             return decode_store(xmlElt) if xmlElt.name == STORE
             return decode_list(xmlElt) if xmlElt.name == HEADERS
@@ -83,10 +84,8 @@ module OpenWFE
             return decode_list(xmlElt) if xmlElt.name == HISTORY
             return decode_historyitem(xmlElt) if xmlElt.name == HISTORY_ITEM
 
-            return decode_list(xmlElt) \
-                if xmlElt.name == FLOW_EXPRESSION_IDS
-            return decode_fei(xmlElt) \
-                if xmlElt.name == FLOW_EXPRESSION_ID
+            return decode_list(xmlElt) if xmlElt.name == FLOW_EXPRESSION_IDS
+            return decode_fei(xmlElt) if xmlElt.name == FLOW_EXPRESSION_ID
 
             return decode_inflowworkitem(xmlElt) \
                 if xmlElt.name == IN_FLOW_WORKITEM
@@ -114,7 +113,7 @@ module OpenWFE
         #
         # Takes some OpenWFE Ruby instance and returns it as XML
         #
-        def encode (owfeData)
+        def XmlCodec.encode (owfeData)
 
             #puts "encode() #{owfeData.inspect}"
 
@@ -132,18 +131,35 @@ module OpenWFE
                 "Cannot encode : "+owfeData.inspect()
         end
 
+        def XmlCodec.encode_workitem_as_header (in_flow_workitem, locked)
+
+            e = REXML::Element.new HEADER
+
+            e.add_attribute A_LAST_MODIFIED, "#{in_flow_workitem.last_modified}"
+            e.add_attribute A_LOCKED, locked
+
+            e << XmlCodec::encode_fei(in_flow_workitem.fei)
+            e << XmlCodec::encode_attributes(in_flow_workitem)
+
+            e
+        end
+
         private
 
             #
             # DECODE
             #
 
-            def decode_list (xmlElt)
+            def XmlCodec.decode_session_id (xmlElt)
+                Integer(xmlElt.attributes['id'])
+            end
+
+            def XmlCodec.decode_list (xmlElt)
                 xmlElt.elements.collect { |elt| decode(elt) }
             end
 
 
-            def decode_launchable (xmlElt)
+            def XmlCodec.decode_launchable (xmlElt)
 
                 launchable = Launchable.new()
 
@@ -154,7 +170,7 @@ module OpenWFE
             end
 
 
-            def decode_expression (xmlElt)
+            def XmlCodec.decode_expression (xmlElt)
 
                 exp = Expression.new()
                 
@@ -165,11 +181,11 @@ module OpenWFE
                 exp.state = xmlElt.attributes[STATE]
                 exp.state_since = xmlElt.attributes[STATE_SINCE]
 
-                return exp
+                exp
             end
 
 
-            def decode_store (xmlElt)
+            def XmlCodec.decode_store (xmlElt)
 
                 store = Store.new()
 
@@ -178,11 +194,11 @@ module OpenWFE
                 store.workitem_count = Integer(store.workitem_count)
                 store.permissions = xmlElt.attributes[PERMISSIONS]
 
-                return store
+                store
             end
 
 
-            def decode_header (xmlElt)
+            def XmlCodec.decode_header (xmlElt)
 
                 header = Header.new()
 
@@ -191,11 +207,11 @@ module OpenWFE
                 header.flow_expression_id = decode(OpenWFE.first_element(xmlElt, FLOW_EXPRESSION_ID))
                 header.attributes = decode(OpenWFE.first_element(xmlElt, ATTRIBUTES))
 
-                return header
+                header
             end
 
 
-            def decode_fei (xmlElt)
+            def XmlCodec.decode_fei (xmlElt)
 
                 fei = FlowExpressionId.new
 
@@ -219,7 +235,7 @@ module OpenWFE
             end
 
 
-            def decode_attribute (xmlElt)
+            def XmlCodec.decode_attribute (xmlElt)
 
                 #puts "decodeAttribute() '#{xmlElt.name}' --> '#{xmlElt.text}'"
 
@@ -273,13 +289,13 @@ module OpenWFE
                     OpenWFE.xmldoc_to_string(xmlElt.document())
             end
 
-            def decode_xmldocument (xmlElt)
+            def XmlCodec.decode_xmldocument (xmlElt)
 
                 s = Base64::decode64 xmlElt.text.strip
                 REXML::Document.new s
             end
 
-            def decode_entry (xmlElt, map)
+            def XmlCodec.decode_entry (xmlElt, map)
 
                 key = xmlElt.elements[1]
                 val = xmlElt.elements[2]
@@ -301,12 +317,12 @@ module OpenWFE
                 map[key] = val
             end
 
-            def parse_boolean (string)
+            def XmlCodec.parse_boolean (string)
 
-                return string.strip.downcase == 'true'
+                string.strip.downcase == 'true'
             end
 
-            def decode_historyitem (xmlElt)
+            def XmlCodec.decode_historyitem (xmlElt)
 
                 hi = HistoryItem.new
 
@@ -320,21 +336,21 @@ module OpenWFE
                 hi.wf_instance_id = xmlElt.attributes[WORKFLOW_INSTANCE_ID]
                 hi.expression_id = xmlElt.attributes[EXPRESSION_ID]
 
-                return hi
+                hi
             end
 
 
-            def decode_launch_ok (xmlElt)
+            def XmlCodec.decode_launch_ok (xmlElt)
 
                 sFei = xmlElt.attributes[A_FLOW_ID]
 
-                return true if not sFei
+                return true unless sFei
 
                 FlowExpressionId.to_fei(sFei)
             end
 
 
-            def decode_inflowworkitem (xmlElt)
+            def XmlCodec.decode_inflowworkitem (xmlElt)
 
                 wi = InFlowWorkItem.new()
 
@@ -350,13 +366,12 @@ module OpenWFE
 
                 wi.history = decode(OpenWFE.first_element(xmlElt, HISTORY))
 
-                return wi
+                wi
             end
 
+            def XmlCodec.decode_launchitem (xmlElt)
 
-            def decode_launchitem (xmlElt)
-
-                li = LaunchItem.new()
+                li = LaunchItem.new
 
                 li.workflow_definition_url = 
                     xmlElt.attributes[WORKFLOW_DEFINITION_URL]
@@ -373,19 +388,24 @@ module OpenWFE
             #
 
 
-            def encode_item (item, elt)
+            def XmlCodec.encode_item (item, elt)
 
                 elt.attributes[A_LAST_MODIFIED] = item.last_modified
 
+                elt << encode_attributes(item)
+            end
+
+            def XmlCodec.encode_attributes (item)
+
                 eAttributes = REXML::Element.new(ATTRIBUTES)
 
                 eAttributes << encode_attribute(item.attributes)
 
-                elt << eAttributes
+                eAttributes
             end
 
 
-            def encode_launchitem (launchitem)
+            def XmlCodec.encode_launchitem (launchitem)
 
                 doc = REXML::Document.new()
 
@@ -408,7 +428,7 @@ module OpenWFE
             end
 
 
-            def encode_inflowitem (item, elt)
+            def XmlCodec.encode_inflowitem (item, elt)
 
                 encode_item(item, elt)
 
@@ -422,7 +442,7 @@ module OpenWFE
             end
 
 
-            def encode_inflowworkitem (item)
+            def XmlCodec.encode_inflowworkitem (item)
 
                 doc = REXML::Document.new()
 
@@ -440,11 +460,11 @@ module OpenWFE
 
                 s = OpenWFE.xmldoc_to_string(doc)
                 #puts "encoded :\n#{s}"
-                return s
+                s
             end
 
 
-            def encode_history (item, elt)
+            def XmlCodec.encode_history (item, elt)
 
                 eHistory = REXML::Element.new(HISTORY)
 
@@ -468,7 +488,7 @@ module OpenWFE
             end
 
 
-            def encode_attribute (att)
+            def XmlCodec.encode_attribute (att)
 
                 #puts "encodeAttribute() att.class is #{att.class}"
 
@@ -505,14 +525,14 @@ module OpenWFE
                 #    "Cannot encode attribute of class '#{att.class}'"
             end
 
-            def encode_xmldocument (elt)
+            def XmlCodec.encode_xmldocument (elt)
 
                 e = REXML::Element.new(E_XML_DOCUMENT)
                 e.text = Base64::encode64(elt.to_s)
                 e
             end
 
-            def encode_xmlattribute (elt)
+            def XmlCodec.encode_xmlattribute (elt)
 
                 return elt if elt.name == E_RAW_XML
 
@@ -526,7 +546,7 @@ module OpenWFE
             end
 
 
-            def encode_base64attribute (att)
+            def XmlCodec.encode_base64attribute (att)
 
                 e = REXML::Element.new(E_BASE64)
                 e.text = att.content
@@ -535,7 +555,7 @@ module OpenWFE
             end
 
 
-            def encode_atomicattribute (name, value)
+            def XmlCodec.encode_atomicattribute (name, value)
 
                 elt = REXML::Element.new(name)
                 #elt << REXML::Text.new(value.to_s())
@@ -545,7 +565,7 @@ module OpenWFE
             end
 
 
-            def encode_listattribute (list)
+            def XmlCodec.encode_listattribute (list)
 
                 elt = REXML::Element.new(E_LIST)
 
@@ -553,11 +573,11 @@ module OpenWFE
                     elt << encode_attribute(e)
                 end
 
-                return elt
+                elt
             end
 
 
-            def encode_mapattribute (hash)
+            def XmlCodec.encode_mapattribute (hash)
 
                 name = hash[MAP_TYPE]
                 name = 'map' if name == nil
@@ -578,11 +598,11 @@ module OpenWFE
                     elt << eEntry
                 end
 
-                return elt
+                elt
             end
 
 
-            def encode_fei (fei)
+            def XmlCodec.encode_fei (fei)
 
                 elt = REXML::Element.new(FLOW_EXPRESSION_ID)
 
@@ -598,43 +618,33 @@ module OpenWFE
                 elt.attributes[EXPRESSION_NAME] = fei.expression_name
                 elt.attributes[EXPRESSION_ID] = fei.expression_id
 
-                return elt
+                elt
             end
     end
 
-    XMLCODEC = XmlCodec.new
-        #
-        # some kind of a singleton, rather a lonelyton
-
-    #
-    # Decodes any XML blurb produced by OpenWFE[ja] into a Ruby instance.
-    #
-    def OpenWFE.xml_decode (xmlelt)
-        XMLCODEC.decode(xmlelt)
-    end
-
-    #
-    # Encodes to XML (OpenWFE dialect ;) ) workitems and launch items.
-    #
-    def OpenWFE.xml_encode (owfedata)
-        XMLCODEC.encode(owfedata)
-    end
-
     #
     # Just turns some XML to a String (if decl is set to false, no 
     # XML declaration will be printed).
     #
     def OpenWFE.xmldoc_to_string (xml, decl=true)
 
-        s = ""
+        #return xml if xml.is_a?(String)
 
-        if decl and xml[0].kind_of? REXML::XMLDecl
+        if decl and (not xml[0].is_a?(REXML::XMLDecl))
             xml << REXML::XMLDecl.new()
         end
 
+        s = ""
         xml.write(s, 0)
         return s
     end
 
+    #
+    # An alias for OpenWFE::xmldoc_to_string()
+    #
+    def OpenWFE.xml_to_s (xml, decl=true)
+        OpenWFE::xmldoc_to_string(xml, decl)
+    end
+
 end
 

data/lib/openwfe/rudefinitions.rb

@@ -90,25 +90,33 @@ module OpenWFE
     module OwfeServiceLocator
 
         def get_engine
-            return @application_context[S_ENGINE]
+            @application_context[S_ENGINE]
         end
         def get_scheduler
-            return @application_context[S_SCHEDULER]
+            @application_context[S_SCHEDULER]
         end
         def get_expression_map
-            return @application_context[S_EXPRESSION_MAP]
+            @application_context[S_EXPRESSION_MAP]
         end
         def get_wfid_generator
-            return @application_context[S_WFID_GENERATOR]
+            @application_context[S_WFID_GENERATOR]
         end
         def get_expression_pool
-            return @application_context[S_EXPRESSION_POOL]
+            @application_context[S_EXPRESSION_POOL]
         end
         def get_expression_storage
-            return @application_context[S_EXPRESSION_STORAGE]
+            @application_context[S_EXPRESSION_STORAGE]
         end
         def get_participant_map
-            return @application_context[S_PARTICIPANT_MAP]
+            @application_context[S_PARTICIPANT_MAP]
+        end
+
+        #
+        # Returns the 'journal' service (or nil if there is no
+        # journal service available).
+        #
+        def get_journal
+            @application_context['journal']
         end
         
         #

data/lib/openwfe/storage/yamlextras.rb

@@ -60,11 +60,11 @@ module OpenWFE
 
             l.delete("@application_context")
 
-            l.delete("@timeout_job_id")
+            #l.delete("@timeout_job_id")
             #l.delete("@scheduler_job_id")
                 # scheduler ids should not get persisted
 
-            return l
+            l
         end
     end
 
@@ -108,7 +108,7 @@ module OpenWFE
         def to_yaml_properties
             l = super()
             l.delete("@raw_representation")
-            return l
+            l
         end
     end
 end    

data/lib/openwfe/util/observable.rb

@@ -53,29 +53,86 @@ module OpenWFE
         # Observers will register themselves to the Observable via
         # this method.
         #
-        def add_observer (channel, &callback)
-            (@observers[channel] ||= []) << callback
+        # An observer is an instance which responds to call(channel, *args)
+        #
+        def add_observer (channel, observer=nil, &callback)
+            observer = callback unless observer
+            (@observers[channel] ||= []) << observer
+        end
+
+        #
+        # Removes an observer (this obviously doesn't work well when 
+        # the actual observer is a block).
+        # If a channel is given, the observer will only get removed when
+        # registered for that channel.
+        #
+        def remove_observer (observer, channel=nil)
+
+            channels = if channel
+                [ channel ]
+            else
+                @observers.keys
+            end
+
+            channels.each do |c|
+                do_remove_observer observer, c
+            end
         end
 
         protected
 
             #
             # Observable classes do call this method to notify their
-            # observers
+            # observers.
+            #
+            # Returns true if there was an observer registered.
             #
             def onotify (channel, *args)
-                do_notify(channel, channel, *args)
+
                 do_notify(:all, channel, *args)
+                do_notify(channel, channel, *args)
             end
 
         private
 
+            def do_remove_observer (observer, channel)
+
+                observers = @observers[channel]
+                observers.delete(observer) if observers
+            end
+
             def do_notify (target_channel, channel, *args)
-                if @observers[target_channel]
-                    @observers[target_channel].each do |obs|
-                        obs.call channel, *args
+
+                if target_channel.is_a?(String)
+
+                    observers = []
+
+                    @observers.each do |c, o|
+
+                        if c.is_a?(String)
+                            next unless target_channel.match(c)
+                        elsif c.is_a?(Regexp)
+                            next unless c.match(target_channel)
+                        else
+                            next
+                        end
+
+                        observers = observers + o
                     end
+                else
+
+                    observers = @observers[target_channel]
+                end
+
+                return false unless observers
+
+                observers.each do |obs|
+                    obs.call channel, *args
                 end
+
+                observers.size > 0
+                    #
+                    # returns true if at least one observer was called
             end
     end
 end