floe 0.17.1 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7631c084cea78319880f47959e5bc883a5406caaf2623b894004172c4d01ff96
-  data.tar.gz: 58416b08ffcd26360eeaa8e8f8056279ed57440f8a65c6650fb26e95a3564c28
+  metadata.gz: d7ec87295c6283b53c25c1791a9f8a2a953e48bec4059bf67fd5487875c114ce
+  data.tar.gz: a56a431253dd0a4a4c4470363ce0dfa83aa6f8ec834239a43266c6e41ccc0b61
 SHA512:
-  metadata.gz: 72f82e4eafec1ea8c1317f4766424e55c821c5f360e5e9db04037032552cd76dfafcdd2c5ec842bc2fc58acb1137adeaafed8306fbbf6a18f2b3c8b6e45efafa
-  data.tar.gz: 976265735ea69bb1844bce7ff07b1abd28b9a40fbd01c62dd47fb40d33374333bd7147fc85bbb52760eb2b9903b2727db4c8edf7f3f38371028cf4827a9a78ee
+  metadata.gz: c3d888a3713b5e3291e9fb7a04ea3254268e2ee11ccdc1a49af71f992cab61d5752d689f70292d67f3c9d3b69f146c47c0a86423a424c18220e813c2997c4402
+  data.tar.gz: f54adf8264d7ed09c05d2c78b8f5029d0ed5c472ac365e75a3656cc66fa29db0dd79eded1136b0893114d75eaf9a5e4637e76a2c347d1b8917ac8d3cf4238ec2

data/CHANGELOG.md

@@ -4,6 +4,33 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [0.19.0] - 2025-12-16
+### Fixed
+- Fix builtin_runner/runner spec file name ([#329](https://github.com/ManageIQ/floe/pull/329))
+- Check WaitUntil before starting a State ([#336](https://github.com/ManageIQ/floe/pull/336))
+- Task TimeoutSeconds and TimeoutSecondsPath not implemented ([#330](https://github.com/ManageIQ/floe/pull/330))
+
+### Added
+- Add floe://log builtin method ([#328](https://github.com/ManageIQ/floe/pull/328))
+
+### Changed
+- Raise `States.Timeout` in `running?` and remove duplicate `timed_out?` check in `finished?` ([#337](https://github.com/ManageIQ/floe/pull/337))
+
+## [0.18.0] - 2025-10-24
+### Added
+- Declare active support dependency ([#316](https://github.com/ManageIQ/floe/pull/316))
+- Add Context equality comparison ([#317](https://github.com/ManageIQ/floe/pull/317))
+- Choice rule payload validation ([#189](https://github.com/ManageIQ/floe/pull/189))
+
+### Changed
+- In ChoiceRule use Regexp.union ([#323](https://github.com/ManageIQ/floe/pull/323))
+- Remove special case for choice rule IsPresent ([#322](https://github.com/ManageIQ/floe/pull/322))
+- Rename data operation parameters ([#324](https://github.com/ManageIQ/floe/pull/324))
+- Refactor workflow state check to not use payload ([#326](https://github.com/ManageIQ/floe/pull/326))
+
+### Fixed
+- Fix missing parameters in item_batcher_spec ([#325](https://github.com/ManageIQ/floe/pull/325))
+
 ## [0.17.1] - 2025-08-25
 ### Changed
 - Default Method=GET for floe://http method parameter ([#315](https://github.com/ManageIQ/floe/pull/315))
@@ -302,7 +329,11 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - Initial release
 
-[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.17.0...HEAD
+[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.19.0...HEAD
+[0.19.0]: https://github.com/ManageIQ/floe/compare/v0.18.0...v0.19.0
+[0.18.0]: https://github.com/ManageIQ/floe/compare/v0.17.1...v0.18.0
+[0.17.1]: https://github.com/ManageIQ/floe/compare/v0.17.0...v0.17.1
+[0.17.0]: https://github.com/ManageIQ/floe/compare/v0.16.0...v0.17.0
 [0.16.0]: https://github.com/ManageIQ/floe/compare/v0.16.0...v0.17.0
 [0.16.0]: https://github.com/ManageIQ/floe/compare/v0.15.1...v0.16.0
 [0.15.1]: https://github.com/ManageIQ/floe/compare/v0.15.0...v0.15.1

data/README.md

@@ -1,8 +1,6 @@
 # Floe
 
 [![CI](https://github.com/ManageIQ/floe/actions/workflows/ci.yaml/badge.svg)](https://github.com/ManageIQ/floe/actions/workflows/ci.yaml)
-[![Code Climate](https://codeclimate.com/github/ManageIQ/floe.svg)](https://codeclimate.com/github/ManageIQ/floe)
-[![Test Coverage](https://codeclimate.com/github/ManageIQ/floe/badges/coverage.svg)](https://codeclimate.com/github/ManageIQ/floe/coverage)
 
 ## Overview
 
@@ -167,6 +165,31 @@ Task Runner Types:
 
 This is the "builtin" runner and exposes methods that are executed internally without having to call out to a docker image.
 
+##### Log builtin method
+
+`floe://log` allows you to write a message to the logger.
+
+Example:
+```json
+{
+  "Comment": "Print log message",
+  "StartAt": "Log",
+  "States": {
+    "Log": {
+      "Type": "Task",
+      "Resource": "floe://log",
+      "Parameters": {
+        "Level": "INFO",
+        "Message": "Hello, Floe!"
+      },
+      "End": true
+    }
+```
+
+Log Parameters:
+* `Level` (required) - Log level. Permitted values: `DEBUG`, `INFO`, `WARN`, `ERROR`, `FATAL`, or `UNKNOWN`.  Defaults to `INFO`.
+* `Message` (required) - The message to log
+
 ##### HTTP builtin method
 
 `floe://http` allows you to execute HTTP method calls.

data/examples/log.asl

@@ -0,0 +1,33 @@
+{
+  "Comment": "Print log messages",
+  "StartAt": "Log Info",
+  "States": {
+    "Log Info": {
+      "Type": "Task",
+      "Resource": "floe://log",
+      "Parameters": {
+        "Level": "INFO",
+        "Message": "Hello, Floe!"
+      },
+      "Next": "Log Debug"
+    },
+    "Log Debug": {
+      "Type": "Task",
+      "Resource": "floe://log",
+      "Parameters": {
+        "Level": "DEBUG",
+        "Message": "Hello, Floe!"
+      },
+      "Next": "Log From Input"
+    },
+    "Log From Input": {
+      "Type": "Task",
+      "Resource": "floe://log",
+      "Parameters": {
+        "Level": "INFO",
+        "Message.$": "States.Format('Hello, {}!', $.name)"
+      },
+      "End": true
+    }
+  }
+}

data/floe.gemspec

@@ -31,15 +31,16 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "activesupport", ">5.2"
   spec.add_dependency "awesome_spawn", "~>1.6"
+  spec.add_dependency "faraday"
+  spec.add_dependency "faraday-follow_redirects"
   spec.add_dependency "io-wait"
+  spec.add_dependency "json", "~>2.10"
   spec.add_dependency "jsonpath", "~>1.1"
   spec.add_dependency "kubeclient", "~>4.7"
   spec.add_dependency "optimist", "~>3.0"
   spec.add_dependency "parslet", "~>2.0"
-  spec.add_dependency "json", "~>2.10"
-  spec.add_dependency "faraday"
-  spec.add_dependency "faraday-follow_redirects"
 
   spec.add_development_dependency "manageiq-style", ">= 1.5.2"
   spec.add_development_dependency "rake", "~> 13.0"

data/lib/floe/builtin_runner/methods.rb

@@ -1,6 +1,35 @@
+require "logger"
+
 module Floe
   module BuiltinRunner
     class Methods < BasicObject
+      def self.log(params, _secrets, context)
+        params["Level"] = (params["Level"] ||= "INFO").upcase
+
+        error = log_verify_params(params)
+        return BuiltinRunner.error!({}, :cause => error) if error
+
+        level, message = params.values_at("Level", "Message")
+
+        context.logger.add(::Logger::Severity.const_get(level), message)
+
+        BuiltinRunner.success!({}, :output => context.input)
+      end
+
+      LOG_SEVERITIES = ::Logger::Severity.constants.sort_by { |s| ::Logger::Severity.const_get(s) }.map(&:to_s)
+      LOG_SEVERITIES_S = "#{LOG_SEVERITIES[0..-2].join(", ")}, or #{LOG_SEVERITIES[-1]}"
+
+      private_class_method def self.log_verify_params(params)
+        return "Missing Parameter: Message" if params["Message"].nil?
+        return "Invalid Parameter: Level: [#{params["Level"]}], must be one of #{LOG_SEVERITIES_S}" unless LOG_SEVERITIES.include?(params["Level"])
+
+        nil
+      end
+
+      private_class_method def self.log_status!(runner_context)
+        runner_context
+      end
+
       def self.http(params, _secrets, _context)
         params["Method"] ||= "GET"
 
@@ -59,8 +88,8 @@ module Floe
           connection.response(:follow_redirects)
         end
 
-        response = connection.send(method.downcase) do |request|
-          request.body = body if body
+        response = connection.send(method.downcase) do |faraday_request|
+          faraday_request.body = body if body
         end
 
         output = {"Status" => response.status, "Body" => response.body, "Headers" => response.headers}

data/lib/floe/builtin_runner/runner.rb

@@ -23,7 +23,7 @@ module Floe
         method_name = runner_context["method"]
         raise ArgumentError if method_name.nil?
 
-        cleanup_method = "#{method_name}_cleanup"
+        cleanup_method = :"#{method_name}_cleanup"
         return unless Methods.respond_to?(cleanup_method, true)
 
         Methods.send(cleanup_method, runner_context)
@@ -34,7 +34,7 @@ module Floe
         raise ArgumentError if method_name.nil?
         return if runner_context["running"] == false
 
-        Methods.send("#{method_name}_status!", runner_context)
+        Methods.send(:"#{method_name}_status!", runner_context)
       end
 
       def running?(runner_context)

data/lib/floe/container_runner/docker.rb

@@ -105,10 +105,14 @@ module Floe
       end
 
       def running?(runner_context)
+        return false if runner_context.key?("Error")
+
         !!runner_context.dig("container_state", "Running")
       end
 
       def success?(runner_context)
+        return false if runner_context.key?("Error")
+
         runner_context.dig("container_state", "ExitCode") == 0
       end
 
@@ -176,18 +180,21 @@ module Floe
         when "die", "destroy"
           :delete
         else
-          :unkonwn
+          :unknown
         end
       end
 
       def inspect_container(container_id)
         JSON.parse(docker!("inspect", container_id).output).first
       rescue AwesomeSpawn::CommandResultError => err
-        raise Floe::ExecutionError.new("Failed to get status for container #{container_id}: #{err}")
+        raise Floe::ExecutionError, "Failed to get status for container #{container_id}: #{err}"
       end
 
-      def delete_container(container_id)
-        docker!("rm", container_id)
+      def delete_container(container_id, force: true)
+        params = ["rm", container_id]
+        params << "--force" if force
+
+        docker!(*params)
       rescue
         nil
       end

data/lib/floe/container_runner/kubernetes.rb

@@ -11,7 +11,7 @@ module Floe
       FAILURE_REASONS = %w[CrashLoopBackOff ImagePullBackOff ErrImagePull].freeze
 
       def initialize(options = {})
-        require "active_support/core_ext/hash/keys"
+        require "active_support/core_ext/hash/keys" # deep_stringify_keys
         require "awesome_spawn"
         require "securerandom"
         require "base64"
@@ -70,6 +70,7 @@ module Floe
       end
 
       def running?(runner_context)
+        return false if runner_context.key?("Error")
         return false unless pod_running?(runner_context)
         # If a pod is Pending and the containers are waiting with a failure
         # reason such as ImagePullBackOff or CrashLoopBackOff then the pod
@@ -80,6 +81,8 @@ module Floe
       end
 
       def success?(runner_context)
+        return false if runner_context.key?("Error")
+
         runner_context.dig("container_state", "phase") == "Succeeded"
       end
 
@@ -156,7 +159,7 @@ module Floe
       def pod_info(pod_name)
         kubeclient.get_pod(pod_name, namespace)
       rescue Kubeclient::HttpError => err
-        raise Floe::ExecutionError.new("Failed to get status for pod #{namespace}/#{pod_name}: #{err}")
+        raise Floe::ExecutionError, "Failed to get status for pod #{namespace}/#{pod_name}: #{err}"
       end
 
       def pod_running?(context)

data/lib/floe/validation_mixin.rb

@@ -22,10 +22,6 @@ module Floe
       raise Floe::ExecutionError.new(self.class.field_error_text(name, field_name, field_value, comment), floe_error)
     end
 
-    def workflow_state?(field_value, workflow)
-      workflow.payload["States"] ? workflow.payload["States"].include?(field_value) : true
-    end
-
     def wrap_parser_error(field_name, field_value)
       yield
     rescue ArgumentError, InvalidWorkflowError => error

data/lib/floe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Floe
-  VERSION = "0.17.1"
+  VERSION = "0.19.0"
 end

data/lib/floe/workflow/catcher.rb

@@ -24,7 +24,7 @@ module Floe
 
       def validate_state_next!(workflow)
         missing_field_error!("Next") if @next.nil?
-        invalid_field_error!("Next", @next, "is not found in \"States\"") if @next && !workflow_state?(@next, workflow)
+        invalid_field_error!("Next", @next, "is not found in \"States\"") if @next && !workflow.state?(@next)
       end
     end
   end

data/lib/floe/workflow/choice_rule/data.rb

@@ -6,12 +6,14 @@ module Floe
       class Data < Floe::Workflow::ChoiceRule
         TYPES      = ["String", "Numeric", "Boolean", "Timestamp", "Present", "Null"].freeze
         COMPARES   = ["Equals", "LessThan", "GreaterThan", "LessThanEquals", "GreaterThanEquals", "Matches"].freeze
+        OPERATIONS = TYPES.each_with_object({}) { |dt, a| a[dt] = :"is_#{dt.downcase}?" }
+                          .merge(COMPARES.each_with_object({}) { |op, a| a[op] = :"op_#{op.downcase}?" }).freeze
         # e.g.: (Is)(String), (Is)(Present)
-        TYPE_CHECK = /^(Is)(#{TYPES.join("|")})$/.freeze
+        TYPE_CHECK = /^Is(#{Regexp.union(TYPES)})$/
         # e.g.: (String)(LessThan)(Path), (Numeric)(GreaterThanEquals)()
-        OPERATION  = /^(#{(TYPES - %w[Null Present]).join("|")})(#{COMPARES.join("|")})(Path)?$/.freeze
+        OPERATION  = /^(#{Regexp.union(TYPES - %w[Null Present])})(#{Regexp.union(COMPARES)})(Path)?$/
 
-        attr_reader :variable, :compare_key, :operation, :type, :compare_predicate, :path
+        attr_reader :variable, :compare_key, :operator, :type, :compare_predicate, :path
 
         def initialize(_workflow, _name, payload)
           super
@@ -20,62 +22,80 @@ module Floe
           parse_compare_key
         end
 
+        # Evaluate whether this rule is true for the given context and input (runtime)
+        #
+        # @param context [Context] The workflow execution context
+        # @param input [Hash] The current state input
+        # @return [Boolean] true if the rule evaluate to true
         def true?(context, input)
-          return presence_check(context, input) if compare_key == "IsPresent"
-
-          lhs = variable_value(context, input)
+          # Payload pattern is: {"Variable": $lhs, $operator: $rhs}
+          # Example:
+          #
+          #   {"Variable": "$.foo", "IsNumeric": true}
+          #     lhs = input["$.foo"]
+          #     rhs = true
+          #     is_numeric?(lhs, rhs)
+          #
+          #   {"Variable": "$.foo", "GreaterThanString": "aaa"}
+          #     lhs = input["$.foo"]
+          #     rhs = "aaa"
+          #     op_greaterthan?(lhs, rhs)
+          #
+          #   {"Variable": "$.foo", "GreaterThanNumericPath": "$.bar"}
+          #     lhs = input["$.foo"]
+          #     rhs = input["$.bar"]
+          #     op_greaterthan?(lhs, rhs)
+          #
+          # NOTE: IsPresent works a little differently as lhs might raise a PathError.
+          #       See the exception handler below. This is why we process the rhs before the lhs.
           rhs = compare_value(context, input)
-          send(operation, lhs, rhs)
+          lhs = variable_value(context, input)
+          send(OPERATIONS[operator], lhs, rhs)
+        rescue Floe::PathError
+          # For IsPresent, we can expect the lhs to not be present in some cases,
+          #                This throws a PathError. We handle that special case here.
+          # Example:
+          #
+          #   {"Variable": "$.foo", "IsPresent": false}
+          #     lhs = input["$.foo"], but variable is not present. (The variable lookup threw PathError)
+          #     rhs = false
+          return is_present?(:not_present, rhs) if operator == "Present"
+
+          # for non "IsPresent" checks, share that lhs or rhs is not found.
+          raise
         end
 
         private
 
-        def presence_check(context, input)
-          # Get the right hand side for {"Variable": "$.foo", "IsPresent": true} i.e.: true
-          # If true  then return true when present.
-          # If false then return true when not present.
-          predicate = compare_value(context, input)
-          # Don't need the variable_value, just need to see if the path finds the value.
-          variable_value(context, input)
-
-          # The variable_value is present
-          # If predicate is true, then presence check was successful, return true.
-          predicate
-        rescue Floe::PathError
-          # variable_value is not present. (the path lookup threw an error)
-          # If predicate is false, then it successfully wasn't present, return true.
-          !predicate
-        end
-
         # rubocop:disable Naming/PredicateName
         # rubocop:disable Style/OptionalBooleanParameter
-        def is_null?(value, predicate = true)
-          value.nil? == predicate
+        def is_null?(value, expectation)
+          value.nil? == expectation
         end
 
-        def is_present?(value, predicate = true)
-          !value.nil? == predicate
+        def is_present?(value, expectation)
+          (value != :not_present) == expectation
         end
 
-        def is_numeric?(value, predicate = true)
-          value.kind_of?(Numeric) == predicate
+        def is_numeric?(value, expectation)
+          value.kind_of?(Numeric) == expectation
         end
 
-        def is_string?(value, predicate = true)
-          value.kind_of?(String) == predicate
+        def is_string?(value, expectation)
+          value.kind_of?(String) == expectation
         end
 
-        def is_boolean?(value, predicate = true)
-          [true, false].include?(value) == predicate
+        def is_boolean?(value, expectation)
+          [true, false].include?(value) == expectation
         end
 
-        def is_timestamp?(value, predicate = true)
+        def is_timestamp?(value, expectation)
           require "date"
 
           DateTime.rfc3339(value)
-          predicate
+          expectation
         rescue TypeError, Date::Error
-          !predicate
+          !expectation
         end
         # rubocop:enable Naming/PredicateName
         # rubocop:enable Style/OptionalBooleanParameter
@@ -100,8 +120,8 @@ module Floe
           lhs >= rhs
         end
 
-        def op_matches?(lhs, rhs)
-          lhs.match?(Regexp.escape(rhs).gsub('\*', '.*?'))
+        def op_matches?(value, pattern)
+          value.match?(Regexp.escape(pattern).gsub('\*', '.*?'))
         end
 
         # parse the compare key at initialization time
@@ -110,26 +130,26 @@ module Floe
             # e.g. (String)(GreaterThan)(Path)
             if (match_values = OPERATION.match(key))
               @compare_key = key
-              @type, operator, @path = match_values.captures
-              @operation = "op_#{operator.downcase}?".to_sym
+              @type, @operator, @path = match_values.captures
               @compare_predicate = parse_predicate(type)
               break
-            end
             # e.g. (Is)(String)
-            if (match_value = TYPE_CHECK.match(key))
+            elsif (match_value = TYPE_CHECK.match(key))
               @compare_key = key
-              _operator, type = match_value.captures
+              @operator = match_value.captures.first
               # type: nil means no runtime type checking.
               @type = @path = nil
-              @operation = "is_#{type.downcase}?".to_sym
               @compare_predicate = parse_predicate("Boolean")
               break
             end
           end
-          parser_error!("requires a compare key") if compare_key.nil? || operation.nil?
+          parser_error!("requires a compare key") if compare_key.nil? || operator.nil?
         end
 
-        # parse predicate at initilization time
+        # parse predicate at initialization time
+        # @param data_type [String] the data type of the variable
+        #                  When parsing operations (IntegerGreaterThan), this will be the operation data type (e.g.: Integer)
+        #                  When parsing type checks (IsString), this will always be a Boolean
         # @return the right predicate attached to the compare key
         def parse_predicate(data_type)
           path ? parse_path(compare_key) : parse_field(compare_key, data_type)
@@ -140,13 +160,13 @@ module Floe
           path ? fetch_path(compare_key, compare_predicate, context, input) : compare_predicate
         end
 
-        # feth the variable value at runtime
-        # @return variable value (left hand side )
+        # fetch the variable value at runtime
+        # @return variable value (left hand side)
         def variable_value(context, input)
           fetch_path("Variable", variable, context, input)
         end
 
-        # parse path at initilization time
+        # parse path at initialization time
         # helper method to parse a path from the payload
         def parse_path(field_name)
           value = payload[field_name]
@@ -155,6 +175,10 @@ module Floe
         end
 
         # parse predicate field at initialization time
+        # @param field_name [String] the compare key
+        # @param data_type [String] the data type of the variable
+        #                  When parsing operations (IntegerGreaterThan), this will be the operation data type (e.g.: Integer)
+        #                  When parsing type checks (IsString), this will always be a Boolean
         def parse_field(field_name, data_type)
           value = payload[field_name]
           return value if correct_type?(value, data_type)
@@ -165,6 +189,7 @@ module Floe
         # fetch a path at runtime
         def fetch_path(field_name, field_path, context, input)
           value = field_path.value(context, input)
+          # if this is an operation (GreaterThanPath), ensure the value is the correct type
           return value if type.nil? || correct_type?(value, type)
 
           runtime_field_error!(field_name, field_path.to_s, "required to point to a #{type}")
@@ -173,7 +198,7 @@ module Floe
         # if we have runtime checking, check against that type
         #   otherwise assume checking a TYPE_CHECK predicate and check against Boolean
         def correct_type?(value, data_type)
-          send("is_#{data_type.downcase}?".to_sym, value)
+          send(OPERATIONS[data_type], value, true)
         end
       end
     end

data/lib/floe/workflow/choice_rule.rb

@@ -51,7 +51,7 @@ module Floe
         elsif !@next
           # top level nodes require a next
           missing_field_error!("Next")
-        elsif !workflow_state?(@next, workflow)
+        elsif !workflow.state?(@next)
           # top level nodes require a next field that is found
           invalid_field_error!("Next", @next, "is not found in \"States\"")
         end

data/lib/floe/workflow/context.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 module Floe
   class Workflow
     class Context
@@ -25,6 +27,17 @@ module Floe
         raise Floe::InvalidExecutionInput, "Invalid State Machine Execution Input: #{err}: was expecting (JSON String, Number, Array, Object or token 'null', 'true' or 'false')"
       end
 
+      def prepare_start(start_at)
+        return if started?
+
+        state["Name"]  = start_at
+        state["Input"] = execution["Input"].dup
+        state["Guid"]  = SecureRandom.uuid
+
+        execution["Id"]      ||= SecureRandom.uuid
+        execution["StartTime"] = Time.now.utc.iso8601
+      end
+
       def execution
         @context["Execution"]
       end
@@ -140,13 +153,22 @@ module Floe
       end
 
       def inspect
-        format("#<%s: %s>", self.class.name, safe_context.inspect)
+        "#<#{self.class.name}: #{safe_context.inspect}>"
       end
 
       def to_h
         safe_context
       end
 
+      def ==(other)
+        other.kind_of?(self.class) && other.instance_variable_get(:@context) == @context
+      end
+      alias eql? ==
+
+      def hash
+        @context.hash
+      end
+
       private
 
       def safe_context

data/lib/floe/workflow/intrinsic_function/transformer.rb

@@ -77,7 +77,7 @@ module Floe
         rule(:number   => simple(:v)) { v.match(/[eE.]/) ? Float(v) : Integer(v) }
         rule(:jsonpath => simple(:v)) { Floe::Workflow::Path.value(v.to_s, context, input) }
 
-        STATES_FORMAT_PLACEHOLDER = /(?<!\\)\{\}/.freeze
+        STATES_FORMAT_PLACEHOLDER = /(?<!\\)\{\}/
 
         rule(:states_format => {:args => subtree(:args)}) do
           args = Transformer.process_args(args(), "States.Format", [String, VariadicArgs[[String, TrueClass, FalseClass, Numeric, NilClass]]])
@@ -236,15 +236,15 @@ module Floe
 
         rule(:states_string_split => {:args => subtree(:args)}) do
           args = Transformer.process_args(args(), "States.StringSplit", [String, String])
-          str, delimeter = *args
+          str, delimiter = *args
 
-          case delimeter.size
+          case delimiter.size
           when 0
             str.empty? ? [] : [str]
           when 1
-            str.split(delimeter)
+            str.split(delimiter)
           else
-            str.split(/[#{Regexp.escape(delimeter)}]+/)
+            str.split(/[#{Regexp.escape(delimiter)}]+/)
           end
         end
 

data/lib/floe/workflow/payload_template.rb

@@ -48,7 +48,7 @@ module Floe
       end
 
       def check_dynamic_datatype(key, value)
-        unless value.is_a?(String)
+        unless value.kind_of?(String)
           raise Floe::InvalidWorkflowError, "The value for the field \"#{key}\" must be a String that contains a valid Reference Path or Intrinsic Function expression"
         end
       end

data/lib/floe/workflow/state.rb

@@ -43,7 +43,9 @@ module Floe
 
       # @return for incomplete Errno::EAGAIN, for completed 0
       def run_nonblock!(context)
-        start(context) unless context.state_started?
+        # Only start the state if it isn't already started and it isn't waiting
+        # from a prior Retry.
+        start(context)       unless started?(context) || waiting?(context)
         return Errno::EAGAIN unless ready?(context)
 
         finish(context)
@@ -89,13 +91,13 @@ module Floe
       def mark_error(context, exception)
         # InputPath or OutputPath were bad.
         context.next_state = nil
-        context.output     = {"Error" => exception.floe_error, "Cause" => exception.message}
+        context.output     = exception.to_output
         # Since finish threw an exception, super was never called. Calling that now.
         mark_finished(context)
       end
 
       def ready?(context)
-        !started?(context) || !running?(context)
+        (started?(context) && !running?(context)) || !waiting?(context)
       end
 
       def running?(context)

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

@@ -49,7 +49,7 @@ module Floe
         end
 
         def validate_state_default!(workflow)
-          invalid_field_error!("Default", @default, "is not found in \"States\"") if @default && !workflow_state?(@default, workflow)
+          invalid_field_error!("Default", @default, "is not found in \"States\"") if @default && !workflow.state?(@default)
         end
       end
     end

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

@@ -58,7 +58,7 @@ module Floe
               "Execution" => {
                 "Id" => context.execution["Id"]
               },
-              "Map" => {
+              "Map"       => {
                 "Item" => {"Index" => index, "Value" => item}
               }
             }

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

@@ -13,7 +13,7 @@ module Floe
 
         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)
+          invalid_field_error!("Next", @next, "is not found in \"States\"") if @next && !workflow.state?(@next)
         end
       end
     end

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

@@ -9,29 +9,29 @@ module Floe
         include RetryCatchMixin
 
         attr_reader :credentials, :end, :heartbeat_seconds, :next, :parameters,
-                    :result_selector, :resource, :timeout_seconds, :retry, :catch,
-                    :input_path, :output_path, :result_path
+                    :result_selector, :resource, :timeout_seconds, :timeout_seconds_path,
+                    :retry, :catch, :input_path, :output_path, :result_path
 
         def initialize(workflow, name, payload)
           super
 
-          @heartbeat_seconds = payload["HeartbeatSeconds"]
-          @next              = payload["Next"]
-          @end               = !!payload["End"]
-          @resource          = payload["Resource"]
-
+          @resource = payload["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.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", "$"))
-          @parameters        = PayloadTemplate.new(payload["Parameters"])     if payload["Parameters"]
-          @result_selector   = PayloadTemplate.new(payload["ResultSelector"]) if payload["ResultSelector"]
-          @credentials       = PayloadTemplate.new(payload["Credentials"])    if payload["Credentials"]
+          @next                 = payload["Next"]
+          @end                  = !!payload["End"]
+          @timeout_seconds      = payload["TimeoutSeconds"]
+          @heartbeat_seconds    = payload["HeartbeatSeconds"]
+          @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", "$"))
+          @timeout_seconds_path = ReferencePath.new(payload["TimeoutSecondsPath"]) if payload["TimeoutSecondsPath"]
+          @parameters           = PayloadTemplate.new(payload["Parameters"])       if payload["Parameters"]
+          @result_selector      = PayloadTemplate.new(payload["ResultSelector"])   if payload["ResultSelector"]
+          @credentials          = PayloadTemplate.new(payload["Credentials"])      if payload["Credentials"]
 
           validate_state!(workflow)
         end
@@ -39,6 +39,9 @@ module Floe
         def start(context)
           super
 
+          # Wakeup no later than timeout_seconds to check if the Resource has timed out
+          wait_until!(context, :seconds => timeout_seconds) if timeout_seconds
+
           input          = process_input(context)
           secrets        = credentials&.value(context, context.input)
           runner_context = runner.run_async!(resource, input, secrets, context)
@@ -48,27 +51,31 @@ module Floe
 
         def finish(context)
           output = runner.output(context.state["RunnerContext"])
+          raise Floe::ExecutionError.from_output(parse_error(output)) unless success?(context)
+
+          output = parse_output(output)
+          context.output = process_output(context, output)
 
-          if success?(context)
-            output = parse_output(output)
-            context.output = process_output(context, output)
-          else
-            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?(context)
-          return true  if waiting?(context)
+          raise Floe::TimeoutError if timed_out?(context)
           return false if finished?(context)
 
           runner.status!(context.state["RunnerContext"])
           runner.running?(context.state["RunnerContext"])
         end
 
+        def mark_error(context, exception)
+          error = exception.to_output
+
+          retry_state!(context, error) || catch_error!(context, error) || fail_workflow!(context, error)
+          mark_finished(context)
+        end
+
         def end?
           @end
         end
@@ -79,12 +86,43 @@ module Floe
 
         def validate_state!(workflow)
           validate_state_next!(workflow)
+          validate_state_timeout_seconds!(workflow)
+          validate_state_timeout_seconds_path!(workflow)
+        end
+
+        def validate_state_timeout_seconds!(workflow)
+          return if @timeout_seconds.nil?
+          return if @timeout_seconds.kind_of?(Integer) && @timeout_seconds > 0
+
+          invalid_field_error!("TimeoutSeconds", @timeout_seconds, "must be positive, non-zero integer")
+        end
+
+        def validate_state_timeout_seconds_path!(workflow)
+          return if @timeout_seconds_path.nil? || @timeout_seconds.nil?
+
+          invalid_field_error!("TimeoutSecondsPath", nil, "cannot specify both \"TimeoutSeconds\" and \"TimeoutSecondsPath\"")
         end
 
         def success?(context)
           runner.success?(context.state["RunnerContext"])
         end
 
+        def timed_out?(context)
+          return false if timeout_seconds.nil? && timeout_seconds_path.nil?
+
+          timeout      = timeout_seconds || timeout_seconds_path.value(context, context.input)
+          entered_time = Time.parse(context.state["EnteredTime"])
+
+          Time.now.utc > entered_time + timeout
+        end
+
+        def task_timed_out!(context)
+          context.state["RunnerContext"]["Error"] = "States.Timeout"
+          context.state["RunnerContext"]["Cause"] = "Task timed out"
+
+          false
+        end
+
         def parse_error(output)
           return if output.nil?
           return output if output.kind_of?(Hash)

data/lib/floe/workflow.rb

@@ -150,15 +150,7 @@ module Floe
 
     # setup a workflow
     def start_workflow
-      return if context.state_name
-
-      context.state["Name"]  = start_at
-      context.state["Input"] = context.execution["Input"].dup
-      context.state["Guid"]  = SecureRandom.uuid
-
-      context.execution["Id"]      ||= SecureRandom.uuid
-      context.execution["StartTime"] = Time.now.utc.iso8601
-
+      context.prepare_start(start_at)
       self
     end
 
@@ -183,7 +175,7 @@ module Floe
 
       # if rerunning due to an error (and we are using Retry)
       if context.state_name == context.next_state && context.failed? && context.state.key?("Retrier")
-        next_state.merge!(context.state.slice("RetryCount", "Input", "Retrier"))
+        next_state.merge!(context.state.slice("RetryCount", "Input", "Retrier", "WaitUntil"))
       else
         next_state["Input"] = context.output
       end

data/lib/floe/workflow_base.rb

@@ -77,6 +77,10 @@ module Floe
       context.output.to_json if end?(context)
     end
 
+    def state?(state_name)
+      @payload["States"].include?(state_name)
+    end
+
     private
 
     def step!(context)
@@ -102,7 +106,7 @@ module Floe
     def validate_workflow!
       missing_field_error!("States") if @states.empty?
       missing_field_error!("StartAt") if @start_at.nil?
-      invalid_field_error!("StartAt", @start_at, "is not found in \"States\"") unless workflow_state?(@start_at, self)
+      invalid_field_error!("StartAt", @start_at, "is not found in \"States\"") unless state?(@start_at)
     end
   end
 end

data/lib/floe.rb

@@ -54,17 +54,36 @@ module Floe
   class InvalidExecutionInput < Error; end
 
   class ExecutionError < Error
+    def self.from_output(output)
+      raise ArgumentError unless output.kind_of?(Hash) && output.key?("Error")
+
+      new(output["Cause"], output["Error"])
+    end
+
     attr_reader :floe_error
 
     def initialize(message, floe_error = "States.Runtime")
       super(message)
       @floe_error = floe_error
     end
+
+    def to_output
+      {"Error" => floe_error}.tap do |output|
+        # If there is no "Cause" then ::Exception will use the exception class name
+        output["Cause"] = message if message != self.class.name.to_s
+      end
+    end
   end
 
   class PathError < ExecutionError
   end
 
+  class TimeoutError < ExecutionError
+    def initialize(message = nil)
+      super(message, "States.Timeout")
+    end
+  end
+
   def self.logger
     @logger ||= NullLogger.new
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: floe
 version: !ruby/object:Gem::Version
-  version: 0.17.1
+  version: 0.19.0
 platform: ruby
 authors:
 - ManageIQ Developers
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: awesome_spawn
   requirement: !ruby/object:Gem::Requirement
@@ -24,7 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
-  name: io-wait
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -38,103 +52,103 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: jsonpath
+  name: faraday-follow_redirects
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: kubeclient
+  name: io-wait
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.7'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.7'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: optimist
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.10'
 - !ruby/object:Gem::Dependency
-  name: parslet
+  name: jsonpath
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: json
+  name: kubeclient
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '4.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '4.7'
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: optimist
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: faraday-follow_redirects
+  name: parslet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: manageiq-style
   requirement: !ruby/object:Gem::Requirement
@@ -211,10 +225,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".codeclimate.yml"
 - ".rspec"
 - ".rubocop.yml"
-- ".rubocop_cc.yml"
 - ".rubocop_local.yml"
 - ".yamllint"
 - CHANGELOG.md
@@ -224,6 +236,7 @@ files:
 - Rakefile
 - examples/everything.asl
 - examples/http.asl
+- examples/log.asl
 - examples/map.asl
 - examples/parallel.asl
 - examples/set-credential.asl

data/.codeclimate.yml

@@ -1,36 +0,0 @@
-version: '2'
-prepare:
-  fetch:
-  - url: https://raw.githubusercontent.com/ManageIQ/manageiq-style/master/.rubocop_base.yml
-    path: ".rubocop_base.yml"
-  - url: https://raw.githubusercontent.com/ManageIQ/manageiq-style/master/.rubocop_cc_base.yml
-    path: ".rubocop_cc_base.yml"
-  - url: https://raw.githubusercontent.com/ManageIQ/manageiq-style/master/styles/base.yml
-    path: styles/base.yml
-  - url: https://raw.githubusercontent.com/ManageIQ/manageiq-style/master/styles/cc_base.yml
-    path: styles/cc_base.yml
-checks:
-  argument-count:
-    enabled: false
-  complex-logic:
-    enabled: false
-  file-lines:
-    enabled: false
-  method-complexity:
-    config:
-      threshold: 11
-  method-count:
-    enabled: false
-  method-lines:
-    enabled: false
-  nested-control-flow:
-    enabled: false
-  return-statements:
-    enabled: false
-plugins:
-  rubocop:
-    enabled: true
-    config: ".rubocop_cc.yml"
-    channel: rubocop-1-56-3
-exclude_patterns:
-- spec/

data/.rubocop_cc.yml

@@ -1,4 +0,0 @@
-inherit_from:
-- ".rubocop_base.yml"
-- ".rubocop_cc_base.yml"
-- ".rubocop_local.yml"