feat: add support for restore schedules

Author: DeltaLaboratory

README.md

@@ -121,12 +121,54 @@ compress {
   compress_level = 12
 }
 
-# backup schedule, required when using `storage-schedule` command
+# backup schedules, required when using `schedule run` command
 # see https://pkg.go.dev/github.com/robfig/cron#hdr-CRON_Expression_Format for more information
 schedule = [
-  "0 1 * * *",
+  "0 1 * * *",    # Daily at 1 AM
+  "0 13 * * *",   # Daily at 1 PM
 ]
 
+# restore schedules (optional) - automatically restore backups on schedule
+# useful for refreshing test/staging databases
+restore_schedule {
+  # cron expression for when to run the restore
+  cron = "0 3 * * 0"  # Weekly on Sunday at 3 AM
+  
+  # target database name to restore to
+  target_database = "test_db"
+  
+  # backup selection strategy: "latest", "pattern", or "specific"
+  backup_selection = "latest"
+  
+  # include S3 backups in selection (optional, default true)
+  include_s3 = true
+  
+  # include local backups in selection (optional, default true)
+  include_local = true
+  
+  # enable/disable this restore schedule (optional, default true)
+  enabled = true
+}
+
+# example: restore backups matching a pattern
+restore_schedule {
+  cron = "0 4 * * 1"  # Weekly on Monday at 4 AM
+  target_database = "staging_db"
+  backup_selection = "pattern"
+  backup_pattern = "2024-08"  # restore backups containing "2024-08"
+  include_s3 = true
+  include_local = false
+}
+
+# example: restore a specific backup
+restore_schedule {
+  cron = "0 2 15 * *"  # Monthly on 15th at 2 AM
+  target_database = "monthly_test_db"
+  backup_selection = "specific"
+  backup_id = "2024-01-15T01:00:00"  # specific backup timestamp
+  enabled = false  # disabled by default
+}
+
 # verbose mode
 verbose = false
 ```

cmd/restore.go

@@ -91,9 +91,7 @@ Examples:
 
 		// Handle list-only mode
 		if restoreListOnly {
-			if err := listAvailableBackups(cmd.Context(), s3Configured, localConfigured); err != nil {
-				logger.Fatal().Err(err).Msg("failed to list available backups")
-			}
+			listAvailableBackups(cmd.Context(), s3Configured, localConfigured)
 			return
 		}
 
@@ -109,6 +107,7 @@ Examples:
 			}
 			if selectedBackup == nil {
 				logger.Fatal().Msg("no backups found")
+				return // This line will never execute, but helps staticcheck understand
 			}
 			logger.Info().Str("backup", selectedBackup.Name).Str("source", selectedBackup.Source).Msg("selected latest backup")
 		} else if restoreBackupID != "" {
@@ -119,6 +118,7 @@ Examples:
 			}
 			if selectedBackup == nil {
 				logger.Fatal().Str("backup_id", restoreBackupID).Msg("backup not found")
+				return // This line will never execute, but helps staticcheck understand
 			}
 			logger.Info().Str("backup", selectedBackup.Name).Str("source", selectedBackup.Source).Msg("found specified backup")
 		} else {
@@ -226,7 +226,7 @@ func listLocalBackups(logger zerolog.Logger) []BackupEntry {
 	return backups
 }
 
-func listAvailableBackups(ctx context.Context, listS3, listLocal bool) error {
+func listAvailableBackups(ctx context.Context, listS3, listLocal bool) {
 	logger := log.Logger.With().Str("caller", "list_backups").Logger()
 
 	logger.Info().
@@ -257,7 +257,7 @@ func listAvailableBackups(ctx context.Context, listS3, listLocal bool) error {
 
 	if len(allBackups) == 0 {
 		fmt.Fprintln(os.Stdout, "No backups found.")
-		return nil
+		return
 	}
 
 	fmt.Fprintf(os.Stdout, "%-30s %-10s %-15s %s\n", "BACKUP NAME", "SOURCE", "SIZE", "CREATED")
@@ -270,8 +270,6 @@ func listAvailableBackups(ctx context.Context, listS3, listLocal bool) error {
 	}
 
 	fmt.Fprintf(os.Stdout, "\nTotal: %d backups\n", len(allBackups))
-
-	return nil
 }
 
 // formatSize formats a size in bytes to a human-readable string
@@ -365,19 +363,19 @@ func findLatestBackup(ctx context.Context, includeS3, includeLocal bool) (*Backu
 }
 
 // findBackupByID finds a specific backup by ID (timestamp or filename)
-func findBackupByID(ctx context.Context, backupId string, includeS3, includeLocal bool) (*BackupEntry, error) {
+func findBackupByID(ctx context.Context, backupID string, includeS3, includeLocal bool) (*BackupEntry, error) {
 	backups, err := getAllBackups(ctx, includeS3, includeLocal)
 	if err != nil {
 		return nil, err
 	}
 
 	for _, backup := range backups {
 		// Check if backup name contains the ID (partial match for timestamp)
-		if strings.Contains(backup.Name, backupId) {
+		if strings.Contains(backup.Name, backupID) {
 			return &backup, nil
 		}
 		// Also check exact name match
-		if backup.Name == backupId {
+		if backup.Name == backupID {
 			return &backup, nil
 		}
 	}

cmd/schedule/run.go

@@ -14,32 +14,79 @@ import (
 // runCmd represents the run command
 var runCmd = &cobra.Command{
 	Use:   "run",
-	Short: "Run the backup schedule",
-	Long:  `Run the backup schedule defined in the configuration file.`,
+	Short: "Run the backup and restore schedules",
+	Long:  `Run the backup and restore schedules defined in the configuration file.`,
 	Run: func(_ *cobra.Command, _ []string) {
 		logger := log.Logger.With().Str("caller", "schedule_runner").Logger()
 
-		if len(config.Loaded.Schedule) == 0 {
-			logger.Fatal().Msg("no backup schedules configured - cannot start scheduler")
+		backupCount := len(config.Loaded.Schedule)
+		restoreCount := len(config.Loaded.RestoreSchedule)
+		totalSchedules := backupCount + restoreCount
+
+		if totalSchedules == 0 {
+			logger.Fatal().Msg("no schedules configured - cannot start scheduler")
 		}
 
-		logger.Info().Int("schedule_count", len(config.Loaded.Schedule)).Msg("initializing backup scheduler")
+		logger.Info().
+			Int("backup_schedules", backupCount).
+			Int("restore_schedules", restoreCount).
+			Int("total_schedules", totalSchedules).
+			Msg("initializing scheduler")
 
 		c := cron.New()
+
+		// Register backup schedules
 		for _, schedule := range config.Loaded.Schedule {
 			if id, err := c.AddFunc(schedule, func() { internal.Backup(context.Background()) }); err != nil {
 				logger.Fatal().Err(err).
 					Str("cron_expression", schedule).
 					Msg("failed to register backup schedule - invalid cron expression")
 			} else {
 				logger.Info().
+					Str("type", "backup").
 					Str("cron_expression", schedule).
 					Str("next_run", c.Entry(id).Next.String()).
-					Msg("backup schedule registered successfully")
+					Msg("schedule registered successfully")
+			}
+		}
+
+		// Register restore schedules
+		for _, restoreSchedule := range config.Loaded.RestoreSchedule {
+			if !restoreSchedule.IsEnabled() {
+				logger.Info().
+					Str("type", "restore").
+					Str("cron_expression", restoreSchedule.Cron).
+					Str("target_database", restoreSchedule.TargetDatabase).
+					Msg("restore schedule disabled, skipping")
+				continue
+			}
+
+			// Create a closure to capture the restore schedule config
+			scheduleConfig := restoreSchedule // Important: capture the value, not the reference
+			if id, err := c.AddFunc(restoreSchedule.Cron, func() {
+				if err := internal.ScheduledRestore(context.Background(), scheduleConfig); err != nil {
+					log.Error().Err(err).
+						Str("cron_expression", scheduleConfig.Cron).
+						Str("target_database", scheduleConfig.TargetDatabase).
+						Msg("scheduled restore failed")
+				}
+			}); err != nil {
+				logger.Fatal().Err(err).
+					Str("cron_expression", restoreSchedule.Cron).
+					Str("target_database", restoreSchedule.TargetDatabase).
+					Msg("failed to register restore schedule - invalid cron expression")
+			} else {
+				logger.Info().
+					Str("type", "restore").
+					Str("cron_expression", restoreSchedule.Cron).
+					Str("target_database", restoreSchedule.TargetDatabase).
+					Str("backup_selection", restoreSchedule.BackupSelection).
+					Str("next_run", c.Entry(id).Next.String()).
+					Msg("schedule registered successfully")
 			}
 		}
 
-		logger.Info().Msg("starting backup scheduler - waiting for scheduled backup jobs")
+		logger.Info().Msg("starting scheduler - waiting for scheduled jobs")
 		c.Run()
 	},
 }

internal/config/config.go

@@ -11,14 +11,36 @@ import (
 
 var Loaded *Config
 
-type Config struct {
-	Postgres PostgresConfig  `hcl:"postgres,block"`
-	Storage  storage.Storage `hcl:"storage,block"`
-	Compress *CompressConfig `hcl:"compress,block"`
+type RestoreScheduleConfig struct {
+	Cron            string  `hcl:"cron"`
+	TargetDatabase  string  `hcl:"target_database"`
+	BackupSelection string  `hcl:"backup_selection"` // "latest", "pattern", "specific"
+	BackupPattern   *string `hcl:"backup_pattern"`   // optional: for pattern-based selection
+	BackupID        *string `hcl:"backup_id"`        // optional: for specific backup selection
+	IncludeS3       *bool   `hcl:"include_s3"`
+	IncludeLocal    *bool   `hcl:"include_local"`
+	Enabled         *bool   `hcl:"enabled"`
+}
+
+func (r RestoreScheduleConfig) IsEnabled() bool {
+	return r.Enabled == nil || *r.Enabled
+}
 
-	Schedule []string `hcl:"schedule"`
+func (r RestoreScheduleConfig) ShouldIncludeS3() bool {
+	return r.IncludeS3 == nil || *r.IncludeS3
+}
+
+func (r RestoreScheduleConfig) ShouldIncludeLocal() bool {
+	return r.IncludeLocal == nil || *r.IncludeLocal
+}
 
-	Verbose *bool `hcl:"verbose"`
+type Config struct {
+	Postgres        PostgresConfig          `hcl:"postgres,block"`
+	Storage         storage.Storage         `hcl:"storage,block"`
+	Compress        *CompressConfig         `hcl:"compress,block"`
+	Schedule        []string                `hcl:"schedule"`
+	RestoreSchedule []RestoreScheduleConfig `hcl:"restore_schedule,block"`
+	Verbose         *bool                   `hcl:"verbose"`
 }
 
 func (c Config) IsVerbose() bool {
@@ -63,6 +85,61 @@ func (c Config) Validate() error {
 		}
 	}
 
+	// Validate restore schedules
+	for i, restoreSchedule := range c.RestoreSchedule {
+		if err := c.validateRestoreSchedule(restoreSchedule, i); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c Config) validateRestoreSchedule(rs RestoreScheduleConfig, index int) error {
+	// Validate required fields
+	if rs.Cron == "" {
+		return fmt.Errorf("restore_schedule[%d]: cron expression is required", index)
+	}
+
+	if rs.TargetDatabase == "" {
+		return fmt.Errorf("restore_schedule[%d]: target_database is required", index)
+	}
+
+	if rs.BackupSelection == "" {
+		return fmt.Errorf("restore_schedule[%d]: backup_selection is required", index)
+	}
+
+	// Validate backup_selection values
+	validSelections := []string{"latest", "pattern", "specific"}
+	validSelection := false
+	for _, valid := range validSelections {
+		if rs.BackupSelection == valid {
+			validSelection = true
+			break
+		}
+	}
+	if !validSelection {
+		return fmt.Errorf("restore_schedule[%d]: backup_selection must be one of %v, got '%s'",
+			index, validSelections, rs.BackupSelection)
+	}
+
+	// Validate selection-specific requirements
+	switch rs.BackupSelection {
+	case "pattern":
+		if rs.BackupPattern == nil || *rs.BackupPattern == "" {
+			return fmt.Errorf("restore_schedule[%d]: backup_pattern is required when backup_selection is 'pattern'", index)
+		}
+	case "specific":
+		if rs.BackupID == nil || *rs.BackupID == "" {
+			return fmt.Errorf("restore_schedule[%d]: backup_id is required when backup_selection is 'specific'", index)
+		}
+	}
+
+	// Validate that at least one storage source is enabled
+	if !rs.ShouldIncludeS3() && !rs.ShouldIncludeLocal() {
+		return fmt.Errorf("restore_schedule[%d]: at least one of include_s3 or include_local must be true", index)
+	}
+
 	return nil
 }
 

internal/dump.go

@@ -16,7 +16,6 @@ type Process struct {
 	cmd *exec.Cmd
 
 	stdout io.ReadCloser
-	done   chan struct{}
 }
 
 func (p *Process) Start() error {