nonnative 2.1.0 → 2.10.0

data/lib/nonnative/pool.rb

@@ -18,6 +18,9 @@ module Nonnative
     # @param configuration [Nonnative::Configuration] the configuration to run
     def initialize(configuration)
       @configuration = configuration
+      @services = nil
+      @servers = nil
+      @processes = nil
     end
 
     # Starts all configured runners and yields results for each process/server.
@@ -27,10 +30,14 @@ module Nonnative
     # @yieldparam name [String, nil] runner name
     # @yieldparam values [Object] runner-specific return value from `start` (e.g. `[pid, running]` for processes)
     # @yieldparam result [Boolean] result of the port readiness check (`true` if ready in time)
-    # @return [void]
+    # @return [Array<String>] lifecycle and readiness-check errors collected while starting
     def start(&)
-      services.each(&:start)
-      [servers, processes].each { |t| process(t, :start, :open?, &) }
+      errors = []
+
+      errors.concat(service_lifecycle(services, :start, :start))
+      [servers, processes].each { |t| errors.concat(process(t, :start, :open?, :start, &)) }
+
+      errors
     end
 
     # Stops all configured runners and yields results for each process/server.
@@ -40,10 +47,32 @@ module Nonnative
     # @yieldparam name [String, nil] runner name
     # @yieldparam id [Object] runner-specific identifier returned by `stop` (e.g. pid or object_id)
     # @yieldparam result [Boolean] result of the port shutdown check (`true` if closed in time)
-    # @return [void]
+    # @return [Array<String>] lifecycle and shutdown-check errors collected while stopping
     def stop(&)
-      [processes, servers].each { |t| process(t, :stop, :closed?, &) }
-      services.each(&:stop)
+      errors = []
+
+      [processes, servers].each { |t| errors.concat(process(t, :stop, :closed?, :stop, &)) }
+      errors.concat(service_lifecycle(services, :stop, :stop))
+
+      errors
+    end
+
+    # Stops only runners that have already been instantiated in this pool.
+    #
+    # This is used to rollback partial startup after a failed {#start} without constructing new runner
+    # wrappers as a side effect.
+    #
+    # @yieldparam name [String, nil] runner name
+    # @yieldparam id [Object] runner-specific identifier returned by `stop`
+    # @yieldparam result [Boolean] result of the port shutdown check (`true` if closed in time)
+    # @return [Array<String>] lifecycle and shutdown-check errors collected while rolling back
+    def rollback(&)
+      errors = []
+
+      [existing_processes, existing_servers].each { |t| errors.concat(process(t, :stop, :closed?, :stop, &)) }
+      errors.concat(service_lifecycle(existing_services, :stop, :stop))
+
+      errors
     end
 
     # Finds a running process runner by configured name.
@@ -96,41 +125,103 @@ module Nonnative
     end
 
     def processes
-      @processes ||= configuration.processes.map do |p|
-        [Nonnative::Process.new(p), Nonnative::Port.new(p)]
+      return @processes unless @processes.nil?
+
+      @processes = []
+      configuration.processes.each do |p|
+        @processes << [Nonnative::Process.new(p), Nonnative::Port.new(p)]
       end
+
+      @processes
     end
 
     def servers
-      @servers ||= configuration.servers.map do |s|
-        [s.klass.new(s), Nonnative::Port.new(s)]
+      return @servers unless @servers.nil?
+
+      @servers = []
+      configuration.servers.each do |s|
+        @servers << [s.klass.new(s), Nonnative::Port.new(s)]
       end
+
+      @servers
     end
 
     def services
-      @services ||= configuration.services.map { |s| Nonnative::Service.new(s) }
+      return @services unless @services.nil?
+
+      @services = []
+      configuration.services.each do |s|
+        @services << Nonnative::Service.new(s)
+      end
+
+      @services
+    end
+
+    def existing_processes
+      @processes || []
+    end
+
+    def existing_servers
+      @servers || []
+    end
+
+    def existing_services
+      @services || []
     end
 
-    def process(all, type_method, port_method, &)
-      types = []
-      pids = []
-      threads = []
+    def service_lifecycle(all, type_method, action)
+      all.each_with_object([]) do |service, errors|
+        service.send(type_method)
+      rescue StandardError => e
+        errors << lifecycle_error(action, service, e)
+      end
+    end
+
+    def process(all, type_method, port_method, action, &)
+      checks = []
+      errors = []
 
       all.each do |type, port|
-        types << type
-        pids << type.send(type_method)
-        threads << Thread.new { port.send(port_method) }
+        values = type.send(type_method)
+        checks << [type, values, Thread.new { check_port(port, port_method) }]
+      rescue StandardError => e
+        errors << lifecycle_error(action, type, e)
       end
 
-      ports = threads.map(&:value)
+      errors.concat(yield_results(checks, action, &))
+    end
 
-      yield_results(types, pids, ports, &)
+    def check_port(port, port_method)
+      { result: port.send(port_method) }
+    rescue StandardError => e
+      { error: e }
     end
 
-    def yield_results(all, pids, ports)
-      all.zip(pids, ports).each do |type, values, result|
-        yield type.name, values, result
+    def yield_results(checks, action, &)
+      checks.each_with_object([]) do |(type, values, thread), errors|
+        result = thread.value
+        if result[:error]
+          errors << port_error(action, type, result[:error])
+        elsif block_given?
+          yield type.name, values, result[:result]
+        end
       end
     end
+
+    def lifecycle_error(action, type, error)
+      "#{action.to_s.capitalize} failed for #{runner_name(type)}: #{error.class} - #{error.message}"
+    end
+
+    def port_error(action, type, error)
+      check = action == :start ? 'readiness' : 'shutdown'
+      "#{check.capitalize} check failed for #{runner_name(type)}: #{error.class} - #{error.message}"
+    end
+
+    def runner_name(type)
+      name = type.name
+      return "runner '#{name}'" if name
+
+      type.class.to_s
+    end
   end
 end

data/lib/nonnative/process.rb

@@ -45,11 +45,12 @@ module Nonnative
     def stop
       if process_exists?
         process_kill
-        proxy.stop
         wait_stop
       end
 
       pid
+    ensure
+      proxy.stop
     end
 
     # Returns a memoized memory reader for the spawned process.

data/lib/nonnative/version.rb

@@ -4,5 +4,5 @@ module Nonnative
   # The current gem version.
   #
   # @return [String]
-  VERSION = '2.1.0'
+  VERSION = '2.10.0'
 end

data/lib/nonnative.rb

@@ -53,7 +53,6 @@ require 'rest-client'
 require 'retriable'
 require 'concurrent'
 require 'config'
-require 'cucumber'
 require 'get_process_mem'
 require 'rspec-benchmark'
 require 'rspec/expectations'
@@ -109,10 +108,10 @@ require 'nonnative/header'
 # @see Nonnative::Pool for lifecycle orchestration once started
 module Nonnative
   class << self
-    # Returns the current runner pool (created on {Nonnative.start}).
+    # Returns or overrides the current runner pool (created on {Nonnative.start}).
     #
     # @return [Nonnative::Pool, nil] the pool instance, or `nil` if not started yet
-    attr_reader :pool
+    attr_accessor :pool
 
     # Loads one or more configuration files using the `config` gem.
     #
@@ -210,13 +209,19 @@ module Nonnative
     def start
       @pool ||= Nonnative::Pool.new(configuration)
       errors = []
-
-      @pool.start do |name, values, result|
+      errors.concat(@pool.start do |name, values, result|
         id, started = values
-        errors << "Started #{name} with id #{id}, though did respond in time" if !started || !result
-      end
+        errors << "Started #{name} with id #{id}, though did not respond in time" if !started || !result
+      end)
+      nil
+    rescue StandardError => e
+      errors << unexpected_lifecycle_error(:start, e)
+    ensure
+      if errors.any?
+        errors.concat(rollback_start)
 
-      raise Nonnative::StartError, errors.join("\n") unless errors.empty?
+        raise Nonnative::StartError, errors.join("\n")
+      end
     end
 
     # Stops all configured processes and servers, then services, and waits for shutdown.
@@ -224,14 +229,16 @@ module Nonnative
     # @return [void]
     # @raise [Nonnative::StopError] if one or more runners fail to stop in time
     def stop
-      return if @pool.nil?
-
       errors = []
+      return if @pool.nil?
 
-      @pool.stop do |name, id, result|
-        errors << "Stopped #{name} with id #{id}, though did respond in time" unless result
-      end
-
+      errors.concat(@pool.stop do |name, id, result|
+        errors << "Stopped #{name} with id #{id}, though did not respond in time" unless result
+      end)
+      nil
+    rescue StandardError => e
+      errors << unexpected_lifecycle_error(:stop, e)
+    ensure
       raise Nonnative::StopError, errors.join("\n") unless errors.empty?
     end
 
@@ -242,6 +249,22 @@ module Nonnative
       @configuration = nil
     end
 
+    # Closes and clears the memoized logger instance.
+    #
+    # @return [void]
+    def clear_logger
+      @logger&.close
+    ensure
+      @logger = nil
+    end
+
+    # Clears the memoized observability client.
+    #
+    # @return [void]
+    def clear_observability
+      @observability = nil
+    end
+
     # Clears the memoized pool instance.
     #
     # @return [void]
@@ -249,10 +272,12 @@ module Nonnative
       @pool = nil
     end
 
-    # Clears memoized configuration and pool.
+    # Clears memoized configuration, logger, observability client, and pool.
     #
     # @return [void]
     def clear
+      clear_logger
+      clear_observability
       clear_configuration
       clear_pool
     end
@@ -264,5 +289,24 @@ module Nonnative
     def reset
       Nonnative.pool.reset
     end
+
+    private
+
+    def rollback_start
+      errors = []
+      return errors if @pool.nil?
+
+      errors.concat(@pool.rollback do |name, id, result|
+        errors << "Rollback failed for #{name} with id #{id}, because it did not stop in time" unless result
+      end)
+    rescue StandardError => e
+      errors << unexpected_lifecycle_error(:rollback, e)
+    ensure
+      clear_pool if errors.empty?
+    end
+
+    def unexpected_lifecycle_error(action, error)
+      "#{action.to_s.capitalize} failed with #{error.class}: #{error.message}"
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nonnative
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.10.0
 platform: ruby
 authors:
 - Alejandro Falkowski