state_flow 0.2.0 → 0.2.1

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/lib/state_flow.rb

@@ -20,6 +20,7 @@ module StateFlow
   autoload :ActionEvent, 'state_flow/action_event'
   autoload :ExceptionHandler, 'state_flow/exception_handler'
   autoload :ExceptionHandlerClient, 'state_flow/exception_handler_client'
+  autoload :RecoverableException, 'state_flow/recoverable_exception'
 
   autoload :Log, 'state_flow/log'
   
@@ -27,6 +28,7 @@ module StateFlow
   
   def self.included(mod)
     mod.module_eval do
+      include(Base::ClientInstanceMethods)
       extend(Base::ClientClassMethods)
     end
   end

data/lib/state_flow/action.rb

@@ -19,10 +19,9 @@ module StateFlow
       exception_handling(context) do
         result = context.record_send(method_name, *method_args)
         event = event_for_action_result(result)
-        if event
-          event.process(context)
-        elsif action
-          action.process(context)
+        event.process(context) if event
+        unless event
+          action.process(context) if action
         end
         update_to_destination(context)
       end

data/lib/state_flow/base.rb

@@ -4,6 +4,13 @@ module StateFlow
 
   class Base
     
+    module ClientInstanceMethods
+      def state_flow_contexts
+        @state_flow_contexts ||= {}
+      end
+    end
+
+
     module ClientClassMethods
       def state_flow_for(selectable_attr)
         return nil unless @state_flows
@@ -20,8 +27,9 @@ module StateFlow
         @state_flows << flow
         module_eval(<<-EOS, __FILE__, __LINE__)
           def process_#{selectable_attr}(context_or_options = nil)
-            flow = self.class.state_flow_for(:#{selectable_attr})
+            flow = self.class.state_flow_for(:#{flow.attr_name})
             context = flow.prepare_context(self, context_or_options)
+            state_flow_contexts[:#{selectable_attr}] = context
             context.process(flow)
           end
         EOS
@@ -97,7 +105,9 @@ module StateFlow
 
     def process(context)
       current_key = context.current_attr_key
+      raise ArgumentError, "current_key not found for: #{context.inspect}" unless current_key
       state = concrete_states[current_key]
+      raise ArgumentError, "status not found for: #{current_key.inspect}" unless state
       state.process(context)
       context
     end

data/lib/state_flow/context.rb

@@ -13,7 +13,7 @@ module StateFlow
     end
 
     def process(flow_or_named_event = flow)
-      flow.klass.transaction do
+      transaction_with_recovering do
         flow_or_named_event.process(self)
         save_record_if_need
       end
@@ -21,8 +21,10 @@ module StateFlow
         last_current_key = current_attr_key
         while true
           @mark_proceeding = false
-          flow.process(self)
-          save_record_if_need if @mark_proceeding
+          transaction_with_recovering do
+            flow.process(self)
+            save_record_if_need if @mark_proceeding
+          end
           break unless @mark_proceeding
           break if last_current_key == current_attr_key
           last_current_key = current_attr_key
@@ -30,12 +32,39 @@ module StateFlow
       end
       self
     end
+    
+    private
+    def transaction_with_recovering(&block)
+      begin
+        flow.klass.transaction(&block)
+      rescue ::StateFlow::RecoverableException => exception
+        handler = exception.recover_handler
+        log_with_stack_trace(:info, "RECOVERING START", :backtrace => true, :exception => exception, :recover_handler => handler)
+        start_force_recovering
+        begin
+          transaction_with_recovering do
+            handler.process(self)
+            save_record_if_need
+          end
+          log_with_stack_trace(:info, "RECOVERED", :backtrace => false, :exception => exception, :recover_handler => handler)
+        rescue Exception => exception
+          exceptions << exception
+          trace(exception)
+          log_with_stack_trace(:warn, "RECOVERING FAILURE!!!!!", :backtrace => true, :exception => exception, :recover_handler => handler)
+          raise
+        end
+      end
+    end
+    
 
+    public
+    
     def mark_proceeding
       @mark_proceeding = true
     end
 
     def trace(object)
+      ActiveRecord::Base.logger.debug(object.inspect)
       stack_trace << object
     end
 
@@ -43,22 +72,100 @@ module StateFlow
       @stack_trace ||= []
     end
 
+    def stack_trace_inspects
+      stack_trace.map{|st| st.inspect}
+    end
+
+    def start_force_recovering ; @force_recovering = true ; end
+    def finish_force_recovering; @force_recovering = false; end
+    def force_recovering?; @force_recovering; end
+
+    def with_force_recovering(target = nil, *recovering_method_and_args)
+      return yield unless force_recovering?
+      begin
+        return yield
+      rescue Exception => exception
+        log_with_stack_trace(:warn, "IGNORE EXCEPTION IN RECOVERING", 
+            :exception => exception, :backtrace => true)
+        if recovering_method_and_args.empty?
+          return
+        else
+          return target.send(*recovering_method_and_args)
+        end
+      end
+    end
+
+
+    def log_with_stack_trace(level, *messages)
+      options = messages.extract_options!
+      exception = options.delete(:exception)
+      backtrace = options.delete(:backtrace)
+      result = "#{messages.shift}"
+      result << "\n  exception: #{exception.inspect}" if exception
+      messages.each do |msg|
+        result << "\n  #{msg}"
+      end
+      options.each do |key, value|
+        result << "\n  #{key.inspect}: #{value.inspect}"
+      end
+      if exception && backtrace
+        result << "\n  exception.backtrace:\n    " << exception.backtrace.join("\n    ")
+      end
+      result << "\n  context.stack_trace:\n    " << stack_trace_inspects.reverse.join("\n    ")
+      ActiveRecord::Base.logger.send(level, result)
+    end
+
+    class Manipulation
+      attr_reader :target, :method, :args, :block
+      attr_reader :trace, :result
+      attr_reader :context
+      def initialize(context, target, method, *args, &block)
+        @context = context
+        @target, @method, @args, @block = target, method, args, block
+        @trace = caller(3)
+      end
+
+      def execute
+        begin
+          return @result = @target.send(@method, *@args, &@block)
+        rescue Exception
+          raise unless @context.force_recovering?
+        end
+      end
+
+      def inspect
+        args_part = @args.inspect.gsub(/^\[|\]$/, '')
+        if !args_part.nil? && !args_part.empty?
+          args_part = "(#{args_part})"
+        end
+        "#{@target.class.name}##{@method}#{args_part}#{@block ? " with block" : nil}"
+      end
+    end
 
     def save_record_if_need
       return unless options[:save]
-      record.send(options[:save])
+      manipulation = Manipulation.new(self, record, options[:save])
+      trace(manipulation)
+      manipulation.execute
     end
 
     def record_send(*args, &block)
-      record.send(*args, &block)
+      manipulation = Manipulation.new(self, record, *args, &block)
+      trace(manipulation)
+      manipulation.execute
     end
 
     def record_reload_if_possible
-      record.reload unless record.new_record?
+      return if record.new_record?
+      manipulation = Manipulation.new(self, record, :reload)
+      trace(manipulation)
+      manipulation.execute 
     end
 
     def transaction_rollback
-      record.class.connection.rollback_db_transaction
+      manipulation = Manipulation.new(self, record.class.connection, :rollback_db_transaction)
+      trace(manipulation)
+      manipulation.execute
     end
     
     def exceptions

data/lib/state_flow/element.rb

@@ -30,6 +30,11 @@ module StateFlow
       context.record_send("#{flow.attr_key_name}=", destination)
     end
 
+    def retry_in_recovering(context)
+      update_to_destination(context)
+    end
+
+
     class << self
       def uninspected_var(*vars)
         @@uninspected_var_hash ||= {}
@@ -41,8 +46,8 @@ module StateFlow
         @uninspected_vars ||= @@uninspected_var_hash.nil? ? %w(@flow @origin) :
           self.ancestors.map{|klass| @@uninspected_var_hash[klass] || []}.flatten
       end
-   end
-   self.uninspected_var :flow, :origin, :events, :guards, :action
+    end
+    self.uninspected_var :flow, :origin, :events, :guards, :action
  
     def inspect
       vars = (instance_variables - self.class.uninspected_vars).map do |name|
@@ -52,8 +57,6 @@ module StateFlow
       vars.unshift("%s:%#x" % [self.class.name, self.object_id])
       "#<#{vars.join(' ')}>"
     end
-
-
     
   end
 

data/lib/state_flow/event_client.rb

@@ -65,23 +65,6 @@ module StateFlow
     def event_for_action_result(result)
       events.detect{|ev| ev.match?(result)}
     end
-
-    def exception_handling(context)
-      begin
-        yield
-      rescue Exception => exception
-        context.exceptions << exception
-        context.trace(exception)
-        handlers = events.select{|ev| ev.is_a?(ExceptionHandler)}
-        handlers.each do |handler|
-          next unless handler.match?(exception)
-          handler.process(context)
-          break
-        end
-        raise exception unless context.recovered?(exception)
-      end
-    end
-
   end
 
 

data/lib/state_flow/exception_handler.rb

@@ -4,7 +4,7 @@ module StateFlow
 
   class ExceptionHandler < Event
     attr_reader :exceptions
-    attr_reader :recovering, :rolling_back, :logging_error
+    attr_reader :recovering, :rolling_back, :logging_error, :raise_error_in_handling
     
     def initialize(origin, *exceptions, &block)
       options = exceptions.extract_options!
@@ -13,6 +13,8 @@ module StateFlow
       @recovering = options[:recovering] || false
       @rolling_back = options[:rolling_back] || options[:rollback] || false
       @logging_error = options[:logging]
+      # 例外をハンドリングしている最中にエラーが出た場合にraiseするかどうか。デフォルトnil
+      @raise_error_in_handling = options[:raise_error_in_handling] 
     end
     
     def match?(exception)
@@ -22,8 +24,8 @@ module StateFlow
 
     def process(context)
       context.recovered_exceptions << context.exceptions.last if recovering
-      context.transaction_rollback if rolling_back
-      context.record_reload_if_possible
+      context.record_reload_if_possible # rollbackよりもreloadが先じゃないとネストしたtransactionでおかしい場合がある？
+      # context.transaction_rollback if rolling_back
       super
     end
 

data/lib/state_flow/exception_handler_client.rb

@@ -3,19 +3,34 @@ require 'state_flow'
 module StateFlow
 
   module ExceptionHandlerClient
-    def exception_handling(context)
+    # 例外ハンドラの配列を返します。
+    # StateFlow::Stateはこれを上書きして親のハンドラも含めて返します。
+    def exception_handlers
+      events.select{|ev| ev.is_a?(ExceptionHandler)}
+    end
+
+    def exception_handling(context, &block)
+      if context.force_recovering?
+        return context.with_force_recovering(self, :retry_in_recovering, context, &block)
+      end
+
+      handlers = exception_handlers
+      return yield if handlers.empty?
+      ActiveRecord::Base.logger.debug("---- exception_handling BEGIN by #{self.inspect}")
       begin
-        yield
+        return yield
+        ActiveRecord::Base.logger.debug("---- exception_handling END by #{self.inspect}")
       rescue Exception => exception
         context.exceptions << exception
         context.trace(exception)
-        handlers = events.select{|ev| ev.is_a?(ExceptionHandler)}
-        handlers.each do |handler|
-          next unless handler.match?(exception)
-          handler.process(context)
-          break
+        if recover_handler = handlers.detect{|handler| handler.match?(exception)}
+          raise ::StateFlow::RecoverableException.new(recover_handler, exception)
+        else
+          context.log_with_stack_trace(:error, "NOT RECOVERED", 
+            :exception => exception, :backtrace => true, 
+            :exception_handlers => handlers, :recover_handler => recover_handler)
+          raise exception
         end
-        raise exception unless context.recovered?(exception)
       end
     end
 

data/lib/state_flow/named_event.rb

@@ -10,10 +10,9 @@ module StateFlow
     end
 
     def process(context)
-      block = state.ancestors_exception_handled_proc(context) do
+      state.exception_handling(context) do
         super
       end
-      block.call
     end
 
     class << self
@@ -38,6 +37,7 @@ module StateFlow
               events.each do |event|
                 if event.state.include?(self.send(flow.attr_key_name))
                   context = flow.prepare_context(self, args.first)
+                  self.state_flow_contexts[flow.attr_name] = context
                   result = context.process(event)
                   break
                 end

data/lib/state_flow/recoverable_exception.rb

@@ -0,0 +1,12 @@
+module StateFlow
+  class RecoverableException < Exception
+    attr_reader :recover_handler, :original
+    def initialize(recover_handler, original = nil)
+      @recover_handler = recover_handler
+      @original = original
+      super("#{original ? original.inspect + ' ' : nil}RECOVERABLE by " << recover_handler.inspect)
+    end
+    
+  end
+
+end

data/lib/state_flow/state.rb

@@ -59,17 +59,18 @@ module StateFlow
     public
     def process(context)
       context.trace(self)
-      block = ancestors_exception_handled_proc(context) do
+      exception_handling(context) do
         guard = guard_for(context)
         return guard.process(context) if guard
         return action.process(context) if action
       end
-      block.call
     end
     
-    def ancestors_exception_handled_proc(context, &block)
-      result = Proc.new{ exception_handling(context, &block) }
-      parent ? parent.ancestors_exception_handled_proc(context, &result) : result
+    # override ExceptionHandlerClient#exception_handlers
+    def exception_handlers
+      result = events.select{|ev| ev.is_a?(ExceptionHandler)}
+      result.concat(parent.exception_handlers) if parent
+      result
     end
 
     def name_path(separator = '>')

data/spec/order_spec.rb

@@ -81,6 +81,44 @@ describe Order do
         Order.count(:conditions => {:status_cd => Order.status_id_by_key(:internal_error)}).should == 1
         StateFlow::Log.count.should == 0
       end
+
+      it "cancel_request but raised error and another error during recovering" do
+        @order.should_receive(:send_mail_cancel_requested).and_raise(IOError)
+        @order.should_receive(:send_mail_error).and_raise(IOError)
+        context = @order.cancel_request(:keep_process => false)
+        @order.status_key.should == :internal_error
+        # saveされてます。
+        Order.count.should == 1
+        Order.count(:conditions => {:status_cd => Order.status_id_by_key(:internal_error)}).should == 1
+        StateFlow::Log.count.should == 0
+      end
+
+      it "cancel_request but raised error and another error during recovering #2" do
+        @order.should_receive(:send_mail_cancel_requested).and_raise(IOError)
+        @order.should_receive(:write_exception_to_log).and_raise(IOError)
+        context = @order.cancel_request(:keep_process => false)
+        @order.status_key.should == :internal_error
+        # saveされてます。
+        Order.count.should == 1
+        Order.count(:conditions => {:status_cd => Order.status_id_by_key(:internal_error)}).should == 1
+        StateFlow::Log.count.should == 0
+      end
+
+      it "can access runtime error message in action method" do
+        expected_msg = "実行時に取得しにくいエラー"
+        @order.should_receive(:send_mail_cancel_requested).and_raise(IOError.new(expected_msg))
+        context = @order.cancel_request(:keep_process => false)
+        
+        # context.stack_trace.should == []
+
+        @order.status_key.should == :internal_error
+        @order.instance_variable_get(:@last_error_message).should == expected_msg
+        
+        # saveされてます。
+        Order.count.should == 1
+        Order.count(:conditions => {:status_cd => Order.status_id_by_key(:internal_error)}).should == 1
+        StateFlow::Log.count.should == 0
+      end
     end
 
     describe "credit_card" do
@@ -252,11 +290,41 @@ describe Order do
         Order.count(:conditions => {:status_cd => Order.status_id_by_key(:settlement_error)}).should == 1
       end
 
-      it "settle failed by IOError" do
-        @order.should_receive(:settle).and_raise(IOError)
+      class TestRuntimeError1 < RuntimeError
+      end
+
+      it "settle failed by RuntimeError" do
+        @order.should_receive(:settle).and_raise(TestRuntimeError1)
         @order.should_receive(:release_stock)
         @order.should_receive(:delete_point)
-        @order.process_status_cd
+        context = @order.process_status_cd
+        # context.stack_trace.should == []
+        context.stack_trace[ 0].inspect.should == "Order#status_key"
+        context.stack_trace[ 1].should be_a(StateFlow::State)
+        context.stack_trace[ 1].name_path.should == "valid>auto_cancelable>online_settling"
+        context.stack_trace[ 2].inspect.should == "Order#credit_card?" 
+        context.stack_trace[ 3].should be_a(StateFlow::Action)
+        context.stack_trace[ 3].method_name.should == :settle
+        context.stack_trace[ 4].inspect.should == "Order#settle"
+        context.stack_trace[ 5].should be_a(TestRuntimeError1)
+        context.stack_trace[ 6].inspect.should == "Order#reload"
+        # context.stack_trace[ 6].inspect.should == "#{Order.connection.class.name}#rollback_db_transaction"
+        context.stack_trace[ 7].should be_a(StateFlow::ExceptionHandler)
+        context.stack_trace[ 7].exceptions.should == [Exception]
+        context.stack_trace[ 8].should be_a(StateFlow::Action)
+        context.stack_trace[ 8].method_name.should == :release_stock
+        context.stack_trace[ 9].inspect.should == "Order#release_stock"
+        context.stack_trace[10].should be_a(StateFlow::Action)
+        context.stack_trace[10].method_name.should == :delete_point
+        context.stack_trace[11].inspect.should == "Order#delete_point"
+        context.stack_trace[12].inspect.should == "Order#status_key=(:settlement_error)"
+        context.stack_trace[13].inspect.should == "Order#save!"
+        context.stack_trace[14].inspect.should == "Order#status_key"
+        context.stack_trace[15].inspect.should == "Order#status_key"
+        context.stack_trace[16].should be_a(StateFlow::State)
+        context.stack_trace[16].name_path.should == "error>settlement_error"
+        context.stack_trace.length.should == 17
+
         @order.status_key.should == :settlement_error
         Order.count.should == 1
         Order.count(:conditions => {:status_cd => Order.status_id_by_key(:settlement_error)}).should == 1

data/spec/resources/models/order.rb

@@ -27,7 +27,7 @@ class Order < ActiveRecord::Base
       # recoverの順番は重要。Exceptionを先に書くと全ての例外は:internal_errorになってしまいます。
       recover(:'Net::HTTPHeaderSyntaxError').to(:external_error)
       recover(:'Net::ProtocolError').to(:external_error)
-      recover(:'Exception').to(:internal_error)
+      recover(:'Exception').action(:write_exception_to_log).action(:send_mail_error).to(:internal_error)
 
       group(:auto_cancelable) do # 自動キャンセル可
         
@@ -126,7 +126,6 @@ class Order < ActiveRecord::Base
     
     group(:error) do # 異常系
       from(:settlement_error) do
-        action(:send_mail_settlement_error)
         # to(:settlement_error) # 遷移しない
       end
       
@@ -168,4 +167,21 @@ class Order < ActiveRecord::Base
   def send_mail_deliver_notification; end
   def send_mail_settlement_error; end
 
+  def send_mail_error; end
+  
+  # recover(:'Exception') で処理した例外を実行時に参照します。
+  def write_exception_to_log
+    logger.debug "*" * 100
+    logger.debug "write_exception_to_log"
+    
+    logger.debug state_flow_contexts.inspect
+
+    if context = state_flow_contexts[:status_cd]
+      logger.debug context.inspect
+      logger.debug context.exceptions.inspect
+      @last_error_message = context.exceptions.last.to_s
+    end
+
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: state_flow
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Takeshi Akima
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-04 00:00:00 +09:00
+date: 2009-11-05 00:00:00 +09:00
 default_executable: 
 dependencies: []
 
@@ -46,6 +46,7 @@ files:
 - lib/state_flow/log.rb
 - lib/state_flow/named_event.rb
 - lib/state_flow/named_guard.rb
+- lib/state_flow/recoverable_exception.rb
 - lib/state_flow/state.rb
 - spec/.gitignore
 - spec/database.yml