floe 0.0.1 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 379fa04920aa1757f0e189fba83310a25f4a2b2f6faa224016c570bc47a114cd
+  data.tar.gz: d9558845724ac2ba5e0758953239fe582d90e99aa14d2e3dbdce9a51dd874c1a
+SHA512:
+  metadata.gz: 22f2964e5eab2f3f710dab683b7540e2c9ef59b5dc4045f573ff8857283467be1855a660f80373bd349e83fb94848c16dd114db9bcfeb7e3e45b89f538cac4ae
+  data.tar.gz: d4507d552bc4bd4415f7d3efb8620100cac8f70456fe121c014085c82103ece545d2ecb69b720d784749886fca0b16367bcd561884ba7b4740cce23838fc1419

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+## [Unreleased]
+
+## [0.1.0] - 2023-03-13
+### Added
+- Initial release
+
+[Unreleased]: https://github.com/ManageIQ/manageiq-floe/compare/v0.1.0...HEAD

data/Gemfile

@@ -1,4 +1,11 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+plugin "bundler-inject", "~> 2.0"
+require File.join(Bundler::Plugin.index.load_paths("bundler-inject")[0], "bundler-inject") rescue nil
 
 # Specify your gem's dependencies in floe.gemspec
 gemspec
+
+gem "rake", "~> 13.0"

data/README.md

@@ -1,29 +1,46 @@
 # Floe
 
-TODO: Write a gem description
+[![CI](https://github.com/ManageIQ/floe/actions/workflows/ci.yaml/badge.svg)](https://github.com/ManageIQ/floe/actions/workflows/ci.yaml)
 
-## Installation
+## Overview
 
-Add this line to your application's Gemfile:
+Floe is a runner for [Amazon States Language](https://states-language.net/) workflows with support for Docker resources and running on Docker, Podman, or Kubernetes.
 
-    gem 'floe'
+## Installation
 
-And then execute:
+Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle
+    $ bundle add floe
 
-Or install it yourself as:
+If bundler is not being used to manage dependencies, install the gem by executing:
 
     $ gem install floe
 
 ## Usage
 
-TODO: Write usage instructions here
+Floe can be run as a command-line utility or as a ruby class.
+
+### Command Line
+
+```
+bundle exec ruby exe/floe --workflow examples/workflow.asl --inputs='{"foo": 1}'
+```
+
+### Ruby Library
+
+```ruby
+require 'floe'
+
+workflow = Floe::Workflow.load(File.read("workflow.json"))
+workflow.run!
+```
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+Bug reports and pull requests are welcome on GitHub at https://github.com/ManageIQ/floe.

data/Rakefile

@@ -1 +1,4 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
+task default: %i[]

data/examples/workflow.asl

@@ -0,0 +1,89 @@
+{
+  "Comment": "An example of the Amazon States Language using a choice state.",
+  "StartAt": "FirstState",
+  "States": {
+    "FirstState": {
+      "Type": "Task",
+      "Resource": "docker://agrare/hello-world:latest",
+      "Credentials": {
+        "mysecret": "dont tell anyone"
+      },
+      "Retry": [
+        {
+          "ErrorEquals": [ "States.Timeout" ],
+          "IntervalSeconds": 3,
+          "MaxAttempts": 2,
+          "BackoffRate": 1.5
+        }
+      ],
+      "Catch": [
+        {
+          "ErrorEquals": [ "States.ALL" ],
+          "Next": "FailState"
+        }
+      ],
+      "Next": "ChoiceState"
+    },
+
+    "ChoiceState": {
+      "Type" : "Choice",
+      "Choices": [
+        {
+          "Variable": "$.foo",
+          "NumericEquals": 1,
+          "Next": "FirstMatchState"
+        },
+        {
+          "Variable": "$.foo",
+          "NumericEquals": 2,
+          "Next": "SecondMatchState"
+        },
+        {
+          "Variable": "$.foo",
+          "NumericEquals": 3,
+          "Next": "SuccessState"
+        }
+      ],
+      "Default": "FailState"
+    },
+
+    "FirstMatchState": {
+      "Type" : "Task",
+      "Resource": "docker://agrare/hello-world:latest",
+      "Next": "PassState"
+    },
+
+    "SecondMatchState": {
+      "Type" : "Task",
+      "Resource": "docker://agrare/hello-world:latest",
+      "Next": "NextState"
+    },
+
+    "PassState": {
+      "Type": "Pass",
+      "Result": {
+        "foo": "bar",
+        "bar": "baz"
+      },
+      "ResultPath": "$.result",
+      "Next": "NextState"
+    },
+
+    "FailState": {
+      "Type": "Fail",
+      "Error": "FailStateError",
+      "Cause": "No Matches!"
+    },
+
+    "SuccessState": {
+      "Type": "Succeed"
+    },
+
+    "NextState": {
+      "Type": "Task",
+      "Resource": "docker://agrare/hello-world:latest",
+      "Secrets": ["vmdb:aaa-bbb-ccc"],
+      "End": true
+    }
+  }
+}

data/exe/floe

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+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 => '{}'
+end
+
+require "logger"
+Floe.logger = Logger.new(STDOUT)
+
+workflow = Floe::Workflow.load(opts[:workflow], opts[:inputs], opts[:credentials])
+
+output = workflow.run!
+
+puts output.inspect

data/floe.gemspec

@@ -1,23 +1,39 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'floe/version'
+# frozen_string_literal: true
+
+require_relative "lib/floe/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "floe"
-  spec.version       = Floe::VERSION
-  spec.authors       = ["Kyle Maxwell"]
-  spec.email         = ["kyle@kylemaxwell.com"]
-  spec.description   = %q{The command-line issues client}
-  spec.summary       = %q{A quirky github issues client}
-  spec.homepage      = ""
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.name = "floe"
+  spec.version = Floe::VERSION
+  spec.authors = ["ManageIQ Developers"]
+
+  spec.summary = "Simple Workflow Runner."
+  spec.description = "Simple Workflow Runner."
+  spec.homepage = "https://github.com/ManageIQ/floe"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.add_dependency "awesome_spawn", "~>1.0"
+  spec.add_dependency "jsonpath", "~>1.1"
+  spec.add_dependency "optimist", "~>3.0"
+  spec.add_dependency "more_core_extensions"
+
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rspec"
 end

data/lib/floe/logging.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Floe
+  module Logging
+    def self.included(base)
+      base.extend(self)
+    end
+
+    def logger
+      Floe.logger
+    end
+  end
+end

data/lib/floe/null_logger.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Floe
+  class NullLogger < Logger
+    def initialize(*_args)
+    end
+
+    def add(*_args, &_block)
+    end
+  end
+end

data/lib/floe/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Floe
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/floe/workflow/catcher.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class Catcher
+      attr_reader :error_equals, :next, :result_path
+
+      def initialize(payload)
+        @payload = payload
+
+        @error_equals = payload["ErrorEquals"]
+        @next         = payload["Next"]
+        @result_path  = payload.fetch("ResultPath", "$")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class ChoiceRule
+      class Boolean < Floe::Workflow::ChoiceRule
+        def true?(context, input)
+          if payload.key?("Not")
+            !ChoiceRule.true?(payload["Not"], context, input)
+          elsif payload.key?("And")
+            payload["And"].all? { |choice| ChoiceRule.true?(choice, context, input) }
+          else
+            payload["Or"].any? { |choice| ChoiceRule.true?(choice, context, input) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    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 "StringEquals", "StringEqualsPath",
+               "NumericEquals", "NumericEqualsPath",
+               "BooleanEquals", "BooleanEqualsPath",
+               "TimestampEquals", "TimestampEqualsPath"
+            lhs == rhs
+          when "StringLessThan", "StringLessThanPath",
+               "NumericLessThan", "NumericLessThanPath",
+               "TimestampLessThan", "TimestampLessThanPath"
+            lhs < rhs
+          when "StringGreaterThan", "StringGreaterThanPath",
+               "NumericGreaterThan", "NumericGreaterThanPath",
+               "TimestampGreaterThan", "TimestampGreaterThanPath"
+            lhs > rhs
+          when "StringLessThanEquals", "StringLessThanEqualsPath",
+               "NumericLessThanEquals", "NumericLessThanEqualsPath",
+               "TimestampLessThanEquals", "TimestampLessThanEqualsPath"
+            lhs <= rhs
+          when "StringGreaterThanEquals", "StringGreaterThanEqualsPath",
+               "NumericGreaterThanEquals", "NumericGreaterThanEqualsPath",
+               "TimestampGreaterThanEquals", "TimestampGreaterThanEqualsPath"
+            lhs >= rhs
+          when "StringMatches"
+            lhs.match?(Regexp.escape(rhs).gsub('\*','.*?'))
+          else
+            raise Floe::InvalidWorkflowError, "Invalid choice [#{compare_key}]"
+          end
+        end
+
+        private
+
+        def validate!(value)
+          raise RuntimeError, "No such variable [#{variable}]" if value.nil? && !%w[IsNull IsPresent].include?(compare_key)
+        end
+
+        def is_null?(value)
+          value.nil?
+        end
+
+        def is_present?(value)
+          !value.nil?
+        end
+
+        def is_numeric?(value)
+          value.kind_of?(Integer) || value.kind_of?(Float)
+        end
+
+        def is_string?(value)
+          value.kind_of?(String)
+        end
+
+        def is_boolean?(value)
+          [true, false].include?(value)
+        end
+
+        def is_timestamp?(value)
+          require "date"
+
+          DateTime.rfc3339(value)
+          true
+        rescue TypeError, Date::Error
+          false
+        end
+
+        def compare_key
+          @compare_key ||= payload.keys.detect { |key| key.match?(/^(IsNull|IsPresent|IsNumeric|IsString|IsBoolean|IsTimestamp|String|Numeric|Boolean|Timestamp)/) }
+        end
+
+        def compare_value(context, input)
+          compare_key.end_with?("Path") ? Path.value(payload[compare_key], context, input) : payload[compare_key]
+        end
+      end
+    end
+  end
+end

data/lib/floe/workflow/choice_rule.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class ChoiceRule
+      class << self
+        def true?(payload, context, input)
+          build(payload).true?(context, input)
+        end
+
+        def build(payload)
+          data_expression = (payload.keys & %w[And Not Or]).empty?
+          if data_expression
+            Floe::Workflow::ChoiceRule::Data.new(payload)
+          else
+            Floe::Workflow::ChoiceRule::Boolean.new(payload)
+          end
+        end
+      end
+
+      attr_reader :next, :payload, :variable
+
+      def initialize(payload)
+        @payload = payload
+
+        @next     = payload["Next"]
+        @variable = payload["Variable"]
+      end
+
+      def true?(*)
+        raise NotImplementedError, "Must be implemented in a subclass"
+      end
+
+      private
+
+      def variable_value(context, input)
+        @variable_value ||= Path.value(variable, context, input)
+      end
+    end
+  end
+end

data/lib/floe/workflow/path.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class Path
+      class << self
+        def value(payload, context, input = {})
+          new(payload).value(context, input)
+        end
+      end
+
+      def initialize(payload)
+        @payload = payload
+      end
+
+      def value(context, input = {})
+        obj, path =
+          if payload.start_with?("$$")
+            [context, payload[1..]]
+          else
+            [input, payload]
+          end
+
+        results = JsonPath.on(obj, path)
+
+        results.count < 2 ? results.first : results
+      end
+
+      private
+
+      attr_reader :payload
+    end
+  end
+end

data/lib/floe/workflow/payload_template.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class PayloadTemplate
+      def initialize(payload)
+        @payload = payload
+      end
+
+      def value(context, inputs = {})
+        interpolate_value_nested(payload, context, inputs)
+      end
+
+      private
+
+      attr_reader :payload
+
+      def interpolate_value_nested(value, context, inputs)
+        case value
+        when Array
+          value.map { |val| interpolate_value_nested(val, context, inputs) }
+        when Hash
+          value.to_h do |key, val|
+            val = interpolate_value_nested(val, context, inputs)
+            key = key.gsub(/\.\$$/, "") if key.end_with?(".$")
+
+            [key, val]
+          end
+        when String
+          value.start_with?("$") ? Path.value(value, context, inputs) : value
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/floe/workflow/reference_path.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class ReferencePath < Path
+      class << self
+        def set (payload, context, value)
+          new(payload).set(context, value)
+        end
+      end
+
+      def initialize(*)
+        require "more_core_extensions/core_ext/hash/nested"
+        require "more_core_extensions/core_ext/array/nested"
+
+        super
+
+        raise Floe::InvalidWorkflowError, "Invalid Reference Path" if payload.match?(/@|,|:|\?/)
+      end
+
+      def set(context, value)
+        result = context.dup
+
+        path = JsonPath.new(payload)
+                       .path[1..]
+                       .map { |v| v.match(/\[(?<name>.+)\]/)["name"] }
+                       .map { |v| v[0] == "'" ? v.gsub("'", "") : v.to_i }
+                       .compact
+
+        # If the payload is '$' then merge the value into the context
+        # otherwise use store path to set the value to a sub-key
+        #
+        # TODO: how to handle non-hash values, raise error if path=$ and value not a hash?
+        if path.empty?
+          result.merge!(value)
+        else
+          result.store_path(path, value)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/floe/workflow/retrier.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class Retrier
+      attr_reader :error_equals, :interval_seconds, :max_attempts, :backoff_rate
+
+      def initialize(payload)
+        @payload = payload
+
+        @error_equals     = payload["ErrorEquals"]
+        @interval_seconds = payload["IntervalSeconds"] || 1.0
+        @max_attempts     = payload["MaxAttempts"] || 3
+        @backoff_rate     = payload["BackoffRate"] || 2.0
+      end
+
+      def sleep_duration(attempt)
+        interval_seconds * (backoff_rate * attempt)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    class Runner
+      class Docker < Floe::Workflow::Runner
+        def initialize(*)
+          require "awesome_spawn"
+          require "tempfile"
+
+          super
+        end
+
+        def run!(resource, env = {}, secrets = {})
+          raise ArgumentError, "Invalid resource" unless resource&.start_with?("docker://")
+
+          image = resource.sub("docker://", "")
+
+          params = ["run", :rm, [:net, "host"]]
+          params += env.map { |k, v| [:e, "#{k}=#{v}"] } if env
+
+          secrets_file = nil
+
+          if secrets && !secrets.empty?
+            secrets_file = Tempfile.new
+            secrets_file.write(secrets.to_json)
+            secrets_file.flush
+
+            params << [:e, "SECRETS=/run/secrets"]
+            params << [:v, "#{secrets_file.path}:/run/secrets:z"]
+          end
+
+          params << image
+
+          logger.debug("Running docker: #{AwesomeSpawn.build_command_line("docker", params)}")
+          result = AwesomeSpawn.run!("docker", :params => params)
+
+          [result.exit_status, result.output]
+        ensure
+          secrets_file&.close!
+        end
+      end
+    end
+  end
+end