Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

FEATURE (restores): Validate there is enough disk space on restore

Rostislav Dugin205cb1ec0200
diff --git a/backend/internal/features/disk/service.go b/backend/internal/features/disk/service.go
index bc05360f..fdd40ebf 100644
--- a/backend/internal/features/disk/service.go
+++ b/backend/internal/features/disk/service.go
@@ -1,7 +1,9 @@
package disk
import (
+ "databasus-backend/internal/config"
"fmt"
+ "path/filepath"
"runtime"
"github.com/shirou/gopsutil/v4/disk"
@@ -12,10 +14,14 @@ type DiskService struct{}
func (s *DiskService) GetDiskUsage() (*DiskUsage, error) {
platform := s.detectPlatform()
- // Set path based on platform
- path := "/"
+ var path string
+
if platform == PlatformWindows {
path = "C:\\"
+ } else {
+ // Use databasus-data folder location for Linux (Docker)
+ cfg := config.GetEnv()
+ path = filepath.Dir(cfg.DataFolder) // Gets /databasus-data from /databasus-data/backups
}
diskUsage, err := disk.Usage(path)
diff --git a/backend/internal/features/restores/controller_test.go b/backend/internal/features/restores/controller_test.go
index 693fea0b..27b48c75 100644
--- a/backend/internal/features/restores/controller_test.go
+++ b/backend/internal/features/restores/controller_test.go
@@ -250,6 +250,44 @@ func Test_RestoreBackup_AuditLogWritten(t *testing.T) {
assert.True(t, found, "Audit log for restore not found")
}
+func Test_RestoreBackup_InsufficientDiskSpace_ReturnsError(t *testing.T) {
+ router := createTestRouter()
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+
+ _, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)
+
+ // Update backup size to 10 TB via repository
+ repo := &backups.BackupRepository{}
+ backup.BackupSizeMb = 10485760.0 // 10 TB in MB
+ err := repo.Save(backup)
+ assert.NoError(t, err)
+
+ request := RestoreBackupRequest{
+ PostgresqlDatabase: &postgresql.PostgresqlDatabase{
+ Version: tools.PostgresqlVersion16,
+ Host: "localhost",
+ Port: 5432,
+ Username: "postgres",
+ Password: "postgres",
+ },
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/restores/%s/restore", backup.ID.String()),
+ "Bearer "+owner.Token,
+ request,
+ http.StatusBadRequest,
+ )
+
+ bodyStr := string(testResp.Body)
+ assert.Contains(t, bodyStr, "is required")
+ assert.Contains(t, bodyStr, "is available")
+ assert.Contains(t, bodyStr, "disk space")
+}
+
func createTestDatabaseWithBackupForRestore(
workspace *workspaces_models.Workspace,
owner *users_dto.SignInResponseDTO,
diff --git a/backend/internal/features/restores/di.go b/backend/internal/features/restores/di.go
index 774104f8..7bafd876 100644
--- a/backend/internal/features/restores/di.go
+++ b/backend/internal/features/restores/di.go
@@ -5,6 +5,7 @@ import (
"databasus-backend/internal/features/backups/backups"
backups_config "databasus-backend/internal/features/backups/config"
"databasus-backend/internal/features/databases"
+ "databasus-backend/internal/features/disk"
"databasus-backend/internal/features/restores/usecases"
"databasus-backend/internal/features/storages"
workspaces_services "databasus-backend/internal/features/workspaces/services"
@@ -24,6 +25,7 @@ var restoreService = &RestoreService{
workspaces_services.GetWorkspaceService(),
audit_logs.GetAuditLogService(),
encryption.GetFieldEncryptor(),
+ disk.GetDiskService(),
}
var restoreController = &RestoreController{
restoreService,
diff --git a/backend/internal/features/restores/service.go b/backend/internal/features/restores/service.go
index 22fbf0f8..d7ef4a11 100644
--- a/backend/internal/features/restores/service.go
+++ b/backend/internal/features/restores/service.go
@@ -5,6 +5,7 @@ import (
"databasus-backend/internal/features/backups/backups"
backups_config "databasus-backend/internal/features/backups/config"
"databasus-backend/internal/features/databases"
+ "databasus-backend/internal/features/disk"
"databasus-backend/internal/features/restores/enums"
"databasus-backend/internal/features/restores/models"
"databasus-backend/internal/features/restores/usecases"
@@ -32,6 +33,7 @@ type RestoreService struct {
workspaceService *workspaces_services.WorkspaceService
auditLogService *audit_logs.AuditLogService
fieldEncryptor encryption.FieldEncryptor
+ diskService *disk.DiskService
}
func (s *RestoreService) OnBeforeBackupRemove(backup *backups.Backup) error {
@@ -126,6 +128,11 @@ func (s *RestoreService) RestoreBackupWithAuth(
return err
}
+ // Validate disk space before starting restore
+ if err := s.validateDiskSpace(backup); err != nil {
+ return err
+ }
+
go func() {
if err := s.RestoreBackup(backup, requestDTO); err != nil {
s.logger.Error("Failed to restore backup", "error", err)
@@ -361,3 +368,41 @@ func (s *RestoreService) validateVersionCompatibility(
}
return nil
}
+
+func (s *RestoreService) validateDiskSpace(backup *backups.Backup) error {
+ diskUsage, err := s.diskService.GetDiskUsage()
+ if err != nil {
+ return fmt.Errorf("failed to check disk space: %w", err)
+ }
+
+ // Convert backup size from MB to bytes
+ backupSizeBytes := int64(backup.BackupSizeMb * 1024 * 1024)
+
+ // Calculate required space: backup size + 10% buffer
+ bufferBytes := int64(float64(backupSizeBytes) * 0.1)
+ requiredBytes := backupSizeBytes + bufferBytes
+
+ // Ensure minimum of 1 GB total (even if backup is small)
+ minRequiredBytes := int64(1024 * 1024 * 1024) // 1 GB
+ if requiredBytes < minRequiredBytes {
+ requiredBytes = minRequiredBytes
+ }
+
+ // Check if there's enough free space
+ if diskUsage.FreeSpaceBytes < requiredBytes {
+ backupSizeGB := float64(backupSizeBytes) / (1024 * 1024 * 1024)
+ bufferSizeGB := float64(bufferBytes) / (1024 * 1024 * 1024)
+ requiredGB := float64(requiredBytes) / (1024 * 1024 * 1024)
+ availableGB := float64(diskUsage.FreeSpaceBytes) / (1024 * 1024 * 1024)
+
+ return fmt.Errorf(
+ "to restore this backup, %.1f GB (%.1f GB backup + %.1f GB buffer) is required, but only %.1f GB is available. Please free up disk space before restoring",
+ requiredGB,
+ backupSizeGB,
+ bufferSizeGB,
+ availableGB,
+ )
+ }
+
+ return nil
+}