manageiq-floe 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a6a8fe345f9e54f72394a96fab04b30c611df88d75c37312c0c1ca4fabb19b94
+  data.tar.gz: e912605c61ee9cfb3e299d730aa2612ca152013095635d6e43bb7ba70f95d2e9
+SHA512:
+  metadata.gz: 85afb6b3c99ec3c21500a51c04eacd4023231bc89fafb81ad9648077f84dcb37d65fc0545affe66db93209ee935fed81060b51aa34a92171d68ef215bda94a7e
+  data.tar.gz: a31a038245135c3c2e16647ab26209e3c16a40ca91c3d3491e6c6e167a4824acd3e1e16471779cc82009fd2eaec2a2466cb048171583360318e88e6e5bdf93c0

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

@@ -0,0 +1,11 @@
+# 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 manageiq-floe.gemspec
+gemspec
+
+gem "rake", "~> 13.0"

data/README.md

@@ -0,0 +1,46 @@
+# ManageIQ::Floe
+
+[![CI](https://github.com/ManageIQ/manageiq-floe/actions/workflows/ci.yaml/badge.svg)](https://github.com/ManageIQ/manageiq-floe/actions/workflows/ci.yaml)
+
+## Overview
+
+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.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add manageiq-floe
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install manageiq-floe
+
+## Usage
+
+Floe can be run as a command-line utility or as a ruby class.
+
+### Command Line
+
+```
+bundle exec ruby exe/manageiq-floe --workflow examples/workflow.json --inputs='{"foo": 1}'
+```
+
+### Ruby Library
+
+```ruby
+require 'manageiq-floe'
+
+workflow = ManageIQ::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
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ManageIQ/manageiq-floe.

data/Rakefile

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

data/examples/workflow.json

@@ -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/manageiq-floe

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

data/lib/manageiq/floe/logging.rb

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

data/lib/manageiq/floe/null_logger.rb

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

data/lib/manageiq/floe/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ManageIQ
+  module Floe
+    VERSION = "0.1.0"
+  end
+end

data/lib/manageiq/floe/workflow/catcher.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ManageIQ
+  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
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ManageIQ
+  module Floe
+    class Workflow
+      class ChoiceRule
+        class Boolean < ManageIQ::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
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module ManageIQ
+  module Floe
+    class Workflow
+      class ChoiceRule
+        class Data < ManageIQ::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 ManageIQ::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
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ManageIQ
+  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
+              ManageIQ::Floe::Workflow::ChoiceRule::Data.new(payload)
+            else
+              ManageIQ::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
+end

data/lib/manageiq/floe/workflow/path.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ManageIQ
+  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
+end

data/lib/manageiq/floe/workflow/payload_template.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ManageIQ
+  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
+end

data/lib/manageiq/floe/workflow/reference_path.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ManageIQ
+  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 ManageIQ::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
+end

data/lib/manageiq/floe/workflow/retrier.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ManageIQ
+  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
+end

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

@@ -0,0 +1,45 @@
+module ManageIQ
+  module Floe
+    class Workflow
+      class Runner
+        class Docker < ManageIQ::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
+end