active_postgres 0.9.5 → 0.9.7

data/lib/active_postgres/configuration.rb

@@ -1,9 +1,14 @@
 require 'yaml'
+require_relative 'configuration/pgbackrest_policy'
+require_relative 'configuration/standby_policy'
 
 module ActivePostgres
   class Configuration
-    attr_reader :environment, :version, :user, :ssh_key, :ssh_host_key_verification, :primary, :standbys, :components, :secrets_config,
-                :database_config
+    include PgBackRestPolicy
+    include StandbyPolicy
+
+    attr_reader :environment, :version, :user, :ssh_key, :ssh_known_hosts_file, :ssh_host_key_verification,
+                :primary, :standbys, :jump_hosts, :components, :secrets_config, :database_config
 
     def initialize(config_hash, environment = 'development')
       @environment = environment
@@ -14,6 +19,7 @@ module ActivePostgres
       @version = env_config['version'] || 18
       @user = env_config['user'] || 'ubuntu'
       @ssh_key = File.expand_path(env_config['ssh_key'] || '~/.ssh/id_rsa')
+      @ssh_known_hosts_file = optional_path(env_config['ssh_known_hosts_file'])
       @ssh_host_key_verification = normalize_ssh_host_key_verification(
         env_config['ssh_host_key_verification'] || env_config['ssh_verify_host_key']
       )
@@ -21,6 +27,7 @@ module ActivePostgres
       @primary = env_config['primary'] || {}
       @standbys = env_config['standby'] || []
       @standbys = [@standbys] unless @standbys.is_a?(Array)
+      @jump_hosts = env_config['jump_hosts'] || {}
 
       @components = parse_components(env_config['components'] || {})
       @secrets_config = env_config['secrets'] || {}
@@ -111,6 +118,24 @@ module ActivePostgres
       @standbys.find { |s| s['host'] == host }
     end
 
+    def node_config_for(host)
+      return @primary if host == primary_host
+
+      standby_config_for(host)
+    end
+
+    def jump_host_config_for(host)
+      jump_host_name = node_config_for(host)&.dig('jump_host')
+      return unless jump_host_name
+
+      @jump_hosts[jump_host_name] || raise(Error, "Host #{host} jump_host not found: #{jump_host_name}")
+    end
+
+    def repmgr_config_for(host)
+      overrides = node_config_for(host)&.dig('repmgr') || {}
+      component_config(:repmgr).merge(symbolize_keys(overrides))
+    end
+
     def node_label_for(host)
       if host == primary_host
         @primary['label']
@@ -125,23 +150,15 @@ module ActivePostgres
       # Validate required secrets if components are enabled
       raise Error, 'Missing replication_password secret' if component_enabled?(:repmgr) && !secrets_config['replication_password']
       raise Error, 'Missing monitoring_password secret' if component_enabled?(:monitoring) && !secrets_config['monitoring_password']
+
       if component_enabled?(:monitoring)
         grafana_config = component_config(:monitoring)[:grafana] || {}
-        if grafana_config[:enabled] && !secrets_config['grafana_admin_password']
-          raise Error, 'Missing grafana_admin_password secret'
-        end
+        raise Error, 'Missing grafana_admin_password secret' if grafana_config[:enabled] && !secrets_config['grafana_admin_password']
         if grafana_config[:enabled] && grafana_config[:host].to_s.strip.empty?
           raise Error, 'monitoring.grafana.host is required when grafana is enabled'
         end
       end
-      if component_enabled?(:pgbackrest)
-        pg_config = component_config(:pgbackrest)
-        retention_full = pg_config[:retention_full]
-        retention_archive = pg_config[:retention_archive]
-        if retention_full && retention_archive && retention_archive.to_i < retention_full.to_i
-          raise Error, 'pgbackrest.retention_archive must be >= retention_full for PITR safety'
-        end
-      end
+      validate_pgbackrest!
 
       if component_enabled?(:pgbouncer)
         pgbouncer_app_hosts.each do |app_host|
@@ -150,27 +167,38 @@ module ActivePostgres
         end
       end
 
-        if component_enabled?(:repmgr)
-          dns_failover = component_config(:repmgr)[:dns_failover]
-          if dns_failover && dns_failover[:enabled]
-            domains = Array(dns_failover[:domains] || dns_failover[:domain]).map(&:to_s).map(&:strip).reject(&:empty?)
-            servers = Array(dns_failover[:dns_servers])
-            provider = (dns_failover[:provider] || 'dnsmasq').to_s.strip
-
-            raise Error, 'dns_failover.domain or dns_failover.domains is required when enabled' if domains.empty?
-            raise Error, 'dns_failover.dns_servers is required when enabled' if servers.empty?
-            raise Error, "Unsupported dns_failover provider '#{provider}'" unless provider == 'dnsmasq'
-
-            servers.each do |server|
-              next unless server.is_a?(Hash)
-
-              ssh_host = server['ssh_host'] || server[:ssh_host] || server['host'] || server[:host]
-              private_ip = server['private_ip'] || server[:private_ip] || server['ip'] || server[:ip]
-              raise Error, 'dns_failover.dns_servers entries must include host/ssh_host or private_ip' if
-                (ssh_host.nil? || ssh_host.to_s.strip.empty?) && (private_ip.nil? || private_ip.to_s.strip.empty?)
-            end
+      all_hosts.each do |host|
+        jump_host_name = node_config_for(host)&.dig('jump_host')
+        next unless jump_host_name
+
+        jump_host = @jump_hosts[jump_host_name]
+        raise Error, "Host #{host} jump_host not found: #{jump_host_name}" unless jump_host
+        raise Error, "Jump host #{jump_host_name} must include host" if jump_host['host'].to_s.strip.empty?
+      end
+
+      validate_standby_seed_methods!
+
+      if component_enabled?(:repmgr)
+        dns_failover = component_config(:repmgr)[:dns_failover]
+        if dns_failover && dns_failover[:enabled]
+          domains = Array(dns_failover[:domains] || dns_failover[:domain]).map(&:to_s).map(&:strip).reject(&:empty?)
+          servers = Array(dns_failover[:dns_servers])
+          provider = (dns_failover[:provider] || 'dnsmasq').to_s.strip
+
+          raise Error, 'dns_failover.domain or dns_failover.domains is required when enabled' if domains.empty?
+          raise Error, 'dns_failover.dns_servers is required when enabled' if servers.empty?
+          raise Error, "Unsupported dns_failover provider '#{provider}'" unless provider == 'dnsmasq'
+
+          servers.each do |server|
+            next unless server.is_a?(Hash)
+
+            ssh_host = server['ssh_host'] || server[:ssh_host] || server['host'] || server[:host]
+            private_ip = server['private_ip'] || server[:private_ip] || server['ip'] || server[:ip]
+            raise Error, 'dns_failover.dns_servers entries must include host/ssh_host or private_ip' if
+              (ssh_host.nil? || ssh_host.to_s.strip.empty?) && (private_ip.nil? || private_ip.to_s.strip.empty?)
           end
         end
+      end
 
       true
     end
@@ -247,12 +275,6 @@ module ActivePostgres
       result
     end
 
-    def node_config_for(host)
-      return @primary if host == primary_host
-
-      standby_config_for(host)
-    end
-
     def private_ip_for(node_config)
       return unless node_config
 
@@ -296,5 +318,9 @@ module ActivePostgres
       raise Error,
             "Invalid ssh_host_key_verification '#{value}'. Use 'always' or 'accept_new'."
     end
+
+    def optional_path(path)
+      File.expand_path(path) if path
+    end
   end
 end

data/lib/active_postgres/deployment_flow.rb

@@ -13,12 +13,16 @@ module ActivePostgres
       @skip_validation = skip_validation
     end
 
-    def execute
+    def execute(dry_run: false)
       ErrorHandler.with_handling(context: { operation: operation_name }) do
         print_header
         validate_prerequisites
         run_preflight_checks unless skip_validation
         print_deployment_plan
+        if dry_run
+          logger.info "\n[DRY RUN] No changes made."
+          return
+        end
         return unless confirm_deployment
 
         rollback_manager.with_rollback(description: operation_name) do

data/lib/active_postgres/direct_executor.rb

@@ -62,19 +62,13 @@ module ActivePostgres
       return nil if value.nil?
 
       # Handle Rails credentials
-      if value.start_with?('rails_credentials:')
-        return resolve_rails_credentials(value)
-      end
+      return resolve_rails_credentials(value) if value.start_with?('rails_credentials:')
 
       # Handle environment variables
-      if value.start_with?('$')
-        return ENV[value[1..]]
-      end
+      return ENV.fetch(value[1..], nil) if value.start_with?('$')
 
       # Handle shell commands
-      if value.start_with?('$(') && value.end_with?(')')
-        return `#{value[2..-2]}`.strip
-      end
+      return `#{value[2..-2]}`.strip if value.start_with?('$(') && value.end_with?(')')
 
       value
     end

data/lib/active_postgres/error_handler.rb

@@ -127,24 +127,24 @@ module ActivePostgres
 
       # Identify error type from error message
       def identify_error_type(message)
-        case message.downcase
-        when /ssh|connection refused|network unreachable/
-          :ssh_connection
-        when /private network|vpn|wireguard network/
-          :private_network_connectivity
-        when /postgresql.*not.*start|cluster.*not.*running/
-          :postgresql_not_starting
-        when /repmgr.*clone|data directory/
-          :repmgr_clone_failed
-        when /repmgr.*register|unable to connect to.*primary/
-          :repmgr_register_failed
-        when /ssl|certificate|tls/
-          :ssl_certificate_error
-        when /no space|disk full/
-          :disk_space_error
-        when /authentication|password|pg_hba/
-          :authentication_failed
-        end
+        normalized = message.to_s.downcase
+
+        return :ssh_connection if contains_any?(normalized, 'ssh', 'connection refused', 'network unreachable')
+        return :private_network_connectivity if contains_any?(normalized, 'private network', 'vpn', 'wireguard network')
+        return :postgresql_not_starting if normalized.include?('postgresql') && normalized.include?('not') && normalized.include?('start')
+        return :postgresql_not_starting if normalized.include?('cluster') && normalized.include?('not') && normalized.include?('running')
+        return :repmgr_clone_failed if normalized.include?('repmgr') && normalized.include?('clone')
+        return :repmgr_clone_failed if normalized.include?('data directory')
+        return :repmgr_register_failed if normalized.include?('repmgr') && normalized.include?('register')
+        return :repmgr_register_failed if normalized.include?('unable to connect to') && normalized.include?('primary')
+        return :ssl_certificate_error if contains_any?(normalized, 'ssl', 'certificate', 'tls')
+        return :disk_space_error if contains_any?(normalized, 'no space', 'disk full')
+
+        :authentication_failed if contains_any?(normalized, 'authentication', 'password', 'pg_hba')
+      end
+
+      def contains_any?(value, *needles)
+        needles.any? { |needle| value.include?(needle) }
       end
 
       # Show troubleshooting guide for a specific error type

data/lib/active_postgres/generators/active_postgres/templates/postgres.yml.erb

@@ -57,6 +57,13 @@ shared: &shared
     
     pgbackrest:
       enabled: false
+      # For large, frequently changed relation files, bundle repository objects
+      # and back up changed blocks instead of copying each whole file.
+      # repo_bundle: true
+      # repo_block: true
+      # schedule_full: "0 2 * * 0"
+      # schedule_differential: "35 2 * * 1-6"
+      # schedule_incremental: "5 */4 * * *"
     
     monitoring:
       enabled: false

data/lib/active_postgres/health_checker.rb

@@ -12,14 +12,6 @@ module ActivePostgres
       @executor
     end
 
-    private def create_executor
-      if use_ssh_executor?
-        SSHExecutor.new(config, quiet: true)
-      else
-        DirectExecutor.new(config, quiet: true)
-      end
-    end
-
     def use_ssh_executor?
       mode = ENV['ACTIVE_POSTGRES_STATUS_MODE'].to_s.strip.downcase
       return true if mode == 'ssh'
@@ -131,6 +123,14 @@ module ActivePostgres
 
     private
 
+    def create_executor
+      if use_ssh_executor?
+        SSHExecutor.new(config, quiet: true)
+      else
+        DirectExecutor.new(config, quiet: true)
+      end
+    end
+
     def collect_node_status
       nodes = []
 
@@ -184,9 +184,7 @@ module ActivePostgres
         lag: [3, nodes.map { |n| n[:lag].to_s.length }.max].max
       }
 
-      if config.component_enabled?(:pgbouncer)
-        cols[:pgbouncer] = [9, nodes.map { |n| n[:pgbouncer].to_s.length }.max].max
-      end
+      cols[:pgbouncer] = [9, nodes.map { |n| n[:pgbouncer].to_s.length }.max].max if config.component_enabled?(:pgbouncer)
 
       cols
     end
@@ -194,7 +192,7 @@ module ActivePostgres
     def print_table_header(cols)
       fmt = "%-#{cols[:role]}s  %-#{cols[:host]}s  %-#{cols[:private_ip]}s  " \
             "%-#{cols[:label]}s  %-#{cols[:status]}s  %#{cols[:conn]}s  %#{cols[:lag]}s"
-      headers = %w[Role Host Private\ IP Label Status Conn Lag]
+      headers = ['Role', 'Host', 'Private IP', 'Label', 'Status', 'Conn', 'Lag']
 
       if cols[:pgbouncer]
         fmt += "  %-#{cols[:pgbouncer]}s"

data/lib/active_postgres/installer.rb

@@ -28,7 +28,7 @@ module ActivePostgres
         rollback_manager: rollback_manager,
         skip_validation: skip_validation
       )
-      flow.execute
+      flow.execute(dry_run: dry_run)
     end
 
     def setup_component(component_name)
@@ -117,7 +117,7 @@ module ActivePostgres
         rollback_manager: rollback_manager,
         skip_validation: skip_validation
       )
-      flow.execute
+      flow.execute(dry_run: dry_run)
     end
   end
 end

data/lib/active_postgres/overview.rb

@@ -61,14 +61,14 @@ module ActivePostgres
         label = config.node_label_for(host)
         stats = fetch_system_stats(host, paths)
         if stats.nil?
-          puts "  #{host}#{label ? " (#{label})" : ''}: unavailable"
+          puts "  #{host}#{" (#{label})" if label}: unavailable"
           next
         end
 
         mem_used_kb = stats[:mem_total_kb] - stats[:mem_avail_kb]
         mem_pct = stats[:mem_total_kb].positive? ? (mem_used_kb.to_f / stats[:mem_total_kb] * 100).round : 0
 
-        puts "  #{host}#{label ? " (#{label})" : ''}: load #{stats[:loadavg]} | cpu #{stats[:cpu]}% | " \
+        puts "  #{host}#{" (#{label})" if label}: load #{stats[:loadavg]} | cpu #{stats[:cpu]}% | " \
              "mem #{format_kb(mem_used_kb)}/#{format_kb(stats[:mem_total_kb])} (#{mem_pct}%)"
 
         stats[:disks].each do |disk|
@@ -227,7 +227,7 @@ module ActivePostgres
       with_timeout("system stats #{host}") do
         ssh_executor = executor
         safe_paths = paths.map { |p| Shellwords.escape(p) }.join(' ')
-        script = <<~'BASH'
+        script = <<~BASH
           set -e
           loadavg=$(cut -d' ' -f1-3 /proc/loadavg)
 
@@ -256,7 +256,7 @@ module ActivePostgres
 
         ssh_executor.execute_on_host(host) do
           output = capture(:bash, '-lc', "#{script}\n df -kP #{safe_paths} 2>/dev/null | tail -n +2 | " \
-                                        "awk '{print \"disk=\" $6 \"|\" $2 \"|\" $3 \"|\" $4 \"|\" $5}'",
+                                         "awk '{print \"disk=\" $6 \"|\" $2 \"|\" $3 \"|\" $4 \"|\" $5}'",
                            raise_on_non_zero_exit: false).to_s
         end
       end
@@ -299,12 +299,12 @@ module ActivePostgres
       stats
     end
 
-    def format_kb(kb)
-      kb = kb.to_f
-      gb = kb / 1024 / 1024
+    def format_kb(kilobytes)
+      kilobytes = kilobytes.to_f
+      gb = kilobytes / 1024 / 1024
       return format('%.1fG', gb) if gb >= 1
 
-      mb = kb / 1024
+      mb = kilobytes / 1024
       format('%.0fM', mb)
     end
 
@@ -342,8 +342,8 @@ module ActivePostgres
       value.positive? ? value : DEFAULT_TIMEOUT
     end
 
-    def with_timeout(label)
-      Timeout.timeout(overview_timeout) { yield }
+    def with_timeout(label, &)
+      Timeout.timeout(overview_timeout, &)
     rescue Timeout::Error
       raise StandardError, "#{label} timed out after #{overview_timeout}s"
     end

data/lib/active_postgres/secrets.rb

@@ -20,8 +20,8 @@ module ActivePostgres
     end
 
     def resolve_all
-      config.secrets_config.keys.each_with_object({}) do |key, result|
-        result[key] = resolve(key)
+      config.secrets_config.keys.to_h do |key|
+        [key, resolve(key)]
       end
     end
 
@@ -47,8 +47,9 @@ module ActivePostgres
 
       resolve_all.each do |key, value|
         file_path = File.join(directory, key)
-        File.write(file_path, value)
-        File.chmod(0o600, file_path)
+        File.open(file_path, File::WRONLY | File::CREAT | File::TRUNC, 0o600) do |file|
+          file.write(value)
+        end
         puts "Cached #{key} to #{file_path}"
       end
 
@@ -101,9 +102,7 @@ module ActivePostgres
 
       # Try loading just the Rails application (without full initialization)
       # This makes Rails.application available for credential access
-      if File.exist?('./config/application.rb')
-        require './config/application'
-      end
+      require './config/application' if File.exist?('./config/application.rb')
     rescue StandardError
       # Rails boot failed — CLI running outside a Rails project
       nil

data/lib/active_postgres/ssh_executor.rb

@@ -1,6 +1,8 @@
 require 'sshkit'
 require 'sshkit/dsl'
+require 'net/ssh/proxy/command'
 require 'securerandom'
+require 'shellwords'
 require 'stringio'
 
 module ActivePostgres
@@ -20,11 +22,11 @@ module ActivePostgres
     end
 
     def execute_on_host(host, &)
-      on("#{config.user}@#{host}", &)
+      on(ssh_host_for(host), &)
     end
 
     def execute_on_host_as(host, user, &)
-      on("#{user}@#{host}", &)
+      on(ssh_host_for(host, user:), &)
     end
 
     def execute_on_primary(&)
@@ -32,12 +34,12 @@ module ActivePostgres
     end
 
     def execute_on_standbys(&)
-      hosts = config.standby_hosts.map { |h| "#{config.user}@#{h}" }
+      hosts = config.standby_hosts.map { |host| ssh_host_for(host) }
       on(hosts, in: :parallel, &)
     end
 
     def execute_on_all_hosts(&)
-      hosts = config.all_hosts.map { |h| "#{config.user}@#{h}" }
+      hosts = config.all_hosts.map { |host| ssh_host_for(host) }
       on(hosts, in: :parallel, &)
     end
 
@@ -215,11 +217,11 @@ module ActivePostgres
       execute_on_host(host) do
         backend = self
         result = executor.run_sql_on_backend(backend, sql,
-                                    postgres_user: postgres_user,
-                                    port: port,
-                                    database: database,
-                                    tuples_only: tuples_only,
-                                    capture: capture)
+                                             postgres_user: postgres_user,
+                                             port: port,
+                                             database: database,
+                                             tuples_only: tuples_only,
+                                             capture: capture)
       end
       result
     end
@@ -307,6 +309,8 @@ module ActivePostgres
           number_of_password_prompts: 0
         }
 
+        options[:user_known_hosts_file] = [config.ssh_known_hosts_file] if config.ssh_known_hosts_file
+
         if config.ssh_key && File.exist?(config.ssh_key)
           options[:keys] = [config.ssh_key]
           options[:keys_only] = true
@@ -315,5 +319,58 @@ module ActivePostgres
         ssh.ssh_options = options
       end
     end
+
+    def ssh_host_for(host, user: config.user)
+      ssh_host = SSHKit::Host.new(host)
+      ssh_host.user = user
+
+      node_config = config.node_config_for(host) || {}
+      ssh_host.port = node_config['ssh_port'] || node_config['port'] if node_config['ssh_port'] || node_config['port']
+
+      options = {
+        verify_host_key: config.ssh_host_key_verification || :always
+      }
+      options[:user_known_hosts_file] = [config.ssh_known_hosts_file] if config.ssh_known_hosts_file
+
+      if node_config['ssh_key']
+        options[:keys] = [File.expand_path(node_config['ssh_key'])]
+        options[:keys_only] = true
+      end
+
+      if (jump_host_config = config.jump_host_config_for(host))
+        options[:proxy] = jump_proxy(jump_host_config)
+      end
+
+      ssh_host.ssh_options = options
+      ssh_host
+    end
+
+    def jump_proxy(jump_host_config)
+      jump_user = jump_host_config['ssh_user'] || jump_host_config['user'] || config.user
+      jump_port = jump_host_config['ssh_port'] || jump_host_config['port']
+      jump_key = jump_host_config['ssh_key'] || config.ssh_key
+      command = [
+        'ssh',
+        '-F', '/dev/null',
+        '-o', 'BatchMode=yes',
+        '-o', 'ForwardAgent=no',
+        '-o', "StrictHostKeyChecking=#{open_ssh_host_key_mode}"
+      ]
+
+      command.push('-o', "UserKnownHostsFile=#{config.ssh_known_hosts_file}") if config.ssh_known_hosts_file
+
+      command.push('-i', File.expand_path(jump_key), '-o', 'IdentitiesOnly=yes') if
+        jump_key && File.exist?(File.expand_path(jump_key))
+
+      command.push('-p', jump_port.to_s) if jump_port
+      command.push('-W', '%h:%p', "#{jump_user}@#{jump_host_config.fetch('host')}")
+
+      command_line = Shellwords.join(command).gsub('\\%h', '%h').gsub('\\%p', '%p')
+      Net::SSH::Proxy::Command.new(command_line)
+    end
+
+    def open_ssh_host_key_mode
+      config.ssh_host_key_verification == :accept_new ? 'accept-new' : 'yes'
+    end
   end
 end

data/lib/active_postgres/standby_deployment_flow.rb

@@ -21,9 +21,9 @@ module ActivePostgres
     def validate_specific_requirements
       abort "❌ #{standby_host} is not configured as a standby in config/postgres.yml" unless config.standby_hosts.include?(standby_host)
 
-      return if config.component_enabled?(:repmgr)
+      abort '❌ repmgr component must be enabled to setup standbys' unless config.component_enabled?(:repmgr)
 
-      abort '❌ repmgr component must be enabled to setup standbys'
+      validate_required_secrets!
     end
 
     def run_preflight_checks
@@ -49,17 +49,22 @@ module ActivePostgres
 
     def list_deployment_steps
       logger.info "  • Install PostgreSQL #{config.version} packages on #{standby_host}"
-      logger.info "  • Clone data from primary: #{config.primary_host}"
+      if config.standby_seed_method_for(standby_host) == :pgbackrest
+        logger.info '  • Restore the latest valid pgBackRest backup as a standby'
+      else
+        logger.info "  • Clone data from primary: #{config.primary_host}"
+      end
       logger.info '  • Register standby with repmgr cluster'
     end
 
     def list_warnings
-      logger.info "\n⚠️  Primary database will NOT be touched"
+      logger.info "\n⚠️  Primary stays online; setup performs idempotent role and repmgr checks"
     end
 
     def deploy_components
       deploy_ssl if config.component_enabled?(:ssl)
       deploy_core
+      deploy_pgbackrest if config.component_enabled?(:pgbackrest)
       deploy_repmgr
       deploy_optional_components
     end
@@ -79,8 +84,15 @@ module ActivePostgres
       end
     end
 
+    def deploy_pgbackrest
+      logger.task('Installing pgBackRest on standby') do
+        component = Components::PgBackRest.new(config, ssh_executor, secrets)
+        component.install_on_standby(standby_host)
+      end
+    end
+
     def deploy_repmgr
-      logger.task('Setting up repmgr and cloning from primary') do
+      logger.task('Setting up repmgr and seeding standby') do
         component = Components::Repmgr.new(config, ssh_executor, secrets)
         register_rollback('repmgr', component)
         component.setup_standby_only(standby_host)
@@ -107,13 +119,39 @@ module ActivePostgres
     end
 
     def register_rollback(component_name, component)
-      rollback_manager.register("Uninstall #{component_name} on #{standby_host}", host: standby_host) do
-        component.uninstall
+      target_host = standby_host
+      captured_logger = logger
+
+      rollback_manager.register("Uninstall #{component_name} on #{target_host}") do
+        if component.respond_to?(:uninstall_from)
+          component.uninstall_from(target_host)
+        else
+          component.uninstall
+        end
       rescue StandardError => e
-        logger.warn "Failed to uninstall #{component_name} on #{standby_host}: #{e.message}"
+        captured_logger.warn "Failed to uninstall #{component_name} on #{target_host}: #{e.message}"
       end
     end
 
+    def validate_required_secrets!
+      required = %w[repmgr_password replication_password]
+      required.push('ssl_cert', 'ssl_key') if config.component_enabled?(:ssl)
+      required << 'monitoring_password' if config.component_enabled?(:monitoring)
+
+      if config.component_enabled?(:pgbackrest)
+        pgbackrest = secrets.resolve_value(config.component_config(:pgbackrest))
+        if pgbackrest[:repo_type] == 's3'
+          required.push('s3_access_key', 's3_secret_key')
+          raise Error, 'pgbackrest.s3_bucket did not resolve' if pgbackrest[:s3_bucket].to_s.empty?
+        end
+      end
+
+      missing = required.uniq.select { |key| secrets.resolve(key).to_s.empty? }
+      return if missing.empty?
+
+      raise Error, "Required standby secrets did not resolve: #{missing.join(', ')}"
+    end
+
     def list_next_steps
       logger.info '  1. Check cluster status: active_postgres status'
       logger.info '  2. Verify replication: Check repmgr cluster show'

data/lib/active_postgres/version.rb

@@ -1,3 +1,3 @@
 module ActivePostgres
-  VERSION = '0.9.5'.freeze
+  VERSION = '0.9.7'.freeze
 end