floe 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abe15498a790293b2a375c4538ed649bfa577edd1b7eaa38d02266fc4f7fc576
-  data.tar.gz: 733e0e6687ca143de8a74214f13b4a78118333a99f89a9a09a9998ab0319768a
+  metadata.gz: e0e0b86c08d322e2ebc8e115e5193d0493f8257c831f7377b18c32d4284ae6f2
+  data.tar.gz: 1bf5ed62abafe2e1af6025dbaf47d9faa3b1c93ffec8fd88fbeacd4445efc795
 SHA512:
-  metadata.gz: d5dfc65c86e68d39b7c9bbeedd20e2a3ea844f158d601bb72bf35595e6d6597ac6571f7bc9ad6802f8ed33d6753b4906e7745a3e46cb38790492869aa95e6a02
-  data.tar.gz: 913032cb3a042e8b3464f05c7e0e65401f8532b28ded1cebd57df310899dcc8bd1bc26d9307a6b824837474c0e3ee9144477147779e0b40b6fd9c9fecfc7bddc
+  metadata.gz: 34f64555f2472c121fcea9dda8baac7fbe853cdbc5e949c831d7b7f070878d3ef2f86ed90d907b5a7033539fcad6aeea64a4dee6475a752d7f89e4f679a4b269
+  data.tar.gz: 378c5bcd562d4bbeb7e3eb13eb55b1d5d8e7aed0ea4749c2b65f951cf3be0e5f13d3e288cdbf63b4a5729e98c5010656d6dca3db60ffbf8463988008980edd83

data/CHANGELOG.md

@@ -4,6 +4,22 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [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))
+
+### 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))
@@ -233,7 +249,9 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - Initial release
 
-[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.13.0...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
 [0.11.3]: https://github.com/ManageIQ/floe/compare/v0.11.2...v0.11.3

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,22 +123,23 @@ 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)}")
 
         result = docker!(*params)
-        result.output
+        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.0"
+  VERSION = "0.14.0"
 end

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

@@ -4,6 +4,18 @@ 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"
 
@@ -11,11 +23,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",
@@ -50,54 +62,71 @@ 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?(Integer) || value.kind_of?(Float)
+        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
 
-        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/transformer.rb

@@ -80,7 +80,7 @@ module Floe
         STATES_FORMAT_PLACEHOLDER = /(?<!\\)\{\}/.freeze
 
         rule(:states_format => {:args => subtree(:args)}) do
-          args = Transformer.process_args(args(), "States.Format", [String, VariadicArgs[[String, TrueClass, FalseClass, Integer, Float, NilClass]]])
+          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
@@ -191,13 +191,9 @@ 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
 
-          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)
             raise ArgumentError, "invalid value for argument 2 to States.Hash (given #{algorithm.inspect}, expected one of #{algorithms.map(&:inspect).join(", ")})"

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

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

@@ -23,6 +23,7 @@ module Floe
           output     = output_path.value(context, input)
           next_state = choices.detect { |choice| choice.true?(context, output) }&.next || default
 
+          runtime_field_error!("Default", nil, "not defined and no match found", :floe_error => "States.NoChoiceMatched") if next_state.nil?
           context.next_state = next_state
           context.output     = output
           super

data/lib/floe/workflow.rb

@@ -63,9 +63,11 @@ module Floe
 
           loop do
             # Block until an event is raised
-            event, runner_context = queue.pop
+            event, data = queue.pop
             break if event.nil?
 
+            _execution_id, runner_context = data.values_at("execution_id", "runner_context")
+
             # If the event is for one of our workflows set the updated runner_context
             workflows.each do |workflow|
               next unless workflow.context.state.dig("RunnerContext", "container_ref") == runner_context["container_ref"]
@@ -175,7 +177,7 @@ module Floe
       context.state["Input"] = context.execution["Input"].dup
       context.state["Guid"]  = SecureRandom.uuid
 
-      context.execution["Id"]        = SecureRandom.uuid
+      context.execution["Id"]      ||= SecureRandom.uuid
       context.execution["StartTime"] = Time.now.utc.iso8601
 
       self

data/lib/floe.rb

@@ -43,7 +43,18 @@ module Floe
   class Error < StandardError; end
   class InvalidWorkflowError < Error; end
   class InvalidExecutionInput < Error; end
-  class PathError < Error; end
+
+  class ExecutionError < Error
+    attr_reader :floe_error
+
+    def initialize(message, floe_error = "States.Runtime")
+      super(message)
+      @floe_error = floe_error
+    end
+  end
+
+  class PathError < ExecutionError
+  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.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - ManageIQ Developers
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-12 00:00:00.000000000 Z
+date: 2024-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_spawn