floe 0.11.2 → 0.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 302eabcce76893426ed95920bff11ed2bba9956a7d006249d86212e30c5cc67c
-  data.tar.gz: 4148b20da8ef81e6e45a4ec73489cdcf956115d1f99535019aef3b561ed45e00
+  metadata.gz: cb1a786256a191ba7d1b3b08f6e3cd02fa778fcf28ab44a7353f36ae7979039b
+  data.tar.gz: ca5ab5d0b5ed1949945593bb1f07141e554fbbac4d825cbf6333bb92e5b17b6d
 SHA512:
-  metadata.gz: 73a1a714b1d729af89dd9839655955f76c3ed69fa8814e230fc03746175d1ff243b8b58fd02dce272d683b39fe50cd88c1c3a7f05cd2e36e9aa070747f85ae6f
-  data.tar.gz: bf13a6c8f07a5918e78d99bb5a03c29b3a76e059c92cd6f3fec85dd64b1d701138a16a9c0e6df10ed820f4f97ef932152f1d0a61b38a60d3d344728da9ec33c7
+  metadata.gz: e96574a58740f8659f27947144bdc5067fbade1645a0b651e66607494fce5b0a16ef762bbba1638d54a8804425c2de2c3938884b4c18346be3623b4ffbdc821b
+  data.tar.gz: da673ecc866d1df2f6f75872df183beda957996fd54ff09177ebd84b27bc64fade88122eaaf34f7134e3a92d74b9d9f7a7322648042df444ad889de9a053d298

data/.codeclimate.yml

@@ -0,0 +1,16 @@
+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
+plugins:
+  rubocop:
+    enabled: true
+    config: ".rubocop_cc.yml"
+    channel: rubocop-1-56-3
+version: '2'

data/CHANGELOG.md

@@ -4,6 +4,28 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [0.11.3] - 2024-06-20
+### Fixed
+- ResultPath=$ replaces complete output ([#199](https://github.com/ManageIQ/floe/pull/199))
+- Fix retrier backoff values ([#200](https://github.com/ManageIQ/floe/pull/200))
+- Fix Retry issues ([#202](https://github.com/ManageIQ/floe/pull/202))
+- Add Apache-2.0 license ([#217](https://github.com/ManageIQ/floe/pull/217))
+
+### Changed
+- Update gemspec summary ([#205](https://github.com/ManageIQ/floe/pull/205))
+- Simpler State#long_name ([#204](https://github.com/ManageIQ/floe/pull/204))
+- State only modifies Context#state - prep for Map/Parallel ([#206](https://github.com/ManageIQ/floe/pull/206))
+- Set StateHistory in Workflow not State ([#211](https://github.com/ManageIQ/floe/pull/211))
+- Make Runner#wait optional ([#190](https://github.com/ManageIQ/floe/pull/190))
+- Pass credentials around with context ([#203](https://github.com/ManageIQ/floe/pull/203))
+- Pass context to State without workflow ([#216](https://github.com/ManageIQ/floe/pull/216))
+- Move the guts of the CLI into a class for easy testing ([#220](https://github.com/ManageIQ/floe/pull/220))
+
+### Added
+- Set State PreviousStateGuid in StateHistory ([#208](https://github.com/ManageIQ/floe/pull/208))
+- Add a codeclimate config file ([#224](https://github.com/ManageIQ/floe/pull/224))
+- Add an Execution unique ID to Context ([#226](https://github.com/ManageIQ/floe/pull/226))
+
 ## [0.11.2] - 2024-05-24
 ### Fixed
 - Output now based upon raw input not effective input ([#191](https://github.com/ManageIQ/floe/pull/191))
@@ -177,7 +199,8 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - Initial release
 
-[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.11.2...HEAD
+[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.11.3...HEAD
+[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
 [0.11.0]: https://github.com/ManageIQ/floe/compare/v0.10.0...v0.11.0

data/Gemfile

@@ -3,7 +3,7 @@
 source "https://rubygems.org"
 
 plugin "bundler-inject", "~> 2.0"
-require File.join(Bundler::Plugin.index.load_paths("bundler-inject")[0], "bundler-inject") rescue nil
+require File.join(Bundler::Plugin.index.load_paths("bundler-inject")[0], "bundler-inject") rescue nil # rubocop:disable Style/RescueModifier
 
 # Specify your gem's dependencies in floe.gemspec
 gemspec

data/LICENSE.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -148,7 +148,7 @@ until running_workflows.empty?
   ready_workflows = Floe::Workflow.wait(running_workflows)
   # Step through the ready workflows until they would block
   ready_workflows.each do |workflow|
-    loop while workflow.step_nonblock == 0
+    workflow.run_nonblock
   end
   # Remove any finished workflows from the list of running_workflows
   running_workflows.reject!(&:end?)
@@ -206,3 +206,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/ManageIQ/floe.
+
+## License
+
+The gem is available as open source under the terms of the [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0).

data/exe/floe

@@ -3,75 +3,6 @@
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 
-require "optimist"
-require "floe"
-require "floe/container_runner"
-
-opts = Optimist.options do
-  version("v#{Floe::VERSION}\n")
-  usage("[options] workflow input [workflow2 input2]")
-
-  opt :workflow, "Path to your workflow json file (alternative to passing a bare workflow)", :type => :string
-  opt :input, <<~EOMSG, :type => :string
-    JSON payload of the Input to the workflow
-      If --input is passed and --workflow is not passed, will be used for all bare workflows listed.
-      If --input is not passed and --workflow is passed, defaults to '{}'.
-  EOMSG
-  opt :context, "JSON payload of the Context",              :type => :string
-  opt :credentials, "JSON payload with Credentials",        :type => :string
-  opt :credentials_file, "Path to a file with Credentials", :type => :string
-
-  Floe::ContainerRunner.cli_options(self)
-
-  banner("")
-  banner("General options:")
-end
-
-# Create workflow/input pairs from the various combinations of paramaters
-args =
-  if opts[:workflow_given]
-    Optimist.die("cannot specify both --workflow and bare workflows") if ARGV.any?
-
-    [opts[:workflow], opts.fetch(:input, "{}")]
-  elsif opts[:input_given]
-    Optimist.die("workflow(s) must be specified") if ARGV.empty?
-
-    ARGV.flat_map { |w| [w, opts[:input].dup] }
-  else
-    Optimist.die("workflow/input pairs must be specified") if ARGV.empty? || (ARGV.size > 1 && ARGV.size.odd?)
-
-    ARGV
-  end
-
-Floe::ContainerRunner.resolve_cli_options!(opts)
-
-require "logger"
-Floe.logger = Logger.new($stdout)
-
-credentials =
-  if opts[:credentials_given]
-    opts[:credentials] == "-" ? $stdin.read : opts[:credentials]
-  elsif opts[:credentials_file_given]
-    File.read(opts[:credentials_file])
-  end
-
-workflows =
-  args.each_slice(2).map do |workflow, input|
-    context = Floe::Workflow::Context.new(opts[:context], :input => input)
-    Floe::Workflow.load(workflow, context, credentials)
-  end
-
-# run
-
-Floe::Workflow.wait(workflows, &:run_nonblock)
-
-# display status
-
-workflows.each do |workflow|
-  puts "", "#{workflow.name}#{" (#{workflow.status})" unless workflow.context.success?}", "===" if workflows.size > 1
-  puts workflow.output.inspect
-end
-
-# exit status
-
-exit workflows.all? { |workflow| workflow.context.success? } ? 0 : 1
+require "floe/cli"
+success = Floe::CLI.new.run(ARGV)
+exit(success ? 0 : 1)

data/floe.gemspec

@@ -7,9 +7,10 @@ Gem::Specification.new do |spec|
   spec.version = Floe::VERSION
   spec.authors = ["ManageIQ Developers"]
 
-  spec.summary = "Simple Workflow Runner."
-  spec.description = "Simple Workflow Runner."
+  spec.summary = "Floe is a runner for Amazon States Language workflows."
+  spec.description = spec.summary
   spec.homepage = "https://github.com/ManageIQ/floe"
+  spec.licenses = ["Apache-2.0"]
   spec.required_ruby_version = ">= 2.7.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"

data/lib/floe/cli.rb

@@ -0,0 +1,83 @@
+module Floe
+  class CLI
+    def initialize
+      require "optimist"
+      require "floe"
+      require "floe/container_runner"
+      require "logger"
+
+      Floe.logger = Logger.new($stdout)
+    end
+
+    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
+
+      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)
+        end
+
+      Floe::Workflow.wait(workflows, &:run_nonblock)
+
+      # Display status
+      workflows.each do |workflow|
+        puts "", "#{workflow.name}#{" (#{workflow.status})" unless workflow.context.success?}", "===" if workflows.size > 1
+        puts workflow.output.inspect
+      end
+
+      workflows.all? { |workflow| workflow.context.success? }
+    end
+
+    private
+
+    def parse_options!(args)
+      opts = Optimist.options(args) do
+        version("v#{Floe::VERSION}\n")
+        usage("[options] workflow input [workflow2 input2]")
+
+        opt :workflow, "Path to your workflow json file (alternative to passing a bare workflow)", :type => :string
+        opt :input, <<~EOMSG, :type => :string
+          JSON payload of the Input to the workflow
+            If --input is passed and --workflow is not passed, will be used for all bare workflows listed.
+            If --input is not passed and --workflow is passed, defaults to '{}'.
+        EOMSG
+        opt :context, "JSON payload of the Context",              :type => :string
+        opt :credentials, "JSON payload with Credentials",        :type => :string
+        opt :credentials_file, "Path to a file with Credentials", :type => :string
+
+        Floe::ContainerRunner.cli_options(self)
+
+        banner("")
+        banner("General options:")
+      end
+
+      # Create workflow/input pairs from the various combinations of paramaters
+      workflows_inputs =
+        if opts[:workflow_given]
+          Optimist.die("cannot specify both --workflow and bare workflows") if args.any?
+
+          [opts[:workflow], opts.fetch(:input, "{}")]
+        elsif opts[:input_given]
+          Optimist.die("workflow(s) must be specified") if args.empty?
+
+          args.flat_map { |w| [w, opts[:input].dup] }
+        else
+          Optimist.die("workflow/input pairs must be specified") if args.empty? || (args.size > 1 && args.size.odd?)
+
+          args
+        end
+
+      Floe::ContainerRunner.resolve_cli_options!(opts)
+
+      return workflows_inputs, opts
+    end
+  end
+end

data/lib/floe/runner.rb

@@ -6,7 +6,7 @@ module Floe
 
     OUTPUT_MARKER = "__FLOE_OUTPUT__\n"
 
-    def initialize(_options = {})
+    def initialize(_options = {}) # rubocop:disable Style/RedundantInitialize
     end
 
     @runners = {}
@@ -75,8 +75,13 @@ module Floe
       raise NotImplementedError, "Must be implemented in a subclass"
     end
 
-    def wait(timeout: nil, events: %i[create update delete])
-      raise NotImplementedError, "Must be implemented in a subclass"
-    end
+    # Optional Watcher for events that is run in another thread.
+    #
+    # @yield [event, runner_context]
+    # @yieldparam [Symbol] event values: :create :update :delete :unknown
+    # @yieldparam [Hash] runner_context context provided by runner
+    # def wait(timeout: nil, events: %i[create update delete])
+    #   raise NotImplementedError, "Must be implemented in a subclass"
+    # end
   end
 end

data/lib/floe/version.rb

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

data/lib/floe/workflow/context.rb

@@ -3,9 +3,11 @@
 module Floe
   class Workflow
     class Context
+      attr_accessor :credentials
+
       # @param context [Json|Hash] (default, create another with input and execution params)
       # @param input [Hash] (default: {})
-      def initialize(context = nil, input: nil)
+      def initialize(context = nil, input: nil, credentials: {})
         context = JSON.parse(context) if context.kind_of?(String)
 
         input ||= {}
@@ -18,6 +20,10 @@ module Floe
         self["StateHistory"]       ||= []
         self["StateMachine"]       ||= {}
         self["Task"]               ||= {}
+
+        @credentials = credentials || {}
+      rescue JSON::ParserError => err
+        raise Floe::InvalidWorkflowError, err.message
       end
 
       def execution
@@ -84,6 +90,16 @@ module Floe
         status == "success"
       end
 
+      def state_started?
+        state.key?("EnteredTime")
+      end
+
+      # State#running? also checks docker to see if it is running.
+      # You possibly want to use that instead
+      def state_finished?
+        state.key?("FinishedTime")
+      end
+
       def state=(val)
         @context["State"] = val
       end

data/lib/floe/workflow/reference_path.rb

@@ -25,12 +25,9 @@ module Floe
       def set(context, value)
         result = context.dup
 
-        # If the payload is '$' then merge the value into the context
-        # otherwise store the value under the path
-        #
-        # TODO: how to handle non-hash values, raise error if path=$ and value not a hash?
+        # If the payload is '$' then replace the output with the value
         if path.empty?
-          result.merge!(value)
+          result = value.dup
         else
           child    = result
           keys     = path.dup

data/lib/floe/workflow/retrier.rb

@@ -14,8 +14,9 @@ module Floe
         @backoff_rate     = payload["BackoffRate"] || 2.0
       end
 
+      # @param [Integer] attempt 1 for the first attempt
       def sleep_duration(attempt)
-        interval_seconds * (backoff_rate * attempt)
+        interval_seconds * (backoff_rate**(attempt - 1))
       end
     end
   end

data/lib/floe/workflow/state.rb

@@ -20,95 +20,79 @@ module Floe
         end
       end
 
-      attr_reader :workflow, :comment, :name, :type, :payload
+      attr_reader :comment, :name, :type, :payload
 
       def initialize(workflow, name, payload)
-        @workflow = workflow
         @name     = name
         @payload  = payload
         @type     = payload["Type"]
         @comment  = payload["Comment"]
 
         raise Floe::InvalidWorkflowError, "Missing \"Type\" field in state [#{name}]" if payload["Type"].nil?
-        raise Floe::InvalidWorkflowError, "State name [#{name}] must be less than or equal to 80 characters" if name.length > 80
+        raise Floe::InvalidWorkflowError, "State name [#{name[..79]}...] must be less than or equal to 80 characters" if name.length > 80
       end
 
-      def wait(timeout: nil)
+      def wait(context, timeout: nil)
         start = Time.now.utc
 
         loop do
-          return 0             if ready?
+          return 0             if ready?(context)
           return Errno::EAGAIN if timeout && (timeout.zero? || Time.now.utc - start > timeout)
 
           sleep(1)
         end
       end
 
-      def run_nonblock!
-        start(context.input) unless started?
-        return Errno::EAGAIN unless ready?
+      # @return for incomplete Errno::EAGAIN, for completed 0
+      def run_nonblock!(context)
+        start(context) unless context.state_started?
+        return Errno::EAGAIN unless ready?(context)
 
-        finish
+        finish(context)
       end
 
-      def start(_input)
-        start_time = Time.now.utc.iso8601
-
-        context.execution["StartTime"] ||= start_time
-        context.state["Guid"]            = SecureRandom.uuid
-        context.state["EnteredTime"]     = start_time
+      def start(context)
+        context.state["EnteredTime"] = Time.now.utc.iso8601
 
         logger.info("Running state: [#{long_name}] with input [#{context.input}]...")
       end
 
-      def finish
+      def finish(context)
         finished_time     = Time.now.utc
-        finished_time_iso = finished_time.iso8601
         entered_time      = Time.parse(context.state["EnteredTime"])
 
-        context.state["FinishedTime"] ||= finished_time_iso
+        context.state["FinishedTime"] ||= finished_time.iso8601
         context.state["Duration"]       = finished_time - entered_time
-        context.execution["EndTime"]    = finished_time_iso if context.next_state.nil?
 
         level = context.output&.[]("Error") ? :error : :info
         logger.public_send(level, "Running state: [#{long_name}] with input [#{context.input}]...Complete #{context.next_state ? "- next state [#{context.next_state}]" : "workflow -"} output: [#{context.output}]")
 
-        context.state_history << context.state
-
         0
       end
 
-      def context
-        workflow.context
-      end
-
-      def started?
-        context.state.key?("EnteredTime")
-      end
-
-      def ready?
-        !started? || !running?
+      def ready?(context)
+        !context.state_started? || !running?(context)
       end
 
-      def finished?
-        context.state.key?("FinishedTime")
+      def running?(context)
+        raise NotImplementedError, "Must be implemented in a subclass"
       end
 
-      def waiting?
+      def waiting?(context)
         context.state["WaitUntil"] && Time.now.utc <= Time.parse(context.state["WaitUntil"])
       end
 
-      def wait_until
+      def wait_until(context)
         context.state["WaitUntil"] && Time.parse(context.state["WaitUntil"])
       end
 
       def long_name
-        "#{self.class.name.split("::").last}:#{name}"
+        "#{@type}:#{name}"
       end
 
       private
 
-      def wait_until!(seconds: nil, time: nil)
+      def wait_until!(context, seconds: nil, time: nil)
         context.state["WaitUntil"] =
           if seconds
             (Time.parse(context.state["EnteredTime"]) + seconds).iso8601

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

@@ -9,7 +9,7 @@ module Floe
         def initialize(workflow, name, payload)
           super
 
-          validate_state!
+          validate_state!(workflow)
 
           @choices = payload["Choices"].map { |choice| ChoiceRule.build(choice) }
           @default = payload["Default"]
@@ -18,7 +18,7 @@ module Floe
           @output_path = Path.new(payload.fetch("OutputPath", "$"))
         end
 
-        def finish
+        def finish(context)
           output     = output_path.value(context, context.input)
           next_state = choices.detect { |choice| choice.true?(context, output) }&.next || default
 
@@ -27,7 +27,7 @@ module Floe
           super
         end
 
-        def running?
+        def running?(_)
           false
         end
 
@@ -37,9 +37,9 @@ module Floe
 
         private
 
-        def validate_state!
+        def validate_state!(workflow)
           validate_state_choices!
-          validate_state_default!
+          validate_state_default!(workflow)
         end
 
         def validate_state_choices!
@@ -47,7 +47,7 @@ module Floe
           raise Floe::InvalidWorkflowError, "\"Choices\" must be a non-empty array" unless payload["Choices"].kind_of?(Array) && !payload["Choices"].empty?
         end
 
-        def validate_state_default!
+        def validate_state_default!(workflow)
           raise Floe::InvalidWorkflowError, "\"Default\" not in \"States\"" unless workflow.payload["States"].include?(payload["Default"])
         end
       end

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

@@ -15,7 +15,7 @@ module Floe
           @error_path = Path.new(payload["ErrorPath"]) if payload["ErrorPath"]
         end
 
-        def finish
+        def finish(context)
           context.next_state = nil
           # TODO: support intrinsic functions here
           # see https://docs.aws.amazon.com/step-functions/latest/dg/amazon-states-language-fail-state.html
@@ -27,7 +27,7 @@ module Floe
           super
         end
 
-        def running?
+        def running?(_)
           false
         end
 

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

@@ -4,23 +4,23 @@ module Floe
   class Workflow
     module States
       module InputOutputMixin
-        def process_input(input)
-          input = input_path.value(context, input)
+        def process_input(context)
+          input = input_path.value(context, context.input)
           input = parameters.value(context, input) if parameters
           input
         end
 
-        def process_output(input, results)
-          return input if results.nil?
+        def process_output(context, results)
+          return context.input.dup if results.nil?
           return if output_path.nil?
 
           results = result_selector.value(context, results) if @result_selector
           if result_path.payload.start_with?("$.Credentials")
-            credentials = result_path.set(workflow.credentials, results)["Credentials"]
-            workflow.credentials.merge!(credentials)
-            output = input
+            credentials = result_path.set(context.credentials, results)["Credentials"]
+            context.credentials.merge!(credentials)
+            output = context.input.dup
           else
-            output = result_path.set(input, results)
+            output = result_path.set(context.input.dup, results)
           end
 
           output_path.value(context, output)

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

@@ -4,14 +4,14 @@ module Floe
   class Workflow
     module States
       module NonTerminalMixin
-        def finish
-          # If this state is failed or the End state set next_state to nil
-          context.next_state = end? || context.failed? ? nil : @next
+        def finish(context)
+          # If this state is failed or this is an end state, next_state to nil
+          context.next_state ||= end? || context.failed? ? nil : @next
 
           super
         end
 
-        def validate_state_next!
+        def validate_state_next!(workflow)
           raise Floe::InvalidWorkflowError, "Missing \"Next\" field in state [#{name}]" if @next.nil? && !@end
           raise Floe::InvalidWorkflowError, "\"Next\" [#{@next}] not in \"States\" for state [#{name}]" if @next && !workflow.payload["States"].key?(@next)
         end

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

@@ -21,15 +21,15 @@ module Floe
           @output_path = Path.new(payload.fetch("OutputPath", "$"))
           @result_path = ReferencePath.new(payload.fetch("ResultPath", "$"))
 
-          validate_state!
+          validate_state!(workflow)
         end
 
-        def finish
-          context.output = process_output(context.input.dup, result)
+        def finish(context)
+          context.output = process_output(context, result)
           super
         end
 
-        def running?
+        def running?(_)
           false
         end
 
@@ -39,8 +39,8 @@ module Floe
 
         private
 
-        def validate_state!
-          validate_state_next!
+        def validate_state!(workflow)
+          validate_state_next!(workflow)
         end
       end
     end

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

@@ -6,13 +6,13 @@ module Floe
       class Succeed < Floe::Workflow::State
         attr_reader :input_path, :output_path
 
-        def finish
+        def finish(context)
           context.next_state = nil
           context.output     = context.input
           super
         end
 
-        def running?
+        def running?(_)
           false
         end
 

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

@@ -29,36 +29,37 @@ module Floe
           @result_selector   = PayloadTemplate.new(payload["ResultSelector"]) if payload["ResultSelector"]
           @credentials       = PayloadTemplate.new(payload["Credentials"])    if payload["Credentials"]
 
-          validate_state!
+          validate_state!(workflow)
+        rescue ArgumentError => err
+          raise Floe::InvalidWorkflowError, err.message
         end
 
-        def start(input)
+        def start(context)
           super
 
-          input          = process_input(input)
-          runner_context = runner.run_async!(resource, input, credentials&.value({}, workflow.credentials), context)
+          input          = process_input(context)
+          runner_context = runner.run_async!(resource, input, credentials&.value({}, context.credentials), context)
 
           context.state["RunnerContext"] = runner_context
         end
 
-        def finish
+        def finish(context)
           output = runner.output(context.state["RunnerContext"])
 
-          if success?
+          if success?(context)
             output = parse_output(output)
-            context.output = process_output(context.input.dup, output)
-            super
+            context.output = process_output(context, output)
           else
-            context.output = error = parse_error(output)
-            super
-            retry_state!(error) || catch_error!(error) || fail_workflow!(error)
+            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?
-          return true if waiting?
+        def running?(context)
+          return true if waiting?(context)
 
           runner.status!(context.state["RunnerContext"])
           runner.running?(context.state["RunnerContext"])
@@ -72,11 +73,11 @@ module Floe
 
         attr_reader :runner
 
-        def validate_state!
-          validate_state_next!
+        def validate_state!(workflow)
+          validate_state_next!(workflow)
         end
 
-        def success?
+        def success?(context)
           runner.success?(context.state["RunnerContext"])
         end
 
@@ -88,7 +89,7 @@ module Floe
           self.catch.detect { |c| (c.error_equals & [error, "States.ALL"]).any? }
         end
 
-        def retry_state!(error)
+        def retry_state!(context, error)
           retrier = find_retrier(error["Error"]) if error
           return if retrier.nil?
 
@@ -102,13 +103,14 @@ module Floe
 
           return if context["State"]["RetryCount"] > retrier.max_attempts
 
-          wait_until!(:seconds => retrier.sleep_duration(context["State"]["RetryCount"]))
+          wait_until!(context, :seconds => retrier.sleep_duration(context["State"]["RetryCount"]))
           context.next_state = context.state_name
-          logger.info("Running state: [#{long_name}] with input [#{context.input}]...Retry - delay: #{wait_until}")
+          context.output     = error
+          logger.info("Running state: [#{long_name}] with input [#{context.input}] got error[#{context.output}]...Retry - delay: #{wait_until(context)}")
           true
         end
 
-        def catch_error!(error)
+        def catch_error!(context, error)
           catcher = find_catcher(error["Error"]) if error
           return if catcher.nil?
 
@@ -119,9 +121,11 @@ module Floe
           true
         end
 
-        def fail_workflow!(error)
-          context.next_state     = nil
-          context.output         = {"Error" => error["Error"], "Cause" => error["Cause"]}.compact
+        def fail_workflow!(context, error)
+          # next_state is nil, and will be set to nil again in super
+          # keeping in here for completeness
+          context.next_state = nil
+          context.output = error
           logger.error("Running state: [#{long_name}] with input [#{context.input}]...Complete workflow - output: [#{context.output}]")
         end
 

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

@@ -23,28 +23,29 @@ module Floe
           @input_path  = Path.new(payload.fetch("InputPath", "$"))
           @output_path = Path.new(payload.fetch("OutputPath", "$"))
 
-          validate_state!
+          validate_state!(workflow)
         end
 
-        def start(input)
+        def start(context)
           super
 
           input = input_path.value(context, context.input)
 
           wait_until!(
+            context,
             :seconds => seconds_path ? seconds_path.value(context, input).to_i : seconds,
             :time    => timestamp_path ? timestamp_path.value(context, input) : timestamp
           )
         end
 
-        def finish
+        def finish(context)
           input          = input_path.value(context, context.input)
           context.output = output_path.value(context, input)
           super
         end
 
-        def running?
-          waiting?
+        def running?(context)
+          waiting?(context)
         end
 
         def end?
@@ -53,8 +54,8 @@ module Floe
 
         private
 
-        def validate_state!
-          validate_state_next!
+        def validate_state!(workflow)
+          validate_state_next!(workflow)
         end
       end
     end

data/lib/floe/workflow.rb

@@ -85,13 +85,17 @@ module Floe
       end
     end
 
-    attr_reader :context, :credentials, :payload, :states, :states_by_name, :start_at, :name, :comment
+    attr_reader :context, :payload, :states, :states_by_name, :start_at, :name, :comment
 
-    def initialize(payload, context = nil, credentials = {}, name = nil)
+    def initialize(payload, context = nil, credentials = nil, name = nil)
       payload     = JSON.parse(payload)     if payload.kind_of?(String)
       credentials = JSON.parse(credentials) if credentials.kind_of?(String)
       context     = Context.new(context)    unless context.kind_of?(Context)
 
+      # backwards compatibility
+      # caller should really put credentials into context and not pass that variable
+      context.credentials = credentials if credentials
+
       raise Floe::InvalidWorkflowError, "Missing field \"States\""  if payload["States"].nil?
       raise Floe::InvalidWorkflowError, "Missing field \"StartAt\"" if payload["StartAt"].nil?
       raise Floe::InvalidWorkflowError, "\"StartAt\" not in the \"States\" field" unless payload["States"].key?(payload["StartAt"])
@@ -99,47 +103,53 @@ module Floe
       @name        = name
       @payload     = payload
       @context     = context
-      @credentials = credentials || {}
       @comment     = payload["Comment"]
       @start_at    = payload["StartAt"]
 
       @states         = payload["States"].to_a.map { |state_name, state| State.build!(self, state_name, state) }
       @states_by_name = @states.each_with_object({}) { |state, result| result[state.name] = state }
-
-      unless context.state.key?("Name")
-        context.state["Name"] = start_at
-        context.state["Input"] = context.execution["Input"].dup
-      end
-    rescue StandardError => err
+    rescue Floe::InvalidWorkflowError
+      raise
+    rescue => err
       raise Floe::InvalidWorkflowError, err.message
     end
 
     def run_nonblock
+      start_workflow
       loop while step_nonblock == 0 && !end?
       self
     end
 
+    # NOTE: If running manually, make sure to call start_workflow at startup
     def step_nonblock
       return Errno::EPERM if end?
 
-      step_next
-      current_state.run_nonblock!
+      result = current_state.run_nonblock!(context)
+      return result if result != 0
+
+      # if it completed the step
+      context.state_history << context.state
+      context.next_state ? step! : end_workflow!
+
+      result
     end
 
+    # if this hasn't started (and we have no current_state yet), assume it is ready
     def step_nonblock_wait(timeout: nil)
-      current_state.wait(:timeout => timeout)
+      context.started? ? current_state.wait(context, :timeout => timeout) : 0
     end
 
+    # if this hasn't started (and we have no current_state yet), assume it is ready
     def step_nonblock_ready?
-      current_state.ready?
+      !context.started? || current_state.ready?(context)
     end
 
     def waiting?
-      current_state.waiting?
+      current_state.waiting?(context)
     end
 
     def wait_until
-      current_state.wait_until
+      current_state.wait_until(context)
     end
 
     def status
@@ -154,14 +164,46 @@ module Floe
       context.ended?
     end
 
+    # 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
+
+      self
+    end
+
+    # NOTE: Expecting the context to be initialized (via start_workflow) before this
     def current_state
       @states_by_name[context.state_name]
     end
 
+    # backwards compatibility. Caller should access directly from context
+    def credentials
+      @context.credentials
+    end
     private
 
-    def step_next
-      context.state = {"Name" => context.next_state, "Input" => context.output} if context.next_state
+    def step!
+      next_state = {"Name" => context.next_state, "Guid" => SecureRandom.uuid, "PreviousStateGuid" => context.state["Guid"]}
+
+      # 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"))
+      else
+        next_state["Input"] = context.output
+      end
+
+      context.state = next_state
+    end
+
+    def end_workflow!
+      context.execution["EndTime"] = context.state["FinishedTime"]
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: floe
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.11.3
 platform: ruby
 authors:
 - ManageIQ Developers
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-24 00:00:00.000000000 Z
+date: 2024-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_spawn
@@ -164,13 +164,14 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Simple Workflow Runner.
+description: Floe is a runner for Amazon States Language workflows.
 email:
 executables:
 - floe
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_cc.yml"
@@ -178,6 +179,7 @@ files:
 - ".yamllint"
 - CHANGELOG.md
 - Gemfile
+- LICENSE.txt
 - README.md
 - Rakefile
 - examples/set-credential.asl
@@ -185,6 +187,7 @@ files:
 - exe/floe
 - floe.gemspec
 - lib/floe.rb
+- lib/floe/cli.rb
 - lib/floe/container_runner.rb
 - lib/floe/container_runner/docker.rb
 - lib/floe/container_runner/docker_mixin.rb
@@ -220,7 +223,8 @@ files:
 - renovate.json
 - sig/floe.rbs/floe.rbs
 homepage: https://github.com/ManageIQ/floe
-licenses: []
+licenses:
+- Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
   rubygems_mfa_required: 'true'
@@ -242,8 +246,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.10
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
-summary: Simple Workflow Runner.
+summary: Floe is a runner for Amazon States Language workflows.
 test_files: []