floe 0.11.3 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb1a786256a191ba7d1b3b08f6e3cd02fa778fcf28ab44a7353f36ae7979039b
-  data.tar.gz: ca5ab5d0b5ed1949945593bb1f07141e554fbbac4d825cbf6333bb92e5b17b6d
+  metadata.gz: abe15498a790293b2a375c4538ed649bfa577edd1b7eaa38d02266fc4f7fc576
+  data.tar.gz: 733e0e6687ca143de8a74214f13b4a78118333a99f89a9a09a9998ab0319768a
 SHA512:
-  metadata.gz: e96574a58740f8659f27947144bdc5067fbade1645a0b651e66607494fce5b0a16ef762bbba1638d54a8804425c2de2c3938884b4c18346be3623b4ffbdc821b
-  data.tar.gz: da673ecc866d1df2f6f75872df183beda957996fd54ff09177ebd84b27bc64fade88122eaaf34f7134e3a92d74b9d9f7a7322648042df444ad889de9a053d298
+  metadata.gz: d5dfc65c86e68d39b7c9bbeedd20e2a3ea844f158d601bb72bf35595e6d6597ac6571f7bc9ad6802f8ed33d6753b4906e7745a3e46cb38790492869aa95e6a02
+  data.tar.gz: 913032cb3a042e8b3464f05c7e0e65401f8532b28ded1cebd57df310899dcc8bd1bc26d9307a6b824837474c0e3ee9144477147779e0b40b6fd9c9fecfc7bddc

data/.yamllint

@@ -1,8 +1,6 @@
----
 extends: relaxed
-
 rules:
   indentation:
     indent-sequences: false
   line-length:
-    max: 120
+    max: 1000

data/CHANGELOG.md

@@ -4,6 +4,40 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [0.13.0] - 2024-08-12
+### Added
+- Choice rule payload validation path ([#253](https://github.com/ManageIQ/floe/pull/253))
+- Intrinsics JsonToString and StringToJson ([#256](https://github.com/ManageIQ/floe/pull/256))
+- Add States.Format intrinsic function ([#258](https://github.com/ManageIQ/floe/pull/258))
+- Intrinsics States.JsonMerge ([#255](https://github.com/ManageIQ/floe/pull/255))
+- Enable support for Hashes in States.Hash ([#260](https://github.com/ManageIQ/floe/pull/260))
+
+## [0.12.0] - 2024-07-31
+### Added
+- Set Floe.logger.level if DEBUG env var set ([#234](https://github.com/ManageIQ/floe/pull/234))
+- Add InstrinsicFunction foundation + States.Array, States.UUID ([#194](https://github.com/ManageIQ/floe/pull/194))
+- Evaluate IntrinsicFunctions from PayloadTemplate ([#236](https://github.com/ManageIQ/floe/pull/236))
+- Add more intrinsic functions ([#242](https://github.com/ManageIQ/floe/pull/242))
+- Add State#cause_path, error_path ([#249](https://github.com/ManageIQ/floe/pull/249))
+- Validate Catcher Next ([#250](https://github.com/ManageIQ/floe/pull/250))
+- Add spec/supports ([#248](https://github.com/ManageIQ/floe/pull/248))
+
+### Fixed
+- Handle non-hash input/output values ([#214](https://github.com/ManageIQ/floe/pull/214))
+- Fix Input/Output handling for Pass, Choice, Succeed states ([#225](https://github.com/ManageIQ/floe/pull/225))
+- Wrap Parslet::ParseFailed errors as Floe::InvalidWorkflowError ([#235](https://github.com/ManageIQ/floe/pull/235))
+- Fix edge cases with States.Array ([#237](https://github.com/ManageIQ/floe/pull/237))
+- Fix sporadic test failure with Wait state ([#243](https://github.com/ManageIQ/floe/pull/243))
+- Fix invalid container names after normalizing ([#252](https://github.com/ManageIQ/floe/pull/252))
+
+### Changed
+- Extract ErrorMatcherMixin from Catch and Retry ([#186](https://github.com/ManageIQ/floe/pull/186))
+- Output should be JSON ([#230](https://github.com/ManageIQ/floe/pull/230))
+- Normalize functions to all take arguments ([#238](https://github.com/ManageIQ/floe/pull/238))
+- Pass full path name to State.new for better errors ([#229](https://github.com/ManageIQ/floe/pull/229))
+- Validate that state machine input is valid JSON ([#227](https://github.com/ManageIQ/floe/pull/227))
+- Move the Parslet parse into initialize so that invalid function definition will fail on workflow load ([#245](https://github.com/ManageIQ/floe/pull/245))
+
 ## [0.11.3] - 2024-06-20
 ### Fixed
 - ResultPath=$ replaces complete output ([#199](https://github.com/ManageIQ/floe/pull/199))
@@ -199,7 +233,9 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - Initial release
 
-[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.11.3...HEAD
+[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.13.0...HEAD
+[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
 [0.11.3]: https://github.com/ManageIQ/floe/compare/v0.11.2...v0.11.3
 [0.11.2]: https://github.com/ManageIQ/floe/compare/v0.11.1...v0.11.2
 [0.11.1]: https://github.com/ManageIQ/floe/compare/v0.11.0...v0.11.1

data/floe.gemspec

@@ -36,11 +36,11 @@ Gem::Specification.new do |spec|
   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_development_dependency "manageiq-style"
+  spec.add_development_dependency "manageiq-style", ">= 1.5.2"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "rubocop"
   spec.add_development_dependency "simplecov", ">= 0.21.2"
   spec.add_development_dependency "timecop"
 end

data/lib/floe/cli.rb

@@ -7,6 +7,7 @@ module Floe
       require "logger"
 
       Floe.logger = Logger.new($stdout)
+      Floe.logger.level = 0 if ENV["DEBUG"]
     end
 
     def run(args = ARGV)
@@ -30,10 +31,12 @@ module Floe
       # Display status
       workflows.each do |workflow|
         puts "", "#{workflow.name}#{" (#{workflow.status})" unless workflow.context.success?}", "===" if workflows.size > 1
-        puts workflow.output.inspect
+        puts workflow.output
       end
 
       workflows.all? { |workflow| workflow.context.success? }
+    rescue Floe::Error => err
+      abort(err.message)
     end
 
     private

data/lib/floe/container_runner/docker_mixin.rb

@@ -24,6 +24,9 @@ module Floe
         # This does not follow the leading and trailing character restriction because we will embed it
         # below with a prefix and suffix that already conform to the RFC.
         normalized_name = name.downcase.gsub(/[^a-z0-9-]/, "-")[0, MAX_CONTAINER_NAME_SIZE]
+        # Ensure that the normalized_name doesn't end in any invalid characters after we
+        # limited the length to the MAX_CONTAINER_NAME_SIZE.
+        normalized_name.gsub!(/[^a-z0-9]+$/, "")
 
         "floe-#{normalized_name}-#{SecureRandom.hex(4)}"
       end

data/lib/floe/validation_mixin.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Floe
+  module ValidationMixin
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def parser_error!(comment)
+      self.class.parser_error!(name, comment)
+    end
+
+    def missing_field_error!(field_name)
+      self.class.missing_field_error!(name, field_name)
+    end
+
+    def invalid_field_error!(field_name, field_value = nil, comment = nil)
+      self.class.invalid_field_error!(name, field_name, field_value, comment)
+    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
+      invalid_field_error!(field_name, field_value, error.message)
+    end
+
+    module ClassMethods
+      def parser_error!(name, comment)
+        name = name.join(".") if name.kind_of?(Array)
+        raise Floe::InvalidWorkflowError, "#{name} #{comment}"
+      end
+
+      def missing_field_error!(name, field_name)
+        parser_error!(name, "does not have required field \"#{field_name}\"")
+      end
+
+      def invalid_field_error!(name, field_name, field_value, comment)
+        # 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}")
+      end
+    end
+  end
+end

data/lib/floe/version.rb

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

data/lib/floe/workflow/catcher.rb

@@ -3,14 +3,28 @@
 module Floe
   class Workflow
     class Catcher
-      attr_reader :error_equals, :next, :result_path
+      include ErrorMatcherMixin
+      include ValidationMixin
 
-      def initialize(payload)
-        @payload = payload
+      attr_reader :error_equals, :next, :result_path, :name
+
+      def initialize(workflow, name, payload)
+        @name         = name
+        @payload      = payload
 
         @error_equals = payload["ErrorEquals"]
         @next         = payload["Next"]
         @result_path  = ReferencePath.new(payload.fetch("ResultPath", "$"))
+
+        missing_field_error!("ErrorEquals") if !@error_equals.kind_of?(Array) || @error_equals.empty?
+        validate_state_next!(workflow)
+      end
+
+      private
+
+      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)
       end
     end
   end

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

@@ -5,14 +5,13 @@ module Floe
     class ChoiceRule
       class Data < Floe::Workflow::ChoiceRule
         def true?(context, input)
+          return presence_check(context, input) if compare_key == "IsPresent"
+
           lhs = variable_value(context, input)
           rhs = compare_value(context, input)
 
-          validate!(lhs)
-
           case compare_key
           when "IsNull" then is_null?(lhs)
-          when "IsPresent" then is_present?(lhs)
           when "IsNumeric" then is_numeric?(lhs)
           when "IsString" then is_string?(lhs)
           when "IsBoolean" then is_boolean?(lhs)
@@ -47,8 +46,21 @@ module Floe
 
         private
 
-        def validate!(value)
-          raise "No such variable [#{variable}]" if value.nil? && !%w[IsNull IsPresent].include?(compare_key)
+        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.
+          rhs = 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
+        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
         end
 
         def is_null?(value) # rubocop:disable Naming/PredicateName

data/lib/floe/workflow/choice_rule.rb

@@ -4,26 +4,31 @@ module Floe
   class Workflow
     class ChoiceRule
       class << self
-        def build(payload)
+        def build(workflow, name, payload)
           if (sub_payloads = payload["Not"])
-            Floe::Workflow::ChoiceRule::Not.new(payload, build_children([sub_payloads]))
+            name += ["Not"]
+            Floe::Workflow::ChoiceRule::Not.new(workflow, name, payload, build_children(workflow, name, [sub_payloads]))
           elsif (sub_payloads = payload["And"])
-            Floe::Workflow::ChoiceRule::And.new(payload, build_children(sub_payloads))
+            name += ["And"]
+            Floe::Workflow::ChoiceRule::And.new(workflow, name, payload, build_children(workflow, name, sub_payloads))
           elsif (sub_payloads = payload["Or"])
-            Floe::Workflow::ChoiceRule::Or.new(payload, build_children(sub_payloads))
+            name += ["Or"]
+            Floe::Workflow::ChoiceRule::Or.new(workflow, name, payload, build_children(workflow, name, sub_payloads))
           else
-            Floe::Workflow::ChoiceRule::Data.new(payload)
+            name += ["Data"]
+            Floe::Workflow::ChoiceRule::Data.new(workflow, name, payload)
           end
         end
 
-        def build_children(sub_payloads)
-          sub_payloads.map { |payload| build(payload) }
+        def build_children(workflow, name, sub_payloads)
+          sub_payloads.map.with_index { |payload, i| build(workflow, name + [i.to_s], payload) }
         end
       end
 
-      attr_reader :next, :payload, :variable, :children
+      attr_reader :next, :payload, :variable, :children, :name
 
-      def initialize(payload, children = nil)
+      def initialize(_workflow, name, payload, children = nil)
+        @name      = name
         @payload   = payload
         @children  = children
 

data/lib/floe/workflow/context.rb

@@ -9,9 +9,7 @@ module Floe
       # @param input [Hash] (default: {})
       def initialize(context = nil, input: nil, credentials: {})
         context = JSON.parse(context) if context.kind_of?(String)
-
-        input ||= {}
-        input = JSON.parse(input) if input.kind_of?(String)
+        input   = JSON.parse(input || "{}")
 
         @context = context || {}
         self["Execution"]          ||= {}
@@ -23,7 +21,7 @@ module Floe
 
         @credentials = credentials || {}
       rescue JSON::ParserError => err
-        raise Floe::InvalidWorkflowError, err.message
+        raise Floe::InvalidExecutionInput, "Invalid State Machine Execution Input: #{err}: was expecting (JSON String, Number, Array, Object or token 'null', 'true' or 'false')"
       end
 
       def execution
@@ -39,7 +37,7 @@ module Floe
       end
 
       def failed?
-        output&.key?("Error") || false
+        (output.kind_of?(Hash) && output.key?("Error")) || false
       end
 
       def ended?
@@ -54,10 +52,18 @@ module Floe
         state["Input"]
       end
 
+      def json_input
+        input.to_json
+      end
+
       def output
         state["Output"]
       end
 
+      def json_output
+        output.to_json
+      end
+
       def output=(val)
         state["Output"] = val
       end

data/lib/floe/workflow/error_matcher_mixin.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    # Methods for common error handling
+    module ErrorMatcherMixin
+      # @param [String] error the error thrown
+      def match_error?(error)
+        return false if error == "States.Runtime"
+        return true if error_equals.include?("States.ALL")
+        return true if error_equals.include?("States.Timeout") && error == "States.HeartbeatTimeout"
+
+        error_equals.include?(error)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+require "parslet"
+
+module Floe
+  class Workflow
+    class IntrinsicFunction
+      class Parser < Parslet::Parser
+        rule(:spaces)  { str(' ').repeat(1) }
+        rule(:spaces?) { spaces.maybe }
+        rule(:digit)   { match('[0-9]') }
+        rule(:quote)   { str('\'') }
+
+        rule(:comma_sep) { str(',') >> spaces? }
+
+        rule(:true_literal)  { str('true').as(:true_literal) }
+        rule(:false_literal) { str('false').as(:false_literal) }
+        rule(:null_literal)  { str('null').as(:null_literal) }
+
+        rule(:number) do
+          (
+            str('-').maybe >> (
+              str('0') | (match('[1-9]') >> digit.repeat)
+            ) >> (
+              str('.') >> digit.repeat(1)
+            ).maybe >> (
+              match('[eE]') >> (str('+') | str('-')).maybe >> digit.repeat(1)
+            ).maybe
+          ).as(:number)
+        end
+
+        rule(:string) do
+          (
+            quote >> (
+              (str('\\') >> any) | (quote.absent? >> any)
+            ).repeat >> quote
+          ).as(:string)
+        end
+
+        rule(:jsonpath) do
+          (
+            str('$') >> match('[^,)]').repeat(0)
+          ).as(:jsonpath)
+        end
+
+        rule(:arg) do
+          (
+            string | number | jsonpath | true_literal | false_literal | null_literal | expression
+          ).as(:arg)
+        end
+
+        rule(:args) do
+          (
+            arg >> (comma_sep >> arg).repeat
+          ).maybe.as(:args)
+        end
+
+        [
+          :states_format,          "States.Format",
+          :states_string_to_json,  "States.StringToJson",
+          :states_json_to_string,  "States.JsonToString",
+          :states_array,           "States.Array",
+          :states_array_partition, "States.ArrayPartition",
+          :states_array_contains,  "States.ArrayContains",
+          :states_array_range,     "States.ArrayRange",
+          :states_array_get_item,  "States.ArrayGetItem",
+          :states_array_length,    "States.ArrayLength",
+          :states_array_unique,    "States.ArrayUnique",
+          :states_base64_encode,   "States.Base64Encode",
+          :states_base64_decode,   "States.Base64Decode",
+          :states_hash,            "States.Hash",
+          :states_json_merge,      "States.JsonMerge",
+          :states_math_random,     "States.MathRandom",
+          :states_math_add,        "States.MathAdd",
+          :states_string_split,    "States.StringSplit",
+          :states_uuid,            "States.UUID",
+        ].each_slice(2) do |function_symbol, function_name|
+          rule(function_symbol) do
+            (
+              str(function_name) >> str('(') >> args >> str(')')
+            ).as(function_symbol)
+          end
+        end
+
+        rule(:expression) do
+          states_format |
+            states_string_to_json |
+            states_json_to_string |
+            states_array |
+            states_array_partition |
+            states_array_contains |
+            states_array_range |
+            states_array_get_item |
+            states_array_length |
+            states_array_unique |
+            states_base64_encode |
+            states_base64_decode |
+            states_hash |
+            states_json_merge |
+            states_math_random |
+            states_math_add |
+            states_string_split |
+            states_uuid
+        end
+
+        root(:expression)
+      end
+    end
+  end
+end