ruote 0.9.20 → 2.1.1

data/lib/ruote/exp/ro_variables.rb

@@ -0,0 +1,192 @@
+#--
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote::Exp
+
+  #
+  # 're-opening' the FlowExpression class to add the methods about variables.
+  #
+  class FlowExpression
+
+    # A shortcut to the variables held in the expression (nil if none held).
+    #
+    def variables
+
+      @h['variables']
+    end
+
+    # Returns a fresh hash of all the variables visible from this expression.
+    #
+    # This is used mainly when forgetting an expression.
+    #
+    def compile_variables
+
+      vars = h.parent_id ? parent.compile_variables : {}
+      vars.merge!(h.variables) if h.variables
+
+      vars
+    end
+
+    # Looks up the value of a variable in expression tree
+    # (seen from a leave, it looks more like a stack than a tree)
+    #
+    def lookup_variable (var, prefix=nil)
+
+      var, prefix = split_prefix(var, prefix)
+
+      return @context.storage.get_engine_variable(var) \
+        if prefix.length >= 2
+
+      return parent.lookup_variable(var, prefix) \
+        if h.parent_id && prefix.length >= 1
+
+      if h.variables
+
+        val = h.variables[var]
+        return val if val != nil
+      end
+
+      if h.parent_id
+
+        return parent.lookup_variable(var, prefix)
+      end
+
+      @context.storage.get_engine_variable(var)
+    end
+
+    # A shortcut for #lookup_variable
+    #
+    alias :v :lookup_variable
+
+    # A shortcut for #lookup_variable
+    #
+    alias :lv :lookup_variable
+
+    # Sets a variable to a given value.
+    # (will set at the appropriate level).
+    #
+    def set_variable (var, val)
+
+      fexp, v = locate_var(var)
+
+      raise(
+        ArgumentError.new("cannot set var at engine level : #{var}")
+      ) if fexp.nil?
+
+      fexp.un_set_variable(:set, v, val, true)
+    end
+
+    # Unbinds a variables.
+    #
+    def unset_variable (var)
+
+      fexp, v = locate_var(var)
+
+      raise(
+        ArgumentError.new("cannot set var at engine level : #{var}")
+      ) if fexp.nil?
+
+      should_persist = (fexp.h.fei != h.fei)
+        # don't use a ticket when expression wants to modify its own vars
+
+      fexp.un_set_variable(:unset, v, nil, should_persist)
+    end
+
+    # This method is mostly used by the expression pool when looking up
+    # a process name or participant name bound under a variable.
+    #
+    def iterative_var_lookup (k)
+
+      v = lookup_variable(k)
+
+      return [ k, v ] unless (v.is_a?(String) or v.is_a?(Symbol))
+
+      iterative_var_lookup(v)
+    end
+
+    protected
+
+    # Sets (or unsets) the value of a local variable
+    #
+    # val should be nil in case of 'unset'.
+    #
+    def un_set_variable (op, var, val, should_persist)
+
+      if op == :set
+        h.variables[var] = val
+      else # op == :unset
+        h.variables.delete(var)
+      end
+
+      return unless should_persist
+
+      if r = try_persist # persist failed, have to retry
+
+        @h = r
+        un_set_variable(op, var, val, true)
+
+      else # success
+
+        @context.storage.put_msg("variable_#{op}", 'var' => var, 'fei' => h.fei)
+      end
+    end
+
+    VAR_PREFIX_REGEX = /^(\/*)/
+
+    # Used by lookup_variable and set_variable to extract the
+    # prefix in a variable name
+    #
+    def split_prefix (var, prefix)
+
+      if prefix.nil?
+        var = var.to_s
+        m = VAR_PREFIX_REGEX.match(var)
+        prefix = m ? m[1][0, 2] : ''
+        var = var[prefix.length..-1]
+      end
+
+      [ var, prefix ]
+    end
+
+    # Returns the flow expression that owns a variable (or the one
+    # that should own it) and the var without its potential / prefixes.
+    #
+    def locate_var (var, prefix=nil)
+
+      var, prefix = split_prefix(var, prefix)
+
+      return nil if prefix.length >= 2 # engine variable
+      return parent.locate_var(var, prefix) if prefix.length == 1 && h.parent_id
+
+      # no prefix...
+
+      return [ self, var ] if h.variables
+      return parent.locate_var(var, prefix) if h.parent_id
+
+      raise "uprooted var lookup, something went wrong"
+    end
+  end
+end
+

data/lib/ruote/fei.rb

@@ -0,0 +1,131 @@
+#--
+# Copyright (c) 2009, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+require 'ruote/util/misc'
+require 'ruote/util/hashdot'
+
+
+module Ruote
+
+  # A shortcut for
+  #
+  #   Ruote::FlowExpressionId.to_storage_id(fei)
+  #
+  def self.to_storage_id (fei)
+
+    Ruote::FlowExpressionId.to_storage_id(fei)
+  end
+
+  #
+  # TODO : document me
+  #
+  class FlowExpressionId
+
+    CHILD_SEP = '_'
+
+    attr_reader :h
+
+    def initialize (h)
+
+      @h = h
+      class << h; include Ruote::HashDot; end
+    end
+
+    def expid
+      @h['expid']
+    end
+
+    def wfid
+      @h['wfid']
+    end
+
+    def sub_wfid
+      @h['sub_wfid']
+    end
+
+    def to_storage_id
+
+      "#{@h['expid']}!#{@h['sub_wfid']}!#{@h['wfid']}"
+    end
+
+    def self.to_storage_id (hfei)
+
+      "#{hfei['expid']}!#{hfei['sub_wfid']}!#{hfei['wfid']}"
+    end
+
+    # Returns the last number in the expid. For instance, if the expid is
+    # '0_5_7', the child_id will be '7'.
+    #
+    def child_id
+
+      h.expid.split(CHILD_SEP).last.to_i
+    end
+
+    def hash
+
+      to_storage_id.hash
+    end
+
+    def == (other)
+
+      return false unless other.is_a?(Ruote::FlowExpressionId)
+
+      (hash == other.hash)
+    end
+
+    alias eql? ==
+
+    # Returns true if the h is a representation of a FlowExpressionId instance.
+    #
+    def self.is_a_fei? (h)
+
+      h.respond_to?(:keys) &&
+      (h.keys - [ 'sub_wfid' ]).sort == %w[ engine_id expid wfid ]
+    end
+
+    # Returns child_id... For an expid of '0_1_4', this will be 4.
+    #
+    def self.child_id (h)
+
+      h['expid'].split(CHILD_SEP).last.to_i
+    end
+
+    def to_h
+      @h
+    end
+
+    def self.direct_child? (parent_fei, other_fei)
+
+      %w[ sub_wfid wfid engine_id ].each do |k|
+        return false if parent_fei[k] != other_fei[k]
+      end
+
+      pei = other_fei['expid'].split(CHILD_SEP)[0..-2].join('_')
+
+      (pei == parent_fei['expid'])
+    end
+  end
+end
+

data/lib/{openwfe/version.rb → ruote/id/mnemo_wfid_generator.rb}

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2009, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -22,8 +22,22 @@
 # Made in Japan.
 #++
 
-module OpenWFE
+require 'rufus/mnemo' # gem install rufus-mnemo
+require 'ruote/id/wfid_generator'
 
-  OPENWFERU_VERSION = '0.9.20'
+
+module Ruote
+
+  class MnemoWfidGenerator < WfidGenerator
+
+    def generate
+
+      raw = get_raw
+
+      m = ((raw.to_f % 60 * 60 * 24) * 1000).to_i
+
+      "#{raw.strftime('%Y%m%d')}-#{Rufus::Mnemo.from_integer(m)}"
+    end
+  end
 end
 

data/lib/{openwfe/extras/engine/dm_engine.rb → ruote/id/wfid_generator.rb}

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2009, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -23,36 +23,48 @@
 #++
 
 
-require 'openwfe/engine/engine'
-require 'openwfe/extras/expool/dm_expstorage'
-#require 'openwfe/extras/expool/db_errorjournal'
-require 'openwfe/expool/yaml_errorjournal'
+module Ruote
 
+  class WfidGenerator
 
-module OpenWFE::Extras
+    def initialize (context)
 
-  #
-  # A DataMapper persisted engine.
-  #
-  class DmPersistedEngine < OpenWFE::Engine
+      @context = context
 
-    protected
+      @last =
+        @context.storage.get('variables', 'last_wfid') ||
+        { 'type' => 'variables', '_id' => 'last_wfid', 'raw' => Time.now.utc.to_f }
+    end
 
-    #
-    # Overrides the method already found in Engine with a persisted
-    # expression storage
-    #
-    def build_expression_storage
+    def generate
 
-      init_storage(DmExpressionStorage)
+      raw = get_raw
+
+      "#{raw.strftime('%Y%m%d%H%M%S')}-#{raw.usec}"
     end
 
-    #
-    # Uses a file persisted error journal.
-    #
-    def build_error_journal
+    protected
+
+    def get_raw
+
+      raw = Time.now.utc
+
+      @last['raw'] = raw.to_f
+
+      last = @context.storage.put(@last)
 
-      init_service(:s_error_journal, OpenWFE::YamlErrorJournal)
+      if last
+        #
+        # put failed, have to re-ask
+        #
+        @last = last
+        get_raw
+      else
+        #
+        # put successful, we can build a new wfid
+        #
+        raw
+      end
     end
   end
 end

data/lib/ruote/log/fs_history.rb

@@ -0,0 +1,181 @@
+#--
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+require 'fileutils'
+require 'rufus/json'
+
+
+module Ruote
+
+  #
+  # Logs the ruote engine history to files.
+  #
+  # REMEMBER : this FsHistory only logs 1 worker. StorageHistory is better
+  # to let all the workers output history in the shared storage.
+  #
+  class FsHistory
+
+    def initialize (context, options={})
+
+      @context = context
+      @options = options
+
+      @path =
+        @options['history_path'] ||
+        @context['history_path'] ||
+        File.join('work', 'log')
+
+      FileUtils.mkdir_p(@path)
+
+      @last = nil
+      @file = nil
+
+      if @context.respond_to?(:worker)
+        @context.worker.subscribe(:all, self)
+      end
+
+      rotate_if_necessary
+    end
+
+    # Makes sure to close the history file.
+    #
+    def shutdown
+
+      @file.close rescue nil
+    end
+
+    # Returns an array of Ruote::Record instances, each record represents
+    # a ruote engine [history] event.
+    # Returns an empty array if no history was found for the given wfid.
+    #
+    def by_process (wfid)
+
+      files = Dir[File.join(@path, '*.json')].sort.reverse
+
+      history = []
+
+      files.each do |f|
+
+        lines = File.readlines(f).reverse
+
+        lines.each do |l|
+
+          a = Rufus::Json.decode(l) rescue nil
+
+          next unless a
+
+          at, msg = a
+
+          m_wfid = msg['wfid'] || (msg['fei']['wfid'] rescue nil)
+
+          next if m_wfid != wfid
+
+          history.unshift(a)
+
+          return history if msg['action'] == 'launch'
+        end
+      end
+
+      history # shouldn't occur, unless history [file] got lost
+    end
+
+    RANGE_REGEXP = /_([0-9]{4}-[0-9]{2}-[0-9]{2}).json$/
+
+    # Returns an array [ most recent date, oldest date ] (Time instances).
+    #
+    def range
+
+      files = Dir[File.join(@path, '*.json')].sort
+
+      [ files.last, files.first ].inject([]) do |a, fn|
+        if m = RANGE_REGEXP.match(fn)
+          a << Time.parse(m[1])
+        end
+        a
+      end
+    end
+
+    # Returns an array of Record instances for a given date, and any process
+    # instance.
+    #
+    def by_date (date)
+
+      date = Time.parse(date.to_s).strftime('%F')
+
+      lines = File.readlines(File.join(@path, "history_#{date}.json")) rescue []
+
+      lines.inject([]) do |a, l|
+        if r = (Rufus::Json.decode(l) rescue nil)
+          a << r
+        end
+        a
+      end
+    end
+
+    #def history_to_tree (wfid)
+    #  # (NOTE why not ?)
+    #end
+
+    # The history system doesn't implement purge! so that when purge! is called
+    # on the engine, the history is not cleared.
+    #
+    # Call this *dangerous* clear! method to clean out any history file.
+    #
+    def clear!
+
+      Dir[File.join(@path, "#{engine.engine_id}_*.txt")].each do |f|
+        FileUtils.rm_f(f) rescue nil
+      end
+    end
+
+    # This is the method called by the workqueue. Incoming engine events
+    # are 'processed' here.
+    #
+    def notify (msg)
+
+      rotate_if_necessary
+
+      @file.puts(Rufus::Json.encode(
+        [ "#{@last.strftime('%F %T')}.#{"%06d" % @last.usec}", msg ]))
+      @file.flush
+    end
+
+    protected
+
+    def rotate_if_necessary
+
+      prev = @last
+      @last = Time.now.utc
+
+      return if prev && prev.day == @last.day
+
+      @file.close rescue nil
+
+      fn = [ 'history', @last.strftime('%F') ].join('_') + '.json'
+
+      @file = File.open(File.join(@path, fn), 'a')
+    end
+  end
+end
+