floe 0.13.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fb1e855fda7d4a00a72e494b820a89304350945c14a71675d5cc6306e69f079
-  data.tar.gz: 9780e210073c41b4a5c534bdabd301c2df6275c13328dbb1ee43569470e8d590
+  metadata.gz: 75d5be2f5b9cdcfc64b4b3994d32b9e3955486fd99bf4e05c62c2414485188c8
+  data.tar.gz: 7257009d5942f157f2ccef6499c77e1f9033e0ac4846a08f3f589943bd4794ef
 SHA512:
-  metadata.gz: bec5c7f6337c74258e185b76abfc3953f05ef16cf4de640972d23b7dfa81bf4439df3ce00dd539c618f7d18905d783bfa55dc777365e1a48969942b182448107
-  data.tar.gz: cf584d349c69927dec6945fe21d652b79e96f6228754b1a91a57b3241825661ed6d977a7d53e3ebfae526551da2a4a573148e9d855840d8edc52b8ebeffc948b
+  metadata.gz: bd9275c7e845841fc472e3e0ec92593354c6293bae3c8dc9d7258acb71fcd5db7abaca2c2aadcc4c7701952b65eae8a14da29c1e8e26d71a7d9df2c6aad9abeb
+  data.tar.gz: 8cc089f45244d80428d92feeeb162d8c65fafcea915e00405c54f5340dee4f9106113ad87e36c97a18fd159c3d338bee0f78869e91d200f19b145df494e5edfd

data/.codeclimate.yml

@@ -1,3 +1,4 @@
+version: '2'
 prepare:
   fetch:
   - url: https://raw.githubusercontent.com/ManageIQ/manageiq-style/master/.rubocop_base.yml
@@ -8,9 +9,28 @@ prepare:
     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
-version: '2'
+exclude_patterns:
+- spec/

data/CHANGELOG.md

@@ -4,6 +4,31 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [0.15.0] - 2024-10-28
+### Added
+- Add WorkflowBase base class for Workflow ([#279](https://github.com/ManageIQ/floe/pull/279))
+- Add tool for using the aws stepfunctions simulator ([#244](https://github.com/ManageIQ/floe/pull/244))
+- Implement Map state ([#184](https://github.com/ManageIQ/floe/pull/184))
+- Add Map State Tolerated Failure ([#282](https://github.com/ManageIQ/floe/pull/282))
+- Run Map iterations in parallel up to MaxConcurrency ([#283](https://github.com/ManageIQ/floe/pull/283))
+- Implement Parallel State ([#291](https://github.com/ManageIQ/floe/pull/291))
+
+### Changed
+- More granular compare_key and determine path at initialization time ([#274](https://github.com/ManageIQ/floe/pull/274))
+- For Choice validation, use instance variables and not payload ([#277](https://github.com/ManageIQ/floe/pull/277))
+- Return ExceedToleratedFailureThreshold if ToleratedFailureCount/Percentage is present ([#285](https://github.com/ManageIQ/floe/pull/285))
+
+### Fixed
+- Fix case on log messages ([#280](https://github.com/ManageIQ/floe/pull/280))
+- Handle either ToleratedFailureCount or ToleratedFailurePercentage ([#284](https://github.com/ManageIQ/floe/pull/284))
+
+## [0.14.0] - 2024-08-20
+### Added
+- Implement "IsNumeric": false ([#266](https://github.com/ManageIQ/floe/pull/266))
+- Support choices that do not have a Default defined ([#267](https://github.com/ManageIQ/floe/pull/267))
+- Label containers/pods with workflow Execution ID ([#268](https://github.com/ManageIQ/floe/pull/268))
+- Allow for Execution Id to be passed in ([#269](https://github.com/ManageIQ/floe/pull/269))
+
 ## [0.13.1] - 2024-08-16
 ### Fixed
 - Fix podman/docker container_ref trailing newline ([#265](https://github.com/ManageIQ/floe/pull/265))
@@ -242,7 +267,8 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - Initial release
 
-[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.13.1...HEAD
+[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.14.0...HEAD
+[0.14.0]: https://github.com/ManageIQ/floe/compare/v0.13.1...v0.14.0
 [0.13.1]: https://github.com/ManageIQ/floe/compare/v0.13.0...v0.13.1
 [0.13.0]: https://github.com/ManageIQ/floe/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/ManageIQ/floe/compare/v0.11.3...v0.12.0

data/README.md

@@ -197,6 +197,14 @@ Options supported by the kubernetes docker runner are:
 * `ca_file` - Path to a certificate-authority file for the kubernetes API, only valid if server and token are passed.  If present `/run/secrets/kubernetes.io/serviceaccount/ca.crt` will be used
 * `verify_ssl` - Controls if the kubernetes API certificate-authority should be verified, defaults to "true", only vaild if server and token are passed
 
+## Features Not Yet Supported
+
+The following are not yet supported:
+- Map State Fields:
+  - ItemReader
+  - ItemSelector/ItemBatcher
+  - ResultWriter
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/examples/map.asl

@@ -0,0 +1,46 @@
+{
+  "Comment": "Using Map state in Inline mode",
+  "StartAt": "Pass",
+  "States": {
+    "Pass": {
+      "Type": "Pass",
+      "Next": "Map demo",
+      "Result": {
+        "foo": "bar",
+        "colors": [
+          "red",
+          "green",
+          "blue",
+          "yellow",
+          "white"
+        ]
+      }
+    },
+    "Map demo": {
+      "Type": "Map",
+      "ItemsPath": "$.colors",
+      "MaxConcurrency": 2,
+      "ItemProcessor": {
+        "ProcessorConfig": {
+          "Mode": "INLINE"
+        },
+        "StartAt": "Generate UUID",
+        "States": {
+          "Generate UUID": {
+            "Type": "Pass",
+            "Next": "Sleep",
+            "Parameters": {
+              "uuid.$": "States.UUID()"
+            }
+          },
+          "Sleep": {
+            "Type": "Task",
+            "Resource": "docker://docker.io/agrare/sleep:latest",
+            "End": true
+          }
+        }
+      },
+      "End": true
+    }
+  }
+}

data/examples/parallel.asl

@@ -0,0 +1,32 @@
+{
+  "Comment": "Parallel Example.",
+  "StartAt": "FunWithMath",
+  "States": {
+    "FunWithMath": {
+      "Type": "Parallel",
+      "End": true,
+      "Branches": [
+        {
+          "StartAt": "Add",
+          "States": {
+            "Add": {
+              "Type": "Task",
+              "Resource": "docker://docker.io/agrare/sleep:latest",
+              "End": true
+            }
+          }
+        },
+        {
+          "StartAt": "Subtract",
+          "States": {
+            "Subtract": {
+              "Type": "Task",
+              "Resource": "docker://docker.io/agrare/sleep:latest",
+              "End": true
+            }
+          }
+        }
+      ]
+    }
+  }
+}

data/lib/floe/cli.rb

@@ -13,17 +13,11 @@ module Floe
     def run(args = ARGV)
       workflows_inputs, opts = parse_options!(args)
 
-      credentials =
-        if opts[:credentials_given]
-          opts[:credentials] == "-" ? $stdin.read : opts[:credentials]
-        elsif opts[:credentials_file_given]
-          File.read(opts[:credentials_file])
-        end
+      credentials = create_credentials(opts)
 
       workflows =
         workflows_inputs.each_slice(2).map do |workflow, input|
-          context = Floe::Workflow::Context.new(opts[:context], :input => input, :credentials => credentials)
-          Floe::Workflow.load(workflow, context)
+          create_workflow(workflow, opts[:context], input, credentials)
         end
 
       Floe::Workflow.wait(workflows, &:run_nonblock)
@@ -82,5 +76,18 @@ module Floe
 
       return workflows_inputs, opts
     end
+
+    def create_credentials(opts)
+      if opts[:credentials_given]
+        opts[:credentials] == "-" ? $stdin.read : opts[:credentials]
+      elsif opts[:credentials_file_given]
+        File.read(opts[:credentials_file])
+      end
+    end
+
+    def create_workflow(workflow, context_payload, input, credentials)
+      context = Floe::Workflow::Context.new(context_payload, :input => input, :credentials => credentials)
+      Floe::Workflow.load(workflow, context)
+    end
   end
 end

data/lib/floe/container_runner/docker.rb

@@ -18,11 +18,11 @@ module Floe
         @pull_policy = options["pull-policy"]
       end
 
-      def run_async!(resource, env = {}, secrets = {}, _context = {})
+      def run_async!(resource, env, secrets, context)
         raise ArgumentError, "Invalid resource" unless resource&.start_with?("docker://")
 
-        image = resource.sub("docker://", "")
-
+        image          = resource.sub("docker://", "")
+        execution_id   = context.execution["Id"]
         runner_context = {}
 
         if secrets && !secrets.empty?
@@ -30,7 +30,7 @@ module Floe
         end
 
         begin
-          runner_context["container_ref"] = run_container(image, env, runner_context["secrets_ref"])
+          runner_context["container_ref"] = run_container(image, env, execution_id, runner_context["secrets_ref"])
           runner_context
         rescue AwesomeSpawn::CommandResultError => err
           cleanup(runner_context)
@@ -123,8 +123,8 @@ module Floe
 
       attr_reader :network
 
-      def run_container(image, env, secrets_file)
-        params = run_container_params(image, env, secrets_file)
+      def run_container(image, env, execution_id, secrets_file)
+        params = run_container_params(image, env, execution_id, secrets_file)
 
         logger.debug("Running #{AwesomeSpawn.build_command_line(self.class::DOCKER_COMMAND, params)}")
 
@@ -132,13 +132,14 @@ module Floe
         result.output.chomp
       end
 
-      def run_container_params(image, env, secrets_file)
+      def run_container_params(image, env, execution_id, secrets_file)
         params  = ["run"]
         params << :detach
         params += env.map { |k, v| [:e, "#{k}=#{v}"] }
         params << [:e, "_CREDENTIALS=/run/secrets"] if secrets_file
         params << [:pull, @pull_policy] if @pull_policy
         params << [:net, "host"] if @network == "host"
+        params << [:label, "execution_id=#{execution_id}"]
         params << [:v, "#{secrets_file}:/run/secrets:z"] if secrets_file
         params << [:name, container_name(image)]
         params << image
@@ -157,11 +158,11 @@ module Floe
         event   = docker_event_status_to_event(status)
         running = event != :delete
 
-        name, exit_code = notice.dig("Actor", "Attributes")&.values_at("name", "exitCode")
+        name, exit_code, execution_id = notice.dig("Actor", "Attributes")&.values_at("name", "exitCode", "execution_id")
 
         runner_context = {"container_ref" => name, "container_state" => {"Running" => running, "ExitCode" => exit_code.to_i}}
 
-        [event, runner_context]
+        [event, {"execution_id" => execution_id, "runner_context" => runner_context}]
       rescue JSON::ParserError
         []
       end

data/lib/floe/container_runner/kubernetes.rb

@@ -45,17 +45,17 @@ module Floe
         super
       end
 
-      def run_async!(resource, env = {}, secrets = {}, _context = {})
+      def run_async!(resource, env, secrets, context)
         raise ArgumentError, "Invalid resource" unless resource&.start_with?("docker://")
 
         image  = resource.sub("docker://", "")
         name   = container_name(image)
         secret = create_secret!(secrets) if secrets && !secrets.empty?
-
+        execution_id   = context.execution["Id"]
         runner_context = {"container_ref" => name, "container_state" => {"phase" => "Pending"}, "secrets_ref" => secret}
 
         begin
-          create_pod!(name, image, env, secret)
+          create_pod!(name, image, env, execution_id, secret)
           runner_context
         rescue Kubeclient::HttpError => err
           cleanup(runner_context)
@@ -171,13 +171,14 @@ module Floe
         failed_container_states(context).any?
       end
 
-      def pod_spec(name, image, env, secret = nil)
+      def pod_spec(name, image, env, execution_id, secret = nil)
         spec = {
           :kind       => "Pod",
           :apiVersion => "v1",
           :metadata   => {
             :name      => name,
-            :namespace => namespace
+            :namespace => namespace,
+            :labels    => {"execution_id" => execution_id}
           },
           :spec       => {
             :containers    => [
@@ -219,8 +220,8 @@ module Floe
         spec
       end
 
-      def create_pod!(name, image, env, secret = nil)
-        kubeclient.create_pod(pod_spec(name, image, env, secret))
+      def create_pod!(name, image, env, execution_id, secret = nil)
+        kubeclient.create_pod(pod_spec(name, image, env, execution_id, secret))
       end
 
       def delete_pod!(name)
@@ -294,9 +295,10 @@ module Floe
 
         pod             = notice.object
         container_ref   = pod.metadata.name
+        execution_id    = pod.metadata.labels["execution_id"]
         container_state = pod.to_h[:status].deep_stringify_keys
 
-        {"container_ref" => container_ref, "container_state" => container_state}
+        {"execution_id" => execution_id, "runner_context" => {"container_ref" => container_ref, "container_state" => container_state}}
       end
 
       def kubeclient

data/lib/floe/container_runner/podman.rb

@@ -30,13 +30,14 @@ module Floe
 
       private
 
-      def run_container_params(image, env, secret)
+      def run_container_params(image, env, execution_id, secret)
         params  = ["run"]
         params << :detach
         params += env.map { |k, v| [:e, "#{k}=#{v}"] }
         params << [:e, "_CREDENTIALS=/run/secrets/#{secret}"] if secret
         params << [:pull, @pull_policy] if @pull_policy
         params << [:net, "host"]        if @network == "host"
+        params << [:label, "execution_id=#{execution_id}"]
         params << [:secret, secret] if secret
         params << [:name, container_name(image)]
         params << image
@@ -55,14 +56,16 @@ module Floe
       end
 
       def parse_notice(notice)
-        id, status, exit_code = JSON.parse(notice).values_at("ID", "Status", "ContainerExitCode")
+        notice = JSON.parse(notice)
+        id, status, exit_code, attributes = notice.values_at("ID", "Status", "ContainerExitCode", "Attributes")
 
-        event   = podman_event_status_to_event(status)
-        running = event != :delete
+        execution_id = attributes&.dig("execution_id")
+        event        = podman_event_status_to_event(status)
+        running      = event != :delete
 
         runner_context = {"container_ref" => id, "container_state" => {"Running" => running, "ExitCode" => exit_code.to_i}}
 
-        [event, runner_context]
+        [event, {"execution_id" => execution_id, "runner_context" => runner_context}]
       rescue JSON::ParserError
         []
       end

data/lib/floe/validation_mixin.rb

@@ -18,6 +18,10 @@ module Floe
       self.class.invalid_field_error!(name, field_name, field_value, comment)
     end
 
+    def runtime_field_error!(field_name, field_value, comment, floe_error: "States.Runtime")
+      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
@@ -39,10 +43,14 @@ module Floe
       end
 
       def invalid_field_error!(name, field_name, field_value, comment)
+        raise Floe::InvalidWorkflowError, field_error_text(name, field_name, field_value, comment)
+      end
+
+      def field_error_text(name, field_name, field_value, comment = nil)
         # instead of displaying a large hash or array, just displaying the word Hash or Array
         field_value = field_value.class if field_value.kind_of?(Hash) || field_value.kind_of?(Array)
 
-        parser_error!(name, "field \"#{field_name}\"#{" value \"#{field_value}\"" unless field_value.nil?} #{comment}")
+        "#{Array(name).join(".")} field \"#{field_name}\"#{" value \"#{field_value}\"" unless field_value.nil?} #{comment}"
       end
     end
   end

data/lib/floe/version.rb

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

data/lib/floe/workflow/branch.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class Branch < Floe::WorkflowBase
+    end
+  end
+end

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

@@ -4,16 +4,20 @@ module Floe
   class Workflow
     class ChoiceRule
       class Data < Floe::Workflow::ChoiceRule
-        COMPARE_KEYS = %w[IsNull IsPresent IsNumeric IsString IsBoolean IsTimestamp String Numeric Boolean Timestamp].freeze
+        TYPES      = ["String", "Numeric", "Boolean", "Timestamp", "Present", "Null"].freeze
+        COMPARES   = ["Equals", "LessThan", "GreaterThan", "LessThanEquals", "GreaterThanEquals", "Matches"].freeze
+        # e.g.: (Is)(String), (Is)(Present)
+        TYPE_CHECK = /^(Is)(#{TYPES.join("|")})$/.freeze
+        # e.g.: (String)(LessThan)(Path), (Numeric)(GreaterThanEquals)()
+        OPERATION  = /^(#{(TYPES - %w[Null Present]).join("|")})(#{COMPARES.join("|")})(Path)?$/.freeze
 
-        attr_reader :variable, :compare_key, :value, :path
+        attr_reader :variable, :compare_key, :type, :compare_predicate, :path
 
         def initialize(_workflow, _name, payload)
           super
 
-          @variable = parse_path("Variable", payload)
+          @variable = parse_path("Variable")
           parse_compare_key
-          @value = path ? parse_path(compare_key, payload) : payload[compare_key]
         end
 
         def true?(context, input)
@@ -23,11 +27,11 @@ module Floe
           rhs = compare_value(context, input)
 
           case compare_key
-          when "IsNull" then is_null?(lhs)
-          when "IsNumeric" then is_numeric?(lhs)
-          when "IsString" then is_string?(lhs)
-          when "IsBoolean" then is_boolean?(lhs)
-          when "IsTimestamp" then is_timestamp?(lhs)
+          when "IsNull" then is_null?(lhs, rhs)
+          when "IsNumeric" then is_numeric?(lhs, rhs)
+          when "IsString" then is_string?(lhs, rhs)
+          when "IsBoolean" then is_boolean?(lhs, rhs)
+          when "IsTimestamp" then is_timestamp?(lhs, rhs)
           when "StringEquals", "StringEqualsPath",
                "NumericEquals", "NumericEqualsPath",
                "BooleanEquals", "BooleanEqualsPath",
@@ -62,68 +66,120 @@ module Floe
           # 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.
-          rhs = compare_value(context, input)
+          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 rhs is true, then presence check was successful, return true.
-          rhs
+          # 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 rhs is false, then it successfully wasn't present, return true.
-          !rhs
+          # If predicate is false, then it successfully wasn't present, return true.
+          !predicate
         end
 
-        def is_null?(value) # rubocop:disable Naming/PredicateName
-          value.nil?
+        # rubocop:disable Naming/PredicateName
+        # rubocop:disable Style/OptionalBooleanParameter
+        def is_null?(value, predicate = true)
+          value.nil? == predicate
         end
 
-        def is_present?(value) # rubocop:disable Naming/PredicateName
-          !value.nil?
+        def is_present?(value, predicate = true)
+          !value.nil? == predicate
         end
 
-        def is_numeric?(value) # rubocop:disable Naming/PredicateName
-          value.kind_of?(Numeric)
+        def is_numeric?(value, predicate = true)
+          value.kind_of?(Numeric) == predicate
         end
 
-        def is_string?(value) # rubocop:disable Naming/PredicateName
-          value.kind_of?(String)
+        def is_string?(value, predicate = true)
+          value.kind_of?(String) == predicate
         end
 
-        def is_boolean?(value) # rubocop:disable Naming/PredicateName
-          [true, false].include?(value)
+        def is_boolean?(value, predicate = true)
+          [true, false].include?(value) == predicate
         end
 
-        def is_timestamp?(value) # rubocop:disable Naming/PredicateName
+        def is_timestamp?(value, predicate = true)
           require "date"
 
           DateTime.rfc3339(value)
-          true
+          predicate
         rescue TypeError, Date::Error
-          false
+          !predicate
         end
+        # rubocop:enable Naming/PredicateName
+        # rubocop:enable Style/OptionalBooleanParameter
 
+        # parse the compare key at initialization time
         def parse_compare_key
-          @compare_key = payload.keys.detect { |key| key.match?(/^(#{COMPARE_KEYS.join("|")})/) }
+          payload.each_key do |key|
+            # e.g. (String)(GreaterThan)(Path)
+            if (match_values = OPERATION.match(key))
+              @compare_key = key
+              @type, _operator, @path = match_values.captures
+              @compare_predicate = parse_predicate(type)
+              break
+            end
+            # e.g. (Is)(String)
+            if TYPE_CHECK.match?(key)
+              @compare_key = key
+              # type: nil means no runtime type checking.
+              @type = @path = nil
+              @compare_predicate = parse_predicate("Boolean")
+              break
+            end
+          end
           parser_error!("requires a compare key") unless compare_key
+        end
 
-          @path = compare_key.end_with?("Path")
+        # parse predicate at initilization time
+        # @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)
         end
 
+        # @return right hand predicate - input path or static payload value)
         def compare_value(context, input)
-          path ? value.value(context, input) : value
+          path ? fetch_path(compare_key, compare_predicate, context, input) : compare_predicate
         end
 
+        # feth the variable value at runtime
+        # @return variable value (left hand side )
         def variable_value(context, input)
-          variable.value(context, input)
+          fetch_path("Variable", variable, context, input)
         end
 
-        def parse_path(field_name, payload)
+        # parse path at initilization time
+        # helper method to parse a path from the payload
+        def parse_path(field_name)
           value = payload[field_name]
           missing_field_error!(field_name) unless value
           wrap_parser_error(field_name, value) { Path.new(value) }
         end
+
+        # parse predicate field at initialization time
+        def parse_field(field_name, data_type)
+          value = payload[field_name]
+          return value if correct_type?(value, data_type)
+
+          invalid_field_error!(field_name, value, "required to be a #{data_type}")
+        end
+
+        # fetch a path at runtime
+        def fetch_path(field_name, field_path, context, input)
+          value = field_path.value(context, input)
+          return value if type.nil? || correct_type?(value, type)
+
+          runtime_field_error!(field_name, field_path.to_s, "required to point to a #{type}")
+        end
+
+        # 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)
+        end
       end
     end
   end

data/lib/floe/workflow/item_processor.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class ItemProcessor < Floe::WorkflowBase
+      attr_reader :processor_config
+
+      def initialize(payload, name = nil)
+        super
+        @processor_config = payload.fetch("ProcessorConfig", "INLINE")
+      end
+    end
+  end
+end

data/lib/floe/workflow/state.rb

@@ -48,7 +48,7 @@ module Floe
         return Errno::EAGAIN unless ready?(context)
 
         finish(context)
-      rescue Floe::Error => e
+      rescue Floe::ExecutionError => e
         mark_error(context, e)
       end
 
@@ -82,7 +82,7 @@ module Floe
       def mark_error(context, exception)
         # InputPath or OutputPath were bad.
         context.next_state = nil
-        context.output     = {"Error" => "States.Runtime", "Cause" => exception.message}
+        context.output     = {"Error" => exception.floe_error, "Cause" => exception.message}
         # Since finish threw an exception, super was never called. Calling that now.
         mark_finished(context)
       end