openwferu 0.9.1 → 0.9.2

data/lib/openwfe/expool/expstorage.rb

@@ -0,0 +1,184 @@
+#
+#--
+# Copyright (c) 2006-2007, Nicolas Modryzk and 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: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
+#
+
+#
+# "made in Japan"
+#
+# Nicolas Modrzyk at openwfe.org
+# John Mettraux at openwfe.org
+#
+
+require 'fileutils'
+
+require 'openwfe/service'
+require 'openwfe/util/lru_cache'
+require 'openwfe/flowexpressionid'
+
+module OpenWFE
+    
+    #
+    # Create a composite expression storage.
+    # This will take parameters from the application context to create 
+    # the resulting composite storage
+    class CompositeExpressionStorage 
+        include ServiceMixin
+        
+        attr_accessor \
+        :persistence, \
+        :cache, \
+        :journal
+        
+        def initialize (serviceName, applicationContext)
+            
+            service_init(serviceName, applicationContext)
+            
+            @cache = @application_context[:cached_expression_storage]
+            @journal = @application_context[:journalized_expression_storage]
+            @persistence = @application_context[:file_expression_storage]
+        end
+        
+        #
+        # call the add method for each registered storage
+        def []= (fei, flowExpression)
+            @journal[fei] = flowExpression if @journal
+            @cache[fei] = flowExpression if @cache
+            @persistence[fei] = flowExpression
+        end
+        
+        #
+        # remove the expressionid from each registered storage
+        def remove (fei, workitem)
+            @journal.remove(fei, workitem) if @journal
+            @cache.remove(fei, workitem) if @cache
+            @persistence.remove(fei,workitem)
+        end
+        
+        #
+        # slightly different method. Try to get the value from the cache storage if one
+        # if not retrieve it, and then add it to the cache.
+        def [] (fei)
+            return @cache[fei] if @cache
+            flow_expression = @persistence[fei]
+            @cache[fei] = flow_expression if @cache
+            return flow_expression
+        end
+    end
+        
+     #
+     # implementation of a LRU caching storage.
+    class LruCachedExpressionStorage
+        include ServiceMixin
+        
+        DEFAULT_LRU_SIZE = 10
+        
+        def initialize (service_name, application_context)
+            service_init(service_name, application_context)
+            size = if (@application_context) 
+                @application_context[:lru_storage_size] 
+            else 
+                DEFAULT_LRU_SIZE 
+            end
+            @cache = LRUCache.new(size)
+        end
+        
+        def []= (fei, flowExpression)
+            @cache[fei]=flowExpression
+        end
+        
+        #
+        # interface method to remove an entry for the given expression_id
+        def remove (fei, workitem)
+            @cache.delete(fei)
+        end
+        
+        #
+        # check if the value is in the cache
+        def is_in_cache?(fei)
+            @cache.include?(fei)
+        end
+        alias has_key? is_in_cache? 
+        
+        #
+        # interface method, return the value associated with the given id, 
+        # or nil if not in cache.
+        def [] (fei)
+            if(@cache.include?(fei))
+                return @cache[fei]
+            else
+                return nil
+            end
+        end
+        
+    end
+        
+    #
+    # Memory consuming in-memory storage.
+    # No memory limit, puts everything in a Hash
+    #
+    class InMemoryExpressionStorage < Hash
+        include ServiceMixin
+        
+        def initialize (service_name, application_context)
+            @service_name = service_name
+            @application_context = application_context
+        end
+
+        def remove (fei, workitem)
+            delete(fei)
+        end
+
+        def purge
+            self.clear
+        end
+        
+        def to_s
+            s = "\n\n==== #{self.class} ===="
+            each do |k, v|
+                s << "\n"
+                if v.kind_of?(RawExpression)
+                    s << "*raw" 
+                else
+                    s << "  "
+                end
+                s << v.to_s
+                s << "    key/value mismatch !" if k != v.fei
+            end
+            s << "\n==== . ====\n"
+            return s
+        end
+        
+    end
+
+end

data/lib/openwfe/expool/journalexpstorage.rb

@@ -0,0 +1,312 @@
+#
+#--
+# Copyright (c) 2006-2007, Nicolas Modryzk and 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: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
+#
+
+#
+# "made in Japan"
+#
+# Nicolas Modrzyk at openwfe.org
+# John Mettraux at openwfe.org
+#
+
+require 'fileutils'
+require 'base64'
+
+require 'openwfe/service'
+require 'openwfe/workitem'
+require 'openwfe/flowexpressionid'
+require 'openwfe/expressions/expressionmap'
+
+
+module OpenWFE
+
+    #
+    # by default the journals are stored into "work/journal"
+    #
+    DEFAULT_STORAGE_PATH = "work/"
+    
+    #
+    # this is the container class for storing entries in the the journal
+    #
+    class JournalEntry
+        
+        # reused for 
+        ENTRY_DELIM = ' -- ' 
+        
+        attr_reader :fei, :action, :fe, :time
+        
+        
+        def initialize (action, fei, fe, stime=nil)
+            @action = action
+            @fei = fei
+            @fe = fe
+            @time = if stime 
+                stime 
+            else 
+                Time.new 
+            end
+        end
+        
+        #
+        # parse the entry from a line read from a log file
+        def JournalEntry.parse_from_string (line)
+            # offset includes iso formatting and delim
+            time_offset = line.index(ENTRY_DELIM) 
+            
+            time = Time.iso8601(line.slice(0..time_offset))
+            
+            line = line.slice(time_offset+ ENTRY_DELIM.length..line.length)
+            action = line[0..2]
+            
+            index = line.index(ENTRY_DELIM,7)                   
+            fei = OpenWFE::FlowExpressionId.to_fei(line[8..index-1])
+            
+            if action == :put.to_s
+                fe_64_yaml = line[index+ENTRY_DELIM.length,line.length].rstrip
+                fe_yaml = Base64.decode64(fe_64_yaml.gsub("**","\n"))
+                fe = YAML.load(fe_yaml)
+                return JournalEntry.new(:put, fei, fe, time)
+            else
+                return JournalEntry.new(action, fei, nil, time)
+            end    
+        end
+        
+        #
+        # this is directly used to store the entry in the journal. 
+        # This is using base64 encoding to wrap the encoded object, and is not readable. Use to_human_s to decrypt
+        def to_s
+            if @action == :put
+                base64 = Base64.encode64(YAML.dump(@fe)).gsub("\n","**") + "\n"
+                @time.iso8601 + ENTRY_DELIM + @action.to_s + ENTRY_DELIM + @fei.to_s + ENTRY_DELIM + base64
+            else
+                @time.iso8601 + ENTRY_DELIM + @action.to_s + ENTRY_DELIM + @fei.to_s + ENTRY_DELIM + "\n"
+            end
+        end
+        
+        #
+        # same as above,except the encoded object is fully expanded. The return value cannot be processed.
+        def to_human_s
+            if @action == :put
+                @time.iso8601 + ENTRY_DELIM + @action.to_s + ENTRY_DELIM + @fei.to_s + ENTRY_DELIM + "\n" + YAML.dump(@fe).to_s + "---\n"
+            else
+                to_s
+            end
+        end
+    end
+    
+    #
+    # the class responsible for handling replay of a log file
+    class JournalReplay
+        
+        def initialize(storage=nil) 
+            if not storage
+                @storage = @application_context[S_EXPRESSION_STORAGE] 
+            else
+                @storage = storage
+            end
+        end
+        
+        # 
+        # from the content of path_to_journal, will replay all the entries one by one on the given storage
+        def replay(path_to_journal)
+            datalines = IO.readlines(path_to_journal)
+            datalines.each { 
+                |line_read| 
+                entry = (JournalEntry.parse_from_string(line_read))
+                if(entry.action == :put)
+                    @storage[entry.fei]=entry.fe
+                else
+                    #TODO: implement delete
+                    #@storage.delete(entry.fei)
+                    @storage.remove(entry.fei)
+                end     
+            }
+        end
+        
+    end
+    
+    #
+    # this is the main class for journalized storage
+    class JournalizedExpressionStorage
+        include ServiceMixin
+        
+        attr_accessor :basepath
+        
+        def initialize (serviceName, applicationContext)
+            service_init(serviceName, applicationContext)
+            path = if (@application_context) 
+                @application_context[:file_expression_storage_path] 
+            else 
+                DEFAULT_STORAGE_PATH 
+            end
+            @basepath = path + "/journal"
+            FileUtils.makedirs @basepath 
+        end
+        
+        #
+        # remove the file corresponding to the journal of this workflow instance
+        def clean (workflow_id)
+            fei_path = compute_file_path_id(workflow_id)
+            if (File.exist?(fei_path))
+                File.delete(fei_path)
+            end
+        end 
+        
+        #
+        # backup the journal file corresponding to the give workflow instance
+        # by default, deletes the original journal file.
+        def backup (workflow_id, delete_original = true, backup_path = nil)
+            path_to_journal = compute_file_path_id(workflow_id)
+            temporary_journal = if not backup_path 
+                                                        path_to_journal+".0"
+                                                    else
+                                                        backup_path
+                                                    end
+            FileUtils.copy_file(path_to_journal, temporary_journal)
+            File.delete(path_to_journal) if delete_original
+            return temporary_journal
+        end
+        
+        # 
+        # truncate the content of the log file:
+        # - number of lines
+        # - before a given date
+        def truncate! (workflow_id, number_of_lines=nil, after_date=nil)
+            return 0 if not number_of_lines and not after_date
+            
+            fei_path = compute_file_path_id(workflow_id)
+            datalines = IO.readlines(fei_path)
+            entries = Array.new
+            
+            datalines.each { |line_read| 
+                    entry = JournalEntry.parse_from_string(line_read)
+                    break if after_date and entry.time >= after_date
+                    break if number_of_lines and entries.length >= number_of_lines
+                    entries.push entry
+                }
+            
+            backup(workflow_id)
+            
+            fd = IO.sysopen(fei_path, File::WRONLY|File::CREAT, 0666) 
+            io = IO.open(fd , "w")
+            
+            entries.each{ |entry|
+                    io.write(entry.to_s)
+            }
+            io.close
+            
+            return entries.length
+        end
+        
+        # 
+        # create a human readable log file for the given workflow instance.
+        # Note that this will override any existing previously created file
+        def  to_human_s(workflow_id)
+            fei_path = compute_file_path_id(workflow_id)
+            if (File.exist?(fei_path))
+                fei_new_path = fei_path[0,fei_path.length-5] + ".txt"
+                File.delete(fei_new_path) if (File.exist?(fei_new_path)) 
+                
+                fd = IO.sysopen(fei_new_path, File::WRONLY|File::CREAT, 0666) 
+                io = IO.open(fd , "w")
+                
+                datalines = IO.readlines(fei_path)
+                datalines.each { |line_read| human = (JournalEntry.parse_from_string(line_read)).to_human_s ; io.write(human) }
+                
+                io.close
+            else
+                raise "workflow journal does not exist for given id:"+workflow_id
+            end
+        end
+        
+        # 
+        # interface method for the persistence. add a flow expression to the storage
+        def []= (fei, flow_expression)
+            write_to_journal(JournalEntry.new(:put, fei, flow_expression))
+        end
+        
+        #
+        # interface method: remove the expressionid and persist the related workitem
+        def remove (fei, workitem=nil)
+            write_to_journal(JournalEntry.new(:del, fei, nil))
+        end
+        
+        #
+        # compute the size of the journal (number of entries) in the journal for the 
+        # given workflow id
+        def size (workflow_instance_id)
+            fei_path = compute_file_path_id(workflow_instance_id)
+            return 0 if not File.exist?(fei_path)
+            
+            datalines = IO.readlines(fei_path)
+            return datalines.length
+        end
+        
+        # 
+        # alias for the protected compute_file_path with a better name.
+        # Return the path of the log for the given workflow instance
+        def where_is_journal_for (workflow_instance_id)
+            compute_file_path(workflow_instance_id)
+        end
+        
+        # 
+        # write an entry to the journal. This call the to_s method of the entry
+        # and append the resulting line to the log file
+        def write_to_journal (journal_entry)
+            fei_path = compute_file_path(journal_entry.fei)
+            fei_parent_path = File.dirname(fei_path)
+            
+            FileUtils.makedirs fei_parent_path if not (File.exist?(fei_parent_path))
+            
+            fd = IO.sysopen(fei_path, File::WRONLY|File::APPEND|File::CREAT, 0666) 
+            io = IO.open(fd , "w")
+            
+            io.write(journal_entry.to_s)
+            
+            io.close
+        end
+        
+        protected 
+        
+            def compute_file_path (fei)
+                compute_file_path_id(fei.parent_workflow_instance_id)            
+            end
+            
+            def compute_file_path_id (parent_workflow_instance_id)
+                @basepath + "/" + parent_workflow_instance_id.to_s + ".yaml"
+            end
+        
+    end
+    
+end