floe 0.12.0 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2eb195983f47d7cac44f18e962bf314c3ff4fefbdf3ac5cae32e960bfc2c0fb0
-  data.tar.gz: 6a0f8d91337297786c03e99fc96cb118ed8cb76244e52cf8253702d1517a6f5d
+  metadata.gz: 6fb1e855fda7d4a00a72e494b820a89304350945c14a71675d5cc6306e69f079
+  data.tar.gz: 9780e210073c41b4a5c534bdabd301c2df6275c13328dbb1ee43569470e8d590
 SHA512:
-  metadata.gz: 99f5a3c8e67a9f5c97b43795739c201a49a8f1195d40a1da38f2aa0e16d200266783336e4be9ada5d41b566c545144a4533db258546ebbf04a23c454a489e6a1
-  data.tar.gz: a77bfe436b37adf9dbdc2a279b9b1f70f48980062aaaec191a8e1fd57238e8b8b50b02828025e561c7ccb8429cb67fefb3f7ed044ed309d82eaae8dd8d9d407b
+  metadata.gz: bec5c7f6337c74258e185b76abfc3953f05ef16cf4de640972d23b7dfa81bf4439df3ce00dd539c618f7d18905d783bfa55dc777365e1a48969942b182448107
+  data.tar.gz: cf584d349c69927dec6945fe21d652b79e96f6228754b1a91a57b3241825661ed6d977a7d53e3ebfae526551da2a4a573148e9d855840d8edc52b8ebeffc948b

data/CHANGELOG.md

@@ -4,6 +4,23 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [0.13.1] - 2024-08-16
+### Fixed
+- Fix podman/docker container_ref trailing newline ([#265](https://github.com/ManageIQ/floe/pull/265))
+
+### Changed
+- Improve type check for States.Hash ([#261](https://github.com/ManageIQ/floe/pull/261))
+- Use Numeric over Integer || Float ([#264](https://github.com/ManageIQ/floe/pull/264))
+- In ChoiceRule::Data, parse compare key and variable ([#257](https://github.com/ManageIQ/floe/pull/257))
+
+## [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))
@@ -225,7 +242,9 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - Initial release
 
-[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.12.0...HEAD
+[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.13.1...HEAD
+[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
 [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

data/lib/floe/container_runner/docker.rb

@@ -129,7 +129,7 @@ module Floe
         logger.debug("Running #{AwesomeSpawn.build_command_line(self.class::DOCKER_COMMAND, params)}")
 
         result = docker!(*params)
-        result.output
+        result.output.chomp
       end
 
       def run_container_params(image, env, secrets_file)

data/lib/floe/version.rb

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

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

@@ -4,15 +4,26 @@ 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
+
+        attr_reader :variable, :compare_key, :value, :path
+
+        def initialize(_workflow, _name, payload)
+          super
+
+          @variable = parse_path("Variable", payload)
+          parse_compare_key
+          @value = path ? parse_path(compare_key, payload) : payload[compare_key]
+        end
+
         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 +58,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
@@ -60,7 +84,7 @@ module Floe
         end
 
         def is_numeric?(value) # rubocop:disable Naming/PredicateName
-          value.kind_of?(Integer) || value.kind_of?(Float)
+          value.kind_of?(Numeric)
         end
 
         def is_string?(value) # rubocop:disable Naming/PredicateName
@@ -80,12 +104,25 @@ module Floe
           false
         end
 
-        def compare_key
-          @compare_key ||= payload.keys.detect { |key| key.match?(/^(IsNull|IsPresent|IsNumeric|IsString|IsBoolean|IsTimestamp|String|Numeric|Boolean|Timestamp)/) }
+        def parse_compare_key
+          @compare_key = payload.keys.detect { |key| key.match?(/^(#{COMPARE_KEYS.join("|")})/) }
+          parser_error!("requires a compare key") unless compare_key
+
+          @path = compare_key.end_with?("Path")
         end
 
         def compare_value(context, input)
-          compare_key.end_with?("Path") ? Path.value(payload[compare_key], context, input) : payload[compare_key]
+          path ? value.value(context, input) : value
+        end
+
+        def variable_value(context, input)
+          variable.value(context, input)
+        end
+
+        def parse_path(field_name, payload)
+          value = payload[field_name]
+          missing_field_error!(field_name) unless value
+          wrap_parser_error(field_name, value) { Path.new(value) }
         end
       end
     end

data/lib/floe/workflow/choice_rule.rb

@@ -3,6 +3,8 @@
 module Floe
   class Workflow
     class ChoiceRule
+      include ValidationMixin
+
       class << self
         def build(workflow, name, payload)
           if (sub_payloads = payload["Not"])
@@ -25,15 +27,15 @@ module Floe
         end
       end
 
-      attr_reader :next, :payload, :variable, :children, :name
+      attr_reader :next, :payload, :children, :name
 
-      def initialize(_workflow, name, payload, children = nil)
+      def initialize(workflow, name, payload, children = nil)
         @name      = name
         @payload   = payload
         @children  = children
+        @next      = payload["Next"]
 
-        @next     = payload["Next"]
-        @variable = payload["Variable"]
+        validate_next!(workflow)
       end
 
       def true?(*)
@@ -42,8 +44,31 @@ module Floe
 
       private
 
-      def variable_value(context, input)
-        Path.value(variable, context, input)
+      def validate_next!(workflow)
+        if is_child?
+          # non-top level nodes don't allow a next
+          invalid_field_error!("Next", @next, "not allowed in a child rule") if @next
+        elsif !@next
+          # top level nodes require a next
+          missing_field_error!("Next")
+        elsif !workflow_state?(@next, workflow)
+          # top level nodes require a next field that is found
+          invalid_field_error!("Next", @next, "is not found in \"States\"")
+        end
+      end
+
+      # returns true if this is a child rule underneath an And/Or/Not
+      # {
+      #   "Or": [
+      #     {"Variable": "$.foo", "IsString": true},
+      #     {"Variable": "$.foo", "IsBoolean": true}
+      #   ], "Next": "Finished"
+      # }
+      #
+      # The Or node, has no conjunction parent, so it is not a child (requires a Next)
+      # The 2 Data nodes have a conjunction parent, so each one is a child (do not allow a Next)
+      def is_child? # rubocop:disable Naming/PredicateName
+        !(%w[And Or Not] & name[0..-2]).empty?
       end
     end
   end

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

@@ -54,6 +54,9 @@ module Floe
         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",
@@ -64,6 +67,7 @@ module Floe
           :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",
@@ -77,7 +81,10 @@ module Floe
         end
 
         rule(:expression) do
-          states_array |
+          states_format |
+            states_string_to_json |
+            states_json_to_string |
+            states_array |
             states_array_partition |
             states_array_contains |
             states_array_range |
@@ -87,6 +94,7 @@ module Floe
             states_base64_encode |
             states_base64_decode |
             states_hash |
+            states_json_merge |
             states_math_random |
             states_math_add |
             states_string_split |

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

@@ -9,6 +9,7 @@ module Floe
     class IntrinsicFunction
       class Transformer < Parslet::Transform
         OptionalArg = Struct.new(:type)
+        VariadicArgs = Struct.new(:type)
 
         class << self
           def process_args(args, function, signature = nil)
@@ -37,20 +38,33 @@ module Floe
 
           def check_arity(args, function, signature)
             if signature.any?(OptionalArg)
-              signature_without_optional = signature.reject { |a| a.kind_of?(OptionalArg) }
-              signature_size = (signature_without_optional.size..signature.size)
+              signature_required = signature.reject { |a| a.kind_of?(OptionalArg) }
+              signature_size = (signature_required.size..signature.size)
 
               raise ArgumentError, "wrong number of arguments to #{function} (given #{args.size}, expected #{signature_size})" unless signature_size.include?(args.size)
+            elsif signature.any?(VariadicArgs)
+              signature_required = signature.reject { |a| a.kind_of?(VariadicArgs) }
+
+              raise ArgumentError, "wrong number of arguments to #{function} (given #{args.size}, expected at least #{signature_required.size})" unless args.size >= signature_required.size
             else
               raise ArgumentError, "wrong number of arguments to #{function} (given #{args.size}, expected #{signature.size})" unless signature.size == args.size
             end
           end
 
           def check_types(args, function, signature)
+            # Adjust the signature for VariadicArgs to create a copy of the expected type for each given arg
+            if signature.last.kind_of?(VariadicArgs)
+              signature = signature[0..-2] + Array.new(args.size - signature.size + 1, signature.last.type)
+            end
+
             args.zip(signature).each_with_index do |(arg, type), index|
               type = type.type if type.kind_of?(OptionalArg)
 
-              raise ArgumentError, "wrong type for argument #{index + 1} to #{function} (given #{arg.class}, expected #{type})" unless arg.kind_of?(type)
+              if type.kind_of?(Array)
+                raise ArgumentError, "wrong type for argument #{index + 1} to #{function} (given #{arg.class}, expected one of #{type.join(", ")})" unless type.any? { |t| arg.kind_of?(t) }
+              else
+                raise ArgumentError, "wrong type for argument #{index + 1} to #{function} (given #{arg.class}, expected #{type})" unless arg.kind_of?(type)
+              end
             end
           end
         end
@@ -63,6 +77,50 @@ 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
+
+        rule(:states_format => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.Format", [String, VariadicArgs[[String, TrueClass, FalseClass, Numeric, NilClass]]])
+          str, *rest = *args
+
+          # TODO: Handle templates with escaped characters, including invalid templates
+          #   See https://states-language.net/#intrinsic-functions (number 6)
+
+          expected_args = str.scan(STATES_FORMAT_PLACEHOLDER).size
+          actual_args = rest.size
+          if expected_args != actual_args
+            raise ArgumentError, "number of arguments to States.Format do not match the occurrences of {} (given #{actual_args}, expected #{expected_args})"
+          end
+
+          rest.each do |arg|
+            str = str.sub(STATES_FORMAT_PLACEHOLDER, arg.nil? ? "null" : arg.to_s)
+          end
+
+          # TODO: Handle arguments that have escape characters within them but are interpolated
+          str.gsub!("\\'", "'")
+          str.gsub!("\\{", "{")
+          str.gsub!("\\}", "}")
+          str.gsub!("\\\\", "\\")
+
+          str
+        end
+
+        rule(:states_json_to_string => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.JsonToString", [Object])
+          json = args.first
+
+          JSON.generate(json)
+        end
+
+        rule(:states_string_to_json => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.StringToJson", [String])
+          str = args.first
+
+          JSON.parse(str)
+        rescue JSON::ParserError => e
+          raise ArgumentError, "invalid value for argument 1 to States.StringToJson (invalid json: #{e.message})"
+        end
+
         rule(:states_array => {:args => subtree(:args)}) do
           Transformer.process_args(args, "States.Array")
         end
@@ -133,12 +191,8 @@ module Floe
         end
 
         rule(:states_hash => {:args => subtree(:args)}) do
-          args = Transformer.process_args(args(), "States.Hash", [Object, String])
+          args = Transformer.process_args(args(), "States.Hash", [[String, TrueClass, FalseClass, Numeric, Array, Hash], String])
           data, algorithm = *args
-          raise NotImplementedError if data.kind_of?(Hash)
-          if data.nil?
-            raise ArgumentError, "invalid value for argument 1 to States.Hash (given null, expected non-null)"
-          end
 
           algorithms = %w[MD5 SHA-1 SHA-256 SHA-384 SHA-512]
           unless algorithms.include?(algorithm)
@@ -147,8 +201,20 @@ module Floe
 
           require "openssl"
           algorithm = algorithm.sub("-", "")
-          data = data.to_json unless data.kind_of?(String)
-          OpenSSL::Digest.hexdigest(algorithm, data)
+          data = JSON.generate(data) unless data.kind_of?(String)
+          OpenSSL::Digest.hexdigest(algorithm, data).force_encoding("UTF-8")
+        end
+
+        rule(:states_json_merge => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.JsonMerge", [Hash, Hash, [TrueClass, FalseClass]])
+          left, right, deep = *args
+
+          if deep
+            # NOTE: not implemented by AWS Step Functions and nuances not defined in docs
+            left.merge(right) { |_key, l, r| l.kind_of?(Hash) && r.kind_of?(Hash) ? l.merge(r) : r }
+          else
+            left.merge(right)
+          end
         end
 
         rule(:states_math_random => {:args => subtree(:args)}) do

data/lib/floe/workflow/path.rb

@@ -34,7 +34,18 @@ module Floe
         return obj if path == "$"
 
         results = JsonPath.on(obj, path)
-        results.count < 2 ? results.first : results
+        case results.count
+        when 0
+          raise Floe::PathError, "Path [#{payload}] references an invalid value"
+        when 1
+          results.first
+        else
+          results
+        end
+      end
+
+      def to_s
+        payload
       end
     end
   end

data/lib/floe/workflow/state.rb

@@ -48,17 +48,27 @@ module Floe
         return Errno::EAGAIN unless ready?(context)
 
         finish(context)
+      rescue Floe::Error => e
+        mark_error(context, e)
       end
 
       def start(context)
+        mark_started(context)
+      end
+
+      def finish(context)
+        mark_finished(context)
+      end
+
+      def mark_started(context)
         context.state["EnteredTime"] = Time.now.utc.iso8601
 
         logger.info("Running state: [#{long_name}] with input [#{context.json_input}]...")
       end
 
-      def finish(context)
-        finished_time     = Time.now.utc
-        entered_time      = Time.parse(context.state["EnteredTime"])
+      def mark_finished(context)
+        finished_time = Time.now.utc
+        entered_time  = Time.parse(context.state["EnteredTime"])
 
         context.state["FinishedTime"] ||= finished_time.iso8601
         context.state["Duration"]       = finished_time - entered_time
@@ -69,6 +79,14 @@ module Floe
         0
       end
 
+      def mark_error(context, exception)
+        # InputPath or OutputPath were bad.
+        context.next_state = nil
+        context.output     = {"Error" => "States.Runtime", "Cause" => exception.message}
+        # Since finish threw an exception, super was never called. Calling that now.
+        mark_finished(context)
+      end
+
       def ready?(context)
         !context.state_started? || !running?(context)
       end

data/lib/floe.rb

@@ -43,6 +43,7 @@ module Floe
   class Error < StandardError; end
   class InvalidWorkflowError < Error; end
   class InvalidExecutionInput < Error; end
+  class PathError < Error; end
 
   def self.logger
     @logger ||= NullLogger.new

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: floe
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.1
 platform: ruby
 authors:
 - ManageIQ Developers
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-01 00:00:00.000000000 Z
+date: 2024-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_spawn