floe 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12212f802a614d03428c29b36a882efc7b12a2ae0e61ec1ac118aea28c34d95b
-  data.tar.gz: 5d62f266c83af21dffce7f8c2a1a8a3686ad24f85ad5421bced3cd483903ccb8
+  metadata.gz: 3a8984568027905b79c95ab066b45f0e87872bbb290022a018f3574d47e3054e
+  data.tar.gz: 73390d044e75811f2b1c91acfa1aea1814b38f1d3a60ad4b9bd0eed88d131af0
 SHA512:
-  metadata.gz: 16f88b2b6f1cbb7baa4038f5c6f55da0a1f74b2a1a54b49e74ac24480dddb0b64d59fda3c6b26512a116d8060be3a171a68f6f52f4a9e4ff9a971737312c327c
-  data.tar.gz: b5a318594423446d5de524950a894bbcac334e5875cc2d52cdfcfaef08f068eb946a1a9120c1626392917a8a325944652b4a8d8fb21aa270393df25a3460fac7
+  metadata.gz: b5d6cec81ef1adc60cc5912cc34275c032f250d84361982ac556284ada3c807f3189eef5357c193ae5b76db795f328b761fd53fd5dbfcd3468e5fc439d54c9fe
+  data.tar.gz: d4a9ce5beea167b41ec66b1b049c6466a41c91b64076792e87b34e92787e19120965580c638a755c5a1e406398f4b1842851105dad2d388c21b7db76944c7df7

data/.rubocop.yml

@@ -0,0 +1,4 @@
+inherit_gem:
+  manageiq-style: ".rubocop_base.yml"
+inherit_from:
+- ".rubocop_local.yml"

data/.rubocop_cc.yml

@@ -0,0 +1,4 @@
+inherit_from:
+- ".rubocop_base.yml"
+- ".rubocop_cc_base.yml"
+- ".rubocop_local.yml"

data/.rubocop_local.yml

@@ -0,0 +1,2 @@
+Rails:
+  Enabled: false

data/.yamllint

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

data/CHANGELOG.md

@@ -4,6 +4,17 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [0.2.0] - 2023-07-05
+### Added
+- Add ability to pass options to `Floe::Workflow::Runner` (#48)
+- Add kubeconfig file support to `Floe::Workflow::Runner::Kubernetes` (#53)
+
+### Removed
+- Remove to_dot/to_svg code (#54)
+
+### Fixed
+- Fixed default rake task to spec (#55)
+
 ## [0.1.1] - 2023-06-05
 ### Fixed
 - Fix States::Wait Path initializer arguments (#47)

data/README.md

@@ -28,6 +28,14 @@ Floe can be run as a command-line utility or as a ruby class.
 bundle exec ruby exe/floe --workflow examples/workflow.asl --inputs='{"foo": 1}'
 ```
 
+By default Floe will use `docker` to run `docker://` type resources, but `podman` and `kubernetes` are also supported runners.
+A different runner can be specified with the `--docker-runner` option:
+
+```
+bundle exec ruby exe/floe --workflow examples/workflow.asl --inputs='{"foo": 1}' --docker-runner podman
+bundle exec ruby exe/floe --workflow examples/workflow.asl --inputs='{"foo": 1}' --docker-runner kubernetes --docker-runner-options namespace=default server=https://k8s.example.com:6443 token=my-token
+```
+
 ### Ruby Library
 
 ```ruby
@@ -37,6 +45,32 @@ workflow = Floe::Workflow.load(File.read("workflow.asl"))
 workflow.run!
 ```
 
+You can also specify a specific docker runner and runner options:
+```ruby
+require 'floe'
+
+Floe::Workflow::Runner.docker_runner = Floe::Workflow::Runner::Podman.new
+# Or
+Floe::Workflow::Runner.docker_runner = Floe::Workflow::Runner::Kubernetes.new("namespace" => "default", "server" => "https://k8s.example.com:6443", "token" => "my-token")
+
+workflow = Floe::Workflow.load(File.read("workflow.asl"))
+workflow.run!
+```
+
+### Docker Runner Options
+
+#### Kubernetes
+
+Options supported by the kubernetes docker runner are:
+
+* `kubeconfig` - Path to a kubeconfig file, defaults to `KUBECONFIG` environment variable or `~/.kube/config`
+* `kubeconfig_context` - Context to use in the kubeconfig file, defaults to `"default"`
+* `namespace` - Namespace to use when creating kubernetes resources, defaults to `"default"`
+* `server` - A kubernetes API Server URL, overrides anything in your kubeconfig file.  If set `KUBERNETES_SERVICE_HOST` and `KUBERNETES_SERVICE_PORT` will be used
+* `token` - A bearer_token to use to authenticate to the kubernetes API, overrides anything in your kubeconfig file.  If present, `/run/secrets/kubernetes.io/serviceaccount/token` will be used
+* `ca_file` - Path to a certificate-authority file for the kubernetes API, only valid if server and token are passed.  If present `/run/secrets/kubernetes.io/serviceaccount/ca.crt` will be used
+* `verify_ssl` - Controls if the kubernetes API certificate-authority should be verified, defaults to "true", only vaild if server and token are passed
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-task default: %i[]
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new("spec")
+task :default => :spec

data/exe/floe

@@ -5,17 +5,35 @@ require "floe"
 require "optimist"
 
 opts = Optimist.options do
-  version "v#{Floe::VERSION}\n"
-  opt :workflow, "Path to your workflow json", :type => :string, :required => true
-  opt :inputs, "JSON payload to input to the workflow", :type => :string, :default => '{}'
-  opt :credentials, "JSON payload with credentials", :type => :string, :default => '{}'
+  version("v#{Floe::VERSION}\n")
+  opt :workflow, "Path to your workflow json",                 :type => :string, :required => true
+  opt :input, "JSON payload to input to the workflow",         :default => '{}'
+  opt :credentials, "JSON payload with credentials",           :default => "{}"
+  opt :docker_runner, "Type of runner for docker images",      :default => "docker"
+  opt :docker_runner_options, "Options to pass to the runner", :type => :strings
 end
 
+Optimist.die(:docker_runner, "must be one of #{Floe::Workflow::Runner::TYPES.join(", ")}") unless Floe::Workflow::Runner::TYPES.include?(opts[:docker_runner])
+
 require "logger"
-Floe.logger = Logger.new(STDOUT)
+Floe.logger = Logger.new($stdout)
+
+context = Floe::Workflow::Context.new(input: opts[:input])
+workflow = Floe::Workflow.load(opts[:workflow], context, opts[:credentials])
+
+runner_klass = case opts[:docker_runner]
+               when "docker"
+                 Floe::Workflow::Runner::Docker
+               when "podman"
+                 Floe::Workflow::Runner::Podman
+               when "kubernetes"
+                 Floe::Workflow::Runner::Kubernetes
+               end
+
+runner_options = opts[:docker_runner_options].to_h { |opt| opt.split("=", 2) }
 
-workflow = Floe::Workflow.load(opts[:workflow], opts[:inputs], opts[:credentials])
+Floe::Workflow::Runner.docker_runner = runner_klass.new(runner_options)
 
-output = workflow.run!
+workflow.run!
 
-puts output.inspect
+puts workflow.context.state["Output"].inspect

data/floe.gemspec

@@ -31,9 +31,11 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "awesome_spawn", "~>1.0"
   spec.add_dependency "jsonpath", "~>1.1"
-  spec.add_dependency "optimist", "~>3.0"
+  spec.add_dependency "kubeclient", "~>4.7"
   spec.add_dependency "more_core_extensions"
+  spec.add_dependency "optimist", "~>3.0"
 
-  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "manageiq-style"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rubocop"
 end

data/lib/floe/null_logger.rb

@@ -4,7 +4,7 @@ require 'logger'
 
 module Floe
   class NullLogger < Logger
-    def initialize(*_args)
+    def initialize(*)
     end
 
     def add(*_args, &_block)

data/lib/floe/version.rb

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

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

@@ -5,19 +5,18 @@ module Floe
     class ChoiceRule
       class Data < Floe::Workflow::ChoiceRule
         def true?(context, input)
-
           lhs = variable_value(context, input)
           rhs = compare_value(context, input)
 
           validate!(lhs)
 
           case compare_key
-          when "IsNull"; is_null?(lhs)
-          when "IsPresent"; is_present?(lhs)
-          when "IsNumeric"; is_numeric?(lhs)
-          when "IsString"; is_string?(lhs)
-          when "IsBoolean"; is_boolean?(lhs)
-          when "IsTimestamp"; is_timestamp?(lhs)
+          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)
+          when "IsTimestamp" then is_timestamp?(lhs)
           when "StringEquals", "StringEqualsPath",
                "NumericEquals", "NumericEqualsPath",
                "BooleanEquals", "BooleanEqualsPath",
@@ -40,7 +39,7 @@ module Floe
                "TimestampGreaterThanEquals", "TimestampGreaterThanEqualsPath"
             lhs >= rhs
           when "StringMatches"
-            lhs.match?(Regexp.escape(rhs).gsub('\*','.*?'))
+            lhs.match?(Regexp.escape(rhs).gsub('\*', '.*?'))
           else
             raise Floe::InvalidWorkflowError, "Invalid choice [#{compare_key}]"
           end
@@ -49,7 +48,7 @@ module Floe
         private
 
         def validate!(value)
-          raise RuntimeError, "No such variable [#{variable}]" if value.nil? && !%w[IsNull IsPresent].include?(compare_key)
+          raise "No such variable [#{variable}]" if value.nil? && !%w[IsNull IsPresent].include?(compare_key)
         end
 
         def is_null?(value)

data/lib/floe/workflow/context.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class Context
+      def initialize(context = nil, input: {})
+        context = JSON.parse(context) if context.kind_of?(String)
+
+        @context = context || {
+          "Execution"    => {
+            "Input" => input
+          },
+          "State"        => {},
+          "States"       => [],
+          "StateMachine" => {},
+          "Task"         => {}
+        }
+      end
+
+      def execution
+        @context["Execution"]
+      end
+
+      def state
+        @context["State"]
+      end
+
+      def states
+        @context["States"]
+      end
+
+      def state_machine
+        @context["StateMachine"]
+      end
+
+      def task
+        @context["Task"]
+      end
+
+      def [](key)
+        @context[key]
+      end
+
+      def []=(key, val)
+        @context[key] = val
+      end
+
+      def dig(*args)
+        @context.dig(*args)
+      end
+
+      def to_h
+        @context
+      end
+    end
+  end
+end

data/lib/floe/workflow/reference_path.rb

@@ -4,7 +4,7 @@ module Floe
   class Workflow
     class ReferencePath < Path
       class << self
-        def set (payload, context, value)
+        def set(payload, context, value)
           new(payload).set(context, value)
         end
       end
@@ -24,7 +24,7 @@ module Floe
         path = JsonPath.new(payload)
                        .path[1..]
                        .map { |v| v.match(/\[(?<name>.+)\]/)["name"] }
-                       .map { |v| v[0] == "'" ? v.gsub("'", "") : v.to_i }
+                       .map { |v| v[0] == "'" ? v.delete("'") : v.to_i }
                        .compact
 
         # If the payload is '$' then merge the value into the context

data/lib/floe/workflow/runner/kubernetes.rb

@@ -4,15 +4,36 @@ module Floe
   class Workflow
     class Runner
       class Kubernetes < Floe::Workflow::Runner
-        attr_reader :namespace
+        TOKEN_FILE   = "/run/secrets/kubernetes.io/serviceaccount/token"
+        CA_CERT_FILE = "/run/secrets/kubernetes.io/serviceaccount/ca.crt"
 
-        def initialize(*)
+        def initialize(options = {})
           require "awesome_spawn"
           require "securerandom"
           require "base64"
+          require "kubeclient"
           require "yaml"
 
-          @namespace = ENV.fetch("DOCKER_RUNNER_NAMESPACE", "default")
+          @kubeconfig_file    = ENV.fetch("KUBECONFIG", nil) || options.fetch("kubeconfig", File.join(Dir.home, ".kube", "config"))
+          @kubeconfig_context = options["kubeconfig_context"]
+
+          @token   = options["token"]
+          @token ||= File.read(options["token_file"]) if options.key?("token_file")
+          @token ||= File.read(TOKEN_FILE) if File.exist?(TOKEN_FILE)
+
+          @server   = options["server"]
+          @server ||= URI::HTTPS.build(:host => ENV.fetch("KUBERNETES_SERVICE_HOST"), :port => ENV.fetch("KUBERNETES_SERVICE_PORT", 6443)) if ENV.key?("KUBERNETES_SERVICE_HOST")
+
+          @ca_file   = options["ca_file"]
+          @ca_file ||= CA_CERT_FILE if File.exist?(CA_CERT_FILE)
+
+          @verify_ssl = options["verify_ssl"] == "false" ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+
+          if server.nil? && token.nil? && !File.exist?(kubeconfig_file)
+            raise ArgumentError, "Missing connections options, provide a kubeconfig file or pass server and token via --docker-runner-options"
+          end
+
+          @namespace = options.fetch("namespace", "default")
 
           super
         end
@@ -20,25 +41,52 @@ module Floe
         def run!(resource, env = {}, secrets = {})
           raise ArgumentError, "Invalid resource" unless resource&.start_with?("docker://")
 
-          image     = resource.sub("docker://", "")
-          name      = pod_name(image)
-          secret    = create_secret!(secrets) unless secrets&.empty?
-          overrides = pod_spec(image, env, secret)
+          image  = resource.sub("docker://", "")
+          name   = pod_name(image)
+          secret = create_secret!(secrets) if secrets && !secrets.empty?
+
+          begin
+            create_pod!(name, image, env, secret)
+            while running?(name)
+              sleep(1)
+            end
+
+            exit_status = success?(name) ? 0 : 1
+            results     = output(name)
 
-          result = kubectl_run!(image, name, overrides)
+            [exit_status, results]
+          ensure
+            cleanup(name, secret)
+          end
+        end
 
-          # Kubectl prints that the pod was deleted, strip this from the output
-          output = result.output.gsub(/pod \"#{name}\" deleted/, "")
+        def running?(pod_name)
+          %w[Pending Running].include?(pod_info(pod_name).dig("status", "phase"))
+        end
+
+        def success?(pod_name)
+          pod_info(pod_name).dig("status", "phase") == "Succeeded"
+        end
 
-          [result.exit_status, output]
-        ensure
-          delete_secret!(secret) if secret
+        def output(pod)
+          kubeclient.get_pod_log(pod, namespace).body
+        end
+
+        def cleanup(pod, secret)
+          delete_pod(pod)       if pod
+          delete_secret(secret) if secret
         end
 
         private
 
+        attr_reader :ca_file, :kubeconfig_file, :kubeconfig_context, :namespace, :server, :token, :verify_ssl
+
+        def pod_info(pod_name)
+          kubeclient.get_pod(pod_name, namespace)
+        end
+
         def container_name(image)
-          image.match(%r{^(?<repository>.+\/)?(?<image>.+):(?<tag>.+)$})&.named_captures&.dig("image")
+          image.match(%r{^(?<repository>.+/)?(?<image>.+):(?<tag>.+)$})&.named_captures&.dig("image")
         end
 
         def pod_name(image)
@@ -48,23 +96,44 @@ module Floe
           "#{container_short_name}-#{SecureRandom.uuid}"
         end
 
-        def pod_spec(image, env, secret = nil)
-          container_spec = {
-            "name" => container_name(image),
-            "image" => image,
-            "env" => env.to_h.map { |k, v| {"name" => k, "value" => v} }
+        def pod_spec(name, image, env, secret = nil)
+          spec = {
+            :kind       => "Pod",
+            :apiVersion => "v1",
+            :metadata   => {
+              :name      => name,
+              :namespace => namespace
+            },
+            :spec       => {
+              :containers    => [
+                {
+                  :name  => container_name(image),
+                  :image => image,
+                  :env   => env.map { |k, v| {:name => k, :value => v.to_s} }
+                }
+              ],
+              :restartPolicy => "Never"
+            }
           }
 
-          spec = {"spec" => {"containers" => [container_spec]}}
-
           if secret
-            spec["spec"]["volumes"] = [{"name"   => "secret-volume", "secret" => {"secretName" => secret}}]
-            container_spec["env"] << {"name" => "SECRETS", "value" => "/run/secrets/#{secret}/secret"}
-            container_spec["volumeMounts"] = [
+            spec[:spec][:volumes] = [
               {
-                "name"      => "secret-volume",
-                "mountPath" => "/run/secrets/#{secret}",
-                "readOnly"  => true
+                :name   => "secret-volume",
+                :secret => {:secretName => secret}
+              }
+            ]
+
+            spec[:spec][:containers][0][:env] << {
+              :name  => "SECRETS",
+              :value => "/run/secrets/#{secret}/secret"
+            }
+
+            spec[:spec][:containers][0][:volumeMounts] = [
+              {
+                :name      => "secret-volume",
+                :mountPath => "/run/secrets/#{secret}",
+                :readOnly  => true
               }
             ]
           end
@@ -72,45 +141,75 @@ module Floe
           spec
         end
 
+        def create_pod!(name, image, env, secret = nil)
+          kubeclient.create_pod(pod_spec(name, image, env, secret))
+        end
+
+        def delete_pod!(name)
+          kubeclient.delete_pod(name, namespace)
+        end
+
+        def delete_pod(name)
+          delete_pod!(name)
+        rescue
+          nil
+        end
+
         def create_secret!(secrets)
           secret_name = SecureRandom.uuid
 
-          secret_yaml = {
-            "kind"       => "Secret",
-            "apiVersion" => "v1",
-            "metadata"   => {
-              "name" => secret_name,
-              "namespace" => namespace
+          secret_config = {
+            :kind       => "Secret",
+            :apiVersion => "v1",
+            :metadata   => {
+              :name      => secret_name,
+              :namespace => namespace
             },
-            "data"       => {
-              "secret" => Base64.urlsafe_encode64(secrets.to_json)
+            :data       => {
+              :secret => Base64.urlsafe_encode64(secrets.to_json)
             },
-            "type"       => "Opaque"
-          }.to_yaml
+            :type       => "Opaque"
+          }
 
-          kubectl!("create", "-f", "-", :in_data => secret_yaml)
+          kubeclient.create_secret(secret_config)
 
           secret_name
         end
 
         def delete_secret!(secret_name)
-          kubectl!("delete", "secret", secret_name, [:namespace, namespace])
+          kubeclient.delete_secret(secret_name, namespace)
         end
 
-        def kubectl!(*params, **kwargs)
-          AwesomeSpawn.run!("kubectl", :params => params, **kwargs)
+        def delete_secret(name)
+          delete_secret!(name)
+        rescue
+          nil
         end
 
-        def kubectl_run!(image, name, overrides = nil)
-          params = [
-            "run", :rm, :attach, [:image, image], [:restart, "Never"], [:namespace, namespace], name
-          ]
+        def kubeclient
+          return @kubeclient unless @kubeclient.nil?
+
+          if server && token
+            api_endpoint = server
+            auth_options = {:bearer_token => token}
+            ssl_options  = {:verify_ssl => verify_ssl}
+            ssl_options[:ca_file] = ca_file if ca_file
+          else
+            context = kubeconfig&.context(kubeconfig_context)
+            raise ArgumentError, "Missing connections options, provide a kubeconfig file or pass server and token via --docker-runner-options" if context.nil?
+
+            api_endpoint = context.api_endpoint
+            auth_options = context.auth_options
+            ssl_options  = context.ssl_options
+          end
 
-          params << "--overrides=#{overrides.to_json}" if overrides
+          @kubeclient = Kubeclient::Client.new(api_endpoint, "v1", :ssl_options => ssl_options, :auth_options => auth_options).tap(&:discover)
+        end
 
-          logger.debug("Running kubectl: #{AwesomeSpawn.build_command_line("kubectl", params)}")
+        def kubeconfig
+          return if kubeconfig_file.nil? || !File.exist?(kubeconfig_file)
 
-          kubectl!(*params)
+          Kubeclient::Config.read(kubeconfig_file)
         end
       end
     end

data/lib/floe/workflow/runner.rb

@@ -5,11 +5,16 @@ module Floe
     class Runner
       include Logging
 
+      TYPES = %w[docker podman kubernetes].freeze
+
+      def initialize(_options = {})
+      end
+
       class << self
-        attr_writer :docker_runner_klass
+        attr_writer :docker_runner
 
-        def docker_runner_klass
-          @docker_runner_klass ||= const_get(ENV.fetch("DOCKER_RUNNER", "docker").capitalize)
+        def docker_runner
+          @docker_runner ||= Floe::Workflow::Runner::Docker.new
         end
 
         def for_resource(resource)
@@ -18,7 +23,7 @@ module Floe
           scheme = resource.split("://").first
           case scheme
           when "docker"
-            docker_runner_klass.new
+            docker_runner
           else
             raise "Invalid resource scheme [#{scheme}]"
           end

data/lib/floe/workflow/state.rb

@@ -38,6 +38,10 @@ module Floe
         workflow.context
       end
 
+      def status
+        end? ? "success" : "running"
+      end
+
       def run!(input)
         logger.info("Running state: [#{name}] with input [#{input}]")
 
@@ -53,24 +57,6 @@ module Floe
 
         [next_state, output]
       end
-
-      def to_dot
-        String.new.tap do |s|
-          s << "  #{name}"
-
-          attributes = to_dot_attributes
-          s << " [ #{attributes.to_a.map { |kv| kv.join("=") }.join(" ")} ]" unless attributes.empty?
-        end
-      end
-
-      private def to_dot_attributes
-        end? ? {:style => "bold"} : {}
-      end
-
-      def to_dot_transitions
-        next_state_name = payload["Next"] unless end?
-        Array(next_state_name && "  #{name} -> #{next_state_name}")
-      end
     end
   end
 end

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

@@ -26,27 +26,6 @@ module Floe
             [output, next_state]
           end
         end
-
-        private def to_dot_attributes
-          super.merge(:shape => "diamond")
-        end
-
-        def to_dot_transitions
-          [].tap do |a|
-            choices.each do |choice|
-              choice_label =
-                if choice.payload["NumericEquals"]
-                  "#{choice.variable} == #{choice.payload["NumericEquals"]}"
-                else
-                  "Unknown" # TODO
-                end
-
-              a << "  #{name} -> #{choice.next} [ label=#{choice_label.inspect} ]"
-            end
-
-            a << "  #{name} -> #{default} [ label=\"Default\" ]" if default
-          end
-        end
       end
     end
   end

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

@@ -28,8 +28,8 @@ module Floe
           true
         end
 
-        private def to_dot_attributes
-          super.merge(:color => "red")
+        def status
+          "errored"
         end
       end
     end

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

@@ -16,10 +16,6 @@ module Floe
         def end?
           true # TODO: Handle if this is ending a parallel or map state
         end
-
-        private def to_dot_attributes
-          super.merge(:color => "green")
-        end
       end
     end
   end

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

@@ -51,15 +51,16 @@ module Floe
           return if retrier.nil?
 
           # If a different retrier is hit reset the context
-          if !context.key?("retrier") || context["retrier"]["error_equals"] != retrier.error_equals
-            context["retrier"] = {"error_equals" => retrier.error_equals, "retry_count" => 0}
+          if !context["State"].key?("RetryCount") || context["State"]["Retrier"] != retrier.error_equals
+            context["State"]["RetryCount"] = 0
+            context["State"]["Retrier"]    = retrier.error_equals
           end
 
-          context["retrier"]["retry_count"] += 1
+          context["State"]["RetryCount"] += 1
 
-          return if context["retrier"]["retry_count"] > retrier.max_attempts
+          return if context["State"]["RetryCount"] > retrier.max_attempts
 
-          Kernel.sleep(retrier.sleep_duration(context["retrier"]["retry_count"]))
+          Kernel.sleep(retrier.sleep_duration(context["State"]["RetryCount"]))
           true
         end
 

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

@@ -17,7 +17,10 @@ module Floe
         end
 
         def run!(*)
-          super { sleep(seconds); nil }
+          super do
+            sleep(seconds)
+            nil
+          end
         end
       end
     end

data/lib/floe/workflow.rb

@@ -5,78 +5,74 @@ require "json"
 module Floe
   class Workflow
     class << self
-      def load(path_or_io, context = {}, credentials = {})
+      def load(path_or_io, context = nil, credentials = {})
         payload = path_or_io.respond_to?(:read) ? path_or_io.read : File.read(path_or_io)
         new(payload, context, credentials)
       end
     end
 
-    attr_reader :context, :credentials, :first_state, :payload, :states, :states_by_name, :start_at
+    attr_reader :context, :credentials, :payload, :states, :states_by_name, :current_state, :status
 
-    def initialize(payload, context = {}, credentials = {})
+    def initialize(payload, context = nil, credentials = {})
       payload     = JSON.parse(payload)     if payload.kind_of?(String)
       context     = JSON.parse(context)     if context.kind_of?(String)
       credentials = JSON.parse(credentials) if credentials.kind_of?(String)
+      context     = Context.new(context)    unless context.kind_of?(Context)
+
+      @payload     = payload
+      @context     = context || {"global" => {}}
+      @credentials = credentials
 
-      @payload        = payload
-      @context        = context
-      @credentials    = credentials
       @states         = payload["States"].to_a.map { |name, state| State.build!(self, name, state) }
-      @states_by_name = states.to_h { |state| [state.name, state] }
-      @start_at       = @payload["StartAt"]
-      @first_state    = @states_by_name[@start_at]
+      @states_by_name = @states.each_with_object({}) { |state, result| result[state.name] = state }
+      start_at        = @payload["StartAt"]
+
+      current_state_name = @context["State"]["Name"] || start_at
+      @current_state = @states_by_name[current_state_name]
+
+      @status = current_state_name == start_at ? "pending" : current_state.status
     rescue JSON::ParserError => err
       raise Floe::InvalidWorkflowError, err.message
     end
 
-    def run!
-      state = first_state
-      input = context.dup
+    def step
+      @status = "running" if @status == "pending"
+      @context["Execution"]["StartTime"] ||= Time.now.utc
 
-      until state.nil?
-        state, output = state.run!(input)
-        input = output
-      end
+      input = @context["State"]["Output"] || @context["Execution"]["Input"].dup
 
-      output
-    end
+      tick = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      next_state, output = current_state.run!(input)
+      tock = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-    def to_dot
-      String.new.tap do |s|
-        s << "digraph {\n"
-        states.each do |state|
-          s << state.to_dot << "\n"
-        end
-        s << "\n"
-        states.each do |state|
-          Array(state.to_dot_transitions).each do |transition|
-            s << transition << "\n"
-          end
-        end
-        s << "}\n"
-      end
-    end
+      @context["State"] = {
+        "EnteredTime"  => tick,
+        "FinishedTime" => tock,
+        "Duration"     => tock - tick,
+        "Output"       => output,
+        "Name"         => next_state&.name,
+        "Input"        => output
+      }
 
-    def to_svg(path: nil)
-      require "open3"
-      out, err, _status = Open3.capture3("dot -Tsvg", :stdin_data => to_dot)
+      @context["States"] << @context["State"]
 
-      raise "Error from graphviz:\n#{err}" if err && !err.empty?
+      @status = current_state.status
 
-      File.write(path, out) if path
+      next_state_name = next_state&.name
+      @current_state = next_state_name && @states_by_name[next_state_name]
 
-      out
+      self
     end
 
-    def to_ascii(path: nil)
-      require "open3"
-      out, err, _status = Open3.capture3("graph-easy", :stdin_data => to_dot)
-
-      raise "Error from graph-easy:\n#{err}" if err && !err.empty?
-
-      File.write(path, out) if path
+    def run!
+      until end?
+        step
+      end
+      self
+    end
 
-      out
+    def end?
+      current_state.nil?
     end
   end
 end

data/lib/floe.rb

@@ -10,6 +10,7 @@ require_relative "floe/workflow/catcher"
 require_relative "floe/workflow/choice_rule"
 require_relative "floe/workflow/choice_rule/boolean"
 require_relative "floe/workflow/choice_rule/data"
+require_relative "floe/workflow/context"
 require_relative "floe/workflow/path"
 require_relative "floe/workflow/payload_template"
 require_relative "floe/workflow/reference_path"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: floe
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - ManageIQ Developers
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-05 00:00:00.000000000 Z
+date: 2023-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_spawn
@@ -39,19 +39,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: optimist
+  name: kubeclient
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.7'
 - !ruby/object:Gem::Dependency
   name: more_core_extensions
   requirement: !ruby/object:Gem::Requirement
@@ -67,7 +67,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: optimist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: manageiq-style
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Simple Workflow Runner.
 email:
 executables:
@@ -102,6 +130,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- ".rubocop.yml"
+- ".rubocop_cc.yml"
+- ".rubocop_local.yml"
+- ".yamllint"
 - CHANGELOG.md
 - Gemfile
 - README.md
@@ -118,6 +150,7 @@ files:
 - lib/floe/workflow/choice_rule.rb
 - lib/floe/workflow/choice_rule/boolean.rb
 - lib/floe/workflow/choice_rule/data.rb
+- lib/floe/workflow/context.rb
 - lib/floe/workflow/path.rb
 - lib/floe/workflow/payload_template.rb
 - lib/floe/workflow/reference_path.rb