floe 0.3.0 → 0.4.0

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

@@ -46,33 +46,65 @@ module Floe
           secret = create_secret!(secrets) if secrets && !secrets.empty?
 
           begin
+            runner_context = {"container_ref" => name}
+
             create_pod!(name, image, env, secret)
-            while running?(name)
-              sleep(1)
+            loop do
+              case pod_info(name).dig("status", "phase")
+              when "Pending", "Running"
+                sleep(1)
+              else # also "Succeeded"
+                runner_context["exit_code"] = 0
+                output(runner_context)
+                break
+              end
             end
 
-            exit_status = success?(name) ? 0 : 1
-            results     = output(name)
-
-            [exit_status, results]
+            runner_context
           ensure
-            cleanup(name, secret)
+            cleanup({"container_ref" => name, "secrets_ref" => secret})
+          end
+        end
+
+        def run_async!(resource, env = {}, secrets = {})
+          raise ArgumentError, "Invalid resource" unless resource&.start_with?("docker://")
+
+          image  = resource.sub("docker://", "")
+          name   = pod_name(image)
+          secret = create_secret!(secrets) if secrets && !secrets.empty?
+
+          runner_context = {"container_ref" => name, "secrets_ref" => secret}
+
+          begin
+            create_pod!(name, image, env, secret)
+          rescue
+            cleanup(runner_context)
+            raise
           end
+
+          runner_context
+        end
+
+        def status!(runner_context)
+          runner_context["container_state"] = pod_info(runner_context["container_ref"])["status"]
         end
 
-        def running?(pod_name)
-          %w[Pending Running].include?(pod_info(pod_name).dig("status", "phase"))
+        def running?(runner_context)
+          %w[Pending Running].include?(runner_context.dig("container_state", "phase"))
         end
 
-        def success?(pod_name)
-          pod_info(pod_name).dig("status", "phase") == "Succeeded"
+        def success?(runner_context)
+          runner_context.dig("container_state", "phase") == "Succeeded"
         end
 
-        def output(pod)
-          kubeclient.get_pod_log(pod, namespace).body
+        def output(runner_context)
+          output = kubeclient.get_pod_log(runner_context["container_ref"], namespace).body
+          runner_context["output"] = output
         end
 
-        def cleanup(pod, secret)
+        def cleanup(runner_context)
+          pod, secret = runner_context.values_at("container_ref", "secrets_ref")
+
           delete_pod(pod)       if pod
           delete_secret(secret) if secret
         end
@@ -125,7 +157,7 @@ module Floe
             ]
 
             spec[:spec][:containers][0][:env] << {
-              :name  => "SECRETS",
+              :name  => "_CREDENTIALS",
               :value => "/run/secrets/#{secret}/secret"
             }
 

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

@@ -10,7 +10,20 @@ module Floe
 
           super
 
-          @network = options.fetch("network", "bridge")
+          @identity        = options["identity"]
+          @log_level       = options["log-level"]
+          @network         = options["network"]
+          @noout           = options["noout"].to_s == "true" if options.key?("noout")
+          @root            = options["root"]
+          @runroot         = options["runroot"]
+          @runtime         = options["runtime"]
+          @runtime_flag    = options["runtime-flag"]
+          @storage_driver  = options["storage-driver"]
+          @storage_opt     = options["storage-opt"]
+          @syslog          = options["syslog"].to_s == "true" if options.key?("syslog")
+          @tmpdir          = options["tmpdir"]
+          @transient_store = !!options["transient-store"] if options.key?("transient-store")
+          @volumepath      = options["volumepath"]
         end
 
         def run!(resource, env = {}, secrets = {})
@@ -18,31 +31,123 @@ module Floe
 
           image = resource.sub("docker://", "")
 
-          params  = ["run", :rm]
-          params += [[:net, "host"]] if network == "host"
-          params += env.map { |k, v| [:e, "#{k}=#{v}"] } if env
+          if secrets && !secrets.empty?
+            secret = create_secret(secrets)
+            env["_CREDENTIALS"] = "/run/secrets/#{secret}"
+          end
+
+          output = run_container(image, env, secret)
+
+          {"exit_code" => 0, :output => output}
+        ensure
+          delete_secret(secret) if secret
+        end
+
+        def run_async!(resource, env = {}, secrets = {})
+          raise ArgumentError, "Invalid resource" unless resource&.start_with?("docker://")
+
+          image = resource.sub("docker://", "")
 
           if secrets && !secrets.empty?
-            secret_guid = SecureRandom.uuid
-            AwesomeSpawn.run!("podman", :params => ["secret", "create", secret_guid, "-"], :in_data => secrets.to_json)
+            secret_guid = create_secret(secrets)
+            env["_CREDENTIALS"] = "/run/secrets/#{secret_guid}"
+          end
 
-            params << [:e, "SECRETS=/run/secrets/#{secret_guid}"]
-            params << [:secret, secret_guid]
+          begin
+            container_id = run_container(image, env, secret_guid, :detached => true)
+          rescue
+            cleanup({"container_ref" => container_id, "secrets_ref" => secret_guid})
+            raise
           end
 
+          {"container_ref" => container_id, "secrets_ref" => secret_guid}
+        end
+
+        def cleanup(runner_context)
+          container_id, secret_guid = runner_context.values_at("container_ref", "secrets_ref")
+
+          delete_container(container_id) if container_id
+          delete_secret(secret_guid)     if secret_guid
+        end
+
+        def status!(runner_context)
+          runner_context["container_state"] = inspect_container(runner_context["container_ref"]).first&.dig("State")
+        end
+
+        def running?(runner_context)
+          runner_context.dig("container_state", "Running")
+        end
+
+        def success?(runner_context)
+          runner_context.dig("container_state", "ExitCode") == 0
+        end
+
+        def output(runner_context)
+          output = podman!("logs", runner_context["container_ref"]).output
+          runner_context["output"] = output
+        end
+
+        private
+
+        def run_container(image, env, secret, detached: false)
+          params  = ["run"]
+          params << (detached ? :detach : :rm)
+          params += env.map { |k, v| [:e, "#{k}=#{v}"] }
+          params << [:net, "host"] if @network == "host"
+          params << [:secret, secret] if secret
           params << image
 
           logger.debug("Running podman: #{AwesomeSpawn.build_command_line("podman", params)}")
-          result = AwesomeSpawn.run!("podman", :params => params)
 
-          [result.exit_status, result.output]
-        ensure
-          AwesomeSpawn.run("podman", :params => ["secret", "rm", secret_guid]) if secret_guid
+          result = podman!(*params)
+          result.output
         end
 
-        private
+        def inspect_container(container_id)
+          JSON.parse(podman!("inspect", container_id).output)
+        end
 
-        attr_reader :network
+        def delete_container(container_id)
+          podman!("rm", container_id)
+        rescue
+          nil
+        end
+
+        def create_secret(secrets)
+          secret_guid = SecureRandom.uuid
+          podman!("secret", "create", secret_guid, "-", :in_data => secrets.to_json)
+          secret_guid
+        end
+
+        def delete_secret(secret_guid)
+          podman!("secret", "rm", secret_guid)
+        rescue
+          nil
+        end
+
+        def podman!(*args, **kwargs)
+          params = podman_global_options + args
+
+          AwesomeSpawn.run!("podman", :params => params, **kwargs)
+        end
+
+        def podman_global_options
+          options = []
+          options << [:identity, @identity]                 if @identity
+          options << [:"log-level", @log_level]             if @log_level
+          options << :noout                                 if @noout
+          options << [:root, @root]                         if @root
+          options << [:runroot, @runroot]                   if @runroot
+          options << [:runtime, @runtime]                   if @runtime
+          options << [:"runtime-flag", @runtime_flag]       if @runtime_flag
+          options << [:"storage-driver", @storage_driver]   if @storage_driver
+          options << [:"storage-opt", @storage_opt]         if @storage_opt
+          options << :syslog                                if @syslog
+          options << [:tmpdir, @tmpdir]                     if @tmpdir
+          options << [:"transient-store", @transient_store] if @transient_store
+          options << [:volumepath, @volumepath]             if @volumepath
+          options
+        end
       end
     end
   end

data/lib/floe/workflow/runner.rb

@@ -30,7 +30,27 @@ module Floe
         end
       end
 
-      def run!(image, env = {}, secrets = {})
+      def run!(resource, env = {}, secrets = {})
+        raise NotImplementedError, "Must be implemented in a subclass"
+      end
+
+      def run_async!(_image, _env = {}, _secrets = {})
+        raise NotImplementedError, "Must be implemented in a subclass"
+      end
+
+      def running?(_ref)
+        raise NotImplementedError, "Must be implemented in a subclass"
+      end
+
+      def success?(_ref)
+        raise NotImplementedError, "Must be implemented in a subclass"
+      end
+
+      def output(_ref)
+        raise NotImplementedError, "Must be implemented in a subclass"
+      end
+
+      def cleanup(_ref, _secret)
         raise NotImplementedError, "Must be implemented in a subclass"
       end
     end

data/lib/floe/workflow/state.rb

@@ -29,9 +29,69 @@ module Floe
         @comment  = payload["Comment"]
       end
 
+      def run!(_input = nil)
+        run_wait until run_nonblock! == 0
+      end
+
+      def run_wait(timeout: 5)
+        start = Time.now.utc
+
+        loop do
+          return 0             if ready?
+          return Errno::EAGAIN if timeout.zero? || Time.now.utc - start > timeout
+
+          sleep(1)
+        end
+      end
+
+      def run_nonblock!
+        start(context.input) unless started?
+        return Errno::EAGAIN unless ready?
+
+        finish
+      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
+
+        logger.info("Running state: [#{context.state_name}] with input [#{context.input}]...")
+      end
+
+      def finish
+        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["Duration"]       = finished_time - entered_time
+        context.execution["EndTime"]    = finished_time_iso if context.next_state.nil?
+
+        logger.info("Running state: [#{context.state_name}] with input [#{context.input}]...Complete - next state: [#{context.next_state}] 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?
+      end
+
+      def finished?
+        context.state.key?("FinishedTime")
+      end
     end
   end
 end

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

@@ -16,16 +16,18 @@ module Floe
           @output_path = Path.new(payload.fetch("OutputPath", "$"))
         end
 
-        def run!(input)
+        def start(input)
+          super
           input      = input_path.value(context, input)
           next_state = choices.detect { |choice| choice.true?(context, input) }&.next || default
           output     = output_path.value(context, input)
 
-          [next_state, output]
+          context.next_state = next_state
+          context.output     = output
         end
 
-        def status
-          "running"
+        def running?
+          false
         end
 
         def end?

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

@@ -13,12 +13,16 @@ module Floe
           @error = payload["Error"]
         end
 
-        def run!(input)
-          [nil, input]
+        def start(input)
+          super
+          context.state["Error"] = error
+          context.state["Cause"] = cause
+          context.next_state     = nil
+          context.output         = input
         end
 
-        def status
-          "errored"
+        def running?
+          false
         end
 
         def end?

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

@@ -5,6 +5,7 @@ module Floe
     module States
       class Map < Floe::Workflow::State
         def initialize(*)
+          super
           raise NotImplementedError
         end
       end

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

@@ -5,6 +5,7 @@ module Floe
     module States
       class Parallel < Floe::Workflow::State
         def initialize(*)
+          super
           raise NotImplementedError
         end
       end

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

@@ -19,16 +19,18 @@ module Floe
           @result_path = ReferencePath.new(payload.fetch("ResultPath", "$"))
         end
 
-        def run!(input)
+        def start(input)
+          super
           output = input_path.value(context, input)
           output = result_path.set(output, result) if result && result_path
           output = output_path.value(context, output)
 
-          [@end ? nil : @next, output]
+          context.next_state = end? ? nil : @next
+          context.output     = output
         end
 
-        def status
-          @end ? "success" : "running"
+        def running?
+          false
         end
 
         def end?

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

@@ -10,12 +10,14 @@ module Floe
           super
         end
 
-        def run!(input)
-          [nil, input]
+        def start(input)
+          super
+          context.next_state = nil
+          context.output     = input
         end
 
-        def status
-          "success"
+        def running?
+          false
         end
 
         def end?

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

@@ -15,6 +15,7 @@ module Floe
           @next              = payload["Next"]
           @end               = !!payload["End"]
           @resource          = payload["Resource"]
+          @runner            = Floe::Workflow::Runner.for_resource(@resource)
           @timeout_seconds   = payload["TimeoutSeconds"]
           @retry             = payload["Retry"].to_a.map { |retrier| Retrier.new(retrier) }
           @catch             = payload["Catch"].to_a.map { |catcher| Catcher.new(catcher) }
@@ -26,27 +27,37 @@ module Floe
           @credentials       = PayloadTemplate.new(payload["Credentials"])    if payload["Credentials"]
         end
 
-        def run!(input)
+        def start(input)
+          super
           input = input_path.value(context, input)
           input = parameters.value(context, input) if parameters
 
-          runner = Floe::Workflow::Runner.for_resource(resource)
-          _exit_status, results = runner.run!(resource, input, credentials&.value({}, workflow.credentials))
+          runner_context = runner.run_async!(resource, input, credentials&.value({}, workflow.credentials))
+          context.state["RunnerContext"] = runner_context
+        end
 
-          output = process_output!(input, results)
-          [@end ? nil : @next, output]
-        rescue => err
-          retrier = self.retry.detect { |r| (r.error_equals & [err.to_s, "States.ALL"]).any? }
-          retry if retry!(retrier)
+        def status
+          @end ? "success" : "running"
+        end
+
+        def finish
+          results = runner.output(context.state["RunnerContext"])
 
-          catcher = self.catch.detect { |c| (c.error_equals & [err.to_s, "States.ALL"]).any? }
-          raise if catcher.nil?
+          if success?
+            context.state["Output"] = process_output!(results)
+            context.next_state      = next_state
+          else
+            retry_state!(results) || catch_error!(results)
+          end
 
-          [catcher.next, output]
+          super
+        ensure
+          runner.cleanup(context.state["RunnerContext"])
         end
 
-        def status
-          @end ? "success" : "running"
+        def running?
+          runner.status!(context.state["RunnerContext"])
+          runner.running?(context.state["RunnerContext"])
         end
 
         def end?
@@ -55,7 +66,22 @@ module Floe
 
         private
 
-        def retry!(retrier)
+        attr_reader :runner
+
+        def success?
+          runner.success?(context.state["RunnerContext"])
+        end
+
+        def find_retrier(error)
+          self.retry.detect { |r| (r.error_equals & [error, "States.ALL"]).any? }
+        end
+
+        def find_catcher(error)
+          self.catch.detect { |c| (c.error_equals & [error, "States.ALL"]).any? }
+        end
+
+        def retry_state!(error)
+          retrier = find_retrier(error)
           return if retrier.nil?
 
           # If a different retrier is hit reset the context
@@ -68,11 +94,26 @@ module Floe
 
           return if context["State"]["RetryCount"] > retrier.max_attempts
 
-          Kernel.sleep(retrier.sleep_duration(context["State"]["RetryCount"]))
+          # TODO: Kernel.sleep(retrier.sleep_duration(context["State"]["RetryCount"]))
+          context.next_state = context.state_name
           true
         end
 
-        def process_output!(output, results)
+        def catch_error!(error)
+          catcher = find_catcher(error)
+          raise error if catcher.nil?
+
+          context.next_state = catcher.next
+        end
+
+        def process_input(input)
+          input = input_path.value(context, input)
+          input = parameters.value(context, input) if parameters
+          input
+        end
+
+        def process_output!(results)
+          output = process_input(context.state["Input"])
           return output if results.nil?
           return if output_path.nil?
 
@@ -86,6 +127,10 @@ module Floe
           output  = result_path.set(output, results)
           output_path.value(context, output)
         end
+
+        def next_state
+          end? ? nil : @next
+        end
       end
     end
   end

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

@@ -17,15 +17,22 @@ module Floe
           @output_path = Path.new(payload.fetch("OutputPath", "$"))
         end
 
-        def run!(input)
+        def start(input)
+          super
           input = input_path.value(context, input)
-          sleep(seconds)
-          output = output_path.value(context, input)
-          [@end ? nil : @next, output]
+
+          context.output     = output_path.value(context, input)
+          context.next_state = end? ? nil : @next
         end
 
-        def status
-          @end ? "success" : "running"
+        def running?
+          now = Time.now.utc
+          if now > (Time.parse(context.state["EnteredTime"]) + @seconds)
+            context.state["FinishedTime"] = now.iso8601
+            false
+          else
+            true
+          end
         end
 
         def end?