floe 0.11.2 → 0.12.0

data/lib/floe/workflow/choice_rule.rb

@@ -4,26 +4,31 @@ module Floe
   class Workflow
     class ChoiceRule
       class << self
-        def build(payload)
+        def build(workflow, name, payload)
           if (sub_payloads = payload["Not"])
-            Floe::Workflow::ChoiceRule::Not.new(payload, build_children([sub_payloads]))
+            name += ["Not"]
+            Floe::Workflow::ChoiceRule::Not.new(workflow, name, payload, build_children(workflow, name, [sub_payloads]))
           elsif (sub_payloads = payload["And"])
-            Floe::Workflow::ChoiceRule::And.new(payload, build_children(sub_payloads))
+            name += ["And"]
+            Floe::Workflow::ChoiceRule::And.new(workflow, name, payload, build_children(workflow, name, sub_payloads))
           elsif (sub_payloads = payload["Or"])
-            Floe::Workflow::ChoiceRule::Or.new(payload, build_children(sub_payloads))
+            name += ["Or"]
+            Floe::Workflow::ChoiceRule::Or.new(workflow, name, payload, build_children(workflow, name, sub_payloads))
           else
-            Floe::Workflow::ChoiceRule::Data.new(payload)
+            name += ["Data"]
+            Floe::Workflow::ChoiceRule::Data.new(workflow, name, payload)
           end
         end
 
-        def build_children(sub_payloads)
-          sub_payloads.map { |payload| build(payload) }
+        def build_children(workflow, name, sub_payloads)
+          sub_payloads.map.with_index { |payload, i| build(workflow, name + [i.to_s], payload) }
         end
       end
 
-      attr_reader :next, :payload, :variable, :children
+      attr_reader :next, :payload, :variable, :children, :name
 
-      def initialize(payload, children = nil)
+      def initialize(_workflow, name, payload, children = nil)
+        @name      = name
         @payload   = payload
         @children  = children
 

data/lib/floe/workflow/context.rb

@@ -3,13 +3,13 @@
 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 ||= {}
-        input = JSON.parse(input) if input.kind_of?(String)
+        input   = JSON.parse(input || "{}")
 
         @context = context || {}
         self["Execution"]          ||= {}
@@ -18,6 +18,10 @@ module Floe
         self["StateHistory"]       ||= []
         self["StateMachine"]       ||= {}
         self["Task"]               ||= {}
+
+        @credentials = credentials || {}
+      rescue JSON::ParserError => err
+        raise Floe::InvalidExecutionInput, "Invalid State Machine Execution Input: #{err}: was expecting (JSON String, Number, Array, Object or token 'null', 'true' or 'false')"
       end
 
       def execution
@@ -33,7 +37,7 @@ module Floe
       end
 
       def failed?
-        output&.key?("Error") || false
+        (output.kind_of?(Hash) && output.key?("Error")) || false
       end
 
       def ended?
@@ -48,10 +52,18 @@ module Floe
         state["Input"]
       end
 
+      def json_input
+        input.to_json
+      end
+
       def output
         state["Output"]
       end
 
+      def json_output
+        output.to_json
+      end
+
       def output=(val)
         state["Output"] = val
       end
@@ -84,6 +96,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/error_matcher_mixin.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Floe
+  class Workflow
+    # Methods for common error handling
+    module ErrorMatcherMixin
+      # @param [String] error the error thrown
+      def match_error?(error)
+        return false if error == "States.Runtime"
+        return true if error_equals.include?("States.ALL")
+        return true if error_equals.include?("States.Timeout") && error == "States.HeartbeatTimeout"
+
+        error_equals.include?(error)
+      end
+    end
+  end
+end

data/lib/floe/workflow/intrinsic_function/parser.rb

@@ -0,0 +1,100 @@
+require "parslet"
+
+module Floe
+  class Workflow
+    class IntrinsicFunction
+      class Parser < Parslet::Parser
+        rule(:spaces)  { str(' ').repeat(1) }
+        rule(:spaces?) { spaces.maybe }
+        rule(:digit)   { match('[0-9]') }
+        rule(:quote)   { str('\'') }
+
+        rule(:comma_sep) { str(',') >> spaces? }
+
+        rule(:true_literal)  { str('true').as(:true_literal) }
+        rule(:false_literal) { str('false').as(:false_literal) }
+        rule(:null_literal)  { str('null').as(:null_literal) }
+
+        rule(:number) do
+          (
+            str('-').maybe >> (
+              str('0') | (match('[1-9]') >> digit.repeat)
+            ) >> (
+              str('.') >> digit.repeat(1)
+            ).maybe >> (
+              match('[eE]') >> (str('+') | str('-')).maybe >> digit.repeat(1)
+            ).maybe
+          ).as(:number)
+        end
+
+        rule(:string) do
+          (
+            quote >> (
+              (str('\\') >> any) | (quote.absent? >> any)
+            ).repeat >> quote
+          ).as(:string)
+        end
+
+        rule(:jsonpath) do
+          (
+            str('$') >> match('[^,)]').repeat(0)
+          ).as(:jsonpath)
+        end
+
+        rule(:arg) do
+          (
+            string | number | jsonpath | true_literal | false_literal | null_literal | expression
+          ).as(:arg)
+        end
+
+        rule(:args) do
+          (
+            arg >> (comma_sep >> arg).repeat
+          ).maybe.as(:args)
+        end
+
+        [
+          :states_array,           "States.Array",
+          :states_array_partition, "States.ArrayPartition",
+          :states_array_contains,  "States.ArrayContains",
+          :states_array_range,     "States.ArrayRange",
+          :states_array_get_item,  "States.ArrayGetItem",
+          :states_array_length,    "States.ArrayLength",
+          :states_array_unique,    "States.ArrayUnique",
+          :states_base64_encode,   "States.Base64Encode",
+          :states_base64_decode,   "States.Base64Decode",
+          :states_hash,            "States.Hash",
+          :states_math_random,     "States.MathRandom",
+          :states_math_add,        "States.MathAdd",
+          :states_string_split,    "States.StringSplit",
+          :states_uuid,            "States.UUID",
+        ].each_slice(2) do |function_symbol, function_name|
+          rule(function_symbol) do
+            (
+              str(function_name) >> str('(') >> args >> str(')')
+            ).as(function_symbol)
+          end
+        end
+
+        rule(:expression) do
+          states_array |
+            states_array_partition |
+            states_array_contains |
+            states_array_range |
+            states_array_get_item |
+            states_array_length |
+            states_array_unique |
+            states_base64_encode |
+            states_base64_decode |
+            states_hash |
+            states_math_random |
+            states_math_add |
+            states_string_split |
+            states_uuid
+        end
+
+        root(:expression)
+      end
+    end
+  end
+end

data/lib/floe/workflow/intrinsic_function/transformer.rb

@@ -0,0 +1,196 @@
+# Disable rubocops against the `match` method, since this is a Parslet specific
+#   match method and not the typical `Object#match`.
+# rubocop:disable Performance/RegexpMatch, Performance/RedundantMatch
+
+require "parslet"
+
+module Floe
+  class Workflow
+    class IntrinsicFunction
+      class Transformer < Parslet::Transform
+        OptionalArg = Struct.new(:type)
+
+        class << self
+          def process_args(args, function, signature = nil)
+            args = resolve_args(args)
+            if signature
+              check_arity(args, function, signature)
+              check_types(args, function, signature)
+            end
+            args
+          end
+
+          private
+
+          def resolve_args(args)
+            if args.nil?
+              # 0 args
+              []
+            elsif args.kind_of?(Array)
+              # >1 arg
+              args.map { |a| a[:arg] }
+            else
+              # 1 arg
+              [args[:arg]]
+            end
+          end
+
+          def check_arity(args, function, signature)
+            if signature.any?(OptionalArg)
+              signature_without_optional = signature.reject { |a| a.kind_of?(OptionalArg) }
+              signature_size = (signature_without_optional.size..signature.size)
+
+              raise ArgumentError, "wrong number of arguments to #{function} (given #{args.size}, expected #{signature_size})" unless signature_size.include?(args.size)
+            else
+              raise ArgumentError, "wrong number of arguments to #{function} (given #{args.size}, expected #{signature.size})" unless signature.size == args.size
+            end
+          end
+
+          def check_types(args, function, signature)
+            args.zip(signature).each_with_index do |(arg, type), index|
+              type = type.type if type.kind_of?(OptionalArg)
+
+              raise ArgumentError, "wrong type for argument #{index + 1} to #{function} (given #{arg.class}, expected #{type})" unless arg.kind_of?(type)
+            end
+          end
+        end
+
+        rule(:null_literal  => simple(:v)) { nil }
+        rule(:true_literal  => simple(:v)) { true }
+        rule(:false_literal => simple(:v)) { false }
+
+        rule(:string   => simple(:v)) { v.to_s[1..-2] }
+        rule(:number   => simple(:v)) { v.match(/[eE.]/) ? Float(v) : Integer(v) }
+        rule(:jsonpath => simple(:v)) { Floe::Workflow::Path.value(v.to_s, context, input) }
+
+        rule(:states_array => {:args => subtree(:args)}) do
+          Transformer.process_args(args, "States.Array")
+        end
+
+        rule(:states_array_partition => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.ArrayPartition", [Array, Integer])
+          array, chunk = *args
+          raise ArgumentError, "invalid value for argument 2 to States.ArrayPartition (given #{chunk}, expected a positive Integer)" unless chunk.positive?
+
+          array.each_slice(chunk).to_a
+        end
+
+        rule(:states_array_contains => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.ArrayContains", [Array, Object])
+          array, target = *args
+
+          array.include?(target)
+        end
+
+        rule(:states_array_range => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.ArrayRange", [Integer, Integer, Integer])
+          range_begin, range_end, increment = *args
+          raise ArgumentError, "invalid value for argument 3 to States.ArrayRange (given #{increment}, expected a non-zero Integer)" if increment.zero?
+
+          (range_begin..range_end).step(increment).to_a
+        end
+
+        rule(:states_array_get_item => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.ArrayGetItem", [Array, Integer])
+          array, index = *args
+          raise ArgumentError, "invalid value for argument 2 to States.ArrayGetItem (given #{index}, expected 0 or a positive Integer)" unless index >= 0
+
+          array[index]
+        end
+
+        rule(:states_array_length => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.ArrayLength", [Array])
+          array = args.first
+
+          array.size
+        end
+
+        rule(:states_array_unique => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.ArrayUnique", [Array])
+          array = args.first
+
+          array.uniq
+        end
+
+        rule(:states_base64_encode => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.Base64Encode", [String])
+          str = args.first
+
+          require "base64"
+          Base64.strict_encode64(str).force_encoding("UTF-8")
+        end
+
+        rule(:states_base64_decode => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.Base64Decode", [String])
+          str = args.first
+
+          require "base64"
+          begin
+            Base64.strict_decode64(str)
+          rescue ArgumentError => err
+            raise ArgumentError, "invalid value for argument 1 to States.Base64Decode (#{err})"
+          end
+        end
+
+        rule(:states_hash => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.Hash", [Object, String])
+          data, algorithm = *args
+          raise NotImplementedError if data.kind_of?(Hash)
+          if data.nil?
+            raise ArgumentError, "invalid value for argument 1 to States.Hash (given null, expected non-null)"
+          end
+
+          algorithms = %w[MD5 SHA-1 SHA-256 SHA-384 SHA-512]
+          unless algorithms.include?(algorithm)
+            raise ArgumentError, "invalid value for argument 2 to States.Hash (given #{algorithm.inspect}, expected one of #{algorithms.map(&:inspect).join(", ")})"
+          end
+
+          require "openssl"
+          algorithm = algorithm.sub("-", "")
+          data = data.to_json unless data.kind_of?(String)
+          OpenSSL::Digest.hexdigest(algorithm, data)
+        end
+
+        rule(:states_math_random => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.MathRandom", [Integer, Integer, OptionalArg[Integer]])
+          range_start, range_end, seed = *args
+          unless range_start < range_end
+            raise ArgumentError, "invalid values for arguments to States.MathRandom (start must be less than end)"
+          end
+
+          seed ||= Random.new_seed
+          Random.new(seed).rand(range_start..range_end)
+        end
+
+        rule(:states_math_add => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.MathAdd", [Integer, Integer])
+
+          args.sum
+        end
+
+        rule(:states_string_split => {:args => subtree(:args)}) do
+          args = Transformer.process_args(args(), "States.StringSplit", [String, String])
+          str, delimeter = *args
+
+          case delimeter.size
+          when 0
+            str.empty? ? [] : [str]
+          when 1
+            str.split(delimeter)
+          else
+            str.split(/[#{Regexp.escape(delimeter)}]+/)
+          end
+        end
+
+        rule(:states_uuid => {:args => subtree(:args)}) do
+          Transformer.process_args(args, "States.UUID", [])
+
+          require "securerandom"
+          SecureRandom.uuid
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Performance/RegexpMatch, Performance/RedundantMatch

data/lib/floe/workflow/intrinsic_function.rb

@@ -0,0 +1,34 @@
+require "parslet"
+
+module Floe
+  class Workflow
+    class IntrinsicFunction
+      def self.value(payload, context = {}, input = {})
+        new(payload).value(context, input)
+      end
+
+      def self.intrinsic_function?(payload)
+        payload.start_with?("States.")
+      end
+
+      attr_reader :payload
+
+      def initialize(payload)
+        @payload = payload
+        @tree    = Parser.new.parse(payload)
+
+        Floe.logger.debug { "Parsed intrinsic function: #{payload.inspect} => #{tree.inspect}" }
+      rescue Parslet::ParseFailed => err
+        raise Floe::InvalidWorkflowError, err.message
+      end
+
+      def value(context = {}, input = {})
+        Transformer.new.apply(tree, :context => context, :input => input)
+      end
+
+      private
+
+      attr_reader :tree
+    end
+  end
+end

data/lib/floe/workflow/path.rb

@@ -4,6 +4,10 @@ module Floe
   class Workflow
     class Path
       class << self
+        def path?(payload)
+          payload.start_with?("$")
+        end
+
         def value(payload, context, input = {})
           new(payload).value(context, input)
         end
@@ -26,8 +30,10 @@ module Floe
             [input, payload]
           end
 
-        results = JsonPath.on(obj, path)
+        # If path is $ then just return the entire input
+        return obj if path == "$"
 
+        results = JsonPath.on(obj, path)
         results.count < 2 ? results.first : results
       end
     end

data/lib/floe/workflow/payload_template.rb

@@ -42,14 +42,17 @@ module Floe
       end
 
       def parse_payload_string(value)
-        value.start_with?("$") ? Path.new(value) : value
+        return Path.new(value)              if Path.path?(value)
+        return IntrinsicFunction.new(value) if IntrinsicFunction.intrinsic_function?(value)
+
+        value
       end
 
       def interpolate_value(value, context, inputs)
         case value
-        when Array then interpolate_value_array(value, context, inputs)
-        when Hash  then interpolate_value_hash(value, context, inputs)
-        when Path  then value.value(context, inputs)
+        when Array                   then interpolate_value_array(value, context, inputs)
+        when Hash                    then interpolate_value_hash(value, context, inputs)
+        when Path, IntrinsicFunction then value.value(context, inputs)
         else
           value
         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

@@ -3,19 +3,26 @@
 module Floe
   class Workflow
     class Retrier
-      attr_reader :error_equals, :interval_seconds, :max_attempts, :backoff_rate
+      include ErrorMatcherMixin
+      include ValidationMixin
 
-      def initialize(payload)
-        @payload = payload
+      attr_reader :error_equals, :interval_seconds, :max_attempts, :backoff_rate, :name
+
+      def initialize(_workflow, name, payload)
+        @name             = name
+        @payload          = payload
 
         @error_equals     = payload["ErrorEquals"]
         @interval_seconds = payload["IntervalSeconds"] || 1.0
         @max_attempts     = payload["MaxAttempts"] || 3
         @backoff_rate     = payload["BackoffRate"] || 2.0
+
+        missing_field_error!("ErrorEquals") if !@error_equals.kind_of?(Array) || @error_equals.empty?
       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