fix(restore): add 100ms delay between database restores

Ensures PostgreSQL fully closes connections before starting next
restore, preventing potential connection pool exhaustion during
rapid sequential cluster restores.

CHANGELOG.md

@@ -5,6 +5,41 @@ All notable changes to dbbackup will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.42.50] - 2026-01-16 "Ctrl+C Signal Handling Fix"
+
+### Fixed - Proper Ctrl+C/SIGINT Handling in TUI
+- **Added tea.InterruptMsg handling** - Bubbletea v1.3+ sends `InterruptMsg` for SIGINT signals
+  instead of a `KeyMsg` with "ctrl+c", causing cancellation to not work
+- **Fixed cluster restore cancellation** - Ctrl+C now properly cancels running restore operations
+- **Fixed cluster backup cancellation** - Ctrl+C now properly cancels running backup operations
+- **Added interrupt handling to main menu** - Proper cleanup on SIGINT from menu
+- **Orphaned process cleanup** - `cleanup.KillOrphanedProcesses()` called on all interrupt paths
+
+### Changed
+- All TUI execution views now handle both `tea.KeyMsg` ("ctrl+c") and `tea.InterruptMsg`
+- Context cancellation properly propagates to child processes via `exec.CommandContext`
+- No zombie pg_dump/pg_restore/gzip processes left behind on cancellation
+
+## [3.42.49] - 2026-01-16 "Unified Cluster Backup Progress"
+
+### Added - Unified Progress Display for Cluster Backup
+- **Combined overall progress bar** for cluster backup showing all phases:
+  - Phase 1/3: Backing up Globals (0-15% of overall)
+  - Phase 2/3: Backing up Databases (15-90% of overall)
+  - Phase 3/3: Compressing Archive (90-100% of overall)
+- **Current database indicator** - Shows which database is currently being backed up
+- **Phase-aware progress tracking** - New fields in backup progress state:
+  - `overallPhase` - Current phase (1=globals, 2=databases, 3=compressing)
+  - `phaseDesc` - Human-readable phase description
+- **Dual progress bars** for cluster backup:
+  - Overall progress bar showing combined operation progress
+  - Database count progress bar showing individual database progress
+
+### Changed
+- Cluster backup TUI now shows unified progress display matching restore
+- Progress callbacks now include phase information
+- Better visual feedback during entire cluster backup operation
+
 ## [3.42.48] - 2026-01-15 "Unified Cluster Restore Progress"
 
 ### Added - Unified Progress Display for Cluster Restore

bin/README.md

@@ -3,9 +3,9 @@
 This directory contains pre-compiled binaries for the DB Backup Tool across multiple platforms and architectures.
 
 ## Build Information
-- **Version**: 3.42.34
+- **Version**: 3.42.50
-- **Build Time**: 2026-01-16_13:36:18_UTC
+- **Build Time**: 2026-01-16_14:53:54_UTC
-- **Git Commit**: 838c5b8
+- **Git Commit**: 5728b46
 
 ## Recent Updates (v1.1.0)
 - ✅ Fixed TUI progress display with line-by-line output

internal/dedup/chunker_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"crypto/rand"
 	"io"
+	mathrand "math/rand"
 	"testing"
 )
 
@@ -100,12 +101,15 @@ func TestChunker_Deterministic(t *testing.T) {
 
 func TestChunker_ShiftedData(t *testing.T) {
 	// Test that shifted data still shares chunks (the key CDC benefit)
+	// Use deterministic random data for reproducible test results
+	rng := mathrand.New(mathrand.NewSource(42))
+	
 	original := make([]byte, 100*1024)
-	rand.Read(original)
+	rng.Read(original)
 
 	// Create shifted version (prepend some bytes)
 	prefix := make([]byte, 1000)
-	rand.Read(prefix)
+	rng.Read(prefix)
 	shifted := append(prefix, original...)
 
 	// Chunk both

internal/restore/engine.go

@@ -1203,6 +1203,9 @@ func (e *Engine) RestoreCluster(ctx context.Context, archivePath string) error {
 			completedDBTimesMu.Unlock()
 
 			atomic.AddInt32(&successCount, 1)
+			
+			// Small delay to ensure PostgreSQL fully closes connections before next restore
+			time.Sleep(100 * time.Millisecond)
 		}(dbIndex, entry.Name())
 
 		dbIndex++

internal/tui/backup_exec.go

@@ -36,18 +36,22 @@ type BackupExecutionModel struct {
 	spinnerFrame int
 
 	// Database count progress (for cluster backup)
-	dbTotal int
+	dbTotal      int
-	dbDone  int
+	dbDone       int
-	dbName  string // Current database being backed up
+	dbName       string // Current database being backed up
+	overallPhase int    // 1=globals, 2=databases, 3=compressing
+	phaseDesc    string // Description of current phase
 }
 
 // sharedBackupProgressState holds progress state that can be safely accessed from callbacks
 type sharedBackupProgressState struct {
-	mu        sync.Mutex
+	mu           sync.Mutex
-	dbTotal   int
+	dbTotal      int
-	dbDone    int
+	dbDone       int
-	dbName    string
+	dbName       string
-	hasUpdate bool
+	overallPhase int    // 1=globals, 2=databases, 3=compressing
+	phaseDesc    string // Description of current phase
+	hasUpdate    bool
 }
 
 // Package-level shared progress state for backup operations
@@ -68,12 +72,12 @@ func clearCurrentBackupProgress() {
 	currentBackupProgressState = nil
 }
 
-func getCurrentBackupProgress() (dbTotal, dbDone int, dbName string, hasUpdate bool) {
+func getCurrentBackupProgress() (dbTotal, dbDone int, dbName string, overallPhase int, phaseDesc string, hasUpdate bool) {
 	currentBackupProgressMu.Lock()
 	defer currentBackupProgressMu.Unlock()
 
 	if currentBackupProgressState == nil {
-		return 0, 0, "", false
+		return 0, 0, "", 0, "", false
 	}
 
 	currentBackupProgressState.mu.Lock()
@@ -83,7 +87,8 @@ func getCurrentBackupProgress() (dbTotal, dbDone int, dbName string, hasUpdate b
 	currentBackupProgressState.hasUpdate = false
 
 	return currentBackupProgressState.dbTotal, currentBackupProgressState.dbDone,
-		currentBackupProgressState.dbName, hasUpdate
+		currentBackupProgressState.dbName, currentBackupProgressState.overallPhase,
+		currentBackupProgressState.phaseDesc, hasUpdate
 }
 
 func NewBackupExecution(cfg *config.Config, log logger.Logger, parent tea.Model, ctx context.Context, backupType, dbName string, ratio int) BackupExecutionModel {
@@ -171,6 +176,8 @@ func executeBackupWithTUIProgress(parentCtx context.Context, cfg *config.Config,
 			progressState.dbDone = done
 			progressState.dbTotal = total
 			progressState.dbName = currentDB
+			progressState.overallPhase = 2 // Phase 2: Backing up databases
+			progressState.phaseDesc = fmt.Sprintf("Phase 2/3: Databases (%d/%d)", done, total)
 			progressState.hasUpdate = true
 			progressState.mu.Unlock()
 		})
@@ -223,11 +230,13 @@ func (m BackupExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.spinnerFrame = (m.spinnerFrame + 1) % len(spinnerFrames)
 
 			// Poll for database progress updates from callbacks
-			dbTotal, dbDone, dbName, hasUpdate := getCurrentBackupProgress()
+			dbTotal, dbDone, dbName, overallPhase, phaseDesc, hasUpdate := getCurrentBackupProgress()
 			if hasUpdate {
 				m.dbTotal = dbTotal
 				m.dbDone = dbDone
 				m.dbName = dbName
+				m.overallPhase = overallPhase
+				m.phaseDesc = phaseDesc
 			}
 
 			// Update status based on progress and elapsed time
@@ -286,6 +295,20 @@ func (m BackupExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil
 
+	case tea.InterruptMsg:
+		// Handle Ctrl+C signal (SIGINT) - Bubbletea v1.3+ sends this instead of KeyMsg for ctrl+c
+		if !m.done && !m.cancelling {
+			m.cancelling = true
+			m.status = "[STOP]  Cancelling backup... (please wait)"
+			if m.cancel != nil {
+				m.cancel()
+			}
+			return m, nil
+		} else if m.done {
+			return m.parent, tea.Quit
+		}
+		return m, nil
+
 	case tea.KeyMsg:
 		switch msg.String() {
 		case "ctrl+c", "esc":
@@ -361,19 +384,68 @@ func (m BackupExecutionModel) View() string {
 
 	// Status display
 	if !m.done {
-		// Show database progress bar if we have progress data (cluster backup)
+		// Unified progress display for cluster backup
-		if m.dbTotal > 0 && m.dbDone > 0 {
+		if m.backupType == "cluster" {
-			// Show progress bar instead of spinner when we have real progress
+			// Calculate overall progress across all phases
-			progressBar := renderBackupDatabaseProgressBar(m.dbDone, m.dbTotal, m.dbName, 50)
+			// Phase 1: Globals (0-15%)
-			s.WriteString(progressBar + "\n")
+			// Phase 2: Databases (15-90%)
-			s.WriteString(fmt.Sprintf("  %s\n", m.status))
+			// Phase 3: Compressing (90-100%)
-		} else {
+			overallProgress := 0
-			// Show spinner during initial phases
+			phaseLabel := "Starting..."
-			if m.cancelling {
+
-				s.WriteString(fmt.Sprintf("  %s %s\n", spinnerFrames[m.spinnerFrame], m.status))
+			elapsedSec := int(time.Since(m.startTime).Seconds())
-			} else {
+
-				s.WriteString(fmt.Sprintf("  %s %s\n", spinnerFrames[m.spinnerFrame], m.status))
+			if m.overallPhase == 2 && m.dbTotal > 0 {
+				// Phase 2: Database backups - contributes 15-90%
+				dbPct := int((int64(m.dbDone) * 100) / int64(m.dbTotal))
+				overallProgress = 15 + (dbPct * 75 / 100)
+				phaseLabel = m.phaseDesc
+			} else if elapsedSec < 5 {
+				// Initial setup
+				overallProgress = 2
+				phaseLabel = "Phase 1/3: Initializing..."
+			} else if m.dbTotal == 0 {
+				// Phase 1: Globals backup (before databases start)
+				overallProgress = 10
+				phaseLabel = "Phase 1/3: Backing up Globals"
 			}
+
+			// Header with phase and overall progress
+			s.WriteString(infoStyle.Render("  ─── Cluster Backup Progress ──────────────────────────────"))
+			s.WriteString("\n\n")
+			s.WriteString(fmt.Sprintf("    %s\n\n", phaseLabel))
+
+			// Overall progress bar
+			s.WriteString("    Overall: ")
+			s.WriteString(renderProgressBar(overallProgress))
+			s.WriteString(fmt.Sprintf("  %d%%\n", overallProgress))
+
+			// Phase-specific details
+			if m.dbTotal > 0 && m.dbDone > 0 {
+				// Show current database being backed up
+				s.WriteString("\n")
+				spinner := spinnerFrames[m.spinnerFrame]
+				if m.dbName != "" && m.dbDone <= m.dbTotal {
+					s.WriteString(fmt.Sprintf("    Current: %s %s\n", spinner, m.dbName))
+				}
+				s.WriteString("\n")
+
+				// Database progress bar
+				progressBar := renderBackupDatabaseProgressBar(m.dbDone, m.dbTotal, m.dbName, 50)
+				s.WriteString(progressBar + "\n")
+			} else {
+				// Intermediate phase (globals)
+				spinner := spinnerFrames[m.spinnerFrame]
+				s.WriteString(fmt.Sprintf("\n    %s %s\n\n", spinner, m.status))
+			}
+
+			s.WriteString("\n")
+			s.WriteString(infoStyle.Render("  ───────────────────────────────────────────────────────────"))
+			s.WriteString("\n\n")
+		} else {
+			// Single/sample database backup - simpler display
+			spinner := spinnerFrames[m.spinnerFrame]
+			s.WriteString(fmt.Sprintf("  %s %s\n", spinner, m.status))
 		}
 
 		if !m.cancelling {

internal/tui/menu.go

@@ -188,6 +188,21 @@ func (m *MenuModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil
 
+	case tea.InterruptMsg:
+		// Handle Ctrl+C signal (SIGINT) - Bubbletea v1.3+ sends this
+		if m.cancel != nil {
+			m.cancel()
+		}
+
+		// Clean up any orphaned processes before exit
+		m.logger.Info("Cleaning up processes before exit (SIGINT)")
+		if err := cleanup.KillOrphanedProcesses(m.logger); err != nil {
+			m.logger.Warn("Failed to clean up all processes", "error", err)
+		}
+
+		m.quitting = true
+		return m, tea.Quit
+
 	case tea.KeyMsg:
 		switch msg.String() {
 		case "ctrl+c", "q":

internal/tui/restore_exec.go

@@ -536,6 +536,21 @@ func (m RestoreExecutionModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, nil
 
+	case tea.InterruptMsg:
+		// Handle Ctrl+C signal (SIGINT) - Bubbletea v1.3+ sends this instead of KeyMsg for ctrl+c
+		if !m.done && !m.cancelling {
+			m.cancelling = true
+			m.status = "[STOP]  Cancelling restore... (please wait)"
+			m.phase = "Cancelling"
+			if m.cancel != nil {
+				m.cancel()
+			}
+			return m, nil
+		} else if m.done {
+			return m.parent, tea.Quit
+		}
+		return m, nil
+
 	case tea.KeyMsg:
 		switch msg.String() {
 		case "ctrl+c", "esc":

main.go

@@ -16,7 +16,7 @@ import (
 
 // Build information (set by ldflags)
 var (
-	version   = "3.42.48"
+	version   = "3.42.50"
 	buildTime = "unknown"
 	gitCommit = "unknown"
 )