floe 0.11.2 → 0.12.0

data/lib/floe/workflow/state.rb

@@ -4,114 +4,101 @@ module Floe
   class Workflow
     class State
       include Logging
+      include ValidationMixin
 
       class << self
         def build!(workflow, name, payload)
           state_type = payload["Type"]
-          raise Floe::InvalidWorkflowError, "Missing \"Type\" field in state [#{name}]" if payload["Type"].nil?
+          missing_field_error!(name, "Type") if payload["Type"].nil?
+          invalid_field_error!(name[0..-2], "Name", name.last, "must be less than or equal to 80 characters") if name.last.length > 80
 
           begin
             klass = Floe::Workflow::States.const_get(state_type)
           rescue NameError
-            raise Floe::InvalidWorkflowError, "Invalid state type: [#{state_type}]"
+            invalid_field_error!(name, "Type", state_type, "is not valid")
           end
 
           klass.new(workflow, name, payload)
         end
       end
 
-      attr_reader :workflow, :comment, :name, :type, :payload
+      attr_reader :comment, :name, :type, :payload
 
-      def initialize(workflow, name, payload)
-        @workflow = workflow
+      def initialize(_workflow, name, payload)
         @name     = name
         @payload  = payload
         @type     = payload["Type"]
         @comment  = payload["Comment"]
-
-        raise Floe::InvalidWorkflowError, "Missing \"Type\" field in state [#{name}]" if payload["Type"].nil?
-        raise Floe::InvalidWorkflowError, "State name [#{name}] must be less than or equal to 80 characters" if name.length > 80
       end
 
-      def wait(timeout: nil)
+      def wait(context, timeout: nil)
         start = Time.now.utc
 
         loop do
-          return 0             if ready?
+          return 0             if ready?(context)
           return Errno::EAGAIN if timeout && (timeout.zero? || Time.now.utc - start > timeout)
 
           sleep(1)
         end
       end
 
-      def run_nonblock!
-        start(context.input) unless started?
-        return Errno::EAGAIN unless ready?
+      # @return for incomplete Errno::EAGAIN, for completed 0
+      def run_nonblock!(context)
+        start(context) unless context.state_started?
+        return Errno::EAGAIN unless ready?(context)
 
-        finish
+        finish(context)
       end
 
-      def start(_input)
-        start_time = Time.now.utc.iso8601
-
-        context.execution["StartTime"] ||= start_time
-        context.state["Guid"]            = SecureRandom.uuid
-        context.state["EnteredTime"]     = start_time
+      def start(context)
+        context.state["EnteredTime"] = Time.now.utc.iso8601
 
-        logger.info("Running state: [#{long_name}] with input [#{context.input}]...")
+        logger.info("Running state: [#{long_name}] with input [#{context.json_input}]...")
       end
 
-      def finish
+      def finish(context)
         finished_time     = Time.now.utc
-        finished_time_iso = finished_time.iso8601
         entered_time      = Time.parse(context.state["EnteredTime"])
 
-        context.state["FinishedTime"] ||= finished_time_iso
+        context.state["FinishedTime"] ||= finished_time.iso8601
         context.state["Duration"]       = finished_time - entered_time
-        context.execution["EndTime"]    = finished_time_iso if context.next_state.nil?
-
-        level = context.output&.[]("Error") ? :error : :info
-        logger.public_send(level, "Running state: [#{long_name}] with input [#{context.input}]...Complete #{context.next_state ? "- next state [#{context.next_state}]" : "workflow -"} output: [#{context.output}]")
 
-        context.state_history << context.state
+        level = context.failed? ? :error : :info
+        logger.public_send(level, "Running state: [#{long_name}] with input [#{context.json_input}]...Complete #{context.next_state ? "- next state [#{context.next_state}]" : "workflow -"} output: [#{context.json_output}]")
 
         0
       end
 
-      def context
-        workflow.context
-      end
-
-      def started?
-        context.state.key?("EnteredTime")
+      def ready?(context)
+        !context.state_started? || !running?(context)
       end
 
-      def ready?
-        !started? || !running?
+      def running?(context)
+        raise NotImplementedError, "Must be implemented in a subclass"
       end
 
-      def finished?
-        context.state.key?("FinishedTime")
-      end
-
-      def waiting?
+      def waiting?(context)
         context.state["WaitUntil"] && Time.now.utc <= Time.parse(context.state["WaitUntil"])
       end
 
-      def wait_until
+      def wait_until(context)
         context.state["WaitUntil"] && Time.parse(context.state["WaitUntil"])
       end
 
+      def short_name
+        name.last
+      end
+
       def long_name
-        "#{self.class.name.split("::").last}:#{name}"
+        "#{type}:#{short_name}"
       end
 
       private
 
-      def wait_until!(seconds: nil, time: nil)
+      def wait_until!(context, seconds: nil, time: nil)
         context.state["WaitUntil"] =
           if seconds
-            (Time.parse(context.state["EnteredTime"]) + seconds).iso8601
+            (Time.now + seconds).iso8601
           elsif time.kind_of?(String)
             time
           else

data/lib/floe/workflow/states/choice.rb

@@ -9,17 +9,18 @@ module Floe
         def initialize(workflow, name, payload)
           super
 
-          validate_state!
+          validate_state!(workflow)
 
-          @choices = payload["Choices"].map { |choice| ChoiceRule.build(choice) }
+          @choices = payload["Choices"].map.with_index { |choice, i| ChoiceRule.build(workflow, name + ["Choices", i.to_s], choice) }
           @default = payload["Default"]
 
           @input_path  = Path.new(payload.fetch("InputPath", "$"))
           @output_path = Path.new(payload.fetch("OutputPath", "$"))
         end
 
-        def finish
-          output     = output_path.value(context, context.input)
+        def finish(context)
+          input      = input_path.value(context, context.input)
+          output     = output_path.value(context, input)
           next_state = choices.detect { |choice| choice.true?(context, output) }&.next || default
 
           context.next_state = next_state
@@ -27,7 +28,7 @@ module Floe
           super
         end
 
-        def running?
+        def running?(_)
           false
         end
 
@@ -37,18 +38,18 @@ module Floe
 
         private
 
-        def validate_state!
+        def validate_state!(workflow)
           validate_state_choices!
-          validate_state_default!
+          validate_state_default!(workflow)
         end
 
         def validate_state_choices!
-          raise Floe::InvalidWorkflowError, "Choice state must have \"Choices\"" unless payload.key?("Choices")
-          raise Floe::InvalidWorkflowError, "\"Choices\" must be a non-empty array" unless payload["Choices"].kind_of?(Array) && !payload["Choices"].empty?
+          missing_field_error!("Choices") unless payload.key?("Choices")
+          invalid_field_error!("Choices", nil, "must be a non-empty array") unless payload["Choices"].kind_of?(Array) && !payload["Choices"].empty?
         end
 
-        def validate_state_default!
-          raise Floe::InvalidWorkflowError, "\"Default\" not in \"States\"" unless workflow.payload["States"].include?(payload["Default"])
+        def validate_state_default!(workflow)
+          invalid_field_error!("Default", payload["Default"], "is not found in \"States\"") if payload["Default"] && !workflow_state?(payload["Default"], workflow)
         end
       end
     end

data/lib/floe/workflow/states/fail.rb

@@ -4,7 +4,7 @@ module Floe
   class Workflow
     module States
       class Fail < Floe::Workflow::State
-        attr_reader :cause, :error
+        attr_reader :cause, :error, :cause_path, :error_path
 
         def initialize(workflow, name, payload)
           super
@@ -15,7 +15,7 @@ module Floe
           @error_path = Path.new(payload["ErrorPath"]) if payload["ErrorPath"]
         end
 
-        def finish
+        def finish(context)
           context.next_state = nil
           # TODO: support intrinsic functions here
           # see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-fail-state.html
@@ -27,7 +27,7 @@ module Floe
           super
         end
 
-        def running?
+        def running?(_)
           false
         end
 

data/lib/floe/workflow/states/input_output_mixin.rb

@@ -4,23 +4,23 @@ module Floe
   class Workflow
     module States
       module InputOutputMixin
-        def process_input(input)
-          input = input_path.value(context, input)
+        def process_input(context)
+          input = input_path.value(context, context.input)
           input = parameters.value(context, input) if parameters
           input
         end
 
-        def process_output(input, results)
-          return input if results.nil?
+        def process_output(context, results)
+          return context.input.dup if results.nil?
           return if output_path.nil?
 
           results = result_selector.value(context, results) if @result_selector
           if result_path.payload.start_with?("$.Credentials")
-            credentials = result_path.set(workflow.credentials, results)["Credentials"]
-            workflow.credentials.merge!(credentials)
-            output = input
+            credentials = result_path.set(context.credentials, results)["Credentials"]
+            context.credentials.merge!(credentials)
+            output = context.input.dup
           else
-            output = result_path.set(input, results)
+            output = result_path.set(context.input.dup, results)
           end
 
           output_path.value(context, output)

data/lib/floe/workflow/states/non_terminal_mixin.rb

@@ -4,16 +4,16 @@ module Floe
   class Workflow
     module States
       module NonTerminalMixin
-        def finish
-          # If this state is failed or the End state set next_state to nil
-          context.next_state = end? || context.failed? ? nil : @next
+        def finish(context)
+          # If this state is failed or this is an end state, next_state to nil
+          context.next_state ||= end? || context.failed? ? nil : @next
 
           super
         end
 
-        def validate_state_next!
-          raise Floe::InvalidWorkflowError, "Missing \"Next\" field in state [#{name}]" if @next.nil? && !@end
-          raise Floe::InvalidWorkflowError, "\"Next\" [#{@next}] not in \"States\" for state [#{name}]" if @next && !workflow.payload["States"].key?(@next)
+        def validate_state_next!(workflow)
+          missing_field_error!("Next") if @next.nil? && !@end
+          invalid_field_error!("Next", @next, "is not found in \"States\"") if @next && !workflow_state?(@next, workflow)
         end
       end
     end

data/lib/floe/workflow/states/pass.rb

@@ -21,15 +21,16 @@ module Floe
           @output_path = Path.new(payload.fetch("OutputPath", "$"))
           @result_path = ReferencePath.new(payload.fetch("ResultPath", "$"))
 
-          validate_state!
+          validate_state!(workflow)
         end
 
-        def finish
-          context.output = process_output(context.input.dup, result)
+        def finish(context)
+          input = result.nil? ? process_input(context) : result
+          context.output = process_output(context, input)
           super
         end
 
-        def running?
+        def running?(_)
           false
         end
 
@@ -39,8 +40,8 @@ module Floe
 
         private
 
-        def validate_state!
-          validate_state_next!
+        def validate_state!(workflow)
+          validate_state_next!(workflow)
         end
       end
     end

data/lib/floe/workflow/states/succeed.rb

@@ -6,13 +6,22 @@ module Floe
       class Succeed < Floe::Workflow::State
         attr_reader :input_path, :output_path
 
-        def finish
+        def initialize(workflow, name, payload)
+          super
+
+          @input_path  = Path.new(payload.fetch("InputPath", "$"))
+          @output_path = Path.new(payload.fetch("OutputPath", "$"))
+        end
+
+        def finish(context)
+          input              = input_path.value(context, context.input)
+          context.output     = output_path.value(context, input)
           context.next_state = nil
-          context.output     = context.input
+
           super
         end
 
-        def running?
+        def running?(_)
           false
         end
 

data/lib/floe/workflow/states/task.rb

@@ -18,10 +18,13 @@ module Floe
           @next              = payload["Next"]
           @end               = !!payload["End"]
           @resource          = payload["Resource"]
-          @runner            = Floe::Runner.for_resource(@resource)
+
+          missing_field_error!("Resource") unless @resource.kind_of?(String)
+          @runner = wrap_parser_error("Resource", @resource) { Floe::Runner.for_resource(@resource) }
+
           @timeout_seconds   = payload["TimeoutSeconds"]
-          @retry             = payload["Retry"].to_a.map { |retrier| Retrier.new(retrier) }
-          @catch             = payload["Catch"].to_a.map { |catcher| Catcher.new(catcher) }
+          @retry             = payload["Retry"].to_a.map.with_index { |retrier, i| Retrier.new(workflow, name + ["Retry", i.to_s], retrier) }
+          @catch             = payload["Catch"].to_a.map.with_index { |catcher, i| Catcher.new(workflow, name + ["Catch", i.to_s], catcher) }
           @input_path        = Path.new(payload.fetch("InputPath", "$"))
           @output_path       = Path.new(payload.fetch("OutputPath", "$"))
           @result_path       = ReferencePath.new(payload.fetch("ResultPath", "$"))
@@ -29,36 +32,35 @@ module Floe
           @result_selector   = PayloadTemplate.new(payload["ResultSelector"]) if payload["ResultSelector"]
           @credentials       = PayloadTemplate.new(payload["Credentials"])    if payload["Credentials"]
 
-          validate_state!
+          validate_state!(workflow)
         end
 
-        def start(input)
+        def start(context)
           super
 
-          input          = process_input(input)
-          runner_context = runner.run_async!(resource, input, credentials&.value({}, workflow.credentials), context)
+          input          = process_input(context)
+          runner_context = runner.run_async!(resource, input, credentials&.value({}, context.credentials), context)
 
           context.state["RunnerContext"] = runner_context
         end
 
-        def finish
+        def finish(context)
           output = runner.output(context.state["RunnerContext"])
 
-          if success?
+          if success?(context)
             output = parse_output(output)
-            context.output = process_output(context.input.dup, output)
-            super
+            context.output = process_output(context, output)
           else
-            context.output = error = parse_error(output)
-            super
-            retry_state!(error) || catch_error!(error) || fail_workflow!(error)
+            error = parse_error(output)
+            retry_state!(context, error) || catch_error!(context, error) || fail_workflow!(context, error)
           end
+          super
         ensure
           runner.cleanup(context.state["RunnerContext"])
         end
 
-        def running?
-          return true if waiting?
+        def running?(context)
+          return true if waiting?(context)
 
           runner.status!(context.state["RunnerContext"])
           runner.running?(context.state["RunnerContext"])
@@ -72,23 +74,23 @@ module Floe
 
         attr_reader :runner
 
-        def validate_state!
-          validate_state_next!
+        def validate_state!(workflow)
+          validate_state_next!(workflow)
         end
 
-        def success?
+        def success?(context)
           runner.success?(context.state["RunnerContext"])
         end
 
         def find_retrier(error)
-          self.retry.detect { |r| (r.error_equals & [error, "States.ALL"]).any? }
+          self.retry.detect { |r| r.match_error?(error) }
         end
 
         def find_catcher(error)
-          self.catch.detect { |c| (c.error_equals & [error, "States.ALL"]).any? }
+          self.catch.detect { |c| c.match_error?(error) }
         end
 
-        def retry_state!(error)
+        def retry_state!(context, error)
           retrier = find_retrier(error["Error"]) if error
           return if retrier.nil?
 
@@ -102,27 +104,30 @@ module Floe
 
           return if context["State"]["RetryCount"] > retrier.max_attempts
 
-          wait_until!(:seconds => retrier.sleep_duration(context["State"]["RetryCount"]))
+          wait_until!(context, :seconds => retrier.sleep_duration(context["State"]["RetryCount"]))
           context.next_state = context.state_name
-          logger.info("Running state: [#{long_name}] with input [#{context.input}]...Retry - delay: #{wait_until}")
+          context.output     = error
+          logger.info("Running state: [#{long_name}] with input [#{context.json_input}] got error[#{context.json_output}]...Retry - delay: #{wait_until(context)}")
           true
         end
 
-        def catch_error!(error)
+        def catch_error!(context, error)
           catcher = find_catcher(error["Error"]) if error
           return if catcher.nil?
 
           context.next_state = catcher.next
           context.output     = catcher.result_path.set(context.input, error)
-          logger.info("Running state: [#{long_name}] with input [#{context.input}]...CatchError - next state: [#{context.next_state}] output: [#{context.output}]")
+          logger.info("Running state: [#{long_name}] with input [#{context.json_input}]...CatchError - next state: [#{context.next_state}] output: [#{context.json_output}]")
 
           true
         end
 
-        def fail_workflow!(error)
-          context.next_state     = nil
-          context.output         = {"Error" => error["Error"], "Cause" => error["Cause"]}.compact
-          logger.error("Running state: [#{long_name}] with input [#{context.input}]...Complete workflow - output: [#{context.output}]")
+        def fail_workflow!(context, error)
+          # next_state is nil, and will be set to nil again in super
+          # keeping in here for completeness
+          context.next_state = nil
+          context.output = error
+          logger.error("Running state: [#{long_name}] with input [#{context.json_input}]...Complete workflow - output: [#{context.json_output}]")
         end
 
         def parse_error(output)

data/lib/floe/workflow/states/wait.rb

@@ -23,28 +23,29 @@ module Floe
           @input_path  = Path.new(payload.fetch("InputPath", "$"))
           @output_path = Path.new(payload.fetch("OutputPath", "$"))
 
-          validate_state!
+          validate_state!(workflow)
         end
 
-        def start(input)
+        def start(context)
           super
 
           input = input_path.value(context, context.input)
 
           wait_until!(
+            context,
             :seconds => seconds_path ? seconds_path.value(context, input).to_i : seconds,
             :time    => timestamp_path ? timestamp_path.value(context, input) : timestamp
           )
         end
 
-        def finish
+        def finish(context)
           input          = input_path.value(context, context.input)
           context.output = output_path.value(context, input)
           super
         end
 
-        def running?
-          waiting?
+        def running?(context)
+          waiting?(context)
         end
 
         def end?
@@ -53,8 +54,8 @@ module Floe
 
         private
 
-        def validate_state!
-          validate_state_next!
+        def validate_state!(workflow)
+          validate_state_next!(workflow)
         end
       end
     end