floe 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c121968c8c3f9c70edaa20c0ab3e7937206623b7c06c0cf0f300aceddcde7814
-  data.tar.gz: 943d9e77a9e8309a771e57fee5d6f70e5026a4d254b0da5072b768a99f427d1a
+  metadata.gz: 8c7a74a5297258d481fb588ae0fa6eb1b22b7ecf5c049865b77ad23d6fb135cb
+  data.tar.gz: 82f73726e293e5345d3e7fa55a0049f881f2dce6e6d46570d2352968907c04b9
 SHA512:
-  metadata.gz: 4fa820c364e8dc3266c2fc1eb29d682e72a9d2ab4d8f154aac3a88ff6d4c35e45e124fe714b80110b52e78a0ab654e25f956bc8a39f45f05f3990c0ab26d01ed
-  data.tar.gz: b62ac48c4105497c1d3dd2f2ef9d8aec60c25bcadf71046e8488175705365d0d84facde34c11f0047660b5ab2f4390f13babbe8ba2ab6becf31027f027e0b833
+  metadata.gz: 32d58e28cd76d936f31f9af2c1091d8a7dd930e47a2197b532c02d6d48df2c82feee696072af701aeca5f2af5437040ea3bace5df622c1ad5d0e47e388884ad2
+  data.tar.gz: 1ee0628fbfde496d00fae67812ac869582b1aca754aca7cf44caa7170edc1b0f6c9100a587770d6f6bb97bc0a948dd8fe0123fd108b9ed037ad71bc62bb8e104

data/CHANGELOG.md

@@ -4,6 +4,16 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [0.9.0] - 2024-02-19
+### Changed
+- Default to wait indefinitely ([#157](https://github.com/ManageIQ/floe/pull/157))
+- Create docker runners factory and add scheme ([#152](https://github.com/ManageIQ/floe/pull/152))
+- Add a watch method to Workflow::Runner for event driven updates ([#95](https://github.com/ManageIQ/floe/pull/95))
+
+### Fixed
+- Fix waiting on extremely short durations ([#160](https://github.com/ManageIQ/floe/pull/160))
+- Fix wait state missing finish ([#159](https://github.com/ManageIQ/floe/pull/159))
+
 ## [0.8.0] - 2024-01-17
 ### Added
 - Add CLI shorthand options for docker runner ([#147](https://github.com/ManageIQ/floe/pull/147))
@@ -126,7 +136,8 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - Initial release
 
-[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.8.0...HEAD
+[Unreleased]: https://github.com/ManageIQ/floe/compare/v0.9.0...HEAD
+[0.9.0]: https://github.com/ManageIQ/floe/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/ManageIQ/floe/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/ManageIQ/floe/compare/v0.6.1...v0.7.0
 [0.6.1]: https://github.com/ManageIQ/floe/compare/v0.6.0...v0.6.1

data/exe/floe

@@ -20,8 +20,6 @@ opts = Optimist.options do
   opt :kubernetes, "Use kubernetes to run images (short for --docker_runner=kubernetes)", :type => :boolean
 end
 
-Optimist.die(:docker_runner, "must be one of #{Floe::Workflow::Runner::TYPES.join(", ")}") unless Floe::Workflow::Runner::TYPES.include?(opts[:docker_runner])
-
 # legacy support for --workflow
 args = ARGV.empty? ? [opts[:workflow], opts[:input]] : ARGV
 Optimist.die(:workflow, "must be specified") if args.empty?
@@ -34,18 +32,13 @@ opts[:docker_runner] ||= "kubernetes" if opts[:kubernetes]
 require "logger"
 Floe.logger = Logger.new($stdout)
 
-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) }
 
-Floe::Workflow::Runner.docker_runner = runner_klass.new(runner_options)
+begin
+  Floe.set_runner("docker", opts[:docker_runner], runner_options)
+rescue ArgumentError => e
+  Optimist.die(:docker_runner, e.message)
+end
 
 credentials =
   if opts[:credentials_given]
@@ -62,13 +55,7 @@ workflows =
 
 # run
 
-outstanding = workflows.dup
-until outstanding.empty?
-  ready = outstanding.select(&:step_nonblock_ready?)
-  ready.map(&:run_nonblock)
-  outstanding -= ready.select(&:end?)
-  sleep(1) if !outstanding.empty?
-end
+Floe::Workflow.wait(workflows, &:run_nonblock)
 
 # display status
 

data/floe.gemspec

@@ -29,7 +29,8 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "awesome_spawn", "~>1.0"
+  spec.add_dependency "awesome_spawn", "~>1.6"
+  spec.add_dependency "io-wait"
   spec.add_dependency "jsonpath", "~>1.1"
   spec.add_dependency "kubeclient", "~>4.7"
   spec.add_dependency "optimist", "~>3.0"

data/lib/floe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Floe
-  VERSION = "0.8.0".freeze
+  VERSION = "0.9.0".freeze
 end

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

@@ -10,6 +10,7 @@ module Floe
 
         def initialize(options = {})
           require "awesome_spawn"
+          require "io/wait"
           require "tempfile"
 
           super
@@ -45,10 +46,63 @@ module Floe
           delete_secret(secrets_file)    if secrets_file
         end
 
+        def wait(timeout: nil, events: %i[create update delete], &block)
+          until_timestamp = Time.now.utc + timeout if timeout
+
+          r, w = IO.pipe
+
+          pid = AwesomeSpawn.run_detached(
+            self.class::DOCKER_COMMAND, :err => :out, :out => w, :params => wait_params(until_timestamp)
+          )
+
+          w.close
+
+          loop do
+            readable_timeout = until_timestamp - Time.now.utc if until_timestamp
+
+            # Wait for our end of the pipe to be readable and if it didn't timeout
+            # get the events from stdout
+            next if r.wait_readable(readable_timeout).nil?
+
+            # Get all events while the pipe is readable
+            notices = []
+            while r.ready?
+              notice = r.gets
+
+              # If the process has exited `r.gets` returns `nil` and the pipe is
+              # always `ready?`
+              break if notice.nil?
+
+              event, runner_context = parse_notice(notice)
+              next if event.nil? || !events.include?(event)
+
+              notices << [event, runner_context]
+            end
+
+            # If we're given a block yield the events otherwise return them
+            if block
+              notices.each(&block)
+            else
+              # Terminate the `docker events` process before returning the events
+              sigterm(pid)
+
+              return notices
+            end
+
+            # Check that the `docker events` process is still alive
+            Process.kill(0, pid)
+          rescue Errno::ESRCH
+            # Break out of the loop if the `docker events` process has exited
+            break
+          end
+        ensure
+          r.close
+        end
+
         def status!(runner_context)
           return if runner_context.key?("Error")
 
-          runner_context["container_state"] = inspect_container(runner_context["container_ref"]).first&.dig("State")
+          runner_context["container_state"] = inspect_container(runner_context["container_ref"])&.dig("State")
         end
 
         def running?(runner_context)
@@ -91,8 +145,45 @@ module Floe
           params << image
         end
 
+        def wait_params(until_timestamp)
+          params = ["events", [:format, "{{json .}}"], [:filter, "type=container"], [:since, Time.now.utc.to_i]]
+          params << [:until, until_timestamp.to_i] if until_timestamp
+          params
+        end
+
+        def parse_notice(notice)
+          notice = JSON.parse(notice)
+
+          status  = notice["status"]
+          event   = docker_event_status_to_event(status)
+          running = event != :delete
+
+          name, exit_code = notice.dig("Actor", "Attributes")&.values_at("name", "exitCode")
+
+          runner_context = {"container_ref" => name, "container_state" => {"Running" => running, "ExitCode" => exit_code.to_i}}
+
+          [event, runner_context]
+        rescue JSON::ParserError
+          []
+        end
+
+        def docker_event_status_to_event(status)
+          case status
+          when "create"
+            :create
+          when "start"
+            :update
+          when "die", "destroy"
+            :delete
+          else
+            :unkonwn
+          end
+        end
+
         def inspect_container(container_id)
-          JSON.parse(docker!("inspect", container_id).output)
+          JSON.parse(docker!("inspect", container_id).output).first
+        rescue
+          nil
         end
 
         def delete_container(container_id)
@@ -116,6 +207,12 @@ module Floe
           secrets_file.path
         end
 
+        def sigterm(pid)
+          Process.kill("TERM", pid)
+        rescue Errno::ESRCH
+          nil
+        end
+
         def global_docker_options
           []
         end

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

@@ -53,7 +53,7 @@ module Floe
           name   = container_name(image)
           secret = create_secret!(secrets) if secrets && !secrets.empty?
 
-          runner_context = {"container_ref" => name, "secrets_ref" => secret}
+          runner_context = {"container_ref" => name, "container_state" => {"phase" => "Pending"}, "secrets_ref" => secret}
 
           begin
             create_pod!(name, image, env, secret)
@@ -102,6 +102,54 @@ module Floe
           delete_secret(secret) if secret
         end
 
+        def wait(timeout: nil, events: %i[create update delete])
+          retry_connection = true
+
+          begin
+            watcher = kubeclient.watch_pods(:namespace => namespace)
+
+            retry_connection = true
+
+            if timeout.to_i > 0
+              timeout_thread = Thread.new do
+                sleep(timeout)
+                watcher.finish
+              end
+            end
+
+            watcher.each do |notice|
+              break if error_notice?(notice)
+
+              event = kube_notice_type_to_event(notice.type)
+              next unless events.include?(event)
+
+              runner_context = parse_notice(notice)
+              next if runner_context.nil?
+
+              if block_given?
+                yield [event, runner_context]
+              else
+                timeout_thread&.kill # If we break out before the timeout, kill the timeout thread
+                return [[event, runner_context]]
+              end
+            end
+          rescue Kubeclient::HttpError => err
+            raise unless err.error_code == 401 && retry_connection
+
+            @kubeclient = nil
+            retry_connection = false
+            retry
+          ensure
+            begin
+              watch&.finish
+            rescue
+              nil
+            end
+
+            timeout_thread&.join(0)
+          end
+        end
+
         private
 
         attr_reader :ca_file, :kubeconfig_file, :kubeconfig_context, :namespace, :server, :token, :verify_ssl
@@ -217,6 +265,41 @@ module Floe
           nil
         end
 
+        def kube_notice_type_to_event(type)
+          case type
+          when "ADDED"
+            :create
+          when "MODIFIED"
+            :update
+          when "DELETED"
+            :delete
+          else
+            :unknown
+          end
+        end
+
+        def error_notice?(notice)
+          return false unless notice.type == "ERROR"
+
+          message = notice.object&.message
+          code    = notice.object&.code
+          reason  = notice.object&.reason
+
+          logger.warn("Received [#{code} #{reason}], [#{message}]")
+
+          true
+        end
+
+        def parse_notice(notice)
+          return if notice.object.nil?
+
+          pod             = notice.object
+          container_ref   = pod.metadata.name
+          container_state = pod.to_h[:status].deep_stringify_keys
+
+          {"container_ref" => container_ref, "container_state" => container_state}
+        end
+
         def kubeclient
           return @kubeclient unless @kubeclient.nil?
 

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

@@ -55,6 +55,32 @@ module Floe
           nil
         end
 
+        def parse_notice(notice)
+          id, status, exit_code = JSON.parse(notice).values_at("ID", "Status", "ContainerExitCode")
+
+          event   = podman_event_status_to_event(status)
+          running = event != :delete
+
+          runner_context = {"container_ref" => id, "container_state" => {"Running" => running, "ExitCode" => exit_code.to_i}}
+
+          [event, runner_context]
+        rescue JSON::ParserError
+          []
+        end
+
+        def podman_event_status_to_event(status)
+          case status
+          when "create"
+            :create
+          when "init", "start"
+            :update
+          when "died", "cleanup", "remove"
+            :delete
+          else
+            :unknown
+          end
+        end
+
         alias podman! docker!
 
         def global_docker_options

data/lib/floe/workflow/runner.rb

@@ -5,29 +5,42 @@ module Floe
     class Runner
       include Logging
 
-      TYPES         = %w[docker podman kubernetes].freeze
       OUTPUT_MARKER = "__FLOE_OUTPUT__\n"
 
       def initialize(_options = {})
       end
 
+      @runners = {}
       class << self
-        attr_writer :docker_runner
+        # deprecated -- use Floe.set_runner instead
+        def docker_runner=(value)
+          set_runner("docker", value)
+        end
 
-        def docker_runner
-          @docker_runner ||= Floe::Workflow::Runner::Docker.new
+        # see Floe.set_runner
+        def set_runner(scheme, name_or_instance, options = {})
+          @runners[scheme] =
+            case name_or_instance
+            when "docker", nil
+              Floe::Workflow::Runner::Docker.new(options)
+            when "podman"
+              Floe::Workflow::Runner::Podman.new(options)
+            when "kubernetes"
+              Floe::Workflow::Runner::Kubernetes.new(options)
+            when Floe::Workflow::Runner
+              name_or_instance
+            else
+              raise ArgumentError, "docker runner must be one of: docker, podman, kubernetes"
+            end
         end
 
         def for_resource(resource)
           raise ArgumentError, "resource cannot be nil" if resource.nil?
 
+          # if no runners are set, default docker:// to docker
+          set_runner("docker", "docker") if @runners.empty?
           scheme = resource.split("://").first
-          case scheme
-          when "docker"
-            docker_runner
-          else
-            raise "Invalid resource scheme [#{scheme}]"
-          end
+          @runners[scheme] || raise(ArgumentError, "Invalid resource scheme [#{scheme}]")
         end
       end
 
@@ -55,6 +68,10 @@ module Floe
       def cleanup(_runner_context)
         raise NotImplementedError, "Must be implemented in a subclass"
       end
+
+      def wait(timeout: nil, events: %i[create update delete])
+        raise NotImplementedError, "Must be implemented in a subclass"
+      end
     end
   end
 end

data/lib/floe/workflow/state.rb

@@ -33,12 +33,12 @@ module Floe
         raise Floe::InvalidWorkflowError, "State name [#{name}] must be less than or equal to 80 characters" if name.length > 80
       end
 
-      def wait(timeout: 5)
+      def wait(timeout: nil)
         start = Time.now.utc
 
         loop do
           return 0             if ready?
-          return Errno::EAGAIN if timeout.zero? || Time.now.utc - start > timeout
+          return Errno::EAGAIN if timeout && (timeout.zero? || Time.now.utc - start > timeout)
 
           sleep(1)
         end
@@ -93,6 +93,14 @@ module Floe
         context.state.key?("FinishedTime")
       end
 
+      def waiting?
+        context.state["WaitUntil"] && Time.now.utc <= Time.parse(context.state["WaitUntil"])
+      end
+
+      def wait_until
+        context.state["WaitUntil"] && Time.parse(context.state["WaitUntil"])
+      end
+
       private
 
       def wait_until!(seconds: nil, time: nil)
@@ -105,10 +113,6 @@ module Floe
             time.iso8601
           end
       end
-
-      def waiting?
-        context.state["WaitUntil"] && Time.now.utc <= Time.parse(context.state["WaitUntil"])
-      end
     end
   end
 end

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

@@ -4,6 +4,11 @@ module Floe
   class Workflow
     module States
       module NonTerminalMixin
+        def finish
+          context.next_state = end? ? nil : @next
+          super
+        end
+
         def validate_state_next!
           raise Floe::InvalidWorkflowError, "Missing \"Next\" field in state [#{name}]" if @next.nil? && !@end
           raise Floe::InvalidWorkflowError, "\"Next\" [#{@next}] not in \"States\" for state [#{name}]" if @next && !workflow.payload["States"].key?(@next)

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

@@ -46,18 +46,19 @@ module Floe
         end
 
         def finish
+          super
+
           output = runner.output(context.state["RunnerContext"])
 
           if success?
             output = parse_output(output)
             context.state["Output"] = process_output(context.input.dup, output)
-            context.next_state      = next_state
           else
+            context.next_state = nil
             error = parse_error(output)
             retry_state!(error) || catch_error!(error) || fail_workflow!(error)
           end
 
-          super
         ensure
           runner.cleanup(context.state["RunnerContext"])
         end

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

@@ -28,10 +28,9 @@ module Floe
 
         def start(input)
           super
-          input = input_path.value(context, input)
 
-          context.output     = output_path.value(context, input)
-          context.next_state = end? ? nil : @next
+          input          = input_path.value(context, input)
+          context.output = output_path.value(context, input)
 
           wait_until!(
             :seconds => seconds_path ? seconds_path.value(context, input).to_i : seconds,

data/lib/floe/workflow.rb

@@ -16,21 +16,72 @@ module Floe
         new(payload, context, credentials, name)
       end
 
-      def wait(workflows, timeout: 5)
+      def wait(workflows, timeout: nil, &block)
+        workflows = [workflows] if workflows.kind_of?(self)
         logger.info("checking #{workflows.count} workflows...")
 
-        start = Time.now.utc
-        ready = []
+        run_until   = Time.now.utc + timeout if timeout.to_i > 0
+        ready       = []
+        queue       = Queue.new
+        wait_thread = Thread.new do
+          loop do
+            Runner.for_resource("docker").wait do |event, runner_context|
+              queue.push([event, runner_context])
+            end
+          end
+        end
 
         loop do
           ready = workflows.select(&:step_nonblock_ready?)
-          break if timeout.zero? || Time.now.utc - start > timeout || !ready.empty?
-
-          sleep(1)
+          break if block.nil? && !ready.empty?
+
+          ready.each(&block)
+
+          # Break if all workflows are completed or we've exceeded the
+          # requested timeout
+          break if workflows.all?(&:end?)
+          break if timeout && (timeout.zero? || Time.now.utc > run_until)
+
+          # Find the earliest time that we should wakeup if no container events
+          # are caught, either a workflow in a Wait or Retry state or we've
+          # exceeded the requested timeout
+          wait_until = workflows.map(&:wait_until)
+                                .unshift(run_until)
+                                .compact
+                                .min
+
+          # If a workflow is in a waiting state wakeup the main thread when
+          # it will be done sleeping
+          if wait_until
+            sleep_thread = Thread.new do
+              sleep_duration = wait_until - Time.now.utc
+              sleep sleep_duration if sleep_duration > 0
+              queue.push(nil)
+            end
+          end
+
+          loop do
+            # Block until an event is raised
+            event, runner_context = queue.pop
+            break if event.nil?
+
+            # If the event is for one of our workflows set the updated runner_context
+            workflows.each do |workflow|
+              next unless workflow.context.state.dig("RunnerContext", "container_ref") == runner_context["container_ref"]
+
+              workflow.context.state["RunnerContext"] = runner_context
+            end
+
+            break if queue.empty?
+          end
+        ensure
+          sleep_thread&.kill
         end
 
         logger.info("checking #{workflows.count} workflows...Complete - #{ready.count} ready")
         ready
+      ensure
+        wait_thread&.kill
       end
     end
 
@@ -74,7 +125,7 @@ module Floe
       current_state.run_nonblock!
     end
 
-    def step_nonblock_wait(timeout: 5)
+    def step_nonblock_wait(timeout: nil)
       current_state.wait(:timeout => timeout)
     end
 
@@ -82,6 +133,14 @@ module Floe
       current_state.ready?
     end
 
+    def waiting?
+      current_state.waiting?
+    end
+
+    def wait_until
+      current_state.wait_until
+    end
+
     def status
       context.status
     end

data/lib/floe.rb

@@ -45,7 +45,27 @@ module Floe
     @logger ||= NullLogger.new
   end
 
+  # Set the logger to use
+  #
+  # @example
+  #   require "logger"
+  #   Floe.logger = Logger.new($stdout)
+  #
+  # @param logger [Logger] logger to use for logging actions
   def self.logger=(logger)
     @logger = logger
   end
+
+  # Set the runner to use
+  #
+  # @example
+  #   Floe.set_runner "docker", kubernetes", {}
+  #   Floe.set_runner "docker", Floe::Workflow::Runner::Kubernetes.new({})
+  #
+  # @param scheme [String] scheme                           Protocol to register (e.g.: docker)
+  # @param name_or_instance [String|Floe::Workflow::Runner] Name of runner to use for docker (e.g.: docker)
+  # @param options [Hash]                                   Options for constructor of the runner (optional)
+  def self.set_runner(scheme, name_or_instance, options = {})
+    Floe::Workflow::Runner.set_runner(scheme, name_or_instance, options)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: floe
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - ManageIQ Developers
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-17 00:00:00.000000000 Z
+date: 2024-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_spawn
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: io-wait
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: jsonpath
   requirement: !ruby/object:Gem::Requirement