Skip to content

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

FEATURE (logs): Adopt context-aware structured logging across the backend

Rostislav Dugin237897a02101
diff --git a/CLAUDE.md b/CLAUDE.md
index 44dac6d1..b5c7d4f3 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -152,4 +152,8 @@ Databasus handles sensitive data, so security is a layered defence. CodeQL, Code
- Keep Dockerfiles free of secrets, floating base-image tags and unjustified root. If root-at-start is required (PUID/PGID remap, volume chown, initdb), drop privileges with `gosu` before `exec`-ing the app.
- Never log secrets, tokens or credentials. Redact at the logger layer, not at call sites.
-The README's `🛡️ Security & reliability engineering` section is the public-facing version of these practices — keep both consistent if substance changes.
\ No newline at end of file
+The README's `🛡️ Security & reliability engineering` section is the public-facing version of these practices — keep both consistent if substance changes.
+
+## Commiting
+
+Never put Co-Authoring in commit message until it is requested directly
\ No newline at end of file
diff --git a/README.md b/README.md
index df50c41a..33d125bb 100644
--- a/README.md
+++ b/README.md
@@ -111,6 +111,7 @@ Databasus performs a real restore to confirm backups are usable, not just intact
- **Docker-based**: Easy deployment and management
- **Privacy-first**: All your data stays on your infrastructure
- **Open source**: Apache 2.0 licensed, inspect every line of code
+- **Build-in SSH**: Connect to your databasus via SSH tunnel
### 📦 Installation <a href="https://databasus.com/installation">(docs)</a>
diff --git a/backend/cmd/cleanup_test_db/main.go b/backend/cmd/cleanup_test_db/main.go
index 48222296..a689e1ce 100644
--- a/backend/cmd/cleanup_test_db/main.go
+++ b/backend/cmd/cleanup_test_db/main.go
@@ -80,7 +80,7 @@ func resetValkey(log *slog.Logger) error {
return fmt.Errorf("flush cache: %w", err)
}
- log.Info("Valkey reset complete")
+ log.Info("valkey reset complete")
return nil
}
@@ -174,7 +174,7 @@ func resetOnePostgresContainer(ctx context.Context, log *slog.Logger, host, labe
"SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = %s AND pid <> pg_backend_pid()",
quoteLiteral(name),
)); err != nil {
- log.Warn("could not terminate connections to DB", "db", name, "error", err)
+ log.WarnContext(ctx, "could not terminate connections to DB", "db", name, "error", err)
}
// No WITH (FORCE) - that's PG 13+ only and we support PG 12.
@@ -209,11 +209,11 @@ func resetOnePostgresContainer(ctx context.Context, log *slog.Logger, host, labe
_, _ = db.ExecContext(ctx, fmt.Sprintf("DROP OWNED BY %s", quotedRole))
if _, err := db.ExecContext(ctx, fmt.Sprintf("DROP ROLE IF EXISTS %s", quotedRole)); err != nil {
- log.Warn("could not drop role", "role", role, "error", err)
+ log.WarnContext(ctx, "could not drop role", "role", role, "error", err)
}
}
- log.Info("test PG container reset complete")
+ log.InfoContext(ctx, "test PG container reset complete")
return nil
}
@@ -255,11 +255,11 @@ func dropDatabasusReplicationSlots(ctx context.Context, log *slog.Logger, db *sq
)
if _, err := db.ExecContext(ctx, "SELECT pg_drop_replication_slot($1)", name); err != nil {
- log.Warn("could not drop replication slot", "slot_name", name, "error", err)
+ log.WarnContext(ctx, "could not drop replication slot", "slot_name", name, "error", err)
continue
}
- log.Info("dropped leftover replication slot", "slot_name", name)
+ log.InfoContext(ctx, "dropped leftover replication slot", "slot_name", name)
}
return nil
diff --git a/backend/cmd/main.go b/backend/cmd/main.go
index 7a53468e..ece913f4 100644
--- a/backend/cmd/main.go
+++ b/backend/cmd/main.go
@@ -76,16 +76,17 @@ func main() {
return
}
+ ctx := context.Background()
log := logger.GetLogger()
cache_utils.TestCacheConnection()
- log.Info("Clearing cache...")
+ log.Info("clearing cache")
err := cache_utils.ClearAllCache()
if err != nil {
- log.Error("Failed to clear cache", "error", err)
- os.Exit(1)
+ log.Error("failed to clear cache", "error", err)
+ logger.ExitAfterFlush(1)
}
runMigrations(log)
@@ -96,29 +97,30 @@ func main() {
config.GetEnv().DataFolder,
})
if err != nil {
- log.Error("Failed to ensure directories", "error", err)
- os.Exit(1)
+ log.Error("failed to ensure directories", "error", err)
+ logger.ExitAfterFlush(1)
}
err = secrets.GetSecretKeyService().MigrateKeyFromDbToFileIfExist()
if err != nil {
- log.Error("Failed to migrate secret key from database to file", "error", err)
- os.Exit(1)
+ log.Error("failed to migrate secret key from database to file", "error", err)
+ logger.ExitAfterFlush(1)
}
- err = users_services.GetUserService().CreateInitialAdmin()
+ err = users_services.GetUserService().CreateInitialAdmin(ctx)
if err != nil {
- log.Error("Failed to create initial admin", "error", err)
- os.Exit(1)
+ log.Error("failed to create initial admin", "error", err)
+ logger.ExitAfterFlush(1)
}
- handlePasswordReset(log)
+ resetPasswordIfRequested(ctx, log)
go generateSwaggerDocs(log)
gin.SetMode(gin.ReleaseMode)
ginApp := gin.New()
- ginApp.Use(gin.Logger())
+ ginApp.Use(middleware.AssignRequestID())
+ ginApp.Use(middleware.LogAccess(log))
ginApp.Use(ginRecoveryWithLogger(log))
ginApp.Use(middleware.NoStoreCacheControl())
@@ -144,7 +146,7 @@ func main() {
startServerWithGracefulShutdown(log, ginApp)
}
-func handlePasswordReset(log *slog.Logger) {
+func resetPasswordIfRequested(ctx context.Context, log *slog.Logger) {
audit_logs.SetupDependencies()
newPassword := flag.String("new-password", "", "Set a new password for the user")
@@ -156,28 +158,28 @@ func handlePasswordReset(log *slog.Logger) {
return
}
- log.Info("Found reset password command - reseting password...")
+ log.InfoContext(ctx, "found reset password command, resetting password")
if *email == "" {
- log.Info("No email provided, please provide an email via --email=\"[email protected]\" flag")
- os.Exit(1)
+ log.InfoContext(ctx, "no email provided, pass one via --email=\"[email protected]\"")
+ logger.ExitAfterFlush(1)
}
- resetPassword(*email, *newPassword, log)
+ resetPassword(ctx, *email, *newPassword, log)
}
-func resetPassword(email, newPassword string, log *slog.Logger) {
- log.Info("Resetting password...")
+func resetPassword(ctx context.Context, email, newPassword string, log *slog.Logger) {
+ log.InfoContext(ctx, "resetting password")
userService := users_services.GetUserService()
- err := userService.ChangeUserPasswordByEmail(email, newPassword)
+ err := userService.ChangeUserPasswordByEmail(ctx, email, newPassword)
if err != nil {
- log.Error("Failed to reset password", "error", err)
- os.Exit(1)
+ log.ErrorContext(ctx, "failed to reset password", "error", err)
+ logger.ExitAfterFlush(1)
}
- log.Info("Password reset successfully")
- os.Exit(0)
+ log.InfoContext(ctx, "password reset successfully")
+ logger.ExitAfterFlush(0)
}
func startServerWithGracefulShutdown(log *slog.Logger, app *gin.Engine) {
@@ -186,29 +188,32 @@ func startServerWithGracefulShutdown(log *slog.Logger, app *gin.Engine) {
Handler: app,
}
+ log.Info(fmt.Sprintf("http server listening on %s", serverAddr))
+
go func() {
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
- log.Error("listen:", "error", err)
+ log.Error("http server failed to listen", "error", err)
}
}()
quit := make(chan os.Signal, 1)
signal.Notify(quit, os.Interrupt, syscall.SIGTERM)
<-quit
- log.Info("Shutdown signal received")
-
- // Gracefully shutdown VictoriaLogs writer
- logger.ShutdownVictoriaLogs()
+ log.Info("shutdown signal received")
// The context is used to inform the server it has 10 seconds to finish
// the request it is currently handling
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := srv.Shutdown(ctx); err != nil {
- log.Error("Server forced to shutdown:", "error", err)
+ log.Error("server forced to shutdown", "error", err)
}
- log.Info("Server gracefully stopped")
+ log.Info("server gracefully stopped")
+
+ // Closed after the drain so in-flight request logs are included, on its own deadline so a
+ // slow drain cannot hand the flush an already-expired context.
+ logger.FlushAndCloseSinks()
}
func setUpRoutes(r *gin.Engine) {
@@ -289,7 +294,7 @@ func announceTelemetry() {
}
func runBackgroundTasks(log *slog.Logger) {
- log.Info("Preparing to run background tasks...")
+ log.Info("preparing to run background tasks")
// Create context that will be cancelled on shutdown
ctx, cancel := context.WithCancel(context.Background())
@@ -299,16 +304,16 @@ func runBackgroundTasks(log *slog.Logger) {
signal.Notify(quit, os.Interrupt, syscall.SIGTERM)
go func() {
<-quit
- log.Info("Shutdown signal received, cancelling all background tasks")
+ log.Info("shutdown signal received, cancelling all background tasks")
cancel()
}()
err := files_utils.CleanFolder(config.GetEnv().TempFolder)
if err != nil {
- log.Error("Failed to clean temp folder", "error", err)
+ log.Error("failed to clean temp folder", "error", err)
}
- log.Info("Starting background tasks...")
+ log.Info("starting background tasks")
go runWithPanicLogging(log, "backup background service", func() {
backuping_logical.GetBackupsScheduler().Run(ctx)
@@ -358,7 +363,7 @@ func runBackgroundTasks(log *slog.Logger) {
func runWithPanicLogging(log *slog.Logger, serviceName string, fn func()) {
defer func() {
if r := recover(); r != nil {
- log.Error("Panic in "+serviceName, "error", r, "stacktrace", string(debug.Stack()))
+ log.Error("panic in "+serviceName, "error", r, "stacktrace", string(debug.Stack()))
}
}()
fn()
@@ -377,7 +382,7 @@ func generateSwaggerDocs(log *slog.Logger) {
// This ensures swag can find the files regardless of where the command is run from
currentDir, err := os.Getwd()
if err != nil {
- log.Error("Failed to get current directory", "error", err)
+ log.Error("failed to get current directory", "error", err)
return
}
@@ -387,15 +392,15 @@ func generateSwaggerDocs(log *slog.Logger) {
output, err := cmd.CombinedOutput()
if err != nil {
- log.Error("Failed to generate Swagger docs", "error", err, "output", string(output))
+ log.Error("failed to generate Swagger docs", "error", err, "output", string(output))
return
}
- log.Info("Swagger documentation generated successfully")
+ log.Info("swagger documentation generated successfully")
}
func runMigrations(log *slog.Logger) {
- log.Info("Running database migrations...")
+ log.Info("running database migrations")
cmd := exec.CommandContext(context.Background(), "goose", "-dir", "./migrations", "up")
cmd.Env = append(
@@ -406,11 +411,11 @@ func runMigrations(log *slog.Logger) {
output, err := cmd.CombinedOutput()
if err != nil {
- log.Error("Failed to run migrations", "error", err, "output", string(output))
- os.Exit(1)
+ log.Error("failed to run migrations", "error", err, "output", string(output))
+ logger.ExitAfterFlush(1)
}
- log.Info("Database migrations completed successfully", "output", string(output))
+ log.Info("database migrations completed successfully", "output", string(output))
}
func enableCors(ginApp *gin.Engine) {
@@ -433,6 +438,7 @@ func enableCors(ginApp *gin.Engine) {
"Access-Control-Allow-Headers",
"Access-Control-Allow-Origin",
},
+ ExposeHeaders: []string{middleware.RequestIDHeader},
AllowCredentials: true,
}))
}
@@ -442,7 +448,7 @@ func ginRecoveryWithLogger(log *slog.Logger) gin.HandlerFunc {
return func(ctx *gin.Context) {
defer func() {
if r := recover(); r != nil {
- log.Error("Panic recovered in HTTP handler",
+ log.ErrorContext(ctx.Request.Context(), "panic recovered in HTTP handler",
"error", r,
"stacktrace", string(debug.Stack()),
"method", ctx.Request.Method,
diff --git a/backend/internal/features/audit_logs/background_service.go b/backend/internal/features/audit_logs/background_service.go
index ababa025..b1bc2187 100644
--- a/backend/internal/features/audit_logs/background_service.go
+++ b/backend/internal/features/audit_logs/background_service.go
@@ -6,8 +6,12 @@ import (
"log/slog"
"sync/atomic"
"time"
+
+ "github.com/google/uuid"
)
+const jobName = "audit_log_cleanup"
+
type AuditLogBackgroundService struct {
auditLogService *AuditLogService
logger *slog.Logger
@@ -20,7 +24,9 @@ func (s *AuditLogBackgroundService) Run(ctx context.Context) {
panic(fmt.Sprintf("%T.Run() called multiple times", s))
}
- s.logger.Info("Starting audit log cleanup background service")
+ lifecycleLogger := s.logger.With("job_name", jobName)
+
+ lifecycleLogger.InfoContext(ctx, "audit log cleanup started")
if ctx.Err() != nil {
return
@@ -32,15 +38,12 @@ func (s *AuditLogBackgroundService) Run(ctx context.Context) {
for {
select {
case <-ctx.Done():
+ lifecycleLogger.InfoContext(ctx, "audit log cleanup stopped")
+
return
case <-ticker.C:
- if err := s.cleanOldAuditLogs(); err != nil {
- s.logger.Error("Failed to clean old audit logs", "error", err)
- }
+ logger := s.logger.With("job_id", uuid.New(), "job_name", jobName)
+ _ = s.auditLogService.CleanOldAuditLogs(ctx, logger)
}
}
}
-
-func (s *AuditLogBackgroundService) cleanOldAuditLogs() error {
- return s.auditLogService.CleanOldAuditLogs()
-}
diff --git a/backend/internal/features/audit_logs/background_service_test.go b/backend/internal/features/audit_logs/background_service_test.go
index 9e6a0461..90e4a937 100644
--- a/backend/internal/features/audit_logs/background_service_test.go
+++ b/backend/internal/features/audit_logs/background_service_test.go
@@ -9,14 +9,16 @@ import (
"github.com/stretchr/testify/assert"
"gorm.io/gorm"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
user_enums "databasus-backend/internal/features/users/enums"
users_testing "databasus-backend/internal/features/users/testing"
"databasus-backend/internal/storage"
+ "databasus-backend/internal/util/logger"
)
func Test_CleanOldAuditLogs_DeletesLogsOlderThanOneYear(t *testing.T) {
service := GetAuditLogService()
- user := users_testing.CreateTestUser(user_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleMember)
db := storage.GetDb()
baseTime := time.Now().UTC()
@@ -24,12 +26,18 @@ func Test_CleanOldAuditLogs_DeletesLogsOlderThanOneYear(t *testing.T) {
createTimedAuditLog(db, &user.UserID, "Old log 1", baseTime.Add(-400*24*time.Hour))
createTimedAuditLog(db, &user.UserID, "Old log 2", baseTime.Add(-370*24*time.Hour))
- // Create recent logs (less than 1 year old)
- createAuditLog(service, "Recent log 1", &user.UserID, nil)
- createAuditLog(service, "Recent log 2", &user.UserID, nil)
-
- // Run cleanup
- err := service.CleanOldAuditLogs()
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: "Recent log 1",
+ UserID: &user.UserID,
+ WorkspaceID: nil,
+ })
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: "Recent log 2",
+ UserID: &user.UserID,
+ WorkspaceID: nil,
+ })
+
+ err := service.CleanOldAuditLogs(t.Context(), logger.GetLogger())
assert.NoError(t, err)
// Verify old logs were deleted
@@ -46,7 +54,7 @@ func Test_CleanOldAuditLogs_DeletesLogsOlderThanOneYear(t *testing.T) {
func Test_CleanOldAuditLogs_PreservesLogsNewerThanOneYear(t *testing.T) {
service := GetAuditLogService()
- user := users_testing.CreateTestUser(user_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleMember)
db := storage.GetDb()
baseTime := time.Now().UTC()
@@ -57,14 +65,17 @@ func Test_CleanOldAuditLogs_PreservesLogsNewerThanOneYear(t *testing.T) {
// Create recent logs
createTimedAuditLog(db, &user.UserID, "Recent log 1", baseTime.Add(-364*24*time.Hour))
createTimedAuditLog(db, &user.UserID, "Recent log 2", baseTime.Add(-100*24*time.Hour))
- createAuditLog(service, "Current log", &user.UserID, nil)
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: "Current log",
+ UserID: &user.UserID,
+ WorkspaceID: nil,
+ })
// Get count before cleanup
var countBefore int64
db.Model(&AuditLog{}).Count(&countBefore)
- // Run cleanup
- err := service.CleanOldAuditLogs()
+ err := service.CleanOldAuditLogs(t.Context(), logger.GetLogger())
assert.NoError(t, err)
// Get count after cleanup
@@ -90,13 +101,13 @@ func Test_CleanOldAuditLogs_HandlesEmptyDatabase(t *testing.T) {
service := GetAuditLogService()
// Run cleanup on database that may have no old logs
- err := service.CleanOldAuditLogs()
+ err := service.CleanOldAuditLogs(t.Context(), logger.GetLogger())
assert.NoError(t, err)
}
func Test_CleanOldAuditLogs_DeletesMultipleOldLogs(t *testing.T) {
service := GetAuditLogService()
- user := users_testing.CreateTestUser(user_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleMember)
db := storage.GetDb()
baseTime := time.Now().UTC()
@@ -120,8 +131,7 @@ func Test_CleanOldAuditLogs_DeletesMultipleOldLogs(t *testing.T) {
db.Where("id IN ?", testLogIDs).Find(&logsBeforeCleanup)
assert.Equal(t, 5, len(logsBeforeCleanup), "All test logs should exist before cleanup")
- // Run cleanup
- err := service.CleanOldAuditLogs()
+ err := service.CleanOldAuditLogs(t.Context(), logger.GetLogger())
assert.NoError(t, err)
// Verify test logs were deleted
diff --git a/backend/internal/features/audit_logs/controller.go b/backend/internal/features/audit_logs/controller.go
index f4961a99..b008393b 100644
--- a/backend/internal/features/audit_logs/controller.go
+++ b/backend/internal/features/audit_logs/controller.go
@@ -49,12 +49,14 @@ func (c *AuditLogController) GetGlobalAuditLogs(ctx *gin.Context) {
return
}
- response, err := c.auditLogService.GetGlobalAuditLogs(user, request)
+ response, err := c.auditLogService.GetGlobalAuditLogs(ctx.Request.Context(), user, request)
if err != nil {
if errors.Is(err, ErrOnlyAdminsCanViewGlobalLogs) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
+ _ = ctx.Error(err)
+
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to retrieve audit logs"})
return
}
@@ -98,12 +100,14 @@ func (c *AuditLogController) GetUserAuditLogs(ctx *gin.Context) {
return
}
- response, err := c.auditLogService.GetUserAuditLogs(targetUserID, user, request)
+ response, err := c.auditLogService.GetUserAuditLogs(ctx.Request.Context(), targetUserID, user, request)
if err != nil {
if errors.Is(err, ErrInsufficientPermissionsToViewLogs) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
+ _ = ctx.Error(err)
+
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to retrieve audit logs"})
return
}
diff --git a/backend/internal/features/audit_logs/controller_test.go b/backend/internal/features/audit_logs/controller_test.go
index 89a0a103..8f6cc10c 100644
--- a/backend/internal/features/audit_logs/controller_test.go
+++ b/backend/internal/features/audit_logs/controller_test.go
@@ -10,6 +10,7 @@ import (
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
user_enums "databasus-backend/internal/features/users/enums"
users_middleware "databasus-backend/internal/features/users/middleware"
users_services "databasus-backend/internal/features/users/services"
@@ -18,8 +19,8 @@ import (
)
func Test_GetGlobalAuditLogs_WithDifferentUserRoles_EnforcesPermissionsCorrectly(t *testing.T) {
- adminUser := users_testing.CreateTestUser(user_enums.UserRoleAdmin)
- memberUser := users_testing.CreateTestUser(user_enums.UserRoleMember)
+ adminUser := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleAdmin)
+ memberUser := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleMember)
router := createRouter()
service := GetAuditLogService()
workspaceID := uuid.New()
@@ -30,11 +31,22 @@ func Test_GetGlobalAuditLogs_WithDifferentUserRoles_EnforcesPermissionsCorrectly
workspaceLogMessage := fmt.Sprintf("Test log with workspace %s", testID)
standaloneLogMessage := fmt.Sprintf("Test log standalone %s", testID)
- createAuditLog(service, userLogMessage, &adminUser.UserID, nil)
- createAuditLog(service, workspaceLogMessage, nil, &workspaceID)
- createAuditLog(service, standaloneLogMessage, nil, nil)
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: userLogMessage,
+ UserID: &adminUser.UserID,
+ WorkspaceID: nil,
+ })
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: workspaceLogMessage,
+ UserID: nil,
+ WorkspaceID: &workspaceID,
+ })
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: standaloneLogMessage,
+ UserID: nil,
+ WorkspaceID: nil,
+ })
- // Test ADMIN can access global logs
var response GetAuditLogsResponse
test_utils.MakeGetRequestAndUnmarshal(t, router,
"/api/v1/audit-logs/global?limit=100", "Bearer "+adminUser.Token, http.StatusOK, &response)
@@ -52,9 +64,9 @@ func Test_GetGlobalAuditLogs_WithDifferentUserRoles_EnforcesPermissionsCorrectly
}
func Test_GetUserAuditLogs_WithDifferentUserRoles_EnforcesPermissionsCorrectly(t *testing.T) {
- adminUser := users_testing.CreateTestUser(user_enums.UserRoleAdmin)
- user1 := users_testing.CreateTestUser(user_enums.UserRoleMember)
- user2 := users_testing.CreateTestUser(user_enums.UserRoleMember)
+ adminUser := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleAdmin)
+ user1 := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleMember)
+ user2 := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleMember)
router := createRouter()
service := GetAuditLogService()
workspaceID := uuid.New()
@@ -67,11 +79,31 @@ func Test_GetUserAuditLogs_WithDifferentUserRoles_EnforcesPermissionsCorrectly(t
user2SecondMessage := fmt.Sprintf("Test log user2 second %s", testID)
workspaceLogMessage := fmt.Sprintf("Test workspace log %s", testID)
- createAuditLog(service, user1FirstMessage, &user1.UserID, nil)
- createAuditLog(service, user1SecondMessage, &user1.UserID, &workspaceID)
- createAuditLog(service, user2FirstMessage, &user2.UserID, nil)
- createAuditLog(service, user2SecondMessage, &user2.UserID, &workspaceID)
- createAuditLog(service, workspaceLogMessage, nil, &workspaceID)
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: user1FirstMessage,
+ UserID: &user1.UserID,
+ WorkspaceID: nil,
+ })
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: user1SecondMessage,
+ UserID: &user1.UserID,
+ WorkspaceID: &workspaceID,
+ })
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: user2FirstMessage,
+ UserID: &user2.UserID,
+ WorkspaceID: nil,
+ })
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: user2SecondMessage,
+ UserID: &user2.UserID,
+ WorkspaceID: &workspaceID,
+ })
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: workspaceLogMessage,
+ UserID: nil,
+ WorkspaceID: &workspaceID,
+ })
// Test ADMIN can view any user's logs
var user1Response GetAuditLogsResponse
@@ -113,7 +145,7 @@ func Test_GetUserAuditLogs_WithDifferentUserRoles_EnforcesPermissionsCorrectly(t
}
func Test_GetGlobalAuditLogs_WithBeforeDateFilter_ReturnsFilteredLogs(t *testing.T) {
- adminUser := users_testing.CreateTestUser(user_enums.UserRoleAdmin)
+ adminUser := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleAdmin)
router := createRouter()
baseTime := time.Now().UTC()
diff --git a/backend/internal/features/audit_logs/di.go b/backend/internal/features/audit_logs/di.go
index a0640db6..85e288b8 100644
--- a/backend/internal/features/audit_logs/di.go
+++ b/backend/internal/features/audit_logs/di.go
@@ -12,6 +12,7 @@ var (
auditLogService = &AuditLogService{
auditLogRepository,
logger.GetLogger(),
+ logger.GetAuditLogger(),
}
)
diff --git a/backend/internal/features/audit_logs/models/entry.go b/backend/internal/features/audit_logs/models/entry.go
new file mode 100644
index 00000000..0270ea9e
--- /dev/null
+++ b/backend/internal/features/audit_logs/models/entry.go
@@ -0,0 +1,11 @@
+// Package audit_logs_models sits below audit_logs because users_interfaces declares the writer
+// seam while audit_logs imports users_services to wire it up, so the DTO cannot live in either.
+package audit_logs_models
+
+import "github.com/google/uuid"
+
+type AuditEntry struct {
+ Message string
+ UserID *uuid.UUID
+ WorkspaceID *uuid.UUID
+}
diff --git a/backend/internal/features/audit_logs/repository.go b/backend/internal/features/audit_logs/repository.go
index 9d1d38e9..dc6c161f 100644
--- a/backend/internal/features/audit_logs/repository.go
+++ b/backend/internal/features/audit_logs/repository.go
@@ -1,6 +1,7 @@
package audit_logs
import (
+ "context"
"time"
"github.com/google/uuid"
@@ -10,6 +11,9 @@ import (
type AuditLogRepository struct{}
+// Create is the one method here without a context, and deliberately so: the reads may be abandoned
+// when the caller goes away, but the row describing an action that already happened must be written
+// even if the client disconnected mid-request.
func (r *AuditLogRepository) Create(auditLog *AuditLog) error {
if auditLog.ID == uuid.Nil {
auditLog.ID = uuid.New()
@@ -19,6 +23,7 @@ func (r *AuditLogRepository) Create(auditLog *AuditLog) error {
}
func (r *AuditLogRepository) GetGlobal(
+ ctx context.Context,
limit, offset int,
beforeDate *time.Time,
) ([]*AuditLogDTO, error) {
@@ -48,12 +53,13 @@ func (r *AuditLogRepository) GetGlobal(
sql += " ORDER BY al.created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
- err := storage.GetDb().Raw(sql, args...).Scan(&auditLogs).Error
+ err := storage.GetDb().WithContext(ctx).Raw(sql, args...).Scan(&auditLogs).Error
return auditLogs, err
}
func (r *AuditLogRepository) GetByUser(
+ ctx context.Context,
userID uuid.UUID,
limit, offset int,
beforeDate *time.Time,
@@ -85,12 +91,13 @@ func (r *AuditLogRepository) GetByUser(
sql += " ORDER BY al.created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
- err := storage.GetDb().Raw(sql, args...).Scan(&auditLogs).Error
+ err := storage.GetDb().WithContext(ctx).Raw(sql, args...).Scan(&auditLogs).Error
return auditLogs, err
}
func (r *AuditLogRepository) GetByWorkspace(
+ ctx context.Context,
workspaceID uuid.UUID,
limit, offset int,
beforeDate *time.Time,
@@ -122,14 +129,14 @@ func (r *AuditLogRepository) GetByWorkspace(
sql += " ORDER BY al.created_at DESC LIMIT ? OFFSET ?"
args = append(args, limit, offset)
- err := storage.GetDb().Raw(sql, args...).Scan(&auditLogs).Error
+ err := storage.GetDb().WithContext(ctx).Raw(sql, args...).Scan(&auditLogs).Error
return auditLogs, err
}
-func (r *AuditLogRepository) CountGlobal(beforeDate *time.Time) (int64, error) {
+func (r *AuditLogRepository) CountGlobal(ctx context.Context, beforeDate *time.Time) (int64, error) {
var count int64
- query := storage.GetDb().Model(&AuditLog{})
+ query := storage.GetDb().WithContext(ctx).Model(&AuditLog{})
if beforeDate != nil {
query = query.Where("created_at < ?", *beforeDate)
@@ -139,8 +146,8 @@ func (r *AuditLogRepository) CountGlobal(beforeDate *time.Time) (int64, error) {
return count, err
}
-func (r *AuditLogRepository) DeleteOlderThan(beforeDate time.Time) (int64, error) {
- result := storage.GetDb().
+func (r *AuditLogRepository) DeleteOlderThan(ctx context.Context, beforeDate time.Time) (int64, error) {
+ result := storage.GetDb().WithContext(ctx).
Where("created_at < ?", beforeDate).
Delete(&AuditLog{})
diff --git a/backend/internal/features/audit_logs/service.go b/backend/internal/features/audit_logs/service.go
index 87df9f95..3c054f77 100644
--- a/backend/internal/features/audit_logs/service.go
+++ b/backend/internal/features/audit_logs/service.go
@@ -1,11 +1,14 @@
package audit_logs
import (
+ "context"
+ "fmt"
"log/slog"
"time"
"github.com/google/uuid"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
user_enums "databasus-backend/internal/features/users/enums"
user_models "databasus-backend/internal/features/users/models"
)
@@ -13,32 +16,29 @@ import (
type AuditLogService struct {
auditLogRepository *AuditLogRepository
logger *slog.Logger
+ auditLogger *slog.Logger
}
-func (s *AuditLogService) WriteAuditLog(
- message string,
- userID *uuid.UUID,
- workspaceID *uuid.UUID,
-) {
+// The log-pipeline write is what makes the trail survive the database it describes: an operator
+// who wipes audit_logs cannot erase what already left for the file and the remote backend.
+func (s *AuditLogService) WriteAuditLog(ctx context.Context, entry audit_logs_models.AuditEntry) {
auditLog := &AuditLog{
- UserID: userID,
- WorkspaceID: workspaceID,
- Message: message,
+ UserID: entry.UserID,
+ WorkspaceID: entry.WorkspaceID,
+ Message: entry.Message,
CreatedAt: time.Now().UTC(),
}
- err := s.auditLogRepository.Create(auditLog)
- if err != nil {
- s.logger.Error("failed to create audit log", "error", err)
- return
- }
-}
+ s.auditLogger.InfoContext(ctx, entry.Message, "user_id", entry.UserID, "workspace_id", entry.WorkspaceID)
-func (s *AuditLogService) CreateAuditLog(auditLog *AuditLog) error {
- return s.auditLogRepository.Create(auditLog)
+ if err := s.auditLogRepository.Create(auditLog); err != nil {
+ s.logger.ErrorContext(ctx, "failed to create audit log",
+ "error", err, "user_id", entry.UserID, "workspace_id", entry.WorkspaceID)
+ }
}
func (s *AuditLogService) GetGlobalAuditLogs(
+ ctx context.Context,
user *user_models.User,
request *GetAuditLogsRequest,
) (*GetAuditLogsResponse, error) {
@@ -53,12 +53,12 @@ func (s *AuditLogService) GetGlobalAuditLogs(
offset := max(request.Offset, 0)
- auditLogs, err := s.auditLogRepository.GetGlobal(limit, offset, request.BeforeDate)
+ auditLogs, err := s.auditLogRepository.GetGlobal(ctx, limit, offset, request.BeforeDate)
if err != nil {
return nil, err
}
- total, err := s.auditLogRepository.CountGlobal(request.BeforeDate)
+ total, err := s.auditLogRepository.CountGlobal(ctx, request.BeforeDate)
if err != nil {
return nil, err
}
@@ -72,6 +72,7 @@ func (s *AuditLogService) GetGlobalAuditLogs(
}
func (s *AuditLogService) GetUserAuditLogs(
+ ctx context.Context,
targetUserID uuid.UUID,
user *user_models.User,
request *GetAuditLogsRequest,
@@ -89,6 +90,7 @@ func (s *AuditLogService) GetUserAuditLogs(
offset := max(request.Offset, 0)
auditLogs, err := s.auditLogRepository.GetByUser(
+ ctx,
targetUserID,
limit,
offset,
@@ -107,6 +109,7 @@ func (s *AuditLogService) GetUserAuditLogs(
}
func (s *AuditLogService) GetWorkspaceAuditLogs(
+ ctx context.Context,
workspaceID uuid.UUID,
request *GetAuditLogsRequest,
) (*GetAuditLogsResponse, error) {
@@ -118,6 +121,7 @@ func (s *AuditLogService) GetWorkspaceAuditLogs(
offset := max(request.Offset, 0)
auditLogs, err := s.auditLogRepository.GetByWorkspace(
+ ctx,
workspaceID,
limit,
offset,
@@ -135,18 +139,19 @@ func (s *AuditLogService) GetWorkspaceAuditLogs(
}, nil
}
-func (s *AuditLogService) CleanOldAuditLogs() error {
+func (s *AuditLogService) CleanOldAuditLogs(ctx context.Context, logger *slog.Logger) error {
oneYearAgo := time.Now().UTC().Add(-365 * 24 * time.Hour)
- deletedCount, err := s.auditLogRepository.DeleteOlderThan(oneYearAgo)
+ deletedCount, err := s.auditLogRepository.DeleteOlderThan(ctx, oneYearAgo)
if err != nil {
- s.logger.Error("Failed to delete old audit logs", "error", err)
+ logger.ErrorContext(ctx, "failed to delete old audit logs", "error", err)
+
return err
}
- if deletedCount > 0 {
- s.logger.Info("Deleted old audit logs", "count", deletedCount, "olderThan", oneYearAgo)
- }
+ // Logged even at zero, so that "ran and found nothing" stays distinguishable from "never ran".
+ logger.InfoContext(ctx, fmt.Sprintf("deleted %d audit logs older than a year", deletedCount),
+ "older_than", oneYearAgo)
return nil
}
diff --git a/backend/internal/features/audit_logs/service_test.go b/backend/internal/features/audit_logs/service_test.go
index 764f48c8..6b977ed7 100644
--- a/backend/internal/features/audit_logs/service_test.go
+++ b/backend/internal/features/audit_logs/service_test.go
@@ -1,33 +1,59 @@
package audit_logs
import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "io"
+ "log/slog"
"testing"
"time"
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
user_enums "databasus-backend/internal/features/users/enums"
users_testing "databasus-backend/internal/features/users/testing"
+ "databasus-backend/internal/util/logger"
)
func Test_AuditLogs_WorkspaceSpecificLogs(t *testing.T) {
service := GetAuditLogService()
- user1 := users_testing.CreateTestUser(user_enums.UserRoleMember)
- user2 := users_testing.CreateTestUser(user_enums.UserRoleMember)
+ user1 := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleMember)
+ user2 := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleMember)
workspace1ID, workspace2ID := uuid.New(), uuid.New()
- // Create test logs for workspaces
- createAuditLog(service, "Test workspace1 log first", &user1.UserID, &workspace1ID)
- createAuditLog(service, "Test workspace1 log second", &user2.UserID, &workspace1ID)
- createAuditLog(service, "Test workspace2 log first", &user1.UserID, &workspace2ID)
- createAuditLog(service, "Test workspace2 log second", &user2.UserID, &workspace2ID)
- createAuditLog(service, "Test no workspace log", &user1.UserID, nil)
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: "Test workspace1 log first",
+ UserID: &user1.UserID,
+ WorkspaceID: &workspace1ID,
+ })
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: "Test workspace1 log second",
+ UserID: &user2.UserID,
+ WorkspaceID: &workspace1ID,
+ })
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: "Test workspace2 log first",
+ UserID: &user1.UserID,
+ WorkspaceID: &workspace2ID,
+ })
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: "Test workspace2 log second",
+ UserID: &user2.UserID,
+ WorkspaceID: &workspace2ID,
+ })
+ createAuditLog(t, service, audit_logs_models.AuditEntry{
+ Message: "Test no workspace log",
+ UserID: &user1.UserID,
+ WorkspaceID: nil,
+ })
request := &GetAuditLogsRequest{Limit: 10, Offset: 0}
- // Test workspace 1 logs
- workspace1Response, err := service.GetWorkspaceAuditLogs(workspace1ID, request)
+ workspace1Response, err := service.GetWorkspaceAuditLogs(t.Context(), workspace1ID, request)
assert.NoError(t, err)
assert.Equal(t, 2, len(workspace1Response.AuditLogs))
@@ -38,8 +64,7 @@ func Test_AuditLogs_WorkspaceSpecificLogs(t *testing.T) {
assert.Equal(t, &workspace1ID, log.WorkspaceID)
}
- // Test workspace 2 logs
- workspace2Response, err := service.GetWorkspaceAuditLogs(workspace2ID, request)
+ workspace2Response, err := service.GetWorkspaceAuditLogs(t.Context(), workspace2ID, request)
assert.NoError(t, err)
assert.Equal(t, 2, len(workspace2Response.AuditLogs))
@@ -47,16 +72,14 @@ func Test_AuditLogs_WorkspaceSpecificLogs(t *testing.T) {
assert.Contains(t, messages2, "Test workspace2 log first")
assert.Contains(t, messages2, "Test workspace2 log second")
- // Test pagination
- limitedResponse, err := service.GetWorkspaceAuditLogs(workspace1ID,
+ limitedResponse, err := service.GetWorkspaceAuditLogs(t.Context(), workspace1ID,
&GetAuditLogsRequest{Limit: 1, Offset: 0})
assert.NoError(t, err)
assert.Equal(t, 1, len(limitedResponse.AuditLogs))
assert.Equal(t, 1, limitedResponse.Limit)
- // Test beforeDate filter
beforeTime := time.Now().UTC().Add(-1 * time.Minute)
- filteredResponse, err := service.GetWorkspaceAuditLogs(workspace1ID,
+ filteredResponse, err := service.GetWorkspaceAuditLogs(t.Context(), workspace1ID,
&GetAuditLogsRequest{Limit: 10, BeforeDate: &beforeTime})
assert.NoError(t, err)
for _, log := range filteredResponse.AuditLogs {
@@ -70,8 +93,77 @@ func Test_AuditLogs_WorkspaceSpecificLogs(t *testing.T) {
}
}
-func createAuditLog(service *AuditLogService, message string, userID, workspaceID *uuid.UUID) {
- service.WriteAuditLog(message, userID, workspaceID)
+func Test_WriteAuditLog_PersistsRowAndEmitsToLogPipeline(t *testing.T) {
+ capturedRecords := &bytes.Buffer{}
+ user := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleMember)
+ workspaceID := uuid.New()
+
+ service := &AuditLogService{
+ GetAuditLogService().auditLogRepository,
+ slog.New(slog.NewJSONHandler(io.Discard, nil)),
+ slog.New(slog.NewJSONHandler(capturedRecords, nil)),
+ }
+
+ service.WriteAuditLog(t.Context(), audit_logs_models.AuditEntry{
+ Message: "Storage created: nightly-backups",
+ UserID: &user.UserID,
+ WorkspaceID: &workspaceID,
+ })
+
+ var auditRecord map[string]any
+ require.NoError(t, json.Unmarshal(capturedRecords.Bytes(), &auditRecord))
+ assert.Equal(t, "Storage created: nightly-backups", auditRecord["msg"])
+ assert.Equal(t, user.UserID.String(), auditRecord["user_id"])
+ assert.Equal(t, workspaceID.String(), auditRecord["workspace_id"])
+
+ persistedLogs, err := service.GetWorkspaceAuditLogs(t.Context(), workspaceID, &GetAuditLogsRequest{Limit: 10})
+ require.NoError(t, err)
+ assert.Contains(t, extractMessages(persistedLogs.AuditLogs), "Storage created: nightly-backups")
+}
+
+// A JSON sink cannot show this: the request id is attached by the fan-out handler from the context
+// it is handed, so the capturing handler asserts on the context instead of the output.
+func Test_WriteAuditLog_WhenRequestIsInFlight_EmitsUnderThatRequestID(t *testing.T) {
+ loggedRequestIDs := &[]string{}
+ user := users_testing.CreateTestUser(t.Context(), user_enums.UserRoleMember)
+ workspaceID := uuid.New()
+
+ service := &AuditLogService{
+ GetAuditLogService().auditLogRepository,
+ slog.New(slog.NewJSONHandler(io.Discard, nil)),
+ slog.New(requestIDCapturer{loggedRequestIDs}),
+ }
+
+ ctx := logger.ContextWithRequestID(t.Context(), "3b0f7a52-6c11-4e39-9f7d-2a5c8e4b1d06")
+ service.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: "Database deleted: payments",
+ UserID: &user.UserID,
+ WorkspaceID: &workspaceID,
+ })
+
+ assert.Equal(t, []string{"3b0f7a52-6c11-4e39-9f7d-2a5c8e4b1d06"}, *loggedRequestIDs)
+}
+
+type requestIDCapturer struct {
+ requestIDs *[]string
+}
+
+func (h requestIDCapturer) Enabled(context.Context, slog.Level) bool { return true }
+
+func (h requestIDCapturer) WithAttrs([]slog.Attr) slog.Handler { return h }
+
+func (h requestIDCapturer) WithGroup(string) slog.Handler { return h }
+
+func (h requestIDCapturer) Handle(ctx context.Context, _ slog.Record) error {
+ *h.requestIDs = append(*h.requestIDs, logger.GetRequestID(ctx))
+
+ return nil
+}
+
+func createAuditLog(t *testing.T, service *AuditLogService, entry audit_logs_models.AuditEntry) {
+ t.Helper()
+
+ service.WriteAuditLog(t.Context(), entry)
}
func extractMessages(logs []*AuditLogDTO) []string {
diff --git a/backend/internal/features/backups/backups/backuping/logical/backuper.go b/backend/internal/features/backups/backups/backuping/logical/backuper.go
index 2aafb7ce..1b288340 100644
--- a/backend/internal/features/backups/backups/backuping/logical/backuper.go
+++ b/backend/internal/features/backups/backups/backuping/logical/backuper.go
@@ -23,6 +23,8 @@ import (
util_encryption "databasus-backend/internal/util/encryption"
)
+const partialBackupCleanupTimeout = 30 * time.Second
+
type Backuper struct {
databaseService *databases.DatabaseService
fieldEncryptor util_encryption.FieldEncryptor
@@ -36,44 +38,46 @@ type Backuper struct {
createBackupUseCase backups_core_logical.CreateBackupUsecase
}
-func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
+func (b *Backuper) MakeBackup(ctx context.Context, backupID uuid.UUID, isCallNotifier bool) {
backup, err := b.backupRepository.FindByID(backupID)
if err != nil {
- b.logger.Error("Failed to get backup by ID", "backupId", backupID, "error", err)
+ b.logger.ErrorContext(ctx, "failed to get backup by ID", "backup_id", backupID, "error", err)
return
}
databaseID := backup.DatabaseID
+ logger := b.logger.With("backup_id", backupID, "database_id", databaseID)
database, err := b.databaseService.GetDatabaseByID(databaseID)
if err != nil {
- b.logger.Error("Failed to get database by ID", "databaseId", databaseID, "error", err)
+ logger.ErrorContext(ctx, "failed to get database by ID", "error", err)
return
}
backupConfig, err := b.backupConfigService.GetBackupConfigByDbId(databaseID)
if err != nil {
- b.logger.Error("Failed to get backup config by database ID", "error", err)
+ logger.ErrorContext(ctx, "failed to get backup config by database ID", "error", err)
return
}
if backupConfig.StorageID == nil {
- b.logger.Error("Backup config storage ID is not defined")
+ logger.ErrorContext(ctx, "backup config storage ID is not defined")
return
}
- storage, err := b.storageService.GetStorageByID(*backupConfig.StorageID)
+ // Detached from the caller so a finished HTTP request cannot cancel a running backup.
+ executionCtx, cancel := context.WithCancel(context.Background())
+ b.backupCancelManager.RegisterTask(backup.ID, cancel)
+ defer b.backupCancelManager.UnregisterTask(backup.ID)
+
+ storage, err := b.storageService.GetStorageByID(executionCtx, *backupConfig.StorageID)
if err != nil {
- b.logger.Error("Failed to get storage by ID", "error", err)
+ logger.ErrorContext(ctx, "failed to get storage by ID", "error", err)
return
}
start := time.Now().UTC()
- ctx, cancel := context.WithCancel(context.Background())
- b.backupCancelManager.RegisterTask(backup.ID, cancel)
- defer b.backupCancelManager.UnregisterTask(backup.ID)
-
backupProgressListener := func(
completedMBs float64,
) {
@@ -81,12 +85,12 @@ func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
backup.BackupDurationMs = time.Since(start).Milliseconds()
if err := b.backupRepository.Save(backup); err != nil {
- b.logger.Error("Failed to update backup progress", "error", err)
+ logger.ErrorContext(ctx, "failed to update backup progress", "error", err)
}
}
backupMetadata, err := b.createBackupUseCase.Execute(
- ctx,
+ executionCtx,
backup,
backupConfig,
database,
@@ -98,16 +102,16 @@ func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
// If so, skip error handling to avoid overwriting the status
currentBackup, fetchErr := b.backupRepository.FindByID(backup.ID)
if fetchErr == nil && currentBackup.Status == backups_core_logical.BackupStatusFailed {
- b.logger.Warn(
- "Backup already marked as failed by progress listener, skipping error handling",
- "backupId",
+ logger.WarnContext(ctx,
+ "backup already marked as failed by progress listener, skipping error handling",
+ "backup_id",
backup.ID,
- "failMessage",
+ "fail_message",
*currentBackup.FailMessage,
)
// Still call notification for size limit failures
- b.SendBackupNotification(
+ b.SendBackupNotification(ctx,
backupConfig,
currentBackup,
backups_config_logical.NotificationBackupFailed,
@@ -120,14 +124,13 @@ func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
errMsg := err.Error()
// Log detailed error information for debugging
- b.logger.Error("Backup execution failed",
- "backupId", backup.ID,
- "databaseId", databaseID,
- "databaseType", database.Type,
- "storageId", storage.ID,
- "storageType", storage.Type,
+ logger.ErrorContext(ctx, "backup execution failed",
+ "backup_id", backup.ID,
+ "database_id", databaseID,
+ "database_type", database.Type,
+ "storage_id", storage.ID,
+ "storage_type", storage.Type,
"error", err,
- "errorMessage", errMsg,
)
// Check if backup was cancelled (not due to shutdown)
@@ -137,10 +140,10 @@ func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
isShutdown := strings.Contains(errMsg, "shutdown")
if isCancelled && !isShutdown {
- b.logger.Warn("Backup was cancelled by user or system",
- "backupId", backup.ID,
- "isCancelled", isCancelled,
- "isShutdown", isShutdown,
+ logger.WarnContext(ctx, "backup was cancelled by user or system",
+ "backup_id", backup.ID,
+ "is_cancelled", isCancelled,
+ "is_shutdown", isShutdown,
)
backup.Status = backups_core_logical.BackupStatusCanceled
@@ -148,16 +151,25 @@ func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
backup.BackupSizeMb = 0
if err := b.backupRepository.Save(backup); err != nil {
- b.logger.Error("Failed to save cancelled backup", "error", err)
+ logger.ErrorContext(ctx, "failed to save cancelled backup", "error", err)
}
- // Delete partial backup from storage
- storage, storageErr := b.storageService.GetStorageByID(backup.StorageID)
+ // This branch is reached because executionCtx was cancelled, so the cleanup needs a live
+ // context of its own or the partial file is never deleted.
+ cleanupCtx, cancelCleanup := context.WithTimeout(context.Background(), partialBackupCleanupTimeout)
+ defer cancelCleanup()
+
+ partialBackupStorage, storageErr := b.storageService.GetStorageByID(cleanupCtx, backup.StorageID)
if storageErr == nil {
- if deleteErr := storage.DeleteFile(b.fieldEncryptor, backup.FileName); deleteErr != nil {
- b.logger.Error(
- "Failed to delete partial backup file",
- "backupId",
+ if deleteErr := partialBackupStorage.DeleteFile(
+ cleanupCtx,
+ b.fieldEncryptor,
+ logger,
+ backup.FileName,
+ ); deleteErr != nil {
+ logger.ErrorContext(ctx,
+ "failed to delete partial backup file",
+ "backup_id",
backup.ID,
"error",
deleteErr,
@@ -174,20 +186,21 @@ func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
backup.BackupSizeMb = 0
if updateErr := b.databaseService.SetBackupError(databaseID, errMsg); updateErr != nil {
- b.logger.Error(
- "Failed to update database last backup time",
- "databaseId",
- databaseID,
+ logger.ErrorContext(ctx,
+ "failed to update database last backup time",
"error",
updateErr,
)
}
if err := b.backupRepository.Save(backup); err != nil {
- b.logger.Error("Failed to save backup", "error", err)
+ logger.ErrorContext(ctx, "failed to save backup", "error", err)
}
- b.SendBackupNotification(
+ logger.ErrorContext(ctx, fmt.Sprintf("logical backup failed after %d ms: %s",
+ backup.BackupDurationMs, errMsg))
+
+ b.SendBackupNotification(ctx,
backupConfig,
backup,
backups_config_logical.NotificationBackupFailed,
@@ -204,7 +217,7 @@ func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
backupMetadata.BackupID = backup.ID
if err := backupMetadata.Validate(); err != nil {
- b.logger.Error("Failed to validate backup metadata", "error", err)
+ logger.ErrorContext(ctx, "failed to validate backup metadata", "error", err)
return
}
@@ -216,31 +229,30 @@ func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
if backupMetadata != nil {
metadataJSON, err := json.Marshal(backupMetadata)
if err != nil {
- b.logger.Error("Failed to marshal backup metadata to JSON",
- "backupId", backup.ID,
+ logger.ErrorContext(ctx, "failed to marshal backup metadata to JSON",
+ "backup_id", backup.ID,
"error", err,
)
} else {
metadataReader := bytes.NewReader(metadataJSON)
metadataFileName := backup.FileName + ".metadata"
+ // Not executionCtx: the dump itself already succeeded, and a cancel landing here would
+ // leave a completed backup whose encryption metadata is missing, making it unrestorable.
if err := storage.SaveFile(
context.Background(),
b.fieldEncryptor,
- b.logger,
+ logger,
metadataFileName,
metadataReader,
); err != nil {
- b.logger.Error("Failed to save backup metadata file to storage",
- "backupId", backup.ID,
- "fileName", metadataFileName,
+ logger.ErrorContext(ctx, "failed to save backup metadata file to storage",
+ "backup_id", backup.ID,
+ "file_name", metadataFileName,
"error", err,
)
} else {
- b.logger.Info("Backup metadata file saved successfully",
- "backupId", backup.ID,
- "fileName", metadataFileName,
- )
+ logger.DebugContext(ctx, "backup metadata file saved", "file_name", metadataFileName)
}
}
}
@@ -248,17 +260,18 @@ func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
backup.Status = backups_core_logical.BackupStatusCompleted
if err := b.backupRepository.Save(backup); err != nil {
- b.logger.Error("Failed to save backup", "error", err)
+ logger.ErrorContext(ctx, "failed to save backup", "error", err)
return
}
+ logger.InfoContext(ctx, fmt.Sprintf("logical backup finished: %.1f MB in %d ms",
+ backup.BackupSizeMb, backup.BackupDurationMs), "file_name", backup.FileName)
+
// Update database last backup time
now := time.Now().UTC()
if updateErr := b.databaseService.SetLastBackupTime(databaseID, now); updateErr != nil {
- b.logger.Error(
- "Failed to update database last backup time",
- "databaseId",
- databaseID,
+ logger.ErrorContext(ctx,
+ "failed to update database last backup time",
"error",
updateErr,
)
@@ -268,7 +281,7 @@ func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
return
}
- b.SendBackupNotification(
+ b.SendBackupNotification(ctx,
backupConfig,
backup,
backups_config_logical.NotificationBackupSuccess,
@@ -277,18 +290,25 @@ func (b *Backuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
}
func (b *Backuper) SendBackupNotification(
+ ctx context.Context,
backupConfig *backups_config_logical.LogicalBackupConfig,
backup *backups_core_logical.LogicalBackup,
notificationType backups_config_logical.BackupNotificationType,
errorMessage *string,
) {
+ logger := b.logger.With("backup_id", backup.ID, "database_id", backupConfig.DatabaseID)
+
database, err := b.databaseService.GetDatabaseByID(backupConfig.DatabaseID)
if err != nil {
+ logger.ErrorContext(ctx, "failed to get database for the backup notification", "error", err)
+
return
}
workspace, err := b.workspaceService.GetWorkspaceByID(*database.WorkspaceID)
if err != nil {
+ logger.ErrorContext(ctx, "failed to get workspace for the backup notification", "error", err)
+
return
}
@@ -297,6 +317,9 @@ func (b *Backuper) SendBackupNotification(
backupConfig.SendNotificationsOn,
notificationType,
) {
+ logger.DebugContext(ctx, fmt.Sprintf("skipping %s notification, not in the configured set",
+ notificationType), "notifier_id", notifier.ID)
+
continue
}
@@ -345,7 +368,7 @@ func (b *Backuper) SendBackupNotification(
)
}
- b.notificationSender.SendNotification(
+ b.notificationSender.SendNotification(ctx,
&notifier,
notifier_models.Notification{
Type: sentNotificationType,
diff --git a/backend/internal/features/backups/backups/backuping/logical/backuper_test.go b/backend/internal/features/backups/backups/backuping/logical/backuper_test.go
index 9db2c833..fece528e 100644
--- a/backend/internal/features/backups/backups/backuping/logical/backuper_test.go
+++ b/backend/internal/features/backups/backups/backuping/logical/backuper_test.go
@@ -1,7 +1,10 @@
package backuping_logical
import (
+ "context"
+ "log/slog"
"strings"
+ "sync"
"testing"
"time"
@@ -18,17 +21,18 @@ import (
users_testing "databasus-backend/internal/features/users/testing"
workspaces_testing "databasus-backend/internal/features/workspaces/testing"
cache_utils "databasus-backend/internal/util/cache"
+ util_logger "databasus-backend/internal/util/logger"
)
func Test_BackupExecuted_NotificationSent(t *testing.T) {
cache_utils.ClearAllCache()
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
- backups_config_logical.EnableBackupsForTestDatabase(database.ID, storage)
+ backups_config_logical.EnableBackupsForTestDatabase(t.Context(), database.ID, storage)
defer func() {
// cleanup backups first
@@ -37,11 +41,11 @@ func Test_BackupExecuted_NotificationSent(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond) // Wait for cascading deletes
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
t.Run("BackupFailed_FailNotificationSent", func(t *testing.T) {
@@ -70,7 +74,7 @@ func Test_BackupExecuted_NotificationSent(t *testing.T) {
}),
).Once()
- backuper.MakeBackup(backup.ID, true)
+ backuper.MakeBackup(t.Context(), backup.ID, true)
// Verify all expectations were met
mockNotificationSender.AssertExpectations(t)
@@ -102,7 +106,7 @@ func Test_BackupExecuted_NotificationSent(t *testing.T) {
}),
).Once()
- backuper.MakeBackup(backup.ID, true)
+ backuper.MakeBackup(t.Context(), backup.ID, true)
// Verify all expectations were met
mockNotificationSender.AssertExpectations(t)
@@ -136,7 +140,7 @@ func Test_BackupExecuted_NotificationSent(t *testing.T) {
capturedNotification = args.Get(1).(notifier_models.Notification)
}).Once()
- backuper.MakeBackup(backup.ID, true)
+ backuper.MakeBackup(t.Context(), backup.ID, true)
// Verify expectations were met
mockNotificationSender.AssertExpectations(t)
@@ -150,3 +154,63 @@ func Test_BackupExecuted_NotificationSent(t *testing.T) {
assert.Equal(t, notifier.ID, capturedNotifier.ID)
})
}
+
+func Test_MakeBackup_WhenCallerContextCarriesRequestID_FinishLineIsAttributed(t *testing.T) {
+ fixture := CreateBackupTestFixture(t, "Attribution Test Workspace")
+
+ capturingHandler := &requestIDCapturingHandler{requestIDByMessage: map[string]string{}}
+
+ mockNotificationSender := &MockNotificationSender{}
+ mockNotificationSender.On("SendNotification", mock.Anything, mock.Anything).Maybe()
+
+ backuper := CreateTestBackuper()
+ backuper.notificationSender = mockNotificationSender
+ backuper.createBackupUseCase = &CreateSuccessBackupUsecase{}
+ backuper.logger = slog.New(capturingHandler)
+
+ backup := SeedInProgressTestBackup(t, fixture.Database.ID, fixture.Storage.ID)
+
+ const requestID = "request-id-under-test"
+
+ backuper.MakeBackup(util_logger.ContextWithRequestID(t.Context(), requestID), backup.ID, true)
+
+ capturedRequestID, isLogged := capturingHandler.GetRequestIDForMessagePrefix("logical backup finished")
+
+ assert.True(t, isLogged, "the backup finish line was never logged")
+ assert.Equal(t, requestID, capturedRequestID)
+}
+
+// A record logged on the detached execution context is indistinguishable from one that never
+// carried a request at all, which is what this pins.
+type requestIDCapturingHandler struct {
+ mutex sync.Mutex
+ requestIDByMessage map[string]string
+}
+
+func (h *requestIDCapturingHandler) Enabled(context.Context, slog.Level) bool { return true }
+
+func (h *requestIDCapturingHandler) Handle(ctx context.Context, record slog.Record) error {
+ h.mutex.Lock()
+ defer h.mutex.Unlock()
+
+ h.requestIDByMessage[record.Message] = util_logger.GetRequestID(ctx)
+
+ return nil
+}
+
+func (h *requestIDCapturingHandler) WithAttrs([]slog.Attr) slog.Handler { return h }
+
+func (h *requestIDCapturingHandler) WithGroup(string) slog.Handler { return h }
+
+func (h *requestIDCapturingHandler) GetRequestIDForMessagePrefix(prefix string) (string, bool) {
+ h.mutex.Lock()
+ defer h.mutex.Unlock()
+
+ for message, requestID := range h.requestIDByMessage {
+ if strings.HasPrefix(message, prefix) {
+ return requestID, true
+ }
+ }
+
+ return "", false
+}
diff --git a/backend/internal/features/backups/backups/backuping/logical/cleaner.go b/backend/internal/features/backups/backups/backuping/logical/cleaner.go
index e44d1d04..30ff36e1 100644
--- a/backend/internal/features/backups/backups/backuping/logical/cleaner.go
+++ b/backend/internal/features/backups/backups/backuping/logical/cleaner.go
@@ -18,7 +18,9 @@ import (
)
const (
- cleanerTickerInterval = 3 * time.Second
+ cleanerTickerInterval = 3 * time.Second
+
+ cleanerJobName = "logical_backup_retention_cleanup"
recentBackupGracePeriod = 60 * time.Minute
)
@@ -42,46 +44,58 @@ func (c *BackupCleaner) Run(ctx context.Context) {
return
}
- retentionLog := c.logger.With("task_name", "clean_by_retention_policy")
-
ticker := time.NewTicker(cleanerTickerInterval)
defer ticker.Stop()
+ lifecycleLogger := c.logger.With("job_name", cleanerJobName)
+
+ lifecycleLogger.InfoContext(ctx, "logical backup retention cleaner started")
+
for {
select {
case <-ctx.Done():
+ lifecycleLogger.InfoContext(ctx, "logical backup retention cleaner stopped")
+
return
case <-ticker.C:
- if err := c.cleanByRetentionPolicy(retentionLog); err != nil {
- retentionLog.Error("failed to clean backups by retention policy", "error", err)
+ retentionLog := c.logger.With(
+ "job_id", uuid.New(),
+ "job_name", cleanerJobName,
+ "task_name", "clean_by_retention_policy",
+ )
+
+ if err := c.cleanByRetentionPolicy(ctx, retentionLog); err != nil {
+ retentionLog.ErrorContext(ctx, "failed to clean backups by retention policy", "error", err)
}
}
}
}
-func (c *BackupCleaner) DeleteBackup(backup *backups_core_logical.LogicalBackup) error {
+func (c *BackupCleaner) DeleteBackup(ctx context.Context, backup *backups_core_logical.LogicalBackup) error {
+ logger := c.logger.With("backup_id", backup.ID, "database_id", backup.DatabaseID)
+
for _, listener := range c.backupRemoveListeners {
if err := listener.OnBeforeBackupRemove(backup); err != nil {
return err
}
}
- storage, err := c.storageService.GetStorageByID(backup.StorageID)
+ storage, err := c.storageService.GetStorageByID(ctx, backup.StorageID)
if err != nil {
return err
}
- if err := storage.DeleteFile(c.fieldEncryptor, backup.FileName); err != nil {
+ if err := storage.DeleteFile(ctx, c.fieldEncryptor, logger, backup.FileName); err != nil {
// we do not return error here, because sometimes clean up performed
// before unavailable storage removal or change - therefore we should
// proceed even in case of error. It's possible that some S3 or
// storage is not available yet, it should not block us
- c.logger.Error("Failed to delete backup file", "error", err)
+ logger.WarnContext(ctx, "failed to delete backup file", "error", err)
}
metadataFileName := backup.FileName + ".metadata"
- if err := storage.DeleteFile(c.fieldEncryptor, metadataFileName); err != nil {
- c.logger.Error("Failed to delete backup metadata file", "error", err)
+ if err := storage.DeleteFile(ctx, c.fieldEncryptor, logger, metadataFileName); err != nil {
+ logger.WarnContext(ctx, "failed to delete backup metadata file", "error", err)
}
return c.backupRepository.DeleteByID(backup.ID)
@@ -91,7 +105,7 @@ func (c *BackupCleaner) AddBackupRemoveListener(listener backups_core_logical.Ba
c.backupRemoveListeners = append(c.backupRemoveListeners, listener)
}
-func (c *BackupCleaner) cleanByRetentionPolicy(logger *slog.Logger) error {
+func (c *BackupCleaner) cleanByRetentionPolicy(ctx context.Context, logger *slog.Logger) error {
enabledBackupConfigs, err := c.backupConfigService.GetBackupConfigsWithEnabledBackups()
if err != nil {
return err
@@ -104,15 +118,15 @@ func (c *BackupCleaner) cleanByRetentionPolicy(logger *slog.Logger) error {
switch backupConfig.RetentionPolicyType {
case backups_config_logical.RetentionPolicyTypeCount:
- cleanErr = c.cleanByCount(dbLog, backupConfig)
+ cleanErr = c.cleanByCount(ctx, dbLog, backupConfig)
case backups_config_logical.RetentionPolicyTypeGFS:
- cleanErr = c.cleanByGFS(dbLog, backupConfig)
+ cleanErr = c.cleanByGFS(ctx, dbLog, backupConfig)
default:
- cleanErr = c.cleanByTimePeriod(dbLog, backupConfig)
+ cleanErr = c.cleanByTimePeriod(ctx, dbLog, backupConfig)
}
if cleanErr != nil {
- dbLog.Error("failed to clean backups by retention policy", "error", cleanErr)
+ dbLog.ErrorContext(ctx, "failed to clean backups by retention policy", "error", cleanErr)
}
}
@@ -120,14 +134,13 @@ func (c *BackupCleaner) cleanByRetentionPolicy(logger *slog.Logger) error {
}
func (c *BackupCleaner) cleanByTimePeriod(
+ ctx context.Context,
logger *slog.Logger,
backupConfig *backups_config_logical.LogicalBackupConfig,
) error {
- if backupConfig.RetentionTimePeriod == "" {
- return nil
- }
+ if backupConfig.RetentionTimePeriod == "" || backupConfig.RetentionTimePeriod == period.PeriodForever {
+ logger.DebugContext(ctx, "time-period retention keeps everything, nothing to evaluate")
- if backupConfig.RetentionTimePeriod == period.PeriodForever {
return nil
}
@@ -138,27 +151,52 @@ func (c *BackupCleaner) cleanByTimePeriod(
return fmt.Errorf("failed to find old backups for database %s: %w", backupConfig.DatabaseID, err)
}
+ deletedCount, withinGraceCount := 0, 0
+
for _, backup := range oldBackups {
if isRecentBackup(backup) {
+ withinGraceCount++
+
+ logger.DebugContext(ctx, fmt.Sprintf("keeping backup, still within the %s grace period",
+ recentBackupGracePeriod), "backup_id", backup.ID)
+
continue
}
- if err := c.DeleteBackup(backup); err != nil {
- logger.Error("failed to delete backup", "backup_id", backup.ID, "error", err)
+ if err := c.DeleteBackup(ctx, backup); err != nil {
+ logger.ErrorContext(ctx, "failed to delete backup", "backup_id", backup.ID, "error", err)
+
continue
}
- logger.Info("deleted old backup", "backup_id", backup.ID)
+ deletedCount++
+
+ logger.InfoContext(ctx, fmt.Sprintf("deleted backup older than %s (%.1f MB)",
+ backupConfig.RetentionTimePeriod, backup.BackupSizeMb), "backup_id", backup.ID)
+ }
+
+ summary := fmt.Sprintf("time-period retention: %d backups past the %s cutoff, %d deleted, %d within grace",
+ len(oldBackups), backupConfig.RetentionTimePeriod, deletedCount, withinGraceCount)
+
+ // The cleaner ticks every few seconds, so a summary of a run that changed nothing belongs at
+ // debug; only an actual deletion is a state change.
+ if deletedCount > 0 {
+ logger.InfoContext(ctx, summary)
+ } else {
+ logger.DebugContext(ctx, summary)
}
return nil
}
func (c *BackupCleaner) cleanByCount(
+ ctx context.Context,
logger *slog.Logger,
backupConfig *backups_config_logical.LogicalBackupConfig,
) error {
if backupConfig.RetentionCount <= 0 {
+ logger.DebugContext(ctx, "count retention is not configured, nothing to evaluate")
+
return nil
}
@@ -168,33 +206,60 @@ func (c *BackupCleaner) cleanByCount(
}
if len(completedBackups) <= backupConfig.RetentionCount {
+ logger.DebugContext(ctx, fmt.Sprintf("count retention: keeping all %d backups, limit is %d",
+ len(completedBackups), backupConfig.RetentionCount))
+
return nil
}
- successMsg := fmt.Sprintf("deleted backup by count policy: retention count is %d", backupConfig.RetentionCount)
+ deletedCount, withinGraceCount := 0, 0
+
for _, backup := range completedBackups[backupConfig.RetentionCount:] {
if isRecentBackup(backup) {
+ withinGraceCount++
+
+ logger.DebugContext(ctx, fmt.Sprintf("keeping backup, still within the %s grace period",
+ recentBackupGracePeriod), "backup_id", backup.ID)
+
continue
}
- if err := c.DeleteBackup(backup); err != nil {
- logger.Error("failed to delete backup", "backup_id", backup.ID, "error", err)
+ if err := c.DeleteBackup(ctx, backup); err != nil {
+ logger.ErrorContext(ctx, "failed to delete backup", "backup_id", backup.ID, "error", err)
+
continue
}
- logger.Info(successMsg, "backup_id", backup.ID)
+ deletedCount++
+
+ logger.InfoContext(ctx, fmt.Sprintf("deleted backup past the retention count of %d (%.1f MB)",
+ backupConfig.RetentionCount, backup.BackupSizeMb), "backup_id", backup.ID)
+ }
+
+ summary := fmt.Sprintf("count retention: %d completed backups, %d kept by limit, %d deleted, %d within grace",
+ len(completedBackups), backupConfig.RetentionCount, deletedCount, withinGraceCount)
+
+ if deletedCount > 0 {
+ logger.InfoContext(ctx, summary)
+ } else {
+ logger.DebugContext(ctx, summary)
}
return nil
}
func (c *BackupCleaner) cleanByGFS(
+ ctx context.Context,
logger *slog.Logger,
backupConfig *backups_config_logical.LogicalBackupConfig,
) error {
if backupConfig.RetentionGfsHours <= 0 && backupConfig.RetentionGfsDays <= 0 &&
backupConfig.RetentionGfsWeeks <= 0 && backupConfig.RetentionGfsMonths <= 0 &&
backupConfig.RetentionGfsYears <= 0 {
+ // Every tier is zero, so GFS retains nothing and would delete every backup if it ran. Debug
+ // rather than Warn: an empty config is a deliberate state, and this runs on every tick.
+ logger.DebugContext(ctx, "gfs retention has no tier configured, keeping everything")
+
return nil
}
@@ -203,7 +268,7 @@ func (c *BackupCleaner) cleanByGFS(
return err
}
- keepSet := buildGFSKeepSet(
+ retainedTiersByBackupID := buildRetainedTiersByBackupID(
completedBackups,
backupConfig.RetentionGfsHours,
backupConfig.RetentionGfsDays,
@@ -212,21 +277,47 @@ func (c *BackupCleaner) cleanByGFS(
backupConfig.RetentionGfsYears,
)
+ deletedCount, withinGraceCount := 0, 0
+
for _, backup := range completedBackups {
- if keepSet[backup.ID] {
+ if tiers := retainedTiersByBackupID[backup.ID]; len(tiers) > 0 {
+ logger.DebugContext(ctx, fmt.Sprintf("keeping backup, retained as %s", gfs.FormatTiers(tiers)),
+ "backup_id", backup.ID)
+
continue
}
if isRecentBackup(backup) {
+ withinGraceCount++
+
+ logger.DebugContext(ctx, fmt.Sprintf("keeping backup, still within the %s grace period",
+ recentBackupGracePeriod), "backup_id", backup.ID)
+
continue
}
- if err := c.DeleteBackup(backup); err != nil {
- logger.Error("failed to delete backup", "backup_id", backup.ID, "error", err)
+ if err := c.DeleteBackup(ctx, backup); err != nil {
+ logger.ErrorContext(ctx, "failed to delete backup", "backup_id", backup.ID, "error", err)
+
continue
}
- logger.Info("deleted backup by GFS policy", "backup_id", backup.ID)
+ deletedCount++
+
+ logger.InfoContext(ctx, fmt.Sprintf("deleted backup not retained by any gfs tier (%.1f MB)",
+ backup.BackupSizeMb), "backup_id", backup.ID)
+ }
+
+ summary := fmt.Sprintf(
+ "gfs retention (%dh/%dd/%dw/%dm/%dy): %d completed backups, %d kept by tier, %d deleted, %d within grace",
+ backupConfig.RetentionGfsHours, backupConfig.RetentionGfsDays, backupConfig.RetentionGfsWeeks,
+ backupConfig.RetentionGfsMonths, backupConfig.RetentionGfsYears,
+ len(completedBackups), len(retainedTiersByBackupID), deletedCount, withinGraceCount)
+
+ if deletedCount > 0 {
+ logger.InfoContext(ctx, summary)
+ } else {
+ logger.DebugContext(ctx, summary)
}
return nil
@@ -248,12 +339,10 @@ func isRecentBackup(backup *backups_core_logical.LogicalBackup) bool {
return time.Since(backup.CreatedAt) < recentBackupGracePeriod
}
-// buildGFSKeepSet projects logical backups onto the shared GFS keep-set
-// algorithm. Backups must be sorted newest-first.
-func buildGFSKeepSet(
+func buildRetainedTiersByBackupID(
backups []*backups_core_logical.LogicalBackup,
hours, days, weeks, months, years int,
-) map[uuid.UUID]bool {
+) map[uuid.UUID][]gfs.Tier {
items := make([]gfs.Item, len(backups))
for i, backup := range backups {
items[i] = gfs.Item{ID: backup.ID, CreatedAt: backup.CreatedAt}
diff --git a/backend/internal/features/backups/backups/backuping/logical/cleaner_gfs_test.go b/backend/internal/features/backups/backups/backuping/logical/cleaner_gfs_test.go
index 57ec19b6..ea316d5b 100644
--- a/backend/internal/features/backups/backups/backuping/logical/cleaner_gfs_test.go
+++ b/backend/internal/features/backups/backups/backuping/logical/cleaner_gfs_test.go
@@ -346,7 +346,14 @@ func Test_BuildGFSKeepSet(t *testing.T) {
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
- keepSet := buildGFSKeepSet(tc.backups, tc.hours, tc.days, tc.weeks, tc.months, tc.years)
+ retainedTiersByBackupID := buildRetainedTiersByBackupID(
+ tc.backups,
+ tc.hours,
+ tc.days,
+ tc.weeks,
+ tc.months,
+ tc.years,
+ )
keptIndexSet := make(map[int]bool, len(tc.keptIndices))
for _, idx := range tc.keptIndices {
@@ -355,11 +362,11 @@ func Test_BuildGFSKeepSet(t *testing.T) {
for i, backup := range tc.backups {
if keptIndexSet[i] {
- assert.True(t, keepSet[backup.ID],
+ assert.NotEmpty(t, retainedTiersByBackupID[backup.ID],
"backup at index %d (date=%s) should be kept",
i, backup.CreatedAt.Format("2006-01-02 15:04"))
} else {
- assert.False(t, keepSet[backup.ID],
+ assert.Empty(t, retainedTiersByBackupID[backup.ID],
"backup at index %d (date=%s) should be deleted",
i, backup.CreatedAt.Format("2006-01-02 15:04"))
}
@@ -370,8 +377,8 @@ func Test_BuildGFSKeepSet(t *testing.T) {
func Test_CleanByGFS_KeepsCorrectBackupsPerSlot(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -382,11 +389,11 @@ func Test_CleanByGFS_KeepsCorrectBackupsPerSlot(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -402,7 +409,7 @@ func Test_CleanByGFS_KeepsCorrectBackupsPerSlot(t *testing.T) {
StorageID: &storage.ID,
BackupInterval: interval,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -424,7 +431,7 @@ func Test_CleanByGFS_KeepsCorrectBackupsPerSlot(t *testing.T) {
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -444,8 +451,8 @@ func Test_CleanByGFS_KeepsCorrectBackupsPerSlot(t *testing.T) {
func Test_CleanByGFS_WithWeeklyAndMonthlySlots_KeepsWiderSpread(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -456,11 +463,11 @@ func Test_CleanByGFS_WithWeeklyAndMonthlySlots_KeepsWiderSpread(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -476,7 +483,7 @@ func Test_CleanByGFS_WithWeeklyAndMonthlySlots_KeepsWiderSpread(t *testing.T) {
StorageID: &storage.ID,
BackupInterval: interval,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -500,7 +507,7 @@ func Test_CleanByGFS_WithWeeklyAndMonthlySlots_KeepsWiderSpread(t *testing.T) {
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -522,8 +529,8 @@ func Test_CleanByGFS_WithWeeklyAndMonthlySlots_KeepsWiderSpread(t *testing.T) {
func Test_CleanByGFS_WithHourlySlots_KeepsCorrectBackups(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
testStorage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
@@ -534,11 +541,11 @@ func Test_CleanByGFS_WithHourlySlots_KeepsCorrectBackups(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(testStorage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), testStorage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -551,7 +558,7 @@ func Test_CleanByGFS_WithHourlySlots_KeepsCorrectBackups(t *testing.T) {
StorageID: &testStorage.ID,
BackupInterval: interval,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -573,7 +580,7 @@ func Test_CleanByGFS_WithHourlySlots_KeepsCorrectBackups(t *testing.T) {
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -593,8 +600,8 @@ func Test_CleanByGFS_WithHourlySlots_KeepsCorrectBackups(t *testing.T) {
func Test_CleanByGFS_SkipsRecentBackup_WhenNotInKeepSet(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -605,11 +612,11 @@ func Test_CleanByGFS_SkipsRecentBackup_WhenNotInKeepSet(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -626,7 +633,7 @@ func Test_CleanByGFS_SkipsRecentBackup_WhenNotInKeepSet(t *testing.T) {
StorageID: &storage.ID,
BackupInterval: interval,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -673,7 +680,7 @@ func Test_CleanByGFS_SkipsRecentBackup_WhenNotInKeepSet(t *testing.T) {
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -700,8 +707,8 @@ func Test_CleanByGFS_SkipsRecentBackup_WhenNotInKeepSet(t *testing.T) {
func Test_CleanByGFS_With20DailyBackups_KeepsOnlyExpectedCount(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
testStorage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
@@ -712,11 +719,11 @@ func Test_CleanByGFS_With20DailyBackups_KeepsOnlyExpectedCount(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(testStorage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), testStorage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -731,7 +738,7 @@ func Test_CleanByGFS_With20DailyBackups_KeepsOnlyExpectedCount(t *testing.T) {
StorageID: &testStorage.ID,
BackupInterval: interval,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -754,7 +761,7 @@ func Test_CleanByGFS_With20DailyBackups_KeepsOnlyExpectedCount(t *testing.T) {
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -781,8 +788,8 @@ func Test_CleanByGFS_With20DailyBackups_KeepsOnlyExpectedCount(t *testing.T) {
func Test_CleanByGFS_WithMultipleBackupsPerDay_KeepsOnlyOnePerDailySlot(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
testStorage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
@@ -793,11 +800,11 @@ func Test_CleanByGFS_WithMultipleBackupsPerDay_KeepsOnlyOnePerDailySlot(t *testi
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(testStorage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), testStorage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -811,7 +818,7 @@ func Test_CleanByGFS_WithMultipleBackupsPerDay_KeepsOnlyOnePerDailySlot(t *testi
StorageID: &testStorage.ID,
BackupInterval: interval,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -838,7 +845,7 @@ func Test_CleanByGFS_WithMultipleBackupsPerDay_KeepsOnlyOnePerDailySlot(t *testi
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -870,8 +877,8 @@ func Test_CleanByGFS_WithMultipleBackupsPerDay_KeepsOnlyOnePerDailySlot(t *testi
// Hourly slots should only cover the most recent hours, not span across weeks.
func Test_CleanByGFS_With24HourlySlotsAnd23DailyBackups_DeletesExcessBackups(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
testStorage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
@@ -882,11 +889,11 @@ func Test_CleanByGFS_With24HourlySlotsAnd23DailyBackups_DeletesExcessBackups(t *
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(testStorage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), testStorage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -903,7 +910,7 @@ func Test_CleanByGFS_With24HourlySlotsAnd23DailyBackups_DeletesExcessBackups(t *
StorageID: &testStorage.ID,
BackupInterval: interval,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -922,7 +929,7 @@ func Test_CleanByGFS_With24HourlySlotsAnd23DailyBackups_DeletesExcessBackups(t *
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -939,8 +946,8 @@ func Test_CleanByGFS_With24HourlySlotsAnd23DailyBackups_DeletesExcessBackups(t *
// when hourly slots are not involved.
func Test_CleanByGFS_WithDisabledHourlySlotsAnd23DailyBackups_DeletesExcessBackups(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
testStorage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
@@ -951,11 +958,11 @@ func Test_CleanByGFS_WithDisabledHourlySlotsAnd23DailyBackups_DeletesExcessBacku
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(testStorage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), testStorage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -972,7 +979,7 @@ func Test_CleanByGFS_WithDisabledHourlySlotsAnd23DailyBackups_DeletesExcessBacku
StorageID: &testStorage.ID,
BackupInterval: interval,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -991,7 +998,7 @@ func Test_CleanByGFS_WithDisabledHourlySlotsAnd23DailyBackups_DeletesExcessBacku
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -1008,8 +1015,8 @@ func Test_CleanByGFS_WithDisabledHourlySlotsAnd23DailyBackups_DeletesExcessBacku
// Daily slots should only cover the most recent days, not span months.
func Test_CleanByGFS_WithDailySlotsAndWeeklyBackups_DeletesExcessBackups(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
testStorage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
@@ -1020,11 +1027,11 @@ func Test_CleanByGFS_WithDailySlotsAndWeeklyBackups_DeletesExcessBackups(t *test
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(testStorage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), testStorage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -1038,7 +1045,7 @@ func Test_CleanByGFS_WithDailySlotsAndWeeklyBackups_DeletesExcessBackups(t *test
StorageID: &testStorage.ID,
BackupInterval: interval,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -1060,7 +1067,7 @@ func Test_CleanByGFS_WithDailySlotsAndWeeklyBackups_DeletesExcessBackups(t *test
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -1089,8 +1096,8 @@ func Test_CleanByGFS_WithDailySlotsAndWeeklyBackups_DeletesExcessBackups(t *test
// Weekly slots should only cover the most recent weeks, not span years.
func Test_CleanByGFS_WithWeeklySlotsAndMonthlyBackups_DeletesExcessBackups(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
testStorage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
@@ -1101,11 +1108,11 @@ func Test_CleanByGFS_WithWeeklySlotsAndMonthlyBackups_DeletesExcessBackups(t *te
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(testStorage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), testStorage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -1119,7 +1126,7 @@ func Test_CleanByGFS_WithWeeklySlotsAndMonthlyBackups_DeletesExcessBackups(t *te
StorageID: &testStorage.ID,
BackupInterval: interval,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -1142,7 +1149,7 @@ func Test_CleanByGFS_WithWeeklySlotsAndMonthlyBackups_DeletesExcessBackups(t *te
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
diff --git a/backend/internal/features/backups/backups/backuping/logical/cleaner_test.go b/backend/internal/features/backups/backups/backuping/logical/cleaner_test.go
index 73264bb3..ca55fccb 100644
--- a/backend/internal/features/backups/backups/backuping/logical/cleaner_test.go
+++ b/backend/internal/features/backups/backups/backuping/logical/cleaner_test.go
@@ -24,8 +24,8 @@ import (
func Test_CleanOldBackups_DeletesBackupsOlderThanRetentionTimePeriod(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -36,11 +36,11 @@ func Test_CleanOldBackups_DeletesBackupsOlderThanRetentionTimePeriod(t *testing.
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -54,7 +54,7 @@ func Test_CleanOldBackups_DeletesBackupsOlderThanRetentionTimePeriod(t *testing.
BackupInterval: interval,
Encryption: backups_core_enums.BackupEncryptionEncrypted,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -91,7 +91,7 @@ func Test_CleanOldBackups_DeletesBackupsOlderThanRetentionTimePeriod(t *testing.
assert.NoError(t, err)
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -102,8 +102,8 @@ func Test_CleanOldBackups_DeletesBackupsOlderThanRetentionTimePeriod(t *testing.
func Test_CleanOldBackups_SkipsDatabaseWithForeverRetentionPeriod(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -114,11 +114,11 @@ func Test_CleanOldBackups_SkipsDatabaseWithForeverRetentionPeriod(t *testing.T)
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -132,7 +132,7 @@ func Test_CleanOldBackups_SkipsDatabaseWithForeverRetentionPeriod(t *testing.T)
BackupInterval: interval,
Encryption: backups_core_enums.BackupEncryptionEncrypted,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
oldBackup := &backups_core_logical.LogicalBackup{
@@ -147,7 +147,7 @@ func Test_CleanOldBackups_SkipsDatabaseWithForeverRetentionPeriod(t *testing.T)
assert.NoError(t, err)
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -158,8 +158,8 @@ func Test_CleanOldBackups_SkipsDatabaseWithForeverRetentionPeriod(t *testing.T)
func Test_CleanByCount_KeepsNewestNBackups_DeletesOlder(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -170,11 +170,11 @@ func Test_CleanByCount_KeepsNewestNBackups_DeletesOlder(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -188,7 +188,7 @@ func Test_CleanByCount_KeepsNewestNBackups_DeletesOlder(t *testing.T) {
BackupInterval: interval,
Encryption: backups_core_enums.BackupEncryptionEncrypted,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -210,7 +210,7 @@ func Test_CleanByCount_KeepsNewestNBackups_DeletesOlder(t *testing.T) {
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -230,8 +230,8 @@ func Test_CleanByCount_KeepsNewestNBackups_DeletesOlder(t *testing.T) {
func Test_CleanByCount_WhenUnderLimit_NoBackupsDeleted(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -242,11 +242,11 @@ func Test_CleanByCount_WhenUnderLimit_NoBackupsDeleted(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -260,7 +260,7 @@ func Test_CleanByCount_WhenUnderLimit_NoBackupsDeleted(t *testing.T) {
BackupInterval: interval,
Encryption: backups_core_enums.BackupEncryptionEncrypted,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
for i := range 5 {
@@ -277,7 +277,7 @@ func Test_CleanByCount_WhenUnderLimit_NoBackupsDeleted(t *testing.T) {
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -287,8 +287,8 @@ func Test_CleanByCount_WhenUnderLimit_NoBackupsDeleted(t *testing.T) {
func Test_CleanByCount_DoesNotDeleteInProgressBackups(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -299,11 +299,11 @@ func Test_CleanByCount_DoesNotDeleteInProgressBackups(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -317,7 +317,7 @@ func Test_CleanByCount_DoesNotDeleteInProgressBackups(t *testing.T) {
BackupInterval: interval,
Encryption: backups_core_enums.BackupEncryptionEncrypted,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -347,7 +347,7 @@ func Test_CleanByCount_DoesNotDeleteInProgressBackups(t *testing.T) {
assert.NoError(t, err)
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -368,8 +368,8 @@ func Test_CleanByCount_DoesNotDeleteInProgressBackups(t *testing.T) {
// the database. This prevents orphaned backup records when storage is no longer accessible.
func Test_DeleteBackup_WhenStorageDeleteFails_BackupStillRemovedFromDatabase(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
testStorage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
@@ -380,11 +380,11 @@ func Test_DeleteBackup_WhenStorageDeleteFails_BackupStillRemovedFromDatabase(t *
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(testStorage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), testStorage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
backup := &backups_core_logical.LogicalBackup{
@@ -400,7 +400,7 @@ func Test_DeleteBackup_WhenStorageDeleteFails_BackupStillRemovedFromDatabase(t *
cleaner := GetBackupCleaner()
- err = cleaner.DeleteBackup(backup)
+ err = cleaner.DeleteBackup(t.Context(), backup)
assert.NoError(t, err, "DeleteBackup should succeed even when storage file doesn't exist")
deletedBackup, err := backupRepository.FindByID(backup.ID)
@@ -410,8 +410,8 @@ func Test_DeleteBackup_WhenStorageDeleteFails_BackupStillRemovedFromDatabase(t *
func Test_CleanByTimePeriod_SkipsRecentBackup_EvenIfOlderThanRetention(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -422,11 +422,11 @@ func Test_CleanByTimePeriod_SkipsRecentBackup_EvenIfOlderThanRetention(t *testin
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -442,7 +442,7 @@ func Test_CleanByTimePeriod_SkipsRecentBackup_EvenIfOlderThanRetention(t *testin
BackupInterval: interval,
Encryption: backups_core_enums.BackupEncryptionEncrypted,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -470,7 +470,7 @@ func Test_CleanByTimePeriod_SkipsRecentBackup_EvenIfOlderThanRetention(t *testin
assert.NoError(t, err)
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
@@ -481,8 +481,8 @@ func Test_CleanByTimePeriod_SkipsRecentBackup_EvenIfOlderThanRetention(t *testin
func Test_CleanByCount_SkipsRecentBackup_EvenIfOverLimit(t *testing.T) {
router := CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -493,11 +493,11 @@ func Test_CleanByCount_SkipsRecentBackup_EvenIfOverLimit(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
interval := createTestInterval()
@@ -513,7 +513,7 @@ func Test_CleanByCount_SkipsRecentBackup_EvenIfOverLimit(t *testing.T) {
BackupInterval: interval,
Encryption: backups_core_enums.BackupEncryptionEncrypted,
}
- _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err := backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
now := time.Now().UTC()
@@ -558,7 +558,7 @@ func Test_CleanByCount_SkipsRecentBackup_EvenIfOverLimit(t *testing.T) {
}
cleaner := GetBackupCleaner()
- err = cleaner.cleanByRetentionPolicy(testLogger())
+ err = cleaner.cleanByRetentionPolicy(t.Context(), testLogger())
assert.NoError(t, err)
remainingBackups, err := backupRepository.FindByDatabaseID(database.ID)
diff --git a/backend/internal/features/backups/backups/backuping/logical/mocks.go b/backend/internal/features/backups/backups/backuping/logical/mocks.go
index 389eacea..efe42149 100644
--- a/backend/internal/features/backups/backups/backuping/logical/mocks.go
+++ b/backend/internal/features/backups/backups/backuping/logical/mocks.go
@@ -23,6 +23,7 @@ type MockNotificationSender struct {
}
func (m *MockNotificationSender) SendNotification(
+ _ context.Context,
notifier *notifiers.Notifier,
notification notifier_models.Notification,
) {
diff --git a/backend/internal/features/backups/backups/backuping/logical/scheduler.go b/backend/internal/features/backups/backups/backuping/logical/scheduler.go
index a921fe1c..f76e1367 100644
--- a/backend/internal/features/backups/backups/backuping/logical/scheduler.go
+++ b/backend/internal/features/backups/backups/backuping/logical/scheduler.go
@@ -16,7 +16,11 @@ import (
)
const (
- schedulerTickerInterval = 15 * time.Second
+ schedulerTickerInterval = 15 * time.Second
+
+ // Stable log job_name; never the struct type name, since a rename would silently break log
+ // queries.
+ schedulerJobName = "logical_backup_scheduler"
schedulerHealthcheckThreshold = 5 * time.Minute
)
@@ -56,8 +60,12 @@ func (s *BackupsScheduler) Run(ctx context.Context) {
s.lastBackupTime = time.Now().UTC()
- if err := s.failBackupsInProgress(); err != nil {
- s.logger.Error("Failed to fail backups in progress", "error", err)
+ startupRecoveryLogger := s.logger.With("job_id", uuid.New(), "job_name", schedulerJobName)
+ lifecycleLogger := s.logger.With("job_name", schedulerJobName)
+
+ if err := s.failBackupsInProgress(ctx, startupRecoveryLogger); err != nil {
+ startupRecoveryLogger.ErrorContext(ctx, "failed to fail backups in progress", "error", err)
+
panic(err)
}
@@ -71,13 +79,19 @@ func (s *BackupsScheduler) Run(ctx context.Context) {
ticker := time.NewTicker(schedulerTickerInterval)
defer ticker.Stop()
+ lifecycleLogger.InfoContext(ctx, "logical backup scheduler started")
+
for {
select {
case <-ctx.Done():
+ lifecycleLogger.InfoContext(ctx, "logical backup scheduler stopped")
+
return
case <-ticker.C:
- if err := s.runPendingBackups(); err != nil {
- s.logger.Error("Failed to run pending backups", "error", err)
+ tickLogger := s.logger.With("job_id", uuid.New(), "job_name", schedulerJobName)
+
+ if err := s.runPendingBackups(ctx, tickLogger); err != nil {
+ tickLogger.ErrorContext(ctx, "failed to run pending backups", "error", err)
}
s.lastBackupTime = time.Now().UTC()
@@ -90,15 +104,15 @@ func (s *BackupsScheduler) IsSchedulerRunning() bool {
return s.lastBackupTime.After(time.Now().UTC().Add(-schedulerHealthcheckThreshold))
}
-func (s *BackupsScheduler) StartBackup(database *databases.Database, isCallNotifier bool) {
+func (s *BackupsScheduler) StartBackup(ctx context.Context, database *databases.Database, isCallNotifier bool) {
backupConfig, err := s.backupConfigService.GetBackupConfigByDbId(database.ID)
if err != nil {
- s.logger.Error("Failed to get backup config by database ID", "error", err)
+ s.logger.ErrorContext(ctx, "failed to get backup config by database ID", "error", err)
return
}
if backupConfig.StorageID == nil {
- s.logger.Error("Backup config storage ID is nil", "databaseId", database.ID)
+ s.logger.ErrorContext(ctx, "backup config storage ID is nil", "database_id", database.ID)
return
}
@@ -108,9 +122,9 @@ func (s *BackupsScheduler) StartBackup(database *databases.Database, isCallNotif
backups_core_logical.BackupStatusInProgress,
)
if err != nil {
- s.logger.Error(
- "Failed to check for in-progress backups",
- "databaseId",
+ s.logger.ErrorContext(ctx,
+ "failed to check for in-progress backups",
+ "database_id",
database.ID,
"error",
err,
@@ -119,9 +133,9 @@ func (s *BackupsScheduler) StartBackup(database *databases.Database, isCallNotif
}
if len(inProgressBackups) > 0 {
- s.logger.Warn(
- "Backup already in progress for database, skipping new backup",
- "databaseId",
+ s.logger.WarnContext(ctx,
+ "backup already in progress for database, skipping new backup",
+ "database_id",
database.ID,
"existingBackupId",
inProgressBackups[0].ID,
@@ -144,9 +158,9 @@ func (s *BackupsScheduler) StartBackup(database *databases.Database, isCallNotif
backup.GenerateFilename(database.Name)
if err := s.backupRepository.Save(backup); err != nil {
- s.logger.Error(
- "Failed to save backup",
- "databaseId",
+ s.logger.ErrorContext(ctx,
+ "failed to save backup",
+ "database_id",
backupConfig.DatabaseID,
"error",
err,
@@ -155,15 +169,15 @@ func (s *BackupsScheduler) StartBackup(database *databases.Database, isCallNotif
}
go func() {
- s.backuper.MakeBackup(backup.ID, isCallNotifier)
+ s.backuper.MakeBackup(ctx, backup.ID, isCallNotifier)
s.onBackupCompleted(backup.ID)
}()
- s.logger.Info(
- "Successfully triggered scheduled backup",
- "databaseId",
+ s.logger.InfoContext(ctx,
+ "successfully triggered scheduled backup",
+ "database_id",
backupConfig.DatabaseID,
- "backupId",
+ "backup_id",
backup.ID,
)
}
@@ -172,26 +186,33 @@ func (s *BackupsScheduler) StartBackup(database *databases.Database, isCallNotif
// If the backup is not failed or the backup config does not allow retries, it returns 0.
// If the backup is failed and the backup config allows retries, it returns the number of remaining tries.
// If the backup is failed and the backup config does not allow retries, it returns 0.
-func (s *BackupsScheduler) GetRemainedBackupTryCount(lastBackup *backups_core_logical.LogicalBackup) int {
- if lastBackup == nil {
+func (s *BackupsScheduler) GetRemainedBackupTryCount(
+ ctx context.Context,
+ logger *slog.Logger,
+ lastBackup *backups_core_logical.LogicalBackup,
+) int {
+ if lastBackup == nil || lastBackup.Status != backups_core_logical.BackupStatusFailed {
return 0
}
- if lastBackup.Status != backups_core_logical.BackupStatusFailed {
- return 0
- }
+ logger = logger.With("backup_id", lastBackup.ID, "database_id", lastBackup.DatabaseID)
if lastBackup.IsSkipRetry {
+ logger.DebugContext(ctx, "not retrying the last failed backup, it is marked skip-retry")
+
return 0
}
backupConfig, err := s.backupConfigService.GetBackupConfigByDbId(lastBackup.DatabaseID)
if err != nil {
- s.logger.Error("Failed to get backup config by database ID", "error", err)
+ logger.ErrorContext(ctx, "failed to get backup config by database ID", "error", err)
+
return 0
}
if !backupConfig.IsRetryIfFailed {
+ logger.DebugContext(ctx, "not retrying the last failed backup, retries are disabled")
+
return 0
}
@@ -202,7 +223,8 @@ func (s *BackupsScheduler) GetRemainedBackupTryCount(lastBackup *backups_core_lo
maxFailedTriesCount,
)
if err != nil {
- s.logger.Error("Failed to find last backups by database ID", "error", err)
+ logger.ErrorContext(ctx, "failed to find last backups by database ID", "error", err)
+
return 0
}
@@ -214,10 +236,20 @@ func (s *BackupsScheduler) GetRemainedBackupTryCount(lastBackup *backups_core_lo
}
}
- return maxFailedTriesCount - len(lastFailedBackups)
+ remainedTryCount := maxFailedTriesCount - len(lastFailedBackups)
+
+ if remainedTryCount <= 0 {
+ logger.InfoContext(ctx, fmt.Sprintf(
+ "not retrying the last failed backup, all %d tries are used up", maxFailedTriesCount))
+ } else {
+ logger.DebugContext(ctx, fmt.Sprintf("%d of %d backup retries remain",
+ remainedTryCount, maxFailedTriesCount))
+ }
+
+ return remainedTryCount
}
-func (s *BackupsScheduler) runPendingBackups() error {
+func (s *BackupsScheduler) runPendingBackups(ctx context.Context, logger *slog.Logger) error {
enabledBackupConfigs, err := s.backupConfigService.GetBackupConfigsWithEnabledBackups()
if err != nil {
return err
@@ -226,9 +258,9 @@ func (s *BackupsScheduler) runPendingBackups() error {
for _, backupConfig := range enabledBackupConfigs {
lastBackup, err := s.backupRepository.FindLastByDatabaseID(backupConfig.DatabaseID)
if err != nil {
- s.logger.Error(
- "Failed to get last backup for database",
- "databaseId",
+ logger.ErrorContext(ctx,
+ "failed to get last backup for database",
+ "database_id",
backupConfig.DatabaseID,
"error",
err,
@@ -241,13 +273,13 @@ func (s *BackupsScheduler) runPendingBackups() error {
lastBackupTime = &lastBackup.CreatedAt
}
- remainedBackupTryCount := s.GetRemainedBackupTryCount(lastBackup)
+ remainedBackupTryCount := s.GetRemainedBackupTryCount(ctx, logger, lastBackup)
if backupConfig.BackupInterval.ShouldTriggerBackup(time.Now().UTC(), lastBackupTime) ||
remainedBackupTryCount > 0 {
- s.logger.Info(
- "Triggering scheduled backup",
- "databaseId",
+ logger.InfoContext(ctx,
+ "triggering scheduled backup",
+ "database_id",
backupConfig.DatabaseID,
"intervalType",
backupConfig.BackupInterval.Type,
@@ -255,11 +287,11 @@ func (s *BackupsScheduler) runPendingBackups() error {
database, err := s.databaseService.GetDatabaseByID(backupConfig.DatabaseID)
if err != nil {
- s.logger.Error("Failed to get database by ID", "error", err)
+ logger.ErrorContext(ctx, "failed to get database by ID", "error", err)
continue
}
- s.StartBackup(database, remainedBackupTryCount == 1)
+ s.StartBackup(ctx, database, remainedBackupTryCount == 1)
continue
}
}
@@ -267,17 +299,22 @@ func (s *BackupsScheduler) runPendingBackups() error {
return nil
}
-func (s *BackupsScheduler) failBackupsInProgress() error {
+func (s *BackupsScheduler) failBackupsInProgress(ctx context.Context, logger *slog.Logger) error {
backupsInProgress, err := s.backupRepository.FindByStatus(backups_core_logical.BackupStatusInProgress)
if err != nil {
return err
}
+ if len(backupsInProgress) > 0 {
+ logger.InfoContext(ctx, fmt.Sprintf(
+ "failing %d logical backups left in progress by the previous run", len(backupsInProgress)))
+ }
+
for _, backup := range backupsInProgress {
if err := s.taskCancelManager.CancelTask(backup.ID); err != nil {
- s.logger.Error(
- "Failed to cancel backup via task cancel manager",
- "backupId",
+ logger.ErrorContext(ctx,
+ "failed to cancel backup via task cancel manager",
+ "backup_id",
backup.ID,
"error",
err,
@@ -286,7 +323,7 @@ func (s *BackupsScheduler) failBackupsInProgress() error {
backupConfig, err := s.backupConfigService.GetBackupConfigByDbId(backup.DatabaseID)
if err != nil {
- s.logger.Error("Failed to get backup config by database ID", "error", err)
+ logger.ErrorContext(ctx, "failed to get backup config by database ID", "error", err)
continue
}
@@ -295,7 +332,7 @@ func (s *BackupsScheduler) failBackupsInProgress() error {
backup.Status = backups_core_logical.BackupStatusFailed
backup.BackupSizeMb = 0
- s.backuper.SendBackupNotification(
+ s.backuper.SendBackupNotification(ctx,
backupConfig,
backup,
backups_config_logical.NotificationBackupFailed,
@@ -305,6 +342,9 @@ func (s *BackupsScheduler) failBackupsInProgress() error {
if err := s.backupRepository.Save(backup); err != nil {
return err
}
+
+ logger.InfoContext(ctx, "failed a logical backup left in progress by the previous run",
+ "backup_id", backup.ID, "database_id", backup.DatabaseID)
}
return nil
diff --git a/backend/internal/features/backups/backups/backuping/logical/scheduler_test.go b/backend/internal/features/backups/backups/backuping/logical/scheduler_test.go
index 8cc523a5..17299f49 100644
--- a/backend/internal/features/backups/backups/backuping/logical/scheduler_test.go
+++ b/backend/internal/features/backups/backups/backuping/logical/scheduler_test.go
@@ -17,6 +17,7 @@ import (
users_testing "databasus-backend/internal/features/users/testing"
workspaces_testing "databasus-backend/internal/features/workspaces/testing"
cache_utils "databasus-backend/internal/util/cache"
+ "databasus-backend/internal/util/logger"
"databasus-backend/internal/util/period"
"databasus-backend/internal/util/testing/containers"
)
@@ -58,9 +59,9 @@ func Test_RunPendingBackups_ByDatabaseType_OnlySchedulesNonAgentManagedBackups(t
t.Run(tc.name, func(t *testing.T) {
cache_utils.ClearAllCache()
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := tc.createDatabase(t, workspace.ID, storage, notifier)
@@ -71,11 +72,11 @@ func Test_RunPendingBackups_ByDatabaseType_OnlySchedulesNonAgentManagedBackups(t
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
backupConfig, err := backups_config_logical.GetBackupConfigService().GetBackupConfigByDbId(database.ID)
@@ -92,7 +93,7 @@ func Test_RunPendingBackups_ByDatabaseType_OnlySchedulesNonAgentManagedBackups(t
backupConfig.Storage = storage
backupConfig.StorageID = &storage.ID
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
// add old backup (24h ago)
@@ -103,7 +104,7 @@ func Test_RunPendingBackups_ByDatabaseType_OnlySchedulesNonAgentManagedBackups(t
CreatedAt: time.Now().UTC().Add(-24 * time.Hour),
})
- GetBackupsScheduler().runPendingBackups()
+ GetBackupsScheduler().runPendingBackups(t.Context(), logger.GetLogger())
if tc.isBackupExpected {
WaitForBackupCompletion(t, database.ID, 1, 10*time.Second)
@@ -127,9 +128,9 @@ func Test_RunPendingBackups_ByDatabaseType_OnlySchedulesNonAgentManagedBackups(t
func Test_RunPendingBackups_WhenLastBackupWasYesterday_CreatesNewBackup(t *testing.T) {
cache_utils.ClearAllCache()
// setup data
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -141,11 +142,11 @@ func Test_RunPendingBackups_WhenLastBackupWasYesterday_CreatesNewBackup(t *testi
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
// Enable backups for the database
@@ -163,7 +164,7 @@ func Test_RunPendingBackups_WhenLastBackupWasYesterday_CreatesNewBackup(t *testi
backupConfig.Storage = storage
backupConfig.StorageID = &storage.ID
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
// add old backup
@@ -176,7 +177,7 @@ func Test_RunPendingBackups_WhenLastBackupWasYesterday_CreatesNewBackup(t *testi
CreatedAt: time.Now().UTC().Add(-24 * time.Hour),
})
- GetBackupsScheduler().runPendingBackups()
+ GetBackupsScheduler().runPendingBackups(t.Context(), logger.GetLogger())
// Wait for backup to complete (runs in goroutine)
WaitForBackupCompletion(t, database.ID, 1, 10*time.Second)
@@ -193,9 +194,9 @@ func Test_RunPendingBackups_WhenLastBackupWasYesterday_CreatesNewBackup(t *testi
func Test_RunPendingBackups_WhenLastBackupWasRecentlyCompleted_SkipsBackup(t *testing.T) {
cache_utils.ClearAllCache()
// setup data
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -207,11 +208,11 @@ func Test_RunPendingBackups_WhenLastBackupWasRecentlyCompleted_SkipsBackup(t *te
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
// Enable backups for the database
@@ -229,7 +230,7 @@ func Test_RunPendingBackups_WhenLastBackupWasRecentlyCompleted_SkipsBackup(t *te
backupConfig.Storage = storage
backupConfig.StorageID = &storage.ID
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
backupRepository.Save(&backups_core_logical.LogicalBackup{
@@ -241,7 +242,7 @@ func Test_RunPendingBackups_WhenLastBackupWasRecentlyCompleted_SkipsBackup(t *te
CreatedAt: time.Now().UTC(),
})
- GetBackupsScheduler().runPendingBackups()
+ GetBackupsScheduler().runPendingBackups(t.Context(), logger.GetLogger())
time.Sleep(100 * time.Millisecond)
@@ -257,9 +258,9 @@ func Test_RunPendingBackups_WhenLastBackupWasRecentlyCompleted_SkipsBackup(t *te
func Test_RunPendingBackups_WhenLastBackupFailedAndRetriesDisabled_SkipsBackup(t *testing.T) {
cache_utils.ClearAllCache()
// setup data
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -271,11 +272,11 @@ func Test_RunPendingBackups_WhenLastBackupFailedAndRetriesDisabled_SkipsBackup(t
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
// Enable backups for the database with retries disabled
@@ -295,7 +296,7 @@ func Test_RunPendingBackups_WhenLastBackupFailedAndRetriesDisabled_SkipsBackup(t
backupConfig.IsRetryIfFailed = false
backupConfig.MaxFailedTriesCount = 0
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
failMessage := "backup failed"
@@ -309,7 +310,7 @@ func Test_RunPendingBackups_WhenLastBackupFailedAndRetriesDisabled_SkipsBackup(t
CreatedAt: time.Now().UTC(),
})
- GetBackupsScheduler().runPendingBackups()
+ GetBackupsScheduler().runPendingBackups(t.Context(), logger.GetLogger())
time.Sleep(100 * time.Millisecond)
@@ -325,9 +326,9 @@ func Test_RunPendingBackups_WhenLastBackupFailedAndRetriesDisabled_SkipsBackup(t
func Test_RunPendingBackups_WhenLastBackupFailedAndRetriesEnabled_CreatesNewBackup(t *testing.T) {
cache_utils.ClearAllCache()
// setup data
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -339,11 +340,11 @@ func Test_RunPendingBackups_WhenLastBackupFailedAndRetriesEnabled_CreatesNewBack
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
// Enable backups for the database with retries enabled
@@ -363,7 +364,7 @@ func Test_RunPendingBackups_WhenLastBackupFailedAndRetriesEnabled_CreatesNewBack
backupConfig.IsRetryIfFailed = true
backupConfig.MaxFailedTriesCount = 3
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
// add failed backup
@@ -378,7 +379,7 @@ func Test_RunPendingBackups_WhenLastBackupFailedAndRetriesEnabled_CreatesNewBack
CreatedAt: time.Now().UTC().Add(-1 * time.Hour),
})
- GetBackupsScheduler().runPendingBackups()
+ GetBackupsScheduler().runPendingBackups(t.Context(), logger.GetLogger())
// Wait for backup to complete (runs in goroutine)
WaitForBackupCompletion(t, database.ID, 1, 10*time.Second)
@@ -395,9 +396,9 @@ func Test_RunPendingBackups_WhenLastBackupFailedAndRetriesEnabled_CreatesNewBack
func Test_RunPendingBackups_WhenFailedBackupsExceedMaxRetries_SkipsBackup(t *testing.T) {
cache_utils.ClearAllCache()
// setup data
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -409,11 +410,11 @@ func Test_RunPendingBackups_WhenFailedBackupsExceedMaxRetries_SkipsBackup(t *tes
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
// Enable backups for the database with retries enabled
@@ -433,7 +434,7 @@ func Test_RunPendingBackups_WhenFailedBackupsExceedMaxRetries_SkipsBackup(t *tes
backupConfig.IsRetryIfFailed = true
backupConfig.MaxFailedTriesCount = 3
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
failMessage := "backup failed"
@@ -450,7 +451,7 @@ func Test_RunPendingBackups_WhenFailedBackupsExceedMaxRetries_SkipsBackup(t *tes
})
}
- GetBackupsScheduler().runPendingBackups()
+ GetBackupsScheduler().runPendingBackups(t.Context(), logger.GetLogger())
time.Sleep(100 * time.Millisecond)
@@ -465,9 +466,9 @@ func Test_RunPendingBackups_WhenFailedBackupsExceedMaxRetries_SkipsBackup(t *tes
func Test_RunPendingBackups_WhenBackupsDisabled_SkipsBackup(t *testing.T) {
cache_utils.ClearAllCache()
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -478,11 +479,11 @@ func Test_RunPendingBackups_WhenBackupsDisabled_SkipsBackup(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
backupConfig, err := backups_config_logical.GetBackupConfigService().GetBackupConfigByDbId(database.ID)
@@ -499,7 +500,7 @@ func Test_RunPendingBackups_WhenBackupsDisabled_SkipsBackup(t *testing.T) {
backupConfig.Storage = storage
backupConfig.StorageID = &storage.ID
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
// add old backup that would trigger new backup if enabled
@@ -512,7 +513,7 @@ func Test_RunPendingBackups_WhenBackupsDisabled_SkipsBackup(t *testing.T) {
CreatedAt: time.Now().UTC().Add(-24 * time.Hour),
})
- GetBackupsScheduler().runPendingBackups()
+ GetBackupsScheduler().runPendingBackups(t.Context(), logger.GetLogger())
time.Sleep(100 * time.Millisecond)
@@ -527,9 +528,9 @@ func Test_RunPendingBackups_WhenBackupsDisabled_SkipsBackup(t *testing.T) {
func Test_FailBackupsInProgress_WhenSchedulerStarts_CancelsBackupsAndUpdatesStatus(t *testing.T) {
cache_utils.ClearAllCache()
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -540,11 +541,11 @@ func Test_FailBackupsInProgress_WhenSchedulerStarts_CancelsBackupsAndUpdatesStat
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
cache_utils.ClearAllCache()
}()
@@ -563,7 +564,7 @@ func Test_FailBackupsInProgress_WhenSchedulerStarts_CancelsBackupsAndUpdatesStat
backupConfig.Storage = storage
backupConfig.StorageID = &storage.ID
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
// Create two in-progress backups that should be failed on scheduler restart
@@ -600,7 +601,7 @@ func Test_FailBackupsInProgress_WhenSchedulerStarts_CancelsBackupsAndUpdatesStat
// Trigger the scheduler's failBackupsInProgress logic
// This should cancel in-progress backups and mark them as failed
- err = GetBackupsScheduler().failBackupsInProgress()
+ err = GetBackupsScheduler().failBackupsInProgress(t.Context(), logger.GetLogger())
assert.NoError(t, err)
// Verify all backups exist and were processed correctly
@@ -633,9 +634,9 @@ func Test_FailBackupsInProgress_WhenSchedulerStarts_CancelsBackupsAndUpdatesStat
func Test_StartBackup_WhenBackupAlreadyInProgress_SkipsNewBackup(t *testing.T) {
cache_utils.ClearAllCache()
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -646,11 +647,11 @@ func Test_StartBackup_WhenBackupAlreadyInProgress_SkipsNewBackup(t *testing.T) {
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
backupConfig, err := backups_config_logical.GetBackupConfigService().GetBackupConfigByDbId(database.ID)
@@ -667,7 +668,7 @@ func Test_StartBackup_WhenBackupAlreadyInProgress_SkipsNewBackup(t *testing.T) {
backupConfig.Storage = storage
backupConfig.StorageID = &storage.ID
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
// Create an in-progress backup manually
@@ -682,7 +683,7 @@ func Test_StartBackup_WhenBackupAlreadyInProgress_SkipsNewBackup(t *testing.T) {
assert.NoError(t, err)
// Try to start a new backup - should be skipped
- GetBackupsScheduler().StartBackup(database, false)
+ GetBackupsScheduler().StartBackup(t.Context(), database, false)
time.Sleep(200 * time.Millisecond)
@@ -700,9 +701,9 @@ func Test_RunPendingBackups_WhenLastBackupFailedWithIsSkipRetry_SkipsBackupEvenW
t *testing.T,
) {
cache_utils.ClearAllCache()
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -713,11 +714,11 @@ func Test_RunPendingBackups_WhenLastBackupFailedWithIsSkipRetry_SkipsBackupEvenW
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
// Enable backups with retries enabled and high retry count
@@ -737,7 +738,7 @@ func Test_RunPendingBackups_WhenLastBackupFailedWithIsSkipRetry_SkipsBackupEvenW
backupConfig.IsRetryIfFailed = true
backupConfig.MaxFailedTriesCount = 5
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
// Create a failed backup with IsSkipRetry set to true
@@ -758,11 +759,11 @@ func Test_RunPendingBackups_WhenLastBackupFailedWithIsSkipRetry_SkipsBackupEvenW
assert.NoError(t, err)
assert.NotNil(t, lastBackup)
- remainedTries := GetBackupsScheduler().GetRemainedBackupTryCount(lastBackup)
+ remainedTries := GetBackupsScheduler().GetRemainedBackupTryCount(t.Context(), logger.GetLogger(), lastBackup)
assert.Equal(t, 0, remainedTries, "Should return 0 tries when IsSkipRetry is true")
// Run the scheduler
- GetBackupsScheduler().runPendingBackups()
+ GetBackupsScheduler().runPendingBackups(t.Context(), logger.GetLogger())
time.Sleep(100 * time.Millisecond)
@@ -790,9 +791,9 @@ func Test_StartBackup_When2BackupsStartedForDifferentDatabases_BothUseCasesAreCa
defer schedulerCancel()
// Setup test data
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
@@ -813,12 +814,12 @@ func Test_StartBackup_When2BackupsStartedForDifferentDatabases_BothUseCasesAreCa
backupRepository.DeleteByID(backup.ID)
}
- databases.RemoveTestDatabase(database1)
- databases.RemoveTestDatabase(database2)
+ databases.RemoveTestDatabase(t.Context(), database1)
+ databases.RemoveTestDatabase(t.Context(), database2)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
// Enable backups for database1
@@ -837,7 +838,7 @@ func Test_StartBackup_When2BackupsStartedForDifferentDatabases_BothUseCasesAreCa
backupConfig1.Storage = storage
backupConfig1.StorageID = &storage.ID
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig1)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig1)
assert.NoError(t, err)
// Enable backups for database2
@@ -855,15 +856,15 @@ func Test_StartBackup_When2BackupsStartedForDifferentDatabases_BothUseCasesAreCa
backupConfig2.Storage = storage
backupConfig2.StorageID = &storage.ID
- _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(backupConfig2)
+ _, err = backups_config_logical.GetBackupConfigService().SaveBackupConfig(t.Context(), backupConfig2)
assert.NoError(t, err)
// Start 2 backups simultaneously
t.Log("Starting backup for database1")
- scheduler.StartBackup(database1, false)
+ scheduler.StartBackup(t.Context(), database1, false)
t.Log("Starting backup for database2")
- scheduler.StartBackup(database2, false)
+ scheduler.StartBackup(t.Context(), database2, false)
// Wait up to 10 seconds for both backups to complete
t.Log("Waiting for both backups to complete...")
diff --git a/backend/internal/features/backups/backups/backuping/logical/testing.go b/backend/internal/features/backups/backups/backuping/logical/testing.go
index 74d4e55a..6b34680f 100644
--- a/backend/internal/features/backups/backups/backuping/logical/testing.go
+++ b/backend/internal/features/backups/backups/backuping/logical/testing.go
@@ -15,10 +15,13 @@ import (
"databasus-backend/internal/features/databases"
"databasus-backend/internal/features/notifiers"
"databasus-backend/internal/features/storages"
+ users_enums "databasus-backend/internal/features/users/enums"
+ users_testing "databasus-backend/internal/features/users/testing"
workspaces_controllers "databasus-backend/internal/features/workspaces/controllers"
workspaces_services "databasus-backend/internal/features/workspaces/services"
workspaces_testing "databasus-backend/internal/features/workspaces/testing"
"databasus-backend/internal/storage"
+ cache_utils "databasus-backend/internal/util/cache"
"databasus-backend/internal/util/encryption"
"databasus-backend/internal/util/logger"
)
@@ -74,6 +77,48 @@ func SeedInProgressTestBackup(
})
}
+type BackupTestFixture struct {
+ Storage *storages.Storage
+ Notifier *notifiers.Notifier
+ Database *databases.Database
+}
+
+func CreateBackupTestFixture(t *testing.T, workspaceName string) *BackupTestFixture {
+ t.Helper()
+
+ if err := cache_utils.ClearAllCache(); err != nil {
+ t.Fatalf("clear cache before backup fixture: %v", err)
+ }
+
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ router := CreateTestRouter()
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), workspaceName, user, router)
+ createdStorage := storages.CreateTestStorage(workspace.ID)
+ createdNotifier := notifiers.CreateTestNotifier(workspace.ID)
+ createdDatabase := databases.CreateTestDatabase(workspace.ID, createdStorage, createdNotifier)
+
+ backups_config_logical.EnableBackupsForTestDatabase(t.Context(), createdDatabase.ID, createdStorage)
+
+ t.Cleanup(func() {
+ backups, _ := backupRepository.FindByDatabaseID(createdDatabase.ID)
+ for _, backup := range backups {
+ if err := backupRepository.DeleteByID(backup.ID); err != nil {
+ t.Errorf("clean up backup %s: %v", backup.ID, err)
+ }
+ }
+
+ databases.RemoveTestDatabase(t.Context(), createdDatabase)
+ // The database delete cascades; removing its storage and notifier before that lands leaves
+ // the rows behind.
+ time.Sleep(50 * time.Millisecond)
+ notifiers.RemoveTestNotifier(createdNotifier)
+ storages.RemoveTestStorage(t.Context(), createdStorage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
+ })
+
+ return &BackupTestFixture{createdStorage, createdNotifier, createdDatabase}
+}
+
func CreateTestRouter() *gin.Engine {
router := workspaces_testing.CreateTestRouter(
workspaces_controllers.GetWorkspaceController(),
diff --git a/backend/internal/features/backups/backups/backuping/physical/backuper.go b/backend/internal/features/backups/backups/backuping/physical/backuper.go
index ebe849b4..8704e0e9 100644
--- a/backend/internal/features/backups/backups/backuping/physical/backuper.go
+++ b/backend/internal/features/backups/backups/backuping/physical/backuper.go
@@ -49,41 +49,42 @@ type PhysicalBackuper struct {
incrExecutor IncrementalBackupExecutor
}
-func (b *PhysicalBackuper) MakeBackup(backupID uuid.UUID, isCallNotifier bool) {
+func (b *PhysicalBackuper) MakeBackup(ctx context.Context, backupID uuid.UUID, isCallNotifier bool) {
logger := b.logger.With("backup_id", backupID)
fullBackup, err := b.fullRepo.FindByID(backupID)
if err != nil {
- logger.Error("failed to look up full backup row", "error", err)
+ logger.ErrorContext(ctx, "failed to look up full backup row", "error", err)
return
}
if fullBackup != nil {
- b.runFullBackup(logger, fullBackup, isCallNotifier)
+ b.runFullBackup(ctx, logger, fullBackup, isCallNotifier)
return
}
incrBackup, err := b.incrRepo.FindByID(backupID)
if err != nil {
- logger.Error("failed to look up incremental backup row", "error", err)
+ logger.ErrorContext(ctx, "failed to look up incremental backup row", "error", err)
return
}
if incrBackup != nil {
- b.runIncrementalBackup(logger, incrBackup, isCallNotifier)
+ b.runIncrementalBackup(ctx, logger, incrBackup, isCallNotifier)
return
}
- logger.Warn("backup not found in either typed table; ignoring assignment")
+ logger.WarnContext(ctx, "backup not found in either typed table; ignoring assignment")
}
func (b *PhysicalBackuper) runFullBackup(
+ ctx context.Context,
logger *slog.Logger,
fullBackup *physical_models.PhysicalFullBackup,
isCallNotifier bool,
) {
- backupCtx, ok := b.openBackupContext(logger, fullBackup.DatabaseID)
+ backupCtx, ok := b.openBackupContext(ctx, logger, fullBackup.DatabaseID)
if !ok {
b.finalizeFullAsError(fullBackup, physical_enums.PhysicalBackupErrorPgBasebackupFailed,
"failed to open backup context")
@@ -93,11 +94,13 @@ func (b *PhysicalBackuper) runFullBackup(
defer backupCtx.Close()
- ctx, cancel := context.WithCancel(context.Background())
+ // Detached from the caller so a finished HTTP request cannot cancel a running backup; the
+ // caller's ctx stays in use for logging, which is what carries request_id and user_id.
+ executionCtx, cancel := context.WithCancel(context.Background())
b.taskCancelManager.RegisterTask(fullBackup.ID, cancel)
defer b.taskCancelManager.UnregisterTask(fullBackup.ID)
- rawSizeMb := b.getSourceClusterSizeMb(ctx, logger, backupCtx.Database)
+ rawSizeMb := b.getSourceClusterSizeMb(executionCtx, logger, backupCtx.Database)
fullBackupSpec := postgresql_executor.FullBackupSpec{
CommonBackupSpec: postgresql_executor.CommonBackupSpec{
@@ -113,16 +116,27 @@ func (b *PhysicalBackuper) runFullBackup(
Logger: logger,
ProgressListener: func(completedMb float64, elapsedMs int64) {
if err := b.fullRepo.UpdateProgress(fullBackup.ID, completedMb, elapsedMs); err != nil {
- logger.Error("failed to update full backup progress", "error", err)
+ logger.ErrorContext(ctx, "failed to update full backup progress", "error", err)
}
},
},
Backup: fullBackup,
}
- backupResult, err := b.fullExecutor.Execute(ctx, fullBackupSpec)
+ // The source-size probe is best effort (it warns and returns nil when the cluster is unreachable),
+ // so the started line must not depend on it.
+ sourceSize := "unknown"
+ if rawSizeMb != nil {
+ sourceSize = fmt.Sprintf("%.1f MB", *rawSizeMb)
+ }
+
+ logger.InfoContext(ctx, fmt.Sprintf("physical full backup started: database %q, %s source",
+ backupCtx.Database.Name, sourceSize),
+ "storage_id", backupCtx.Storage.ID, "encryption", backupCtx.Config.Encryption)
+
+ backupResult, err := b.fullExecutor.Execute(executionCtx, fullBackupSpec)
if err != nil {
- logger.Error("full executor returned error", "error", err)
+ logger.ErrorContext(ctx, "full executor returned error", "error", err)
b.finalizeFullAsError(fullBackup, physical_enums.PhysicalBackupErrorPgBasebackupFailed, err.Error())
@@ -130,29 +144,35 @@ func (b *PhysicalBackuper) runFullBackup(
}
if backupResult.Status != physical_enums.PhysicalBackupStatusCompleted {
- logger.Warn("full executor returned non-COMPLETED result",
+ logger.WarnContext(ctx, "full executor returned non-COMPLETED result",
"status", backupResult.Status,
"reason", reasonOrEmpty(backupResult.ErrorReason),
"message", backupResult.ErrorMessage)
}
if err := b.persistFullResult(fullBackup, backupResult, rawSizeMb); err != nil {
- logger.Error("failed to persist full result", "error", err)
+ logger.ErrorContext(ctx, "failed to persist full result", "error", err)
return
}
+ logger.InfoContext(ctx, fmt.Sprintf(
+ "physical full backup finished: %s, %.1f MB in %d ms, timeline %d, lsn %s -> %s",
+ backupResult.Status, backupResult.BackupSizeMb, backupResult.BackupDurationMs,
+ backupResult.TimelineID, backupResult.StartLSN, backupResult.StopLSN))
+
if isCallNotifier {
- b.sendFullBackupNotification(backupCtx.Config, backupCtx.Database, fullBackup, backupResult)
+ b.sendFullBackupNotification(ctx, backupCtx.Config, backupCtx.Database, fullBackup, backupResult)
}
}
func (b *PhysicalBackuper) runIncrementalBackup(
+ ctx context.Context,
logger *slog.Logger,
incrBackup *physical_models.PhysicalIncrementalBackup,
isCallNotifier bool,
) {
- backupCtx, ok := b.openBackupContext(logger, incrBackup.DatabaseID)
+ backupCtx, ok := b.openBackupContext(ctx, logger, incrBackup.DatabaseID)
if !ok {
b.finalizeIncrAsError(incrBackup, physical_enums.PhysicalBackupErrorPgBasebackupFailed,
"failed to open backup context")
@@ -164,7 +184,7 @@ func (b *PhysicalBackuper) runIncrementalBackup(
parentRef, err := b.resolveParentManifest(incrBackup)
if err != nil {
- logger.Error("failed to resolve parent manifest", "error", err)
+ logger.ErrorContext(ctx, "failed to resolve parent manifest", "error", err)
b.finalizeIncrAsChainBroken(incrBackup,
physical_enums.PhysicalBackupErrorParentManifestMissing, err.Error())
@@ -172,7 +192,7 @@ func (b *PhysicalBackuper) runIncrementalBackup(
return
}
- ctx, cancel := context.WithCancel(context.Background())
+ executionCtx, cancel := context.WithCancel(context.Background())
b.taskCancelManager.RegisterTask(incrBackup.ID, cancel)
defer b.taskCancelManager.UnregisterTask(incrBackup.ID)
@@ -190,7 +210,7 @@ func (b *PhysicalBackuper) runIncrementalBackup(
Logger: logger,
ProgressListener: func(completedMb float64, elapsedMs int64) {
if err := b.incrRepo.UpdateProgress(incrBackup.ID, completedMb, elapsedMs); err != nil {
- logger.Error("failed to update incremental backup progress", "error", err)
+ logger.ErrorContext(ctx, "failed to update incremental backup progress", "error", err)
}
},
},
@@ -200,9 +220,13 @@ func (b *PhysicalBackuper) runIncrementalBackup(
IncrementalCadence: backupCtx.Config.IncrementalBackupInterval.ApproxPeriod(),
}
- backupResult, err := b.incrExecutor.Execute(ctx, incrBackupSpec)
+ logger.InfoContext(ctx, fmt.Sprintf("physical incremental backup started: database %q, parent lsn %s",
+ backupCtx.Database.Name, parentRef.StopLSN),
+ "parent_backup_id", parentRef.BackupID, "storage_id", backupCtx.Storage.ID)
+
+ backupResult, err := b.incrExecutor.Execute(executionCtx, incrBackupSpec)
if err != nil {
- logger.Error("incremental executor returned error", "error", err)
+ logger.ErrorContext(ctx, "incremental executor returned error", "error", err)
b.finalizeIncrAsError(incrBackup, physical_enums.PhysicalBackupErrorPgBasebackupFailed, err.Error())
@@ -210,56 +234,64 @@ func (b *PhysicalBackuper) runIncrementalBackup(
}
if backupResult.Status != physical_enums.PhysicalBackupStatusCompleted {
- logger.Warn("incremental executor returned non-COMPLETED result",
+ logger.WarnContext(ctx, "incremental executor returned non-COMPLETED result",
"status", backupResult.Status,
"reason", reasonOrEmpty(backupResult.ErrorReason),
"message", backupResult.ErrorMessage)
}
if err := b.persistIncrResult(incrBackup, backupResult); err != nil {
- logger.Error("failed to persist incremental result", "error", err)
+ logger.ErrorContext(ctx, "failed to persist incremental result", "error", err)
return
}
+ logger.InfoContext(ctx, fmt.Sprintf(
+ "physical incremental backup finished: %s, %.1f MB in %d ms, timeline %d, lsn %s -> %s",
+ backupResult.Status, backupResult.BackupSizeMb, backupResult.BackupDurationMs,
+ backupResult.TimelineID, backupResult.StartLSN, backupResult.StopLSN))
+
if isCallNotifier {
- b.sendIncrBackupNotification(backupCtx.Config, backupCtx.Database, incrBackup, backupResult)
+ b.sendIncrBackupNotification(ctx, backupCtx.Config, backupCtx.Database, incrBackup, backupResult)
}
}
func (b *PhysicalBackuper) openBackupContext(
+ ctx context.Context,
logger *slog.Logger,
databaseID uuid.UUID,
) (*backupContext, bool) {
+ logger = logger.With("database_id", databaseID)
+
cfg, err := b.backupConfigService.GetBackupConfigByDbId(databaseID)
if err != nil {
- logger.Error("failed to fetch physical backup config", "error", err)
+ logger.ErrorContext(ctx, "failed to fetch physical backup config", "error", err)
return nil, false
}
if cfg.StorageID == nil {
- logger.Error("physical backup config has no storage id")
+ logger.ErrorContext(ctx, "physical backup config has no storage id")
return nil, false
}
db, err := b.databaseService.GetDatabaseByID(databaseID)
if err != nil {
- logger.Error("failed to fetch database by id", "error", err)
+ logger.ErrorContext(ctx, "failed to fetch database by id", "error", err)
return nil, false
}
if db.PostgresqlPhysical == nil {
- logger.Error("database is not a physical postgres database")
+ logger.ErrorContext(ctx, "database is not a physical postgres database")
return nil, false
}
- storage, err := b.storageService.GetStorageByID(*cfg.StorageID)
+ storage, err := b.storageService.GetStorageByID(ctx, *cfg.StorageID)
if err != nil {
- logger.Error("failed to fetch storage", "error", err)
+ logger.ErrorContext(ctx, "failed to fetch storage", "error", err)
return nil, false
}
@@ -268,7 +300,7 @@ func (b *PhysicalBackuper) openBackupContext(
if cfg.Encryption == backups_core_enums.BackupEncryptionEncrypted {
key, secretErr := b.secretKeyService.GetSecretKey()
if secretErr != nil {
- logger.Error("failed to fetch master key", "error", secretErr)
+ logger.ErrorContext(ctx, "failed to fetch master key", "error", secretErr)
return nil, false
}
@@ -287,7 +319,7 @@ func (b *PhysicalBackuper) openBackupContext(
Encryptor: b.fieldEncryptor,
})
if err != nil {
- logger.Error("failed to open ssh tunnel to the source cluster", "error", err)
+ logger.ErrorContext(ctx, "failed to open ssh tunnel to the source cluster", "error", err)
return nil, false
}
@@ -364,7 +396,7 @@ func (b *PhysicalBackuper) getSourceClusterSizeMb(
b.fieldEncryptor,
)
if err != nil {
- logger.Warn("failed to measure source cluster size", "error", err)
+ logger.WarnContext(ctx, "failed to measure source cluster size", "error", err)
return nil
}
@@ -534,11 +566,19 @@ func (b *PhysicalBackuper) finalizeFullAsError(
fullBackup.ErrorReason = &r
fullBackup.FailMessage = nilOrPtr(message)
+ logger := b.logger.With("backup_id", fullBackup.ID, "database_id", fullBackup.DatabaseID)
+
if err := b.fullRepo.Save(fullBackup); err != nil {
- b.logger.Error("failed to flip full row to ERROR", "backup_id", fullBackup.ID, "error", err)
+ logger.Error("failed to flip full row to ERROR", "error", err)
}
- _ = b.inFlightRepo.ReleaseOwned(fullBackup.DatabaseID, fullBackup.ID)
+ logger.Error(fmt.Sprintf("physical full backup failed: %s, %s", reason, message))
+
+ // A claim that is not released leaves the database's single in-flight slot occupied, so the
+ // scheduler will never start another backup for it.
+ if err := b.inFlightRepo.ReleaseOwned(fullBackup.DatabaseID, fullBackup.ID); err != nil {
+ logger.Error("failed to release the in-flight claim", "error", err)
+ }
}
func (b *PhysicalBackuper) finalizeIncrAsError(
@@ -574,15 +614,27 @@ func (b *PhysicalBackuper) finalizeIncrWithStatus(
incrBackup.ErrorReason = &r
incrBackup.FailMessage = nilOrPtr(message)
+ logger := b.logger.With("backup_id", incrBackup.ID, "database_id", incrBackup.DatabaseID)
+
if err := b.incrRepo.Save(incrBackup); err != nil {
- b.logger.Error("failed to flip incr row to terminal status",
- "status", status, "backup_id", incrBackup.ID, "error", err)
+ logger.Error("failed to flip incr row to terminal status", "status", status, "error", err)
}
- _ = b.inFlightRepo.ReleaseOwned(incrBackup.DatabaseID, incrBackup.ID)
+ // CHAIN_BROKEN is not a retry: it forces the next tick to open a fresh FULL, so it changes what
+ // the scheduler does next and an operator needs to see why.
+ if status == physical_enums.PhysicalBackupStatusChainBroken {
+ logger.Warn(fmt.Sprintf("physical backup chain broken: %s, %s", reason, message))
+ } else {
+ logger.Error(fmt.Sprintf("physical incremental backup failed: %s, %s", reason, message))
+ }
+
+ if err := b.inFlightRepo.ReleaseOwned(incrBackup.DatabaseID, incrBackup.ID); err != nil {
+ logger.Error("failed to release the in-flight claim", "error", err)
+ }
}
func (b *PhysicalBackuper) sendFullBackupNotification(
+ ctx context.Context,
cfg *backups_config_physical.PhysicalBackupConfig,
db *databases.Database,
fullBackup *physical_models.PhysicalFullBackup,
@@ -604,11 +656,12 @@ func (b *PhysicalBackuper) sendFullBackupNotification(
}
for _, notifier := range db.Notifiers {
- b.notificationSender.SendNotification(&notifier, notification)
+ b.notificationSender.SendNotification(ctx, &notifier, notification)
}
}
func (b *PhysicalBackuper) sendIncrBackupNotification(
+ ctx context.Context,
cfg *backups_config_physical.PhysicalBackupConfig,
db *databases.Database,
incrBackup *physical_models.PhysicalIncrementalBackup,
@@ -630,7 +683,7 @@ func (b *PhysicalBackuper) sendIncrBackupNotification(
}
for _, notifier := range db.Notifiers {
- b.notificationSender.SendNotification(&notifier, notification)
+ b.notificationSender.SendNotification(ctx, &notifier, notification)
}
}
diff --git a/backend/internal/features/backups/backups/backuping/physical/backuper_test.go b/backend/internal/features/backups/backups/backuping/physical/backuper_test.go
index 84d94713..2c450627 100644
--- a/backend/internal/features/backups/backups/backuping/physical/backuper_test.go
+++ b/backend/internal/features/backups/backups/backuping/physical/backuper_test.go
@@ -425,7 +425,13 @@ func Test_SendFullBackupNotification_WhenTypeNotInSendOn_DoesNotSend(t *testing.
Status: physical_enums.PhysicalBackupStatusCompleted,
}
- backuper.sendFullBackupNotification(cfg, database, fullBackup, postgresql_executor.PhysicalBackupResult{})
+ backuper.sendFullBackupNotification(
+ t.Context(),
+ cfg,
+ database,
+ fullBackup,
+ postgresql_executor.PhysicalBackupResult{},
+ )
assert.Empty(t, sender.sentNotifications)
}
@@ -452,7 +458,13 @@ func Test_SendFullBackupNotification_WhenEnabled_FansOutToAllNotifiers(t *testin
Status: physical_enums.PhysicalBackupStatusCompleted,
}
- backuper.sendFullBackupNotification(cfg, database, fullBackup, postgresql_executor.PhysicalBackupResult{})
+ backuper.sendFullBackupNotification(
+ t.Context(),
+ cfg,
+ database,
+ fullBackup,
+ postgresql_executor.PhysicalBackupResult{},
+ )
require.Len(t, sender.sentNotifications, 2)
notifiedIDs := []uuid.UUID{
@@ -469,7 +481,7 @@ func Test_OpenBackupContext_WhenNotEncrypted_LeavesMasterKeyEmpty(t *testing.T)
prereqs := seedBackupPrereqs(t)
backuper := CreateTestPhysicalBackuper(nil)
- backupCtx, ok := backuper.openBackupContext(logger.GetLogger(), prereqs.DB.ID)
+ backupCtx, ok := backuper.openBackupContext(t.Context(), logger.GetLogger(), prereqs.DB.ID)
require.True(t, ok)
require.NotNil(t, backupCtx)
@@ -486,10 +498,10 @@ func Test_OpenBackupContext_WhenEncrypted_PopulatesMasterKey(t *testing.T) {
backuper := CreateTestPhysicalBackuper(nil)
prereqs.Config.Encryption = backups_core_enums.BackupEncryptionEncrypted
- _, err := backups_config_physical.GetBackupConfigService().SaveBackupConfig(prereqs.Config)
+ _, err := backups_config_physical.GetBackupConfigService().SaveBackupConfig(t.Context(), prereqs.Config)
require.NoError(t, err)
- backupCtx, ok := backuper.openBackupContext(logger.GetLogger(), prereqs.DB.ID)
+ backupCtx, ok := backuper.openBackupContext(t.Context(), logger.GetLogger(), prereqs.DB.ID)
require.True(t, ok)
require.NotNil(t, backupCtx)
@@ -505,10 +517,10 @@ func Test_OpenBackupContext_WhenConfigHasNoStorageID_ReturnsNotOk(t *testing.T)
prereqs.Config.IsBackupsEnabled = false
prereqs.Config.StorageID = nil
prereqs.Config.Storage = nil
- _, err := backups_config_physical.GetBackupConfigService().SaveBackupConfig(prereqs.Config)
+ _, err := backups_config_physical.GetBackupConfigService().SaveBackupConfig(t.Context(), prereqs.Config)
require.NoError(t, err)
- _, ok := backuper.openBackupContext(logger.GetLogger(), prereqs.DB.ID)
+ _, ok := backuper.openBackupContext(t.Context(), logger.GetLogger(), prereqs.DB.ID)
assert.False(t, ok)
}
@@ -517,7 +529,7 @@ func Test_MakeBackup_WhenRowAbsentInBothTables_InvokesNoExecutor(t *testing.T) {
backuper := CreateTestPhysicalBackuper(sender)
fullExecutor, incrExecutor := installFakeExecutors(backuper)
- backuper.MakeBackup(uuid.New(), false)
+ backuper.MakeBackup(t.Context(), uuid.New(), false)
assert.Equal(t, 0, fullExecutor.callCount)
assert.Equal(t, 0, incrExecutor.callCount)
@@ -532,7 +544,7 @@ func Test_MakeBackup_WhenFullRowExists_InvokesFullExecutorOnly(t *testing.T) {
fullBackup := seedInProgressFull(t, prereqs)
- backuper.MakeBackup(fullBackup.ID, false)
+ backuper.MakeBackup(t.Context(), fullBackup.ID, false)
assert.Equal(t, 1, fullExecutor.callCount)
assert.Equal(t, 0, incrExecutor.callCount)
@@ -552,7 +564,7 @@ func Test_MakeBackup_WhenIncrementalRowExists_InvokesIncrementalExecutorOnly(t *
rootFull := seedCompletedRootFull(t, prereqs)
incrBackup := seedInProgressIncr(t, prereqs, rootFull.ID)
- backuper.MakeBackup(incrBackup.ID, false)
+ backuper.MakeBackup(t.Context(), incrBackup.ID, false)
assert.Equal(t, 0, fullExecutor.callCount)
assert.Equal(t, 1, incrExecutor.callCount)
@@ -571,7 +583,7 @@ func Test_RunFullBackup_WhenExecutorReturnsGoError_FlipsToErrorAndSkipsNotificat
fullBackup := seedInProgressFull(t, prereqs)
- backuper.MakeBackup(fullBackup.ID, true)
+ backuper.MakeBackup(t.Context(), fullBackup.ID, true)
assert.Equal(t, 1, fullExecutor.callCount)
@@ -597,7 +609,7 @@ func Test_RunFullBackup_WhenExecutorResultErrorStatus_PersistsErrorAndSendsFaile
fullBackup := seedInProgressFull(t, prereqs)
- backuper.MakeBackup(fullBackup.ID, true)
+ backuper.MakeBackup(t.Context(), fullBackup.ID, true)
persisted, err := physical_repositories.GetFullBackupRepository().FindByID(fullBackup.ID)
require.NoError(t, err)
@@ -620,7 +632,7 @@ func Test_RunFullBackup_WhenExecutorResultChainBroken_PersistsChainBrokenAndSend
fullBackup := seedInProgressFull(t, prereqs)
- backuper.MakeBackup(fullBackup.ID, true)
+ backuper.MakeBackup(t.Context(), fullBackup.ID, true)
persisted, err := physical_repositories.GetFullBackupRepository().FindByID(fullBackup.ID)
require.NoError(t, err)
@@ -643,7 +655,7 @@ func Test_RunIncrementalBackup_WhenParentManifestMissing_FlipsToChainBrokenBefor
physical_testing.CreateTestFullBackup(t, rootFull)
incrBackup := seedInProgressIncr(t, prereqs, rootFull.ID)
- backuper.MakeBackup(incrBackup.ID, true)
+ backuper.MakeBackup(t.Context(), incrBackup.ID, true)
assert.Equal(t, 0, incrExecutor.callCount, "executor must not run when the parent manifest is unresolved")
@@ -668,7 +680,7 @@ func Test_RunIncrementalBackup_WhenExecutorResultErrorStatus_PersistsErrorAndSen
rootFull := seedCompletedRootFull(t, prereqs)
incrBackup := seedInProgressIncr(t, prereqs, rootFull.ID)
- backuper.MakeBackup(incrBackup.ID, true)
+ backuper.MakeBackup(t.Context(), incrBackup.ID, true)
assert.Equal(t, 1, incrExecutor.callCount)
diff --git a/backend/internal/features/backups/backups/backuping/physical/cleaner.go b/backend/internal/features/backups/backups/backuping/physical/cleaner.go
index ad40270c..679d6ade 100644
--- a/backend/internal/features/backups/backups/backuping/physical/cleaner.go
+++ b/backend/internal/features/backups/backups/backuping/physical/cleaner.go
@@ -59,11 +59,11 @@ func (c *PhysicalBackupCleaner) Run(ctx context.Context) {
logger := c.logger.With("job_id", uuid.New(), "job_name", cleanerJobName)
if err := c.cleanByRetentionPolicy(ctx, logger); err != nil {
- logger.Error("failed to clean by retention policy", "error", err)
+ logger.ErrorContext(ctx, "failed to clean by retention policy", "error", err)
}
if err := c.cleanOrphans(ctx, logger); err != nil {
- logger.Error("failed to clean orphans", "error", err)
+ logger.ErrorContext(ctx, "failed to clean orphans", "error", err)
}
}
}
@@ -76,8 +76,11 @@ func (c *PhysicalBackupCleaner) Run(ctx context.Context) {
func (c *PhysicalBackupCleaner) runStartupSlotCleanup(ctx context.Context) {
isSlotProtected := func(uuid.UUID) (bool, error) { return false, nil }
- if err := usecases_physical_postgresql.RunStartupCleanup(ctx, c.logger, isSlotProtected); err != nil {
- c.logger.Error("physical startup slot cleanup reported failures", "error", err)
+ logger := c.logger.With("job_id", uuid.New(), "job_name", cleanerJobName)
+
+ // Best effort at boot: a slot that cannot be dropped is retried by the orphan sweep.
+ if err := usecases_physical_postgresql.RunStartupCleanup(ctx, logger, isSlotProtected); err != nil {
+ logger.WarnContext(ctx, "physical startup slot cleanup reported failures", "error", err)
}
}
@@ -142,59 +145,73 @@ func (c *PhysicalBackupCleaner) nonExtendableChainsNewestEndFirst(
return candidates, nil
}
-// deleteChainThroughService removes a whole chain via the service, bounded by
-// the per-tick WAL byte budget, logging progress.
+// Reports whether the delete succeeded, so callers count outcomes rather than attempts.
func (c *PhysicalBackupCleaner) deleteChainThroughService(
ctx context.Context,
logger *slog.Logger,
backupConfig *backups_config_physical.PhysicalBackupConfig,
rootFullBackupID uuid.UUID,
-) {
+) bool {
summary, err := c.physicalBackupService.DeleteFull(
- ctx, rootFullBackupID, c.walDeleteBudgetMB(backupConfig.DatabaseID),
+ ctx, rootFullBackupID, c.walDeleteBudgetMB(ctx, backupConfig.DatabaseID),
)
if err != nil {
- logger.Error("failed to delete chain", "root_full_backup_id", rootFullBackupID, "error", err)
+ logger.ErrorContext(ctx, "failed to delete chain", "root_full_backup_id", rootFullBackupID, "error", err)
- return
+ return false
}
- logger.Info(fmt.Sprintf(
+ logger.InfoContext(ctx, fmt.Sprintf(
"chain cleanup progress: %d wal, %d incr, %d history, %.1f MB, complete=%v",
summary.WalSegments, summary.Incrementals, summary.HistoryFiles,
summary.BytesDeletedMB, summary.ChainFullyDeleted,
), "root_full_backup_id", rootFullBackupID)
+
+ return true
}
-// deleteChainDependentsThroughService drops a chain's INCRs and WAL but keeps
-// the FULL — used by FULL_BACKUPS policies that retain a kept FULL as a
-// standalone restore point.
+// A kept FULL stays a standalone restore point, so its INCRs and WAL go while it remains.
+// Reports whether the delete succeeded, so callers count outcomes rather than attempts.
func (c *PhysicalBackupCleaner) deleteChainDependentsThroughService(
ctx context.Context,
logger *slog.Logger,
backupConfig *backups_config_physical.PhysicalBackupConfig,
rootFullBackupID uuid.UUID,
-) {
+) bool {
summary, err := c.physicalBackupService.DeleteChainDependentsKeepFull(
- ctx, rootFullBackupID, c.walDeleteBudgetMB(backupConfig.DatabaseID),
+ ctx, rootFullBackupID, c.walDeleteBudgetMB(ctx, backupConfig.DatabaseID),
)
if err != nil {
- logger.Error("failed to delete chain dependents", "root_full_backup_id", rootFullBackupID, "error", err)
+ logger.ErrorContext(ctx, "failed to delete chain dependents",
+ "root_full_backup_id", rootFullBackupID,
+ "error", err,
+ )
- return
+ return false
}
- logger.Info(fmt.Sprintf(
+ logger.InfoContext(ctx, fmt.Sprintf(
"chain dependents cleanup: %d wal, %d incr, %.1f MB",
summary.WalSegments, summary.Incrementals, summary.BytesDeletedMB,
), "root_full_backup_id", rootFullBackupID)
+
+ return true
}
// walDeleteBudgetMB anchors the per-tick WAL byte budget to the latest COMPLETED
// FULL's size, floored at minWalDeleteBudgetMB.
-func (c *PhysicalBackupCleaner) walDeleteBudgetMB(databaseID uuid.UUID) float64 {
+func (c *PhysicalBackupCleaner) walDeleteBudgetMB(ctx context.Context, databaseID uuid.UUID) float64 {
fulls, err := c.fullRepo.FindCompletedNewestFirstByDatabase(databaseID)
- if err == nil && len(fulls) > 0 && fulls[0].BackupSizeMb != nil {
+ if err != nil {
+ // Falling back to the floor silently would look like retention crawling for no reason.
+ c.logger.WarnContext(ctx, fmt.Sprintf(
+ "failed to size the wal delete budget, falling back to the %.0f MB floor",
+ minWalDeleteBudgetMB), "database_id", databaseID, "error", err)
+
+ return minWalDeleteBudgetMB
+ }
+
+ if len(fulls) > 0 && fulls[0].BackupSizeMb != nil {
return math.Max(*fulls[0].BackupSizeMb, minWalDeleteBudgetMB)
}
@@ -206,12 +223,13 @@ func (c *PhysicalBackupCleaner) walDeleteBudgetMB(databaseID uuid.UUID) float64
// per-backup grace). A failure to read the timestamp is treated as within grace
// so a transient error never causes a premature delete.
func (c *PhysicalBackupCleaner) isChainWithinGrace(
+ ctx context.Context,
backupConfig *backups_config_physical.PhysicalBackupConfig,
rootFullBackupID uuid.UUID,
) bool {
endTs, err := c.chainViewService.GetChainEndTimestamp(rootFullBackupID)
if err != nil {
- c.logger.Error("failed to get chain end timestamp; treating as within grace",
+ c.logger.WarnContext(ctx, "failed to get chain end timestamp; treating as within grace",
"root_full_backup_id", rootFullBackupID, "error", err)
return true
@@ -237,6 +255,8 @@ func (c *PhysicalBackupCleaner) cleanByChains(
) error {
keepCount := backupConfig.ChainsRetention.Count
if keepCount <= 0 {
+ logger.DebugContext(ctx, "chain retention has no count configured, keeping every chain")
+
return nil
}
@@ -246,15 +266,40 @@ func (c *PhysicalBackupCleaner) cleanByChains(
}
if len(candidates) <= keepCount {
+ logger.DebugContext(ctx, fmt.Sprintf("chain retention: keeping all %d chains, limit is %d",
+ len(candidates), keepCount))
+
return nil
}
+ deletedCount, withinGraceCount := 0, 0
+
for _, candidate := range candidates[keepCount:] {
- if c.isChainWithinGrace(backupConfig, candidate.view.RootFull.ID) {
+ rootFullBackupID := candidate.view.RootFull.ID
+
+ if c.isChainWithinGrace(ctx, backupConfig, rootFullBackupID) {
+ withinGraceCount++
+
+ logger.DebugContext(ctx, "keeping chain, it is still within the retention grace period",
+ "root_full_backup_id", rootFullBackupID)
+
continue
}
- c.deleteChainThroughService(ctx, logger, backupConfig, candidate.view.RootFull.ID)
+ if c.deleteChainThroughService(ctx, logger, backupConfig, rootFullBackupID) {
+ deletedCount++
+ }
+ }
+
+ summary := fmt.Sprintf(
+ "chain retention: %d non-extendable chains, %d kept by limit, %d deleted, %d within grace",
+ len(candidates), keepCount, deletedCount, withinGraceCount)
+
+ // The cleaner ticks every few seconds, so a run that changed nothing belongs at debug.
+ if deletedCount > 0 {
+ logger.InfoContext(ctx, summary)
+ } else {
+ logger.DebugContext(ctx, summary)
}
return nil
@@ -274,8 +319,8 @@ func (c *PhysicalBackupCleaner) cleanByFulls(
return err
}
- keepFullIDs := c.fullBackupsKeepSet(backupConfig, completedFulls)
- if keepFullIDs == nil {
+ retainedTiersByFullBackupID := c.getRetainedTiersByFullBackupID(backupConfig, completedFulls)
+ if retainedTiersByFullBackupID == nil {
return nil
}
@@ -284,32 +329,55 @@ func (c *PhysicalBackupCleaner) cleanByFulls(
return err
}
+ deletedCount, dependentsOnlyCount, withinGraceCount := 0, 0, 0
+
for _, candidate := range candidates {
rootFullBackupID := candidate.view.RootFull.ID
- if c.isChainWithinGrace(backupConfig, rootFullBackupID) {
+ if c.isChainWithinGrace(ctx, backupConfig, rootFullBackupID) {
+ withinGraceCount++
+
+ logger.DebugContext(ctx, "keeping chain, it is still within the retention grace period",
+ "root_full_backup_id", rootFullBackupID)
+
continue
}
- if keepFullIDs[rootFullBackupID] {
- c.deleteChainDependentsThroughService(ctx, logger, backupConfig, rootFullBackupID)
+ if tiers, isKept := retainedTiersByFullBackupID[rootFullBackupID]; isKept {
+ logger.DebugContext(ctx, fmt.Sprintf("keeping the full backup%s, shedding its dependents",
+ formatRetentionTiersSuffix(tiers)), "root_full_backup_id", rootFullBackupID)
+
+ if c.deleteChainDependentsThroughService(ctx, logger, backupConfig, rootFullBackupID) {
+ dependentsOnlyCount++
+ }
continue
}
- c.deleteChainThroughService(ctx, logger, backupConfig, rootFullBackupID)
+ if c.deleteChainThroughService(ctx, logger, backupConfig, rootFullBackupID) {
+ deletedCount++
+ }
+ }
+
+ summary := fmt.Sprintf(
+ "full-backup retention: %d chains, %d shed to their full, %d deleted whole, %d within grace",
+ len(candidates), dependentsOnlyCount, deletedCount, withinGraceCount)
+
+ if deletedCount+dependentsOnlyCount > 0 {
+ logger.InfoContext(ctx, summary)
+ } else {
+ logger.DebugContext(ctx, summary)
}
return nil
}
-// fullBackupsKeepSet computes the kept-FULL id set for the FULL_BACKUPS policy.
-// Returns nil when the policy has no effective configuration (so the caller
-// no-ops rather than treating an empty set as "delete everything").
-func (c *PhysicalBackupCleaner) fullBackupsKeepSet(
+// Returns nil when the policy has no effective configuration, so the caller no-ops rather than
+// treating an empty result as "delete everything".
+func (c *PhysicalBackupCleaner) getRetainedTiersByFullBackupID(
backupConfig *backups_config_physical.PhysicalBackupConfig,
completedFullsNewestFirst []*physical_models.PhysicalFullBackup,
-) map[uuid.UUID]bool {
+) map[uuid.UUID][]gfs.Tier {
retention := backupConfig.FullBackupsRetention
switch retention.Policy {
@@ -318,10 +386,10 @@ func (c *PhysicalBackupCleaner) fullBackupsKeepSet(
return nil
}
- keep := make(map[uuid.UUID]bool)
+ keep := make(map[uuid.UUID][]gfs.Tier)
for i, full := range completedFullsNewestFirst {
if i < retention.Count {
- keep[full.ID] = true
+ keep[full.ID] = nil
}
}
@@ -374,22 +442,46 @@ func (c *PhysicalBackupCleaner) cleanByCombined(
return err
}
- for fullID := range c.fullBackupsKeepSet(backupConfig, completedFulls) {
+ for fullID := range c.getRetainedTiersByFullBackupID(backupConfig, completedFulls) {
keepRoots[fullID] = true
}
+ deletedCount, keptCount, withinGraceCount := 0, 0, 0
+
for _, candidate := range candidates {
rootFullBackupID := candidate.view.RootFull.ID
if keepRoots[rootFullBackupID] {
+ keptCount++
+
+ logger.DebugContext(ctx, "keeping chain, either policy retains it",
+ "root_full_backup_id", rootFullBackupID)
+
continue
}
- if c.isChainWithinGrace(backupConfig, rootFullBackupID) {
+ if c.isChainWithinGrace(ctx, backupConfig, rootFullBackupID) {
+ withinGraceCount++
+
+ logger.DebugContext(ctx, "keeping chain, it is still within the retention grace period",
+ "root_full_backup_id", rootFullBackupID)
+
continue
}
- c.deleteChainThroughService(ctx, logger, backupConfig, rootFullBackupID)
+ if c.deleteChainThroughService(ctx, logger, backupConfig, rootFullBackupID) {
+ deletedCount++
+ }
+ }
+
+ summary := fmt.Sprintf(
+ "combined retention: %d chains, %d kept by either policy, %d deleted, %d within grace",
+ len(candidates), keptCount, deletedCount, withinGraceCount)
+
+ if deletedCount > 0 {
+ logger.InfoContext(ctx, summary)
+ } else {
+ logger.DebugContext(ctx, summary)
}
return nil
@@ -407,7 +499,7 @@ func (c *PhysicalBackupCleaner) cleanOrphans(ctx context.Context, logger *slog.L
dbLog := logger.With("database_id", backupConfig.DatabaseID)
c.cleanOrphanWalForDatabase(ctx, dbLog, backupConfig.DatabaseID)
- c.reapAbandonedWalClaims(dbLog, backupConfig.DatabaseID)
+ c.reapAbandonedWalClaims(ctx, dbLog, backupConfig.DatabaseID)
}
return nil
@@ -420,12 +512,12 @@ func (c *PhysicalBackupCleaner) cleanOrphanWalForDatabase(
) {
orphans, err := c.chainViewService.FindWalOrphansByDatabase(databaseID)
if err != nil {
- logger.Error("failed to find orphan wal", "error", err)
+ logger.ErrorContext(ctx, "failed to find orphan wal", "error", err)
return
}
- budget := c.walDeleteBudgetMB(databaseID)
+ budget := c.walDeleteBudgetMB(ctx, databaseID)
for _, orphan := range orphans {
segment := orphan.WalSegment
@@ -438,29 +530,38 @@ func (c *PhysicalBackupCleaner) cleanOrphanWalForDatabase(
ctx, databaseID, segment.TimelineID, span, budget,
)
if err != nil {
- logger.Error("failed to delete orphan wal segment", "wal_filename", segment.WalFilename, "error", err)
+ logger.ErrorContext(ctx, "failed to delete orphan wal segment",
+ "wal_filename", segment.WalFilename,
+ "error", err,
+ )
continue
}
if rows > 0 {
- logger.Info(fmt.Sprintf("deleted orphan wal segment (%.2f MB)", mb), "wal_filename", segment.WalFilename)
+ logger.InfoContext(ctx, fmt.Sprintf("deleted orphan wal segment (%.2f MB)", mb),
+ "wal_filename", segment.WalFilename,
+ )
}
}
}
-func (c *PhysicalBackupCleaner) reapAbandonedWalClaims(logger *slog.Logger, databaseID uuid.UUID) {
+func (c *PhysicalBackupCleaner) reapAbandonedWalClaims(
+ ctx context.Context,
+ logger *slog.Logger,
+ databaseID uuid.UUID,
+) {
cutoff := time.Now().UTC().Add(-walClaimGracePeriod)
- deleted, err := c.walSegmentRepo.DeleteAbandonedClaims(databaseID, cutoff)
+ deletedClaimCount, err := c.walSegmentRepo.DeleteAbandonedClaims(databaseID, cutoff)
if err != nil {
- logger.Error("failed to reap abandoned wal claims", "error", err)
+ logger.ErrorContext(ctx, "failed to reap abandoned wal claims", "error", err)
return
}
- if deleted > 0 {
- logger.Info(fmt.Sprintf("reaped %d abandoned wal claims", deleted))
+ if deletedClaimCount > 0 {
+ logger.InfoContext(ctx, fmt.Sprintf("reaped %d abandoned wal claims", deletedClaimCount))
}
}
@@ -480,3 +581,12 @@ func approxIntervalDuration(interval intervals.Interval) time.Duration {
return 24 * time.Hour
}
}
+
+// The LAST_N variant keeps by position rather than by tier, so it records no tiers at all.
+func formatRetentionTiersSuffix(tiers []gfs.Tier) string {
+ if len(tiers) == 0 {
+ return ""
+ }
+
+ return " (retained as " + gfs.FormatTiers(tiers) + ")"
+}
diff --git a/backend/internal/features/backups/backups/backuping/physical/cleaner_test.go b/backend/internal/features/backups/backups/backuping/physical/cleaner_test.go
index 5677c8b6..8b11e5f9 100644
--- a/backend/internal/features/backups/backups/backuping/physical/cleaner_test.go
+++ b/backend/internal/features/backups/backups/backuping/physical/cleaner_test.go
@@ -281,7 +281,7 @@ func Test_ReapAbandonedWalClaims_WhenClaimOlderThanGrace_DeletesIt(t *testing.T)
require.NoError(t, physical_repositories.GetWalSegmentRepository().Insert(abandoned))
cleaner := CreateTestPhysicalCleaner()
- cleaner.reapAbandonedWalClaims(logger.GetLogger(), prereqs.DB.ID)
+ cleaner.reapAbandonedWalClaims(t.Context(), logger.GetLogger(), prereqs.DB.ID)
assert.False(
t,
@@ -308,7 +308,7 @@ func Test_ReapAbandonedWalClaims_WhenClaimWithinGrace_KeepsIt(t *testing.T) {
require.NoError(t, physical_repositories.GetWalSegmentRepository().Insert(freshClaim))
cleaner := CreateTestPhysicalCleaner()
- cleaner.reapAbandonedWalClaims(logger.GetLogger(), prereqs.DB.ID)
+ cleaner.reapAbandonedWalClaims(t.Context(), logger.GetLogger(), prereqs.DB.ID)
assert.True(t, walExists(t, freshClaim.ID), "a live in-flight claim within grace must survive")
}
diff --git a/backend/internal/features/backups/backups/backuping/physical/config_change_listener.go b/backend/internal/features/backups/backups/backuping/physical/config_change_listener.go
index 1cf3c010..ac91241f 100644
--- a/backend/internal/features/backups/backups/backuping/physical/config_change_listener.go
+++ b/backend/internal/features/backups/backups/backuping/physical/config_change_listener.go
@@ -1,6 +1,7 @@
package backuping_physical
import (
+ "context"
"log/slog"
"github.com/google/uuid"
@@ -41,7 +42,7 @@ func (l *PhysicalBackupCancellationListener) OnBackupConfigChanged(
// OnBeforeDatabaseRemove cancels any in-flight backup and removes the streamer
// row before the database (and its cascade-deleted catalog rows) goes away.
-func (l *PhysicalBackupCancellationListener) OnBeforeDatabaseRemove(databaseID uuid.UUID) error {
+func (l *PhysicalBackupCancellationListener) OnBeforeDatabaseRemove(ctx context.Context, databaseID uuid.UUID) error {
logger := l.logger.With("database_id", databaseID)
l.canceller.CancelInFlightForDatabase(databaseID)
diff --git a/backend/internal/features/backups/backups/backuping/physical/config_change_listener_test.go b/backend/internal/features/backups/backups/backuping/physical/config_change_listener_test.go
index 4a1ee51e..6d66aeab 100644
--- a/backend/internal/features/backups/backups/backuping/physical/config_change_listener_test.go
+++ b/backend/internal/features/backups/backups/backuping/physical/config_change_listener_test.go
@@ -95,7 +95,7 @@ func Test_OnBeforeDatabaseRemove_CancelsInFlightAndDeletesStreamer(t *testing.T)
seedClaimAndStreamer(t, prereqs.DB.ID)
listener := newTestCancellationListener()
- require.NoError(t, listener.OnBeforeDatabaseRemove(prereqs.DB.ID))
+ require.NoError(t, listener.OnBeforeDatabaseRemove(t.Context(), prereqs.DB.ID))
claim, _ := physical_repositories.GetInFlightBackupRepository().FindByDatabaseID(prereqs.DB.ID)
assert.Nil(t, claim)
diff --git a/backend/internal/features/backups/backups/backuping/physical/interfaces.go b/backend/internal/features/backups/backups/backuping/physical/interfaces.go
index 74919ec5..95439c28 100644
--- a/backend/internal/features/backups/backups/backuping/physical/interfaces.go
+++ b/backend/internal/features/backups/backups/backuping/physical/interfaces.go
@@ -9,7 +9,7 @@ import (
)
type NotificationSender interface {
- SendNotification(notifier *notifiers.Notifier, notification notifier_models.Notification)
+ SendNotification(ctx context.Context, notifier *notifiers.Notifier, notification notifier_models.Notification)
}
type FullBackupExecutor interface {
diff --git a/backend/internal/features/backups/backups/backuping/physical/mocks_test.go b/backend/internal/features/backups/backups/backuping/physical/mocks_test.go
index 206a97a9..a51c006a 100644
--- a/backend/internal/features/backups/backups/backuping/physical/mocks_test.go
+++ b/backend/internal/features/backups/backups/backuping/physical/mocks_test.go
@@ -68,6 +68,7 @@ type recordingNotificationSender struct {
}
func (s *recordingNotificationSender) SendNotification(
+ _ context.Context,
notifier *notifiers.Notifier,
notification notifier_models.Notification,
) {
@@ -98,19 +99,19 @@ func seedBackupPrereqs(t *testing.T) *backupPrereqs {
router := backuping_logical.CreateTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
testStorage := storages.CreateTestStorage(workspace.ID)
- t.Cleanup(func() { storages.RemoveTestStorage(testStorage.ID) })
+ t.Cleanup(func() { storages.RemoveTestStorage(t.Context(), testStorage.ID) })
notifier := notifiers.CreateTestNotifier(workspace.ID)
t.Cleanup(func() { notifiers.RemoveTestNotifier(notifier) })
db := databases.CreateTestPhysicalPostgresDatabase(workspace.ID, notifier, "17")
- t.Cleanup(func() { databases.RemoveTestDatabase(db) })
+ t.Cleanup(func() { databases.RemoveTestDatabase(t.Context(), db) })
cfgService := backups_config_physical.GetBackupConfigService()
@@ -129,7 +130,7 @@ func seedBackupPrereqs(t *testing.T) *backupPrereqs {
TimeOfDay: &timeOfDay,
}
- savedConfig, err := cfgService.SaveBackupConfig(cfg)
+ savedConfig, err := cfgService.SaveBackupConfig(t.Context(), cfg)
require.NoError(t, err)
t.Cleanup(func() { physical_testing.DeleteAllPhysicalCatalogForDatabase(t, db.ID) })
diff --git a/backend/internal/features/backups/backups/backuping/physical/scheduler.go b/backend/internal/features/backups/backups/backuping/physical/scheduler.go
index f6182653..75c795a2 100644
--- a/backend/internal/features/backups/backups/backuping/physical/scheduler.go
+++ b/backend/internal/features/backups/backups/backuping/physical/scheduler.go
@@ -64,12 +64,13 @@ func (s *PhysicalBackupsScheduler) Run(ctx context.Context) {
panic(fmt.Sprintf("%T.Run() called multiple times", s))
}
- s.logger = s.logger.With("job_id", uuid.New(), "job_name", schedulerJobName)
+ startupRecoveryLogger := s.logger.With("job_id", uuid.New(), "job_name", schedulerJobName)
+ lifecycleLogger := s.logger.With("job_name", schedulerJobName)
s.lastTickTime.Store(time.Now().UTC())
- if err := s.recoverInFlightBackupsOnRestart(); err != nil {
- s.logger.Error("failed to recover in-flight physical backups on restart", "error", err)
+ if err := s.recoverInFlightBackupsOnRestart(ctx, startupRecoveryLogger); err != nil {
+ startupRecoveryLogger.ErrorContext(ctx, "failed to recover in-flight physical backups on restart", "error", err)
panic(err)
}
@@ -84,13 +85,20 @@ func (s *PhysicalBackupsScheduler) Run(ctx context.Context) {
ticker := time.NewTicker(schedulerTickInterval)
defer ticker.Stop()
+ lifecycleLogger.InfoContext(ctx, "physical backup scheduler started")
+
for {
select {
case <-ctx.Done():
+ lifecycleLogger.InfoContext(ctx, "physical backup scheduler stopped")
+
return
case <-ticker.C:
- if err := s.runPendingBackups(); err != nil {
- s.logger.Error("failed to run pending physical backups", "error", err)
+ // A fresh job_id per tick: it is the correlation ID for one run, not for the process.
+ tickLogger := s.logger.With("job_id", uuid.New(), "job_name", schedulerJobName)
+
+ if err := s.runPendingBackups(ctx, tickLogger); err != nil {
+ tickLogger.ErrorContext(ctx, "failed to run pending physical backups", "error", err)
}
s.lastTickTime.Store(time.Now().UTC())
@@ -98,7 +106,7 @@ func (s *PhysicalBackupsScheduler) Run(ctx context.Context) {
}
}
-func (s *PhysicalBackupsScheduler) runPendingBackups() error {
+func (s *PhysicalBackupsScheduler) runPendingBackups(ctx context.Context, logger *slog.Logger) error {
enabledConfigs, err := s.backupConfigService.GetBackupConfigsWithEnabledBackups()
if err != nil {
return err
@@ -107,20 +115,22 @@ func (s *PhysicalBackupsScheduler) runPendingBackups() error {
now := time.Now().UTC()
for _, backupConfig := range enabledConfigs {
- s.evaluateConfig(now, backupConfig)
+ s.evaluateConfig(ctx, logger, now, backupConfig)
}
return nil
}
func (s *PhysicalBackupsScheduler) evaluateConfig(
+ ctx context.Context,
+ logger *slog.Logger,
now time.Time,
backupConfig *backups_config_physical.PhysicalBackupConfig,
) {
- logger := s.logger.With("database_id", backupConfig.DatabaseID, "job_name", schedulerJobName)
+ logger = logger.With("database_id", backupConfig.DatabaseID)
if backupConfig.StorageID == nil {
- logger.Error("physical backup config has no storage id; skipping")
+ logger.ErrorContext(ctx, "physical backup config has no storage id; skipping")
return
}
@@ -130,12 +140,15 @@ func (s *PhysicalBackupsScheduler) evaluateConfig(
return
}
- s.scheduleBackup(logger, backupConfig, decision)
+ s.scheduleBackup(ctx, logger, backupConfig, decision)
}
// backupDecision is the outcome of the per-tick FULL-vs-INCR decision.
type backupDecision struct {
- kind physical_enums.PhysicalBackupType
+ kind physical_enums.PhysicalBackupType
+ // Why this backup was scheduled - "forced" and "cadence due" produce an identical row, so
+ // without it an operator cannot tell an out-of-cadence request from a normal tick.
+ reason string
incrRootFullBackupID uuid.UUID
incrParentIncrID *uuid.UUID
forceFullRequestedAt *time.Time
@@ -163,6 +176,7 @@ func (s *PhysicalBackupsScheduler) decideBackupKind(
if backupConfig.ForceFullRequestedAt != nil {
return backupDecision{
kind: physical_enums.PhysicalBackupTypeFull,
+ reason: "full requested out of cadence",
forceFullRequestedAt: backupConfig.ForceFullRequestedAt,
}, true
}
@@ -181,10 +195,15 @@ func (s *PhysicalBackupsScheduler) decideBackupKind(
}
if backupConfig.FullBackupInterval.ShouldTriggerBackup(now, createdAtOrNil(lastFull)) {
- return backupDecision{kind: physical_enums.PhysicalBackupTypeFull}, true
+ return backupDecision{
+ kind: physical_enums.PhysicalBackupTypeFull,
+ reason: "full cadence is due",
+ }, true
}
if !isIncrementalEnabled(backupConfig) {
+ logger.Debug("nothing due: full cadence is not due and incrementals are disabled")
+
return backupDecision{}, false
}
@@ -197,8 +216,15 @@ func (s *PhysicalBackupsScheduler) decideBackupKind(
lastBackupTime := newestCreatedAt(lastFull, lastIncr)
- if extendableChain == nil ||
- !backupConfig.IncrementalBackupInterval.ShouldTriggerBackup(now, lastBackupTime) {
+ if extendableChain == nil {
+ logger.Debug("nothing due: no extendable chain to add an incremental to")
+
+ return backupDecision{}, false
+ }
+
+ if !backupConfig.IncrementalBackupInterval.ShouldTriggerBackup(now, lastBackupTime) {
+ logger.Debug("nothing due: neither cadence has elapsed")
+
return backupDecision{}, false
}
@@ -211,6 +237,7 @@ func (s *PhysicalBackupsScheduler) decideBackupKind(
return backupDecision{
kind: physical_enums.PhysicalBackupTypeIncremental,
+ reason: "incremental cadence is due",
incrRootFullBackupID: extendableChain.RootFull.ID,
incrParentIncrID: parentIncrID,
}, true
@@ -289,6 +316,7 @@ func (s *PhysicalBackupsScheduler) resolveIncrParent(rootFullBackupID uuid.UUID)
}
func (s *PhysicalBackupsScheduler) scheduleBackup(
+ ctx context.Context,
logger *slog.Logger,
backupConfig *backups_config_physical.PhysicalBackupConfig,
decision backupDecision,
@@ -298,13 +326,13 @@ func (s *PhysicalBackupsScheduler) scheduleBackup(
claimed, err := s.claimAndInsert(backupConfig, backupID, decision)
if err != nil {
- logger.Error("failed to claim and insert backup row", "error", err)
+ logger.ErrorContext(ctx, "failed to claim and insert backup row", "error", err)
return
}
if !claimed {
- logger.Debug("in-flight slot already claimed by another instance; skipping")
+ logger.DebugContext(ctx, "in-flight slot already claimed by another instance; skipping")
return
}
@@ -314,7 +342,7 @@ func (s *PhysicalBackupsScheduler) scheduleBackup(
backupConfig.DatabaseID,
decision.forceFullRequestedAt,
); err != nil {
- logger.Error("failed to clear forced full request", "error", err)
+ logger.ErrorContext(ctx, "failed to clear forced full request", "error", err)
}
}
@@ -323,13 +351,13 @@ func (s *PhysicalBackupsScheduler) scheduleBackup(
backupConfig.DatabaseID,
decision.forceIncrementalRequestedAt,
); err != nil {
- logger.Error("failed to clear forced incremental request", "error", err)
+ logger.ErrorContext(ctx, "failed to clear forced incremental request", "error", err)
}
}
- go s.backuper.MakeBackup(backupID, true)
+ go s.backuper.MakeBackup(ctx, backupID, true)
- logger.Info("scheduled physical backup")
+ logger.InfoContext(ctx, fmt.Sprintf("scheduled physical %s backup: %s", decision.kind, decision.reason))
}
// claimAndInsert reserves the cross-table in-flight slot and inserts the typed
@@ -397,28 +425,40 @@ func (s *PhysicalBackupsScheduler) claimAndInsert(
// Runs once at Run() entry. The claim is the source of truth for in-flight state —
// claimAndInsert writes the claim and the typed row in one transaction — so
// iterating claims covers every backup that was running.
-func (s *PhysicalBackupsScheduler) recoverInFlightBackupsOnRestart() error {
+func (s *PhysicalBackupsScheduler) recoverInFlightBackupsOnRestart(
+ ctx context.Context,
+ logger *slog.Logger,
+) error {
claims, err := s.inFlightRepo.FindAll()
if err != nil {
return err
}
+ if len(claims) > 0 {
+ logger.InfoContext(ctx, fmt.Sprintf(
+ "failing %d physical backups orphaned by the previous run", len(claims)))
+ }
+
claimedBackupIDs := make(map[uuid.UUID]struct{}, len(claims))
for _, claim := range claims {
claimedBackupIDs[claim.BackupID] = struct{}{}
- s.failOrphanedBackup(claim.BackupType, claim.BackupID, claim.DatabaseID)
+ s.failOrphanedBackup(ctx, logger, claim.BackupType, claim.BackupID, claim.DatabaseID)
}
- return s.failClaimlessInProgressBackups(claimedBackupIDs)
+ return s.failClaimlessInProgressBackups(ctx, logger, claimedBackupIDs)
}
// failClaimlessInProgressBackups fails any IN_PROGRESS row that has no matching
// in-flight claim. The atomic claim+insert should never leave such a row, so this
// is a defensive sweep: without it a stray row could sit IN_PROGRESS forever after
// a restart, since claim-driven recovery would never see it.
-func (s *PhysicalBackupsScheduler) failClaimlessInProgressBackups(claimedBackupIDs map[uuid.UUID]struct{}) error {
+func (s *PhysicalBackupsScheduler) failClaimlessInProgressBackups(
+ ctx context.Context,
+ logger *slog.Logger,
+ claimedBackupIDs map[uuid.UUID]struct{},
+) error {
fulls, err := s.fullRepo.FindAllInProgress()
if err != nil {
return err
@@ -429,7 +469,11 @@ func (s *PhysicalBackupsScheduler) failClaimlessInProgressBackups(claimedBackupI
continue
}
- s.failOrphanedBackup(physical_enums.PhysicalBackupTypeFull, full.ID, full.DatabaseID)
+ // The atomic claim+insert should make this unreachable, so a hit means the invariant broke.
+ logger.WarnContext(ctx, "found an in-progress full backup with no in-flight claim",
+ "backup_id", full.ID, "database_id", full.DatabaseID)
+
+ s.failOrphanedBackup(ctx, logger, physical_enums.PhysicalBackupTypeFull, full.ID, full.DatabaseID)
}
incrementals, err := s.incrRepo.FindAllInProgress()
@@ -442,28 +486,41 @@ func (s *PhysicalBackupsScheduler) failClaimlessInProgressBackups(claimedBackupI
continue
}
- s.failOrphanedBackup(physical_enums.PhysicalBackupTypeIncremental, incremental.ID, incremental.DatabaseID)
+ logger.WarnContext(ctx, "found an in-progress incremental backup with no in-flight claim",
+ "backup_id", incremental.ID, "database_id", incremental.DatabaseID)
+
+ s.failOrphanedBackup(ctx, logger,
+ physical_enums.PhysicalBackupTypeIncremental, incremental.ID, incremental.DatabaseID)
}
return nil
}
func (s *PhysicalBackupsScheduler) failOrphanedBackup(
+ ctx context.Context,
+ logger *slog.Logger,
kind physical_enums.PhysicalBackupType,
backupID, databaseID uuid.UUID,
) {
+ logger = logger.With("backup_id", backupID, "database_id", databaseID)
+
// Best-effort cancel of any locally-registered task; harmless if none
// (a fresh process holds no registrations).
if err := s.taskCancelManager.CancelTask(backupID); err != nil {
- s.logger.Error("failed to cancel orphaned backup task", "backup_id", backupID, "error", err)
+ logger.ErrorContext(ctx, "failed to cancel orphaned backup task", "error", err)
}
if err := s.failBackupAndReleaseClaim(
kind, backupID, databaseID, physical_enums.PhysicalBackupErrorApplicationRestart,
"Backup was interrupted by an application restart and marked failed. Trigger a new backup.",
); err != nil {
- s.logger.Error("failed to fail orphaned backup on restart", "backup_id", backupID, "error", err)
+ logger.ErrorContext(ctx, "failed to fail orphaned backup on restart", "error", err)
+
+ return
}
+
+ logger.InfoContext(ctx, fmt.Sprintf(
+ "failed a %s backup orphaned by the previous run", kind))
}
// failBackupAndReleaseClaim flips one typed row to ERROR and deletes the
diff --git a/backend/internal/features/backups/backups/backuping/physical/scheduler_test.go b/backend/internal/features/backups/backups/backuping/physical/scheduler_test.go
index deed0bce..db8829bb 100644
--- a/backend/internal/features/backups/backups/backuping/physical/scheduler_test.go
+++ b/backend/internal/features/backups/backups/backuping/physical/scheduler_test.go
@@ -349,7 +349,7 @@ func Test_EvaluateConfig_WhenInFlightClaimExists_SkipsWithoutNewRow(t *testing.T
require.NoError(t, err)
require.True(t, ok)
- scheduler.evaluateConfig(time.Now().UTC(), prereqs.Config)
+ scheduler.evaluateConfig(t.Context(), logger.GetLogger(), time.Now().UTC(), prereqs.Config)
lastFull, _ := physical_repositories.GetFullBackupRepository().FindLastFullAnyStatusByDatabase(prereqs.DB.ID)
assert.Nil(t, lastFull, "the existing claim must block a new typed row this tick")
@@ -471,7 +471,7 @@ func Test_RecoverInFlightOnRestart_FailsAndReleasesClaim(t *testing.T) {
scheduler := CreateTestPhysicalScheduler()
backupID := seedInProgressFullWithClaim(t, prereqs)
- require.NoError(t, scheduler.recoverInFlightBackupsOnRestart())
+ require.NoError(t, scheduler.recoverInFlightBackupsOnRestart(t.Context(), logger.GetLogger()))
got, _ := physical_repositories.GetFullBackupRepository().FindByID(backupID)
require.NotNil(t, got)
@@ -539,7 +539,7 @@ func Test_EvaluateConfig_WhenStorageIDNil_SkipsWithoutScheduling(t *testing.T) {
prereqs.Config.StorageID = nil
scheduler := CreateTestPhysicalScheduler()
- scheduler.evaluateConfig(time.Now().UTC(), prereqs.Config)
+ scheduler.evaluateConfig(t.Context(), logger.GetLogger(), time.Now().UTC(), prereqs.Config)
lastFull, _ := physical_repositories.GetFullBackupRepository().FindLastFullAnyStatusByDatabase(prereqs.DB.ID)
assert.Nil(t, lastFull, "a config without a storage id must schedule nothing")
diff --git a/backend/internal/features/backups/backups/backuping/physical/wal_supervisor.go b/backend/internal/features/backups/backups/backuping/physical/wal_supervisor.go
index 3a232359..3c7c5ba6 100644
--- a/backend/internal/features/backups/backups/backuping/physical/wal_supervisor.go
+++ b/backend/internal/features/backups/backups/backuping/physical/wal_supervisor.go
@@ -86,12 +86,11 @@ func (s *PhysicalWalStreamSupervisor) Run(ctx context.Context) {
s.lastTickTime.Store(time.Now().UTC())
if err := s.recoverStreamersOnStartup(); err != nil {
- s.logger.Error(
+ s.logger.ErrorContext(
+ ctx,
"failed to recover wal streamers on startup",
"error",
err,
- "job_name",
- walStreamSupervisorJobName,
)
panic(err)
@@ -131,7 +130,6 @@ func (s *PhysicalWalStreamSupervisor) recoverStreamersOnStartup() error {
if failed > 0 {
s.logger.Warn(
fmt.Sprintf("recovered %d stale wal streamers on startup", failed),
- "job_name", walStreamSupervisorJobName,
)
}
@@ -141,12 +139,11 @@ func (s *PhysicalWalStreamSupervisor) recoverStreamersOnStartup() error {
func (s *PhysicalWalStreamSupervisor) reconcile(ctx context.Context) {
configs, err := s.backupConfigService.GetBackupConfigsWithEnabledBackups()
if err != nil {
- s.logger.Error(
- "wal supervisor: failed to load enabled configs",
+ s.logger.ErrorContext(
+ ctx,
+ "failed to load enabled configs",
"error",
err,
- "job_name",
- walStreamSupervisorJobName,
)
return
@@ -159,13 +156,16 @@ func (s *PhysicalWalStreamSupervisor) reconcile(ctx context.Context) {
continue
}
- logger := s.logger.With("database_id", backupConfig.DatabaseID, "job_name", walStreamSupervisorJobName)
+ logger := s.logger.With("database_id", backupConfig.DatabaseID)
candidates[backupConfig.DatabaseID] = true
s.ensureStreamerRunning(ctx, logger, backupConfig)
}
+ s.logger.DebugContext(ctx, fmt.Sprintf("reconciled wal streamers: %d candidates of %d enabled configs",
+ len(candidates), len(configs)))
+
s.stopNonCandidates(candidates)
s.heartbeatOwnedStreamers()
}
@@ -196,7 +196,7 @@ func (s *PhysicalWalStreamSupervisor) ensureStreamerRunning(
backupConfig.DatabaseID, int(streamerHeartbeatStaleness.Seconds()),
)
if err != nil {
- logger.Error("wal supervisor: claim failed", "error", err)
+ logger.ErrorContext(ctx, "claim failed", "error", err)
return
}
@@ -215,15 +215,15 @@ func (s *PhysicalWalStreamSupervisor) startStreamer(
) {
db, err := s.databaseService.GetDatabaseByID(backupConfig.DatabaseID)
if err != nil || db.PostgresqlPhysical == nil {
- logger.Error("wal supervisor: failed to load database for streamer", "error", err)
+ logger.ErrorContext(ctx, "failed to load database for streamer", "error", err)
s.releaseClaim(logger, backupConfig.DatabaseID)
return
}
- storage, err := s.storageService.GetStorageByID(*backupConfig.StorageID)
+ storage, err := s.storageService.GetStorageByID(ctx, *backupConfig.StorageID)
if err != nil {
- logger.Error("wal supervisor: failed to load storage for streamer", "error", err)
+ logger.ErrorContext(ctx, "failed to load storage for streamer", "error", err)
s.releaseClaim(logger, backupConfig.DatabaseID)
return
@@ -247,7 +247,7 @@ func (s *PhysicalWalStreamSupervisor) startStreamer(
Encryptor: s.fieldEncryptor,
})
if err != nil {
- logger.Error("wal supervisor: failed to open ssh tunnel to the source cluster", "error", err)
+ logger.ErrorContext(ctx, "failed to open ssh tunnel to the source cluster", "error", err)
s.releaseClaim(logger, backupConfig.DatabaseID)
return
@@ -284,9 +284,9 @@ func (s *PhysicalWalStreamSupervisor) startStreamer(
WalLagThresholdBytes: backupConfig.WalLagThresholdBytes,
ForcedRotationInterval: postgresql_executor.DefaultForcedRotationInterval,
ArchiveStalenessThreshold: postgresql_executor.DefaultArchiveStalenessThreshold,
- OnGapDetected: s.gapNotifier(db, backupConfig),
- OnSlotRebuilt: s.slotRebuildFullRequester(logger, db, backupConfig),
- OnChainAtRisk: s.chainRiskNotifier(db, backupConfig),
+ OnGapDetected: s.gapNotifier(ctx, db, backupConfig),
+ OnSlotRebuilt: s.slotRebuildFullRequester(ctx, logger, db, backupConfig),
+ OnChainAtRisk: s.chainRiskNotifier(ctx, db, backupConfig),
Logger: s.logger,
})
@@ -294,7 +294,7 @@ func (s *PhysicalWalStreamSupervisor) startStreamer(
s.running[db.ID] = streamer
s.mu.Unlock()
- logger.Info("wal stream supervisor started for database")
+ logger.InfoContext(ctx, "wal stream supervisor started for database")
go func() {
defer close(done)
@@ -303,9 +303,9 @@ func (s *PhysicalWalStreamSupervisor) startStreamer(
defer s.removeWatchDirIfRequested(logger, streamer)
if err := supervisor.Run(streamerCtx); err != nil {
- logger.Error("wal stream supervisor exited with error", "error", err)
+ logger.ErrorContext(ctx, "wal stream supervisor exited with error", "error", err)
- s.notifyChainBroken(db, backupConfig, chainAlert{
+ s.notifyChainBroken(ctx, db, backupConfig, chainAlert{
Kind: chainAlertStreamerFailed,
Heading: fmt.Sprintf("WAL streaming stopped for %q", db.Name),
Message: fmt.Sprintf("database_id=%s error=%s", db.ID, err),
@@ -315,7 +315,7 @@ func (s *PhysicalWalStreamSupervisor) startStreamer(
// ctx-cancel (shutdown / lifecycle stop) does not reach here with an
// error, so the row is left for the cancelling path to handle.
if markErr := s.walStreamerRepo.MarkFailed(db.ID); markErr != nil {
- logger.Error("wal supervisor: failed to mark streamer failed", "error", markErr)
+ logger.ErrorContext(ctx, "failed to mark streamer failed", "error", markErr)
}
}
@@ -335,7 +335,7 @@ func (s *PhysicalWalStreamSupervisor) resolveMasterKey(
key, err := s.secretKeyService.GetSecretKey()
if err != nil {
- logger.Error("wal supervisor: failed to fetch master key", "error", err)
+ logger.Error("failed to fetch master key", "error", err)
return "", false
}
@@ -344,6 +344,7 @@ func (s *PhysicalWalStreamSupervisor) resolveMasterKey(
}
func (s *PhysicalWalStreamSupervisor) gapNotifier(
+ ctx context.Context,
db *databases.Database,
backupConfig *backups_config_physical.PhysicalBackupConfig,
) func(gapStart, gapEnd walmath.LSN) {
@@ -359,12 +360,13 @@ func (s *PhysicalWalStreamSupervisor) gapNotifier(
}
for _, notifier := range db.Notifiers {
- s.notificationSender.SendNotification(&notifier, notification)
+ s.notificationSender.SendNotification(ctx, &notifier, notification)
}
}
}
func (s *PhysicalWalStreamSupervisor) slotRebuildFullRequester(
+ ctx context.Context,
logger *slog.Logger,
db *databases.Database,
backupConfig *backups_config_physical.PhysicalBackupConfig,
@@ -374,11 +376,11 @@ func (s *PhysicalWalStreamSupervisor) slotRebuildFullRequester(
return err
}
- logger.Warn("requested out-of-cadence full backup after wal slot rebuild", "reason", reason)
+ logger.WarnContext(ctx, "requested out-of-cadence full backup after wal slot rebuild", "reason", reason)
// Dropping and recreating the slot always leaves a WAL gap, so the chain
// this notifies about is already broken by the time we get here.
- s.notifyChainBroken(db, backupConfig, chainAlert{
+ s.notifyChainBroken(ctx, db, backupConfig, chainAlert{
Kind: chainAlertSlotRebuilt,
Heading: fmt.Sprintf("Physical WAL chain rebuilt for %q", db.Name),
Message: fmt.Sprintf("database_id=%s reason=%s; a fresh full backup was requested to anchor the new chain",
@@ -390,11 +392,12 @@ func (s *PhysicalWalStreamSupervisor) slotRebuildFullRequester(
}
func (s *PhysicalWalStreamSupervisor) chainRiskNotifier(
+ ctx context.Context,
db *databases.Database,
backupConfig *backups_config_physical.PhysicalBackupConfig,
) func(postgresql_executor.ChainRiskReport) {
return func(report postgresql_executor.ChainRiskReport) {
- s.notifyChainBroken(db, backupConfig, buildChainRiskAlert(db, report))
+ s.notifyChainBroken(ctx, db, backupConfig, buildChainRiskAlert(db, report))
}
}
@@ -442,6 +445,7 @@ func buildChainRiskAlert(db *databases.Database, report postgresql_executor.Chai
}
func (s *PhysicalWalStreamSupervisor) notifyChainBroken(
+ ctx context.Context,
db *databases.Database,
backupConfig *backups_config_physical.PhysicalBackupConfig,
alert chainAlert,
@@ -461,7 +465,7 @@ func (s *PhysicalWalStreamSupervisor) notifyChainBroken(
}
for _, notifier := range db.Notifiers {
- s.notificationSender.SendNotification(&notifier, notification)
+ s.notificationSender.SendNotification(ctx, &notifier, notification)
}
}
@@ -514,8 +518,9 @@ func (s *PhysicalWalStreamSupervisor) stopStreamer(databaseID uuid.UUID, shouldR
select {
case <-streamer.done:
+ s.logger.Info("wal stream supervisor stopped for database", "database_id", databaseID)
case <-time.After(streamerStopTimeout):
- s.logger.Warn("wal supervisor: streamer stop timed out", "database_id", databaseID)
+ s.logger.Warn("streamer stop timed out", "database_id", databaseID)
}
s.mu.Lock()
@@ -529,7 +534,7 @@ func (s *PhysicalWalStreamSupervisor) stopStreamer(databaseID uuid.UUID, shouldR
if err := s.walStreamerRepo.MarkFailed(databaseID); err != nil {
s.logger.Error(
- "wal supervisor: failed to mark stopped streamer failed",
+ "failed to mark stopped streamer failed",
"database_id",
databaseID,
"error",
@@ -548,7 +553,7 @@ func (s *PhysicalWalStreamSupervisor) heartbeatOwnedStreamers() {
for _, databaseID := range owned {
if err := s.walStreamerRepo.Heartbeat(databaseID); err != nil {
- s.logger.Error("wal supervisor: heartbeat failed", "database_id", databaseID, "error", err)
+ s.logger.Error("heartbeat failed", "database_id", databaseID, "error", err)
}
}
}
@@ -580,6 +585,6 @@ func (s *PhysicalWalStreamSupervisor) removeWatchDirIfRequested(logger *slog.Log
// alive until the heartbeat goes stale.
func (s *PhysicalWalStreamSupervisor) releaseClaim(logger *slog.Logger, databaseID uuid.UUID) {
if err := s.walStreamerRepo.MarkFailed(databaseID); err != nil {
- logger.Error("wal supervisor: failed to release streamer claim", "error", err)
+ logger.Error("failed to release streamer claim", "error", err)
}
}
diff --git a/backend/internal/features/backups/backups/backuping/physical/wal_supervisor_test.go b/backend/internal/features/backups/backups/backuping/physical/wal_supervisor_test.go
index 865f4b67..4e4d4112 100644
--- a/backend/internal/features/backups/backups/backuping/physical/wal_supervisor_test.go
+++ b/backend/internal/features/backups/backups/backuping/physical/wal_supervisor_test.go
@@ -230,7 +230,7 @@ func Test_NotifyChainBroken_WhenSameIncidentRepeats_SendsOneNotificationPerWindo
// A FAILED streamer is reclaimable on the next tick, so the same incident
// re-enters this path every cycle until the cause is fixed.
for range 3 {
- supervisor.notifyChainBroken(prereqs.DB, prereqs.Config, chainAlert{
+ supervisor.notifyChainBroken(t.Context(), prereqs.DB, prereqs.Config, chainAlert{
Kind: chainAlertStreamerFailed,
Heading: "WAL streaming stopped",
Message: "database_id=x",
@@ -251,7 +251,7 @@ func Test_NotifyChainBroken_WhenConfigDoesNotOptIn_SendsNoNotification(t *testin
backups_config_physical.NotificationBackupSuccess,
}
- supervisor.notifyChainBroken(prereqs.DB, prereqs.Config, chainAlert{
+ supervisor.notifyChainBroken(t.Context(), prereqs.DB, prereqs.Config, chainAlert{
Kind: chainAlertStreamerFailed,
Heading: "WAL streaming stopped",
Message: "database_id=x",
@@ -270,12 +270,12 @@ func Test_NotifyChainBroken_WhenDifferentIncidentKinds_SendsEachOnce(t *testing.
backups_config_physical.NotificationChainBroken,
}
- supervisor.notifyChainBroken(prereqs.DB, prereqs.Config, chainAlert{
+ supervisor.notifyChainBroken(t.Context(), prereqs.DB, prereqs.Config, chainAlert{
Kind: chainAlertChainAtRisk,
Heading: "chain at risk",
Message: "database_id=x",
})
- supervisor.notifyChainBroken(prereqs.DB, prereqs.Config, chainAlert{
+ supervisor.notifyChainBroken(t.Context(), prereqs.DB, prereqs.Config, chainAlert{
Kind: chainAlertSlotRebuilt,
Heading: "chain rebuilt",
Message: "database_id=x",
@@ -306,11 +306,11 @@ func Test_NotifyChainBroken_WhenThrottleWindowElapsed_SendsAgain(t *testing.T) {
Message: "database_id=x",
}
- supervisor.notifyChainBroken(prereqs.DB, prereqs.Config, streamerFailed)
+ supervisor.notifyChainBroken(t.Context(), prereqs.DB, prereqs.Config, streamerFailed)
time.Sleep(5 * time.Millisecond)
- supervisor.notifyChainBroken(prereqs.DB, prereqs.Config, streamerFailed)
+ supervisor.notifyChainBroken(t.Context(), prereqs.DB, prereqs.Config, streamerFailed)
require.Len(t, sender.sentNotifications, 2,
"the throttle must mute a burst, not the incident itself — an unfixed break has to keep reminding the operator")
@@ -332,7 +332,7 @@ func Test_StopStreamer_WhenStreamerStops_ForgetsChainAlertThrottle(t *testing.T)
Message: "database_id=x",
}
- supervisor.notifyChainBroken(prereqs.DB, prereqs.Config, streamerFailed)
+ supervisor.notifyChainBroken(t.Context(), prereqs.DB, prereqs.Config, streamerFailed)
done := make(chan struct{})
close(done)
@@ -340,7 +340,7 @@ func Test_StopStreamer_WhenStreamerStops_ForgetsChainAlertThrottle(t *testing.T)
supervisor.running[prereqs.DB.ID] = &runningStreamer{cancel: func() {}, done: done}
supervisor.stopStreamer(prereqs.DB.ID, false)
- supervisor.notifyChainBroken(prereqs.DB, prereqs.Config, streamerFailed)
+ supervisor.notifyChainBroken(t.Context(), prereqs.DB, prereqs.Config, streamerFailed)
require.Len(t, sender.sentNotifications, 2,
"a reclaimed database is a fresh incident, so the throttle from the previous streamer must not mute it")
@@ -356,7 +356,7 @@ func Test_ChainRiskNotifier_WhenReasonsDiffer_UsesSeparateThrottleKinds(t *testi
backups_config_physical.NotificationChainBroken,
}
- notifyChainRisk := supervisor.chainRiskNotifier(prereqs.DB, prereqs.Config)
+ notifyChainRisk := supervisor.chainRiskNotifier(t.Context(), prereqs.DB, prereqs.Config)
lastArchivedWalAt := time.Now().UTC().Add(-2 * time.Hour)
diff --git a/backend/internal/features/backups/backups/backuping/shared/gfs/enums.go b/backend/internal/features/backups/backups/backuping/shared/gfs/enums.go
new file mode 100644
index 00000000..8678c3c1
--- /dev/null
+++ b/backend/internal/features/backups/backups/backuping/shared/gfs/enums.go
@@ -0,0 +1,25 @@
+package gfs
+
+import "strings"
+
+// Tier names the grandfather-father-son level that retained an item. A single item can satisfy
+// several levels at once, which is why retention returns every tier that claimed it rather than one.
+type Tier string
+
+const (
+ TierHourly Tier = "hourly"
+ TierDaily Tier = "daily"
+ TierWeekly Tier = "weekly"
+ TierMonthly Tier = "monthly"
+ TierYearly Tier = "yearly"
+)
+
+// An item can satisfy several levels at once, so a retention log line has to name all of them.
+func FormatTiers(tiers []Tier) string {
+ names := make([]string, len(tiers))
+ for i, tier := range tiers {
+ names[i] = string(tier)
+ }
+
+ return strings.Join(names, "+")
+}
diff --git a/backend/internal/features/backups/backups/backuping/shared/gfs/gfs.go b/backend/internal/features/backups/backups/backuping/shared/gfs/gfs.go
index 2ff7bf79..2b47d224 100644
--- a/backend/internal/features/backups/backups/backuping/shared/gfs/gfs.go
+++ b/backend/internal/features/backups/backups/backuping/shared/gfs/gfs.go
@@ -17,8 +17,8 @@ type Item struct {
func GetItemsToRetain(
items []Item,
hours, days, weeks, months, years int,
-) map[uuid.UUID]bool {
- keep := make(map[uuid.UUID]bool)
+) map[uuid.UUID][]Tier {
+ keep := make(map[uuid.UUID][]Tier)
if len(items) == 0 {
return keep
@@ -93,31 +93,31 @@ func GetItemsToRetain(
yearKey := t.Format("2006")
if hours > 0 && hoursKept < hours && !hoursSeen[hourKey] && t.After(hourlyCutoff) {
- keep[item.ID] = true
+ keep[item.ID] = append(keep[item.ID], TierHourly)
hoursSeen[hourKey] = true
hoursKept++
}
if days > 0 && daysKept < days && !daysSeen[dayKey] && t.After(dailyCutoff) {
- keep[item.ID] = true
+ keep[item.ID] = append(keep[item.ID], TierDaily)
daysSeen[dayKey] = true
daysKept++
}
if weeks > 0 && weeksKept < weeks && !weeksSeen[weekKey] && t.After(weeklyCutoff) {
- keep[item.ID] = true
+ keep[item.ID] = append(keep[item.ID], TierWeekly)
weeksSeen[weekKey] = true
weeksKept++
}
if months > 0 && monthsKept < months && !monthsSeen[monthKey] && t.After(monthlyCutoff) {
- keep[item.ID] = true
+ keep[item.ID] = append(keep[item.ID], TierMonthly)
monthsSeen[monthKey] = true
monthsKept++
}
if years > 0 && yearsKept < years && !yearsSeen[yearKey] && t.After(yearlyCutoff) {
- keep[item.ID] = true
+ keep[item.ID] = append(keep[item.ID], TierYearly)
yearsSeen[yearKey] = true
yearsKept++
}
diff --git a/backend/internal/features/backups/backups/backuping/shared/gfs/gfs_test.go b/backend/internal/features/backups/backups/backuping/shared/gfs/gfs_test.go
index 852f1a65..b6861f3a 100644
--- a/backend/internal/features/backups/backups/backuping/shared/gfs/gfs_test.go
+++ b/backend/internal/features/backups/backups/backuping/shared/gfs/gfs_test.go
@@ -47,7 +47,7 @@ func Test_GetItemsToRetain_WhenItemFillsEveryLevel_KeptOnce(t *testing.T) {
// The single newest item simultaneously fills the hourly, daily, weekly,
// monthly, and yearly slot, so each level is satisfied by it alone.
- assert.True(t, keep[newest.ID])
+ assert.NotEmpty(t, keep[newest.ID])
assert.Len(t, keep, 1)
}
@@ -62,9 +62,9 @@ func Test_GetItemsToRetain_WhenInputUnsorted_SortsBeforeApplyingScheme(t *testin
keep := GetItemsToRetain(unsorted, 2, 0, 0, 0, 0)
- assert.True(t, keep[newest.ID])
- assert.True(t, keep[middle.ID])
- assert.False(t, keep[oldest.ID])
+ assert.NotEmpty(t, keep[newest.ID])
+ assert.NotEmpty(t, keep[middle.ID])
+ assert.Empty(t, keep[oldest.ID])
assert.Len(t, keep, 2)
}
@@ -93,10 +93,10 @@ func Test_GetItemsToRetain_WhenMultipleItemsShareOneHour_KeepsOnlyNewestOfThatHo
// All three of the first three share the same hour bucket, so only the
// newest of them is kept; the previous hour fills the second hourly slot.
- assert.True(t, keep[hourNewest.ID])
- assert.True(t, keep[previousHour.ID])
- assert.False(t, keep[hourMiddle.ID])
- assert.False(t, keep[hourOldest.ID])
+ assert.NotEmpty(t, keep[hourNewest.ID])
+ assert.NotEmpty(t, keep[previousHour.ID])
+ assert.Empty(t, keep[hourMiddle.ID])
+ assert.Empty(t, keep[hourOldest.ID])
assert.Len(t, keep, 2)
}
@@ -111,10 +111,10 @@ func Test_GetItemsToRetain_WhenHourlyCountExceeded_StopsKeeping(t *testing.T) {
keep := GetItemsToRetain(items, 2, 0, 0, 0, 0)
- assert.True(t, keep[items[0].ID])
- assert.True(t, keep[items[1].ID])
- assert.False(t, keep[items[2].ID])
- assert.False(t, keep[items[3].ID])
+ assert.NotEmpty(t, keep[items[0].ID])
+ assert.NotEmpty(t, keep[items[1].ID])
+ assert.Empty(t, keep[items[2].ID])
+ assert.Empty(t, keep[items[3].ID])
assert.Len(t, keep, 2)
}
@@ -129,10 +129,10 @@ func Test_GetItemsToRetain_WithDailyRetention_KeepsOnePerDay(t *testing.T) {
[]Item{today, todayEarlier, yesterday, twoDaysAgo}, 0, 3, 0, 0, 0,
)
- assert.True(t, keep[today.ID])
- assert.True(t, keep[yesterday.ID])
- assert.True(t, keep[twoDaysAgo.ID])
- assert.False(t, keep[todayEarlier.ID])
+ assert.NotEmpty(t, keep[today.ID])
+ assert.NotEmpty(t, keep[yesterday.ID])
+ assert.NotEmpty(t, keep[twoDaysAgo.ID])
+ assert.Empty(t, keep[todayEarlier.ID])
assert.Len(t, keep, 3)
}
@@ -163,12 +163,12 @@ func Test_GetItemsToRetain_WithMixedLevels_KeepsExpectedItems(t *testing.T) {
keep := GetItemsToRetain(items, 2, 2, 2, 2, 2)
- assert.True(t, keep[now.ID])
- assert.True(t, keep[oneHourAgo.ID])
- assert.True(t, keep[yesterday.ID])
- assert.True(t, keep[lastWeek.ID])
- assert.True(t, keep[lastMonth.ID])
- assert.True(t, keep[lastYear.ID])
+ assert.NotEmpty(t, keep[now.ID])
+ assert.NotEmpty(t, keep[oneHourAgo.ID])
+ assert.NotEmpty(t, keep[yesterday.ID])
+ assert.NotEmpty(t, keep[lastWeek.ID])
+ assert.NotEmpty(t, keep[lastMonth.ID])
+ assert.NotEmpty(t, keep[lastYear.ID])
}
func Test_GetItemsToRetain_DropsItemsOlderThanEveryWindow(t *testing.T) {
@@ -178,7 +178,7 @@ func Test_GetItemsToRetain_DropsItemsOlderThanEveryWindow(t *testing.T) {
keep := GetItemsToRetain([]Item{recent, ancient}, 1, 1, 1, 1, 1)
- assert.True(t, keep[recent.ID])
- assert.False(t, keep[ancient.ID])
+ assert.NotEmpty(t, keep[recent.ID])
+ assert.Empty(t, keep[ancient.ID])
assert.Len(t, keep, 1)
}
diff --git a/backend/internal/features/backups/backups/controllers/logical/controller.go b/backend/internal/features/backups/backups/controllers/logical/controller.go
index 0d0d107a..95edffdc 100644
--- a/backend/internal/features/backups/backups/controllers/logical/controller.go
+++ b/backend/internal/features/backups/backups/controllers/logical/controller.go
@@ -75,7 +75,14 @@ func (c *BackupController) GetBackups(ctx *gin.Context) {
filters := c.buildBackupFilters(&request)
- response, err := c.backupService.GetBackups(user, databaseID, request.Limit, request.Offset, filters)
+ response, err := c.backupService.GetBackups(
+ ctx.Request.Context(),
+ user,
+ databaseID,
+ request.Limit,
+ request.Offset,
+ filters,
+ )
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -109,7 +116,7 @@ func (c *BackupController) MakeBackup(ctx *gin.Context) {
return
}
- if err := c.backupService.MakeBackupWithAuth(user, request.DatabaseID); err != nil {
+ if err := c.backupService.MakeBackupWithAuth(ctx.Request.Context(), user, request.DatabaseID); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -140,7 +147,7 @@ func (c *BackupController) DeleteBackup(ctx *gin.Context) {
return
}
- if err := c.backupService.DeleteBackup(user, id); err != nil {
+ if err := c.backupService.DeleteBackup(ctx.Request.Context(), user, id); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -171,7 +178,7 @@ func (c *BackupController) CancelBackup(ctx *gin.Context) {
return
}
- if err := c.backupService.CancelBackup(user, id); err != nil {
+ if err := c.backupService.CancelBackup(ctx.Request.Context(), user, id); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -202,7 +209,7 @@ func (c *BackupController) GenerateDownloadToken(ctx *gin.Context) {
return
}
- response, err := c.backupService.GenerateDownloadToken(user, id)
+ response, err := c.backupService.GenerateDownloadToken(ctx.Request.Context(), user, id)
if err != nil {
if errors.Is(err, stream_guard.ErrDownloadAlreadyInProgress) {
ctx.JSON(
@@ -253,7 +260,7 @@ func (c *BackupController) GetFile(ctx *gin.Context) {
return
}
- downloadToken, err := c.backupService.ValidateDownloadToken(token)
+ downloadToken, err := c.backupService.ValidateDownloadToken(ctx.Request.Context(), token)
if err != nil {
if errors.Is(err, stream_guard.ErrDownloadAlreadyInProgress) {
ctx.JSON(
@@ -279,7 +286,7 @@ func (c *BackupController) GetFile(ctx *gin.Context) {
downloadToken.BackupID,
)
if err != nil {
- c.backupService.ReleaseDownloadLock(downloadToken.UserID)
+ c.backupService.ReleaseDownloadLock(ctx.Request.Context(), downloadToken.UserID)
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -287,7 +294,7 @@ func (c *BackupController) GetFile(ctx *gin.Context) {
heartbeatCtx, cancelHeartbeat := context.WithCancel(context.Background())
defer func() {
cancelHeartbeat()
- c.backupService.ReleaseDownloadLock(downloadToken.UserID)
+ c.backupService.ReleaseDownloadLock(ctx.Request.Context(), downloadToken.UserID)
if err := fileReader.Close(); err != nil {
fmt.Printf("Error closing file reader: %v\n", err)
}
@@ -313,7 +320,7 @@ func (c *BackupController) GetFile(ctx *gin.Context) {
fmt.Printf("Error streaming file: %v\n", err)
}
- c.backupService.WriteAuditLogForDownload(downloadToken.UserID, backup, database)
+ c.backupService.WriteAuditLogForDownload(ctx.Request.Context(), downloadToken.UserID, backup, database)
}
func (c *BackupController) generateBackupFilename(
@@ -357,7 +364,7 @@ func (c *BackupController) startDownloadHeartbeat(ctx context.Context, userID uu
case <-ctx.Done():
return
case <-ticker.C:
- c.backupService.RefreshDownloadLock(userID)
+ c.backupService.RefreshDownloadLock(ctx, userID)
}
}
}
diff --git a/backend/internal/features/backups/backups/controllers/logical/controller_test.go b/backend/internal/features/backups/backups/controllers/logical/controller_test.go
index 85779a21..632df55b 100644
--- a/backend/internal/features/backups/backups/controllers/logical/controller_test.go
+++ b/backend/internal/features/backups/backups/controllers/logical/controller_test.go
@@ -86,20 +86,20 @@ func Test_GetBackups_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, _, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, _, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil {
if *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -110,7 +110,7 @@ func Test_GetBackups_PermissionsEnforced(t *testing.T) {
testUserToken = member.Token
}
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUserToken = nonMember.Token
}
@@ -133,27 +133,27 @@ func Test_GetBackups_PermissionsEnforced(t *testing.T) {
}
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
func Test_GetBackups_WithStatusFilter_ReturnsFilteredBackups(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabase("Test Database", workspace.ID, owner.Token, router)
storage := createTestStorage(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
now := time.Now().UTC()
@@ -215,17 +215,17 @@ func Test_GetBackups_WithStatusFilter_ReturnsFilteredBackups(t *testing.T) {
func Test_GetBackups_WithBeforeDateFilter_ReturnsFilteredBackups(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabase("Test Database", workspace.ID, owner.Token, router)
storage := createTestStorage(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
now := time.Now().UTC()
@@ -261,17 +261,17 @@ func Test_GetBackups_WithBeforeDateFilter_ReturnsFilteredBackups(t *testing.T) {
func Test_GetBackups_WithCombinedFilters_ReturnsFilteredBackups(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabase("Test Database", workspace.ID, owner.Token, router)
storage := createTestStorage(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
now := time.Now().UTC()
@@ -360,21 +360,21 @@ func Test_CreateBackup_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabase("Test Database", workspace.ID, owner.Token, router)
- enableBackupForDatabase(database.ID)
+ enableBackupForDatabase(t.Context(), database.ID)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil {
if *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -385,7 +385,7 @@ func Test_CreateBackup_PermissionsEnforced(t *testing.T) {
testUserToken = member.Token
}
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUserToken = nonMember.Token
}
@@ -406,19 +406,19 @@ func Test_CreateBackup_PermissionsEnforced(t *testing.T) {
}
// Cleanup
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
func Test_CreateBackup_AuditLogWritten(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabase("Test Database", workspace.ID, owner.Token, router)
- enableBackupForDatabase(database.ID)
+ enableBackupForDatabase(t.Context(), database.ID)
request := backups_dto_logical.MakeBackupRequest{DatabaseID: database.ID}
test_utils.MakePostRequest(
@@ -433,7 +433,7 @@ func Test_CreateBackup_AuditLogWritten(t *testing.T) {
time.Sleep(100 * time.Millisecond)
auditLogService := audit_logs.GetAuditLogService()
- auditLogs, err := auditLogService.GetWorkspaceAuditLogs(
+ auditLogs, err := auditLogService.GetWorkspaceAuditLogs(t.Context(),
workspace.ID,
&audit_logs.GetAuditLogsRequest{
Limit: 100,
@@ -453,8 +453,8 @@ func Test_CreateBackup_AuditLogWritten(t *testing.T) {
assert.True(t, found, "Audit log for backup creation not found")
// Cleanup
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_DeleteBackup_PermissionsEnforced(t *testing.T) {
@@ -505,20 +505,20 @@ func Test_DeleteBackup_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, backup, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, backup, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil {
if *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -529,7 +529,7 @@ func Test_DeleteBackup_PermissionsEnforced(t *testing.T) {
testUserToken = member.Token
}
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUserToken = nonMember.Token
}
@@ -545,29 +545,30 @@ func Test_DeleteBackup_PermissionsEnforced(t *testing.T) {
assert.Contains(t, string(testResp.Body), "insufficient permissions")
} else {
userService := users_services.GetUserService()
- ownerUser, err := userService.GetUserFromToken(owner.Token)
+ ownerUser, err := userService.GetUserFromToken(t.Context(), owner.Token)
assert.NoError(t, err)
- response, err := backups_services.GetBackupService().GetBackups(ownerUser, database.ID, 10, 0, nil)
+ response, err := backups_services.GetBackupService().
+ GetBackups(t.Context(), ownerUser, database.ID, 10, 0, nil)
assert.NoError(t, err)
assert.Equal(t, 0, len(response.Backups))
}
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
func Test_DeleteBackup_AuditLogWritten(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, backup, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, backup, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
test_utils.MakeDeleteRequest(
t,
@@ -580,7 +581,7 @@ func Test_DeleteBackup_AuditLogWritten(t *testing.T) {
time.Sleep(100 * time.Millisecond)
auditLogService := audit_logs.GetAuditLogService()
- auditLogs, err := auditLogService.GetWorkspaceAuditLogs(
+ auditLogs, err := auditLogService.GetWorkspaceAuditLogs(t.Context(),
workspace.ID,
&audit_logs.GetAuditLogsRequest{
Limit: 100,
@@ -600,10 +601,10 @@ func Test_DeleteBackup_AuditLogWritten(t *testing.T) {
assert.True(t, found, "Audit log for backup deletion not found")
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_GenerateDownloadToken_PermissionsEnforced(t *testing.T) {
@@ -647,20 +648,20 @@ func Test_GenerateDownloadToken_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, backup, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, backup, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil {
if *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -671,7 +672,7 @@ func Test_GenerateDownloadToken_PermissionsEnforced(t *testing.T) {
testUserToken = member.Token
}
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUserToken = nonMember.Token
}
@@ -696,20 +697,20 @@ func Test_GenerateDownloadToken_PermissionsEnforced(t *testing.T) {
}
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
func Test_DownloadBackup_WithValidToken_Success(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, backup, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, backup, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
// Generate download token
var tokenResponse download_token.GenerateTokenResponse
@@ -738,18 +739,18 @@ func Test_DownloadBackup_WithValidToken_Success(t *testing.T) {
assert.Contains(t, contentDisposition, tokenResponse.Filename)
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_DownloadBackup_WithoutToken_Unauthorized(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, backup, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, backup, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
// Try to download without token
testResp := test_utils.MakeGetRequest(
@@ -763,18 +764,18 @@ func Test_DownloadBackup_WithoutToken_Unauthorized(t *testing.T) {
assert.Contains(t, string(testResp.Body), "download token is required")
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_DownloadBackup_WithInvalidToken_Unauthorized(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, backup, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, backup, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
// Try to download with invalid token
testResp := test_utils.MakeGetRequest(
@@ -788,26 +789,29 @@ func Test_DownloadBackup_WithInvalidToken_Unauthorized(t *testing.T) {
assert.Contains(t, string(testResp.Body), "invalid or expired download token")
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_DownloadBackup_WithExpiredToken_Unauthorized(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, backup, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, backup, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
// Get user for token generation
userService := users_services.GetUserService()
- user, err := userService.GetUserFromToken(owner.Token)
+ user, err := userService.GetUserFromToken(t.Context(), owner.Token)
assert.NoError(t, err)
// Create an expired token directly in the database
- expiredToken := createExpiredDownloadToken(backup.ID, user.ID)
+ expiredToken := createExpiredDownloadToken(
+ t.Context(),
+ expiredDownloadTokenSpec{BackupID: backup.ID, UserID: user.ID},
+ )
// Try to download with expired token
testResp := test_utils.MakeGetRequest(
@@ -823,7 +827,7 @@ func Test_DownloadBackup_WithExpiredToken_Unauthorized(t *testing.T) {
// Verify audit log was NOT created for failed download
time.Sleep(100 * time.Millisecond)
auditLogService := audit_logs.GetAuditLogService()
- auditLogs, err := auditLogService.GetWorkspaceAuditLogs(
+ auditLogs, err := auditLogService.GetWorkspaceAuditLogs(t.Context(),
workspace.ID,
&audit_logs.GetAuditLogsRequest{
Limit: 100,
@@ -843,18 +847,18 @@ func Test_DownloadBackup_WithExpiredToken_Unauthorized(t *testing.T) {
assert.False(t, found, "Audit log should NOT be created for failed download with expired token")
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_DownloadBackup_TokenUsedOnce_CannotReuseToken(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, backup, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, backup, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
// Generate download token
var tokenResponse download_token.GenerateTokenResponse
@@ -889,16 +893,16 @@ func Test_DownloadBackup_TokenUsedOnce_CannotReuseToken(t *testing.T) {
assert.Contains(t, string(testResp.Body), "invalid or expired download token")
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_DownloadBackup_WithDifferentBackupToken_Unauthorized(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database1 := createTestDatabase("Database 1", workspace.ID, owner.Token, router)
storage := createTestStorage(workspace.ID)
@@ -909,10 +913,10 @@ func Test_DownloadBackup_WithDifferentBackupToken_Unauthorized(t *testing.T) {
config1.IsBackupsEnabled = true
config1.StorageID = &storage.ID
config1.Storage = storage
- _, err = configService.SaveBackupConfig(config1)
+ _, err = configService.SaveBackupConfig(t.Context(), config1)
assert.NoError(t, err)
- backup1 := createTestBackup(database1, owner)
+ backup1 := createTestBackup(t.Context(), database1, owner)
database2 := createTestDatabase("Database 2", workspace.ID, owner.Token, router)
config2, err := configService.GetBackupConfigByDbId(database2.ID)
@@ -920,10 +924,10 @@ func Test_DownloadBackup_WithDifferentBackupToken_Unauthorized(t *testing.T) {
config2.IsBackupsEnabled = true
config2.StorageID = &storage.ID
config2.Storage = storage
- _, err = configService.SaveBackupConfig(config2)
+ _, err = configService.SaveBackupConfig(t.Context(), config2)
assert.NoError(t, err)
- backup2 := createTestBackup(database2, owner)
+ backup2 := createTestBackup(t.Context(), database2, owner)
// Generate token for backup1
var tokenResponse download_token.GenerateTokenResponse
@@ -949,19 +953,19 @@ func Test_DownloadBackup_WithDifferentBackupToken_Unauthorized(t *testing.T) {
assert.Contains(t, string(testResp.Body), "invalid or expired download token")
// Cleanup
- databases.RemoveTestDatabase(database1)
- databases.RemoveTestDatabase(database2)
+ databases.RemoveTestDatabase(t.Context(), database1)
+ databases.RemoveTestDatabase(t.Context(), database2)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_DownloadBackup_AuditLogWritten(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, backup, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, backup, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
// Generate download token
var tokenResponse download_token.GenerateTokenResponse
@@ -987,7 +991,7 @@ func Test_DownloadBackup_AuditLogWritten(t *testing.T) {
time.Sleep(100 * time.Millisecond)
auditLogService := audit_logs.GetAuditLogService()
- auditLogs, err := auditLogService.GetWorkspaceAuditLogs(
+ auditLogs, err := auditLogService.GetWorkspaceAuditLogs(t.Context(),
workspace.ID,
&audit_logs.GetAuditLogsRequest{
Limit: 100,
@@ -1007,10 +1011,10 @@ func Test_DownloadBackup_AuditLogWritten(t *testing.T) {
assert.True(t, found, "Audit log for backup download not found")
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_DownloadBackup_ProperFilenameForPostgreSQL(t *testing.T) {
@@ -1043,8 +1047,8 @@ func Test_DownloadBackup_ProperFilenameForPostgreSQL(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabase(tt.databaseName, workspace.ID, owner.Token, router)
storage := createTestStorage(workspace.ID)
@@ -1056,10 +1060,10 @@ func Test_DownloadBackup_ProperFilenameForPostgreSQL(t *testing.T) {
config.IsBackupsEnabled = true
config.StorageID = &storage.ID
config.Storage = storage
- _, err = configService.SaveBackupConfig(config)
+ _, err = configService.SaveBackupConfig(t.Context(), config)
assert.NoError(t, err)
- backup := createTestBackup(database, owner)
+ backup := createTestBackup(t.Context(), database, owner)
// Generate download token
var tokenResponse download_token.GenerateTokenResponse
@@ -1113,10 +1117,10 @@ func Test_DownloadBackup_ProperFilenameForPostgreSQL(t *testing.T) {
)
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
@@ -1144,8 +1148,8 @@ func Test_SanitizeFilename(t *testing.T) {
func Test_CancelBackup_InProgressBackup_SuccessfullyCancelled(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabase("Test Database", workspace.ID, owner.Token, router)
storage := createTestStorage(workspace.ID)
@@ -1156,7 +1160,7 @@ func Test_CancelBackup_InProgressBackup_SuccessfullyCancelled(t *testing.T) {
config.IsBackupsEnabled = true
config.StorageID = &storage.ID
config.Storage = storage
- _, err = configService.SaveBackupConfig(config)
+ _, err = configService.SaveBackupConfig(t.Context(), config)
assert.NoError(t, err)
backup := &backups_core_logical.LogicalBackup{
@@ -1188,13 +1192,13 @@ func Test_CancelBackup_InProgressBackup_SuccessfullyCancelled(t *testing.T) {
assert.Equal(t, http.StatusNoContent, resp.StatusCode)
// Verify audit log was created
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
userService := users_services.GetUserService()
- adminUser, err := userService.GetUserFromToken(admin.Token)
+ adminUser, err := userService.GetUserFromToken(t.Context(), admin.Token)
assert.NoError(t, err)
auditLogService := audit_logs.GetAuditLogService()
- auditLogs, err := auditLogService.GetGlobalAuditLogs(
+ auditLogs, err := auditLogService.GetGlobalAuditLogs(t.Context(),
adminUser,
&audit_logs.GetAuditLogsRequest{Limit: 100, Offset: 0},
)
@@ -1211,18 +1215,18 @@ func Test_CancelBackup_InProgressBackup_SuccessfullyCancelled(t *testing.T) {
assert.True(t, foundCancelLog, "Cancel audit log should be created")
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_ConcurrentDownloadPrevention(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, backup, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, backup, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
var token1Response download_token.GenerateTokenResponse
test_utils.MakePostRequestAndUnmarshal(
@@ -1250,7 +1254,7 @@ func Test_ConcurrentDownloadPrevention(t *testing.T) {
// Hold the per-user stream lock to simulate a download in progress, deterministically —
// without racing a real download goroutine, which finishes too fast to observe under load.
- service.RefreshDownloadLock(owner.UserID)
+ service.RefreshDownloadLock(t.Context(), owner.UserID)
assert.True(t, service.IsDownloadInProgress(owner.UserID))
resp := test_utils.MakeGetRequest(
@@ -1267,7 +1271,7 @@ func Test_ConcurrentDownloadPrevention(t *testing.T) {
assert.Contains(t, errorResponse["error"], "download already in progress")
// After the lock is released, a download proceeds normally.
- service.ReleaseDownloadLock(owner.UserID)
+ service.ReleaseDownloadLock(t.Context(), owner.UserID)
assert.False(t, service.IsDownloadInProgress(owner.UserID))
test_utils.MakeGetRequest(
@@ -1279,25 +1283,25 @@ func Test_ConcurrentDownloadPrevention(t *testing.T) {
)
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_GenerateDownloadToken_BlockedWhenDownloadInProgress(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, backup, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, backup, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
service := backups_services.GetBackupService()
// Mark a download in progress for this user deterministically. Taking the per-user stream
// lock is exactly what a real download does; setting it directly avoids racing a real
// download, which completes too fast to observe reliably under parallel test load.
- service.RefreshDownloadLock(owner.UserID)
+ service.RefreshDownloadLock(t.Context(), owner.UserID)
assert.True(t, service.IsDownloadInProgress(owner.UserID))
resp := test_utils.MakePostRequest(
@@ -1315,7 +1319,7 @@ func Test_GenerateDownloadToken_BlockedWhenDownloadInProgress(t *testing.T) {
assert.Contains(t, errorResponse["error"], "Download already in progress")
// Releasing the lock allows token generation again.
- service.ReleaseDownloadLock(owner.UserID)
+ service.ReleaseDownloadLock(t.Context(), owner.UserID)
assert.False(t, service.IsDownloadInProgress(owner.UserID))
var tokenResponse download_token.GenerateTokenResponse
@@ -1332,18 +1336,18 @@ func Test_GenerateDownloadToken_BlockedWhenDownloadInProgress(t *testing.T) {
assert.NotEmpty(t, tokenResponse.Token)
// Cleanup
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_MakeBackup_VerifyBackupAndMetadataFilesExistInStorage(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
- database, _, storage := createTestDatabaseWithBackups(workspace, owner, router)
+ database, _, storage := createTestDatabaseWithBackups(t.Context(), workspace, owner, router)
scheduler := backuping_logical.CreateTestScheduler()
schedulerCancel := backuping_logical.StartSchedulerForTest(t, scheduler)
@@ -1373,7 +1377,7 @@ func Test_MakeBackup_VerifyBackupAndMetadataFilesExistInStorage(t *testing.T) {
assert.Equal(t, backups_core_logical.BackupStatusCompleted, backup.Status)
storageService := storages.GetStorageService()
- backupStorage, err := storageService.GetStorageByID(backup.StorageID)
+ backupStorage, err := storageService.GetStorageByID(t.Context(), backup.StorageID)
assert.NoError(t, err)
encryptor := encryption.GetFieldEncryptor()
@@ -1418,10 +1422,10 @@ func Test_MakeBackup_VerifyBackupAndMetadataFilesExistInStorage(t *testing.T) {
err = backupRepo.DeleteByID(backup.ID)
assert.NoError(t, err)
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func createTestRouter() *gin.Engine {
@@ -1495,7 +1499,7 @@ func createTestStorage(workspaceID uuid.UUID) *storages.Storage {
return storage
}
-func enableBackupForDatabase(databaseID uuid.UUID) {
+func enableBackupForDatabase(ctx context.Context, databaseID uuid.UUID) {
configService := backups_config_logical.GetBackupConfigService()
config, err := configService.GetBackupConfigByDbId(databaseID)
if err != nil {
@@ -1503,13 +1507,14 @@ func enableBackupForDatabase(databaseID uuid.UUID) {
}
config.IsBackupsEnabled = true
- _, err = configService.SaveBackupConfig(config)
+ _, err = configService.SaveBackupConfig(ctx, config)
if err != nil {
panic(err)
}
}
func createTestDatabaseWithBackups(
+ ctx context.Context,
workspace *workspaces_models.Workspace,
owner *users_dto.SignInResponseDTO,
router *gin.Engine,
@@ -1526,27 +1531,28 @@ func createTestDatabaseWithBackups(
config.IsBackupsEnabled = true
config.StorageID = &storage.ID
config.Storage = storage
- _, err = configService.SaveBackupConfig(config)
+ _, err = configService.SaveBackupConfig(ctx, config)
if err != nil {
panic(err)
}
- backup := createTestBackup(database, owner)
+ backup := createTestBackup(ctx, database, owner)
return database, backup, storage
}
func createTestBackup(
+ ctx context.Context,
database *databases.Database,
owner *users_dto.SignInResponseDTO,
) *backups_core_logical.LogicalBackup {
userService := users_services.GetUserService()
- user, err := userService.GetUserFromToken(owner.Token)
+ user, err := userService.GetUserFromToken(ctx, owner.Token)
if err != nil {
panic(err)
}
- loadedStorages, err := storages.GetStorageService().GetStorages(user, *database.WorkspaceID)
+ loadedStorages, err := storages.GetStorageService().GetStorages(ctx, user, *database.WorkspaceID)
if err != nil || len(loadedStorages) == 0 {
panic("No storage found for workspace")
}
@@ -1583,16 +1589,21 @@ func createTestBackup(
return backup
}
-func createExpiredDownloadToken(backupID, userID uuid.UUID) string {
+type expiredDownloadTokenSpec struct {
+ BackupID uuid.UUID
+ UserID uuid.UUID
+}
+
+func createExpiredDownloadToken(ctx context.Context, spec expiredDownloadTokenSpec) string {
tokenService := backups_download.GetDownloadTokenService()
- token, err := tokenService.Generate(backupID, userID)
+ token, err := tokenService.Generate(ctx, spec.BackupID, spec.UserID)
if err != nil {
panic(fmt.Sprintf("Failed to generate download token: %v", err))
}
// Manually update the token to be expired
repo := &download_token.Repository{}
- downloadToken, err := repo.FindByToken(token)
+ downloadToken, err := repo.FindByToken(ctx, token)
if err != nil || downloadToken == nil {
panic(fmt.Sprintf("Failed to find generated token: %v", err))
}
@@ -1608,8 +1619,8 @@ func createExpiredDownloadToken(backupID, userID uuid.UUID) string {
func Test_DeleteBackup_RemovesBackupAndMetadataFilesFromDisk(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabase("Test Database", workspace.ID, owner.Token, router)
storage := createTestStorage(workspace.ID)
@@ -1621,14 +1632,14 @@ func Test_DeleteBackup_RemovesBackupAndMetadataFilesFromDisk(t *testing.T) {
backupConfig.IsBackupsEnabled = true
backupConfig.StorageID = &storage.ID
backupConfig.Storage = storage
- _, err = configService.SaveBackupConfig(backupConfig)
+ _, err = configService.SaveBackupConfig(t.Context(), backupConfig)
assert.NoError(t, err)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
scheduler := backuping_logical.CreateTestScheduler()
diff --git a/backend/internal/features/backups/backups/controllers/physical/controller.go b/backend/internal/features/backups/backups/controllers/physical/controller.go
index dd349941..4d65e98b 100644
--- a/backend/internal/features/backups/backups/controllers/physical/controller.go
+++ b/backend/internal/features/backups/backups/controllers/physical/controller.go
@@ -88,7 +88,7 @@ func (c *PhysicalBackupController) GetBackups(ctx *gin.Context) {
return
}
- response, err := c.physicalBackupService.GetBackups(user, databaseID, &request)
+ response, err := c.physicalBackupService.GetBackups(ctx.Request.Context(), user, databaseID, &request)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -130,7 +130,7 @@ func (c *PhysicalBackupController) TriggerBackup(ctx *gin.Context) {
return
}
- if err := c.requestBackupOfType(user, databaseID, request.Type); err != nil {
+ if err := c.requestBackupOfType(ctx.Request.Context(), user, databaseID, request.Type); err != nil {
if errors.Is(err, backups_services.ErrNoExtendableChain) {
ctx.JSON(http.StatusConflict, gin.H{"error": err.Error()})
return
@@ -176,7 +176,7 @@ func (c *PhysicalBackupController) GenerateRestoreToken(ctx *gin.Context) {
return
}
- token, err := c.physicalBackupService.GenerateRestoreToken(user, databaseID, &request)
+ token, err := c.physicalBackupService.GenerateRestoreToken(ctx.Request.Context(), user, databaseID, &request)
if err != nil {
if errors.Is(err, stream_guard.ErrDownloadAlreadyInProgress) {
ctx.JSON(http.StatusConflict, gin.H{"error": err.Error()})
@@ -227,7 +227,7 @@ func (c *PhysicalBackupController) GenerateBackupRestoreToken(ctx *gin.Context)
return
}
- token, err := c.physicalBackupService.GenerateBackupRestoreToken(user, backupID)
+ token, err := c.physicalBackupService.GenerateBackupRestoreToken(ctx.Request.Context(), user, backupID)
if err != nil {
if errors.Is(err, backups_services.ErrBackupNotFound) {
ctx.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
@@ -280,7 +280,7 @@ func (c *PhysicalBackupController) CancelBackup(ctx *gin.Context) {
return
}
- if err := c.physicalBackupService.CancelBackup(user, backupID); err != nil {
+ if err := c.physicalBackupService.CancelBackup(ctx.Request.Context(), user, backupID); err != nil {
if errors.Is(err, backups_services.ErrBackupNotFound) {
ctx.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
return
@@ -317,7 +317,7 @@ func (c *PhysicalBackupController) DeleteBackup(ctx *gin.Context) {
return
}
- if err := c.physicalBackupService.DeleteBackup(user, backupID); err != nil {
+ if err := c.physicalBackupService.DeleteBackup(ctx.Request.Context(), user, backupID); err != nil {
if errors.Is(err, backups_services.ErrBackupNotFound) {
ctx.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
return
@@ -349,7 +349,7 @@ func (c *PhysicalBackupController) GetRestoreStream(ctx *gin.Context) {
return
}
- restoreToken, err := c.restoreTokenService.ValidateAndConsumeRestoreToken(token)
+ restoreToken, err := c.restoreTokenService.ValidateAndConsumeRestoreToken(ctx.Request.Context(), token)
if err != nil {
if errors.Is(err, stream_guard.ErrDownloadAlreadyInProgress) {
ctx.JSON(http.StatusConflict, gin.H{
@@ -365,7 +365,7 @@ func (c *PhysicalBackupController) GetRestoreStream(ctx *gin.Context) {
heartbeatCtx, cancelHeartbeat := context.WithCancel(context.Background())
defer func() {
cancelHeartbeat()
- c.restoreTokenService.ReleaseDownloadLock(restoreToken.UserID)
+ c.restoreTokenService.ReleaseDownloadLock(ctx.Request.Context(), restoreToken.UserID)
}()
go c.startStreamHeartbeat(heartbeatCtx, restoreToken.UserID)
@@ -434,19 +434,20 @@ func (c *PhysicalBackupController) openRestoreStream(
}
func (c *PhysicalBackupController) requestBackupOfType(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
backupType backups_dto_physical.TriggerBackupType,
) error {
switch backupType {
case backups_dto_physical.TriggerBackupTypeFull:
- return c.physicalBackupService.RequestFullBackup(user, databaseID)
+ return c.physicalBackupService.RequestFullBackup(ctx, user, databaseID)
case backups_dto_physical.TriggerBackupTypeIncremental:
- return c.physicalBackupService.RequestIncrementalBackup(user, databaseID)
+ return c.physicalBackupService.RequestIncrementalBackup(ctx, user, databaseID)
default:
- return c.physicalBackupService.RequestBackup(user, databaseID)
+ return c.physicalBackupService.RequestBackup(ctx, user, databaseID)
}
}
@@ -459,7 +460,7 @@ func (c *PhysicalBackupController) startStreamHeartbeat(ctx context.Context, use
case <-ctx.Done():
return
case <-ticker.C:
- c.restoreTokenService.RefreshDownloadLock(userID)
+ c.restoreTokenService.RefreshDownloadLock(ctx, userID)
}
}
}
diff --git a/backend/internal/features/backups/backups/controllers/physical/controller_test.go b/backend/internal/features/backups/backups/controllers/physical/controller_test.go
index 8af9f3f3..d18d1c7c 100644
--- a/backend/internal/features/backups/backups/controllers/physical/controller_test.go
+++ b/backend/internal/features/backups/backups/controllers/physical/controller_test.go
@@ -60,17 +60,17 @@ func createPhysicalControllerPrereqs(t *testing.T) *physicalControllerPrereqs {
t.Helper()
router := newPhysicalControllerRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Physical Ctrl "+uuid.NewString(), user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Physical Ctrl "+uuid.NewString(), user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestPhysicalPostgresDatabase(workspace.ID, notifier, "17")
t.Cleanup(func() {
physical_testing.DeleteAllPhysicalCatalogForDatabase(t, database.ID)
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
})
return &physicalControllerPrereqs{
@@ -237,7 +237,7 @@ func Test_GetBackups_Paginated_ReturnsRequestedPage(t *testing.T) {
func Test_GetBackups_WhenNonMember_ReturnsError(t *testing.T) {
prereqs := createPhysicalControllerPrereqs(t)
- outsider := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ outsider := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
test_utils.MakeGetRequest(t, prereqs.router,
"/api/v1/backups/physical/database/"+prereqs.database.ID.String()+"/backups",
@@ -1041,13 +1041,13 @@ func runRolePermissionMatrix(
) {
t.Helper()
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
prereqs.workspace, member, users_enums.WorkspaceRoleMember, prereqs.user.Token, prereqs.router)
viewer := addWorkspaceViewer(t, prereqs)
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
viewerCode := successCode
if managersOnly {
@@ -1074,14 +1074,14 @@ func occupyUserStreamSlot(t *testing.T, userID uuid.UUID) {
}
t.Cleanup(func() {
- restoreTokenService.ReleaseDownloadLock(userID)
+ restoreTokenService.ReleaseDownloadLock(t.Context(), userID)
})
}
func addWorkspaceViewer(t *testing.T, prereqs *physicalControllerPrereqs) *users_dto.SignInResponseDTO {
t.Helper()
- viewer := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ viewer := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
prereqs.workspace, viewer, users_enums.WorkspaceRoleViewer, prereqs.user.Token, prereqs.router)
@@ -1131,7 +1131,7 @@ func createSecondPhysicalDatabase(t *testing.T, prereqs *physicalControllerPrere
database := databases.CreateTestPhysicalPostgresDatabase(prereqs.workspace.ID, prereqs.notifier, "17")
t.Cleanup(func() {
physical_testing.DeleteAllPhysicalCatalogForDatabase(t, database.ID)
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
})
return database
@@ -1140,7 +1140,7 @@ func createSecondPhysicalDatabase(t *testing.T, prereqs *physicalControllerPrere
func assertAuditLogContains(t *testing.T, workspaceID uuid.UUID, messageFragment, databaseName string) {
t.Helper()
- logs, err := audit_logs.GetAuditLogService().GetWorkspaceAuditLogs(
+ logs, err := audit_logs.GetAuditLogService().GetWorkspaceAuditLogs(t.Context(),
workspaceID, &audit_logs.GetAuditLogsRequest{Limit: 100, Offset: 0})
require.NoError(t, err)
@@ -1189,7 +1189,7 @@ func saveStorageObject(t *testing.T, storage *storages.Storage, name string, bod
t.Fatalf("save storage object %s: %v", name, err)
}
- t.Cleanup(func() { _ = storage.DeleteFile(encryptor, name) })
+ t.Cleanup(func() { _ = storage.DeleteFile(t.Context(), encryptor, logger.GetLogger(), name) })
}
func zstdTar(t *testing.T, files map[string]string) []byte {
diff --git a/backend/internal/features/backups/backups/core/logical/interfaces.go b/backend/internal/features/backups/backups/core/logical/interfaces.go
index 6d77246d..69b7354b 100644
--- a/backend/internal/features/backups/backups/core/logical/interfaces.go
+++ b/backend/internal/features/backups/backups/core/logical/interfaces.go
@@ -14,6 +14,7 @@ import (
type NotificationSender interface {
SendNotification(
+ ctx context.Context,
notifier *notifiers.Notifier,
notification notifier_models.Notification,
)
diff --git a/backend/internal/features/backups/backups/core/physical/chain_view/service_test.go b/backend/internal/features/backups/backups/core/physical/chain_view/service_test.go
index f449027f..4eb3b79a 100644
--- a/backend/internal/features/backups/backups/core/physical/chain_view/service_test.go
+++ b/backend/internal/features/backups/backups/core/physical/chain_view/service_test.go
@@ -38,17 +38,17 @@ func createChainViewTestPrereqs(t *testing.T) *chainViewTestPrereqs {
t.Helper()
router := newChainViewTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Chain View Test "+uuid.NewString(), user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Chain View Test "+uuid.NewString(), user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestPhysicalPostgresDatabase(workspace.ID, notifier, "17")
t.Cleanup(func() {
physical_testing.DeleteAllPhysicalCatalogForDatabase(t, database.ID)
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
})
return &chainViewTestPrereqs{
diff --git a/backend/internal/features/backups/backups/core/physical/service/service.go b/backend/internal/features/backups/backups/core/physical/service/service.go
index b72c9b3e..9814a8c5 100644
--- a/backend/internal/features/backups/backups/core/physical/service/service.go
+++ b/backend/internal/features/backups/backups/core/physical/service/service.go
@@ -143,7 +143,7 @@ func (s *PhysicalBackupService) DeleteWalSegmentsInSpan(
var deletedMB float64
txErr := storage.GetDb().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- rows, mb, _, err := s.deleteWalInSpanBudgeted(tx, databaseID, timelineID, span, walByteBudgetMB, true)
+ rows, mb, _, err := s.deleteWalInSpanBudgeted(ctx, tx, databaseID, timelineID, span, walByteBudgetMB, true)
deletedRows = rows
deletedMB = mb
@@ -173,7 +173,7 @@ func (s *PhysicalBackupService) DeleteIncrementalCascade(
findErr := tx.Where("id = ?", incrementalID).First(&target).Error
if errors.Is(findErr, gorm.ErrRecordNotFound) {
- s.logger.Debug("incremental already deleted by peer", "incremental_backup_id", incrementalID)
+ s.logger.DebugContext(ctx, "incremental already deleted by peer", "incremental_backup_id", incrementalID)
return nil
}
@@ -204,7 +204,7 @@ func (s *PhysicalBackupService) DeleteIncrementalCascade(
subtree := collectIncrementalSubtree(chain, incrementalID)
- count, mb, err := s.deleteIncrementalSet(tx, reverseTopoOrderIncrementals(subtree))
+ count, mb, err := s.deleteIncrementalSet(ctx, tx, reverseTopoOrderIncrementals(subtree))
summary.Incrementals = count
summary.BytesDeletedMB = mb
@@ -521,7 +521,7 @@ func (s *PhysicalBackupService) cascadeDelete(
Where("id = ?", rootFullBackupID).
First(&full).Error
if errors.Is(lockErr, gorm.ErrRecordNotFound) {
- s.logger.Debug("chain already deleted by peer", "root_full_backup_id", rootFullBackupID)
+ s.logger.DebugContext(ctx, "chain already deleted by peer", "root_full_backup_id", rootFullBackupID)
return nil
}
@@ -534,7 +534,7 @@ func (s *PhysicalBackupService) cascadeDelete(
return err
}
- walRows, walBytes, budgetHit, err := s.deleteWalInSpanBudgeted(
+ walRows, walBytes, budgetHit, err := s.deleteWalInSpanBudgeted(ctx,
tx, full.DatabaseID, full.TimelineID, span, walByteBudgetMB, false,
)
summary.WalSegments = walRows
@@ -549,7 +549,7 @@ func (s *PhysicalBackupService) cascadeDelete(
return nil
}
- incrementalCount, err := s.deleteIncrementals(tx, rootFullBackupID)
+ incrementalCount, err := s.deleteIncrementals(ctx, tx, rootFullBackupID)
summary.Incrementals = incrementalCount
if err != nil {
return err
@@ -559,13 +559,13 @@ func (s *PhysicalBackupService) cascadeDelete(
return nil
}
- historyCount, err := s.deleteOrphanedHistoryFiles(tx, &full)
+ historyCount, err := s.deleteOrphanedHistoryFiles(ctx, tx, &full)
summary.HistoryFiles = historyCount
if err != nil {
return err
}
- if err := s.deleteFullArtifactAndRow(tx, &full); err != nil {
+ if err := s.deleteFullArtifactAndRow(ctx, tx, &full); err != nil {
return err
}
@@ -588,6 +588,7 @@ func (s *PhysicalBackupService) cascadeDelete(
// on); when false the caller already holds the anchor FULL lock. Returns rows
// deleted, MB deleted, and whether the budget capped the run (more rows remain).
func (s *PhysicalBackupService) deleteWalInSpanBudgeted(
+ ctx context.Context,
tx *gorm.DB,
databaseID uuid.UUID,
timelineID int,
@@ -620,11 +621,11 @@ func (s *PhysicalBackupService) deleteWalInSpanBudgeted(
for _, segment := range segments {
if segment.FileName != nil {
- if delErr := s.deleteWalObjectFailClosed(segment.StorageID, *segment.FileName); delErr != nil {
+ if delErr := s.deleteWalObjectFailClosed(ctx, segment.StorageID, *segment.FileName); delErr != nil {
return deletedRows, deletedMB, false, delErr
}
- if delErr := s.deleteWalObjectFailClosed(
+ if delErr := s.deleteWalObjectFailClosed(ctx,
segment.StorageID,
*segment.FileName+metadataSuffix,
); delErr != nil {
@@ -653,7 +654,11 @@ func (s *PhysicalBackupService) deleteWalInSpanBudgeted(
}
}
-func (s *PhysicalBackupService) deleteIncrementals(tx *gorm.DB, rootFullBackupID uuid.UUID) (int, error) {
+func (s *PhysicalBackupService) deleteIncrementals(
+ ctx context.Context,
+ tx *gorm.DB,
+ rootFullBackupID uuid.UUID,
+) (int, error) {
var incrementals []*physical_models.PhysicalIncrementalBackup
if err := tx.
@@ -662,7 +667,7 @@ func (s *PhysicalBackupService) deleteIncrementals(tx *gorm.DB, rootFullBackupID
return 0, err
}
- deleted, _, err := s.deleteIncrementalSet(tx, reverseTopoOrderIncrementals(incrementals))
+ deleted, _, err := s.deleteIncrementalSet(ctx, tx, reverseTopoOrderIncrementals(incrementals))
return deleted, err
}
@@ -671,6 +676,7 @@ func (s *PhysicalBackupService) deleteIncrementals(tx *gorm.DB, rootFullBackupID
// (callers pass them leaves-first), each artifact before its row. Returns the
// number of rows removed and the MB freed.
func (s *PhysicalBackupService) deleteIncrementalSet(
+ ctx context.Context,
tx *gorm.DB,
ordered []*physical_models.PhysicalIncrementalBackup,
) (int, float64, error) {
@@ -679,13 +685,13 @@ func (s *PhysicalBackupService) deleteIncrementalSet(
for _, incremental := range ordered {
if incremental.FileName != nil {
- s.deleteStorageObjectFailOpen(incremental.StorageID, *incremental.FileName+metadataSuffix)
+ s.deleteStorageObjectFailOpen(ctx, incremental.StorageID, *incremental.FileName+metadataSuffix)
if incremental.ManifestFileName != nil {
- s.deleteStorageObjectFailOpen(incremental.StorageID, *incremental.ManifestFileName)
+ s.deleteStorageObjectFailOpen(ctx, incremental.StorageID, *incremental.ManifestFileName)
}
- s.deleteStorageObjectFailOpen(incremental.StorageID, *incremental.FileName)
+ s.deleteStorageObjectFailOpen(ctx, incremental.StorageID, *incremental.FileName)
}
if err := tx.Delete(&physical_models.PhysicalIncrementalBackup{}, "id = ?", incremental.ID).Error; err != nil {
@@ -747,6 +753,7 @@ func collectIncrementalSubtree(
// when no other COMPLETED FULL survives on that timeline — otherwise the history
// still anchors a living chain.
func (s *PhysicalBackupService) deleteOrphanedHistoryFiles(
+ ctx context.Context,
tx *gorm.DB,
full *physical_models.PhysicalFullBackup,
) (int, error) {
@@ -775,8 +782,8 @@ func (s *PhysicalBackupService) deleteOrphanedHistoryFiles(
deleted := 0
for _, historyFile := range historyFiles {
- s.deleteStorageObjectFailOpen(historyFile.StorageID, historyFile.FileName+metadataSuffix)
- s.deleteStorageObjectFailOpen(historyFile.StorageID, historyFile.FileName)
+ s.deleteStorageObjectFailOpen(ctx, historyFile.StorageID, historyFile.FileName+metadataSuffix)
+ s.deleteStorageObjectFailOpen(ctx, historyFile.StorageID, historyFile.FileName)
if err := tx.Delete(&physical_models.PhysicalWalHistoryFile{}, "id = ?", historyFile.ID).Error; err != nil {
return deleted, err
@@ -789,17 +796,18 @@ func (s *PhysicalBackupService) deleteOrphanedHistoryFiles(
}
func (s *PhysicalBackupService) deleteFullArtifactAndRow(
+ ctx context.Context,
tx *gorm.DB,
full *physical_models.PhysicalFullBackup,
) error {
if full.FileName != nil {
- s.deleteStorageObjectFailOpen(full.StorageID, *full.FileName+metadataSuffix)
+ s.deleteStorageObjectFailOpen(ctx, full.StorageID, *full.FileName+metadataSuffix)
if full.ManifestFileName != nil {
- s.deleteStorageObjectFailOpen(full.StorageID, *full.ManifestFileName)
+ s.deleteStorageObjectFailOpen(ctx, full.StorageID, *full.ManifestFileName)
}
- s.deleteStorageObjectFailOpen(full.StorageID, *full.FileName)
+ s.deleteStorageObjectFailOpen(ctx, full.StorageID, *full.FileName)
}
return tx.Delete(&physical_models.PhysicalFullBackup{}, "id = ?", full.ID).Error
@@ -808,8 +816,8 @@ func (s *PhysicalBackupService) deleteFullArtifactAndRow(
// deleteStorageObjectFailOpen deletes one object, logging and continuing on any
// failure. Used for FULL / INCR / history objects: a transient storage error
// must not block the row delete. storage.DeleteFile is idempotent on not-found.
-func (s *PhysicalBackupService) deleteStorageObjectFailOpen(storageID uuid.UUID, fileName string) {
- backupStorage, err := s.storageService.GetStorageByID(storageID)
+func (s *PhysicalBackupService) deleteStorageObjectFailOpen(ctx context.Context, storageID uuid.UUID, fileName string) {
+ backupStorage, err := s.storageService.GetStorageByID(ctx, storageID)
if err != nil {
s.logger.Error("failed to resolve storage for object delete",
"storage_id", storageID, "file_name", fileName, "error", err)
@@ -817,8 +825,8 @@ func (s *PhysicalBackupService) deleteStorageObjectFailOpen(storageID uuid.UUID,
return
}
- if err := backupStorage.DeleteFile(s.fieldEncryptor, fileName); err != nil {
- s.logger.Error("failed to delete storage object", "file_name", fileName, "error", err)
+ if err := backupStorage.DeleteFile(ctx, s.fieldEncryptor, s.logger, fileName); err != nil {
+ s.logger.ErrorContext(ctx, "failed to delete storage object", "file_name", fileName, "error", err)
}
}
@@ -827,8 +835,12 @@ func (s *PhysicalBackupService) deleteStorageObjectFailOpen(storageID uuid.UUID,
// never orphaning a WAL object with no catalog row. A permanently-removed
// storage (the storage row itself is gone) is fail-open — the object is
// unreachable forever, so the row may be deleted.
-func (s *PhysicalBackupService) deleteWalObjectFailClosed(storageID uuid.UUID, fileName string) error {
- backupStorage, err := s.storageService.GetStorageByID(storageID)
+func (s *PhysicalBackupService) deleteWalObjectFailClosed(
+ ctx context.Context,
+ storageID uuid.UUID,
+ fileName string,
+) error {
+ backupStorage, err := s.storageService.GetStorageByID(ctx, storageID)
if err != nil {
s.logger.Warn("storage not found for WAL object delete; removing row anyway",
"storage_id", storageID, "file_name", fileName, "error", err)
@@ -836,7 +848,7 @@ func (s *PhysicalBackupService) deleteWalObjectFailClosed(storageID uuid.UUID, f
return nil
}
- if err := backupStorage.DeleteFile(s.fieldEncryptor, fileName); err != nil {
+ if err := backupStorage.DeleteFile(ctx, s.fieldEncryptor, s.logger, fileName); err != nil {
return fmt.Errorf("delete WAL object %s: %w", fileName, err)
}
diff --git a/backend/internal/features/backups/backups/core/physical/service/service_test.go b/backend/internal/features/backups/backups/core/physical/service/service_test.go
index 886e8fec..f5707410 100644
--- a/backend/internal/features/backups/backups/core/physical/service/service_test.go
+++ b/backend/internal/features/backups/backups/core/physical/service/service_test.go
@@ -41,17 +41,17 @@ func createServiceTestPrereqs(t *testing.T) *serviceTestPrereqs {
workspaces_controllers.GetMembershipController(),
databases.GetDatabaseController(),
)
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Phys Service "+uuid.NewString(), user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Phys Service "+uuid.NewString(), user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestPhysicalPostgresDatabase(workspace.ID, notifier, "17")
t.Cleanup(func() {
physical_testing.DeleteAllPhysicalCatalogForDatabase(t, database.ID)
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
})
return &serviceTestPrereqs{storage: storage, database: database}
diff --git a/backend/internal/features/backups/backups/download/download_token/background.go b/backend/internal/features/backups/backups/download/download_token/background.go
index 3df27926..c3fb711c 100644
--- a/backend/internal/features/backups/backups/download/download_token/background.go
+++ b/backend/internal/features/backups/backups/download/download_token/background.go
@@ -6,8 +6,12 @@ import (
"log/slog"
"sync/atomic"
"time"
+
+ "github.com/google/uuid"
)
+const jobName = "download_token_cleanup"
+
type BackgroundService struct {
downloadTokenService *Service
logger *slog.Logger
@@ -27,7 +31,9 @@ func (s *BackgroundService) Run(ctx context.Context) {
panic(fmt.Sprintf("%T.Run() called multiple times", s))
}
- s.logger.Info("Starting download token cleanup background service")
+ lifecycleLogger := s.logger.With("job_name", jobName)
+
+ lifecycleLogger.InfoContext(ctx, "download token cleanup started")
if ctx.Err() != nil {
return
@@ -39,11 +45,20 @@ func (s *BackgroundService) Run(ctx context.Context) {
for {
select {
case <-ctx.Done():
+ lifecycleLogger.InfoContext(ctx, "download token cleanup stopped")
+
return
case <-ticker.C:
- if err := s.downloadTokenService.CleanExpiredTokens(); err != nil {
- s.logger.Error("Failed to clean expired download tokens", "error", err)
+ logger := s.logger.With("job_id", uuid.New(), "job_name", jobName)
+
+ deletedCount, err := s.downloadTokenService.CleanExpiredTokens(ctx)
+ if err != nil {
+ logger.ErrorContext(ctx, "failed to clean expired download tokens", "error", err)
+
+ continue
}
+
+ logger.DebugContext(ctx, fmt.Sprintf("deleted %d expired download tokens", deletedCount))
}
}
}
diff --git a/backend/internal/features/backups/backups/download/download_token/repository.go b/backend/internal/features/backups/backups/download/download_token/repository.go
index ab57c1cb..214ec372 100644
--- a/backend/internal/features/backups/backups/download/download_token/repository.go
+++ b/backend/internal/features/backups/backups/download/download_token/repository.go
@@ -1,6 +1,7 @@
package download_token
import (
+ "context"
"errors"
"time"
@@ -22,10 +23,10 @@ func (r *Repository) Create(token *Token) error {
return storage.GetDb().Create(token).Error
}
-func (r *Repository) FindByToken(token string) (*Token, error) {
+func (r *Repository) FindByToken(ctx context.Context, token string) (*Token, error) {
var downloadToken Token
- err := storage.GetDb().
+ err := storage.GetDb().WithContext(ctx).
Where("token = ?", token).
First(&downloadToken).Error
if err != nil {
@@ -42,8 +43,11 @@ func (r *Repository) Update(token *Token) error {
return storage.GetDb().Save(token).Error
}
-func (r *Repository) DeleteExpired(before time.Time) error {
- return storage.GetDb().
+func (r *Repository) DeleteExpired(ctx context.Context, before time.Time) (int64, error) {
+ result := storage.GetDb().
+ WithContext(ctx).
Where("expires_at < ?", before).
- Delete(&Token{}).Error
+ Delete(&Token{})
+
+ return result.RowsAffected, result.Error
}
diff --git a/backend/internal/features/backups/backups/download/download_token/service.go b/backend/internal/features/backups/backups/download/download_token/service.go
index 8b3f7350..ce555adb 100644
--- a/backend/internal/features/backups/backups/download/download_token/service.go
+++ b/backend/internal/features/backups/backups/download/download_token/service.go
@@ -1,6 +1,7 @@
package download_token
import (
+ "context"
"errors"
"log/slog"
"time"
@@ -28,7 +29,7 @@ func NewService(guard *stream_guard.Guard, logger *slog.Logger) *Service {
}
}
-func (s *Service) Generate(backupID, userID uuid.UUID) (string, error) {
+func (s *Service) Generate(ctx context.Context, backupID, userID uuid.UUID) (string, error) {
if s.IsDownloadInProgress(userID) {
return "", stream_guard.ErrDownloadAlreadyInProgress
}
@@ -47,48 +48,58 @@ func (s *Service) Generate(backupID, userID uuid.UUID) (string, error) {
return "", err
}
- s.logger.Info("Generated download token", "backupId", backupID, "userId", userID)
+ s.logger.InfoContext(ctx, "generated download token", "backup_id", backupID, "user_id", userID)
+
return token, nil
}
func (s *Service) ValidateAndConsume(
+ ctx context.Context,
token string,
) (*Token, error) {
- dt, err := s.repository.FindByToken(token)
+ downloadToken, err := s.repository.FindByToken(ctx, token)
if err != nil {
return nil, err
}
- if dt == nil {
+ if downloadToken == nil {
return nil, errors.New("invalid token")
}
- if dt.Used {
+ if downloadToken.Used {
return nil, errors.New("token already used")
}
- if time.Now().UTC().After(dt.ExpiresAt) {
+ if time.Now().UTC().After(downloadToken.ExpiresAt) {
return nil, errors.New("token expired")
}
- if err := s.AcquireSlot(dt.UserID); err != nil {
+ if err := s.AcquireSlot(downloadToken.UserID); err != nil {
return nil, err
}
- dt.Used = true
- if err := s.repository.Update(dt); err != nil {
- s.logger.Error("Failed to mark token as used", "error", err)
+ downloadToken.Used = true
+ if err := s.repository.Update(downloadToken); err != nil {
+ s.logger.ErrorContext(ctx, "failed to mark token as used", "error", err)
}
- s.logger.Info("Token validated and consumed", "backupId", dt.BackupID, "userId", dt.UserID)
- return dt, nil
+ s.logger.InfoContext(
+ ctx,
+ "download token validated and consumed",
+ "backup_id",
+ downloadToken.BackupID,
+ "user_id",
+ downloadToken.UserID,
+ )
+
+ return downloadToken, nil
}
-func (s *Service) CleanExpiredTokens() error {
- if err := s.repository.DeleteExpired(time.Now().UTC()); err != nil {
- return err
+func (s *Service) CleanExpiredTokens(ctx context.Context) (int64, error) {
+ deletedCount, err := s.repository.DeleteExpired(ctx, time.Now().UTC())
+ if err != nil {
+ return 0, err
}
- s.logger.Debug("Cleaned expired download tokens")
- return nil
+ return deletedCount, nil
}
diff --git a/backend/internal/features/backups/backups/download/restore_stream/writer.go b/backend/internal/features/backups/backups/download/restore_stream/writer.go
index 28cee7b7..8b2676f4 100644
--- a/backend/internal/features/backups/backups/download/restore_stream/writer.go
+++ b/backend/internal/features/backups/backups/download/restore_stream/writer.go
@@ -134,7 +134,7 @@ func (rw *Writer) writeBackupDir(
return fmt.Errorf("backup %s has no reconstructed manifest sidecar", artifact.RowID)
}
- store, err := rw.resolveStorage(artifact.StorageID, storageCache)
+ store, err := rw.resolveStorage(ctx, artifact.StorageID, storageCache)
if err != nil {
return err
}
@@ -181,7 +181,7 @@ func (rw *Writer) writeManifest(
storageCache map[uuid.UUID]*storages.Storage,
checksums *checksumLedger,
) error {
- store, err := rw.resolveStorage(artifact.StorageID, storageCache)
+ store, err := rw.resolveStorage(ctx, artifact.StorageID, storageCache)
if err != nil {
return err
}
@@ -222,7 +222,7 @@ func (rw *Writer) writeWalSegment(
return fmt.Errorf("wal segment %s has no stored file", segment.WalFilename)
}
- store, err := rw.resolveStorage(segment.StorageID, storageCache)
+ store, err := rw.resolveStorage(ctx, segment.StorageID, storageCache)
if err != nil {
return err
}
@@ -263,7 +263,7 @@ func (rw *Writer) writeHistoryFile(
storageCache map[uuid.UUID]*storages.Storage,
checksums *checksumLedger,
) error {
- store, err := rw.resolveStorage(history.StorageID, storageCache)
+ store, err := rw.resolveStorage(ctx, history.StorageID, storageCache)
if err != nil {
return err
}
@@ -306,6 +306,7 @@ func (rw *Writer) writeHistoryFile(
}
func (rw *Writer) resolveStorage(
+ ctx context.Context,
storageID uuid.UUID,
storageCache map[uuid.UUID]*storages.Storage,
) (*storages.Storage, error) {
@@ -313,7 +314,7 @@ func (rw *Writer) resolveStorage(
return cached, nil
}
- store, err := rw.storageService.GetStorageByID(storageID)
+ store, err := rw.storageService.GetStorageByID(ctx, storageID)
if err != nil {
return nil, fmt.Errorf("load storage %s: %w", storageID, err)
}
diff --git a/backend/internal/features/backups/backups/download/restore_stream/writer_test.go b/backend/internal/features/backups/backups/download/restore_stream/writer_test.go
index 823d2d4c..4c53c6c1 100644
--- a/backend/internal/features/backups/backups/download/restore_stream/writer_test.go
+++ b/backend/internal/features/backups/backups/download/restore_stream/writer_test.go
@@ -112,11 +112,16 @@ func createTestStorage(t *testing.T) *storages.Storage {
workspaces_controllers.GetWorkspaceController(),
workspaces_controllers.GetMembershipController(),
)
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Restore Stream Test "+uuid.NewString(), user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(
+ t.Context(),
+ "Restore Stream Test "+uuid.NewString(),
+ user,
+ router,
+ )
storage := storages.CreateTestStorage(workspace.ID)
- t.Cleanup(func() { storages.RemoveTestStorage(storage.ID) })
+ t.Cleanup(func() { storages.RemoveTestStorage(t.Context(), storage.ID) })
return storage
}
@@ -134,7 +139,7 @@ func saveFile(
err := storage.SaveFile(ctx, encryptor, logger.GetLogger(), name, bytes.NewReader(body))
require.NoError(t, err)
- t.Cleanup(func() { _ = storage.DeleteFile(encryptor, name) })
+ t.Cleanup(func() { _ = storage.DeleteFile(t.Context(), encryptor, logger.GetLogger(), name) })
}
func buildTarZst(t *testing.T, files map[string]string) []byte {
diff --git a/backend/internal/features/backups/backups/download/restore_token/service.go b/backend/internal/features/backups/backups/download/restore_token/service.go
index 21edabbd..8a260d92 100644
--- a/backend/internal/features/backups/backups/download/restore_token/service.go
+++ b/backend/internal/features/backups/backups/download/restore_token/service.go
@@ -1,6 +1,7 @@
package restore_token
import (
+ "context"
"errors"
"log/slog"
"time"
@@ -32,6 +33,7 @@ func NewService(guard *stream_guard.Guard, client valkey.Client, logger *slog.Lo
// GenerateRestoreToken issues a single-use, short-TTL token authorizing a
// physical restore stream of databaseID to targetTime (nil ⇒ latest).
func (s *Service) GenerateRestoreToken(
+ ctx context.Context,
databaseID, userID uuid.UUID,
targetTime *time.Time,
) (string, error) {
@@ -47,7 +49,7 @@ func (s *Service) GenerateRestoreToken(
TargetTime: targetTime,
})
- s.logger.Info("generated restore token", "database_id", databaseID, "user_id", userID)
+ s.logger.InfoContext(ctx, "generated restore token", "database_id", databaseID, "user_id", userID)
return token, nil
}
@@ -56,6 +58,7 @@ func (s *Service) GenerateRestoreToken(
// per-backup restore stream (the FULL plus its incremental ancestors, no WAL)
// of backupID within databaseID.
func (s *Service) GenerateBackupRestoreToken(
+ ctx context.Context,
databaseID, userID, backupID uuid.UUID,
) (string, error) {
if s.IsDownloadInProgress(userID) {
@@ -70,7 +73,7 @@ func (s *Service) GenerateBackupRestoreToken(
BackupID: &backupID,
})
- s.logger.Info("generated backup restore token",
+ s.logger.InfoContext(ctx, "generated backup restore token",
"database_id", databaseID, "user_id", userID, "backup_id", backupID)
return token, nil
@@ -87,6 +90,7 @@ func (s *Service) GenerateBackupRestoreToken(
// and burning the token beats a validate-then-consume window that two requests
// could both pass.
func (s *Service) ValidateAndConsumeRestoreToken(
+ ctx context.Context,
token string,
) (*Token, error) {
restoreToken := s.store.consume(token)
@@ -98,7 +102,7 @@ func (s *Service) ValidateAndConsumeRestoreToken(
return nil, err
}
- s.logger.Info("restore token validated and consumed",
+ s.logger.InfoContext(ctx, "restore token validated and consumed",
"database_id", restoreToken.DatabaseID, "user_id", restoreToken.UserID)
return restoreToken, nil
diff --git a/backend/internal/features/backups/backups/download/stream_guard/guard.go b/backend/internal/features/backups/backups/download/stream_guard/guard.go
index 33901c28..f8f81d93 100644
--- a/backend/internal/features/backups/backups/download/stream_guard/guard.go
+++ b/backend/internal/features/backups/backups/download/stream_guard/guard.go
@@ -1,6 +1,7 @@
package stream_guard
import (
+ "context"
"log/slog"
"github.com/google/uuid"
@@ -26,13 +27,13 @@ func (g *Guard) IsDownloadInProgress(userID uuid.UUID) bool {
return g.tracker.IsDownloadInProgress(userID)
}
-func (g *Guard) RefreshDownloadLock(userID uuid.UUID) {
- g.tracker.RefreshDownloadLock(userID)
+func (g *Guard) RefreshDownloadLock(ctx context.Context, userID uuid.UUID) {
+ g.tracker.RefreshDownloadLock(ctx, userID)
}
-func (g *Guard) ReleaseDownloadLock(userID uuid.UUID) {
- g.tracker.ReleaseDownloadLock(userID)
- g.logger.Info("released stream lock", "user_id", userID)
+func (g *Guard) ReleaseDownloadLock(ctx context.Context, userID uuid.UUID) {
+ g.tracker.ReleaseDownloadLock(ctx, userID)
+ g.logger.InfoContext(ctx, "released stream lock", "user_id", userID)
}
// AcquireSlot takes the per-user single-stream lock.
diff --git a/backend/internal/features/backups/backups/download/stream_guard/tracker.go b/backend/internal/features/backups/backups/download/stream_guard/tracker.go
index 09826393..1ed4e28f 100644
--- a/backend/internal/features/backups/backups/download/stream_guard/tracker.go
+++ b/backend/internal/features/backups/backups/download/stream_guard/tracker.go
@@ -1,6 +1,7 @@
package stream_guard
import (
+ "context"
"time"
"github.com/google/uuid"
@@ -44,13 +45,13 @@ func (t *Tracker) AcquireDownloadLock(userID uuid.UUID) error {
return nil
}
-func (t *Tracker) RefreshDownloadLock(userID uuid.UUID) {
+func (t *Tracker) RefreshDownloadLock(ctx context.Context, userID uuid.UUID) {
key := userID.String()
value := downloadLockValue
t.cache.SetWithExpiration(key, &value, downloadLockTTL)
}
-func (t *Tracker) ReleaseDownloadLock(userID uuid.UUID) {
+func (t *Tracker) ReleaseDownloadLock(ctx context.Context, userID uuid.UUID) {
key := userID.String()
t.cache.Invalidate(key)
}
diff --git a/backend/internal/features/backups/backups/services/logical_service.go b/backend/internal/features/backups/backups/services/logical_service.go
index 85a128f1..9fd9ef2c 100644
--- a/backend/internal/features/backups/backups/services/logical_service.go
+++ b/backend/internal/features/backups/backups/services/logical_service.go
@@ -12,6 +12,7 @@ import (
"github.com/google/uuid"
audit_logs "databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
backuping_logical "databasus-backend/internal/features/backups/backups/backuping/logical"
backups_core_enums "databasus-backend/internal/features/backups/backups/core/enums"
backups_core_logical "databasus-backend/internal/features/backups/backups/core/logical"
@@ -71,8 +72,8 @@ func (s *LogicalBackupService) GetLatestCompletedBackup(
return s.backupRepository.FindLatestCompleted(databaseID)
}
-func (s *LogicalBackupService) OnBeforeBackupsStorageChange(databaseID uuid.UUID) error {
- err := s.deleteDbBackups(databaseID)
+func (s *LogicalBackupService) OnBeforeBackupsStorageChange(ctx context.Context, databaseID uuid.UUID) error {
+ err := s.deleteDbBackups(ctx, databaseID)
if err != nil {
return err
}
@@ -80,8 +81,8 @@ func (s *LogicalBackupService) OnBeforeBackupsStorageChange(databaseID uuid.UUID
return nil
}
-func (s *LogicalBackupService) OnBeforeDatabaseRemove(databaseID uuid.UUID) error {
- err := s.deleteDbBackups(databaseID)
+func (s *LogicalBackupService) OnBeforeDatabaseRemove(ctx context.Context, databaseID uuid.UUID) error {
+ err := s.deleteDbBackups(ctx, databaseID)
if err != nil {
return err
}
@@ -90,6 +91,7 @@ func (s *LogicalBackupService) OnBeforeDatabaseRemove(databaseID uuid.UUID) erro
}
func (s *LogicalBackupService) MakeBackupWithAuth(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
) error {
@@ -102,7 +104,7 @@ func (s *LogicalBackupService) MakeBackupWithAuth(
return errors.New("cannot create backup for database without workspace")
}
- canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(*database.WorkspaceID, user)
+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, *database.WorkspaceID, user)
if err != nil {
return err
}
@@ -110,18 +112,19 @@ func (s *LogicalBackupService) MakeBackupWithAuth(
return errors.New("insufficient permissions to create backup for this database")
}
- s.backupSchedulerService.StartBackup(database, true)
+ s.backupSchedulerService.StartBackup(ctx, database, true)
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Backup manually initiated for database: %s", database.Name),
- &user.ID,
- database.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Backup manually initiated for database: %s", database.Name),
+ UserID: &user.ID,
+ WorkspaceID: database.WorkspaceID,
+ })
return nil
}
func (s *LogicalBackupService) GetBackups(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
limit, offset int,
@@ -136,7 +139,7 @@ func (s *LogicalBackupService) GetBackups(
return nil, errors.New("cannot get backups for database without workspace")
}
- canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(*database.WorkspaceID, user)
+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, *database.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -172,6 +175,7 @@ func (s *LogicalBackupService) GetBackups(
}
func (s *LogicalBackupService) DeleteBackup(
+ ctx context.Context,
user *users_models.User,
backupID uuid.UUID,
) error {
@@ -189,7 +193,7 @@ func (s *LogicalBackupService) DeleteBackup(
return errors.New("cannot delete backup for database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return err
}
@@ -201,13 +205,13 @@ func (s *LogicalBackupService) DeleteBackup(
return errors.New("backup is in progress")
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Backup deleted for database: %s", database.Name),
- &user.ID,
- database.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Backup deleted for database: %s", database.Name),
+ UserID: &user.ID,
+ WorkspaceID: database.WorkspaceID,
+ })
- return s.backupCleaner.DeleteBackup(backup)
+ return s.backupCleaner.DeleteBackup(ctx, backup)
}
func (s *LogicalBackupService) GetBackup(backupID uuid.UUID) (*backups_core_logical.LogicalBackup, error) {
@@ -222,6 +226,7 @@ func (s *LogicalBackupService) SetRestoreVerificationStatus(
}
func (s *LogicalBackupService) CancelBackup(
+ ctx context.Context,
user *users_models.User,
backupID uuid.UUID,
) error {
@@ -239,7 +244,7 @@ func (s *LogicalBackupService) CancelBackup(
return errors.New("cannot cancel backup for database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return err
}
@@ -255,11 +260,11 @@ func (s *LogicalBackupService) CancelBackup(
return err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Backup cancelled for database: %s", database.Name),
- &user.ID,
- database.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Backup cancelled for database: %s", database.Name),
+ UserID: &user.ID,
+ WorkspaceID: database.WorkspaceID,
+ })
return nil
}
@@ -275,7 +280,7 @@ func (s *LogicalBackupService) GetBackupReader(
return nil, fmt.Errorf("failed to find backup: %w", err)
}
- storage, err := s.storageService.GetStorageByID(backup.StorageID)
+ storage, err := s.storageService.GetStorageByID(ctx, backup.StorageID)
if err != nil {
return nil, fmt.Errorf("failed to get storage: %w", err)
}
@@ -286,20 +291,20 @@ func (s *LogicalBackupService) GetBackupReader(
}
if backup.Encryption == backups_core_enums.BackupEncryptionNone {
- logger.Info("returning non-encrypted backup")
+ logger.InfoContext(ctx, "returning non-encrypted backup")
return fileReader, nil
}
if backup.Encryption != backups_core_enums.BackupEncryptionEncrypted {
if err := fileReader.Close(); err != nil {
- logger.Error("failed to close file reader", "error", err)
+ logger.ErrorContext(ctx, "failed to close file reader", "error", err)
}
return nil, fmt.Errorf("unsupported encryption type: %s", backup.Encryption)
}
if backup.EncryptionSalt == nil || backup.EncryptionIV == nil {
if err := fileReader.Close(); err != nil {
- logger.Error("failed to close file reader", "error", err)
+ logger.ErrorContext(ctx, "failed to close file reader", "error", err)
}
return nil, fmt.Errorf("backup marked as encrypted but missing encryption metadata")
}
@@ -307,7 +312,7 @@ func (s *LogicalBackupService) GetBackupReader(
masterKey, err := s.secretKeyService.GetSecretKey()
if err != nil {
if closeErr := fileReader.Close(); closeErr != nil {
- logger.Error("failed to close file reader", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close file reader", "error", closeErr)
}
return nil, fmt.Errorf("failed to get master key: %w", err)
}
@@ -315,7 +320,7 @@ func (s *LogicalBackupService) GetBackupReader(
salt, err := base64.StdEncoding.DecodeString(*backup.EncryptionSalt)
if err != nil {
if closeErr := fileReader.Close(); closeErr != nil {
- logger.Error("failed to close file reader", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close file reader", "error", closeErr)
}
return nil, fmt.Errorf("failed to decode salt: %w", err)
}
@@ -323,7 +328,7 @@ func (s *LogicalBackupService) GetBackupReader(
iv, err := base64.StdEncoding.DecodeString(*backup.EncryptionIV)
if err != nil {
if closeErr := fileReader.Close(); closeErr != nil {
- logger.Error("failed to close file reader", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close file reader", "error", closeErr)
}
return nil, fmt.Errorf("failed to decode IV: %w", err)
}
@@ -337,12 +342,12 @@ func (s *LogicalBackupService) GetBackupReader(
)
if err != nil {
if closeErr := fileReader.Close(); closeErr != nil {
- logger.Error("failed to close file reader", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close file reader", "error", closeErr)
}
return nil, fmt.Errorf("failed to create decrypting reader: %w", err)
}
- logger.Info("returning encrypted backup with decryption")
+ logger.InfoContext(ctx, "returning encrypted backup with decryption")
return &backups_dto_logical.DecryptionReaderCloser{
DecryptionReader: decryptionReader,
@@ -351,6 +356,7 @@ func (s *LogicalBackupService) GetBackupReader(
}
func (s *LogicalBackupService) GenerateDownloadToken(
+ ctx context.Context,
user *users_models.User,
backupID uuid.UUID,
) (*download_token.GenerateTokenResponse, error) {
@@ -368,7 +374,7 @@ func (s *LogicalBackupService) GenerateDownloadToken(
return nil, errors.New("cannot download backup for database without workspace")
}
- canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(*database.WorkspaceID, user)
+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, *database.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -376,18 +382,18 @@ func (s *LogicalBackupService) GenerateDownloadToken(
return nil, errors.New("insufficient permissions to download backup for this database")
}
- token, err := s.downloadTokenService.Generate(backupID, user.ID)
+ token, err := s.downloadTokenService.Generate(ctx, backupID, user.ID)
if err != nil {
return nil, err
}
filename := s.generateBackupFilename(backup, database)
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Download token generated for backup of database: %s", database.Name),
- &user.ID,
- database.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Download token generated for backup of database: %s", database.Name),
+ UserID: &user.ID,
+ WorkspaceID: database.WorkspaceID,
+ })
return &download_token.GenerateTokenResponse{
Token: token,
@@ -397,9 +403,10 @@ func (s *LogicalBackupService) GenerateDownloadToken(
}
func (s *LogicalBackupService) ValidateDownloadToken(
+ ctx context.Context,
token string,
) (*download_token.Token, error) {
- return s.downloadTokenService.ValidateAndConsume(token)
+ return s.downloadTokenService.ValidateAndConsume(ctx, token)
}
func (s *LogicalBackupService) GetLatestVerifiableBackup(
@@ -431,30 +438,31 @@ func (s *LogicalBackupService) GetBackupFileWithoutAuth(
}
func (s *LogicalBackupService) WriteAuditLogForDownload(
+ ctx context.Context,
userID uuid.UUID,
backup *backups_core_logical.LogicalBackup,
database *databases.Database,
) {
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Backup file downloaded for database: %s", database.Name),
- &userID,
- database.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Backup file downloaded for database: %s", database.Name),
+ UserID: &userID,
+ WorkspaceID: database.WorkspaceID,
+ })
}
-func (s *LogicalBackupService) RefreshDownloadLock(userID uuid.UUID) {
- s.downloadTokenService.RefreshDownloadLock(userID)
+func (s *LogicalBackupService) RefreshDownloadLock(ctx context.Context, userID uuid.UUID) {
+ s.downloadTokenService.RefreshDownloadLock(ctx, userID)
}
-func (s *LogicalBackupService) ReleaseDownloadLock(userID uuid.UUID) {
- s.downloadTokenService.ReleaseDownloadLock(userID)
+func (s *LogicalBackupService) ReleaseDownloadLock(ctx context.Context, userID uuid.UUID) {
+ s.downloadTokenService.ReleaseDownloadLock(ctx, userID)
}
func (s *LogicalBackupService) IsDownloadInProgress(userID uuid.UUID) bool {
return s.downloadTokenService.IsDownloadInProgress(userID)
}
-func (s *LogicalBackupService) deleteDbBackups(databaseID uuid.UUID) error {
+func (s *LogicalBackupService) deleteDbBackups(ctx context.Context, databaseID uuid.UUID) error {
dbBackupsInProgress, err := s.backupRepository.FindByDatabaseIdAndStatus(
databaseID,
backups_core_logical.BackupStatusInProgress,
@@ -475,7 +483,7 @@ func (s *LogicalBackupService) deleteDbBackups(databaseID uuid.UUID) error {
}
for _, dbBackup := range dbBackups {
- err := s.backupCleaner.DeleteBackup(dbBackup)
+ err := s.backupCleaner.DeleteBackup(ctx, dbBackup)
if err != nil {
return err
}
diff --git a/backend/internal/features/backups/backups/services/physical_service.go b/backend/internal/features/backups/backups/services/physical_service.go
index d9438002..77300433 100644
--- a/backend/internal/features/backups/backups/services/physical_service.go
+++ b/backend/internal/features/backups/backups/services/physical_service.go
@@ -11,6 +11,7 @@ import (
"github.com/google/uuid"
audit_logs "databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
backuping_physical "databasus-backend/internal/features/backups/backups/backuping/physical"
backups_core_enums "databasus-backend/internal/features/backups/backups/core/enums"
"databasus-backend/internal/features/backups/backups/core/physical/chain_view"
@@ -71,11 +72,12 @@ type PhysicalBackupService struct {
// SQL so a database with many WAL segments never loads its whole catalog. The
// aggregate on-disk usage rides along so the UI need not sum it.
func (s *PhysicalBackupService) GetBackups(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
request *backups_dto_physical.GetPhysicalBackupsRequest,
) (*backups_dto_physical.GetPhysicalBackupsResponse, error) {
- if _, err := s.databaseService.GetDatabase(user, databaseID); err != nil {
+ if _, err := s.databaseService.GetDatabase(ctx, user, databaseID); err != nil {
return nil, err
}
@@ -115,8 +117,12 @@ func (s *PhysicalBackupService) GetBackups(
// RequestBackup triggers the backup the scheduler would naturally pick next:
// an incremental when incrementals are enabled and an extendable chain exists,
// otherwise a full.
-func (s *PhysicalBackupService) RequestBackup(user *users_models.User, databaseID uuid.UUID) error {
- database, err := s.authorizeManage(user, databaseID)
+func (s *PhysicalBackupService) RequestBackup(
+ ctx context.Context,
+ user *users_models.User,
+ databaseID uuid.UUID,
+) error {
+ database, err := s.authorizeManage(ctx, user, databaseID)
if err != nil {
return err
}
@@ -130,14 +136,18 @@ func (s *PhysicalBackupService) RequestBackup(user *users_models.User, databaseI
return err
}
- s.writeBackupAuditLog(user, database,
+ s.writeBackupAuditLog(ctx, user, database,
fmt.Sprintf("Physical backup requested for database: %s", database.Name))
return nil
}
-func (s *PhysicalBackupService) RequestFullBackup(user *users_models.User, databaseID uuid.UUID) error {
- database, err := s.authorizeManage(user, databaseID)
+func (s *PhysicalBackupService) RequestFullBackup(
+ ctx context.Context,
+ user *users_models.User,
+ databaseID uuid.UUID,
+) error {
+ database, err := s.authorizeManage(ctx, user, databaseID)
if err != nil {
return err
}
@@ -146,14 +156,18 @@ func (s *PhysicalBackupService) RequestFullBackup(user *users_models.User, datab
return err
}
- s.writeBackupAuditLog(user, database,
+ s.writeBackupAuditLog(ctx, user, database,
fmt.Sprintf("Physical full backup requested for database: %s", database.Name))
return nil
}
-func (s *PhysicalBackupService) RequestIncrementalBackup(user *users_models.User, databaseID uuid.UUID) error {
- database, err := s.authorizeManage(user, databaseID)
+func (s *PhysicalBackupService) RequestIncrementalBackup(
+ ctx context.Context,
+ user *users_models.User,
+ databaseID uuid.UUID,
+) error {
+ database, err := s.authorizeManage(ctx, user, databaseID)
if err != nil {
return err
}
@@ -171,7 +185,7 @@ func (s *PhysicalBackupService) RequestIncrementalBackup(user *users_models.User
return err
}
- s.writeBackupAuditLog(user, database,
+ s.writeBackupAuditLog(ctx, user, database,
fmt.Sprintf("Physical incremental backup requested for database: %s", database.Name))
return nil
@@ -180,7 +194,7 @@ func (s *PhysicalBackupService) RequestIncrementalBackup(user *users_models.User
// CancelBackup stops an in-progress FULL or incremental backup: it authorizes
// the caller against the owning database, refuses anything not currently
// running, then cancels the in-flight task and releases its claim.
-func (s *PhysicalBackupService) CancelBackup(user *users_models.User, backupID uuid.UUID) error {
+func (s *PhysicalBackupService) CancelBackup(ctx context.Context, user *users_models.User, backupID uuid.UUID) error {
databaseID, status, found, err := s.resolveBackupDatabaseAndStatus(backupID)
if err != nil {
return err
@@ -189,7 +203,7 @@ func (s *PhysicalBackupService) CancelBackup(user *users_models.User, backupID u
return ErrBackupNotFound
}
- database, err := s.authorizeManage(user, databaseID)
+ database, err := s.authorizeManage(ctx, user, databaseID)
if err != nil {
return err
}
@@ -209,7 +223,7 @@ func (s *PhysicalBackupService) CancelBackup(user *users_models.User, backupID u
return ErrBackupNotInProgress
}
- s.writeBackupAuditLog(user, database,
+ s.writeBackupAuditLog(ctx, user, database,
fmt.Sprintf("Physical backup cancelled for database: %s", database.Name))
return nil
@@ -222,22 +236,22 @@ func (s *PhysicalBackupService) CancelBackup(user *users_models.User, backupID u
// - incremental: that incremental and every incremental descending from it;
// WAL and the FULL are left intact.
// - WAL: that segment and every later segment up to the next FULL/INCR anchor.
-func (s *PhysicalBackupService) DeleteBackup(user *users_models.User, backupID uuid.UUID) error {
+func (s *PhysicalBackupService) DeleteBackup(ctx context.Context, user *users_models.User, backupID uuid.UUID) error {
full, err := s.fullBackupRepository.FindByID(backupID)
if err != nil {
return err
}
if full != nil {
- database, err := s.authorizeManage(user, full.DatabaseID)
+ database, err := s.authorizeManage(ctx, user, full.DatabaseID)
if err != nil {
return err
}
- if err := s.deleteFull(full); err != nil {
+ if err := s.deleteFull(ctx, full); err != nil {
return err
}
- s.writeBackupAuditLog(user, database,
+ s.writeBackupAuditLog(ctx, user, database,
fmt.Sprintf("Physical full backup deleted for database: %s", database.Name))
return nil
@@ -248,16 +262,16 @@ func (s *PhysicalBackupService) DeleteBackup(user *users_models.User, backupID u
return err
}
if incremental != nil {
- database, err := s.authorizeManage(user, incremental.DatabaseID)
+ database, err := s.authorizeManage(ctx, user, incremental.DatabaseID)
if err != nil {
return err
}
- if err := s.deleteIncremental(incremental); err != nil {
+ if err := s.deleteIncremental(ctx, incremental); err != nil {
return err
}
- s.writeBackupAuditLog(user, database,
+ s.writeBackupAuditLog(ctx, user, database,
fmt.Sprintf("Physical incremental backup deleted for database: %s", database.Name))
return nil
@@ -268,16 +282,16 @@ func (s *PhysicalBackupService) DeleteBackup(user *users_models.User, backupID u
return err
}
if walSegment != nil {
- database, err := s.authorizeManage(user, walSegment.DatabaseID)
+ database, err := s.authorizeManage(ctx, user, walSegment.DatabaseID)
if err != nil {
return err
}
- if _, _, err := s.physicalCoreService.DeleteWalSegment(context.Background(), walSegment.ID); err != nil {
+ if _, _, err := s.physicalCoreService.DeleteWalSegment(ctx, walSegment.ID); err != nil {
return err
}
- s.writeBackupAuditLog(user, database,
+ s.writeBackupAuditLog(ctx, user, database,
fmt.Sprintf("Physical WAL segment deleted for database: %s", database.Name))
return nil
@@ -292,11 +306,12 @@ func (s *PhysicalBackupService) DeleteBackup(user *users_models.User, backupID u
// — a WAL gap, no chain, or a target before the earliest full — is reported here
// rather than burning a token that only fails once the user runs the curl.
func (s *PhysicalBackupService) GenerateRestoreToken(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
request *backups_dto_physical.GenerateRestoreTokenRequest,
) (string, error) {
- if _, err := s.databaseService.GetDatabase(user, databaseID); err != nil {
+ if _, err := s.databaseService.GetDatabase(ctx, user, databaseID); err != nil {
return "", err
}
@@ -304,7 +319,7 @@ func (s *PhysicalBackupService) GenerateRestoreToken(
return "", err
}
- return s.restoreTokenService.GenerateRestoreToken(databaseID, user.ID, request.TargetTime)
+ return s.restoreTokenService.GenerateRestoreToken(ctx, databaseID, user.ID, request.TargetTime)
}
// GenerateBackupRestoreToken authorizes the caller and issues a single-use token
@@ -312,6 +327,7 @@ func (s *PhysicalBackupService) GenerateRestoreToken(
// a specific FULL or incremental. It resolves the restore set up front so a
// missing or not-yet-restorable backup is reported here, not mid-stream.
func (s *PhysicalBackupService) GenerateBackupRestoreToken(
+ ctx context.Context,
user *users_models.User,
backupID uuid.UUID,
) (string, error) {
@@ -323,7 +339,7 @@ func (s *PhysicalBackupService) GenerateBackupRestoreToken(
return "", ErrBackupNotFound
}
- if _, err := s.databaseService.GetDatabase(user, databaseID); err != nil {
+ if _, err := s.databaseService.GetDatabase(ctx, user, databaseID); err != nil {
return "", err
}
@@ -331,7 +347,7 @@ func (s *PhysicalBackupService) GenerateBackupRestoreToken(
return "", err
}
- return s.restoreTokenService.GenerateBackupRestoreToken(databaseID, user.ID, backupID)
+ return s.restoreTokenService.GenerateBackupRestoreToken(ctx, databaseID, user.ID, backupID)
}
// Performs NO authorization — callers gate access (the user path via a restore token, restore
@@ -378,7 +394,7 @@ func (s *PhysicalBackupService) writeRestoreStream(
return s.restoreStreamWriter.Write(ctx, w, set, masterKey)
}
-func (s *PhysicalBackupService) deleteFull(full *physical_models.PhysicalFullBackup) error {
+func (s *PhysicalBackupService) deleteFull(ctx context.Context, full *physical_models.PhysicalFullBackup) error {
s.stopInFlightForDelete(full.DatabaseID, func(inFlightBackupID uuid.UUID) bool {
if inFlightBackupID == full.ID {
return true
@@ -395,12 +411,15 @@ func (s *PhysicalBackupService) deleteFull(full *physical_models.PhysicalFullBac
return s.fullBackupRepository.DeleteByID(full.ID)
}
- _, err := s.physicalCoreService.DeleteFullCompletely(context.Background(), full.ID)
+ _, err := s.physicalCoreService.DeleteFullCompletely(ctx, full.ID)
return err
}
-func (s *PhysicalBackupService) deleteIncremental(target *physical_models.PhysicalIncrementalBackup) error {
+func (s *PhysicalBackupService) deleteIncremental(
+ ctx context.Context,
+ target *physical_models.PhysicalIncrementalBackup,
+) error {
s.stopInFlightForDelete(target.DatabaseID, func(inFlightBackupID uuid.UUID) bool {
if inFlightBackupID == target.ID {
return true
@@ -417,7 +436,7 @@ func (s *PhysicalBackupService) deleteIncremental(target *physical_models.Physic
*claimed.StartLSN >= *target.StartLSN
})
- _, err := s.physicalCoreService.DeleteIncrementalCascade(context.Background(), target.ID)
+ _, err := s.physicalCoreService.DeleteIncrementalCascade(ctx, target.ID)
return err
}
@@ -475,10 +494,11 @@ func (s *PhysicalBackupService) requestSchedulerChoice(
// state-changing physical-backup operation — trigger, cancel, delete — matching
// the logical backup service.
func (s *PhysicalBackupService) authorizeManage(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
) (*databases.Database, error) {
- database, err := s.databaseService.GetDatabase(user, databaseID)
+ database, err := s.databaseService.GetDatabase(ctx, user, databaseID)
if err != nil {
return nil, err
}
@@ -487,7 +507,7 @@ func (s *PhysicalBackupService) authorizeManage(
return nil, errors.New("cannot manage backups for a database without a workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -502,11 +522,16 @@ func (s *PhysicalBackupService) authorizeManage(
// writeBackupAuditLog records a workspace audit entry for a state-changing
// physical-backup operation, attributing it to the acting user.
func (s *PhysicalBackupService) writeBackupAuditLog(
+ ctx context.Context,
user *users_models.User,
database *databases.Database,
message string,
) {
- s.auditLogService.WriteAuditLog(message, &user.ID, database.WorkspaceID)
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: message,
+ UserID: &user.ID,
+ WorkspaceID: database.WorkspaceID,
+ })
}
// resolveBackupDatabaseAndStatus probes the FULL then incremental tables for a
diff --git a/backend/internal/features/backups/backups/usecases/logical/mariadb/compression_probe.go b/backend/internal/features/backups/backups/usecases/logical/mariadb/compression_probe.go
index d7c57320..425aafb6 100644
--- a/backend/internal/features/backups/backups/usecases/logical/mariadb/compression_probe.go
+++ b/backend/internal/features/backups/backups/usecases/logical/mariadb/compression_probe.go
@@ -65,7 +65,8 @@ func (uc *CreateMariadbBackupUsecase) probeNetworkCompressionArgs(
}
}
- uc.logger.Info(
+ uc.logger.InfoContext(
+ ctx,
fmt.Sprintf("negotiated MariaDB network compression: %s",
getNetworkCompressionLabel(chosenCompressionArgs)),
"database_id", probe.DatabaseID,
@@ -108,7 +109,8 @@ func (uc *CreateMariadbBackupUsecase) isNetworkCompressionAccepted(
)
if err := cmd.Run(); err != nil && isCompressionRejection(probeStderr.String()) {
- uc.logger.Debug(
+ uc.logger.DebugContext(
+ ctx,
fmt.Sprintf("MariaDB rejected network compression: %s",
getNetworkCompressionLabel(candidate)),
"database_id", probe.DatabaseID,
diff --git a/backend/internal/features/backups/backups/usecases/logical/mariadb/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/logical/mariadb/create_backup_uc.go
index bd044a6d..5afeb73c 100644
--- a/backend/internal/features/backups/backups/usecases/logical/mariadb/create_backup_uc.go
+++ b/backend/internal/features/backups/backups/usecases/logical/mariadb/create_backup_uc.go
@@ -74,7 +74,7 @@ func (uc *CreateMariadbBackupUsecase) Execute(
) (*backups_core_logical.BackupMetadata, error) {
logger := uc.logger.With("database_id", db.ID, "storage_id", storage.ID)
- logger.Info("creating mariadb backup via mariadb-dump")
+ logger.InfoContext(ctx, "creating mariadb backup via mariadb-dump")
tunneledDatabase, err := databases.OpenTunnel(ctx, databases.OpenTunnelSpec{
Database: db,
@@ -103,7 +103,7 @@ func (uc *CreateMariadbBackupUsecase) Execute(
rawSizeMB, err := mariadbDatabase.GetRawDbSizeMb(ctx, logger, uc.fieldEncryptor)
if err != nil {
- logger.Warn("failed to fetch raw db size before backup", "error", err)
+ logger.WarnContext(ctx, "failed to fetch raw db size before backup", "error", err)
} else {
backup.BackupRawDbSizeMb = rawSizeMB
}
@@ -178,7 +178,7 @@ func (uc *CreateMariadbBackupUsecase) streamToStorage(
backupProgressListener func(completedMBs float64),
mdbConfig *mariadbtypes.MariadbDatabase,
) (*backups_core_logical.BackupMetadata, error) {
- uc.logger.Info("Streaming MariaDB backup to storage", "mariadbBin", mariadbBin)
+ uc.logger.InfoContext(parentCtx, "streaming MariaDB backup to storage", "mariadb_bin", mariadbBin)
ctx, cancel := uc.createBackupContext(parentCtx)
defer cancel(nil)
@@ -201,7 +201,7 @@ func (uc *CreateMariadbBackupUsecase) streamToStorage(
fullArgs = append(fullArgs, args...)
cmd := exec.CommandContext(ctx, mariadbBin, fullArgs...)
- uc.logger.Info("Executing MariaDB backup command", "command", cmd.String())
+ uc.logger.InfoContext(parentCtx, "executing MariaDB backup command", "command", cmd.String())
cmd.Env = os.Environ()
cmd.Env = append(cmd.Env,
@@ -297,7 +297,7 @@ func (uc *CreateMariadbBackupUsecase) streamToStorage(
}
if err := zstdWriter.Close(); err != nil {
- uc.logger.Error("Failed to close zstd writer", "error", err)
+ uc.logger.ErrorContext(parentCtx, "failed to close zstd writer", "error", err)
}
if err := uc.closeWriters(encryptionWriter, storageWriter); err != nil {
<-saveErrCh
@@ -481,7 +481,7 @@ func (uc *CreateMariadbBackupUsecase) setupBackupEncryption(
if backupConfig.Encryption != backups_core_enums.BackupEncryptionEncrypted {
metadata.Encryption = backups_core_enums.BackupEncryptionNone
- uc.logger.Info("Encryption disabled for backup", "backupId", backupID)
+ uc.logger.Info("encryption disabled for backup", "backup_id", backupID)
return storageWriter, nil, metadata, nil
}
@@ -499,7 +499,7 @@ func (uc *CreateMariadbBackupUsecase) setupBackupEncryption(
metadata.EncryptionIV = &encSetup.NonceBase64
metadata.Encryption = backups_core_enums.BackupEncryptionEncrypted
- uc.logger.Info("Encryption enabled for backup", "backupId", backupID)
+ uc.logger.Info("encryption enabled for backup", "backup_id", backupID)
return encSetup.Writer, encSetup.Writer, metadata, nil
}
@@ -534,7 +534,7 @@ func (uc *CreateMariadbBackupUsecase) cleanupOnCancellation(
}
if err := storageWriter.Close(); err != nil {
- uc.logger.Error("Failed to close pipe writer during cancellation", "error", err)
+ uc.logger.Error("failed to close pipe writer during cancellation", "error", err)
}
<-saveErrCh
@@ -549,7 +549,7 @@ func (uc *CreateMariadbBackupUsecase) closeWriters(
go func() {
closeErr := encryptionWriter.Close()
if closeErr != nil {
- uc.logger.Error("Failed to close encrypting writer", "error", closeErr)
+ uc.logger.Error("failed to close encrypting writer", "error", closeErr)
}
encryptionCloseErrCh <- closeErr
}()
@@ -560,13 +560,13 @@ func (uc *CreateMariadbBackupUsecase) closeWriters(
encryptionCloseErr := <-encryptionCloseErrCh
if encryptionCloseErr != nil {
if err := storageWriter.Close(); err != nil {
- uc.logger.Error("Failed to close pipe writer after encryption error", "error", err)
+ uc.logger.Error("failed to close pipe writer after encryption error", "error", err)
}
return fmt.Errorf("failed to close encryption writer: %w", encryptionCloseErr)
}
if err := storageWriter.Close(); err != nil {
- uc.logger.Error("Failed to close pipe writer", "error", err)
+ uc.logger.Error("failed to close pipe writer", "error", err)
return err
}
diff --git a/backend/internal/features/backups/backups/usecases/logical/mongodb/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/logical/mongodb/create_backup_uc.go
index 89930b1d..b9ab09ed 100644
--- a/backend/internal/features/backups/backups/usecases/logical/mongodb/create_backup_uc.go
+++ b/backend/internal/features/backups/backups/usecases/logical/mongodb/create_backup_uc.go
@@ -60,7 +60,7 @@ func (uc *CreateMongodbBackupUsecase) Execute(
) (*backups_core_logical.BackupMetadata, error) {
logger := uc.logger.With("database_id", db.ID, "storage_id", storage.ID)
- logger.Info("creating mongodb backup via mongodump")
+ logger.InfoContext(ctx, "creating mongodb backup via mongodump")
tunneledDatabase, err := databases.OpenTunnel(ctx, databases.OpenTunnelSpec{
Database: db,
@@ -89,7 +89,7 @@ func (uc *CreateMongodbBackupUsecase) Execute(
rawSizeMB, err := mongodbDatabase.GetRawDbSizeMb(ctx, logger, uc.fieldEncryptor)
if err != nil {
- logger.Warn("failed to fetch raw db size before backup", "error", err)
+ logger.WarnContext(ctx, "failed to fetch raw db size before backup", "error", err)
} else {
backup.BackupRawDbSizeMb = rawSizeMB
}
@@ -142,7 +142,7 @@ func (uc *CreateMongodbBackupUsecase) streamToStorage(
storage *storages.Storage,
backupProgressListener func(completedMBs float64),
) (*backups_core_logical.BackupMetadata, error) {
- uc.logger.Info("Streaming MongoDB backup to storage", "mongodumpBin", mongodumpBin)
+ uc.logger.InfoContext(parentCtx, "streaming MongoDB backup to storage", "mongodump_bin", mongodumpBin)
ctx, cancel := uc.createBackupContext(parentCtx)
defer cancel(nil)
@@ -157,7 +157,7 @@ func (uc *CreateMongodbBackupUsecase) streamToStorage(
safeArgs[i] = arg
}
}
- uc.logger.Info("Executing MongoDB backup command", "command", mongodumpBin, "args", safeArgs)
+ uc.logger.InfoContext(parentCtx, "executing MongoDB backup command", "command", mongodumpBin, "args", safeArgs)
cmd.Env = os.Environ()
cmd.Env = append(cmd.Env,
@@ -420,12 +420,12 @@ func (uc *CreateMongodbBackupUsecase) closeWriters(
) error {
if encryptionWriter != nil {
if err := encryptionWriter.Close(); err != nil {
- uc.logger.Error("Failed to close encryption writer", "error", err)
+ uc.logger.Error("failed to close encryption writer", "error", err)
return fmt.Errorf("failed to close encryption writer: %w", err)
}
}
if err := storageWriter.Close(); err != nil {
- uc.logger.Error("Failed to close storage writer", "error", err)
+ uc.logger.Error("failed to close storage writer", "error", err)
return fmt.Errorf("failed to close storage writer: %w", err)
}
return nil
diff --git a/backend/internal/features/backups/backups/usecases/logical/mysql/compression_probe.go b/backend/internal/features/backups/backups/usecases/logical/mysql/compression_probe.go
index 07f7bc07..9f3bd556 100644
--- a/backend/internal/features/backups/backups/usecases/logical/mysql/compression_probe.go
+++ b/backend/internal/features/backups/backups/usecases/logical/mysql/compression_probe.go
@@ -83,7 +83,8 @@ func (uc *CreateMysqlBackupUsecase) probeNetworkCompressionArgs(
}
}
- uc.logger.Info(
+ uc.logger.InfoContext(
+ ctx,
fmt.Sprintf("negotiated MySQL network compression: %s",
getNetworkCompressionLabel(chosenCompressionArgs)),
"database_id", probe.DatabaseID,
@@ -121,7 +122,8 @@ func (uc *CreateMysqlBackupUsecase) isNetworkCompressionAccepted(
)
if err := cmd.Run(); err != nil && isCompressionRejection(probeStderr.String()) {
- uc.logger.Debug(
+ uc.logger.DebugContext(
+ ctx,
fmt.Sprintf("MySQL rejected network compression: %s",
getNetworkCompressionLabel(candidate)),
"database_id", probe.DatabaseID,
diff --git a/backend/internal/features/backups/backups/usecases/logical/mysql/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/logical/mysql/create_backup_uc.go
index 723fd7f0..6a97b235 100644
--- a/backend/internal/features/backups/backups/usecases/logical/mysql/create_backup_uc.go
+++ b/backend/internal/features/backups/backups/usecases/logical/mysql/create_backup_uc.go
@@ -74,7 +74,7 @@ func (uc *CreateMysqlBackupUsecase) Execute(
) (*backups_core_logical.BackupMetadata, error) {
logger := uc.logger.With("database_id", db.ID, "storage_id", storage.ID)
- logger.Info("creating mysql backup via mysqldump")
+ logger.InfoContext(ctx, "creating mysql backup via mysqldump")
tunneledDatabase, err := databases.OpenTunnel(ctx, databases.OpenTunnelSpec{
Database: db,
@@ -103,7 +103,7 @@ func (uc *CreateMysqlBackupUsecase) Execute(
rawSizeMB, err := mysqlDatabase.GetRawDbSizeMb(ctx, logger, uc.fieldEncryptor)
if err != nil {
- logger.Warn("failed to fetch raw db size before backup", "error", err)
+ logger.WarnContext(ctx, "failed to fetch raw db size before backup", "error", err)
} else {
backup.BackupRawDbSizeMb = rawSizeMB
}
@@ -175,7 +175,7 @@ func (uc *CreateMysqlBackupUsecase) streamToStorage(
backupProgressListener func(completedMBs float64),
myConfig *mysqltypes.MysqlDatabase,
) (*backups_core_logical.BackupMetadata, error) {
- uc.logger.Info("Streaming MySQL backup to storage", "mysqlBin", mysqlBin)
+ uc.logger.InfoContext(parentCtx, "streaming MySQL backup to storage", "mysql_bin", mysqlBin)
ctx, cancel := uc.createBackupContext(parentCtx)
defer cancel(nil)
@@ -197,7 +197,7 @@ func (uc *CreateMysqlBackupUsecase) streamToStorage(
fullArgs = append(fullArgs, args...)
cmd := exec.CommandContext(ctx, mysqlBin, fullArgs...)
- uc.logger.Info("Executing MySQL backup command", "command", cmd.String())
+ uc.logger.InfoContext(parentCtx, "executing MySQL backup command", "command", cmd.String())
cmd.Env = os.Environ()
cmd.Env = append(cmd.Env,
@@ -293,7 +293,7 @@ func (uc *CreateMysqlBackupUsecase) streamToStorage(
}
if err := zstdWriter.Close(); err != nil {
- uc.logger.Error("Failed to close zstd writer", "error", err)
+ uc.logger.ErrorContext(parentCtx, "failed to close zstd writer", "error", err)
}
if err := uc.closeWriters(encryptionWriter, storageWriter); err != nil {
<-saveErrCh
@@ -477,7 +477,7 @@ func (uc *CreateMysqlBackupUsecase) setupBackupEncryption(
if backupConfig.Encryption != backups_core_enums.BackupEncryptionEncrypted {
metadata.Encryption = backups_core_enums.BackupEncryptionNone
- uc.logger.Info("Encryption disabled for backup", "backupId", backupID)
+ uc.logger.Info("encryption disabled for backup", "backup_id", backupID)
return storageWriter, nil, metadata, nil
}
@@ -495,7 +495,7 @@ func (uc *CreateMysqlBackupUsecase) setupBackupEncryption(
metadata.EncryptionIV = &encSetup.NonceBase64
metadata.Encryption = backups_core_enums.BackupEncryptionEncrypted
- uc.logger.Info("Encryption enabled for backup", "backupId", backupID)
+ uc.logger.Info("encryption enabled for backup", "backup_id", backupID)
return encSetup.Writer, encSetup.Writer, metadata, nil
}
@@ -530,7 +530,7 @@ func (uc *CreateMysqlBackupUsecase) cleanupOnCancellation(
}
if err := storageWriter.Close(); err != nil {
- uc.logger.Error("Failed to close pipe writer during cancellation", "error", err)
+ uc.logger.Error("failed to close pipe writer during cancellation", "error", err)
}
<-saveErrCh
@@ -545,7 +545,7 @@ func (uc *CreateMysqlBackupUsecase) closeWriters(
go func() {
closeErr := encryptionWriter.Close()
if closeErr != nil {
- uc.logger.Error("Failed to close encrypting writer", "error", closeErr)
+ uc.logger.Error("failed to close encrypting writer", "error", closeErr)
}
encryptionCloseErrCh <- closeErr
}()
@@ -556,13 +556,13 @@ func (uc *CreateMysqlBackupUsecase) closeWriters(
encryptionCloseErr := <-encryptionCloseErrCh
if encryptionCloseErr != nil {
if err := storageWriter.Close(); err != nil {
- uc.logger.Error("Failed to close pipe writer after encryption error", "error", err)
+ uc.logger.Error("failed to close pipe writer after encryption error", "error", err)
}
return fmt.Errorf("failed to close encryption writer: %w", encryptionCloseErr)
}
if err := storageWriter.Close(); err != nil {
- uc.logger.Error("Failed to close pipe writer", "error", err)
+ uc.logger.Error("failed to close pipe writer", "error", err)
return err
}
diff --git a/backend/internal/features/backups/backups/usecases/logical/postgresql/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/logical/postgresql/create_backup_uc.go
index e11b8db7..97596f54 100644
--- a/backend/internal/features/backups/backups/usecases/logical/postgresql/create_backup_uc.go
+++ b/backend/internal/features/backups/backups/usecases/logical/postgresql/create_backup_uc.go
@@ -70,7 +70,7 @@ func (uc *CreatePostgresqlBackupUsecase) Execute(
) (*backups_core_logical.BackupMetadata, error) {
logger := uc.logger.With("database_id", db.ID, "storage_id", storage.ID, "backup_id", backup.ID)
- logger.Info("creating postgresql backup via pg_dump custom format")
+ logger.InfoContext(ctx, "creating postgresql backup via pg_dump custom format")
if db.PostgresqlLogical == nil {
return nil, fmt.Errorf("postgresql database configuration is required for pg_dump backups")
@@ -103,14 +103,14 @@ func (uc *CreatePostgresqlBackupUsecase) Execute(
rawSizeMB, err := pg.GetRawDbSizeMb(ctx, logger, uc.fieldEncryptor)
if err != nil {
- logger.Warn("failed to fetch raw db size before backup", "error", err)
+ logger.WarnContext(ctx, "failed to fetch raw db size before backup", "error", err)
} else {
backup.BackupRawDbSizeMb = rawSizeMB
}
timescaledbVersion, err := pg.GetTimescaleDBVersion(ctx, uc.fieldEncryptor)
if err != nil {
- logger.Warn("failed to detect timescaledb extension before backup", "error", err)
+ logger.WarnContext(ctx, "failed to detect timescaledb extension before backup", "error", err)
} else {
backup.TimescaledbVersion = timescaledbVersion
}
@@ -140,7 +140,7 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(
db *databases.Database,
backupProgressListener func(completedMBs float64),
) (*backups_core_logical.BackupMetadata, error) {
- uc.logger.Info("Streaming PostgreSQL backup to storage", "pgBin", pgBin, "args", args)
+ uc.logger.InfoContext(parentCtx, "streaming PostgreSQL backup to storage", "pg_bin", pgBin, "args", args)
ctx, cancel := uc.createBackupContext(parentCtx)
defer cancel(nil)
@@ -153,7 +153,7 @@ func (uc *CreatePostgresqlBackupUsecase) streamToStorage(
defer credentials.Remove()
cmd := exec.CommandContext(ctx, pgBin, args...)
- uc.logger.Info("Executing PostgreSQL backup command", "command", cmd.String())
+ uc.logger.InfoContext(parentCtx, "executing PostgreSQL backup command", "command", cmd.String())
if err := uc.setupPgEnvironment(
cmd,
@@ -387,11 +387,11 @@ func (uc *CreatePostgresqlBackupUsecase) getCompressionArgs(
version tools.PostgresqlVersion,
) []string {
if uc.isOlderPostgresVersion(version) {
- uc.logger.Info("Using gzip compression level 5 (zstd not available)", "version", version)
+ uc.logger.Info("using gzip compression level 5 (zstd not available)", "version", version)
return []string{"-Z", strconv.Itoa(compressionLevel)}
}
- uc.logger.Info("Using zstd compression level 5", "version", version)
+ uc.logger.Info("using zstd compression level 5", "version", version)
return []string{fmt.Sprintf("--compress=zstd:%d", compressionLevel)}
}
@@ -448,11 +448,9 @@ func (uc *CreatePostgresqlBackupUsecase) setupPgEnvironment(
cmd.Env = append(cmd.Env, "PGPASSFILE="+credentials.PgpassPath)
cmd.Env = append(cmd.Env, postgresql_shared.GetPgHostAddrEnv(credentialSpec)...)
- uc.logger.Info("Setting up PostgreSQL environment",
- "passwordLength", len(password),
- "passwordEmpty", password == "",
- "pgBin", pgBin,
- "parallelJobs", cpuCount,
+ uc.logger.Info("setting up PostgreSQL environment",
+ "pg_bin", pgBin,
+ "parallel_jobs", cpuCount,
)
cmd.Env = append(cmd.Env,
@@ -474,7 +472,7 @@ func (uc *CreatePostgresqlBackupUsecase) setupPgEnvironment(
"PGSSLROOTCERT="+credentials.RootCertPath,
"PGSSLCRL=",
)
- uc.logger.Info("Using SSL mode", "sslMode", resolvedSslMode)
+ uc.logger.Info("using SSL mode", "ssl_mode", resolvedSslMode)
if _, err := exec.LookPath(pgBin); err != nil {
return fmt.Errorf("PostgreSQL executable not found or not accessible: %s - %w", pgBin, err)
@@ -494,7 +492,7 @@ func (uc *CreatePostgresqlBackupUsecase) setupBackupEncryption(
if backupConfig.Encryption != backups_core_enums.BackupEncryptionEncrypted {
metadata.Encryption = backups_core_enums.BackupEncryptionNone
- uc.logger.Info("Encryption disabled for backup", "backupId", backupID)
+ uc.logger.Info("encryption disabled for backup", "backup_id", backupID)
return storageWriter, nil, metadata, nil
}
@@ -512,7 +510,7 @@ func (uc *CreatePostgresqlBackupUsecase) setupBackupEncryption(
metadata.EncryptionIV = &encSetup.NonceBase64
metadata.Encryption = backups_core_enums.BackupEncryptionEncrypted
- uc.logger.Info("Encryption enabled for backup", "backupId", backupID)
+ uc.logger.Info("encryption enabled for backup", "backup_id", backupID)
return encSetup.Writer, encSetup.Writer, metadata, nil
}
@@ -534,7 +532,7 @@ func (uc *CreatePostgresqlBackupUsecase) cleanupOnCancellation(
}
if err := storageWriter.Close(); err != nil {
- uc.logger.Error("Failed to close pipe writer during cancellation", "error", err)
+ uc.logger.Error("failed to close pipe writer during cancellation", "error", err)
}
<-saveErrCh
@@ -549,7 +547,7 @@ func (uc *CreatePostgresqlBackupUsecase) closeWriters(
go func() {
closeErr := encryptionWriter.Close()
if closeErr != nil {
- uc.logger.Error("Failed to close encrypting writer", "error", closeErr)
+ uc.logger.Error("failed to close encrypting writer", "error", closeErr)
}
encryptionCloseErrCh <- closeErr
}()
@@ -560,13 +558,13 @@ func (uc *CreatePostgresqlBackupUsecase) closeWriters(
encryptionCloseErr := <-encryptionCloseErrCh
if encryptionCloseErr != nil {
if err := storageWriter.Close(); err != nil {
- uc.logger.Error("Failed to close pipe writer after encryption error", "error", err)
+ uc.logger.Error("failed to close pipe writer after encryption error", "error", err)
}
return fmt.Errorf("failed to close encryption writer: %w", encryptionCloseErr)
}
if err := storageWriter.Close(); err != nil {
- uc.logger.Error("Failed to close pipe writer", "error", err)
+ uc.logger.Error("failed to close pipe writer", "error", err)
return err
}
@@ -633,7 +631,7 @@ func (uc *CreatePostgresqlBackupUsecase) handleExitCode1NoStderr(
args []string,
) error {
uc.logger.Error("pg_dump failed with exit status 1 but no stderr output",
- "pgBin", pgBin,
+ "pg_bin", pgBin,
"args", args,
"env_vars", []string{
"PGCLIENTENCODING=UTF8",
@@ -662,9 +660,9 @@ func (uc *CreatePostgresqlBackupUsecase) handleAccessViolation(
pgBin string,
stderrStr string,
) error {
- uc.logger.Error("PostgreSQL tool crashed with access violation",
- "pgBin", pgBin,
- "exitCode", "0xC0000005",
+ uc.logger.Error("postgreSQL tool crashed with access violation",
+ "pg_bin", pgBin,
+ "exit_code", "0xC0000005",
)
return fmt.Errorf(
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/backup_slot.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/backup_slot.go
index 9edca56e..9fd5b56d 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/backup_slot.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/backup_slot.go
@@ -66,18 +66,21 @@ func WithBackupSlot(
return fmt.Errorf("pre-create drop of backup slot %q: %w", slotName, err)
}
- if _, err := conn.Exec(ctx,
+ if _, err := conn.Exec(
+ ctx,
"SELECT pg_create_physical_replication_slot($1, true)",
slotName,
); err != nil {
return fmt.Errorf("create backup slot %q: %w", slotName, err)
}
- logger.Debug("per-backup slot created", "slot_name", slotName)
+ logger.InfoContext(ctx, "per-backup replication slot created", "slot_name", slotName)
defer func() {
// Background context so defer runs even when ctx is cancelled.
if dropErr := dropBackupSlotIfExists(context.Background(), conn, slotName); dropErr == nil {
+ logger.InfoContext(ctx, "per-backup replication slot dropped", "slot_name", slotName)
+
return
}
@@ -85,7 +88,8 @@ func WithBackupSlot(
// source makes those routine. Leaving the slot pins WAL on the source until the next backup
// runs, which on a weekly full is a week of retained segments.
if retryErr := dropBackupSlotOverFreshConn(sourceDB, encryptor, slotName); retryErr != nil {
- logger.Warn(
+ logger.WarnContext(
+ ctx,
"post-backup slot drop failed; will be recovered by next backup or startup cleanup",
"slot_name", slotName,
"error", retryErr,
@@ -114,7 +118,8 @@ func dropBackupSlotOverFreshConn(
}
func dropBackupSlotIfExists(ctx context.Context, conn *pgx.Conn, slotName string) error {
- _, err := conn.Exec(ctx,
+ _, err := conn.Exec(
+ ctx,
`SELECT pg_drop_replication_slot(slot_name)
FROM pg_replication_slots WHERE slot_name = $1`,
slotName,
@@ -230,7 +235,7 @@ func RunStartupCleanup(
skippedCount.Range(func(_, _ any) bool { skipped++; return true })
failureCount.Range(func(_, _ any) bool { failed++; return true })
- logger.Info(fmt.Sprintf(
+ logger.InfoContext(ctx, fmt.Sprintf(
"startup physical backup slot cleanup complete: %d dropped, %d skipped (unreachable), %d failed",
dropped, skipped, failed,
))
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/backup_slot_test.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/backup_slot_test.go
index 7868a970..6bd685ff 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/backup_slot_test.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/backup_slot_test.go
@@ -132,7 +132,7 @@ func Test_BackupSlot_PresentDuringRun_GoneAfterCompleted(t *testing.T) {
go func() {
defer close(backupDone)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
}()
<-backupDone
@@ -167,7 +167,7 @@ func Test_BackupSlot_AbsentWhenTimelineCheckFails_ChainBroken(t *testing.T) {
fixture.DB.PostgresqlPhysical.SystemIdentifier = &wrongSysID
require.NoError(t, storage.GetDb().Save(fixture.DB.PostgresqlPhysical).Error)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
postgresql_executor.WaitForBackupStatus(t, fixture.BackupID, physical_enums.PhysicalBackupTypeFull,
physical_enums.PhysicalBackupStatusChainBroken, nil, 30*time.Second)
@@ -189,7 +189,7 @@ func Test_BackupSlot_OrphanFromPriorCrash_DropIfExistsRecovers(t *testing.T) {
require.True(t, postgresql_executor.SlotExists(t, adminConn, slotName),
"orphan slot must exist before backup starts")
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
postgresql_executor.WaitForBackupStatus(t, fixture.BackupID, physical_enums.PhysicalBackupTypeFull,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
@@ -383,7 +383,7 @@ func Test_BackupSlot_PresentDuringIncrementalRun_GoneAfterFinish(t *testing.T) {
slotName := postgresql_executor.SlotName(fixture.DB.PostgresqlPhysical.ID)
adminConn := postgresql_executor.OpenAdminConn(t, fixture)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
postgresql_executor.WaitForBackupStatus(t, fixture.BackupID, physical_enums.PhysicalBackupTypeFull,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
@@ -412,7 +412,7 @@ func Test_BackupSlot_PresentDuringIncrementalRun_GoneAfterFinish(t *testing.T) {
incrID := postgresql_executor.BuildAndClaimIncremental(t, fixture, nil)
observed := postgresql_executor.RunBackupAndPoll(t, fixture, slotName, func() {
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(incrID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), incrID, false)
})
postgresql_executor.WaitForBackupStatus(t, incrID, physical_enums.PhysicalBackupTypeIncremental,
@@ -439,7 +439,7 @@ func Test_BackupSlot_DroppedAfterFailedIncrementalRun(t *testing.T) {
slotName := postgresql_executor.SlotName(fixture.DB.PostgresqlPhysical.ID)
adminConn := postgresql_executor.OpenAdminConn(t, fixture)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
postgresql_executor.WaitForBackupStatus(t, fixture.BackupID, physical_enums.PhysicalBackupTypeFull,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
@@ -478,7 +478,7 @@ func Test_BackupSlot_DroppedAfterFailedIncrementalRun(t *testing.T) {
incrID := postgresql_executor.BuildAndClaimIncremental(t, fixture, nil)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(incrID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), incrID, false)
incrRow, err := physical_repositories.GetIncrementalBackupRepository().FindByID(incrID)
require.NoError(t, err)
@@ -546,7 +546,7 @@ func Test_BackupSlot_HasExpectedCharacteristics(t *testing.T) {
go func() {
defer close(backupDone)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
}()
<-backupDone
@@ -581,14 +581,14 @@ func Test_BackupSlot_ConcurrentBackupsOnDifferentDBs_NoCollision(t *testing.T) {
go func() {
defer close(doneA)
observedA.Store(postgresql_executor.RunBackupAndPoll(t, fixtureA, slotA, func() {
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixtureA.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixtureA.BackupID, false)
}))
}()
go func() {
defer close(doneB)
observedB.Store(postgresql_executor.RunBackupAndPoll(t, fixtureB, slotB, func() {
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixtureB.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixtureB.BackupID, false)
}))
}()
@@ -667,7 +667,7 @@ func Test_BackupSlot_TwoBackupsInRow_SecondReusesNameOk(t *testing.T) {
slotName := postgresql_executor.SlotName(fixture.DB.PostgresqlPhysical.ID)
adminConn := postgresql_executor.OpenAdminConn(t, fixture)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
postgresql_executor.WaitForBackupStatus(t, fixture.BackupID, physical_enums.PhysicalBackupTypeFull,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
@@ -702,7 +702,7 @@ func Test_BackupSlot_TwoBackupsInRow_SecondReusesNameOk(t *testing.T) {
_ = physical_repositories.GetInFlightBackupRepository().Release(fixture.DB.ID)
})
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(secondID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), secondID, false)
postgresql_executor.WaitForBackupStatus(t, secondID, physical_enums.PhysicalBackupTypeFull,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
@@ -717,7 +717,7 @@ func Test_BackupSlot_PresentDuringRun_PG18(t *testing.T) {
adminConn := postgresql_executor.OpenAdminConn(t, fixture)
observed := postgresql_executor.RunBackupAndPoll(t, fixture, slotName, func() {
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
})
postgresql_executor.WaitForBackupStatus(t, fixture.BackupID, physical_enums.PhysicalBackupTypeFull,
@@ -737,7 +737,7 @@ func Test_BackupSlot_RetryAfterFailure_ReusesName(t *testing.T) {
flakyStorage := storages.CreateTestFlakyS3Storage(*fixture.DB.WorkspaceID,
"http://127.0.0.1:1")
- t.Cleanup(func() { storages.RemoveTestStorage(flakyStorage.ID) })
+ t.Cleanup(func() { storages.RemoveTestStorage(t.Context(), flakyStorage.ID) })
cfgService := backups_config_physical.GetBackupConfigService()
cfg, err := cfgService.GetBackupConfigByDbId(fixture.DB.ID)
@@ -745,10 +745,10 @@ func Test_BackupSlot_RetryAfterFailure_ReusesName(t *testing.T) {
cfg.StorageID = &flakyStorage.ID
cfg.Storage = flakyStorage
- _, err = cfgService.SaveBackupConfig(cfg)
+ _, err = cfgService.SaveBackupConfig(t.Context(), cfg)
require.NoError(t, err)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
finalRow, err := physical_repositories.GetFullBackupRepository().FindByID(fixture.BackupID)
require.NoError(t, err)
@@ -763,7 +763,7 @@ func Test_BackupSlot_RetryAfterFailure_ReusesName(t *testing.T) {
cfg.StorageID = &fixture.Storage.ID
cfg.Storage = fixture.Storage
- _, err = cfgService.SaveBackupConfig(cfg)
+ _, err = cfgService.SaveBackupConfig(t.Context(), cfg)
require.NoError(t, err)
_ = physical_repositories.GetInFlightBackupRepository().Release(fixture.DB.ID)
@@ -795,7 +795,7 @@ func Test_BackupSlot_RetryAfterFailure_ReusesName(t *testing.T) {
_ = physical_repositories.GetInFlightBackupRepository().Release(fixture.DB.ID)
})
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(retryID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), retryID, false)
postgresql_executor.WaitForBackupStatus(t, retryID, physical_enums.PhysicalBackupTypeFull,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
@@ -822,7 +822,7 @@ func Test_BackupSlot_DroppedAfterCancelledMidRun(t *testing.T) {
go func() {
defer close(backupDone)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
}()
go func() {
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/create_full_uc.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/create_full_uc.go
index c1317694..efa17602 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/create_full_uc.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/create_full_uc.go
@@ -191,13 +191,13 @@ func removeUploadedArtifactsAfterChainBroken(
) {
manifestName := fileName + manifestSuffix
- if err := storage.DeleteFile(encryptor, manifestName); err != nil {
+ if err := storage.DeleteFile(context.Background(), encryptor, logger, manifestName); err != nil {
logger.Warn("failed to remove manifest after CHAIN_BROKEN",
"file_name", manifestName,
"error", err)
}
- if err := storage.DeleteFile(encryptor, fileName); err != nil {
+ if err := storage.DeleteFile(context.Background(), encryptor, logger, fileName); err != nil {
logger.Warn("failed to remove artifact after CHAIN_BROKEN",
"file_name", fileName,
"error", err)
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/create_full_uc_test.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/create_full_uc_test.go
index 8be570cb..901eaa57 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/create_full_uc_test.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/create_full_uc_test.go
@@ -19,7 +19,7 @@ import (
func Test_FullOnly_ProducesArtifactAndManifest(t *testing.T) {
fixture := postgresql_executor.SetupPhysicalDBForBackup(t)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
postgresql_executor.WaitForBackupStatus(t, fixture.BackupID, physical_enums.PhysicalBackupTypeFull,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/create_incremental_uc_test.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/create_incremental_uc_test.go
index e26691b7..2017a89b 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/create_incremental_uc_test.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/create_incremental_uc_test.go
@@ -25,13 +25,13 @@ func Test_CreateIncremental_WhenSummarizerOff_ChainBrokenNoArtifact(t *testing.T
source := containers.StartPhysicalPostgres(t, "postgres:17", containers.WithoutSummarizer())
fixture := postgresql_executor.SetupPhysicalDBForBackupNoSummary(t, source.Host, source.Port)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
postgresql_executor.WaitForBackupStatus(t, fixture.BackupID, physical_enums.PhysicalBackupTypeFull,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
incrID := postgresql_executor.BuildAndClaimIncremental(t, fixture, nil)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(incrID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), incrID, false)
summarizerOff := physical_enums.PhysicalBackupErrorSummarizerOff
postgresql_executor.WaitForBackupStatus(t, incrID, physical_enums.PhysicalBackupTypeIncremental,
@@ -51,7 +51,7 @@ func Test_CreateIncremental_WhenSummarizerOff_ChainBrokenNoArtifact(t *testing.T
func Test_CreateIncremental_WhenSummarizerHealthy_GoesIncremental(t *testing.T) {
fixture := postgresql_executor.SetupPhysicalDBForBackup(t)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
postgresql_executor.WaitForBackupStatus(t, fixture.BackupID, physical_enums.PhysicalBackupTypeFull,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
@@ -79,7 +79,7 @@ func Test_CreateIncremental_WhenSummarizerHealthy_GoesIncremental(t *testing.T)
incrID := postgresql_executor.BuildAndClaimIncremental(t, fixture, nil)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(incrID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), incrID, false)
postgresql_executor.WaitForBackupStatus(t, incrID, physical_enums.PhysicalBackupTypeIncremental,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
@@ -92,13 +92,13 @@ func Test_CreateIncremental_WhenSummarizerHealthy_GoesIncremental(t *testing.T)
func Test_CreateIncremental_WhenSummarizerBehindOnIdleDB_StillCompletes(t *testing.T) {
fixture := postgresql_executor.SetupPhysicalDBForBackup(t)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(fixture.BackupID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), fixture.BackupID, false)
postgresql_executor.WaitForBackupStatus(t, fixture.BackupID, physical_enums.PhysicalBackupTypeFull,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
incrID := postgresql_executor.BuildAndClaimIncremental(t, fixture, nil)
- backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(incrID, false)
+ backuping_physical.CreateTestPhysicalBackuper(nil).MakeBackup(t.Context(), incrID, false)
postgresql_executor.WaitForBackupStatus(t, incrID, physical_enums.PhysicalBackupTypeIncremental,
physical_enums.PhysicalBackupStatusCompleted, nil, 3*time.Minute)
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/lag_monitor.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/lag_monitor.go
index 0b382c30..a395066a 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/lag_monitor.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/lag_monitor.go
@@ -137,6 +137,8 @@ func (s *WalStreamSupervisor) runLagMonitor(ctx context.Context, logger *slog.Lo
continue
}
+ s.reportArchivingProgress(ctx, logger, state)
+
s.reportArchiveStalenessIfDue(logger, &stalenessTracker, state)
reason, action := classifier.recordSampleAndClassifyBreak(slotBreakSample{
@@ -154,16 +156,39 @@ func (s *WalStreamSupervisor) runLagMonitor(ctx context.Context, logger *slog.Lo
s.reportChainAtRisk(logger, reason, state)
case slotBreakActionRebuild:
- logger.Warn("wal_stream_break_observed", "reason", string(reason), "slot", s.slotName)
+ logger.WarnContext(ctx, "wal stream break observed", "reason", string(reason),
+ "lag_bytes", state.LagBytes, "wal_status", state.WalStatus)
if err := s.rebuildSlot(ctx, logger, reason); err != nil {
- logger.Error("slot rebuild failed", "reason", string(reason), "error", err)
+ logger.ErrorContext(ctx, "slot rebuild failed", "reason", string(reason), "error", err)
}
}
}
}
}
+// Archiving throughput and lag are only visible today once something has already broken, which
+// leaves no history to read after an incident. This rides the existing poll rather than adding a
+// ticker, and stays at INFO only when segments actually moved.
+func (s *WalStreamSupervisor) reportArchivingProgress(
+ ctx context.Context,
+ logger *slog.Logger,
+ state *SlotState,
+) {
+ archivedSegments, archivedBytes := s.uploader.TakeArchivedSinceLastReport()
+
+ if archivedSegments == 0 {
+ logger.DebugContext(ctx, fmt.Sprintf("no wal archived since the last report, %d bytes behind",
+ state.LagBytes), "wal_status", state.WalStatus)
+
+ return
+ }
+
+ logger.InfoContext(ctx, fmt.Sprintf("archived %d wal segments (%.1f MB), %d bytes behind",
+ archivedSegments, float64(archivedBytes)/(1024*1024), state.LagBytes),
+ "wal_status", state.WalStatus)
+}
+
// The slot's restart_lsn plus its lag is where the source currently is, so the
// staleness check needs no extra query on the source.
func (s *WalStreamSupervisor) reportArchiveStalenessIfDue(
@@ -186,7 +211,8 @@ func (s *WalStreamSupervisor) reportArchiveStalenessIfDue(
logger.Warn("wal archiving fell behind the source; the recovery point is no longer advancing",
"reason", ChainRiskReasonArchiveStale,
- "slot", s.slotName,
+ "lag_bytes", state.LagBytes,
+ "wal_status", state.WalStatus,
)
if s.spec.OnChainAtRisk == nil {
@@ -213,7 +239,6 @@ func (s *WalStreamSupervisor) reportChainAtRisk(logger *slog.Logger, reason walB
logger.Warn(
fmt.Sprintf("wal chain at risk: slot wal_status=%s, %d bytes behind", report.SlotWalStatus, report.LagBytes),
"reason", string(reason),
- "slot", s.slotName,
)
if s.spec.OnChainAtRisk == nil {
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/mocks_test.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/mocks_test.go
index f29b2f2f..adcfdb28 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/mocks_test.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/mocks_test.go
@@ -82,7 +82,12 @@ func (m *mockWalStorage) stopFailingSaves() {
m.isFailingAllSaves.Store(false)
}
-func (m *mockWalStorage) DeleteFile(_ encryption.FieldEncryptor, fileName string) error {
+func (m *mockWalStorage) DeleteFile(
+ _ context.Context,
+ _ encryption.FieldEncryptor,
+ _ *slog.Logger,
+ fileName string,
+) error {
m.mu.Lock()
defer m.mu.Unlock()
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/receivewal_process.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/receivewal_process.go
index 24baaf02..9ba003af 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/receivewal_process.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/receivewal_process.go
@@ -49,7 +49,7 @@ func (s *WalStreamSupervisor) spawnAndSupervise(
) receiverRunResult {
password, err := postgresql_shared.DecryptFieldIfNeeded(s.spec.SourceDB.Password, s.spec.FieldEncryptor)
if err != nil {
- logger.Error("decrypt source password for pg_receivewal", "error", err)
+ logger.ErrorContext(ctx, "decrypt source password for pg_receivewal", "error", err)
return receiverRunResult{Exit: receiverRetryable}
}
@@ -58,7 +58,7 @@ func (s *WalStreamSupervisor) spawnAndSupervise(
s.spec.SourceDB.CredentialSpec(), password, s.spec.FieldEncryptor,
)
if err != nil {
- logger.Error("write pg_receivewal credentials", "error", err)
+ logger.ErrorContext(ctx, "write pg_receivewal credentials", "error", err)
return receiverRunResult{Exit: receiverRetryable}
}
@@ -75,20 +75,20 @@ func (s *WalStreamSupervisor) spawnAndSupervise(
SlotName: s.slotName,
})
if err != nil {
- logger.Error("build pg_receivewal command", "error", err)
+ logger.ErrorContext(ctx, "build pg_receivewal command", "error", err)
return receiverRunResult{Exit: receiverRetryable}
}
stderrPipe, err := cmd.StderrPipe()
if err != nil {
- logger.Error("pg_receivewal stderr pipe", "error", err)
+ logger.ErrorContext(ctx, "pg_receivewal stderr pipe", "error", err)
return receiverRunResult{Exit: receiverRetryable}
}
if err := cmd.Start(); err != nil {
- logger.Error("start pg_receivewal", "error", err)
+ logger.ErrorContext(ctx, "start pg_receivewal", "error", err)
return receiverRunResult{Exit: receiverRetryable}
}
@@ -99,7 +99,7 @@ func (s *WalStreamSupervisor) spawnAndSupervise(
stderr := newStderrCapture(stderrPipe)
startedAt := time.Now().UTC()
- logger.Info("pg_receivewal started", "watch_dir", s.watchDir)
+ logger.InfoContext(ctx, "pg_receivewal started", "watch_dir", s.watchDir)
exited := make(chan error, 1)
@@ -114,7 +114,7 @@ func (s *WalStreamSupervisor) spawnAndSupervise(
return receiverRunResult{Exit: receiverCtxCancelled}
case <-s.restartSignal:
- logger.Info("restarting pg_receivewal on internal signal (back pressure or slot stall)")
+ logger.InfoContext(ctx, "restarting pg_receivewal on internal signal (back pressure or slot stall)")
procCancel()
<-exited
stderr.stop()
@@ -126,21 +126,23 @@ func (s *WalStreamSupervisor) spawnAndSupervise(
ranFor := time.Since(startedAt)
if waitErr == nil || procCtx.Err() != nil {
+ logger.DebugContext(ctx, "pg_receivewal exited cleanly", "ran_for", ranFor)
+
return receiverRunResult{Exit: receiverRetryable, RanFor: ranFor}
}
stderrText := stderr.contents()
if isResumeMismatchError(stderrText) {
- logger.Warn("pg_receivewal asked for WAL the server has recycled; realigning the resume point",
- "error", waitErr, "stderr", truncateStderr(stderrText))
+ logger.WarnContext(ctx, "pg_receivewal asked for WAL the server has recycled; realigning the resume point",
+ "error", waitErr, "ran_for", ranFor, "stderr", truncateStderr(stderrText))
return receiverRunResult{Exit: receiverResumeMismatch, RanFor: ranFor}
}
if isFatalReceivewalError(stderrText) {
- logger.Error("pg_receivewal exited with a non-retryable error",
- "error", waitErr, "stderr", truncateStderr(stderrText))
+ logger.ErrorContext(ctx, "pg_receivewal exited with a non-retryable error",
+ "error", waitErr, "ran_for", ranFor, "stderr", truncateStderr(stderrText))
return receiverRunResult{
Exit: receiverFatal,
@@ -151,8 +153,8 @@ func (s *WalStreamSupervisor) spawnAndSupervise(
}
}
- logger.Warn("pg_receivewal exited; will respawn",
- "error", waitErr, "stderr", truncateStderr(stderrText))
+ logger.WarnContext(ctx, "pg_receivewal exited; will respawn",
+ "error", waitErr, "ran_for", ranFor, "stderr", truncateStderr(stderrText))
return receiverRunResult{Exit: receiverRetryable, RanFor: ranFor}
}
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_cleanup_listener.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_cleanup_listener.go
index 8ca9dc05..28af29bb 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_cleanup_listener.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_cleanup_listener.go
@@ -50,7 +50,7 @@ func NewPhysicalSlotCleanupListener(
}
}
-func (l *PhysicalSlotCleanupListener) OnBeforeDatabaseRemove(databaseID uuid.UUID) error {
+func (l *PhysicalSlotCleanupListener) OnBeforeDatabaseRemove(ctx context.Context, databaseID uuid.UUID) error {
database, err := l.databaseService.GetDatabaseByID(databaseID)
if err != nil {
return nil
@@ -62,7 +62,9 @@ func (l *PhysicalSlotCleanupListener) OnBeforeDatabaseRemove(databaseID uuid.UUI
logger := l.logger.With("database_id", databaseID)
- ctx, cancel := context.WithTimeout(context.Background(), slotCleanupDeadline)
+ // The database row is being deleted, so the slot drop must finish even if the caller goes
+ // away: RunStartupCleanup can never recover a slot whose database row is gone.
+ cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), slotCleanupDeadline)
defer cancel()
// The per-backup slot is keyed by the PostgresqlPhysical ID (see
@@ -73,7 +75,7 @@ func (l *PhysicalSlotCleanupListener) OnBeforeDatabaseRemove(databaseID uuid.UUI
slotName := SlotName(database.PostgresqlPhysical.ID)
walSlotName := database.PostgresqlPhysical.ReplicationSlotName
- tunneledDatabase, err := postgresql_physical.OpenTunnel(ctx, postgresql_physical.OpenTunnelSpec{
+ tunneledDatabase, err := postgresql_physical.OpenTunnel(cleanupCtx, postgresql_physical.OpenTunnelSpec{
Database: database.PostgresqlPhysical,
Logger: logger,
Encryptor: l.fieldEncryptor,
@@ -94,7 +96,7 @@ func (l *PhysicalSlotCleanupListener) OnBeforeDatabaseRemove(databaseID uuid.UUI
sourceDatabase := tunneledDatabase.GetDatabaseThroughTunnel()
- conn, err := sourceDatabase.OpenInspectionConn(ctx, l.fieldEncryptor)
+ conn, err := sourceDatabase.OpenInspectionConn(cleanupCtx, l.fieldEncryptor)
if err != nil {
logger.Warn("physical slot cleanup: source PG unreachable, leaving slots orphaned",
"slot_name", slotName,
@@ -106,11 +108,11 @@ func (l *PhysicalSlotCleanupListener) OnBeforeDatabaseRemove(databaseID uuid.UUI
}
defer func() { _ = conn.Close(context.Background()) }()
- if dropErr := dropBackupSlotIfExists(ctx, conn, slotName); dropErr != nil {
+ if dropErr := dropBackupSlotIfExists(cleanupCtx, conn, slotName); dropErr != nil {
logger.Warn("physical slot cleanup: per-backup slot drop failed", "slot_name", slotName, "error", dropErr)
}
- if dropErr := sourceDatabase.DropWalSlotForRemoval(ctx, logger, l.fieldEncryptor); dropErr != nil {
+ if dropErr := sourceDatabase.DropWalSlotForRemoval(cleanupCtx, logger, l.fieldEncryptor); dropErr != nil {
logger.Warn("physical slot cleanup: WAL streamer slot drop failed",
"slot_name", walSlotName,
"error", dropErr,
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_cleanup_listener_test.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_cleanup_listener_test.go
index 02560851..78ad1bf5 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_cleanup_listener_test.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_cleanup_listener_test.go
@@ -59,7 +59,7 @@ func Test_OnBeforeDatabaseRemove_DropsBothPerBackupAndStreamerSlots(t *testing.T
logger.GetLogger(),
)
- require.NoError(t, listener.OnBeforeDatabaseRemove(fixture.DB.ID))
+ require.NoError(t, listener.OnBeforeDatabaseRemove(t.Context(), fixture.DB.ID))
assert.False(t, postgresql_executor.SlotExists(t, adminConn, perBackupSlot),
"per-backup slot (keyed by PostgresqlPhysical.ID) must be dropped on DB removal")
@@ -102,7 +102,7 @@ func Test_OnBeforeDatabaseRemove_WhenTheSourceIsBehindABastion_DropsBothPerBacku
logger.GetLogger(),
)
- require.NoError(t, listener.OnBeforeDatabaseRemove(fixture.DB.ID))
+ require.NoError(t, listener.OnBeforeDatabaseRemove(t.Context(), fixture.DB.ID))
assert.False(t, postgresql_executor.SlotExists(t, adminConn, perBackupSlot),
"per-backup slot must be dropped through the tunnel on DB removal")
@@ -124,7 +124,7 @@ func Test_OnBeforeDatabaseRemove_WhenSourceUnreachable_DoesNotBlockRemoval(t *te
logger.GetLogger(),
)
- assert.NoError(t, listener.OnBeforeDatabaseRemove(fixture.DB.ID),
+ assert.NoError(t, listener.OnBeforeDatabaseRemove(t.Context(), fixture.DB.ID),
"unreachable source must be logged + skipped, never block the metadata delete")
}
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_lsn_watcher.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_lsn_watcher.go
index 0e599483..af4268c9 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_lsn_watcher.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_lsn_watcher.go
@@ -77,19 +77,31 @@ func (s *WalStreamSupervisor) GetSlotStateIfReachable(
) (state *SlotState, isSourceReachable bool) {
conn, err := s.spec.SourceDB.OpenInspectionConn(ctx, s.spec.FieldEncryptor)
if err != nil {
- logger.Debug("slot-lsn watcher: source unreachable, deferring to lag monitor", "error", err)
+ logger.DebugContext(ctx, "source unreachable, deferring to the lag monitor", "error", err)
return nil, false
}
defer func() { _ = conn.Close(context.Background()) }()
state, err = InspectSlot(ctx, conn, s.slotName)
- if err != nil || state == nil {
+ if err != nil {
+ logger.DebugContext(ctx, "failed to inspect the replication slot", "error", err)
+
+ return nil, false
+ }
+
+ if state == nil {
+ // The slot is gone from the source while we still believe we are streaming from it, so WAL
+ // is no longer retained for us and the chain is already at risk.
+ logger.WarnContext(ctx, "the replication slot no longer exists on the source")
+
return nil, false
}
var alive int
if err := conn.QueryRow(ctx, "SELECT 1").Scan(&alive); err != nil {
+ logger.DebugContext(ctx, "source stopped responding during the slot probe", "error", err)
+
return nil, false
}
@@ -123,7 +135,8 @@ func (s *WalStreamSupervisor) runSlotLsnWatcher(ctx context.Context, logger *slo
}
if tracker.recordSampleAndDetectStall(sample, slotLsnStallTimeout) {
- logger.Warn(
+ logger.WarnContext(
+ ctx,
fmt.Sprintf("slot restart_lsn stalled with %d bytes pending; restarting pg_receivewal",
state.LagBytes),
"restart_lsn", state.RestartLSN.String(),
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_rebuild.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_rebuild.go
index 6d2d2294..d94d91ee 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_rebuild.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/slot_rebuild.go
@@ -15,12 +15,18 @@ func (s *WalStreamSupervisor) rebuildSlot(ctx context.Context, logger *slog.Logg
defer s.rebuildMu.Unlock()
if !s.recordRebuildAttemptWithinCap() {
+ // Repeated rebuilds each open a WAL gap, so hitting the cap means the chain is degrading and
+ // the cause is upstream of this streamer.
+ logger.ErrorContext(ctx, fmt.Sprintf(
+ "rebuild loop-protection tripped: more than %d rebuilds in the last hour",
+ slotRebuildMaxAttemptsPerHour), "reason", string(reason))
+
return fmt.Errorf(
"rebuild loop-protection tripped: more than %d rebuilds in the last hour", slotRebuildMaxAttemptsPerHour,
)
}
- logger.Info("starting slot rebuild", "reason", string(reason))
+ logger.InfoContext(ctx, "starting slot rebuild", "reason", string(reason))
s.isPaused.Store(true)
defer s.isPaused.Store(false)
@@ -39,6 +45,9 @@ func (s *WalStreamSupervisor) rebuildSlot(ctx context.Context, logger *slog.Logg
}
if !terminated {
+ logger.WarnContext(ctx,
+ "refusing to rebuild: the slot is held by a consumer that is not ours")
+
return errors.New(
"slot still active after stopping our receiver; refusing to drop a slot held by another consumer",
)
@@ -73,7 +82,7 @@ func (s *WalStreamSupervisor) rebuildSlot(ctx context.Context, logger *slog.Logg
}
}
- logger.Info("slot rebuild complete; resuming pg_receivewal on fresh slot")
+ logger.InfoContext(ctx, "slot rebuild complete; resuming pg_receivewal on fresh slot")
return nil
}
@@ -109,7 +118,7 @@ func (s *WalStreamSupervisor) terminateOwnedSlotBackend(ctx context.Context, log
return false, err
}
- logger.Warn("terminated Databasus-owned wal receiver backend", "active_pid", *state.ActivePID)
+ logger.WarnContext(ctx, "terminated Databasus-owned wal receiver backend", "active_pid", *state.ActivePID)
return terminated, nil
}
@@ -136,7 +145,7 @@ func (s *WalStreamSupervisor) waitForSlotReleased(ctx context.Context, logger *s
func (s *WalStreamSupervisor) isSlotActive(ctx context.Context, logger *slog.Logger) (active, ok bool) {
conn, err := s.spec.SourceDB.OpenInspectionConn(ctx, s.spec.FieldEncryptor)
if err != nil {
- logger.Debug("rebuild: source unreachable while waiting for slot release", "error", err)
+ logger.DebugContext(ctx, "rebuild: source unreachable while waiting for slot release", "error", err)
return false, false
}
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/stream_test.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/stream_test.go
index d8d79eb8..80d70003 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/stream_test.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/stream_test.go
@@ -110,7 +110,9 @@ func (f *fakeStorageFileSaver) has(fileName string) bool {
return ok
}
-func (f *fakeStorageFileSaver) DeleteFile(encryption.FieldEncryptor, string) error { return nil }
+func (f *fakeStorageFileSaver) DeleteFile(context.Context, encryption.FieldEncryptor, *slog.Logger, string) error {
+ return nil
+}
func (f *fakeStorageFileSaver) Validate(encryption.FieldEncryptor) error { return nil }
func (f *fakeStorageFileSaver) TestConnection(encryption.FieldEncryptor) error { return nil }
func (f *fakeStorageFileSaver) HideSensitiveData() {}
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/summarizer.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/summarizer.go
index 0cbe8d4d..f74b3fec 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/summarizer.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/summarizer.go
@@ -145,7 +145,8 @@ func summarizerGoThresholdBytes(ctx context.Context, conn *pgx.Conn) (int64, err
// current_setting reports the GUC with its display unit (e.g. "16MB"), so
// run it through pg_size_bytes rather than a raw ::bigint cast.
- if err := conn.QueryRow(ctx,
+ if err := conn.QueryRow(
+ ctx,
"SELECT pg_size_bytes(current_setting('wal_segment_size'))::bigint",
).Scan(&segmentSizeBytes); err != nil {
return 0, fmt.Errorf("read wal_segment_size: %w", err)
@@ -224,7 +225,8 @@ func waitForSummarizer(
func isSummarizerEnabled(ctx context.Context, conn *pgx.Conn) (bool, error) {
var setting string
- if err := conn.QueryRow(ctx,
+ if err := conn.QueryRow(
+ ctx,
"SELECT setting FROM pg_settings WHERE name = 'summarize_wal'",
).Scan(&setting); err != nil {
if errors.Is(err, pgx.ErrNoRows) {
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/testing.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/testing.go
index 07531399..402b4773 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/testing.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/testing.go
@@ -217,19 +217,19 @@ func wirePhysicalDBFixture(
backups_config_logical.GetBackupConfigController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
testStorage := storages.CreateTestStorage(workspace.ID)
- t.Cleanup(func() { storages.RemoveTestStorage(testStorage.ID) })
+ t.Cleanup(func() { storages.RemoveTestStorage(t.Context(), testStorage.ID) })
notifier := notifiers.CreateTestNotifier(workspace.ID)
t.Cleanup(func() { notifiers.RemoveTestNotifier(notifier) })
db := createDB(workspace.ID, notifier)
- t.Cleanup(func() { databases.RemoveTestDatabase(db) })
+ t.Cleanup(func() { databases.RemoveTestDatabase(t.Context(), db) })
encryptor := encryption.GetFieldEncryptor()
log := logger.GetLogger()
@@ -291,7 +291,7 @@ func setupPhysicalFixture(
TimeOfDay: new("04:00"),
}
- _, err = cfgService.SaveBackupConfig(cfg)
+ _, err = cfgService.SaveBackupConfig(t.Context(), cfg)
require.NoError(t, err)
backupID := uuid.New()
@@ -437,7 +437,8 @@ func GenerateWalActivity(
) (int64, error) {
tableName := "wal_activity_" + strings.ReplaceAll(uuid.New().String(), "-", "")[:16]
- if _, err := conn.Exec(ctx,
+ if _, err := conn.Exec(
+ ctx,
fmt.Sprintf(`CREATE TABLE %s (id BIGSERIAL PRIMARY KEY, payload TEXT)`, tableName),
); err != nil {
return 0, fmt.Errorf("create wal activity table: %w", err)
@@ -457,7 +458,8 @@ func GenerateWalActivity(
const payloadSize = 1024
for {
- _, err := conn.Exec(ctx,
+ _, err := conn.Exec(
+ ctx,
fmt.Sprintf(
`INSERT INTO %s (payload) SELECT repeat('x', %d) FROM generate_series(1, %d)`,
tableName, payloadSize, rowsPerBatch,
@@ -616,7 +618,8 @@ func SetSummarizerEnabled(t *testing.T, conn *pgx.Conn, enabled bool) {
defer cancel()
var previous string
- if err := conn.QueryRow(ctx,
+ if err := conn.QueryRow(
+ ctx,
"SELECT setting FROM pg_settings WHERE name = 'summarize_wal'",
).Scan(&previous); err != nil {
t.Fatalf("read summarize_wal: %v", err)
@@ -631,7 +634,8 @@ func SetSummarizerEnabled(t *testing.T, conn *pgx.Conn, enabled bool) {
return
}
- if _, err := conn.Exec(ctx,
+ if _, err := conn.Exec(
+ ctx,
fmt.Sprintf("ALTER SYSTEM SET summarize_wal = '%s'", desired),
); err != nil {
t.Fatalf("ALTER SYSTEM summarize_wal=%s: %v", desired, err)
@@ -667,13 +671,15 @@ func ExpireWalSummaries(t *testing.T, conn *pgx.Conn) {
defer cancel()
var previous string
- if err := conn.QueryRow(ctx,
+ if err := conn.QueryRow(
+ ctx,
"SELECT setting FROM pg_settings WHERE name = 'wal_summary_keep_time'",
).Scan(&previous); err != nil {
t.Fatalf("read wal_summary_keep_time: %v", err)
}
- if _, err := conn.Exec(ctx,
+ if _, err := conn.Exec(
+ ctx,
"ALTER SYSTEM SET wal_summary_keep_time = '1min'",
); err != nil {
t.Fatalf("ALTER SYSTEM wal_summary_keep_time: %v", err)
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/timeline.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/timeline.go
index 69b9d676..913c6290 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/timeline.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/timeline.go
@@ -184,7 +184,7 @@ func UploadHistoryFile(
}
if existing != nil {
- logger.Debug("history file already in catalog",
+ logger.DebugContext(ctx, "history file already in catalog",
"database_id", databaseID,
"timeline_id", timelineID)
@@ -239,8 +239,8 @@ func UploadHistoryFile(
// Sidecar upload failed: remove the artifact to preserve the
// "no artifact without sidecar" invariant. DeleteFile is
// idempotent on not-found.
- if delErr := storage.DeleteFile(fieldEncryptor, storageObjectName); delErr != nil {
- logger.Warn("failed to remove orphan history artifact after sidecar failure",
+ if delErr := storage.DeleteFile(ctx, fieldEncryptor, logger, storageObjectName); delErr != nil {
+ logger.WarnContext(ctx, "failed to remove orphan history artifact after sidecar failure",
"file_name", storageObjectName,
"error", delErr)
}
@@ -261,7 +261,7 @@ func UploadHistoryFile(
if err := historyRepo.Insert(row); err != nil {
if isUniqueViolation(err) {
- logger.Debug("history row inserted by concurrent caller",
+ logger.DebugContext(ctx, "history row inserted by concurrent caller",
"database_id", databaseID,
"timeline_id", timelineID)
@@ -344,7 +344,8 @@ func historyIsGapped(rows []*physical_models.PhysicalWalHistoryFile, timelineID
func readHistoryFromCluster(ctx context.Context, conn *pgx.Conn, historyFilename string) ([]byte, error) {
var body []byte
- err := conn.QueryRow(ctx,
+ err := conn.QueryRow(
+ ctx,
`SELECT pg_read_binary_file('pg_wal/' || $1)`,
historyFilename,
).Scan(&body)
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_backpressure.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_backpressure.go
index 50e9af9c..bdb51405 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_backpressure.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_backpressure.go
@@ -43,7 +43,7 @@ func (s *WalStreamSupervisor) waitForBacklogBelowLow(ctx context.Context, logger
return true
}
- logger.Warn("wal backlog over high watermark; pausing pg_receivewal until it drains")
+ logger.WarnContext(ctx, "wal backlog over high watermark; pausing pg_receivewal until it drains")
ticker := time.NewTicker(backpressurePollInterval)
defer ticker.Stop()
@@ -55,7 +55,7 @@ func (s *WalStreamSupervisor) waitForBacklogBelowLow(ctx context.Context, logger
case <-ticker.C:
if s.backlogBytes() < s.lowWatermarkBytes {
- logger.Info("wal backlog drained below low watermark; resuming pg_receivewal")
+ logger.InfoContext(ctx, "wal backlog drained below low watermark; resuming pg_receivewal")
return true
}
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_resume.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_resume.go
index 30f5d6a2..b54c85f8 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_resume.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_resume.go
@@ -125,12 +125,13 @@ func (s *WalStreamSupervisor) realignResumePath(ctx context.Context, logger *slo
movedCount, err := movePendingUploadsOutOfResumePath(s.watchDir, slotSegmentNo, segmentSizeBytes)
if err != nil {
- logger.Error("failed to realign wal resume point", "error", err)
+ logger.ErrorContext(ctx, "failed to realign wal resume point", "error", err)
return
}
- logger.Warn(
+ logger.WarnContext(
+ ctx,
fmt.Sprintf("realigned wal resume point, moved %d segments out of the resume path", movedCount),
"slot_restart_lsn", state.RestartLSN.String(),
"resume_segment_no", uint64(resumeSegmentNo),
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_rotation.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_rotation.go
index b95a505d..d28f77f2 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_rotation.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_rotation.go
@@ -100,12 +100,12 @@ func (s *WalStreamSupervisor) runForcedWalRotation(ctx context.Context, logger *
currentLSNAfterRotation, err := s.forceWalRotation(ctx)
if err != nil {
if !isInsufficientPrivilegeError(err) {
- logger.Warn("forced wal rotation failed; will retry", "error", err)
+ logger.WarnContext(ctx, "forced wal rotation failed; will retry", "error", err)
continue
}
- logger.Warn("source refuses pg_switch_wal; forced wal rotation disabled for this streamer",
+ logger.WarnContext(ctx, "source refuses pg_switch_wal; forced wal rotation disabled for this streamer",
"error", err)
s.reportChainAtRisk(logger, breakReasonRotationDenied, nil)
@@ -115,7 +115,7 @@ func (s *WalStreamSupervisor) runForcedWalRotation(ctx context.Context, logger *
rotationTracker.recordRotation(currentLSNAfterRotation, time.Now().UTC())
- logger.Debug("forced a wal segment switch so the recovery point keeps advancing")
+ logger.DebugContext(ctx, "forced a wal segment switch so the recovery point keeps advancing")
}
}
}
@@ -126,7 +126,7 @@ func (s *WalStreamSupervisor) getCurrentWalLsnIfReachable(
) (currentLSN walmath.LSN, isSourceReachable bool) {
conn, err := s.spec.SourceDB.OpenInspectionConn(ctx, s.spec.FieldEncryptor)
if err != nil {
- logger.Debug("forced wal rotation: source unreachable this tick", "error", err)
+ logger.DebugContext(ctx, "forced wal rotation: source unreachable this tick", "error", err)
return 0, false
}
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_stream.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_stream.go
index 4fbfd843..71170434 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_stream.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_stream.go
@@ -184,6 +184,7 @@ type WalStreamSpec struct {
// is cancelled.
type WalStreamSupervisor struct {
spec WalStreamSpec
+ logger *slog.Logger
uploader *WalUploader
watchDir string
slotName string
@@ -216,6 +217,13 @@ type WalStreamSupervisor struct {
func NewWalStreamSupervisor(spec WalStreamSpec) *WalStreamSupervisor {
watchDir := filepath.Join(spec.WatchDirRoot, "wal-queue", spec.DatabaseID.String())
+ // The uploader logs per segment, so it needs the same scoping the supervisor uses; handing it the
+ // raw spec logger leaves every archiving line unattributable on a multi-database instance.
+ scopedLogger := spec.Logger.With(
+ "database_id", spec.DatabaseID,
+ "slot_name", spec.SourceDB.ReplicationSlotName,
+ )
+
uploader := NewWalUploader(WalUploadDeps{
DatabaseID: spec.DatabaseID,
StorageID: spec.StorageID,
@@ -225,7 +233,7 @@ func NewWalStreamSupervisor(spec WalStreamSpec) *WalStreamSupervisor {
FieldEncryptor: spec.FieldEncryptor,
WalSegmentRepo: spec.WalSegmentRepo,
WalSegmentSizeBytes: walSegmentSizeBytes(spec.SourceDB),
- Logger: spec.Logger,
+ Logger: scopedLogger,
OnGapDetected: spec.OnGapDetected,
})
@@ -233,6 +241,7 @@ func NewWalStreamSupervisor(spec WalStreamSpec) *WalStreamSupervisor {
return &WalStreamSupervisor{
spec: spec,
+ logger: scopedLogger,
uploader: uploader,
watchDir: watchDir,
slotName: spec.SourceDB.ReplicationSlotName,
@@ -243,7 +252,7 @@ func NewWalStreamSupervisor(spec WalStreamSpec) *WalStreamSupervisor {
}
func (s *WalStreamSupervisor) Run(ctx context.Context) error {
- logger := s.spec.Logger.With("database_id", s.spec.DatabaseID, "slot_name", s.slotName)
+ logger := s.logger
// pg_receivewal finalizes a segment by writing a marker into <dir>/archive_status/
// and refuses to start (or errors mid-stream) if that subdirectory is absent — it
@@ -292,12 +301,12 @@ func (s *WalStreamSupervisor) Run(ctx context.Context) error {
wg.Wait()
if fatalErr != nil {
- logger.Error("wal stream supervisor stopping with fatal error", "error", fatalErr)
+ logger.ErrorContext(ctx, "wal stream supervisor stopping with fatal error", "error", fatalErr)
return fatalErr
}
- logger.Info("wal stream supervisor stopped")
+ logger.InfoContext(ctx, "wal stream supervisor stopped")
return nil
}
@@ -381,11 +390,17 @@ func (s *WalStreamSupervisor) runReceivewalSupervision(ctx context.Context, logg
mismatchEscalator.reset()
if !isBastionReachable {
- logger.Warn("wal receiver exited while the bastion was unreachable, waiting for the transport")
+ logger.WarnContext(ctx, "wal receiver exited while the bastion was unreachable, waiting for the transport")
}
decision := failureEscalator.recordExitAndDecideRetry(receiverRun.RanFor, isBastionReachable)
if decision.isEscalationRequired {
+ // The streamer is about to be marked FAILED and handed to another instance; without this
+ // the only evidence is a generic fatal at the top of Run.
+ logger.ErrorContext(ctx, fmt.Sprintf(
+ "pg_receivewal crash-looped: %d rapid failures, escalating for reassignment",
+ receivewalMaxRapidFailures), "ran_for", receiverRun.RanFor)
+
return fmt.Errorf(
"pg_receivewal crash-looped: %d rapid failures, escalating for reassignment",
receivewalMaxRapidFailures,
@@ -396,6 +411,10 @@ func (s *WalStreamSupervisor) runReceivewalSupervision(ctx context.Context, logg
respawnBackoff = receivewalRespawnBackoff
}
+ // A streamer sitting in a long backoff is otherwise completely silent for its duration.
+ logger.DebugContext(ctx, fmt.Sprintf("respawning pg_receivewal in %s", respawnBackoff),
+ "ran_for", receiverRun.RanFor)
+
if !sleepCtx(ctx, respawnBackoff) {
return nil
}
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_upload.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_upload.go
index b0af4024..d6531440 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_upload.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_upload.go
@@ -9,6 +9,7 @@ import (
"log/slog"
"os"
"sync"
+ "sync/atomic"
"time"
"github.com/google/uuid"
@@ -63,6 +64,9 @@ type WalUploader struct {
// The uploader loop retries every second, so a torn segment that never gets
// re-streamed would otherwise warn once per second forever.
warnedIncompleteSegments map[string]struct{}
+
+ archivedSegments atomic.Int64
+ archivedBytes atomic.Int64
}
func NewWalUploader(deps WalUploadDeps) *WalUploader {
@@ -174,11 +178,18 @@ func (u *WalUploader) RecoverSegment(ctx context.Context, localPath, walFilename
return u.uploadAndCommit(ctx, localPath, existing)
}
+// One rollup line per interval, so the counters are consumed rather than read.
+func (u *WalUploader) TakeArchivedSinceLastReport() (int64, int64) {
+ return u.archivedSegments.Swap(0), u.archivedBytes.Swap(0)
+}
+
// handleClaimConflict resolves a lost ClaimInsert race by probing the existing
// row: a durably-completed segment (file_name NOT NULL) means our local copy is
// redundant; an in-flight claim (file_name NULL) means a live or
// not-yet-reaped owner holds it, so we leave the local file untouched.
func (u *WalUploader) handleClaimConflict(localPath string, claim *physical_models.PhysicalWalSegment) error {
+ logger := u.deps.Logger.With("wal_filename", claim.WalFilename, "wal_segment_id", claim.ID)
+
existing, err := u.deps.WalSegmentRepo.FindByChainKey(claim.DatabaseID, claim.TimelineID, claim.StartLSN)
if err != nil {
return fmt.Errorf("probe existing wal claim: %w", err)
@@ -187,17 +198,24 @@ func (u *WalUploader) handleClaimConflict(localPath string, claim *physical_mode
if existing == nil {
// Row vanished between the conflict and the probe — leave the local file;
// the next uploader tick re-claims.
+ logger.Debug("wal claim row vanished before the probe, re-claiming on the next tick")
+
return nil
}
if existing.FileName != nil {
+ logger.Debug("wal segment already durable, dropping the local copy")
+
u.removeLocal(localPath, claim.WalFilename)
return nil
}
// In-flight claim: do not touch storage, leave the local file for a later tick
- // (the cleaner reaps the stale NULL claim after its grace period).
+ // (the cleaner reaps the stale NULL claim after its grace period). Until that happens this
+ // segment cannot be archived by anyone, so it is worth more than a debug line.
+ logger.Warn("wal segment is held by another in-flight claim, leaving it queued locally")
+
return nil
}
@@ -257,6 +275,10 @@ func (u *WalUploader) uploadAndCommit(
if !committed {
// DeleteFull cascade caught the claim mid-upload: the bytes are an orphan
// the cleaner can no longer see (its row is gone), so delete them here.
+ u.deps.Logger.DebugContext(ctx,
+ "discarding an uploaded wal segment, its chain was deleted mid-upload",
+ "wal_filename", claim.WalFilename, "wal_segment_id", claim.ID)
+
u.deleteObject(objectName)
u.deleteObject(objectName + metadataSuffix)
u.removeLocal(localPath, claim.WalFilename)
@@ -264,12 +286,27 @@ func (u *WalUploader) uploadAndCommit(
return nil
}
+ u.recordArchived(compressedSizeBytes)
+
+ // Per segment rather than per archive: a busy cluster finalizes one every few seconds, which
+ // would swamp INFO. The periodic rollup carries the same information at a readable rate.
+ u.deps.Logger.DebugContext(ctx, fmt.Sprintf("archived wal segment %s (%.2f MB)",
+ claim.WalFilename, float64(compressedSizeBytes)/(1024*1024)),
+ "wal_segment_id", claim.ID, "timeline_id", claim.TimelineID)
+
u.probeChainGap(claim)
u.removeLocal(localPath, claim.WalFilename)
return nil
}
+// recordArchived accumulates what the periodic rollup reports, so that INFO can answer "is WAL
+// reaching storage" without a line per segment.
+func (u *WalUploader) recordArchived(compressedSizeBytes int64) {
+ u.archivedSegments.Add(1)
+ u.archivedBytes.Add(compressedSizeBytes)
+}
+
// probeChainGap emits one notification when the just-committed segment is not
// LSN-contiguous with the previous committed segment on its timeline. It is a
// read-only check (no catalog row is written for the gap) de-duplicated by
@@ -352,7 +389,12 @@ func (u *WalUploader) releaseClaim(id uuid.UUID) {
}
func (u *WalUploader) deleteObject(objectName string) {
- if err := u.deps.Storage.DeleteFile(u.deps.FieldEncryptor, objectName); err != nil {
+ if err := u.deps.Storage.DeleteFile(
+ context.Background(),
+ u.deps.FieldEncryptor,
+ u.deps.Logger,
+ objectName,
+ ); err != nil {
u.deps.Logger.Warn("failed to delete orphaned wal storage object", "file_name", objectName, "error", err)
}
}
diff --git a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_watch_dir.go b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_watch_dir.go
index 06af1688..e3fc3e66 100644
--- a/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_watch_dir.go
+++ b/backend/internal/features/backups/backups/usecases/physical/postgresql/wal_watch_dir.go
@@ -60,7 +60,10 @@ func (s *WalStreamSupervisor) recoverLocalSegmentsOnStartup(ctx context.Context,
switch {
case walmath.IsWalFilename(name):
if err := s.uploader.RecoverSegment(ctx, filepath.Join(s.watchDir, name), name); err != nil {
- logger.Warn("startup wal recovery failed; live loop will retry", "wal_filename", name, "error", err)
+ logger.WarnContext(ctx, "startup wal recovery failed; live loop will retry",
+ "wal_filename", name,
+ "error", err,
+ )
}
case strings.HasSuffix(name, ".history"):
@@ -74,7 +77,7 @@ func (s *WalStreamSupervisor) recoverLocalSegmentsOnStartup(ctx context.Context,
func (s *WalStreamSupervisor) scanAndUpload(ctx context.Context, logger *slog.Logger) {
entries, err := os.ReadDir(s.watchDir)
if err != nil {
- logger.Error("read wal watch dir", "error", err)
+ logger.ErrorContext(ctx, "read wal watch dir", "error", err)
return
}
@@ -89,7 +92,10 @@ func (s *WalStreamSupervisor) scanAndUpload(ctx context.Context, logger *slog.Lo
switch {
case walmath.IsWalFilename(name):
if err := s.uploader.ProcessSegment(ctx, filepath.Join(s.watchDir, name), name); err != nil {
- logger.Warn("wal segment upload failed; will retry next tick", "wal_filename", name, "error", err)
+ logger.WarnContext(ctx, "wal segment upload failed; will retry next tick",
+ "wal_filename", name,
+ "error", err,
+ )
}
case strings.HasSuffix(name, ".history"):
@@ -120,7 +126,7 @@ func (s *WalStreamSupervisor) sweepPendingUploads(
}
if err := upload(ctx, filepath.Join(pendingUploadDir, entry.Name()), entry.Name()); err != nil {
- logger.Warn("pending wal segment upload failed; will retry next tick",
+ logger.WarnContext(ctx, "pending wal segment upload failed; will retry next tick",
"wal_filename", entry.Name(), "error", err)
}
}
@@ -131,14 +137,14 @@ func (s *WalStreamSupervisor) sweepPendingUploads(
func (s *WalStreamSupervisor) archiveTimelineHistoryFile(ctx context.Context, logger *slog.Logger, name string) {
timelineID, err := parseHistoryTimeline(name)
if err != nil {
- logger.Warn("skip unparseable history file", "name", name, "error", err)
+ logger.WarnContext(ctx, "skip unparseable history file", "name", name, "error", err)
return
}
conn, err := s.spec.SourceDB.OpenInspectionConn(ctx, s.spec.FieldEncryptor)
if err != nil {
- logger.Warn("could not open connection to upload history file; will retry", "error", err)
+ logger.WarnContext(ctx, "could not open connection to upload history file; will retry", "error", err)
return
}
@@ -148,15 +154,15 @@ func (s *WalStreamSupervisor) archiveTimelineHistoryFile(ctx context.Context, lo
ctx, conn, timelineID, s.spec.Storage, s.spec.SourceDB, s.spec.StorageID,
s.spec.HistoryRepo, s.spec.Encryption, s.spec.MasterKey, s.spec.FieldEncryptor, logger,
); err != nil {
- logger.Warn("history upload failed; will retry next tick", "timeline_id", timelineID, "error", err)
+ logger.WarnContext(ctx, "history upload failed; will retry next tick", "timeline_id", timelineID, "error", err)
return
}
- logger.Info("timeline switch observed via .history", "timeline_id", timelineID)
+ logger.InfoContext(ctx, "timeline switch observed via .history", "timeline_id", timelineID)
if err := os.Remove(filepath.Join(s.watchDir, name)); err != nil && !os.IsNotExist(err) {
- logger.Warn("failed to remove uploaded history file", "name", name, "error", err)
+ logger.WarnContext(ctx, "failed to remove uploaded history file", "name", name, "error", err)
}
}
diff --git a/backend/internal/features/backups/config/cross_strategy_storage_test.go b/backend/internal/features/backups/config/cross_strategy_storage_test.go
index f7355ecf..e1e76a27 100644
--- a/backend/internal/features/backups/config/cross_strategy_storage_test.go
+++ b/backend/internal/features/backups/config/cross_strategy_storage_test.go
@@ -44,21 +44,21 @@ func createCrossStrategyRouter() *gin.Engine {
func Test_StorageDeletion_WithPhysicalOnlyAttachment_BlocksDeletion(t *testing.T) {
router := createCrossStrategyRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
notifier := notifiers.CreateTestNotifier(workspace.ID)
physicalDatabase := databases.CreateTestPhysicalPostgresDatabase(workspace.ID, notifier, "17")
storage := storages.CreateTestStorage(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(physicalDatabase)
- storages.RemoveTestStorage(storage.ID)
+ databases.RemoveTestDatabase(t.Context(), physicalDatabase)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
- backups_config_physical.EnableBackupsForPhysicalTestDatabase(physicalDatabase.ID, storage)
+ backups_config_physical.EnableBackupsForPhysicalTestDatabase(t.Context(), physicalDatabase.ID, storage)
testResp := test_utils.MakeDeleteRequest(
t, router,
@@ -72,21 +72,21 @@ func Test_StorageDeletion_WithPhysicalOnlyAttachment_BlocksDeletion(t *testing.T
func Test_StorageDeletion_WithLogicalOnlyAttachment_BlocksDeletion(t *testing.T) {
router := createCrossStrategyRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
notifier := notifiers.CreateTestNotifier(workspace.ID)
storage := storages.CreateTestStorage(workspace.ID)
logicalDatabase := databases.CreateTestDatabase(workspace.ID, storage, notifier)
defer func() {
- databases.RemoveTestDatabase(logicalDatabase)
- storages.RemoveTestStorage(storage.ID)
+ databases.RemoveTestDatabase(t.Context(), logicalDatabase)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
- backups_config_logical.EnableBackupsForTestDatabase(logicalDatabase.ID, storage)
+ backups_config_logical.EnableBackupsForTestDatabase(t.Context(), logicalDatabase.ID, storage)
testResp := test_utils.MakeDeleteRequest(
t, router,
@@ -100,21 +100,21 @@ func Test_StorageDeletion_WithLogicalOnlyAttachment_BlocksDeletion(t *testing.T)
func Test_StorageIsUsing_WithPhysicalOnlyAttachment_ReportsTrue(t *testing.T) {
router := createCrossStrategyRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
notifier := notifiers.CreateTestNotifier(workspace.ID)
physicalDatabase := databases.CreateTestPhysicalPostgresDatabase(workspace.ID, notifier, "17")
storage := storages.CreateTestStorage(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(physicalDatabase)
- storages.RemoveTestStorage(storage.ID)
+ databases.RemoveTestDatabase(t.Context(), physicalDatabase)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
- backups_config_physical.EnableBackupsForPhysicalTestDatabase(physicalDatabase.ID, storage)
+ backups_config_physical.EnableBackupsForPhysicalTestDatabase(t.Context(), physicalDatabase.ID, storage)
var response map[string]bool
test_utils.MakeGetRequestAndUnmarshal(
@@ -130,13 +130,13 @@ func Test_StorageIsUsing_WithPhysicalOnlyAttachment_ReportsTrue(t *testing.T) {
func Test_StorageDeletion_WithNoAttachment_Succeeds(t *testing.T) {
router := createCrossStrategyRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := storages.CreateTestStorage(workspace.ID)
defer func() {
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
test_utils.MakeDeleteRequest(
diff --git a/backend/internal/features/backups/config/logical/controller.go b/backend/internal/features/backups/config/logical/controller.go
index 27c020e0..8f1dce5d 100644
--- a/backend/internal/features/backups/config/logical/controller.go
+++ b/backend/internal/features/backups/config/logical/controller.go
@@ -17,7 +17,7 @@ type BackupConfigController struct {
func (c *BackupConfigController) RegisterRoutes(router *gin.RouterGroup) {
router.POST("/backup-configs/save", c.SaveBackupConfig)
router.GET("/backup-configs/database/:id", c.GetBackupConfigByDbID)
- router.GET("/backup-configs/storage/:id/is-using", c.IsStorageUsing)
+ router.GET("/backup-configs/storage/:id/is-using", c.IsStorageInUse)
router.GET("/backup-configs/storage/:id/databases-count", c.CountDatabasesForStorage)
router.POST("/backup-configs/database/:id/transfer", c.TransferDatabase)
}
@@ -50,7 +50,7 @@ func (c *BackupConfigController) SaveBackupConfig(ctx *gin.Context) {
// make sure we rely on full .Storage object
requestDTO.StorageID = nil
- savedConfig, err := c.backupConfigService.SaveBackupConfigWithAuth(user, &requestDTO)
+ savedConfig, err := c.backupConfigService.SaveBackupConfigWithAuth(ctx.Request.Context(), user, &requestDTO)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -83,7 +83,7 @@ func (c *BackupConfigController) GetBackupConfigByDbID(ctx *gin.Context) {
return
}
- backupConfig, err := c.backupConfigService.GetBackupConfigByDbIdWithAuth(user, id)
+ backupConfig, err := c.backupConfigService.GetBackupConfigByDbIdWithAuth(ctx.Request.Context(), user, id)
if err != nil {
ctx.JSON(http.StatusNotFound, gin.H{"error": "backup configuration not found"})
return
@@ -92,7 +92,7 @@ func (c *BackupConfigController) GetBackupConfigByDbID(ctx *gin.Context) {
ctx.JSON(http.StatusOK, backupConfig)
}
-// IsStorageUsing
+// IsStorageInUse
// @Summary Check if storage is being used
// @Description Check if a storage is currently being used by any backup configuration
// @Tags backup-configs
@@ -103,7 +103,7 @@ func (c *BackupConfigController) GetBackupConfigByDbID(ctx *gin.Context) {
// @Failure 401
// @Failure 500
// @Router /backup-configs/storage/{id}/is-using [get]
-func (c *BackupConfigController) IsStorageUsing(ctx *gin.Context) {
+func (c *BackupConfigController) IsStorageInUse(ctx *gin.Context) {
user, ok := users_middleware.GetUserFromContext(ctx)
if !ok {
ctx.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
@@ -116,8 +116,9 @@ func (c *BackupConfigController) IsStorageUsing(ctx *gin.Context) {
return
}
- isUsing, err := c.backupConfigService.IsStorageUsing(user, id)
+ isUsing, err := c.backupConfigService.IsStorageInUse(ctx.Request.Context(), user, id)
if err != nil {
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
@@ -149,8 +150,9 @@ func (c *BackupConfigController) CountDatabasesForStorage(ctx *gin.Context) {
return
}
- count, err := c.backupConfigService.CountDatabasesForStorage(user, id)
+ count, err := c.backupConfigService.CountDatabasesForStorage(ctx.Request.Context(), user, id)
if err != nil {
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
@@ -195,7 +197,7 @@ func (c *BackupConfigController) TransferDatabase(ctx *gin.Context) {
return
}
- if err := c.backupConfigService.TransferDatabaseToWorkspace(user, id, &request); err != nil {
+ if err := c.backupConfigService.TransferDatabaseToWorkspace(ctx.Request.Context(), user, id, &request); err != nil {
if errors.Is(err, ErrInsufficientPermissionsInSourceWorkspace) ||
errors.Is(err, ErrInsufficientPermissionsInTargetWorkspace) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
diff --git a/backend/internal/features/backups/config/logical/controller_test.go b/backend/internal/features/backups/config/logical/controller_test.go
index 74d67448..8d3ebb42 100644
--- a/backend/internal/features/backups/config/logical/controller_test.go
+++ b/backend/internal/features/backups/config/logical/controller_test.go
@@ -86,24 +86,24 @@ func Test_SaveBackupConfig_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -155,17 +155,17 @@ func Test_SaveBackupConfig_PermissionsEnforced(t *testing.T) {
func Test_SaveBackupConfig_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
timeOfDay := "04:00"
request := LogicalBackupConfig{
@@ -251,24 +251,24 @@ func Test_GetBackupConfigByDbID_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -278,7 +278,7 @@ func Test_GetBackupConfigByDbID_PermissionsEnforced(t *testing.T) {
)
testUserToken = member.Token
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUserToken = nonMember.Token
}
@@ -304,14 +304,14 @@ func Test_GetBackupConfigByDbID_PermissionsEnforced(t *testing.T) {
func Test_GetBackupConfigByDbID_ReturnsDefaultConfigForNewDatabase(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
var response LogicalBackupConfig
@@ -331,7 +331,7 @@ func Test_GetBackupConfigByDbID_ReturnsDefaultConfigForNewDatabase(t *testing.T)
assert.NotNil(t, response.BackupInterval)
}
-func Test_IsStorageUsing_PermissionsEnforced(t *testing.T) {
+func Test_IsStorageInUse_PermissionsEnforced(t *testing.T) {
tests := []struct {
name string
isStorageOwner bool
@@ -355,8 +355,8 @@ func Test_IsStorageUsing_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- storageOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ storageOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Test Workspace",
storageOwner,
router,
@@ -364,14 +364,14 @@ func Test_IsStorageUsing_PermissionsEnforced(t *testing.T) {
storage := createTestStorage(workspace.ID)
defer func() {
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
var testUserToken string
if tt.isStorageOwner {
testUserToken = storageOwner.Token
} else {
- otherUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ otherUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUserToken = otherUser.Token
}
@@ -405,14 +405,14 @@ func Test_IsStorageUsing_PermissionsEnforced(t *testing.T) {
func Test_SaveBackupConfig_WithEncryptionNone_ConfigSaved(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
timeOfDay := "04:00"
@@ -450,14 +450,14 @@ func Test_SaveBackupConfig_WithEncryptionNone_ConfigSaved(t *testing.T) {
func Test_SaveBackupConfig_WithEncryptionEncrypted_ConfigSaved(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
timeOfDay := "04:00"
@@ -548,15 +548,15 @@ func Test_TransferDatabase_PermissionsEnforced(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouterWithStorageForTransfer()
- sourceOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- targetOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ targetOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace(
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Source Workspace",
sourceOwner,
router,
)
- targetWorkspace := workspaces_testing.CreateTestWorkspace(
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Target Workspace",
targetOwner,
router,
@@ -573,19 +573,19 @@ func Test_TransferDatabase_PermissionsEnforced(t *testing.T) {
defer func() {
// Cleanup in correct order to avoid foreign key violations
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond) // Wait for cascade delete of backup_config
- storages.RemoveTestStorage(targetStorage.ID)
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ storages.RemoveTestStorage(t.Context(), targetStorage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.sourceRole != nil {
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
if *tt.sourceRole == users_enums.WorkspaceRoleOwner {
testUserToken = sourceOwner.Token
workspaces_testing.AddMemberToWorkspace(
@@ -651,15 +651,15 @@ func Test_TransferDatabase_PermissionsEnforced(t *testing.T) {
func Test_TransferDatabase_NonMemberInSourceWorkspace_CannotTransfer(t *testing.T) {
router := createTestRouterWithStorageForTransfer()
- sourceOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- targetOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ targetOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace(
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Source Workspace",
sourceOwner,
router,
)
- targetWorkspace := workspaces_testing.CreateTestWorkspace(
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Target Workspace",
targetOwner,
router,
@@ -673,9 +673,9 @@ func Test_TransferDatabase_NonMemberInSourceWorkspace_CannotTransfer(t *testing.
)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
request := TransferDatabaseRequest{
@@ -697,15 +697,15 @@ func Test_TransferDatabase_NonMemberInSourceWorkspace_CannotTransfer(t *testing.
func Test_TransferDatabase_NonMemberInTargetWorkspace_CannotTransfer(t *testing.T) {
router := createTestRouterWithStorageForTransfer()
- sourceOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- targetOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ targetOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace(
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Source Workspace",
sourceOwner,
router,
)
- targetWorkspace := workspaces_testing.CreateTestWorkspace(
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Target Workspace",
targetOwner,
router,
@@ -719,9 +719,9 @@ func Test_TransferDatabase_NonMemberInTargetWorkspace_CannotTransfer(t *testing.
)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
request := TransferDatabaseRequest{
@@ -743,19 +743,19 @@ func Test_TransferDatabase_NonMemberInTargetWorkspace_CannotTransfer(t *testing.
func Test_TransferDatabase_ToNewStorage_DatabaseTransferd(t *testing.T) {
router := createTestRouterWithStorageForTransfer()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
- targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Target Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
sourceStorage := createTestStorage(sourceWorkspace.ID)
targetStorage := createTestStorage(targetWorkspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(200 * time.Millisecond) // Wait for cascading deletes
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
timeOfDay := "04:00"
@@ -831,18 +831,18 @@ func Test_TransferDatabase_ToNewStorage_DatabaseTransferd(t *testing.T) {
func Test_TransferDatabase_WithExistingStorage_DatabaseAndStorageTransferd(t *testing.T) {
router := createTestRouterWithStorageForTransfer()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
- targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Target Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
storage := createTestStorage(sourceWorkspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(200 * time.Millisecond) // Wait for cascading deletes
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
timeOfDay := "04:00"
@@ -917,9 +917,9 @@ func Test_TransferDatabase_WithExistingStorage_DatabaseAndStorageTransferd(t *te
func Test_TransferDatabase_StorageHasOtherDBs_CannotTransfer(t *testing.T) {
router := createTestRouterWithStorageForTransfer()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
- targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Target Workspace", owner, router)
database1 := createTestDatabaseViaAPI(
"Test Database 1",
@@ -936,11 +936,11 @@ func Test_TransferDatabase_StorageHasOtherDBs_CannotTransfer(t *testing.T) {
storage := createTestStorage(sourceWorkspace.ID)
defer func() {
- databases.RemoveTestDatabase(database1)
- databases.RemoveTestDatabase(database2)
+ databases.RemoveTestDatabase(t.Context(), database1)
+ databases.RemoveTestDatabase(t.Context(), database2)
time.Sleep(200 * time.Millisecond) // Wait for cascading deletes
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
timeOfDay := "04:00"
@@ -1018,9 +1018,9 @@ func Test_TransferDatabase_StorageHasOtherDBs_CannotTransfer(t *testing.T) {
func Test_TransferDatabase_WithNotifiers_NotifiersTransferred(t *testing.T) {
router := createTestRouterWithNotifiersForTransfer()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
- targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Target Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
sourceStorage := createTestStorage(sourceWorkspace.ID)
@@ -1028,11 +1028,11 @@ func Test_TransferDatabase_WithNotifiers_NotifiersTransferred(t *testing.T) {
notifier := notifiers.CreateTestNotifier(sourceWorkspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(200 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
database.Notifiers = []notifiers.Notifier{*notifier}
@@ -1119,9 +1119,9 @@ func Test_TransferDatabase_WithNotifiers_NotifiersTransferred(t *testing.T) {
func Test_TransferDatabase_NotifierHasOtherDBs_NotifierSkipped(t *testing.T) {
router := createTestRouterWithNotifiersForTransfer()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
- targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Target Workspace", owner, router)
database1 := createTestDatabaseViaAPI(
"Test Database 1",
@@ -1140,12 +1140,12 @@ func Test_TransferDatabase_NotifierHasOtherDBs_NotifierSkipped(t *testing.T) {
sharedNotifier := notifiers.CreateTestNotifier(sourceWorkspace.ID)
defer func() {
- databases.RemoveTestDatabase(database1)
- databases.RemoveTestDatabase(database2)
+ databases.RemoveTestDatabase(t.Context(), database1)
+ databases.RemoveTestDatabase(t.Context(), database2)
time.Sleep(200 * time.Millisecond)
notifiers.RemoveTestNotifier(sharedNotifier)
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
database1.Notifiers = []notifiers.Notifier{*sharedNotifier}
@@ -1239,9 +1239,9 @@ func Test_TransferDatabase_NotifierHasOtherDBs_NotifierSkipped(t *testing.T) {
func Test_TransferDatabase_WithMultipleNotifiers_OnlyExclusiveOnesTransferred(t *testing.T) {
router := createTestRouterWithNotifiersForTransfer()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
- targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Target Workspace", owner, router)
database1 := createTestDatabaseViaAPI(
"Test Database 1",
@@ -1262,13 +1262,13 @@ func Test_TransferDatabase_WithMultipleNotifiers_OnlyExclusiveOnesTransferred(t
sharedNotifier := notifiers.CreateTestNotifier(sourceWorkspace.ID)
defer func() {
- databases.RemoveTestDatabase(database1)
- databases.RemoveTestDatabase(database2)
+ databases.RemoveTestDatabase(t.Context(), database1)
+ databases.RemoveTestDatabase(t.Context(), database2)
time.Sleep(200 * time.Millisecond)
notifiers.RemoveTestNotifier(exclusiveNotifier)
notifiers.RemoveTestNotifier(sharedNotifier)
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
database1.Notifiers = []notifiers.Notifier{*exclusiveNotifier, *sharedNotifier}
@@ -1374,9 +1374,9 @@ func Test_TransferDatabase_WithMultipleNotifiers_OnlyExclusiveOnesTransferred(t
func Test_TransferDatabase_WithTargetNotifiers_NotifiersAssigned(t *testing.T) {
router := createTestRouterWithNotifiersForTransfer()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
- targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Target Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
sourceStorage := createTestStorage(sourceWorkspace.ID)
@@ -1384,11 +1384,11 @@ func Test_TransferDatabase_WithTargetNotifiers_NotifiersAssigned(t *testing.T) {
targetNotifier := notifiers.CreateTestNotifier(targetWorkspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(200 * time.Millisecond)
notifiers.RemoveTestNotifier(targetNotifier)
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
timeOfDay := "04:00"
@@ -1453,10 +1453,10 @@ func Test_TransferDatabase_WithTargetNotifiers_NotifiersAssigned(t *testing.T) {
func Test_TransferDatabase_TargetNotifierFromDifferentWorkspace_ReturnsBadRequest(t *testing.T) {
router := createTestRouterWithNotifiersForTransfer()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
- targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
- otherWorkspace := workspaces_testing.CreateTestWorkspace("Other Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Target Workspace", owner, router)
+ otherWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Other Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
sourceStorage := createTestStorage(sourceWorkspace.ID)
@@ -1464,12 +1464,12 @@ func Test_TransferDatabase_TargetNotifierFromDifferentWorkspace_ReturnsBadReques
wrongNotifier := notifiers.CreateTestNotifier(otherWorkspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(200 * time.Millisecond)
notifiers.RemoveTestNotifier(wrongNotifier)
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(otherWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), otherWorkspace, router)
}()
timeOfDay := "04:00"
@@ -1521,21 +1521,21 @@ func Test_TransferDatabase_TargetNotifierFromDifferentWorkspace_ReturnsBadReques
func Test_TransferDatabase_TargetStorageFromDifferentWorkspace_ReturnsBadRequest(t *testing.T) {
router := createTestRouterWithNotifiersForTransfer()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
- targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
- otherWorkspace := workspaces_testing.CreateTestWorkspace("Other Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Target Workspace", owner, router)
+ otherWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Other Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
sourceStorage := createTestStorage(sourceWorkspace.ID)
wrongStorage := createTestStorage(otherWorkspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(200 * time.Millisecond)
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(otherWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), otherWorkspace, router)
}()
timeOfDay := "04:00"
@@ -1586,11 +1586,11 @@ func Test_TransferDatabase_TargetStorageFromDifferentWorkspace_ReturnsBadRequest
func Test_SaveBackupConfig_WithStorageFromAnotherWorkspace_ReturnsBadRequest(t *testing.T) {
router := createTestRouterWithStorageForTransfer()
- owner1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- owner2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ owner2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspaceA := workspaces_testing.CreateTestWorkspace("Workspace A", owner1, router)
- workspaceB := workspaces_testing.CreateTestWorkspace("Workspace B", owner2, router)
+ workspaceA := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace A", owner1, router)
+ workspaceB := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace B", owner2, router)
databaseA := createTestDatabaseViaAPI("Database A", workspaceA.ID, owner1.Token, router)
@@ -1628,10 +1628,10 @@ func Test_SaveBackupConfig_WithStorageFromAnotherWorkspace_ReturnsBadRequest(t *
assert.Contains(t, string(resp.Body), "storage does not belong to the same workspace")
// Cleanup: database first (cascades to backup_config), then storage, then workspaces
- databases.RemoveTestDatabase(databaseA)
- storages.RemoveTestStorage(storageB.ID)
- workspaces_testing.RemoveTestWorkspace(workspaceA, router)
- workspaces_testing.RemoveTestWorkspace(workspaceB, router)
+ databases.RemoveTestDatabase(t.Context(), databaseA)
+ storages.RemoveTestStorage(t.Context(), storageB.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspaceA, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspaceB, router)
}
func createTestDatabaseViaAPI(
diff --git a/backend/internal/features/backups/config/logical/interfaces.go b/backend/internal/features/backups/config/logical/interfaces.go
index d8bdf2d1..d7794b45 100644
--- a/backend/internal/features/backups/config/logical/interfaces.go
+++ b/backend/internal/features/backups/config/logical/interfaces.go
@@ -1,7 +1,11 @@
package backups_config_logical
-import "github.com/google/uuid"
+import (
+ "context"
+
+ "github.com/google/uuid"
+)
type BackupConfigStorageChangeListener interface {
- OnBeforeBackupsStorageChange(dbID uuid.UUID) error
+ OnBeforeBackupsStorageChange(ctx context.Context, dbID uuid.UUID) error
}
diff --git a/backend/internal/features/backups/config/logical/notifiers_test.go b/backend/internal/features/backups/config/logical/notifiers_test.go
index 749677ba..fe22413d 100644
--- a/backend/internal/features/backups/config/logical/notifiers_test.go
+++ b/backend/internal/features/backups/config/logical/notifiers_test.go
@@ -20,16 +20,16 @@ import (
func Test_AttachNotifierFromSameWorkspace_SuccessfullyAttached(t *testing.T) {
router := createTestRouterWithNotifier()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
database.Notifiers = []notifiers.Notifier{*notifier}
@@ -53,19 +53,19 @@ func Test_AttachNotifierFromSameWorkspace_SuccessfullyAttached(t *testing.T) {
func Test_AttachNotifierFromDifferentWorkspace_ReturnsForbidden(t *testing.T) {
router := createTestRouterWithNotifier()
- owner1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", owner1, router)
+ owner1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace1 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 1", owner1, router)
database := createTestDatabaseViaAPI("Test Database", workspace1.ID, owner1.Token, router)
- owner2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", owner2, router)
+ owner2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace2 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 2", owner2, router)
notifier := notifiers.CreateTestNotifier(workspace2.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace1, router)
- workspaces_testing.RemoveTestWorkspace(workspace2, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace1, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace2, router)
}()
database.Notifiers = []notifiers.Notifier{*notifier}
@@ -84,16 +84,16 @@ func Test_AttachNotifierFromDifferentWorkspace_ReturnsForbidden(t *testing.T) {
func Test_DeleteNotifierWithAttachedDatabases_CannotDelete(t *testing.T) {
router := createTestRouterWithNotifier()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
database.Notifiers = []notifiers.Notifier{*notifier}
@@ -126,18 +126,18 @@ func Test_DeleteNotifierWithAttachedDatabases_CannotDelete(t *testing.T) {
func Test_TransferNotifierWithAttachedDatabase_CannotTransfer(t *testing.T) {
router := createTestRouterWithNotifier()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Target Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
database.Notifiers = []notifiers.Notifier{*notifier}
diff --git a/backend/internal/features/backups/config/logical/repository.go b/backend/internal/features/backups/config/logical/repository.go
index 77a9cfc7..fc4dea56 100644
--- a/backend/internal/features/backups/config/logical/repository.go
+++ b/backend/internal/features/backups/config/logical/repository.go
@@ -73,7 +73,7 @@ func (r *BackupConfigRepository) GetWithEnabledBackups() ([]*LogicalBackupConfig
return backupConfigs, nil
}
-func (r *BackupConfigRepository) IsStorageUsing(storageID uuid.UUID) (bool, error) {
+func (r *BackupConfigRepository) IsStorageInUse(storageID uuid.UUID) (bool, error) {
var count int64
if err := storage.
diff --git a/backend/internal/features/backups/config/logical/service.go b/backend/internal/features/backups/config/logical/service.go
index c4c58abc..f4f1bbef 100644
--- a/backend/internal/features/backups/config/logical/service.go
+++ b/backend/internal/features/backups/config/logical/service.go
@@ -1,6 +1,7 @@
package backups_config_logical
import (
+ "context"
"errors"
"github.com/google/uuid"
@@ -43,6 +44,7 @@ func (s *BackupConfigService) GetStorageAttachedDatabasesIDs(
}
func (s *BackupConfigService) SaveBackupConfigWithAuth(
+ ctx context.Context,
user *users_models.User,
backupConfig *LogicalBackupConfig,
) (*LogicalBackupConfig, error) {
@@ -50,7 +52,7 @@ func (s *BackupConfigService) SaveBackupConfigWithAuth(
return nil, err
}
- database, err := s.databaseService.GetDatabase(user, backupConfig.DatabaseID)
+ database, err := s.databaseService.GetDatabase(ctx, user, backupConfig.DatabaseID)
if err != nil {
return nil, err
}
@@ -59,7 +61,7 @@ func (s *BackupConfigService) SaveBackupConfigWithAuth(
return nil, errors.New("cannot save backup config for database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -68,7 +70,7 @@ func (s *BackupConfigService) SaveBackupConfigWithAuth(
}
if backupConfig.Storage != nil && backupConfig.Storage.ID != uuid.Nil {
- storage, err := s.storageService.GetStorageByID(backupConfig.Storage.ID)
+ storage, err := s.storageService.GetStorageByID(ctx, backupConfig.Storage.ID)
if err != nil {
return nil, err
}
@@ -77,10 +79,11 @@ func (s *BackupConfigService) SaveBackupConfigWithAuth(
}
}
- return s.SaveBackupConfig(backupConfig)
+ return s.SaveBackupConfig(ctx, backupConfig)
}
func (s *BackupConfigService) SaveBackupConfig(
+ ctx context.Context,
backupConfig *LogicalBackupConfig,
) (*LogicalBackupConfig, error) {
if err := backupConfig.Validate(); err != nil {
@@ -98,7 +101,7 @@ func (s *BackupConfigService) SaveBackupConfig(
if s.dbStorageChangeListener != nil &&
backupConfig.Storage != nil &&
!storageIDsEqual(existingConfig.StorageID, &backupConfig.Storage.ID) {
- if err := s.dbStorageChangeListener.OnBeforeBackupsStorageChange(
+ if err := s.dbStorageChangeListener.OnBeforeBackupsStorageChange(ctx,
backupConfig.DatabaseID,
); err != nil {
return nil, err
@@ -110,10 +113,11 @@ func (s *BackupConfigService) SaveBackupConfig(
}
func (s *BackupConfigService) GetBackupConfigByDbIdWithAuth(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
) (*LogicalBackupConfig, error) {
- _, err := s.databaseService.GetDatabase(user, databaseID)
+ _, err := s.databaseService.GetDatabase(ctx, user, databaseID)
if err != nil {
return nil, err
}
@@ -141,35 +145,37 @@ func (s *BackupConfigService) GetBackupConfigByDbId(
return config, nil
}
-func (s *BackupConfigService) IsStorageUsing(
+func (s *BackupConfigService) IsStorageInUse(
+ ctx context.Context,
user *users_models.User,
storageID uuid.UUID,
) (bool, error) {
- _, err := s.storageService.GetStorage(user, storageID)
+ _, err := s.storageService.GetStorage(ctx, user, storageID)
if err != nil {
return false, err
}
- return s.storageService.IsStorageUsing(storageID)
+ return s.storageService.IsStorageInUse(ctx, storageID)
}
func (s *BackupConfigService) CountDatabasesForStorage(
+ ctx context.Context,
user *users_models.User,
storageID uuid.UUID,
) (int, error) {
- _, err := s.storageService.GetStorage(user, storageID)
+ _, err := s.storageService.GetStorage(ctx, user, storageID)
if err != nil {
return 0, err
}
- return s.storageService.CountDatabasesForStorage(storageID)
+ return s.storageService.CountDatabasesForStorage(ctx, storageID)
}
func (s *BackupConfigService) GetBackupConfigsWithEnabledBackups() ([]*LogicalBackupConfig, error) {
return s.backupConfigRepository.GetWithEnabledBackups()
}
-func (s *BackupConfigService) OnDatabaseCopied(originalDatabaseID, newDatabaseID uuid.UUID) {
+func (s *BackupConfigService) OnDatabaseCopied(ctx context.Context, originalDatabaseID, newDatabaseID uuid.UUID) {
originalConfig, err := s.GetBackupConfigByDbId(originalDatabaseID)
if err != nil {
return
@@ -177,7 +183,7 @@ func (s *BackupConfigService) OnDatabaseCopied(originalDatabaseID, newDatabaseID
newConfig := originalConfig.Copy(newDatabaseID)
- _, err = s.SaveBackupConfig(newConfig)
+ _, err = s.SaveBackupConfig(ctx, newConfig)
if err != nil {
return
}
@@ -188,6 +194,7 @@ func (s *BackupConfigService) CreateDisabledBackupConfig(databaseID uuid.UUID) e
}
func (s *BackupConfigService) TransferDatabaseToWorkspace(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
request *TransferDatabaseRequest,
@@ -201,7 +208,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
return ErrDatabaseHasNoWorkspace
}
- canManageSource, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManageSource, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return err
}
@@ -209,7 +216,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
return ErrInsufficientPermissionsInSourceWorkspace
}
- canManageTarget, err := s.workspaceService.CanUserManageDBs(request.TargetWorkspaceID, user)
+ canManageTarget, err := s.workspaceService.CanUserManageDBs(ctx, request.TargetWorkspaceID, user)
if err != nil {
return err
}
@@ -217,7 +224,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
return ErrInsufficientPermissionsInTargetWorkspace
}
- if err := s.validateTargetNotifiers(request); err != nil {
+ if err := s.validateTargetNotifiers(ctx, request); err != nil {
return err
}
@@ -227,7 +234,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
}
if request.IsTransferWithNotifiers {
- s.transferNotifiers(user, database, request.TargetWorkspaceID)
+ s.transferNotifiers(ctx, user, database, request.TargetWorkspaceID)
}
switch {
@@ -250,6 +257,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
}
err = s.storageService.TransferStorageToWorkspace(
+ ctx,
user,
*backupConfig.StorageID,
request.TargetWorkspaceID,
@@ -259,7 +267,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
return err
}
case request.TargetStorageID != nil:
- targetStorage, err := s.storageService.GetStorageByID(*request.TargetStorageID)
+ targetStorage, err := s.storageService.GetStorageByID(ctx, *request.TargetStorageID)
if err != nil {
return err
}
@@ -279,13 +287,13 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
return ErrTargetStorageNotSpecified
}
- err = s.databaseService.TransferDatabaseToWorkspace(databaseID, request.TargetWorkspaceID)
+ err = s.databaseService.TransferDatabaseToWorkspace(ctx, databaseID, request.TargetWorkspaceID)
if err != nil {
return err
}
if len(request.TargetNotifierIDs) > 0 {
- err = s.assignTargetNotifiers(databaseID, request.TargetNotifierIDs)
+ err = s.assignTargetNotifiers(ctx, databaseID, request.TargetNotifierIDs)
if err != nil {
return err
}
@@ -321,12 +329,14 @@ func (s *BackupConfigService) initializeDefaultConfig(
}
func (s *BackupConfigService) transferNotifiers(
+ ctx context.Context,
user *users_models.User,
database *databases.Database,
targetWorkspaceID uuid.UUID,
) {
for _, notifier := range database.Notifiers {
_ = s.notifierService.TransferNotifierToWorkspace(
+ ctx,
user,
notifier.ID,
targetWorkspaceID,
@@ -335,9 +345,9 @@ func (s *BackupConfigService) transferNotifiers(
}
}
-func (s *BackupConfigService) validateTargetNotifiers(request *TransferDatabaseRequest) error {
+func (s *BackupConfigService) validateTargetNotifiers(ctx context.Context, request *TransferDatabaseRequest) error {
for _, notifierID := range request.TargetNotifierIDs {
- notifier, err := s.notifierService.GetNotifierByID(notifierID)
+ notifier, err := s.notifierService.GetNotifierByID(ctx, notifierID)
if err != nil {
return err
}
@@ -350,13 +360,14 @@ func (s *BackupConfigService) validateTargetNotifiers(request *TransferDatabaseR
}
func (s *BackupConfigService) assignTargetNotifiers(
+ ctx context.Context,
databaseID uuid.UUID,
notifierIDs []uuid.UUID,
) error {
targetNotifiers := make([]notifiers.Notifier, 0, len(notifierIDs))
for _, notifierID := range notifierIDs {
- notifier, err := s.notifierService.GetNotifierByID(notifierID)
+ notifier, err := s.notifierService.GetNotifierByID(ctx, notifierID)
if err != nil {
return err
}
diff --git a/backend/internal/features/backups/config/logical/storages_test.go b/backend/internal/features/backups/config/logical/storages_test.go
index e02f61a4..32924710 100644
--- a/backend/internal/features/backups/config/logical/storages_test.go
+++ b/backend/internal/features/backups/config/logical/storages_test.go
@@ -22,16 +22,16 @@ import (
func Test_AttachStorageFromSameWorkspace_SuccessfullyAttached(t *testing.T) {
router := createTestRouterWithStorage()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
storage := createTestStorage(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
timeOfDay := "04:00"
@@ -72,19 +72,19 @@ func Test_AttachStorageFromSameWorkspace_SuccessfullyAttached(t *testing.T) {
func Test_AttachStorageFromDifferentWorkspace_ReturnsForbidden(t *testing.T) {
router := createTestRouterWithStorage()
- owner1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", owner1, router)
+ owner1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace1 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 1", owner1, router)
database := createTestDatabaseViaAPI("Test Database", workspace1.ID, owner1.Token, router)
- owner2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", owner2, router)
+ owner2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace2 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 2", owner2, router)
storage := createTestStorage(workspace2.ID)
defer func() {
- databases.RemoveTestDatabase(database)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace1, router)
- workspaces_testing.RemoveTestWorkspace(workspace2, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace1, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace2, router)
}()
timeOfDay := "04:00"
@@ -120,16 +120,16 @@ func Test_AttachStorageFromDifferentWorkspace_ReturnsForbidden(t *testing.T) {
func Test_DeleteStorageWithAttachedDatabases_CannotDelete(t *testing.T) {
router := createTestRouterWithStorage()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
storage := createTestStorage(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
timeOfDay := "04:00"
@@ -179,18 +179,18 @@ func Test_DeleteStorageWithAttachedDatabases_CannotDelete(t *testing.T) {
func Test_TransferStorageWithAttachedDatabase_CannotTransfer(t *testing.T) {
router := createTestRouterWithStorage()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Target Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
storage := createTestStorage(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
}()
timeOfDay := "04:00"
diff --git a/backend/internal/features/backups/config/logical/testing.go b/backend/internal/features/backups/config/logical/testing.go
index 63038f7f..c884f33a 100644
--- a/backend/internal/features/backups/config/logical/testing.go
+++ b/backend/internal/features/backups/config/logical/testing.go
@@ -1,6 +1,8 @@
package backups_config_logical
import (
+ "context"
+
"github.com/google/uuid"
"databasus-backend/internal/features/intervals"
@@ -9,6 +11,7 @@ import (
)
func EnableBackupsForTestDatabase(
+ ctx context.Context,
databaseID uuid.UUID,
storage *storages.Storage,
) *LogicalBackupConfig {
@@ -31,7 +34,7 @@ func EnableBackupsForTestDatabase(
},
}
- backupConfig, err := GetBackupConfigService().SaveBackupConfig(backupConfig)
+ backupConfig, err := GetBackupConfigService().SaveBackupConfig(ctx, backupConfig)
if err != nil {
panic(err)
}
diff --git a/backend/internal/features/backups/config/physical/controller.go b/backend/internal/features/backups/config/physical/controller.go
index 41101209..e0039acb 100644
--- a/backend/internal/features/backups/config/physical/controller.go
+++ b/backend/internal/features/backups/config/physical/controller.go
@@ -47,7 +47,7 @@ func (c *BackupConfigController) SaveBackupConfig(ctx *gin.Context) {
requestDTO.StorageID = nil
- savedConfig, err := c.backupConfigService.SaveBackupConfigWithAuth(user, &requestDTO)
+ savedConfig, err := c.backupConfigService.SaveBackupConfigWithAuth(ctx.Request.Context(), user, &requestDTO)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -80,7 +80,7 @@ func (c *BackupConfigController) GetBackupConfigByDbID(ctx *gin.Context) {
return
}
- backupConfig, err := c.backupConfigService.GetBackupConfigByDbIdWithAuth(user, id)
+ backupConfig, err := c.backupConfigService.GetBackupConfigByDbIdWithAuth(ctx.Request.Context(), user, id)
if err != nil {
ctx.JSON(http.StatusNotFound, gin.H{"error": "backup configuration not found"})
return
@@ -126,7 +126,7 @@ func (c *BackupConfigController) TransferDatabase(ctx *gin.Context) {
return
}
- if err := c.backupConfigService.TransferDatabaseToWorkspace(user, id, &request); err != nil {
+ if err := c.backupConfigService.TransferDatabaseToWorkspace(ctx.Request.Context(), user, id, &request); err != nil {
if errors.Is(err, ErrInsufficientPermissionsInSourceWorkspace) ||
errors.Is(err, ErrInsufficientPermissionsInTargetWorkspace) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
diff --git a/backend/internal/features/backups/config/physical/controller_test.go b/backend/internal/features/backups/config/physical/controller_test.go
index 91688aa1..d8f0f054 100644
--- a/backend/internal/features/backups/config/physical/controller_test.go
+++ b/backend/internal/features/backups/config/physical/controller_test.go
@@ -169,8 +169,8 @@ func Test_SaveBackupConfig_PhysicalWithDifferentRoles_EnforcesPermissions(t *tes
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createPhysicalTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createPhysicalDatabaseViaAPI(
t,
@@ -183,20 +183,20 @@ func Test_SaveBackupConfig_PhysicalWithDifferentRoles_EnforcesPermissions(t *tes
)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
var testUserToken string
switch {
case tt.isGlobalAdmin:
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
case tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner:
testUserToken = owner.Token
case tt.workspaceRole != nil:
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace, member, *tt.workspaceRole, owner.Token, router,
)
@@ -229,8 +229,8 @@ func Test_SaveBackupConfig_PhysicalWithDifferentRoles_EnforcesPermissions(t *tes
func Test_SaveBackupConfig_PhysicalFullOnlyWithChainsRetention_ReturnsBadRequest(t *testing.T) {
router := createPhysicalTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createPhysicalDatabaseViaAPI(
t,
@@ -242,8 +242,8 @@ func Test_SaveBackupConfig_PhysicalFullOnlyWithChainsRetention_ReturnsBadRequest
"17",
)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
request := validPhysicalConfigForFullOnly(database.ID)
@@ -265,8 +265,8 @@ func Test_SaveBackupConfig_PhysicalFullOnlyWithChainsRetention_ReturnsBadRequest
func Test_SaveBackupConfig_PhysicalFullOnlyWithIncrementalInterval_ReturnsBadRequest(t *testing.T) {
router := createPhysicalTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createPhysicalDatabaseViaAPI(
t,
@@ -278,8 +278,8 @@ func Test_SaveBackupConfig_PhysicalFullOnlyWithIncrementalInterval_ReturnsBadReq
"17",
)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
request := validPhysicalConfigForFullOnly(database.ID)
@@ -303,8 +303,8 @@ func Test_SaveBackupConfig_PhysicalFullOnlyWithIncrementalInterval_ReturnsBadReq
func Test_GetBackupConfig_PhysicalWhenNoneExists_InitializesDefaults(t *testing.T) {
router := createPhysicalTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createPhysicalDatabaseViaAPI(
t,
@@ -316,8 +316,8 @@ func Test_GetBackupConfig_PhysicalWhenNoneExists_InitializesDefaults(t *testing.
"17",
)
defer func() {
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
var response PhysicalBackupConfig
diff --git a/backend/internal/features/backups/config/physical/interfaces.go b/backend/internal/features/backups/config/physical/interfaces.go
index a6fcbf3d..95da8118 100644
--- a/backend/internal/features/backups/config/physical/interfaces.go
+++ b/backend/internal/features/backups/config/physical/interfaces.go
@@ -1,9 +1,13 @@
package backups_config_physical
-import "github.com/google/uuid"
+import (
+ "context"
+
+ "github.com/google/uuid"
+)
type BackupConfigStorageChangeListener interface {
- OnBeforeBackupsStorageChange(dbID uuid.UUID) error
+ OnBeforeBackupsStorageChange(ctx context.Context, dbID uuid.UUID) error
}
// BackupConfigChangeListener is notified when a config save crosses a
diff --git a/backend/internal/features/backups/config/physical/repository.go b/backend/internal/features/backups/config/physical/repository.go
index 518fd364..6729aaf0 100644
--- a/backend/internal/features/backups/config/physical/repository.go
+++ b/backend/internal/features/backups/config/physical/repository.go
@@ -118,7 +118,7 @@ func (r *BackupConfigRepository) ClearIncrementalBackupRequest(databaseID uuid.U
return query.Update("force_incremental_requested_at", nil).Error
}
-func (r *BackupConfigRepository) IsStorageUsing(storageID uuid.UUID) (bool, error) {
+func (r *BackupConfigRepository) IsStorageInUse(storageID uuid.UUID) (bool, error) {
var count int64
if err := storage.
diff --git a/backend/internal/features/backups/config/physical/service.go b/backend/internal/features/backups/config/physical/service.go
index 2c418920..442f5526 100644
--- a/backend/internal/features/backups/config/physical/service.go
+++ b/backend/internal/features/backups/config/physical/service.go
@@ -1,6 +1,7 @@
package backups_config_physical
import (
+ "context"
"errors"
"time"
@@ -50,10 +51,11 @@ func (s *BackupConfigService) GetStorageAttachedDatabasesIDs(
}
func (s *BackupConfigService) SaveBackupConfigWithAuth(
+ ctx context.Context,
user *users_models.User,
backupConfig *PhysicalBackupConfig,
) (*PhysicalBackupConfig, error) {
- database, err := s.databaseService.GetDatabase(user, backupConfig.DatabaseID)
+ database, err := s.databaseService.GetDatabase(ctx, user, backupConfig.DatabaseID)
if err != nil {
return nil, err
}
@@ -62,7 +64,7 @@ func (s *BackupConfigService) SaveBackupConfigWithAuth(
return nil, errors.New("cannot save backup config for database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -83,7 +85,7 @@ func (s *BackupConfigService) SaveBackupConfigWithAuth(
}
if backupConfig.Storage != nil && backupConfig.Storage.ID != uuid.Nil {
- storage, err := s.storageService.GetStorageByID(backupConfig.Storage.ID)
+ storage, err := s.storageService.GetStorageByID(ctx, backupConfig.Storage.ID)
if err != nil {
return nil, err
}
@@ -92,10 +94,11 @@ func (s *BackupConfigService) SaveBackupConfigWithAuth(
}
}
- return s.SaveBackupConfig(backupConfig)
+ return s.SaveBackupConfig(ctx, backupConfig)
}
func (s *BackupConfigService) SaveBackupConfig(
+ ctx context.Context,
backupConfig *PhysicalBackupConfig,
) (*PhysicalBackupConfig, error) {
if backupConfig.PostgresqlPhysical == nil {
@@ -126,7 +129,7 @@ func (s *BackupConfigService) SaveBackupConfig(
if s.dbStorageChangeListener != nil &&
backupConfig.Storage != nil &&
!storageIDsEqual(existingConfig.StorageID, &backupConfig.Storage.ID) {
- if err := s.dbStorageChangeListener.OnBeforeBackupsStorageChange(
+ if err := s.dbStorageChangeListener.OnBeforeBackupsStorageChange(ctx,
backupConfig.DatabaseID,
); err != nil {
return nil, err
@@ -147,10 +150,11 @@ func (s *BackupConfigService) SaveBackupConfig(
}
func (s *BackupConfigService) GetBackupConfigByDbIdWithAuth(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
) (*PhysicalBackupConfig, error) {
- _, err := s.databaseService.GetDatabase(user, databaseID)
+ _, err := s.databaseService.GetDatabase(ctx, user, databaseID)
if err != nil {
return nil, err
}
@@ -177,28 +181,30 @@ func (s *BackupConfigService) GetBackupConfigByDbId(
return config, nil
}
-func (s *BackupConfigService) IsStorageUsing(
+func (s *BackupConfigService) IsStorageInUse(
+ ctx context.Context,
user *users_models.User,
storageID uuid.UUID,
) (bool, error) {
- _, err := s.storageService.GetStorage(user, storageID)
+ _, err := s.storageService.GetStorage(ctx, user, storageID)
if err != nil {
return false, err
}
- return s.storageService.IsStorageUsing(storageID)
+ return s.storageService.IsStorageInUse(ctx, storageID)
}
func (s *BackupConfigService) CountDatabasesForStorage(
+ ctx context.Context,
user *users_models.User,
storageID uuid.UUID,
) (int, error) {
- _, err := s.storageService.GetStorage(user, storageID)
+ _, err := s.storageService.GetStorage(ctx, user, storageID)
if err != nil {
return 0, err
}
- return s.storageService.CountDatabasesForStorage(storageID)
+ return s.storageService.CountDatabasesForStorage(ctx, storageID)
}
func (s *BackupConfigService) GetBackupConfigsWithEnabledBackups() (
@@ -224,7 +230,7 @@ func (s *BackupConfigService) ClearIncrementalBackupRequest(databaseID uuid.UUID
return s.backupConfigRepository.ClearIncrementalBackupRequest(databaseID, requestedAt)
}
-func (s *BackupConfigService) OnDatabaseCopied(originalDatabaseID, newDatabaseID uuid.UUID) {
+func (s *BackupConfigService) OnDatabaseCopied(ctx context.Context, originalDatabaseID, newDatabaseID uuid.UUID) {
originalConfig, err := s.backupConfigRepository.FindByDatabaseID(originalDatabaseID)
if err != nil || originalConfig == nil {
return
@@ -232,7 +238,7 @@ func (s *BackupConfigService) OnDatabaseCopied(originalDatabaseID, newDatabaseID
newConfig := originalConfig.Copy(newDatabaseID)
- _, _ = s.SaveBackupConfig(newConfig)
+ _, _ = s.SaveBackupConfig(ctx, newConfig)
}
func (s *BackupConfigService) CreateDisabledBackupConfig(databaseID uuid.UUID) error {
@@ -240,6 +246,7 @@ func (s *BackupConfigService) CreateDisabledBackupConfig(databaseID uuid.UUID) e
}
func (s *BackupConfigService) TransferDatabaseToWorkspace(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
request *TransferDatabaseRequest,
@@ -253,7 +260,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
return ErrDatabaseHasNoWorkspace
}
- canManageSource, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManageSource, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return err
}
@@ -261,7 +268,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
return ErrInsufficientPermissionsInSourceWorkspace
}
- canManageTarget, err := s.workspaceService.CanUserManageDBs(request.TargetWorkspaceID, user)
+ canManageTarget, err := s.workspaceService.CanUserManageDBs(ctx, request.TargetWorkspaceID, user)
if err != nil {
return err
}
@@ -269,7 +276,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
return ErrInsufficientPermissionsInTargetWorkspace
}
- if err := s.validateTargetNotifiers(request); err != nil {
+ if err := s.validateTargetNotifiers(ctx, request); err != nil {
return err
}
@@ -279,7 +286,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
}
if request.IsTransferWithNotifiers {
- s.transferNotifiers(user, database, request.TargetWorkspaceID)
+ s.transferNotifiers(ctx, user, database, request.TargetWorkspaceID)
}
switch {
@@ -302,6 +309,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
}
err = s.storageService.TransferStorageToWorkspace(
+ ctx,
user,
*backupConfig.StorageID,
request.TargetWorkspaceID,
@@ -311,7 +319,7 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
return err
}
case request.TargetStorageID != nil:
- targetStorage, err := s.storageService.GetStorageByID(*request.TargetStorageID)
+ targetStorage, err := s.storageService.GetStorageByID(ctx, *request.TargetStorageID)
if err != nil {
return err
}
@@ -331,13 +339,13 @@ func (s *BackupConfigService) TransferDatabaseToWorkspace(
return ErrTargetStorageNotSpecified
}
- err = s.databaseService.TransferDatabaseToWorkspace(databaseID, request.TargetWorkspaceID)
+ err = s.databaseService.TransferDatabaseToWorkspace(ctx, databaseID, request.TargetWorkspaceID)
if err != nil {
return err
}
if len(request.TargetNotifierIDs) > 0 {
- if err := s.assignTargetNotifiers(databaseID, request.TargetNotifierIDs); err != nil {
+ if err := s.assignTargetNotifiers(ctx, databaseID, request.TargetNotifierIDs); err != nil {
return err
}
}
@@ -373,12 +381,14 @@ func (s *BackupConfigService) initializeDefaultConfig(databaseID uuid.UUID) erro
}
func (s *BackupConfigService) transferNotifiers(
+ ctx context.Context,
user *users_models.User,
database *databases.Database,
targetWorkspaceID uuid.UUID,
) {
for _, notifier := range database.Notifiers {
_ = s.notifierService.TransferNotifierToWorkspace(
+ ctx,
user,
notifier.ID,
targetWorkspaceID,
@@ -387,9 +397,9 @@ func (s *BackupConfigService) transferNotifiers(
}
}
-func (s *BackupConfigService) validateTargetNotifiers(request *TransferDatabaseRequest) error {
+func (s *BackupConfigService) validateTargetNotifiers(ctx context.Context, request *TransferDatabaseRequest) error {
for _, notifierID := range request.TargetNotifierIDs {
- notifier, err := s.notifierService.GetNotifierByID(notifierID)
+ notifier, err := s.notifierService.GetNotifierByID(ctx, notifierID)
if err != nil {
return err
}
@@ -403,13 +413,14 @@ func (s *BackupConfigService) validateTargetNotifiers(request *TransferDatabaseR
}
func (s *BackupConfigService) assignTargetNotifiers(
+ ctx context.Context,
databaseID uuid.UUID,
notifierIDs []uuid.UUID,
) error {
targetNotifiers := make([]notifiers.Notifier, 0, len(notifierIDs))
for _, notifierID := range notifierIDs {
- notifier, err := s.notifierService.GetNotifierByID(notifierID)
+ notifier, err := s.notifierService.GetNotifierByID(ctx, notifierID)
if err != nil {
return err
}
diff --git a/backend/internal/features/backups/config/physical/storages_test.go b/backend/internal/features/backups/config/physical/storages_test.go
index d1696d92..cbdd99d8 100644
--- a/backend/internal/features/backups/config/physical/storages_test.go
+++ b/backend/internal/features/backups/config/physical/storages_test.go
@@ -19,8 +19,8 @@ import (
func Test_AttachStorageFromSameWorkspace_PhysicalConfig_SuccessfullyAttached(t *testing.T) {
router := createPhysicalTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createPhysicalDatabaseViaAPI(
t, "Physical DB "+uuid.New().String(), workspace.ID, owner.Token, router,
@@ -29,9 +29,9 @@ func Test_AttachStorageFromSameWorkspace_PhysicalConfig_SuccessfullyAttached(t *
storage := storages.CreateTestStorage(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
request := validPhysicalConfigForFullOnly(database.ID)
@@ -55,22 +55,22 @@ func Test_AttachStorageFromSameWorkspace_PhysicalConfig_SuccessfullyAttached(t *
func Test_AttachStorageFromDifferentWorkspace_PhysicalConfig_ReturnsBadRequest(t *testing.T) {
router := createPhysicalTestRouter()
- owner1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", owner1, router)
+ owner1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace1 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 1", owner1, router)
database := createPhysicalDatabaseViaAPI(
t, "Physical DB "+uuid.New().String(), workspace1.ID, owner1.Token, router,
postgresql_physical.BackupTypeFullOnly, "17",
)
- owner2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", owner2, router)
+ owner2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace2 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 2", owner2, router)
storage := storages.CreateTestStorage(workspace2.ID)
defer func() {
- databases.RemoveTestDatabase(database)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace1, router)
- workspaces_testing.RemoveTestWorkspace(workspace2, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace1, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace2, router)
}()
request := validPhysicalConfigForFullOnly(database.ID)
@@ -89,8 +89,8 @@ func Test_AttachStorageFromDifferentWorkspace_PhysicalConfig_ReturnsBadRequest(t
func Test_DeleteStorageWithAttachedPhysicalConfig_CannotDelete(t *testing.T) {
router := createPhysicalTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createPhysicalDatabaseViaAPI(
t, "Physical DB "+uuid.New().String(), workspace.ID, owner.Token, router,
@@ -99,9 +99,9 @@ func Test_DeleteStorageWithAttachedPhysicalConfig_CannotDelete(t *testing.T) {
storage := storages.CreateTestStorage(workspace.ID)
defer func() {
- databases.RemoveTestDatabase(database)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
request := validPhysicalConfigForFullOnly(database.ID)
diff --git a/backend/internal/features/backups/config/physical/testing.go b/backend/internal/features/backups/config/physical/testing.go
index 21aa186e..3a334ea9 100644
--- a/backend/internal/features/backups/config/physical/testing.go
+++ b/backend/internal/features/backups/config/physical/testing.go
@@ -1,6 +1,8 @@
package backups_config_physical
import (
+ "context"
+
"github.com/google/uuid"
"databasus-backend/internal/features/intervals"
@@ -8,6 +10,7 @@ import (
)
func EnableBackupsForPhysicalTestDatabase(
+ ctx context.Context,
databaseID uuid.UUID,
storage *storages.Storage,
) *PhysicalBackupConfig {
@@ -34,7 +37,7 @@ func EnableBackupsForPhysicalTestDatabase(
},
}
- backupConfig, err := GetBackupConfigService().SaveBackupConfig(backupConfig)
+ backupConfig, err := GetBackupConfigService().SaveBackupConfig(ctx, backupConfig)
if err != nil {
panic(err)
}
diff --git a/backend/internal/features/databases/controller.go b/backend/internal/features/databases/controller.go
index 75b7104e..726cce38 100644
--- a/backend/internal/features/databases/controller.go
+++ b/backend/internal/features/databases/controller.go
@@ -68,7 +68,7 @@ func (c *DatabaseController) CreateDatabase(ctx *gin.Context) {
return
}
- database, err := c.databaseService.CreateDatabase(user, *request.WorkspaceID, &request)
+ database, err := c.databaseService.CreateDatabase(ctx.Request.Context(), user, *request.WorkspaceID, &request)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -102,7 +102,7 @@ func (c *DatabaseController) UpdateDatabase(ctx *gin.Context) {
return
}
- if err := c.databaseService.UpdateDatabase(user, &request); err != nil {
+ if err := c.databaseService.UpdateDatabase(ctx.Request.Context(), user, &request); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -133,7 +133,8 @@ func (c *DatabaseController) DeleteDatabase(ctx *gin.Context) {
return
}
- if err := c.databaseService.DeleteDatabase(user, id); err != nil {
+ if err := c.databaseService.DeleteDatabase(ctx.Request.Context(), user, id); err != nil {
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
@@ -164,7 +165,7 @@ func (c *DatabaseController) GetDatabase(ctx *gin.Context) {
return
}
- database, err := c.databaseService.GetDatabase(user, id)
+ database, err := c.databaseService.GetDatabase(ctx.Request.Context(), user, id)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -203,7 +204,7 @@ func (c *DatabaseController) GetDatabases(ctx *gin.Context) {
return
}
- databases, err := c.databaseService.GetDatabasesByWorkspace(user, workspaceID)
+ databases, err := c.databaseService.GetDatabasesByWorkspace(ctx.Request.Context(), user, workspaceID)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -235,7 +236,7 @@ func (c *DatabaseController) TestDatabaseConnection(ctx *gin.Context) {
return
}
- if err := c.databaseService.TestDatabaseConnection(user, id); err != nil {
+ if err := c.databaseService.TestDatabaseConnection(ctx.Request.Context(), user, id); err != nil {
respondConnectionTestError(ctx, err)
return
}
@@ -266,7 +267,7 @@ func (c *DatabaseController) TestDatabaseConnectionDirect(ctx *gin.Context) {
return
}
- if err := c.databaseService.TestDatabaseConnectionDirect(&request); err != nil {
+ if err := c.databaseService.TestDatabaseConnectionDirect(ctx.Request.Context(), &request); err != nil {
respondConnectionTestError(ctx, err)
return
}
@@ -309,8 +310,9 @@ func (c *DatabaseController) IsNotifierUsing(ctx *gin.Context) {
return
}
- isUsing, err := c.databaseService.IsNotifierUsing(user, id)
+ isUsing, err := c.databaseService.IsNotifierUsing(ctx.Request.Context(), user, id)
if err != nil {
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
@@ -342,8 +344,9 @@ func (c *DatabaseController) CountDatabasesByNotifier(ctx *gin.Context) {
return
}
- count, err := c.databaseService.CountDatabasesByNotifier(user, id)
+ count, err := c.databaseService.CountDatabasesByNotifier(ctx.Request.Context(), user, id)
if err != nil {
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
@@ -375,7 +378,7 @@ func (c *DatabaseController) CopyDatabase(ctx *gin.Context) {
return
}
- copiedDatabase, err := c.databaseService.CopyDatabase(user, id)
+ copiedDatabase, err := c.databaseService.CopyDatabase(ctx.Request.Context(), user, id)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -410,7 +413,7 @@ func (c *DatabaseController) IsUserReadOnly(ctx *gin.Context) {
return
}
- isReadOnly, privileges, err := c.databaseService.IsUserReadOnly(user, &request)
+ isReadOnly, privileges, err := c.databaseService.IsUserReadOnly(ctx.Request.Context(), user, &request)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -445,7 +448,7 @@ func (c *DatabaseController) CreateReadOnlyUser(ctx *gin.Context) {
return
}
- username, password, err := c.databaseService.CreateReadOnlyUser(user, &request)
+ username, password, err := c.databaseService.CreateReadOnlyUser(ctx.Request.Context(), user, &request)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -483,7 +486,7 @@ func (c *DatabaseController) CreateReplicationOnlyUser(ctx *gin.Context) {
return
}
- username, password, err := c.databaseService.CreateReplicationOnlyUser(user, &request)
+ username, password, err := c.databaseService.CreateReplicationOnlyUser(ctx.Request.Context(), user, &request)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
diff --git a/backend/internal/features/databases/controller_test.go b/backend/internal/features/databases/controller_test.go
index 700d7d86..396edabc 100644
--- a/backend/internal/features/databases/controller_test.go
+++ b/backend/internal/features/databases/controller_test.go
@@ -1,6 +1,7 @@
package databases
import (
+ "context"
"encoding/json"
"fmt"
"net"
@@ -84,18 +85,18 @@ func Test_CreateDatabase_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -125,7 +126,7 @@ func Test_CreateDatabase_PermissionsEnforced(t *testing.T) {
)
if tt.expectSuccess {
- defer RemoveTestDatabase(&response)
+ defer RemoveTestDatabase(t.Context(), &response)
assert.Equal(t, "Test Database", response.Name)
assert.NotEqual(t, uuid.Nil, response.ID)
} else {
@@ -137,11 +138,11 @@ func Test_CreateDatabase_PermissionsEnforced(t *testing.T) {
func Test_CreateDatabase_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := Database{
Name: "Test Database",
@@ -164,9 +165,9 @@ func Test_CreateDatabase_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testin
func Test_CreateDatabase_WithoutConnectionFields_ValidationFails(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
request := Database{
Name: "Test Database",
@@ -230,21 +231,21 @@ func Test_UpdateDatabase_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(database)
+ defer RemoveTestDatabase(t.Context(), database)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -279,14 +280,14 @@ func Test_UpdateDatabase_PermissionsEnforced(t *testing.T) {
func Test_UpdateDatabase_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(database)
+ defer RemoveTestDatabase(t.Context(), database)
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
database.Name = "Hacked Name"
testResp := test_utils.MakePostRequest(
@@ -303,12 +304,12 @@ func Test_UpdateDatabase_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testin
func Test_UpdateDatabase_WhenDatabaseTypeChanged_ReturnsBadRequest(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(database)
+ defer RemoveTestDatabase(t.Context(), database)
database.Type = DatabaseTypeMysql
@@ -365,20 +366,20 @@ func Test_DeleteDatabase_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -398,7 +399,7 @@ func Test_DeleteDatabase_PermissionsEnforced(t *testing.T) {
)
if !tt.expectSuccess {
- defer RemoveTestDatabase(database)
+ defer RemoveTestDatabase(t.Context(), database)
assert.Contains(t, string(testResp.Body), "insufficient permissions")
}
})
@@ -440,19 +441,19 @@ func Test_GetDatabase_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(database)
+ defer RemoveTestDatabase(t.Context(), database)
var testUser string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUser = admin.Token
} else if tt.userRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -462,7 +463,7 @@ func Test_GetDatabase_PermissionsEnforced(t *testing.T) {
)
testUser = member.Token
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUser = nonMember.Token
}
@@ -520,23 +521,23 @@ func Test_GetDatabasesByWorkspace_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
db1 := createTestDatabaseViaAPI("Database 1", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(db1)
+ defer RemoveTestDatabase(t.Context(), db1)
db2 := createTestDatabaseViaAPI("Database 2", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(db2)
+ defer RemoveTestDatabase(t.Context(), db2)
var testUser string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUser = admin.Token
} else if tt.isMember {
testUser = owner.Token
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUser = nonMember.Token
}
@@ -567,16 +568,16 @@ func Test_GetDatabasesByWorkspace_PermissionsEnforced(t *testing.T) {
func Test_GetDatabasesByWorkspace_WhenMultipleDatabasesExist_ReturnsCorrectCount(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
db1 := createTestDatabaseViaAPI("Database 1", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(db1)
+ defer RemoveTestDatabase(t.Context(), db1)
db2 := createTestDatabaseViaAPI("Database 2", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(db2)
+ defer RemoveTestDatabase(t.Context(), db2)
db3 := createTestDatabaseViaAPI("Database 3", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(db3)
+ defer RemoveTestDatabase(t.Context(), db3)
var response []Database
test_utils.MakeGetRequestAndUnmarshal(
@@ -595,22 +596,27 @@ func Test_GetDatabasesByWorkspace_WithPhysicalBackups_ReturnsNewestBackupTimeAcr
const walSegmentBytes = 16 * 1024 * 1024
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Phys Last Backup "+uuid.NewString(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(
+ t.Context(),
+ "Phys Last Backup "+uuid.NewString(),
+ owner,
+ router,
+ )
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
storage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(storage.ID)
+ defer storages.RemoveTestStorage(t.Context(), storage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
backedUp := CreateTestPhysicalPostgresDatabase(workspace.ID, notifier, "17")
defer func() {
physical_testing.DeleteAllPhysicalCatalogForDatabase(t, backedUp.ID)
- RemoveTestDatabase(backedUp)
+ RemoveTestDatabase(t.Context(), backedUp)
}()
noBackups := CreateTestPhysicalPostgresDatabase(workspace.ID, notifier, "17")
- defer RemoveTestDatabase(noBackups)
+ defer RemoveTestDatabase(t.Context(), noBackups)
base := time.Now().UTC().Add(-time.Hour)
@@ -666,21 +672,21 @@ func findDatabaseByID(t *testing.T, databases []Database, databaseID uuid.UUID)
func Test_GetDatabasesByWorkspace_EnsuresCrossWorkspaceIsolation(t *testing.T) {
router := createTestRouter()
- owner1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", owner1, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace1, router)
+ owner1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace1 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 1", owner1, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace1, router)
- owner2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", owner2, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace2, router)
+ owner2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace2 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 2", owner2, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace2, router)
workspace1Db1 := createTestDatabaseViaAPI("Workspace1 DB1", workspace1.ID, owner1.Token, router)
- defer RemoveTestDatabase(workspace1Db1)
+ defer RemoveTestDatabase(t.Context(), workspace1Db1)
workspace1Db2 := createTestDatabaseViaAPI("Workspace1 DB2", workspace1.ID, owner1.Token, router)
- defer RemoveTestDatabase(workspace1Db2)
+ defer RemoveTestDatabase(t.Context(), workspace1Db2)
workspace2Db1 := createTestDatabaseViaAPI("Workspace2 DB1", workspace2.ID, owner2.Token, router)
- defer RemoveTestDatabase(workspace2Db1)
+ defer RemoveTestDatabase(t.Context(), workspace2Db1)
var workspace1Dbs []Database
test_utils.MakeGetRequestAndUnmarshal(
@@ -755,21 +761,21 @@ func Test_CopyDatabase_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(database)
+ defer RemoveTestDatabase(t.Context(), database)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -792,7 +798,7 @@ func Test_CopyDatabase_PermissionsEnforced(t *testing.T) {
)
if tt.expectSuccess {
- defer RemoveTestDatabase(&response)
+ defer RemoveTestDatabase(t.Context(), &response)
assert.NotEqual(t, database.ID, response.ID)
assert.Contains(t, response.Name, "(Copy)")
} else {
@@ -804,12 +810,12 @@ func Test_CopyDatabase_PermissionsEnforced(t *testing.T) {
func Test_CopyDatabase_CopyStaysInSameWorkspace(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(database)
+ defer RemoveTestDatabase(t.Context(), database)
var response Database
test_utils.MakePostRequestAndUnmarshal(
@@ -822,7 +828,7 @@ func Test_CopyDatabase_CopyStaysInSameWorkspace(t *testing.T) {
&response,
)
- defer RemoveTestDatabase(&response)
+ defer RemoveTestDatabase(t.Context(), &response)
assert.NotEqual(t, database.ID, response.ID)
assert.Equal(t, "Test Database (Copy)", response.Name)
@@ -832,8 +838,8 @@ func Test_CopyDatabase_CopyStaysInSameWorkspace(t *testing.T) {
func Test_CreateDatabase_PasswordIsEncryptedInDB(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
pgConfig := getTestPostgresConfig()
plainPassword := "testpassword"
@@ -883,7 +889,7 @@ func Test_CreateDatabase_PasswordIsEncryptedInDB(t *testing.T) {
http.StatusNoContent,
)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
const updatedSshTunnelHost = "moved-bastion.example.com"
@@ -1167,8 +1173,8 @@ func Test_DatabaseSensitiveDataLifecycle_AllTypes(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
// Phase 1: Create database with sensitive data
initialDatabase := tc.createDatabase(t, workspace.ID)
@@ -1263,7 +1269,7 @@ func Test_DatabaseSensitiveDataLifecycle_AllTypes(t *testing.T) {
http.StatusNoContent,
)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
@@ -1302,21 +1308,21 @@ func Test_TestConnection_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(database)
+ defer RemoveTestDatabase(t.Context(), database)
var testUser string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUser = admin.Token
} else if tt.isMember {
testUser = owner.Token
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUser = nonMember.Token
}
@@ -1349,12 +1355,12 @@ func Test_TestConnection_PermissionsEnforced(t *testing.T) {
func Test_UpdateDatabase_WhenExcludeTablesArePastedMultiline_StoresTrimmedUniqueNames(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
- defer RemoveTestDatabase(database)
+ defer RemoveTestDatabase(t.Context(), database)
database.PostgresqlLogical.ExcludeTables = []string{"orders", "\npersonnel_real_time", " ", "orders"}
database.PostgresqlLogical.IncludeSchemas = []string{"public", "\treporting"}
@@ -1481,9 +1487,9 @@ func getTestPostgresConfig() *postgresql_logical.PostgresqlLogicalDatabase {
func Test_CreateDatabase_WhenUserIsNotReadOnly_DatabaseCreated(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Non-Cloud", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Non-Cloud", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
request := Database{
Name: "Non-Cloud DB",
@@ -1502,7 +1508,7 @@ func Test_CreateDatabase_WhenUserIsNotReadOnly_DatabaseCreated(t *testing.T) {
http.StatusCreated,
&response,
)
- defer RemoveTestDatabase(&response)
+ defer RemoveTestDatabase(t.Context(), &response)
assert.Equal(t, "Non-Cloud DB", response.Name)
assert.NotEqual(t, uuid.Nil, response.ID)
@@ -1554,9 +1560,9 @@ func Test_CreateDatabase_FailsForPhysicalIncrementalWhenSummarizeWalOff(t *testi
for _, backupType := range incrementalBackupTypes {
t.Run(fmt.Sprintf("pg%s_%s", dbVersion.tag, backupType), func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
source := containers.StartPhysicalPostgres(t, dbVersion.image, containers.WithoutSummarizer())
physicalConfig := GetTestPhysicalPostgresConfigNoSummary(source.Host, source.Port, dbVersion.tag)
@@ -1588,9 +1594,9 @@ func Test_UpdateDatabase_FailsForSwitchToPhysicalIncrementalWhenSummarizeWalOff(
for _, dbVersion := range physicalNoSummaryVersions {
t.Run("pg"+dbVersion.tag, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
source := containers.StartPhysicalPostgres(t, dbVersion.image, containers.WithoutSummarizer())
createRequest := Database{
@@ -1610,7 +1616,7 @@ func Test_UpdateDatabase_FailsForSwitchToPhysicalIncrementalWhenSummarizeWalOff(
http.StatusCreated,
&createdDatabase,
)
- defer RemoveTestDatabase(&createdDatabase)
+ defer RemoveTestDatabase(t.Context(), &createdDatabase)
createdDatabase.PostgresqlPhysical.BackupType = postgresql_physical.BackupTypeFullAndIncremental
@@ -1694,9 +1700,9 @@ func Test_CreateDatabase_OverSshTunnel_DetectsVersionAndHidesTunnelSecrets(t *te
topology := containers.StartPostgresBehindSshBastion(t, "postgres:16")
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("SSH Tunnel", owner, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "SSH Tunnel", owner, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
var createdDatabase Database
test_utils.MakePostRequestAndUnmarshal(
@@ -1709,7 +1715,7 @@ func Test_CreateDatabase_OverSshTunnel_DetectsVersionAndHidesTunnelSecrets(t *te
},
http.StatusCreated, &createdDatabase,
)
- t.Cleanup(func() { RemoveTestDatabase(&createdDatabase) })
+ t.Cleanup(func() { RemoveTestDatabase(t.Context(), &createdDatabase) })
require.NotNil(t, createdDatabase.PostgresqlLogical)
assert.Equal(t, "16", string(createdDatabase.PostgresqlLogical.Version))
@@ -1743,9 +1749,9 @@ func Test_CreateDatabase_OverSshTunnelWithAPrivateKey_DatabaseCreated(t *testing
topology := containers.StartPostgresBehindSshBastion(t, "postgres:16")
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("SSH Tunnel Key", owner, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "SSH Tunnel Key", owner, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
postgresConfig := bastionedPostgresConfig(topology)
postgresConfig.SshTunnel.AuthType = sshtunnel.AuthTypePrivateKey
@@ -1763,7 +1769,7 @@ func Test_CreateDatabase_OverSshTunnelWithAPrivateKey_DatabaseCreated(t *testing
},
http.StatusCreated, &createdDatabase,
)
- t.Cleanup(func() { RemoveTestDatabase(&createdDatabase) })
+ t.Cleanup(func() { RemoveTestDatabase(t.Context(), &createdDatabase) })
require.NotNil(t, createdDatabase.PostgresqlLogical)
assert.Equal(t, "16", string(createdDatabase.PostgresqlLogical.Version))
@@ -1775,9 +1781,9 @@ func Test_UpdateDatabase_WhenSshAuthTypeChangesToPassword_ClearsTheStoredPrivate
topology := containers.StartPostgresBehindSshBastion(t, "postgres:16")
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("SSH Tunnel Auth Switch", owner, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "SSH Tunnel Auth Switch", owner, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
postgresConfig := bastionedPostgresConfig(topology)
postgresConfig.SshTunnel.AuthType = sshtunnel.AuthTypePrivateKey
@@ -1795,7 +1801,7 @@ func Test_UpdateDatabase_WhenSshAuthTypeChangesToPassword_ClearsTheStoredPrivate
},
http.StatusCreated, &createdDatabase,
)
- t.Cleanup(func() { RemoveTestDatabase(&createdDatabase) })
+ t.Cleanup(func() { RemoveTestDatabase(t.Context(), &createdDatabase) })
createdDatabase.PostgresqlLogical.SshTunnel.AuthType = sshtunnel.AuthTypePassword
createdDatabase.PostgresqlLogical.SshTunnel.Password = containers.SshBastionPassword
@@ -1818,9 +1824,9 @@ func Test_CreateDatabase_WhenSshAuthTypeIsPrivateKeyButOnlyAPasswordIsSet_Return
t *testing.T,
) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("SSH Tunnel Auth Mismatch", owner, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "SSH Tunnel Auth Mismatch", owner, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
postgresConfig := getTestPostgresConfig()
postgresConfig.SshTunnel = sshtunnel.Config{
@@ -1850,9 +1856,9 @@ func Test_CreateDatabase_WhenSshAuthTypeIsPrivateKeyButOnlyAPasswordIsSet_Return
// form only ever shows the chosen one, so nothing would surface it again.
func Test_CreateDatabase_WhenTheSshTunnelCarriesBothSecrets_ReturnsBadRequest(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("SSH Tunnel Both Secrets", owner, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "SSH Tunnel Both Secrets", owner, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
postgresConfig := getTestPostgresConfig()
postgresConfig.SshTunnel = sshtunnel.Config{
@@ -1881,9 +1887,9 @@ func Test_CreateDatabase_WhenTheSshTunnelCarriesBothSecrets_ReturnsBadRequest(t
func Test_CreateDatabase_WhenSshTunnelIsEnabledWithoutAHost_ReturnsBadRequest(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("SSH Tunnel Invalid", owner, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "SSH Tunnel Invalid", owner, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
postgresConfig := getTestPostgresConfig()
postgresConfig.SshTunnel = sshtunnel.Config{
@@ -1912,9 +1918,9 @@ func Test_CopyDatabase_WhenTheSourceIsBehindABastion_KeepsTheTunnelConfig(t *tes
topology := containers.StartPostgresBehindSshBastion(t, "postgres:16")
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("SSH Tunnel Copy", owner, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "SSH Tunnel Copy", owner, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
var createdDatabase Database
test_utils.MakePostRequestAndUnmarshal(
@@ -1927,14 +1933,14 @@ func Test_CopyDatabase_WhenTheSourceIsBehindABastion_KeepsTheTunnelConfig(t *tes
},
http.StatusCreated, &createdDatabase,
)
- t.Cleanup(func() { RemoveTestDatabase(&createdDatabase) })
+ t.Cleanup(func() { RemoveTestDatabase(t.Context(), &createdDatabase) })
var copiedDatabase Database
test_utils.MakePostRequestAndUnmarshal(
t, router, "/api/v1/databases/"+createdDatabase.ID.String()+"/copy",
"Bearer "+owner.Token, nil, http.StatusCreated, &copiedDatabase,
)
- t.Cleanup(func() { RemoveTestDatabase(&copiedDatabase) })
+ t.Cleanup(func() { RemoveTestDatabase(t.Context(), &copiedDatabase) })
require.NotNil(t, copiedDatabase.PostgresqlLogical)
assert.True(t, copiedDatabase.PostgresqlLogical.SshTunnel.IsEnabled)
@@ -1945,9 +1951,9 @@ func Test_CopyDatabase_WhenTheSourceIsBehindABastion_KeepsTheTunnelConfig(t *tes
func Test_CreateMongodbDatabase_WhenSrvAndSshTunnelAreEnabled_ReturnsBadRequest(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Mongo SRV Tunnel", owner, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Mongo SRV Tunnel", owner, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
response := workspaces_testing.MakeAPIRequest(
router, "POST", "/api/v1/databases/create", "Bearer "+owner.Token,
@@ -1985,9 +1991,9 @@ func Test_CreateReplicationOnlyUser_WhenTheDatabaseIsBehindABastion_ReachesTheCl
t *testing.T,
) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Bastioned Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Bastioned Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
topology := containers.StartPhysicalPostgresBehindSshBastion(t, "postgres:17")
@@ -2025,9 +2031,9 @@ func Test_CreateDatabase_WhenThePhysicalClusterIsBehindABastion_PassesTheReplica
t *testing.T,
) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Bastioned Create", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Bastioned Create", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
topology := containers.StartPhysicalPostgresBehindSshBastion(t, "postgres:17")
@@ -2053,7 +2059,7 @@ func Test_CreateDatabase_WhenThePhysicalClusterIsBehindABastion_PassesTheReplica
http.StatusCreated,
&response,
)
- defer RemoveTestDatabase(&response)
+ defer RemoveTestDatabase(t.Context(), &response)
require.NotNil(t, response.PostgresqlPhysical)
assert.NotEmpty(t, response.PostgresqlPhysical.Version,
diff --git a/backend/internal/features/databases/databases/mariadb/model.go b/backend/internal/features/databases/databases/mariadb/model.go
index 1c6b33b3..b5c4ad6f 100644
--- a/backend/internal/features/databases/databases/mariadb/model.go
+++ b/backend/internal/features/databases/databases/mariadb/model.go
@@ -103,7 +103,7 @@ func (m *MariadbDatabase) TestConnection(
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close MariaDB connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close the mariadb connection", "error", closeErr)
}
}()
@@ -112,6 +112,8 @@ func (m *MariadbDatabase) TestConnection(
db.SetMaxIdleConns(1)
if err := db.PingContext(ctx); err != nil {
+ logger.ErrorContext(ctx, "failed to ping the mariadb database", "database_name", *m.Database, "error", err)
+
return fmt.Errorf("failed to ping MariaDB database '%s': %w", *m.Database, err)
}
@@ -156,7 +158,7 @@ func (m *MariadbDatabase) GetRawDbSizeMb(
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close MariaDB connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close MariaDB connection", "error", closeErr)
}
}()
@@ -259,7 +261,7 @@ func (m *MariadbDatabase) PopulateDbData(
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close the connection", "error", closeErr)
}
}()
@@ -302,7 +304,7 @@ func (m *MariadbDatabase) PopulateVersion(
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close the connection", "error", closeErr)
}
}()
@@ -333,7 +335,7 @@ func (m *MariadbDatabase) IsUserReadOnly(
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close connection", "error", closeErr)
}
}()
@@ -412,7 +414,7 @@ func (m *MariadbDatabase) CreateReadOnlyUser(
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close connection", "error", closeErr)
}
}()
@@ -431,7 +433,7 @@ func (m *MariadbDatabase) CreateReadOnlyUser(
defer func() {
if !success {
if rollbackErr := tx.Rollback(); rollbackErr != nil {
- logger.Error("Failed to rollback transaction", "error", rollbackErr)
+ logger.ErrorContext(ctx, "failed to rollback transaction", "error", rollbackErr)
}
}
}()
@@ -475,8 +477,9 @@ func (m *MariadbDatabase) CreateReadOnlyUser(
}
success = true
- logger.Info(
- "Read-only MariaDB user created successfully",
+ logger.InfoContext(
+ ctx,
+ "read-only MariaDB user created successfully",
"username", newUsername,
)
return newUsername, newPassword, nil
diff --git a/backend/internal/features/databases/databases/mongodb/model.go b/backend/internal/features/databases/databases/mongodb/model.go
index 895d6a23..6f835d94 100644
--- a/backend/internal/features/databases/databases/mongodb/model.go
+++ b/backend/internal/features/databases/databases/mongodb/model.go
@@ -116,15 +116,20 @@ func (m *MongodbDatabase) TestConnection(
clientOptions := options.Client().ApplyURI(uri)
client, err := mongo.Connect(ctx, clientOptions)
if err != nil {
+ // The URI carries the password, so only the database name goes into the log.
+ logger.ErrorContext(ctx, "failed to open the mongodb connection", "database_name", m.Database, "error", err)
+
return fmt.Errorf("failed to connect to MongoDB: %w", err)
}
defer func() {
if disconnectErr := client.Disconnect(ctx); disconnectErr != nil {
- logger.Error("Failed to disconnect from MongoDB", "error", disconnectErr)
+ logger.ErrorContext(ctx, "failed to disconnect from mongodb", "error", disconnectErr)
}
}()
if err := client.Ping(ctx, nil); err != nil {
+ logger.ErrorContext(ctx, "failed to ping the mongodb database", "database_name", m.Database, "error", err)
+
return fmt.Errorf("failed to ping MongoDB database '%s': %w", m.Database, err)
}
@@ -172,7 +177,7 @@ func (m *MongodbDatabase) GetRawDbSizeMb(
}
defer func() {
if disconnectErr := client.Disconnect(ctx); disconnectErr != nil {
- logger.Error("Failed to disconnect from MongoDB", "error", disconnectErr)
+ logger.ErrorContext(ctx, "failed to disconnect from MongoDB", "error", disconnectErr)
}
}()
@@ -275,7 +280,7 @@ func (m *MongodbDatabase) PopulateVersion(
}
defer func() {
if disconnectErr := client.Disconnect(ctx); disconnectErr != nil {
- logger.Error("Failed to disconnect", "error", disconnectErr)
+ logger.Error("failed to disconnect", "error", disconnectErr)
}
}()
@@ -307,7 +312,7 @@ func (m *MongodbDatabase) IsUserReadOnly(
}
defer func() {
if disconnectErr := client.Disconnect(ctx); disconnectErr != nil {
- logger.Error("Failed to disconnect", "error", disconnectErr)
+ logger.ErrorContext(ctx, "failed to disconnect", "error", disconnectErr)
}
}()
@@ -493,7 +498,7 @@ func (m *MongodbDatabase) CreateReadOnlyUser(
}
defer func() {
if disconnectErr := client.Disconnect(ctx); disconnectErr != nil {
- logger.Error("Failed to disconnect", "error", disconnectErr)
+ logger.ErrorContext(ctx, "failed to disconnect", "error", disconnectErr)
}
}()
@@ -529,8 +534,9 @@ func (m *MongodbDatabase) CreateReadOnlyUser(
return "", "", fmt.Errorf("failed to create user: %w", err)
}
- logger.Info(
- "Read-only MongoDB user created successfully",
+ logger.InfoContext(
+ ctx,
+ "read-only MongoDB user created successfully",
"username", newUsername,
)
return newUsername, newPassword, nil
diff --git a/backend/internal/features/databases/databases/mysql/model.go b/backend/internal/features/databases/databases/mysql/model.go
index ec32cd73..df2e9b83 100644
--- a/backend/internal/features/databases/databases/mysql/model.go
+++ b/backend/internal/features/databases/databases/mysql/model.go
@@ -97,11 +97,14 @@ func (m *MysqlDatabase) TestConnection(
db, err := sql.Open("mysql", dsn)
if err != nil {
+ // The DSN carries the password, so only the database name goes into the log.
+ logger.ErrorContext(ctx, "failed to open the mysql connection", "database_name", *m.Database, "error", err)
+
return fmt.Errorf("failed to connect to MySQL database '%s': %w", *m.Database, err)
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close MySQL connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close the mysql connection", "error", closeErr)
}
}()
@@ -110,6 +113,8 @@ func (m *MysqlDatabase) TestConnection(
db.SetMaxIdleConns(1)
if err := db.PingContext(ctx); err != nil {
+ logger.ErrorContext(ctx, "failed to ping the mysql database", "database_name", *m.Database, "error", err)
+
return fmt.Errorf("failed to ping MySQL database '%s': %w", *m.Database, err)
}
@@ -154,7 +159,7 @@ func (m *MysqlDatabase) GetRawDbSizeMb(
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close MySQL connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close MySQL connection", "error", closeErr)
}
}()
@@ -255,7 +260,7 @@ func (m *MysqlDatabase) PopulateDbData(
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close the connection", "error", closeErr)
}
}()
@@ -298,7 +303,7 @@ func (m *MysqlDatabase) PopulateVersion(
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close the connection", "error", closeErr)
}
}()
@@ -329,7 +334,7 @@ func (m *MysqlDatabase) IsUserReadOnly(
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close connection", "error", closeErr)
}
}()
@@ -408,7 +413,7 @@ func (m *MysqlDatabase) CreateReadOnlyUser(
}
defer func() {
if closeErr := db.Close(); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close connection", "error", closeErr)
}
}()
@@ -426,7 +431,7 @@ func (m *MysqlDatabase) CreateReadOnlyUser(
defer func() {
if !success {
if rollbackErr := tx.Rollback(); rollbackErr != nil {
- logger.Error("Failed to rollback transaction", "error", rollbackErr)
+ logger.ErrorContext(ctx, "failed to rollback transaction", "error", rollbackErr)
}
}
}()
@@ -470,8 +475,9 @@ func (m *MysqlDatabase) CreateReadOnlyUser(
}
success = true
- logger.Info(
- "Read-only MySQL user created successfully",
+ logger.InfoContext(
+ ctx,
+ "read-only MySQL user created successfully",
"username",
newUsername,
)
diff --git a/backend/internal/features/databases/databases/postgresql/logical/model.go b/backend/internal/features/databases/databases/postgresql/logical/model.go
index 61ab4050..f0e11dce 100644
--- a/backend/internal/features/databases/databases/postgresql/logical/model.go
+++ b/backend/internal/features/databases/databases/postgresql/logical/model.go
@@ -158,7 +158,7 @@ func (p *PostgresqlLogicalDatabase) GetRawDbSizeMb(
}
defer func() {
if closeErr := conn.Close(ctx); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close connection", "error", closeErr)
}
}()
@@ -282,7 +282,7 @@ func (p *PostgresqlLogicalDatabase) PopulateVersion(
}
defer func() {
if closeErr := conn.Close(ctx); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.Error("failed to close connection", "error", closeErr)
}
}()
@@ -320,7 +320,7 @@ func (p *PostgresqlLogicalDatabase) IsUserReadOnly(
}
defer func() {
if closeErr := conn.Close(ctx); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close connection", "error", closeErr)
}
}()
@@ -484,7 +484,7 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
}
defer func() {
if closeErr := conn.Close(ctx); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close connection", "error", closeErr)
}
}()
@@ -529,7 +529,7 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
defer func() {
if !success {
if rollbackErr := tx.Rollback(ctx); rollbackErr != nil {
- logger.Error("Failed to rollback transaction", "error", rollbackErr)
+ logger.ErrorContext(ctx, "failed to rollback transaction", "error", rollbackErr)
}
}
}()
@@ -568,8 +568,9 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
_, err = tx.Exec(ctx, `REVOKE CREATE ON SCHEMA public FROM PUBLIC`)
if err != nil {
if strings.Contains(err.Error(), "permission denied") {
- logger.Warn(
- "Failed to revoke CREATE on public from PUBLIC (permission denied)",
+ logger.WarnContext(
+ ctx,
+ "failed to revoke CREATE on public from PUBLIC (permission denied)",
"error",
err,
)
@@ -584,8 +585,9 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
fmt.Sprintf(`REVOKE CREATE ON SCHEMA public FROM "%s"`, baseUsername),
)
if err != nil {
- logger.Warn(
- "Failed to revoke CREATE on public schema from user",
+ logger.WarnContext(
+ ctx,
+ "failed to revoke CREATE on public schema from user",
"error",
err,
"username",
@@ -593,7 +595,7 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
)
}
} else {
- logger.Info("Public schema does not exist, skipping CREATE privilege revocation")
+ logger.InfoContext(ctx, "public schema does not exist, skipping CREATE privilege revocation")
}
// Step 3: Grant database connection privilege and revoke TEMP
@@ -608,7 +610,7 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
// Revoke TEMP privilege from PUBLIC role (like CREATE on public schema, TEMP is granted to PUBLIC by default)
_, err = tx.Exec(ctx, fmt.Sprintf(`REVOKE TEMP ON DATABASE "%s" FROM PUBLIC`, *p.Database))
if err != nil {
- logger.Warn("Failed to revoke TEMP from PUBLIC", "error", err)
+ logger.WarnContext(ctx, "failed to revoke TEMP from PUBLIC", "error", err)
}
// Also revoke from the specific user (belt and suspenders)
@@ -617,7 +619,7 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
fmt.Sprintf(`REVOKE TEMP ON DATABASE "%s" FROM "%s"`, *p.Database, baseUsername),
)
if err != nil {
- logger.Warn("Failed to revoke TEMP privilege", "error", err, "username", baseUsername)
+ logger.WarnContext(ctx, "failed to revoke TEMP privilege", "error", err, "username", baseUsername)
}
// Step 4: Discover schemas to grant privileges on
@@ -664,8 +666,9 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
fmt.Sprintf(`REVOKE CREATE ON SCHEMA "%s" FROM "%s"`, schema, baseUsername),
)
if err != nil {
- logger.Warn(
- "Failed to revoke CREATE on schema",
+ logger.WarnContext(
+ ctx,
+ "failed to revoke CREATE on schema",
"error",
err,
"schema",
@@ -794,14 +797,14 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
if err != nil {
// Log warning but continue - this is a best-effort enhancement
- logger.Warn("Failed to query object owners for default privileges", "error", err)
+ logger.WarnContext(ctx, "failed to query object owners for default privileges", "error", err)
} else {
var schemaOwners []SchemaOwner
for ownerRows.Next() {
var so SchemaOwner
if err := ownerRows.Scan(&so.SchemaName, &so.RoleName); err != nil {
ownerRows.Close()
- logger.Warn("Failed to scan schema owner", "error", err)
+ logger.WarnContext(ctx, "failed to scan schema owner", "error", err)
break
}
schemaOwners = append(schemaOwners, so)
@@ -809,7 +812,7 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
ownerRows.Close()
if err := ownerRows.Err(); err != nil {
- logger.Warn("Error iterating schema owners", "error", err)
+ logger.WarnContext(ctx, "error iterating schema owners", "error", err)
}
// Step 9: Set default privileges FOR ROLE for each object owner
@@ -827,8 +830,9 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
),
)
if err != nil {
- logger.Warn(
- "Failed to set default privileges for role (tables)",
+ logger.WarnContext(
+ ctx,
+ "failed to set default privileges for role (tables)",
"error",
err,
"role",
@@ -851,8 +855,9 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
),
)
if err != nil {
- logger.Warn(
- "Failed to set default privileges for role (sequences)",
+ logger.WarnContext(
+ ctx,
+ "failed to set default privileges for role (sequences)",
"error",
err,
"role",
@@ -866,8 +871,9 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
}
if len(schemaOwners) > 0 {
- logger.Info(
- "Set default privileges for existing object owners",
+ logger.InfoContext(
+ ctx,
+ "set default privileges for existing object owners",
"readonly_user",
baseUsername,
"owner_count",
@@ -890,8 +896,9 @@ func (p *PostgresqlLogicalDatabase) CreateReadOnlyUser(
success = true
// Return connectionUsername (with project ID suffix for Supabase) for the caller to use when connecting
- logger.Info(
- "Read-only user created successfully",
+ logger.InfoContext(
+ ctx,
+ "read-only user created successfully",
"username",
baseUsername,
"connectionUsername",
@@ -935,7 +942,7 @@ func testSingleDatabaseConnection(
}
defer func() {
if closeErr := conn.Close(ctx); closeErr != nil {
- logger.Error("Failed to close connection", "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close connection", "error", closeErr)
}
}()
diff --git a/backend/internal/features/databases/databases/postgresql/physical/connection.go b/backend/internal/features/databases/databases/postgresql/physical/connection.go
index 93843cd8..b0d7052b 100644
--- a/backend/internal/features/databases/databases/postgresql/physical/connection.go
+++ b/backend/internal/features/databases/databases/postgresql/physical/connection.go
@@ -71,7 +71,7 @@ func openPhysicalReplicationConn(
func closeConnQuietly(ctx context.Context, conn *pgx.Conn, logger *slog.Logger) {
if err := conn.Close(ctx); err != nil {
- logger.Warn("failed to close connection", "error", err)
+ logger.WarnContext(ctx, "failed to close connection", "error", err)
}
}
diff --git a/backend/internal/features/databases/databases/postgresql/physical/model.go b/backend/internal/features/databases/databases/postgresql/physical/model.go
index 58f8b10a..b2e826b8 100644
--- a/backend/internal/features/databases/databases/postgresql/physical/model.go
+++ b/backend/internal/features/databases/databases/postgresql/physical/model.go
@@ -242,7 +242,8 @@ func (p *PostgresqlPhysicalDatabase) PopulateDbData(
if p.WalSegmentSizeBytes == nil {
var sizeBytes int64
- if err := conn.QueryRow(ctx,
+ if err := conn.QueryRow(
+ ctx,
"SELECT setting::bigint FROM pg_settings WHERE name = 'wal_segment_size'",
).Scan(&sizeBytes); err != nil {
return fmt.Errorf("failed to read wal_segment_size: %w", err)
@@ -319,7 +320,8 @@ func (p *PostgresqlPhysicalDatabase) VerifyWalSlot(
defer closeConnQuietly(ctx, conn, logger)
var slotType string
- err = conn.QueryRow(ctx,
+ err = conn.QueryRow(
+ ctx,
"SELECT slot_type FROM pg_replication_slots WHERE slot_name = $1",
p.ReplicationSlotName,
).Scan(&slotType)
@@ -333,7 +335,7 @@ func (p *PostgresqlPhysicalDatabase) VerifyWalSlot(
)
}
- logger.Debug("replication slot already exists", "slot_name", p.ReplicationSlotName)
+ logger.DebugContext(ctx, "replication slot already exists", "slot_name", p.ReplicationSlotName)
return nil
@@ -343,14 +345,15 @@ func (p *PostgresqlPhysicalDatabase) VerifyWalSlot(
return fmt.Errorf("query pg_replication_slots: %w", err)
}
- _, err = conn.Exec(ctx,
+ _, err = conn.Exec(
+ ctx,
"SELECT pg_create_physical_replication_slot($1, true)",
p.ReplicationSlotName,
)
if err != nil {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) && pgErr.Code == "42710" {
- logger.Debug("replication slot created by concurrent verify",
+ logger.DebugContext(ctx, "replication slot created by concurrent verify",
"slot_name", p.ReplicationSlotName)
return nil
@@ -359,7 +362,7 @@ func (p *PostgresqlPhysicalDatabase) VerifyWalSlot(
return fmt.Errorf("create physical replication slot: %w", err)
}
- logger.Info("replication slot created", "slot_name", p.ReplicationSlotName)
+ logger.InfoContext(ctx, "replication slot created", "slot_name", p.ReplicationSlotName)
return nil
}
@@ -389,14 +392,15 @@ func (p *PostgresqlPhysicalDatabase) DropWalSlot(
var slotType string
var isActive bool
- err = conn.QueryRow(ctx,
+ err = conn.QueryRow(
+ ctx,
"SELECT slot_type, active FROM pg_replication_slots WHERE slot_name = $1",
p.ReplicationSlotName,
).Scan(&slotType, &isActive)
switch {
case errors.Is(err, pgx.ErrNoRows):
- logger.Debug("replication slot already absent", "slot_name", p.ReplicationSlotName)
+ logger.DebugContext(ctx, "replication slot already absent", "slot_name", p.ReplicationSlotName)
return nil
@@ -418,14 +422,15 @@ func (p *PostgresqlPhysicalDatabase) DropWalSlot(
)
}
- _, err = conn.Exec(ctx,
+ _, err = conn.Exec(
+ ctx,
"SELECT pg_drop_replication_slot($1)",
p.ReplicationSlotName,
)
if err != nil {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) && pgErr.Code == "42704" {
- logger.Debug("replication slot dropped by concurrent caller",
+ logger.DebugContext(ctx, "replication slot dropped by concurrent caller",
"slot_name", p.ReplicationSlotName)
return nil
@@ -434,7 +439,7 @@ func (p *PostgresqlPhysicalDatabase) DropWalSlot(
return fmt.Errorf("drop replication slot: %w", err)
}
- logger.Info("replication slot dropped", "slot_name", p.ReplicationSlotName)
+ logger.InfoContext(ctx, "replication slot dropped", "slot_name", p.ReplicationSlotName)
return nil
}
@@ -467,14 +472,15 @@ func (p *PostgresqlPhysicalDatabase) DropWalSlotForRemoval(
var slotType string
var isActive bool
var activePID *int
- err = conn.QueryRow(ctx,
+ err = conn.QueryRow(
+ ctx,
"SELECT slot_type, active, active_pid FROM pg_replication_slots WHERE slot_name = $1",
p.ReplicationSlotName,
).Scan(&slotType, &isActive, &activePID)
switch {
case errors.Is(err, pgx.ErrNoRows):
- logger.Debug("replication slot already absent", "slot_name", p.ReplicationSlotName)
+ logger.DebugContext(ctx, "replication slot already absent", "slot_name", p.ReplicationSlotName)
return nil
@@ -498,7 +504,7 @@ func (p *PostgresqlPhysicalDatabase) DropWalSlotForRemoval(
// rather than assume the detach is instantaneous.
if activePID != nil {
if _, termErr := conn.Exec(ctx, "SELECT pg_terminate_backend($1)", *activePID); termErr != nil {
- logger.Warn("failed to terminate replication slot consumer",
+ logger.WarnContext(ctx, "failed to terminate replication slot consumer",
"slot_name", p.ReplicationSlotName, "active_pid", *activePID, "error", termErr)
}
}
@@ -514,7 +520,9 @@ func (p *PostgresqlPhysicalDatabase) DropWalSlotForRemoval(
if err != nil {
var pgErr *pgconn.PgError
if errors.As(err, &pgErr) && pgErr.Code == "42704" {
- logger.Debug("replication slot dropped by concurrent caller", "slot_name", p.ReplicationSlotName)
+ logger.DebugContext(ctx, "replication slot dropped by concurrent caller",
+ "slot_name", p.ReplicationSlotName,
+ )
return nil
}
@@ -522,7 +530,7 @@ func (p *PostgresqlPhysicalDatabase) DropWalSlotForRemoval(
return fmt.Errorf("drop replication slot: %w", err)
}
- logger.Info("replication slot dropped", "slot_name", p.ReplicationSlotName)
+ logger.InfoContext(ctx, "replication slot dropped", "slot_name", p.ReplicationSlotName)
return nil
}
@@ -749,7 +757,7 @@ func (p *PostgresqlPhysicalDatabase) CreateReplicationOnlyUser(
defer func() {
if !isCommitted {
if rollbackErr := tx.Rollback(ctx); rollbackErr != nil {
- logger.Warn("failed to rollback transaction", "error", rollbackErr)
+ logger.WarnContext(ctx, "failed to rollback transaction", "error", rollbackErr)
}
}
}()
@@ -783,7 +791,7 @@ func (p *PostgresqlPhysicalDatabase) CreateReplicationOnlyUser(
}
isCommitted = true
- logger.Info("replication-only user created", "username", baseUsername, "platform", platform)
+ logger.InfoContext(ctx, "replication-only user created", "username", baseUsername, "platform", platform)
return baseUsername, newPassword, nil
}
diff --git a/backend/internal/features/databases/interfaces.go b/backend/internal/features/databases/interfaces.go
index 64921206..c0e824e4 100644
--- a/backend/internal/features/databases/interfaces.go
+++ b/backend/internal/features/databases/interfaces.go
@@ -1,17 +1,19 @@
package databases
import (
+ "context"
+
"github.com/google/uuid"
)
type DatabaseCreationListener interface {
- OnDatabaseCreated(databaseID uuid.UUID)
+ OnDatabaseCreated(ctx context.Context, databaseID uuid.UUID)
}
type DatabaseRemoveListener interface {
- OnBeforeDatabaseRemove(databaseID uuid.UUID) error
+ OnBeforeDatabaseRemove(ctx context.Context, databaseID uuid.UUID) error
}
type DatabaseCopyListener interface {
- OnDatabaseCopied(originalDatabaseID, newDatabaseID uuid.UUID)
+ OnDatabaseCopied(ctx context.Context, originalDatabaseID, newDatabaseID uuid.UUID)
}
diff --git a/backend/internal/features/databases/physical_model_test.go b/backend/internal/features/databases/physical_model_test.go
index 8f05eed3..626f144c 100644
--- a/backend/internal/features/databases/physical_model_test.go
+++ b/backend/internal/features/databases/physical_model_test.go
@@ -81,13 +81,13 @@ func Test_TestConnection_OnPhysicalDatabase_DispatchesToReplicationConnection(t
for _, fx := range physicalFixtures() {
t.Run(fx.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createPhysicalDatabaseInternalAPI(t, router, workspace.ID, owner.Token, fx)
defer func() {
- RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
test_utils.MakePostRequest(
@@ -105,13 +105,13 @@ func Test_CreateReplicationOnlyUser_OnPhysicalDatabase_ReturnsCredentials(t *tes
for _, fx := range physicalFixtures() {
t.Run(fx.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createPhysicalDatabaseInternalAPI(t, router, workspace.ID, owner.Token, fx)
defer func() {
- RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
var response CreateReadOnlyUserResponse
@@ -135,13 +135,13 @@ func Test_TestDatabaseConnectionDirect_OnReplicationReadyCluster_ReturnsSuccess(
for _, fx := range physicalFixtures() {
t.Run(fx.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createPhysicalDatabaseInternalAPI(t, router, workspace.ID, owner.Token, fx)
defer func() {
- RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
test_utils.MakePostRequest(
@@ -157,9 +157,9 @@ func Test_TestDatabaseConnectionDirect_OnReplicationReadyCluster_ReturnsSuccess(
func Test_TestDatabaseConnectionDirect_WithoutPhysicalConfig_ReturnsBadRequest(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
databaseWithoutConfig := Database{
WorkspaceID: &workspace.ID,
@@ -182,8 +182,8 @@ func Test_CreatePhysicalDatabase_DetectsVersionFromServer_OverridingPayloadVersi
for _, fx := range physicalFixtures() {
t.Run(fx.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
request := buildPhysicalDatabaseRequest(t, workspace.ID, fx)
request.PostgresqlPhysical.Version = tools.PostgresqlVersion16
@@ -197,8 +197,8 @@ func Test_CreatePhysicalDatabase_DetectsVersionFromServer_OverridingPayloadVersi
var database Database
require.NoError(t, json.Unmarshal(w.Body.Bytes(), &database))
defer func() {
- RemoveTestDatabase(&database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ RemoveTestDatabase(t.Context(), &database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
assert.Equal(t, fx.version, database.PostgresqlPhysical.Version)
@@ -208,9 +208,9 @@ func Test_CreatePhysicalDatabase_DetectsVersionFromServer_OverridingPayloadVersi
func Test_CreatePhysicalDatabase_OnUnsupportedServerVersion_ReturnsError(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
port, err := strconv.Atoi(config.GetEnv().TestLogicalPostgres16Port)
require.NoError(t, err)
@@ -240,13 +240,13 @@ func Test_CreatePhysicalDatabase_OnUnsupportedServerVersion_ReturnsError(t *test
func Test_CreateReplicationOnlyUser_OnLogicalDatabase_ReturnsBadRequest(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
logicalDB := createTestDatabaseViaAPI("Logical DB", workspace.ID, owner.Token, router)
defer func() {
- RemoveTestDatabase(logicalDB)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ RemoveTestDatabase(t.Context(), logicalDB)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
testResp := test_utils.MakePostRequest(
@@ -264,13 +264,13 @@ func Test_UpdatePhysicalDatabase_KeepsSameChildRow_WithStableIdAndDatabaseId(t *
for _, fx := range physicalFixtures() {
t.Run(fx.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createPhysicalDatabaseInternalAPI(t, router, workspace.ID, owner.Token, fx)
defer func() {
- RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
createdDatabase, err := databaseRepository.FindByID(database.ID)
@@ -309,8 +309,8 @@ func Test_CopyDatabase_OnPhysicalDatabase_DoesNotCopySystemIdentifier(t *testing
for _, fx := range physicalFixtures() {
t.Run(fx.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
originalDatabase := createPhysicalDatabaseInternalAPI(t, router, workspace.ID, owner.Token, fx)
@@ -331,9 +331,9 @@ func Test_CopyDatabase_OnPhysicalDatabase_DoesNotCopySystemIdentifier(t *testing
&copiedDatabase,
)
defer func() {
- RemoveTestDatabase(&copiedDatabase)
- RemoveTestDatabase(originalDatabase)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ RemoveTestDatabase(t.Context(), &copiedDatabase)
+ RemoveTestDatabase(t.Context(), originalDatabase)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}()
copiedPersistedDatabase, err := databaseRepository.FindByID(copiedDatabase.ID)
diff --git a/backend/internal/features/databases/service.go b/backend/internal/features/databases/service.go
index ed96f5b6..9c15a4da 100644
--- a/backend/internal/features/databases/service.go
+++ b/backend/internal/features/databases/service.go
@@ -12,6 +12,7 @@ import (
"gorm.io/gorm"
audit_logs "databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
physical_core_service "databasus-backend/internal/features/backups/backups/core/physical/service"
"databasus-backend/internal/features/notifiers"
users_models "databasus-backend/internal/features/users/models"
@@ -64,11 +65,12 @@ func (s *DatabaseService) GetNotifierAttachedDatabasesIDs(
}
func (s *DatabaseService) CreateDatabase(
+ ctx context.Context,
user *users_models.User,
workspaceID uuid.UUID,
database *Database,
) (*Database, error) {
- canManage, err := s.workspaceService.CanUserManageDBs(workspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, workspaceID, user)
if err != nil {
return nil, err
}
@@ -85,7 +87,7 @@ func (s *DatabaseService) CreateDatabase(
// The database has no ID until it is saved, so the workspace is all there is to correlate on.
logger := s.logger.With("workspace_id", workspaceID)
- tunneledDatabase, err := OpenTunnel(context.Background(), OpenTunnelSpec{
+ tunneledDatabase, err := OpenTunnel(ctx, OpenTunnelSpec{
Database: database,
Logger: logger,
Encryptor: s.fieldEncryptor,
@@ -120,19 +122,20 @@ func (s *DatabaseService) CreateDatabase(
}
for _, listener := range s.dbCreationListener {
- listener.OnDatabaseCreated(database.ID)
+ listener.OnDatabaseCreated(ctx, database.ID)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Database created: %s", database.Name),
- &user.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Database created: %s", database.Name),
+ UserID: &user.ID,
+ WorkspaceID: &workspaceID,
+ })
return database, nil
}
func (s *DatabaseService) UpdateDatabase(
+ ctx context.Context,
user *users_models.User,
database *Database,
) error {
@@ -149,7 +152,7 @@ func (s *DatabaseService) UpdateDatabase(
return errors.New("cannot update database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*existingDatabase.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *existingDatabase.WorkspaceID, user)
if err != nil {
return err
}
@@ -175,7 +178,7 @@ func (s *DatabaseService) UpdateDatabase(
logger := s.logger.With("database_id", existingDatabase.ID)
- tunneledDatabase, err := OpenTunnel(context.Background(), OpenTunnelSpec{
+ tunneledDatabase, err := OpenTunnel(ctx, OpenTunnelSpec{
Database: existingDatabase,
Logger: logger,
Encryptor: s.fieldEncryptor,
@@ -211,27 +214,24 @@ func (s *DatabaseService) UpdateDatabase(
}
if oldName != existingDatabase.Name {
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf(
- "Database updated and renamed from '%s' to '%s'",
- oldName,
- existingDatabase.Name,
- ),
- &user.ID,
- existingDatabase.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Database updated and renamed from '%s' to '%s'", oldName, existingDatabase.Name),
+ UserID: &user.ID,
+ WorkspaceID: existingDatabase.WorkspaceID,
+ })
} else {
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Database updated: %s", existingDatabase.Name),
- &user.ID,
- existingDatabase.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Database updated: %s", existingDatabase.Name),
+ UserID: &user.ID,
+ WorkspaceID: existingDatabase.WorkspaceID,
+ })
}
return nil
}
func (s *DatabaseService) DeleteDatabase(
+ ctx context.Context,
user *users_models.User,
id uuid.UUID,
) error {
@@ -244,7 +244,7 @@ func (s *DatabaseService) DeleteDatabase(
return errors.New("cannot delete database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*existingDatabase.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *existingDatabase.WorkspaceID, user)
if err != nil {
return err
}
@@ -253,16 +253,16 @@ func (s *DatabaseService) DeleteDatabase(
}
for _, listener := range s.dbRemoveListener {
- if err := listener.OnBeforeDatabaseRemove(id); err != nil {
+ if err := listener.OnBeforeDatabaseRemove(ctx, id); err != nil {
return err
}
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Database deleted: %s", existingDatabase.Name),
- &user.ID,
- existingDatabase.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Database deleted: %s", existingDatabase.Name),
+ UserID: &user.ID,
+ WorkspaceID: existingDatabase.WorkspaceID,
+ })
return s.dbRepository.Delete(id)
}
@@ -279,12 +279,12 @@ func (s *DatabaseService) DeleteDatabase(
// parallel test suite (go test -p=N) the cascade can deadlock against a concurrent writer in
// the same process (a backup scheduler still settling), surfacing as SQLSTATE 40P01. The
// aborted transaction is transient, so the whole delete — idempotent on a re-run — is retried.
-func (s *DatabaseService) DeleteForTest(id uuid.UUID) error {
+func (s *DatabaseService) DeleteForTest(ctx context.Context, id uuid.UUID) error {
const maxAttempts = 5
deleteOnce := func() error {
for _, listener := range s.dbRemoveListener {
- if err := listener.OnBeforeDatabaseRemove(id); err != nil {
+ if err := listener.OnBeforeDatabaseRemove(ctx, id); err != nil {
return err
}
}
@@ -319,6 +319,7 @@ func isTransientSerializationError(err error) bool {
}
func (s *DatabaseService) GetDatabase(
+ ctx context.Context,
user *users_models.User,
id uuid.UUID,
) (*Database, error) {
@@ -331,7 +332,7 @@ func (s *DatabaseService) GetDatabase(
return nil, errors.New("cannot access database without workspace")
}
- canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(*database.WorkspaceID, user)
+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, *database.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -344,10 +345,11 @@ func (s *DatabaseService) GetDatabase(
}
func (s *DatabaseService) GetDatabasesByWorkspace(
+ ctx context.Context,
user *users_models.User,
workspaceID uuid.UUID,
) ([]*Database, error) {
- canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(workspaceID, user)
+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, workspaceID, user)
if err != nil {
return nil, err
}
@@ -364,16 +366,17 @@ func (s *DatabaseService) GetDatabasesByWorkspace(
database.HideSensitiveData()
}
- s.fillPhysicalLastBackupTimes(databases)
+ s.fillPhysicalLastBackupTimes(ctx, databases)
return databases, nil
}
func (s *DatabaseService) IsNotifierUsing(
+ ctx context.Context,
user *users_models.User,
notifierID uuid.UUID,
) (bool, error) {
- _, err := s.notifierService.GetNotifier(user, notifierID)
+ _, err := s.notifierService.GetNotifier(ctx, user, notifierID)
if err != nil {
return false, err
}
@@ -382,10 +385,11 @@ func (s *DatabaseService) IsNotifierUsing(
}
func (s *DatabaseService) CountDatabasesByNotifier(
+ ctx context.Context,
user *users_models.User,
notifierID uuid.UUID,
) (int, error) {
- _, err := s.notifierService.GetNotifier(user, notifierID)
+ _, err := s.notifierService.GetNotifier(ctx, user, notifierID)
if err != nil {
return 0, err
}
@@ -399,6 +403,7 @@ func (s *DatabaseService) CountDatabasesByNotifier(
}
func (s *DatabaseService) TestDatabaseConnection(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
) error {
@@ -411,7 +416,7 @@ func (s *DatabaseService) TestDatabaseConnection(
return errors.New("cannot test connection for database without workspace")
}
- canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(*database.WorkspaceID, user)
+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, *database.WorkspaceID, user)
if err != nil {
return err
}
@@ -421,7 +426,7 @@ func (s *DatabaseService) TestDatabaseConnection(
logger := s.logger.With("database_id", database.ID)
- tunneledDatabase, err := OpenTunnel(context.Background(), OpenTunnelSpec{
+ tunneledDatabase, err := OpenTunnel(ctx, OpenTunnelSpec{
Database: database,
Logger: logger,
Encryptor: s.fieldEncryptor,
@@ -449,6 +454,7 @@ func (s *DatabaseService) TestDatabaseConnection(
}
func (s *DatabaseService) TestDatabaseConnectionDirect(
+ ctx context.Context,
database *Database,
) error {
usingDatabase, err := s.resolveConnectionTarget(database)
@@ -458,7 +464,7 @@ func (s *DatabaseService) TestDatabaseConnectionDirect(
logger := s.logger.With("database_id", usingDatabase.ID)
- tunneledDatabase, err := OpenTunnel(context.Background(), OpenTunnelSpec{
+ tunneledDatabase, err := OpenTunnel(ctx, OpenTunnelSpec{
Database: usingDatabase,
Logger: logger,
Encryptor: s.fieldEncryptor,
@@ -514,6 +520,7 @@ func (s *DatabaseService) SetLastBackupTime(databaseID uuid.UUID, backupTime tim
}
func (s *DatabaseService) CopyDatabase(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
) (*Database, error) {
@@ -526,7 +533,7 @@ func (s *DatabaseService) CopyDatabase(
return nil, errors.New("cannot copy database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*existingDatabase.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *existingDatabase.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -547,23 +554,24 @@ func (s *DatabaseService) CopyDatabase(
}
for _, listener := range s.dbCreationListener {
- listener.OnDatabaseCreated(copiedDatabase.ID)
+ listener.OnDatabaseCreated(ctx, copiedDatabase.ID)
}
for _, listener := range s.dbCopyListener {
- listener.OnDatabaseCopied(databaseID, copiedDatabase.ID)
+ listener.OnDatabaseCopied(ctx, databaseID, copiedDatabase.ID)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Database copied: %s to %s", existingDatabase.Name, copiedDatabase.Name),
- &user.ID,
- existingDatabase.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Database copied: %s to %s", existingDatabase.Name, copiedDatabase.Name),
+ UserID: &user.ID,
+ WorkspaceID: existingDatabase.WorkspaceID,
+ })
return copiedDatabase, nil
}
func (s *DatabaseService) TransferDatabaseToWorkspace(
+ ctx context.Context,
databaseID uuid.UUID,
targetWorkspaceID uuid.UUID,
) error {
@@ -590,12 +598,16 @@ func (s *DatabaseService) TransferDatabaseToWorkspace(
return fmt.Errorf("failed to get target workspace: %w", err)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Database transferred: %s from workspace '%s' to workspace '%s'",
- database.Name, sourceWorkspace.Name, targetWorkspace.Name),
- nil,
- &targetWorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf(
+ "Database transferred: %s from workspace '%s' to workspace '%s'",
+ database.Name,
+ sourceWorkspace.Name,
+ targetWorkspace.Name,
+ ),
+ UserID: nil,
+ WorkspaceID: &targetWorkspaceID,
+ })
return nil
}
@@ -650,6 +662,7 @@ func (s *DatabaseService) OnBeforeWorkspaceDeletion(workspaceID uuid.UUID) error
}
func (s *DatabaseService) IsUserReadOnly(
+ ctx context.Context,
user *users_models.User,
database *Database,
) (bool, []string, error) {
@@ -666,6 +679,7 @@ func (s *DatabaseService) IsUserReadOnly(
}
canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(
+ ctx,
*existingDatabase.WorkspaceID,
user,
)
@@ -690,6 +704,7 @@ func (s *DatabaseService) IsUserReadOnly(
} else {
if database.WorkspaceID != nil {
canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(
+ ctx,
*database.WorkspaceID,
user,
)
@@ -704,12 +719,12 @@ func (s *DatabaseService) IsUserReadOnly(
usingDatabase = database
}
- ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+ tunnelCtx, cancel := context.WithTimeout(ctx, 15*time.Second)
defer cancel()
logger := s.logger.With("database_id", usingDatabase.ID)
- tunneledDatabase, err := OpenTunnel(ctx, OpenTunnelSpec{
+ tunneledDatabase, err := OpenTunnel(tunnelCtx, OpenTunnelSpec{
Database: usingDatabase,
Logger: logger,
Encryptor: s.fieldEncryptor,
@@ -720,10 +735,11 @@ func (s *DatabaseService) IsUserReadOnly(
defer tunneledDatabase.Close()
- return tunneledDatabase.GetDatabaseThroughTunnel().IsUserReadOnly(ctx, logger, s.fieldEncryptor)
+ return tunneledDatabase.GetDatabaseThroughTunnel().IsUserReadOnly(tunnelCtx, logger, s.fieldEncryptor)
}
func (s *DatabaseService) CreateReadOnlyUser(
+ ctx context.Context,
user *users_models.User,
database *Database,
) (string, string, error) {
@@ -739,7 +755,7 @@ func (s *DatabaseService) CreateReadOnlyUser(
return "", "", errors.New("cannot create user for database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*existingDatabase.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *existingDatabase.WorkspaceID, user)
if err != nil {
return "", "", err
}
@@ -760,7 +776,7 @@ func (s *DatabaseService) CreateReadOnlyUser(
usingDatabase = existingDatabase
} else {
if database.WorkspaceID != nil {
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return "", "", err
}
@@ -772,12 +788,15 @@ func (s *DatabaseService) CreateReadOnlyUser(
usingDatabase = database
}
- ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ // MySQL and MariaDB commit CREATE USER and each GRANT implicitly, so their transaction cannot
+ // roll a half-granted user back. WithoutCancel keeps the request_id while stopping a client
+ // disconnect from cutting the sequence in half.
+ tunnelCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
defer cancel()
logger := s.logger.With("database_id", usingDatabase.ID)
- tunneledDatabase, err := OpenTunnel(ctx, OpenTunnelSpec{
+ tunneledDatabase, err := OpenTunnel(tunnelCtx, OpenTunnelSpec{
Database: usingDatabase,
Logger: logger,
Encryptor: s.fieldEncryptor,
@@ -795,19 +814,19 @@ func (s *DatabaseService) CreateReadOnlyUser(
switch usingDatabase.Type {
case DatabaseTypePostgresLogical:
username, password, err = databaseThroughTunnel.PostgresqlLogical.CreateReadOnlyUser(
- ctx, logger, s.fieldEncryptor,
+ tunnelCtx, logger, s.fieldEncryptor,
)
case DatabaseTypeMysql:
username, password, err = databaseThroughTunnel.Mysql.CreateReadOnlyUser(
- ctx, logger, s.fieldEncryptor,
+ tunnelCtx, logger, s.fieldEncryptor,
)
case DatabaseTypeMariadb:
username, password, err = databaseThroughTunnel.Mariadb.CreateReadOnlyUser(
- ctx, logger, s.fieldEncryptor,
+ tunnelCtx, logger, s.fieldEncryptor,
)
case DatabaseTypeMongodb:
username, password, err = databaseThroughTunnel.Mongodb.CreateReadOnlyUser(
- ctx, logger, s.fieldEncryptor,
+ tunnelCtx, logger, s.fieldEncryptor,
)
default:
return "", "", errors.New("read-only user creation not supported for this database type")
@@ -818,21 +837,22 @@ func (s *DatabaseService) CreateReadOnlyUser(
}
if usingDatabase.WorkspaceID != nil {
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf(
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf(
"Read-only user created for database: %s (username: %s)",
usingDatabase.Name,
username,
),
- &user.ID,
- usingDatabase.WorkspaceID,
- )
+ UserID: &user.ID,
+ WorkspaceID: usingDatabase.WorkspaceID,
+ })
}
return username, password, nil
}
func (s *DatabaseService) CreateReplicationOnlyUser(
+ ctx context.Context,
user *users_models.User,
database *Database,
) (string, string, error) {
@@ -848,7 +868,7 @@ func (s *DatabaseService) CreateReplicationOnlyUser(
return "", "", errors.New("cannot create user for database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*existingDatabase.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *existingDatabase.WorkspaceID, user)
if err != nil {
return "", "", err
}
@@ -869,7 +889,7 @@ func (s *DatabaseService) CreateReplicationOnlyUser(
usingDatabase = existingDatabase
} else {
if database.WorkspaceID != nil {
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return "", "", err
}
@@ -891,12 +911,12 @@ func (s *DatabaseService) CreateReplicationOnlyUser(
return "", "", errors.New("physical database details are missing")
}
- ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+ tunnelCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()
logger := s.logger.With("database_id", usingDatabase.ID)
- tunneledDatabase, err := OpenTunnel(ctx, OpenTunnelSpec{
+ tunneledDatabase, err := OpenTunnel(tunnelCtx, OpenTunnelSpec{
Database: usingDatabase,
Logger: logger,
Encryptor: s.fieldEncryptor,
@@ -908,21 +928,21 @@ func (s *DatabaseService) CreateReplicationOnlyUser(
defer tunneledDatabase.Close()
username, password, err := tunneledDatabase.GetDatabaseThroughTunnel().
- PostgresqlPhysical.CreateReplicationOnlyUser(ctx, logger, s.fieldEncryptor)
+ PostgresqlPhysical.CreateReplicationOnlyUser(tunnelCtx, logger, s.fieldEncryptor)
if err != nil {
return "", "", err
}
if usingDatabase.WorkspaceID != nil {
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf(
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf(
"Replication-only user created for database: %s (username: %s)",
usingDatabase.Name,
username,
),
- &user.ID,
- usingDatabase.WorkspaceID,
- )
+ UserID: &user.ID,
+ WorkspaceID: usingDatabase.WorkspaceID,
+ })
}
return username, password, nil
@@ -932,7 +952,7 @@ func (s *DatabaseService) CreateReplicationOnlyUser(
// whose backups (FULL / INCREMENTAL / WAL) live outside the databases table and so
// are not denormalized onto the row the way logical backups are. A failure here is
// non-fatal: the list must still render, just without the last-backup decoration.
-func (s *DatabaseService) fillPhysicalLastBackupTimes(databases []*Database) {
+func (s *DatabaseService) fillPhysicalLastBackupTimes(ctx context.Context, databases []*Database) {
var physicalDatabaseIDs []uuid.UUID
for _, database := range databases {
@@ -947,7 +967,7 @@ func (s *DatabaseService) fillPhysicalLastBackupTimes(databases []*Database) {
lastBackupTimes, err := s.physicalBackupService.GetLastBackupTimesByDatabaseIDs(physicalDatabaseIDs)
if err != nil {
- s.logger.Error("failed to load physical last backup times", "error", err)
+ s.logger.ErrorContext(ctx, "failed to load physical last backup times", "error", err)
return
}
diff --git a/backend/internal/features/databases/testing.go b/backend/internal/features/databases/testing.go
index 8e557413..9ff635df 100644
--- a/backend/internal/features/databases/testing.go
+++ b/backend/internal/features/databases/testing.go
@@ -1,6 +1,7 @@
package databases
import (
+ "context"
"fmt"
"os"
"path/filepath"
@@ -432,8 +433,10 @@ func CreateTestMongodbDatabase(
return database
}
-func RemoveTestDatabase(database *Database) {
- if err := databaseService.DeleteForTest(database.ID); err != nil {
+// The context is stripped of cancellation because callers pass t.Context() from a t.Cleanup, and
+// the test context is already cancelled by the time cleanup runs.
+func RemoveTestDatabase(ctx context.Context, database *Database) {
+ if err := databaseService.DeleteForTest(context.WithoutCancel(ctx), database.ID); err != nil {
panic(fmt.Sprintf("failed to delete test database: %v", err))
}
}
diff --git a/backend/internal/features/disk/controller.go b/backend/internal/features/disk/controller.go
index 2050c584..30836834 100644
--- a/backend/internal/features/disk/controller.go
+++ b/backend/internal/features/disk/controller.go
@@ -23,8 +23,9 @@ func (c *DiskController) RegisterRoutes(router *gin.RouterGroup) {
// @Failure 500
// @Router /disk/usage [get]
func (c *DiskController) GetDiskUsage(ctx *gin.Context) {
- diskUsage, err := c.diskService.GetDiskUsage()
+ diskUsage, err := c.diskService.GetDiskUsage(ctx.Request.Context())
if err != nil {
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
diff --git a/backend/internal/features/disk/service.go b/backend/internal/features/disk/service.go
index 6fb8c4dd..7fd300f1 100644
--- a/backend/internal/features/disk/service.go
+++ b/backend/internal/features/disk/service.go
@@ -1,6 +1,7 @@
package disk
import (
+ "context"
"fmt"
"path/filepath"
@@ -11,7 +12,7 @@ import (
type DiskService struct{}
-func (s *DiskService) GetDiskUsage() (*DiskUsage, error) {
+func (s *DiskService) GetDiskUsage(ctx context.Context) (*DiskUsage, error) {
cfg := config.GetEnv()
path := filepath.Dir(cfg.DataFolder) // Gets /databasus-data from /databasus-data/backups
diff --git a/backend/internal/features/healthcheck/attempt/background_service.go b/backend/internal/features/healthcheck/attempt/background_service.go
index 644314f1..85dbc0fb 100644
--- a/backend/internal/features/healthcheck/attempt/background_service.go
+++ b/backend/internal/features/healthcheck/attempt/background_service.go
@@ -7,9 +7,13 @@ import (
"sync/atomic"
"time"
+ "github.com/google/uuid"
+
healthcheck_config "databasus-backend/internal/features/healthcheck/config"
)
+const jobName = "healthcheck_attempt_scan"
+
type HealthcheckAttemptBackgroundService struct {
healthcheckConfigService *healthcheck_config.HealthcheckConfigService
checkDatabaseHealthUseCase *CheckDatabaseHealthUseCase
@@ -24,39 +28,47 @@ func (s *HealthcheckAttemptBackgroundService) Run(ctx context.Context) {
}
// first healthcheck immediately
- s.checkDatabases()
+ s.checkDatabases(ctx)
ticker := time.NewTicker(time.Minute)
defer ticker.Stop()
+ lifecycleLogger := s.logger.With("job_name", jobName)
+
+ lifecycleLogger.InfoContext(ctx, "database healthcheck started")
+
for {
select {
case <-ctx.Done():
+ lifecycleLogger.InfoContext(ctx, "database healthcheck stopped")
+
return
case <-ticker.C:
- s.checkDatabases()
+ s.checkDatabases(ctx)
}
}
}
-func (s *HealthcheckAttemptBackgroundService) checkDatabases() {
+func (s *HealthcheckAttemptBackgroundService) checkDatabases(ctx context.Context) {
now := time.Now().UTC()
+ logger := s.logger.With("job_id", uuid.New(), "job_name", jobName)
healthcheckConfigs, err := s.healthcheckConfigService.GetDatabasesWithEnabledHealthcheck()
if err != nil {
- s.logger.Error("failed to get databases with enabled healthcheck", "error", err)
+ logger.ErrorContext(ctx, "failed to get databases with enabled healthcheck", "error", err)
+
return
}
+ logger.DebugContext(ctx, fmt.Sprintf("probing %d databases with healthcheck enabled",
+ len(healthcheckConfigs)))
+
for _, healthcheckConfig := range healthcheckConfigs {
go func() {
- err := s.checkDatabaseHealthUseCase.Execute(now, &healthcheckConfig)
- if err != nil {
- s.logger.Error(
- "failed to check database health",
- "database_id", healthcheckConfig.DatabaseID,
- "error", err,
- )
+ databaseLogger := logger.With("database_id", healthcheckConfig.DatabaseID)
+
+ if err := s.checkDatabaseHealthUseCase.Execute(ctx, databaseLogger, now, &healthcheckConfig); err != nil {
+ databaseLogger.ErrorContext(ctx, "failed to check database health", "error", err)
}
}()
}
diff --git a/backend/internal/features/healthcheck/attempt/check_database_health_uc.go b/backend/internal/features/healthcheck/attempt/check_database_health_uc.go
index 7e29e826..32831e89 100644
--- a/backend/internal/features/healthcheck/attempt/check_database_health_uc.go
+++ b/backend/internal/features/healthcheck/attempt/check_database_health_uc.go
@@ -1,6 +1,7 @@
package healthcheck_attempt
import (
+ "context"
"errors"
"fmt"
"log/slog"
@@ -12,7 +13,6 @@ import (
"databasus-backend/internal/features/databases"
healthcheck_config "databasus-backend/internal/features/healthcheck/config"
notifier_models "databasus-backend/internal/features/notifiers/models"
- "databasus-backend/internal/util/logger"
)
type CheckDatabaseHealthUseCase struct {
@@ -22,6 +22,8 @@ type CheckDatabaseHealthUseCase struct {
}
func (uc *CheckDatabaseHealthUseCase) Execute(
+ ctx context.Context,
+ logger *slog.Logger,
now time.Time,
healthcheckConfig *healthcheck_config.HealthcheckConfig,
) error {
@@ -43,7 +45,7 @@ func (uc *CheckDatabaseHealthUseCase) Execute(
return nil
}
- healthcheckAttempt, err := uc.healthcheckDatabase(now, database)
+ healthcheckAttempt, err := uc.healthcheckDatabase(ctx, logger, now, database)
if err != nil {
return err
}
@@ -53,7 +55,7 @@ func (uc *CheckDatabaseHealthUseCase) Execute(
return err
}
- err = uc.updateDatabaseHealthStatusIfChanged(
+ err = uc.updateDatabaseHealthStatusIfChanged(ctx,
database,
healthcheckConfig,
healthcheckAttempt,
@@ -74,6 +76,7 @@ func (uc *CheckDatabaseHealthUseCase) Execute(
}
func (uc *CheckDatabaseHealthUseCase) updateDatabaseHealthStatusIfChanged(
+ ctx context.Context,
database *databases.Database,
healthcheckConfig *healthcheck_config.HealthcheckConfig,
healthcheckAttempt *HealthcheckAttempt,
@@ -93,7 +96,7 @@ func (uc *CheckDatabaseHealthUseCase) updateDatabaseHealthStatusIfChanged(
return err
}
- uc.sendDbStatusNotification(
+ uc.sendDbStatusNotification(ctx,
healthcheckConfig,
database,
healthcheckAttempt.Status,
@@ -131,7 +134,7 @@ func (uc *CheckDatabaseHealthUseCase) updateDatabaseHealthStatusIfChanged(
return err
}
- uc.sendDbStatusNotification(
+ uc.sendDbStatusNotification(ctx,
healthcheckConfig,
database,
databases.HealthStatusUnavailable,
@@ -142,19 +145,19 @@ func (uc *CheckDatabaseHealthUseCase) updateDatabaseHealthStatusIfChanged(
}
func (uc *CheckDatabaseHealthUseCase) healthcheckDatabase(
+ ctx context.Context,
+ logger *slog.Logger,
now time.Time,
database *databases.Database,
) (*HealthcheckAttempt, error) {
healthStatus := databases.HealthStatusAvailable
- err := uc.databaseService.TestDatabaseConnectionDirect(database)
- if err != nil {
+
+ // A database being down is the condition this probe exists to detect, and the caller reports it
+ // too, so it is a tolerated finding here rather than something needing attention.
+ if err := uc.databaseService.TestDatabaseConnectionDirect(ctx, database); err != nil {
healthStatus = databases.HealthStatusUnavailable
- logger.GetLogger().
- Error(
- "Database health check failed",
- slog.String("database_id", database.ID.String()),
- slog.String("error", err.Error()),
- )
+
+ logger.WarnContext(ctx, "database healthcheck probe failed", "error", err)
}
attempt := &HealthcheckAttempt{
@@ -190,6 +193,7 @@ func (uc *CheckDatabaseHealthUseCase) isReadyForNewAttempt(
}
func (uc *CheckDatabaseHealthUseCase) sendDbStatusNotification(
+ ctx context.Context,
healthcheckConfig *healthcheck_config.HealthcheckConfig,
database *databases.Database,
newHealthStatus databases.HealthStatus,
@@ -213,6 +217,6 @@ func (uc *CheckDatabaseHealthUseCase) sendDbStatusNotification(
}
for _, notifier := range database.Notifiers {
- uc.healthcheckAttemptSender.SendNotification(&notifier, notification)
+ uc.healthcheckAttemptSender.SendNotification(ctx, &notifier, notification)
}
}
diff --git a/backend/internal/features/healthcheck/attempt/check_database_health_uc_test.go b/backend/internal/features/healthcheck/attempt/check_database_health_uc_test.go
index d68e4e47..8709e198 100644
--- a/backend/internal/features/healthcheck/attempt/check_database_health_uc_test.go
+++ b/backend/internal/features/healthcheck/attempt/check_database_health_uc_test.go
@@ -18,6 +18,7 @@ import (
users_enums "databasus-backend/internal/features/users/enums"
users_testing "databasus-backend/internal/features/users/testing"
workspaces_testing "databasus-backend/internal/features/workspaces/testing"
+ "databasus-backend/internal/util/logger"
)
func unavailableNotification(databaseName string) notifier_models.Notification {
@@ -61,7 +62,7 @@ func newTestHealthcheckConfig(databaseID uuid.UUID) *healthcheck_config.Healthch
}
func Test_CheckDatabaseHealthUseCase(t *testing.T) {
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
// Create workspace directly via service
workspace, err := workspaces_testing.CreateTestWorkspaceDirect("Test Workspace", user.UserID)
@@ -73,14 +74,14 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer func() {
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
workspaces_testing.RemoveTestWorkspaceDirect(workspace.ID)
}()
t.Run("Test_DbAttemptFailed_DbMarkedAsUnavailable", func(t *testing.T) {
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
// Setup mock notifier sender
mockSender := &MockHealthcheckAttemptSender{}
@@ -110,7 +111,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
useCase := newTestUseCase(mockSender, mockDatabaseService)
// Execute healthcheck
- err := useCase.Execute(time.Now().UTC(), healthcheckConfig)
+ err := useCase.Execute(t.Context(), logger.GetLogger(), time.Now().UTC(), healthcheckConfig)
assert.NoError(t, err)
// Verify attempt was created and marked as unavailable
@@ -143,7 +144,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
"Test_DbShouldBeConsideredAsDownOnThirdFailedAttempt_DbNotMarkerdAsDownAfterFirstAttempt",
func(t *testing.T) {
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
// Setup mock notifier sender
mockSender := &MockHealthcheckAttemptSender{}
@@ -169,7 +170,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
useCase := newTestUseCase(mockSender, mockDatabaseService)
// Execute first healthcheck
- err := useCase.Execute(time.Now().UTC(), healthcheckConfig)
+ err := useCase.Execute(t.Context(), logger.GetLogger(), time.Now().UTC(), healthcheckConfig)
assert.NoError(t, err)
// Verify attempt was created and marked as unavailable
@@ -204,7 +205,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
"Test_DbShouldBeConsideredAsDownOnThirdFailedAttempt_DbMarkerdAsDownAfterThirdFailedAttempt",
func(t *testing.T) {
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
// Make sure DB is available
available := databases.HealthStatusAvailable
@@ -243,7 +244,12 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
// Execute three failed healthchecks
now := time.Now().UTC()
for i := range 3 {
- err := useCase.Execute(now.Add(time.Duration(i)*time.Minute), healthcheckConfig)
+ err := useCase.Execute(
+ t.Context(),
+ logger.GetLogger(),
+ now.Add(time.Duration(i)*time.Minute),
+ healthcheckConfig,
+ )
assert.NoError(t, err)
// Verify attempt was created
@@ -276,7 +282,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
t.Run("Test_UnavailableDbAttemptSucceed_DbMarkedAsAvailable", func(t *testing.T) {
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
// Make sure DB is unavailable
unavailable := databases.HealthStatusUnavailable
@@ -312,7 +318,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
useCase := newTestUseCase(mockSender, mockDatabaseService)
// Execute healthcheck (should succeed)
- err = useCase.Execute(time.Now().UTC(), healthcheckConfig)
+ err = useCase.Execute(t.Context(), logger.GetLogger(), time.Now().UTC(), healthcheckConfig)
assert.NoError(t, err)
// Verify attempt was created and marked as available
@@ -345,7 +351,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
"Test_DbHealthcheckExecutedFast_HealthcheckNotExecutedFasterThanInterval",
func(t *testing.T) {
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
// Setup mock notifier sender
mockSender := &MockHealthcheckAttemptSender{}
@@ -375,7 +381,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
// Execute first healthcheck
now := time.Now().UTC()
- err := useCase.Execute(now, healthcheckConfig)
+ err := useCase.Execute(t.Context(), logger.GetLogger(), now, healthcheckConfig)
assert.NoError(t, err)
// Verify first attempt was created
@@ -388,7 +394,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
assert.Equal(t, databases.HealthStatusAvailable, attempts[0].Status)
// Try to execute second healthcheck immediately (should be skipped)
- err = useCase.Execute(now.Add(1*time.Second), healthcheckConfig)
+ err = useCase.Execute(t.Context(), logger.GetLogger(), now.Add(1*time.Second), healthcheckConfig)
assert.NoError(t, err)
// Verify no new attempt was created (still only 1 attempt)
@@ -405,7 +411,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
)
// Try to execute third healthcheck after 4 minutes (still too early)
- err = useCase.Execute(now.Add(4*time.Minute), healthcheckConfig)
+ err = useCase.Execute(t.Context(), logger.GetLogger(), now.Add(4*time.Minute), healthcheckConfig)
assert.NoError(t, err)
// Verify still only 1 attempt
@@ -422,7 +428,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
)
// Execute fourth healthcheck after 5 minutes (should be executed)
- err = useCase.Execute(now.Add(5*time.Minute), healthcheckConfig)
+ err = useCase.Execute(t.Context(), logger.GetLogger(), now.Add(5*time.Minute), healthcheckConfig)
assert.NoError(t, err)
// Verify new attempt was created (now should be 2 attempts)
@@ -452,14 +458,19 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
notifier,
physicalVersionTag,
)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
mockSender := &MockHealthcheckAttemptSender{}
mockSender.On("SendNotification", mock.Anything, mock.Anything).Return()
useCase := newTestUseCase(mockSender, databases.GetDatabaseService())
- err := useCase.Execute(time.Now().UTC(), newTestHealthcheckConfig(database.ID))
+ err := useCase.Execute(
+ t.Context(),
+ logger.GetLogger(),
+ time.Now().UTC(),
+ newTestHealthcheckConfig(database.ID),
+ )
assert.NoError(t, err)
attempts, err := useCase.healthcheckAttemptRepository.FindByDatabaseIDWithLimit(
@@ -493,7 +504,7 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
notifier,
anyPhysicalVersionTag,
)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
mockSender := &MockHealthcheckAttemptSender{}
mockSender.On("SendNotification", mock.Anything, mock.Anything).Return()
@@ -507,7 +518,12 @@ func Test_CheckDatabaseHealthUseCase(t *testing.T) {
useCase := newTestUseCase(mockSender, mockDatabaseService)
- err := useCase.Execute(time.Now().UTC(), newTestHealthcheckConfig(database.ID))
+ err := useCase.Execute(
+ t.Context(),
+ logger.GetLogger(),
+ time.Now().UTC(),
+ newTestHealthcheckConfig(database.ID),
+ )
assert.NoError(t, err)
attempts, err := useCase.healthcheckAttemptRepository.FindByDatabaseIDWithLimit(
diff --git a/backend/internal/features/healthcheck/attempt/controller.go b/backend/internal/features/healthcheck/attempt/controller.go
index 742a5a9c..fb5a3d2a 100644
--- a/backend/internal/features/healthcheck/attempt/controller.go
+++ b/backend/internal/features/healthcheck/attempt/controller.go
@@ -57,6 +57,7 @@ func (c *HealthcheckAttemptController) GetAttemptsByDatabase(ctx *gin.Context) {
}
attempts, err := c.healthcheckAttemptService.GetAttemptsByDatabase(
+ ctx.Request.Context(),
*user,
databaseID,
afterDate,
diff --git a/backend/internal/features/healthcheck/attempt/controller_test.go b/backend/internal/features/healthcheck/attempt/controller_test.go
index acf85f9f..de146885 100644
--- a/backend/internal/features/healthcheck/attempt/controller_test.go
+++ b/backend/internal/features/healthcheck/attempt/controller_test.go
@@ -84,8 +84,8 @@ func Test_GetAttemptsByDatabase_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
@@ -103,12 +103,12 @@ func Test_GetAttemptsByDatabase_PermissionsEnforced(t *testing.T) {
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -118,7 +118,7 @@ func Test_GetAttemptsByDatabase_PermissionsEnforced(t *testing.T) {
)
testUserToken = member.Token
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUserToken = nonMember.Token
}
@@ -146,16 +146,16 @@ func Test_GetAttemptsByDatabase_PermissionsEnforced(t *testing.T) {
}
// Cleanup
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
func Test_GetAttemptsByDatabase_FiltersByAfterDate(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
@@ -187,14 +187,14 @@ func Test_GetAttemptsByDatabase_FiltersByAfterDate(t *testing.T) {
}
// Cleanup
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_GetAttemptsByDatabase_ReturnsEmptyListForNewDatabase(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
@@ -211,8 +211,8 @@ func Test_GetAttemptsByDatabase_ReturnsEmptyListForNewDatabase(t *testing.T) {
assert.Equal(t, 0, len(response))
// Cleanup
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func createTestDatabaseViaAPI(
diff --git a/backend/internal/features/healthcheck/attempt/interfaces.go b/backend/internal/features/healthcheck/attempt/interfaces.go
index 4d269f5d..bb42a5ea 100644
--- a/backend/internal/features/healthcheck/attempt/interfaces.go
+++ b/backend/internal/features/healthcheck/attempt/interfaces.go
@@ -1,6 +1,8 @@
package healthcheck_attempt
import (
+ "context"
+
"github.com/google/uuid"
"databasus-backend/internal/features/databases"
@@ -10,6 +12,7 @@ import (
type HealthcheckAttemptSender interface {
SendNotification(
+ ctx context.Context,
notifier *notifiers.Notifier,
notification notifier_models.Notification,
)
@@ -18,7 +21,7 @@ type HealthcheckAttemptSender interface {
type DatabaseService interface {
GetDatabaseByID(id uuid.UUID) (*databases.Database, error)
- TestDatabaseConnectionDirect(database *databases.Database) error
+ TestDatabaseConnectionDirect(ctx context.Context, database *databases.Database) error
SetHealthStatus(
databaseID uuid.UUID,
diff --git a/backend/internal/features/healthcheck/attempt/mocks.go b/backend/internal/features/healthcheck/attempt/mocks.go
index a96501e8..b2e0dc7c 100644
--- a/backend/internal/features/healthcheck/attempt/mocks.go
+++ b/backend/internal/features/healthcheck/attempt/mocks.go
@@ -1,6 +1,8 @@
package healthcheck_attempt
import (
+ "context"
+
"github.com/google/uuid"
"github.com/stretchr/testify/mock"
@@ -14,6 +16,7 @@ type MockHealthcheckAttemptSender struct {
}
func (m *MockHealthcheckAttemptSender) SendNotification(
+ _ context.Context,
notifier *notifiers.Notifier,
notification notifier_models.Notification,
) {
@@ -25,6 +28,7 @@ type MockDatabaseService struct {
}
func (m *MockDatabaseService) TestDatabaseConnectionDirect(
+ ctx context.Context,
database *databases.Database,
) error {
return m.Called(database).Error(0)
diff --git a/backend/internal/features/healthcheck/attempt/service.go b/backend/internal/features/healthcheck/attempt/service.go
index 18ad4d36..1b378ec2 100644
--- a/backend/internal/features/healthcheck/attempt/service.go
+++ b/backend/internal/features/healthcheck/attempt/service.go
@@ -1,6 +1,7 @@
package healthcheck_attempt
import (
+ "context"
"errors"
"time"
@@ -18,6 +19,7 @@ type HealthcheckAttemptService struct {
}
func (s *HealthcheckAttemptService) GetAttemptsByDatabase(
+ ctx context.Context,
user users_models.User,
databaseID uuid.UUID,
afterDate time.Time,
@@ -31,7 +33,7 @@ func (s *HealthcheckAttemptService) GetAttemptsByDatabase(
return nil, errors.New("cannot access healthcheck attempts for databases without workspace")
}
- canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(*database.WorkspaceID, &user)
+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, *database.WorkspaceID, &user)
if err != nil {
return nil, err
}
diff --git a/backend/internal/features/healthcheck/config/controller.go b/backend/internal/features/healthcheck/config/controller.go
index 1456c2b9..b35a2646 100644
--- a/backend/internal/features/healthcheck/config/controller.go
+++ b/backend/internal/features/healthcheck/config/controller.go
@@ -43,7 +43,7 @@ func (c *HealthcheckConfigController) SaveHealthcheckConfig(ctx *gin.Context) {
return
}
- if err := c.healthcheckConfigService.Save(*user, configDTO); err != nil {
+ if err := c.healthcheckConfigService.Save(ctx.Request.Context(), *user, configDTO); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -77,7 +77,7 @@ func (c *HealthcheckConfigController) GetHealthcheckConfig(ctx *gin.Context) {
return
}
- config, err := c.healthcheckConfigService.GetByDatabaseID(*user, databaseID)
+ config, err := c.healthcheckConfigService.GetByDatabaseID(ctx.Request.Context(), *user, databaseID)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
diff --git a/backend/internal/features/healthcheck/config/controller_test.go b/backend/internal/features/healthcheck/config/controller_test.go
index 41af84bb..10dc7875 100644
--- a/backend/internal/features/healthcheck/config/controller_test.go
+++ b/backend/internal/features/healthcheck/config/controller_test.go
@@ -75,19 +75,19 @@ func Test_SaveHealthcheckConfig_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -132,20 +132,20 @@ func Test_SaveHealthcheckConfig_PermissionsEnforced(t *testing.T) {
}
// Cleanup
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
func Test_SaveHealthcheckConfig_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := HealthcheckConfigDTO{
DatabaseID: database.ID,
@@ -168,8 +168,8 @@ func Test_SaveHealthcheckConfig_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t
assert.Contains(t, string(testResp.Body), "insufficient permissions")
// Cleanup
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_GetHealthcheckConfig_PermissionsEnforced(t *testing.T) {
@@ -227,19 +227,19 @@ func Test_GetHealthcheckConfig_PermissionsEnforced(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -249,7 +249,7 @@ func Test_GetHealthcheckConfig_PermissionsEnforced(t *testing.T) {
)
testUserToken = member.Token
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUserToken = nonMember.Token
}
@@ -278,16 +278,16 @@ func Test_GetHealthcheckConfig_PermissionsEnforced(t *testing.T) {
}
// Cleanup
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
func Test_GetHealthcheckConfig_ReturnsDefaultConfigForNewDatabase(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
@@ -309,8 +309,8 @@ func Test_GetHealthcheckConfig_ReturnsDefaultConfigForNewDatabase(t *testing.T)
assert.Equal(t, 7, response.StoreAttemptsDays)
// Cleanup
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func createTestDatabaseViaAPI(
diff --git a/backend/internal/features/healthcheck/config/service.go b/backend/internal/features/healthcheck/config/service.go
index 4b57ab3c..da2c67bb 100644
--- a/backend/internal/features/healthcheck/config/service.go
+++ b/backend/internal/features/healthcheck/config/service.go
@@ -1,6 +1,7 @@
package healthcheck_config
import (
+ "context"
"errors"
"fmt"
"log/slog"
@@ -8,6 +9,7 @@ import (
"github.com/google/uuid"
"databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
"databasus-backend/internal/features/databases"
users_models "databasus-backend/internal/features/users/models"
workspaces_services "databasus-backend/internal/features/workspaces/services"
@@ -22,15 +24,17 @@ type HealthcheckConfigService struct {
}
func (s *HealthcheckConfigService) OnDatabaseCreated(
+ ctx context.Context,
databaseID uuid.UUID,
) {
err := s.initializeDefaultConfig(databaseID)
if err != nil {
- s.logger.Error("failed to initialize default healthcheck config", "error", err)
+ s.logger.ErrorContext(ctx, "failed to initialize default healthcheck config", "error", err)
}
}
func (s *HealthcheckConfigService) Save(
+ ctx context.Context,
user users_models.User,
configDTO HealthcheckConfigDTO,
) error {
@@ -43,7 +47,7 @@ func (s *HealthcheckConfigService) Save(
return errors.New("cannot modify healthcheck config for databases without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, &user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, &user)
if err != nil {
return err
}
@@ -52,7 +56,6 @@ func (s *HealthcheckConfigService) Save(
}
healthcheckConfig := configDTO.ToDTO()
- s.logger.Info("healthcheck config", "config", healthcheckConfig)
healthcheckConfig.DatabaseID = database.ID
@@ -74,16 +77,17 @@ func (s *HealthcheckConfigService) Save(
}
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Healthcheck config updated for database '%s'", database.Name),
- &user.ID,
- database.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Healthcheck config updated for database '%s'", database.Name),
+ UserID: &user.ID,
+ WorkspaceID: database.WorkspaceID,
+ })
return nil
}
func (s *HealthcheckConfigService) GetByDatabaseID(
+ ctx context.Context,
user users_models.User,
databaseID uuid.UUID,
) (*HealthcheckConfig, error) {
@@ -96,7 +100,7 @@ func (s *HealthcheckConfigService) GetByDatabaseID(
return nil, errors.New("cannot access healthcheck config for databases without workspace")
}
- canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(*database.WorkspaceID, &user)
+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, *database.WorkspaceID, &user)
if err != nil {
return nil, err
}
diff --git a/backend/internal/features/notifiers/controller.go b/backend/internal/features/notifiers/controller.go
index ef62a9b6..0c17c642 100644
--- a/backend/internal/features/notifiers/controller.go
+++ b/backend/internal/features/notifiers/controller.go
@@ -57,7 +57,7 @@ func (c *NotifierController) SaveNotifier(ctx *gin.Context) {
return
}
- if err := c.notifierService.SaveNotifier(user, request.WorkspaceID, &request); err != nil {
+ if err := c.notifierService.SaveNotifier(ctx.Request.Context(), user, request.WorkspaceID, &request); err != nil {
if errors.Is(err, ErrInsufficientPermissionsToManageNotifier) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
@@ -94,7 +94,7 @@ func (c *NotifierController) GetNotifier(ctx *gin.Context) {
return
}
- notifier, err := c.notifierService.GetNotifier(user, id)
+ notifier, err := c.notifierService.GetNotifier(ctx.Request.Context(), user, id)
if err != nil {
if errors.Is(err, ErrInsufficientPermissionsToViewNotifier) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -138,7 +138,7 @@ func (c *NotifierController) GetNotifiers(ctx *gin.Context) {
return
}
- notifiers, err := c.notifierService.GetNotifiers(user, workspaceID)
+ notifiers, err := c.notifierService.GetNotifiers(ctx.Request.Context(), user, workspaceID)
if err != nil {
if errors.Is(err, ErrInsufficientPermissionsToViewNotifiers) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -176,7 +176,7 @@ func (c *NotifierController) DeleteNotifier(ctx *gin.Context) {
return
}
- if err := c.notifierService.DeleteNotifier(user, id); err != nil {
+ if err := c.notifierService.DeleteNotifier(ctx.Request.Context(), user, id); err != nil {
if errors.Is(err, ErrInsufficientPermissionsToManageNotifier) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
@@ -213,7 +213,7 @@ func (c *NotifierController) SendTestNotification(ctx *gin.Context) {
return
}
- if err := c.notifierService.SendTestNotification(user, id); err != nil {
+ if err := c.notifierService.SendTestNotification(ctx.Request.Context(), user, id); err != nil {
if errors.Is(err, ErrInsufficientPermissionsToTestNotifier) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
@@ -264,6 +264,7 @@ func (c *NotifierController) TransferNotifierToWorkspace(ctx *gin.Context) {
}
if err := c.notifierService.TransferNotifierToWorkspace(
+ ctx.Request.Context(),
user,
id,
request.TargetWorkspaceID,
@@ -312,7 +313,7 @@ func (c *NotifierController) SendTestNotificationDirect(ctx *gin.Context) {
return
}
- canView, _, err := c.workspaceService.CanUserAccessWorkspace(request.WorkspaceID, user)
+ canView, _, err := c.workspaceService.CanUserAccessWorkspace(ctx.Request.Context(), request.WorkspaceID, user)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -325,7 +326,7 @@ func (c *NotifierController) SendTestNotificationDirect(ctx *gin.Context) {
return
}
- if err := c.notifierService.SendTestNotificationToNotifier(&request); err != nil {
+ if err := c.notifierService.SendTestNotificationToNotifier(ctx.Request.Context(), &request); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
diff --git a/backend/internal/features/notifiers/controller_test.go b/backend/internal/features/notifiers/controller_test.go
index bf396fc3..5697dc51 100644
--- a/backend/internal/features/notifiers/controller_test.go
+++ b/backend/internal/features/notifiers/controller_test.go
@@ -27,9 +27,9 @@ import (
)
func Test_SaveNewNotifier_NotifierReturnedViaGet(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
notifier := createNewNotifier(workspace.ID)
@@ -74,13 +74,13 @@ func Test_SaveNewNotifier_NotifierReturnedViaGet(t *testing.T) {
assert.Len(t, notifiers, 1)
deleteNotifier(t, router, savedNotifier.ID, workspace.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_UpdateExistingNotifier_UpdatedNotifierReturnedViaGet(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
notifier := createNewNotifier(workspace.ID)
@@ -113,13 +113,13 @@ func Test_UpdateExistingNotifier_UpdatedNotifierReturnedViaGet(t *testing.T) {
assert.Equal(t, savedNotifier.ID, updatedNotifier.ID)
deleteNotifier(t, router, updatedNotifier.ID, workspace.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_DeleteNotifier_NotifierNotReturnedViaGet(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
notifier := createNewNotifier(workspace.ID)
@@ -151,13 +151,13 @@ func Test_DeleteNotifier_NotifierNotReturnedViaGet(t *testing.T) {
)
assert.Contains(t, string(response.Body), "error")
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_SendTestNotificationDirect_NotificationSent(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
GetWebhookStub().ResetCalls()
notifier := createWebhookNotifier(workspace.ID)
@@ -169,13 +169,13 @@ func Test_SendTestNotificationDirect_NotificationSent(t *testing.T) {
assert.Contains(t, string(response.Body), "successful")
assert.Greater(t, GetWebhookStub().CallCount(), 0)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_SendTestNotificationExisting_NotificationSent(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
GetWebhookStub().ResetCalls()
notifier := createWebhookNotifier(workspace.ID)
@@ -204,7 +204,7 @@ func Test_SendTestNotificationExisting_NotificationSent(t *testing.T) {
assert.Greater(t, GetWebhookStub().CallCount(), 0)
deleteNotifier(t, router, savedNotifier.ID, workspace.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_WorkspaceRolePermissions_Notifiers(t *testing.T) {
@@ -263,17 +263,17 @@ func Test_WorkspaceRolePermissions_Notifiers(t *testing.T) {
router := createRouter()
GetNotifierService().SetNotifierDatabaseCounter(&mockNotifierDatabaseCounter{})
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
testUser,
@@ -359,16 +359,16 @@ func Test_WorkspaceRolePermissions_Notifiers(t *testing.T) {
if !tt.canDelete {
deleteNotifier(t, router, ownerNotifier.ID, workspace.ID, owner.Token)
}
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
func Test_UserNotInWorkspace_CannotAccessNotifiers(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- outsider := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ outsider := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
notifier := createNewNotifier(workspace.ID)
@@ -417,15 +417,15 @@ func Test_UserNotInWorkspace_CannotAccessNotifiers(t *testing.T) {
)
deleteNotifier(t, router, savedNotifier.ID, workspace.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_CrossWorkspaceSecurity_CannotAccessNotifierFromAnotherWorkspace(t *testing.T) {
- owner1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- owner2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ owner2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", owner1, router)
- workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", owner2, router)
+ workspace1 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 1", owner1, router)
+ workspace2 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 2", owner2, router)
notifier1 := createNewNotifier(workspace1.ID)
@@ -451,8 +451,8 @@ func Test_CrossWorkspaceSecurity_CannotAccessNotifierFromAnotherWorkspace(t *tes
assert.Contains(t, string(response.Body), "insufficient permissions")
deleteNotifier(t, router, savedNotifier.ID, workspace1.ID, owner1.Token)
- workspaces_testing.RemoveTestWorkspace(workspace1, router)
- workspaces_testing.RemoveTestWorkspace(workspace2, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace1, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace2, router)
}
func Test_NotifierSensitiveDataLifecycle_AllTypes(t *testing.T) {
@@ -841,9 +841,9 @@ func Test_NotifierSensitiveDataLifecycle_AllTypes(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
// Phase 1: Create notifier with sensitive data
initialNotifier := tc.createNotifier(workspace.ID)
@@ -890,7 +890,7 @@ func Test_NotifierSensitiveDataLifecycle_AllTypes(t *testing.T) {
// Phase 4: Retrieve directly from repository to verify sensitive data preservation
repository := &NotifierRepository{}
- notifierFromDB, err := repository.FindByID(createdNotifier.ID)
+ notifierFromDB, err := repository.FindByID(t.Context(), createdNotifier.ID)
assert.NoError(t, err)
// Verify original sensitive data is still present in DB
@@ -912,7 +912,7 @@ func Test_NotifierSensitiveDataLifecycle_AllTypes(t *testing.T) {
tc.verifyHiddenData(t, &finalRetrieved)
deleteNotifier(t, router, createdNotifier.ID, workspace.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
@@ -1163,9 +1163,9 @@ func Test_CreateNotifier_AllSensitiveFieldsEncryptedInDB(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
// Create notifier via API (plaintext credentials)
var createdNotifier Notifier
@@ -1181,7 +1181,7 @@ func Test_CreateNotifier_AllSensitiveFieldsEncryptedInDB(t *testing.T) {
// Read from DB directly (bypass service layer)
repository := &NotifierRepository{}
- notifierFromDB, err := repository.FindByID(createdNotifier.ID)
+ notifierFromDB, err := repository.FindByID(t.Context(), createdNotifier.ID)
assert.NoError(t, err)
// Verify encryption
@@ -1189,7 +1189,7 @@ func Test_CreateNotifier_AllSensitiveFieldsEncryptedInDB(t *testing.T) {
// Cleanup
deleteNotifier(t, router, createdNotifier.ID, workspace.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
@@ -1250,15 +1250,15 @@ func Test_TransferNotifier_PermissionsEnforced(t *testing.T) {
router := createRouter()
GetNotifierService().SetNotifierDatabaseCounter(&mockNotifierDatabaseCounter{})
- sourceOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- targetOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ targetOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace(
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Source Workspace",
sourceOwner,
router,
)
- targetWorkspace := workspaces_testing.CreateTestWorkspace(
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Target Workspace",
targetOwner,
router,
@@ -1278,10 +1278,10 @@ func Test_TransferNotifier_PermissionsEnforced(t *testing.T) {
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.sourceRole != nil {
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
sourceWorkspace,
testUser,
@@ -1332,8 +1332,8 @@ func Test_TransferNotifier_PermissionsEnforced(t *testing.T) {
deleteNotifier(t, router, savedNotifier.ID, sourceWorkspace.ID, sourceOwner.Token)
}
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
})
}
}
@@ -1342,11 +1342,11 @@ func Test_TransferNotifierNotManagableWorkspace_TransferFailed(t *testing.T) {
router := createRouter()
GetNotifierService().SetNotifierDatabaseCounter(&mockNotifierDatabaseCounter{})
- userA := users_testing.CreateTestUser(users_enums.UserRoleMember)
- userB := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ userA := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ userB := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", userA, router)
- workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", userB, router)
+ workspace1 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 1", userA, router)
+ workspace2 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 2", userB, router)
notifier := createNewNotifier(workspace1.ID)
var savedNotifier Notifier
@@ -1380,8 +1380,8 @@ func Test_TransferNotifierNotManagableWorkspace_TransferFailed(t *testing.T) {
)
deleteNotifier(t, router, savedNotifier.ID, workspace1.ID, userA.Token)
- workspaces_testing.RemoveTestWorkspace(workspace1, router)
- workspaces_testing.RemoveTestWorkspace(workspace2, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace1, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace2, router)
}
type mockNotifierDatabaseCounter struct{}
diff --git a/backend/internal/features/notifiers/models/discord/model.go b/backend/internal/features/notifiers/models/discord/model.go
index ed6dd161..90ae6879 100644
--- a/backend/internal/features/notifiers/models/discord/model.go
+++ b/backend/internal/features/notifiers/models/discord/model.go
@@ -67,7 +67,7 @@ func (d *DiscordNotifier) Send(
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
- return fmt.Errorf("failed to send Discord message: %w", err)
+ return fmt.Errorf("failed to send Discord message: %w", notifier_models.ErrorWithoutWebhookURLCredentials(err))
}
defer func() {
_ = resp.Body.Close()
diff --git a/backend/internal/features/notifiers/models/mattermost/model.go b/backend/internal/features/notifiers/models/mattermost/model.go
index 08f08c2a..823c2567 100644
--- a/backend/internal/features/notifiers/models/mattermost/model.go
+++ b/backend/internal/features/notifiers/models/mattermost/model.go
@@ -316,12 +316,7 @@ func (r mattermostRequest) withoutSecretURL(err error) error {
return err
}
- var urlError *url.Error
- if errors.As(err, &urlError) {
- return urlError.Err
- }
-
- return err
+ return notifier_models.ErrorWithoutWebhookURLCredentials(err)
}
func isHTTPURL(candidate string) bool {
diff --git a/backend/internal/features/notifiers/models/slack/model.go b/backend/internal/features/notifiers/models/slack/model.go
index e8375655..6f9bbc0c 100644
--- a/backend/internal/features/notifiers/models/slack/model.go
+++ b/backend/internal/features/notifiers/models/slack/model.go
@@ -108,7 +108,7 @@ func (s *SlackNotifier) Send(
defer func() {
if err := resp.Body.Close(); err != nil {
- logger.Warn("Failed to close response body", "error", err)
+ logger.Warn("failed to close response body", "error", err)
}
}()
@@ -124,7 +124,7 @@ func (s *SlackNotifier) Send(
return fmt.Errorf("rate-limited after %d attempts, giving up", attempts)
}
- logger.Warn("Slack rate-limited, retrying", "after", retryAfter, "attempt", attempts)
+ logger.Warn("slack rate-limited, retrying", "after", retryAfter, "attempt", attempts)
time.Sleep(retryAfter)
backoff = time.Duration(float64(backoff) * backoffMultiplier)
@@ -146,7 +146,7 @@ func (s *SlackNotifier) Send(
return fmt.Errorf("slack API error: %s", respBody.Error)
}
- logger.Info("Slack message sent", "channel", s.TargetChatID, "attempts", attempts)
+ logger.Info("slack message sent", "channel", s.TargetChatID, "attempts", attempts)
return nil
}
diff --git a/backend/internal/features/notifiers/models/teams/model.go b/backend/internal/features/notifiers/models/teams/model.go
index 656b2db0..45b435ed 100644
--- a/backend/internal/features/notifiers/models/teams/model.go
+++ b/backend/internal/features/notifiers/models/teams/model.go
@@ -98,7 +98,7 @@ func (n *TeamsNotifier) Send(
resp, err := http.DefaultClient.Do(req)
if err != nil {
- return err
+ return notifier_models.ErrorWithoutWebhookURLCredentials(err)
}
defer func() {
diff --git a/backend/internal/features/notifiers/models/telegram/model.go b/backend/internal/features/notifiers/models/telegram/model.go
index 959e9f36..6ee86d1b 100644
--- a/backend/internal/features/notifiers/models/telegram/model.go
+++ b/backend/internal/features/notifiers/models/telegram/model.go
@@ -97,7 +97,7 @@ func (t *TelegramNotifier) Send(
resp, err := client.Do(req)
if err != nil {
- return fmt.Errorf("failed to send telegram message: %w", err)
+ return fmt.Errorf("failed to send telegram message: %w", notifier_models.ErrorWithoutWebhookURLCredentials(err))
}
defer func() {
_ = resp.Body.Close()
diff --git a/backend/internal/features/notifiers/models/url_credentials.go b/backend/internal/features/notifiers/models/url_credentials.go
new file mode 100644
index 00000000..7858dabb
--- /dev/null
+++ b/backend/internal/features/notifiers/models/url_credentials.go
@@ -0,0 +1,74 @@
+package notifier_models
+
+import (
+ "errors"
+ "net/url"
+ "strings"
+)
+
+// Percent-encoding would mangle a literal "***" here; this marker survives url.String().
+const redactedURLSegment = "redacted"
+
+// For every webhook notifier we support, the URL itself is the credential, and it sits in the path
+// where the logger's userinfo-based redaction cannot see it. Callers that know the URL is not a
+// secret - Mattermost in bot mode - keep the path by not calling this.
+func StripWebhookURLCredentials(rawURL string) string {
+ parsed, err := url.Parse(rawURL)
+ if err != nil {
+ return redactedURLSegment
+ }
+
+ if parsed.User != nil {
+ parsed.User = url.User(redactedURLSegment)
+ }
+
+ parsed.RawQuery = ""
+ parsed.Fragment = ""
+ parsed.Path = redactPathSecrets(parsed.Path)
+
+ return parsed.String()
+}
+
+// The transport error is what carries the credential off the machine: it is persisted to
+// LastSendError, logged, and returned verbatim by the test-send endpoints. Rewriting the URL rather
+// than unwrapping the *url.Error keeps the operation and host, so a failure stays diagnosable.
+func ErrorWithoutWebhookURLCredentials(err error) error {
+ var urlError *url.Error
+ if !errors.As(err, &urlError) {
+ return err
+ }
+
+ return &url.Error{
+ Op: urlError.Op,
+ URL: StripWebhookURLCredentials(urlError.URL),
+ Err: urlError.Err,
+ }
+}
+
+// Which segment holds the secret varies per provider. The first one usually names the endpoint and
+// is what makes a failure diagnosable, so it survives.
+func redactPathSecrets(path string) string {
+ trimmed := strings.Trim(path, "/")
+ if trimmed == "" {
+ return path
+ }
+
+ segments := strings.Split(trimmed, "/")
+ for i := 1; i < len(segments); i++ {
+ segments[i] = redactedURLSegment
+ }
+
+ segments[0] = redactFusedBotTokenSegment(segments[0])
+
+ return "/" + strings.Join(segments, "/")
+}
+
+// Telegram is the one provider whose secret cannot be handled positionally: it fuses the "bot"
+// prefix and the token into the endpoint segment itself.
+func redactFusedBotTokenSegment(segment string) string {
+ if !strings.HasPrefix(segment, "bot") || !strings.Contains(segment, ":") {
+ return segment
+ }
+
+ return "bot" + redactedURLSegment
+}
diff --git a/backend/internal/features/notifiers/models/url_credentials_test.go b/backend/internal/features/notifiers/models/url_credentials_test.go
new file mode 100644
index 00000000..545d7ec3
--- /dev/null
+++ b/backend/internal/features/notifiers/models/url_credentials_test.go
@@ -0,0 +1,100 @@
+package notifier_models
+
+import (
+ "errors"
+ "net/url"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func Test_StripWebhookURLCredentials_WithTokenBearingUrls_RemovesCredential(t *testing.T) {
+ cases := []struct {
+ name string
+ rawURL string
+ secret string
+ sanitized string
+ }{
+ {
+ name: "telegram fuses the bot prefix and the token into one segment",
+ rawURL: "https://api.telegram.org/bot123456:AAH-REALTOKEN/sendMessage",
+ secret: "AAH-REALTOKEN",
+ sanitized: "https://api.telegram.org/botredacted/redacted",
+ },
+ {
+ name: "discord carries the token as a trailing path segment",
+ rawURL: "https://discord.com/api/webhooks/999/SECRETWEBHOOKTOKEN",
+ secret: "SECRETWEBHOOKTOKEN",
+ sanitized: "https://discord.com/api/redacted/redacted/redacted",
+ },
+ {
+ name: "mattermost incoming webhook",
+ rawURL: "https://chat.example.com/hooks/xxxSECRETHOOKxxx",
+ secret: "xxxSECRETHOOKxxx",
+ sanitized: "https://chat.example.com/hooks/redacted",
+ },
+ {
+ name: "query string can carry a token",
+ rawURL: "https://hooks.example.com/notify?token=SECRETQUERYTOKEN",
+ secret: "SECRETQUERYTOKEN",
+ sanitized: "https://hooks.example.com/notify",
+ },
+ {
+ name: "userinfo credentials",
+ rawURL: "https://user:[email protected]/notify",
+ secret: "SECRETPASSWORD",
+ sanitized: "https://[email protected]/notify",
+ },
+ }
+
+ for _, testCase := range cases {
+ t.Run(testCase.name, func(t *testing.T) {
+ sanitizedURL := StripWebhookURLCredentials(testCase.rawURL)
+
+ assert.NotContains(t, sanitizedURL, testCase.secret)
+ assert.Equal(t, testCase.sanitized, sanitizedURL)
+ })
+ }
+}
+
+func Test_StripWebhookURLCredentials_WithUnparseableUrl_ReturnsRedactedMarker(t *testing.T) {
+ assert.Equal(t, redactedURLSegment, StripWebhookURLCredentials("://not a url\x7f"))
+}
+
+func Test_StripWebhookURLCredentials_KeepsHostReadable(t *testing.T) {
+ assert.Contains(t, StripWebhookURLCredentials("https://api.telegram.org/bot1:X/sendMessage"), "api.telegram.org")
+}
+
+func Test_ErrorWithoutWebhookURLCredentials_WithTelegramTransportError_ErrorContainsNoBotToken(t *testing.T) {
+ transportError := &url.Error{
+ Op: "Post",
+ URL: "https://api.telegram.org/bot123456:AAH-REALBOTTOKEN/sendMessage",
+ Err: errors.New("dial tcp: i/o timeout"),
+ }
+
+ sanitizedError := ErrorWithoutWebhookURLCredentials(transportError)
+
+ assert.NotContains(t, sanitizedError.Error(), "AAH-REALBOTTOKEN")
+ assert.Contains(t, sanitizedError.Error(), "api.telegram.org")
+ assert.Contains(t, sanitizedError.Error(), "i/o timeout")
+}
+
+func Test_ErrorWithoutWebhookURLCredentials_WithWebhookTransportError_ErrorContainsNoUrlCredentials(t *testing.T) {
+ transportError := &url.Error{
+ Op: "Post",
+ URL: "https://discord.com/api/webhooks/999/SECRETWEBHOOKTOKEN",
+ Err: errors.New("connection refused"),
+ }
+
+ sanitizedError := ErrorWithoutWebhookURLCredentials(transportError)
+
+ assert.NotContains(t, sanitizedError.Error(), "SECRETWEBHOOKTOKEN")
+ assert.Contains(t, sanitizedError.Error(), "discord.com")
+ assert.Contains(t, sanitizedError.Error(), "connection refused")
+}
+
+func Test_ErrorWithoutWebhookURLCredentials_WithNonTransportError_ReturnsItUnchanged(t *testing.T) {
+ plainError := errors.New("failed to decrypt bot token")
+
+ assert.Equal(t, plainError, ErrorWithoutWebhookURLCredentials(plainError))
+}
diff --git a/backend/internal/features/notifiers/models/webhook/model.go b/backend/internal/features/notifiers/models/webhook/model.go
index d0e89ab7..117b8de0 100644
--- a/backend/internal/features/notifiers/models/webhook/model.go
+++ b/backend/internal/features/notifiers/models/webhook/model.go
@@ -192,7 +192,7 @@ func (t *WebhookNotifier) sendGET(webhookURL, heading, message string, logger *s
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
- return fmt.Errorf("failed to send GET webhook: %w", err)
+ return fmt.Errorf("failed to send GET webhook: %w", notifier_models.ErrorWithoutWebhookURLCredentials(err))
}
defer func() {
@@ -239,7 +239,7 @@ func (t *WebhookNotifier) sendPOST(webhookURL, heading, message string, logger *
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
- return fmt.Errorf("failed to send POST webhook: %w", err)
+ return fmt.Errorf("failed to send POST webhook: %w", notifier_models.ErrorWithoutWebhookURLCredentials(err))
}
defer func() {
diff --git a/backend/internal/features/notifiers/repository.go b/backend/internal/features/notifiers/repository.go
index 26c6b9cf..3994461b 100644
--- a/backend/internal/features/notifiers/repository.go
+++ b/backend/internal/features/notifiers/repository.go
@@ -1,6 +1,8 @@
package notifiers
import (
+ "context"
+
"github.com/google/uuid"
"gorm.io/gorm"
@@ -135,11 +137,12 @@ func (r *NotifierRepository) Save(notifier *Notifier) (*Notifier, error) {
return notifier, nil
}
-func (r *NotifierRepository) FindByID(id uuid.UUID) (*Notifier, error) {
+func (r *NotifierRepository) FindByID(ctx context.Context, id uuid.UUID) (*Notifier, error) {
var notifier Notifier
if err := storage.
GetDb().
+ WithContext(ctx).
Preload("TelegramNotifier").
Preload("EmailNotifier").
Preload("WebhookNotifier").
diff --git a/backend/internal/features/notifiers/service.go b/backend/internal/features/notifiers/service.go
index 0ac6c153..c19b771c 100644
--- a/backend/internal/features/notifiers/service.go
+++ b/backend/internal/features/notifiers/service.go
@@ -1,12 +1,14 @@
package notifiers
import (
+ "context"
"fmt"
"log/slog"
"github.com/google/uuid"
audit_logs "databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
notifier_models "databasus-backend/internal/features/notifiers/models"
users_models "databasus-backend/internal/features/users/models"
workspaces_services "databasus-backend/internal/features/workspaces/services"
@@ -29,11 +31,12 @@ func (s *NotifierService) SetNotifierDatabaseCounter(
}
func (s *NotifierService) SaveNotifier(
+ ctx context.Context,
user *users_models.User,
workspaceID uuid.UUID,
notifier *Notifier,
) error {
- canManage, err := s.workspaceService.CanUserManageDBs(workspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, workspaceID, user)
if err != nil {
return err
}
@@ -44,7 +47,7 @@ func (s *NotifierService) SaveNotifier(
isUpdate := notifier.ID != uuid.Nil
if isUpdate {
- existingNotifier, err := s.notifierRepository.FindByID(notifier.ID)
+ existingNotifier, err := s.notifierRepository.FindByID(ctx, notifier.ID)
if err != nil {
return err
}
@@ -71,21 +74,21 @@ func (s *NotifierService) SaveNotifier(
}
if oldName != existingNotifier.Name {
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf(
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf(
"Notifier updated and renamed from '%s' to '%s'",
oldName,
existingNotifier.Name,
),
- &user.ID,
- &workspaceID,
- )
+ UserID: &user.ID,
+ WorkspaceID: &workspaceID,
+ })
} else {
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Notifier updated: %s", existingNotifier.Name),
- &user.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Notifier updated: %s", existingNotifier.Name),
+ UserID: &user.ID,
+ WorkspaceID: &workspaceID,
+ })
}
} else {
notifier.WorkspaceID = workspaceID
@@ -103,26 +106,27 @@ func (s *NotifierService) SaveNotifier(
return err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Notifier created: %s", notifier.Name),
- &user.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Notifier created: %s", notifier.Name),
+ UserID: &user.ID,
+ WorkspaceID: &workspaceID,
+ })
}
return nil
}
func (s *NotifierService) DeleteNotifier(
+ ctx context.Context,
user *users_models.User,
notifierID uuid.UUID,
) error {
- notifier, err := s.notifierRepository.FindByID(notifierID)
+ notifier, err := s.notifierRepository.FindByID(ctx, notifierID)
if err != nil {
return err
}
- canManage, err := s.workspaceService.CanUserManageDBs(notifier.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, notifier.WorkspaceID, user)
if err != nil {
return err
}
@@ -145,25 +149,26 @@ func (s *NotifierService) DeleteNotifier(
return err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Notifier deleted: %s", notifier.Name),
- &user.ID,
- &notifier.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Notifier deleted: %s", notifier.Name),
+ UserID: &user.ID,
+ WorkspaceID: &notifier.WorkspaceID,
+ })
return nil
}
func (s *NotifierService) GetNotifier(
+ ctx context.Context,
user *users_models.User,
id uuid.UUID,
) (*Notifier, error) {
- notifier, err := s.notifierRepository.FindByID(id)
+ notifier, err := s.notifierRepository.FindByID(ctx, id)
if err != nil {
return nil, err
}
- canView, _, err := s.workspaceService.CanUserAccessWorkspace(notifier.WorkspaceID, user)
+ canView, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, notifier.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -175,8 +180,8 @@ func (s *NotifierService) GetNotifier(
return notifier, nil
}
-func (s *NotifierService) GetNotifierByID(id uuid.UUID) (*Notifier, error) {
- return s.notifierRepository.FindByID(id)
+func (s *NotifierService) GetNotifierByID(ctx context.Context, id uuid.UUID) (*Notifier, error) {
+ return s.notifierRepository.FindByID(ctx, id)
}
func (s *NotifierService) GetAllNotifiers() ([]*Notifier, error) {
@@ -184,10 +189,11 @@ func (s *NotifierService) GetAllNotifiers() ([]*Notifier, error) {
}
func (s *NotifierService) GetNotifiers(
+ ctx context.Context,
user *users_models.User,
workspaceID uuid.UUID,
) ([]*Notifier, error) {
- canView, _, err := s.workspaceService.CanUserAccessWorkspace(workspaceID, user)
+ canView, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, workspaceID, user)
if err != nil {
return nil, err
}
@@ -208,15 +214,16 @@ func (s *NotifierService) GetNotifiers(
}
func (s *NotifierService) SendTestNotification(
+ ctx context.Context,
user *users_models.User,
notifierID uuid.UUID,
) error {
- notifier, err := s.notifierRepository.FindByID(notifierID)
+ notifier, err := s.notifierRepository.FindByID(ctx, notifierID)
if err != nil {
return err
}
- canView, _, err := s.workspaceService.CanUserAccessWorkspace(notifier.WorkspaceID, user)
+ canView, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, notifier.WorkspaceID, user)
if err != nil {
return err
}
@@ -238,12 +245,13 @@ func (s *NotifierService) SendTestNotification(
}
func (s *NotifierService) SendTestNotificationToNotifier(
+ ctx context.Context,
notifier *Notifier,
) error {
var usingNotifier *Notifier
if notifier.ID != uuid.Nil {
- existingNotifier, err := s.notifierRepository.FindByID(notifier.ID)
+ existingNotifier, err := s.notifierRepository.FindByID(ctx, notifier.ID)
if err != nil {
return err
}
@@ -283,6 +291,7 @@ func newTestNotification() notifier_models.Notification {
}
func (s *NotifierService) SendNotification(
+ ctx context.Context,
notifier *Notifier,
notification notifier_models.Notification,
) {
@@ -291,41 +300,52 @@ func (s *NotifierService) SendNotification(
notification.Message = string(messageRunes[:2000])
}
- notifiedFromDb, err := s.notifierRepository.FindByID(notifier.ID)
+ notifiedFromDb, err := s.notifierRepository.FindByID(ctx, notifier.ID)
if err != nil {
+ s.logger.ErrorContext(ctx, "failed to load notifier before sending", "notifier_id", notifier.ID, "error", err)
+
return
}
err = notifiedFromDb.Send(s.fieldEncryptor, s.logger, notification)
if err != nil {
+ // The notifier keeps working from the user's point of view, so without this a silently
+ // broken destination is only visible by opening the notifier in the UI. Notifier backends
+ // strip the credential from their transport errors before returning them.
+ s.logger.ErrorContext(ctx, "failed to send notification",
+ "notifier_id", notifiedFromDb.ID, "notification_type", notification.Type, "error", err)
+
errMsg := err.Error()
notifiedFromDb.LastSendError = &errMsg
_, err = s.notifierRepository.Save(notifiedFromDb)
if err != nil {
- s.logger.Error("Failed to save notifier", "error", err)
+ s.logger.ErrorContext(ctx, "failed to save notifier", "error", err)
}
+
+ return
}
notifiedFromDb.LastSendError = nil
_, err = s.notifierRepository.Save(notifiedFromDb)
if err != nil {
- s.logger.Error("Failed to save notifier", "error", err)
+ s.logger.ErrorContext(ctx, "failed to save notifier", "error", err)
}
}
func (s *NotifierService) TransferNotifierToWorkspace(
+ ctx context.Context,
user *users_models.User,
notifierID uuid.UUID,
targetWorkspaceID uuid.UUID,
transferingWithDbID *uuid.UUID,
) error {
- existingNotifier, err := s.notifierRepository.FindByID(notifierID)
+ existingNotifier, err := s.notifierRepository.FindByID(ctx, notifierID)
if err != nil {
return err
}
- canManageSource, err := s.workspaceService.CanUserManageDBs(existingNotifier.WorkspaceID, user)
+ canManageSource, err := s.workspaceService.CanUserManageDBs(ctx, existingNotifier.WorkspaceID, user)
if err != nil {
return err
}
@@ -333,7 +353,7 @@ func (s *NotifierService) TransferNotifierToWorkspace(
return ErrInsufficientPermissionsInSourceWorkspace
}
- canManageTarget, err := s.workspaceService.CanUserManageDBs(targetWorkspaceID, user)
+ canManageTarget, err := s.workspaceService.CanUserManageDBs(ctx, targetWorkspaceID, user)
if err != nil {
return err
}
@@ -376,12 +396,16 @@ func (s *NotifierService) TransferNotifierToWorkspace(
return fmt.Errorf("failed to get target workspace: %w", err)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Notifier transferred: %s from workspace '%s' to workspace '%s'",
- existingNotifier.Name, sourceWorkspace.Name, targetWorkspace.Name),
- &user.ID,
- &targetWorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf(
+ "Notifier transferred: %s from workspace '%s' to workspace '%s'",
+ existingNotifier.Name,
+ sourceWorkspace.Name,
+ targetWorkspace.Name,
+ ),
+ UserID: &user.ID,
+ WorkspaceID: &targetWorkspaceID,
+ })
return nil
}
diff --git a/backend/internal/features/restores/controller.go b/backend/internal/features/restores/controller.go
index c4d8dbeb..f5e42c6a 100644
--- a/backend/internal/features/restores/controller.go
+++ b/backend/internal/features/restores/controller.go
@@ -43,7 +43,7 @@ func (c *RestoreController) GetRestores(ctx *gin.Context) {
return
}
- restores, err := c.restoreService.GetRestores(user, backupID)
+ restores, err := c.restoreService.GetRestores(ctx.Request.Context(), user, backupID)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -80,7 +80,7 @@ func (c *RestoreController) RestoreBackup(ctx *gin.Context) {
return
}
- if err := c.restoreService.RestoreBackupWithAuth(user, backupID, requestDTO); err != nil {
+ if err := c.restoreService.RestoreBackupWithAuth(ctx.Request.Context(), user, backupID, requestDTO); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -110,7 +110,7 @@ func (c *RestoreController) CancelRestore(ctx *gin.Context) {
return
}
- if err := c.restoreService.CancelRestore(user, restoreID); err != nil {
+ if err := c.restoreService.CancelRestore(ctx.Request.Context(), user, restoreID); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
diff --git a/backend/internal/features/restores/controller_test.go b/backend/internal/features/restores/controller_test.go
index 8257f51c..2c1f2083 100644
--- a/backend/internal/features/restores/controller_test.go
+++ b/backend/internal/features/restores/controller_test.go
@@ -43,12 +43,12 @@ import (
func Test_GetRestores_WhenUserIsWorkspaceMember_RestoresReturned(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- database, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)
- defer cleanupDatabaseWithBackup(database, backup)
+ database, backup := createTestDatabaseWithBackupForRestore(t.Context(), workspace, owner, router)
+ defer cleanupDatabaseWithBackup(t.Context(), database, backup)
var restores []*restores_core.Restore
test_utils.MakeGetRequestAndUnmarshal(
@@ -67,14 +67,14 @@ func Test_GetRestores_WhenUserIsWorkspaceMember_RestoresReturned(t *testing.T) {
func Test_GetRestores_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- database, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)
- defer cleanupDatabaseWithBackup(database, backup)
+ database, backup := createTestDatabaseWithBackupForRestore(t.Context(), workspace, owner, router)
+ defer cleanupDatabaseWithBackup(t.Context(), database, backup)
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testResp := test_utils.MakeGetRequest(
t,
@@ -89,14 +89,14 @@ func Test_GetRestores_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testing.T
func Test_GetRestores_WhenUserIsGlobalAdmin_RestoresReturned(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- database, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)
- defer cleanupDatabaseWithBackup(database, backup)
+ database, backup := createTestDatabaseWithBackupForRestore(t.Context(), workspace, owner, router)
+ defer cleanupDatabaseWithBackup(t.Context(), database, backup)
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
var restores []*restores_core.Restore
test_utils.MakeGetRequestAndUnmarshal(
@@ -114,12 +114,12 @@ func Test_GetRestores_WhenUserIsGlobalAdmin_RestoresReturned(t *testing.T) {
func Test_RestoreBackup_WhenUserIsWorkspaceMember_RestoreInitiated(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- database, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)
- defer cleanupDatabaseWithBackup(database, backup)
+ database, backup := createTestDatabaseWithBackupForRestore(t.Context(), workspace, owner, router)
+ defer cleanupDatabaseWithBackup(t.Context(), database, backup)
request := restores_core.RestoreBackupRequest{
PostgresqlLogicalDatabase: &postgresql_logical.PostgresqlLogicalDatabase{
@@ -145,14 +145,14 @@ func Test_RestoreBackup_WhenUserIsWorkspaceMember_RestoreInitiated(t *testing.T)
func Test_RestoreBackup_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- database, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)
- defer cleanupDatabaseWithBackup(database, backup)
+ database, backup := createTestDatabaseWithBackupForRestore(t.Context(), workspace, owner, router)
+ defer cleanupDatabaseWithBackup(t.Context(), database, backup)
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := restores_core.RestoreBackupRequest{
PostgresqlLogicalDatabase: &postgresql_logical.PostgresqlLogicalDatabase{
@@ -179,12 +179,12 @@ func Test_RestoreBackup_WhenUserIsNotWorkspaceMember_ReturnsForbidden(t *testing
func Test_RestoreBackup_WithIsExcludeExtensions_FlagPassedCorrectly(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- database, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)
- defer cleanupDatabaseWithBackup(database, backup)
+ database, backup := createTestDatabaseWithBackupForRestore(t.Context(), workspace, owner, router)
+ defer cleanupDatabaseWithBackup(t.Context(), database, backup)
request := restores_core.RestoreBackupRequest{
PostgresqlLogicalDatabase: &postgresql_logical.PostgresqlLogicalDatabase{
@@ -212,12 +212,12 @@ func Test_RestoreBackup_WithIsExcludeExtensions_FlagPassedCorrectly(t *testing.T
func Test_RestoreBackup_AuditLogWritten(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- database, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)
- defer cleanupDatabaseWithBackup(database, backup)
+ database, backup := createTestDatabaseWithBackupForRestore(t.Context(), workspace, owner, router)
+ defer cleanupDatabaseWithBackup(t.Context(), database, backup)
request := restores_core.RestoreBackupRequest{
PostgresqlLogicalDatabase: &postgresql_logical.PostgresqlLogicalDatabase{
@@ -241,7 +241,7 @@ func Test_RestoreBackup_AuditLogWritten(t *testing.T) {
time.Sleep(100 * time.Millisecond)
auditLogService := audit_logs.GetAuditLogService()
- auditLogs, err := auditLogService.GetWorkspaceAuditLogs(
+ auditLogs, err := auditLogService.GetWorkspaceAuditLogs(t.Context(),
workspace.ID,
&audit_logs.GetAuditLogsRequest{
Limit: 100,
@@ -292,9 +292,9 @@ func Test_RestoreBackup_DiskSpaceValidation(t *testing.T) {
t.Run(tc.name, func(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
var database *databases.Database
var backup *backups_core_logical.LogicalBackup
@@ -302,8 +302,8 @@ func Test_RestoreBackup_DiskSpaceValidation(t *testing.T) {
var request restores_core.RestoreBackupRequest
if tc.dbType == databases.DatabaseTypePostgresLogical {
- database, backup = createTestDatabaseWithBackupForRestore(workspace, owner, router)
- defer cleanupDatabaseWithBackup(database, backup)
+ database, backup = createTestDatabaseWithBackupForRestore(t.Context(), workspace, owner, router)
+ defer cleanupDatabaseWithBackup(t.Context(), database, backup)
request = restores_core.RestoreBackupRequest{
PostgresqlLogicalDatabase: &postgresql_logical.PostgresqlLogicalDatabase{
Version: tools.PostgresqlVersion16,
@@ -328,9 +328,9 @@ func Test_RestoreBackup_DiskSpaceValidation(t *testing.T) {
defer func() {
// Cleanup in dependency order: backup -> database -> storage
cleanupBackup(backup)
- databases.RemoveTestDatabase(mysqlDB)
+ databases.RemoveTestDatabase(t.Context(), mysqlDB)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
}()
configService := backups_config_logical.GetBackupConfigService()
@@ -340,7 +340,7 @@ func Test_RestoreBackup_DiskSpaceValidation(t *testing.T) {
config.IsBackupsEnabled = true
config.StorageID = &storage.ID
config.Storage = storage
- _, err = configService.SaveBackupConfig(config)
+ _, err = configService.SaveBackupConfig(t.Context(), config)
assert.NoError(t, err)
backup = createTestBackup(mysqlDB, storage)
@@ -392,9 +392,9 @@ func Test_CancelRestore_InProgressRestore_SuccessfullyCancelled(t *testing.T) {
cache_utils.ClearAllCache()
tasks_cancellation.SetupDependencies()
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := createTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
@@ -416,16 +416,16 @@ func Test_CancelRestore_InProgressRestore_SuccessfullyCancelled(t *testing.T) {
restoreRepo.DeleteByID(restore.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
- storages.RemoveTestStorage(storage.ID)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
notifiers.RemoveTestNotifier(notifier)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
cache_utils.ClearAllCache()
}()
- backups_config_logical.EnableBackupsForTestDatabase(database.ID, storage)
+ backups_config_logical.EnableBackupsForTestDatabase(t.Context(), database.ID, storage)
backup := backups_controllers_logical.CreateTestBackup(database.ID, storage.ID)
mockUsecase := &restoring.MockBlockingRestoreUsecase{
@@ -505,7 +505,7 @@ func Test_CancelRestore_InProgressRestore_SuccessfullyCancelled(t *testing.T) {
assert.Equal(t, restores_core.RestoreStatusCanceled, restore.Status)
auditLogService := audit_logs.GetAuditLogService()
- auditLogs, err := auditLogService.GetWorkspaceAuditLogs(
+ auditLogs, err := auditLogService.GetWorkspaceAuditLogs(t.Context(),
workspace.ID,
&audit_logs.GetAuditLogsRequest{Limit: 100, Offset: 0},
)
@@ -527,12 +527,12 @@ func Test_CancelRestore_InProgressRestore_SuccessfullyCancelled(t *testing.T) {
func Test_RestoreBackup_WithParallelRestoreInProgress_ReturnsError(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- database, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)
- defer cleanupDatabaseWithBackup(database, backup)
+ database, backup := createTestDatabaseWithBackupForRestore(t.Context(), workspace, owner, router)
+ defer cleanupDatabaseWithBackup(t.Context(), database, backup)
// Seeded rather than started for real: a restore dispatched over HTTP runs in a goroutine that
// reaches a terminal status within milliseconds, so the IN_PROGRESS state the guard reacts to
@@ -572,6 +572,7 @@ func createTestRouter() *gin.Engine {
}
func createTestDatabaseWithBackupForRestore(
+ ctx context.Context,
workspace *workspaces_models.Workspace,
owner *users_dto.SignInResponseDTO,
router *gin.Engine,
@@ -588,7 +589,7 @@ func createTestDatabaseWithBackupForRestore(
config.IsBackupsEnabled = true
config.StorageID = &storage.ID
config.Storage = storage
- _, err = configService.SaveBackupConfig(config)
+ _, err = configService.SaveBackupConfig(ctx, config)
if err != nil {
panic(err)
}
@@ -737,29 +738,33 @@ func createTestBackup(
return backup
}
-func cleanupDatabaseWithBackup(database *databases.Database, backup *backups_core_logical.LogicalBackup) {
+func cleanupDatabaseWithBackup(
+ ctx context.Context,
+ database *databases.Database,
+ backup *backups_core_logical.LogicalBackup,
+) {
// Clean up in reverse dependency order
cleanupBackup(backup)
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(ctx, database)
time.Sleep(50 * time.Millisecond)
// Clean up storage last (after database and backup are removed)
configService := backups_config_logical.GetBackupConfigService()
config, err := configService.GetBackupConfigByDbId(database.ID)
if err == nil && config.StorageID != nil {
- storages.RemoveTestStorage(*config.StorageID)
+ storages.RemoveTestStorage(ctx, *config.StorageID)
}
}
func Test_RestoreBackup_WithCpuCountMoreThanOne_RestoreInitiated(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- database, backup := createTestDatabaseWithBackupForRestore(workspace, owner, router)
- defer cleanupDatabaseWithBackup(database, backup)
+ database, backup := createTestDatabaseWithBackupForRestore(t.Context(), workspace, owner, router)
+ defer cleanupDatabaseWithBackup(t.Context(), database, backup)
request := restores_core.RestoreBackupRequest{
PostgresqlLogicalDatabase: &postgresql_logical.PostgresqlLogicalDatabase{
diff --git a/backend/internal/features/restores/restoring/restorer.go b/backend/internal/features/restores/restoring/restorer.go
index 2bec6976..3336a436 100644
--- a/backend/internal/features/restores/restoring/restorer.go
+++ b/backend/internal/features/restores/restoring/restorer.go
@@ -33,7 +33,9 @@ type Restorer struct {
restoreCancelManager *tasks_cancellation.TaskCancelManager
}
-func (r *Restorer) MakeRestore(restoreID uuid.UUID) {
+func (r *Restorer) MakeRestore(ctx context.Context, restoreID uuid.UUID) {
+ logger := r.logger.With("restore_id", restoreID)
+
// Get and delete cached DB credentials atomically
dbCache := r.cacheUtil.GetAndDelete(restoreID.String())
@@ -41,13 +43,7 @@ func (r *Restorer) MakeRestore(restoreID uuid.UUID) {
// Cache miss - fail immediately
restore, err := r.restoreRepository.FindByID(restoreID)
if err != nil {
- r.logger.Error(
- "Failed to get restore by ID after cache miss",
- "restoreId",
- restoreID,
- "error",
- err,
- )
+ logger.ErrorContext(ctx, "failed to get restore by ID after cache miss", "error", err)
return
}
@@ -56,22 +52,22 @@ func (r *Restorer) MakeRestore(restoreID uuid.UUID) {
restore.Status = restores_core.RestoreStatusFailed
if err := r.restoreRepository.Save(restore); err != nil {
- r.logger.Error("Failed to save restore after cache miss", "error", err)
+ logger.ErrorContext(ctx, "failed to save restore after cache miss", "error", err)
}
- r.logger.Error("Restore failed: cache miss", "restoreId", restoreID)
+ logger.ErrorContext(ctx, "restore failed: cache miss")
return
}
restore, err := r.restoreRepository.FindByID(restoreID)
if err != nil {
- r.logger.Error("Failed to get restore by ID", "restoreId", restoreID, "error", err)
+ logger.ErrorContext(ctx, "failed to get restore by ID", "error", err)
return
}
backup, err := r.backupService.GetBackup(restore.BackupID)
if err != nil {
- r.logger.Error("Failed to get backup by ID", "backupId", restore.BackupID, "error", err)
+ logger.ErrorContext(ctx, "failed to get backup by ID", "backup_id", restore.BackupID, "error", err)
return
}
@@ -79,34 +75,34 @@ func (r *Restorer) MakeRestore(restoreID uuid.UUID) {
database, err := r.databaseService.GetDatabaseByID(databaseID)
if err != nil {
- r.logger.Error("Failed to get database by ID", "databaseId", databaseID, "error", err)
+ logger.ErrorContext(ctx, "failed to get database by ID", "database_id", databaseID, "error", err)
return
}
backupConfig, err := r.backupConfigService.GetBackupConfigByDbId(databaseID)
if err != nil {
- r.logger.Error("Failed to get backup config by database ID", "error", err)
+ logger.ErrorContext(ctx, "failed to get backup config by database ID", "error", err)
return
}
if backupConfig.StorageID == nil {
- r.logger.Error("Backup config storage ID is not defined")
+ logger.ErrorContext(ctx, "backup config storage ID is not defined")
return
}
- storage, err := r.storageService.GetStorageByID(*backupConfig.StorageID)
+ // Detached from the caller so a finished HTTP request cannot cancel a running restore.
+ executionCtx, cancel := context.WithCancel(context.Background())
+ r.restoreCancelManager.RegisterTask(restore.ID, cancel)
+ defer r.restoreCancelManager.UnregisterTask(restore.ID)
+
+ storage, err := r.storageService.GetStorageByID(executionCtx, *backupConfig.StorageID)
if err != nil {
- r.logger.Error("Failed to get storage by ID", "error", err)
+ logger.ErrorContext(ctx, "failed to get storage by ID", "error", err)
return
}
start := time.Now().UTC()
- // Create cancellable context
- ctx, cancel := context.WithCancel(context.Background())
- r.restoreCancelManager.RegisterTask(restore.ID, cancel)
- defer r.restoreCancelManager.UnregisterTask(restore.ID)
-
// Create restoring database from cached credentials
restoringToDB := &databases.Database{
Type: database.Type,
@@ -118,9 +114,7 @@ func (r *Restorer) MakeRestore(restoreID uuid.UUID) {
// The restore target is the only endpoint this function connects to, so one tunnel covers
// version detection, the TimescaleDB hooks and pg_restore itself.
- logger := r.logger.With("restore_id", restore.ID)
-
- tunneledDatabase, err := databases.OpenTunnel(ctx, databases.OpenTunnelSpec{
+ tunneledDatabase, err := databases.OpenTunnel(executionCtx, databases.OpenTunnelSpec{
Database: restoringToDB,
Logger: logger,
Encryptor: r.fieldEncryptor,
@@ -131,8 +125,10 @@ func (r *Restorer) MakeRestore(restoreID uuid.UUID) {
restore.Status = restores_core.RestoreStatusFailed
restore.RestoreDurationMs = time.Since(start).Milliseconds()
+ logger.ErrorContext(ctx, "restore failed to open the ssh tunnel to the target", "error", err)
+
if err := r.restoreRepository.Save(restore); err != nil {
- logger.Error("failed to save restore", "error", err)
+ logger.ErrorContext(ctx, "failed to save restore", "error", err)
}
return
@@ -148,8 +144,10 @@ func (r *Restorer) MakeRestore(restoreID uuid.UUID) {
restore.Status = restores_core.RestoreStatusFailed
restore.RestoreDurationMs = time.Since(start).Milliseconds()
+ logger.ErrorContext(ctx, "restore failed to auto-detect target database data", "error", err)
+
if err := r.restoreRepository.Save(restore); err != nil {
- logger.Error("failed to save restore", "error", err)
+ logger.ErrorContext(ctx, "failed to save restore", "error", err)
}
return
@@ -165,8 +163,11 @@ func (r *Restorer) MakeRestore(restoreID uuid.UUID) {
restoreOptions.IsSkipUserMappings = database.PostgresqlLogical.IsSkipUserMappings
}
+ logger.InfoContext(ctx, fmt.Sprintf("restore started: %s database %q", database.Type, database.Name),
+ "backup_id", backup.ID, "database_id", databaseID, "storage_id", storage.ID)
+
err = r.restoreBackupUsecase.Execute(
- ctx,
+ executionCtx,
backupConfig,
*restore,
database,
@@ -185,31 +186,28 @@ func (r *Restorer) MakeRestore(restoreID uuid.UUID) {
isShutdown := strings.Contains(errMsg, "shutdown")
if isCancelled && !isShutdown {
- r.logger.Warn("Restore was cancelled by user or system",
- "restoreId", restore.ID,
- "isCancelled", isCancelled,
- "isShutdown", isShutdown,
+ logger.WarnContext(ctx, "restore was cancelled by user or system",
+ "is_cancelled", isCancelled,
+ "is_shutdown", isShutdown,
)
restore.Status = restores_core.RestoreStatusCanceled
restore.RestoreDurationMs = time.Since(start).Milliseconds()
if err := r.restoreRepository.Save(restore); err != nil {
- r.logger.Error("Failed to save cancelled restore", "error", err)
+ logger.ErrorContext(ctx, "failed to save cancelled restore", "error", err)
}
return
}
- r.logger.Error("Restore execution failed",
- "restoreId", restore.ID,
- "backupId", backup.ID,
- "databaseId", databaseID,
- "databaseType", database.Type,
- "storageId", storage.ID,
- "storageType", storage.Type,
+ logger.ErrorContext(ctx, "restore execution failed",
+ "backup_id", backup.ID,
+ "database_id", databaseID,
+ "database_type", database.Type,
+ "storage_id", storage.ID,
+ "storage_type", storage.Type,
"error", err,
- "errorMessage", errMsg,
)
restore.FailMessage = &errMsg
@@ -217,7 +215,7 @@ func (r *Restorer) MakeRestore(restoreID uuid.UUID) {
restore.RestoreDurationMs = time.Since(start).Milliseconds()
if err := r.restoreRepository.Save(restore); err != nil {
- logger.Error("failed to save restore", "error", err)
+ logger.ErrorContext(ctx, "failed to save restore", "error", err)
}
return
@@ -227,14 +225,10 @@ func (r *Restorer) MakeRestore(restoreID uuid.UUID) {
restore.RestoreDurationMs = time.Since(start).Milliseconds()
if err := r.restoreRepository.Save(restore); err != nil {
- logger.Error("failed to save restore", "error", err)
+ logger.ErrorContext(ctx, "failed to save restore", "error", err)
return
}
- r.logger.Info(
- "Restore completed successfully",
- "restoreId", restore.ID,
- "backupId", backup.ID,
- "durationMs", restore.RestoreDurationMs,
- )
+ logger.InfoContext(ctx, fmt.Sprintf("restore finished in %d ms", restore.RestoreDurationMs),
+ "backup_id", backup.ID)
}
diff --git a/backend/internal/features/restores/restoring/restorer_test.go b/backend/internal/features/restores/restoring/restorer_test.go
index fcc32720..a947d8d9 100644
--- a/backend/internal/features/restores/restoring/restorer_test.go
+++ b/backend/internal/features/restores/restoring/restorer_test.go
@@ -24,13 +24,13 @@ import (
func Test_MakeRestore_WhenCacheMissed_RestoreFails(t *testing.T) {
cache_utils.ClearAllCache()
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
- backups_config_logical.EnableBackupsForTestDatabase(database.ID, storage)
+ backups_config_logical.EnableBackupsForTestDatabase(t.Context(), database.ID, storage)
defer func() {
backupRepo := backups_core_logical.BackupRepository{}
@@ -49,11 +49,11 @@ func Test_MakeRestore_WhenCacheMissed_RestoreFails(t *testing.T) {
restoreRepo.DeleteByID(restore.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
cache_utils.ClearAllCache()
}()
@@ -71,7 +71,7 @@ func Test_MakeRestore_WhenCacheMissed_RestoreFails(t *testing.T) {
// Create restorer and execute restore (should fail due to cache miss)
restorer := CreateTestRestorer()
- restorer.MakeRestore(restore.ID)
+ restorer.MakeRestore(t.Context(), restore.ID)
// Verify restore failed with appropriate error message
updatedRestore, err := restoreRepository.FindByID(restore.ID)
@@ -88,13 +88,13 @@ func Test_MakeRestore_WhenCacheMissed_RestoreFails(t *testing.T) {
func Test_MakeRestore_WhenTaskStarts_CacheDeletedImmediately(t *testing.T) {
cache_utils.ClearAllCache()
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
router := CreateTestRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
- backups_config_logical.EnableBackupsForTestDatabase(database.ID, storage)
+ backups_config_logical.EnableBackupsForTestDatabase(t.Context(), database.ID, storage)
defer func() {
backupRepo := backups_core_logical.BackupRepository{}
@@ -117,11 +117,11 @@ func Test_MakeRestore_WhenTaskStarts_CacheDeletedImmediately(t *testing.T) {
restoreRepo.DeleteByID(restore.ID)
}
- databases.RemoveTestDatabase(database)
+ databases.RemoveTestDatabase(t.Context(), database)
time.Sleep(50 * time.Millisecond)
notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
cache_utils.ClearAllCache()
}()
@@ -156,7 +156,7 @@ func Test_MakeRestore_WhenTaskStarts_CacheDeletedImmediately(t *testing.T) {
// Start restore (this will call GetAndDelete)
restorer := CreateTestRestorer()
- restorer.MakeRestore(restore.ID)
+ restorer.MakeRestore(t.Context(), restore.ID)
// Verify cache was deleted immediately
cachedDBAfter := restoreDatabaseCache.Get(restore.ID.String())
diff --git a/backend/internal/features/restores/restoring/scheduler.go b/backend/internal/features/restores/restoring/scheduler.go
index 297f0aa4..38f64aca 100644
--- a/backend/internal/features/restores/restoring/scheduler.go
+++ b/backend/internal/features/restores/restoring/scheduler.go
@@ -13,6 +13,8 @@ import (
cache_utils "databasus-backend/internal/util/cache"
)
+const jobName = "restore_scheduler"
+
const (
schedulerTickerInterval = 1 * time.Minute
schedulerHealthcheckThreshold = 5 * time.Minute
@@ -35,8 +37,10 @@ func (s *RestoresScheduler) Run(ctx context.Context) {
s.lastCheckTime = time.Now().UTC()
- if err := s.failRestoresInProgress(); err != nil {
- s.logger.Error("Failed to fail restores in progress", "error", err)
+ runLogger := s.logger.With("job_id", uuid.New(), "job_name", jobName)
+
+ if err := s.failRestoresInProgress(ctx, runLogger); err != nil {
+ runLogger.ErrorContext(ctx, "failed to fail restores in progress", "error", err)
panic(err)
}
@@ -47,9 +51,13 @@ func (s *RestoresScheduler) Run(ctx context.Context) {
ticker := time.NewTicker(schedulerTickerInterval)
defer ticker.Stop()
+ runLogger.InfoContext(ctx, "restore scheduler started")
+
for {
select {
case <-ctx.Done():
+ runLogger.InfoContext(ctx, "restore scheduler stopped")
+
return
case <-ticker.C:
s.lastCheckTime = time.Now().UTC()
@@ -61,14 +69,18 @@ func (s *RestoresScheduler) IsSchedulerRunning() bool {
return s.lastCheckTime.After(time.Now().UTC().Add(-schedulerHealthcheckThreshold))
}
-func (s *RestoresScheduler) StartRestore(restoreID uuid.UUID, dbCache *RestoreDatabaseCache) error {
+func (s *RestoresScheduler) StartRestore(
+ ctx context.Context,
+ restoreID uuid.UUID,
+ dbCache *RestoreDatabaseCache,
+) error {
// If dbCache not provided, try to fetch from DB (for backward compatibility/testing)
if dbCache == nil {
restore, err := s.restoreRepository.FindByID(restoreID)
if err != nil {
s.logger.Error(
"Failed to find restore by ID",
- "restoreId",
+ "restore_id",
restoreID,
"error",
err,
@@ -88,14 +100,14 @@ func (s *RestoresScheduler) StartRestore(restoreID uuid.UUID, dbCache *RestoreDa
// Cache database credentials with 1-hour expiration
s.cacheUtil.SetWithExpiration(restoreID.String(), dbCache, 1*time.Hour)
- go s.restorer.MakeRestore(restoreID)
+ go s.restorer.MakeRestore(ctx, restoreID)
- s.logger.Info("Successfully triggered restore", "restoreId", restoreID)
+ s.logger.InfoContext(ctx, "triggered restore", "restore_id", restoreID)
return nil
}
-func (s *RestoresScheduler) failRestoresInProgress() error {
+func (s *RestoresScheduler) failRestoresInProgress(ctx context.Context, logger *slog.Logger) error {
restoresInProgress, err := s.restoreRepository.FindByStatus(
restores_core.RestoreStatusInProgress,
)
@@ -103,6 +115,11 @@ func (s *RestoresScheduler) failRestoresInProgress() error {
return err
}
+ if len(restoresInProgress) > 0 {
+ logger.InfoContext(ctx, fmt.Sprintf(
+ "failing %d restores left in progress by the previous run", len(restoresInProgress)))
+ }
+
for _, restore := range restoresInProgress {
failMessage := "Restore failed due to application restart"
restore.FailMessage = &failMessage
@@ -111,6 +128,9 @@ func (s *RestoresScheduler) failRestoresInProgress() error {
if err := s.restoreRepository.Save(restore); err != nil {
return err
}
+
+ logger.InfoContext(ctx, "failed a restore left in progress by the previous run",
+ "restore_id", restore.ID)
}
return nil
diff --git a/backend/internal/features/restores/service.go b/backend/internal/features/restores/service.go
index 0c3bdc16..3b9fe282 100644
--- a/backend/internal/features/restores/service.go
+++ b/backend/internal/features/restores/service.go
@@ -10,6 +10,7 @@ import (
"github.com/google/uuid"
audit_logs "databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
backups_core_logical "databasus-backend/internal/features/backups/backups/core/logical"
backups_services "databasus-backend/internal/features/backups/backups/services"
backups_config_logical "databasus-backend/internal/features/backups/config/logical"
@@ -63,6 +64,7 @@ func (s *RestoreService) OnBeforeBackupRemove(backup *backups_core_logical.Logic
}
func (s *RestoreService) GetRestores(
+ ctx context.Context,
user *users_models.User,
backupID uuid.UUID,
) ([]*restores_core.Restore, error) {
@@ -81,6 +83,7 @@ func (s *RestoreService) GetRestores(
}
canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(
+ ctx,
*database.WorkspaceID,
user,
)
@@ -95,6 +98,7 @@ func (s *RestoreService) GetRestores(
}
func (s *RestoreService) RestoreBackupWithAuth(
+ ctx context.Context,
user *users_models.User,
backupID uuid.UUID,
requestDTO restores_core.RestoreBackupRequest,
@@ -114,6 +118,7 @@ func (s *RestoreService) RestoreBackupWithAuth(
}
canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(
+ ctx,
*database.WorkspaceID,
user,
)
@@ -124,12 +129,12 @@ func (s *RestoreService) RestoreBackupWithAuth(
return errors.New("insufficient permissions to restore this backup")
}
- backupDatabase, err := s.databaseService.GetDatabase(user, backup.DatabaseID)
+ backupDatabase, err := s.databaseService.GetDatabase(ctx, user, backup.DatabaseID)
if err != nil {
return err
}
- if err := s.populateRestoreTargetVersionThroughTunnel(backupDatabase, requestDTO); err != nil {
+ if err := s.populateRestoreTargetVersionThroughTunnel(ctx, backupDatabase, requestDTO); err != nil {
return err
}
@@ -138,7 +143,7 @@ func (s *RestoreService) RestoreBackupWithAuth(
}
// Validate disk space before starting restore
- if err := s.validateDiskSpace(backup, requestDTO); err != nil {
+ if err := s.validateDiskSpace(ctx, backup, requestDTO); err != nil {
return err
}
@@ -176,27 +181,28 @@ func (s *RestoreService) RestoreBackupWithAuth(
// Trigger restore via scheduler
scheduler := restoring.GetRestoresScheduler()
- if err := scheduler.StartRestore(restore.ID, dbCache); err != nil {
+ if err := scheduler.StartRestore(ctx, restore.ID, dbCache); err != nil {
// Mark restore as failed if we can't schedule it
failMsg := fmt.Sprintf("Failed to schedule restore: %v", err)
restore.FailMessage = &failMsg
restore.Status = restores_core.RestoreStatusFailed
if saveErr := s.restoreRepository.Save(&restore); saveErr != nil {
- s.logger.Error("Failed to save restore after scheduling error", "error", saveErr)
+ s.logger.ErrorContext(ctx, "failed to save restore after scheduling error", "error", saveErr)
}
return err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Database restored for database: %s", database.Name),
- &user.ID,
- database.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Database restored for database: %s", database.Name),
+ UserID: &user.ID,
+ WorkspaceID: database.WorkspaceID,
+ })
return nil
}
func (s *RestoreService) CancelRestore(
+ ctx context.Context,
user *users_models.User,
restoreID uuid.UUID,
) error {
@@ -219,7 +225,7 @@ func (s *RestoreService) CancelRestore(
return errors.New("cannot cancel restore for database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return err
}
@@ -235,11 +241,11 @@ func (s *RestoreService) CancelRestore(
return err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Restore cancelled for database: %s", database.Name),
- &user.ID,
- database.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Restore cancelled for database: %s", database.Name),
+ UserID: &user.ID,
+ WorkspaceID: database.WorkspaceID,
+ })
return nil
}
@@ -305,6 +311,7 @@ func (s *RestoreService) validateVersionCompatibility(
// The restore target arrives as bare engine models in the request DTO, so it is assembled into the
// Database the generic tunnel dispatcher works from, the same way the restorer itself does.
func (s *RestoreService) populateRestoreTargetVersionThroughTunnel(
+ ctx context.Context,
backupDatabase *databases.Database,
requestDTO restores_core.RestoreBackupRequest,
) error {
@@ -316,7 +323,7 @@ func (s *RestoreService) populateRestoreTargetVersionThroughTunnel(
Mongodb: requestDTO.MongodbDatabase,
}
- tunneledDatabase, err := databases.OpenTunnel(context.Background(), databases.OpenTunnelSpec{
+ tunneledDatabase, err := databases.OpenTunnel(ctx, databases.OpenTunnelSpec{
Database: restoreTarget,
Logger: s.logger,
Encryptor: s.fieldEncryptor,
@@ -340,6 +347,7 @@ func (s *RestoreService) populateRestoreTargetVersionThroughTunnel(
}
func (s *RestoreService) validateDiskSpace(
+ ctx context.Context,
backup *backups_core_logical.LogicalBackup,
requestDTO restores_core.RestoreBackupRequest,
) error {
@@ -357,7 +365,7 @@ func (s *RestoreService) validateDiskSpace(
return nil
}
- diskUsage, err := s.diskService.GetDiskUsage()
+ diskUsage, err := s.diskService.GetDiskUsage(ctx)
if err != nil {
return fmt.Errorf("failed to check disk space: %w", err)
}
diff --git a/backend/internal/features/restores/usecases/mariadb/restore_backup_uc.go b/backend/internal/features/restores/usecases/mariadb/restore_backup_uc.go
index b1482bb2..75a6240d 100644
--- a/backend/internal/features/restores/usecases/mariadb/restore_backup_uc.go
+++ b/backend/internal/features/restores/usecases/mariadb/restore_backup_uc.go
@@ -50,10 +50,10 @@ func (uc *RestoreMariadbBackupUsecase) Execute(
return errors.New("database type not supported")
}
- uc.logger.Info(
- "Restoring MariaDB backup via mariadb client",
- "restoreId", restore.ID,
- "backupId", backup.ID,
+ uc.logger.InfoContext(parentCtx,
+ "restoring MariaDB backup via mariadb client",
+ "restore_id", restore.ID,
+ "backup_id", backup.ID,
)
mdb := restoringToDB.Mariadb
@@ -159,7 +159,7 @@ func (uc *RestoreMariadbBackupUsecase) restoreFromStorage(
}
defer func() {
if err := rawReader.Close(); err != nil {
- logger.Error("failed to close backup reader", "error", err)
+ logger.ErrorContext(parentCtx, "failed to close backup reader", "error", err)
}
}()
@@ -186,7 +186,7 @@ func (uc *RestoreMariadbBackupUsecase) executeMariadbRestore(
fullArgs := append([]string{"--defaults-file=" + myCnfFile}, args...)
cmd := exec.CommandContext(ctx, mariadbBin, fullArgs...)
- uc.logger.Info("Executing MariaDB restore command", "command", cmd.String())
+ uc.logger.InfoContext(ctx, "executing MariaDB restore command", "command", cmd.String())
storageReadFailureTracker := io_utils.NewFailureTrackingReader(backupReader)
@@ -295,7 +295,7 @@ func (uc *RestoreMariadbBackupUsecase) setupDecryption(
return nil, fmt.Errorf("failed to create decryption reader: %w", err)
}
- uc.logger.Info("Using decryption for encrypted backup", "backupId", backup.ID)
+ uc.logger.Info("using decryption for encrypted backup", "backup_id", backup.ID)
return decryptReader, nil
}
diff --git a/backend/internal/features/restores/usecases/mongodb/restore_backup_uc.go b/backend/internal/features/restores/usecases/mongodb/restore_backup_uc.go
index 8b4cba54..b90fd9d3 100644
--- a/backend/internal/features/restores/usecases/mongodb/restore_backup_uc.go
+++ b/backend/internal/features/restores/usecases/mongodb/restore_backup_uc.go
@@ -50,10 +50,10 @@ func (uc *RestoreMongodbBackupUsecase) Execute(
return errors.New("database type not supported")
}
- uc.logger.Info(
- "Restoring MongoDB backup via mongorestore",
- "restoreId", restore.ID,
- "backupId", backup.ID,
+ uc.logger.InfoContext(parentCtx,
+ "restoring MongoDB backup via mongorestore",
+ "restore_id", restore.ID,
+ "backup_id", backup.ID,
)
mdb := restoringToDB.Mongodb
@@ -159,7 +159,7 @@ func (uc *RestoreMongodbBackupUsecase) restoreFromStorage(
}
defer func() {
if err := rawReader.Close(); err != nil {
- logger.Error("failed to close backup reader", "error", err)
+ logger.ErrorContext(parentCtx, "failed to close backup reader", "error", err)
}
}()
@@ -183,8 +183,9 @@ func (uc *RestoreMongodbBackupUsecase) executeMongoRestore(
safeArgs[i] = arg
}
}
- uc.logger.Info(
- "Executing MongoDB restore command",
+ uc.logger.InfoContext(
+ ctx,
+ "executing MongoDB restore command",
"command",
mongorestoreBin,
"args",
diff --git a/backend/internal/features/restores/usecases/mysql/restore_backup_uc.go b/backend/internal/features/restores/usecases/mysql/restore_backup_uc.go
index d4acd8d1..5f7a43aa 100644
--- a/backend/internal/features/restores/usecases/mysql/restore_backup_uc.go
+++ b/backend/internal/features/restores/usecases/mysql/restore_backup_uc.go
@@ -50,10 +50,10 @@ func (uc *RestoreMysqlBackupUsecase) Execute(
return errors.New("database type not supported")
}
- uc.logger.Info(
- "Restoring MySQL backup via mysql client",
- "restoreId", restore.ID,
- "backupId", backup.ID,
+ uc.logger.InfoContext(parentCtx,
+ "restoring MySQL backup via mysql client",
+ "restore_id", restore.ID,
+ "backup_id", backup.ID,
)
my := restoringToDB.Mysql
@@ -148,7 +148,7 @@ func (uc *RestoreMysqlBackupUsecase) restoreFromStorage(
}
defer func() {
if err := rawReader.Close(); err != nil {
- logger.Error("failed to close backup reader", "error", err)
+ logger.ErrorContext(parentCtx, "failed to close backup reader", "error", err)
}
}()
@@ -167,7 +167,7 @@ func (uc *RestoreMysqlBackupUsecase) executeMysqlRestore(
fullArgs := append([]string{"--defaults-file=" + myCnfFile}, args...)
cmd := exec.CommandContext(ctx, mysqlBin, fullArgs...)
- uc.logger.Info("Executing MySQL restore command", "command", cmd.String())
+ uc.logger.InfoContext(ctx, "executing MySQL restore command", "command", cmd.String())
storageReadFailureTracker := io_utils.NewFailureTrackingReader(backupReader)
@@ -276,7 +276,7 @@ func (uc *RestoreMysqlBackupUsecase) setupDecryption(
return nil, fmt.Errorf("failed to create decryption reader: %w", err)
}
- uc.logger.Info("Using decryption for encrypted backup", "backupId", backup.ID)
+ uc.logger.Info("using decryption for encrypted backup", "backup_id", backup.ID)
return decryptReader, nil
}
diff --git a/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go b/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go
index 6d93c589..f5da32b7 100644
--- a/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go
+++ b/backend/internal/features/restores/usecases/postgresql/restore_backup_uc.go
@@ -51,11 +51,11 @@ func (uc *RestorePostgresqlBackupUsecase) Execute(
return errors.New("database type not supported")
}
- uc.logger.Info(
- "Restoring PostgreSQL backup via pg_restore",
- "restoreId",
+ uc.logger.InfoContext(parentCtx,
+ "restoring PostgreSQL backup via pg_restore",
+ "restore_id",
restore.ID,
- "backupId",
+ "backup_id",
backup.ID,
)
@@ -92,9 +92,9 @@ func (uc *RestorePostgresqlBackupUsecase) restoreCustomType(
pg *pgtypes.PostgresqlLogicalDatabase,
options restores_core.RestoreOptions,
) error {
- uc.logger.Info(
- "Restoring backup in custom type (-Fc)",
- "backupId",
+ uc.logger.InfoContext(parentCtx,
+ "restoring backup in custom type (-Fc)",
+ "backup_id",
backup.ID,
"cpuCount",
pg.CpuCount,
@@ -134,11 +134,12 @@ func (uc *RestorePostgresqlBackupUsecase) withTimescaleHooks(
return fmt.Errorf("timescaledb_pre_restore failed: %w", err)
}
- uc.logger.Info("entered timescaledb restoring mode")
+ uc.logger.InfoContext(ctx, "entered timescaledb restoring mode")
defer func() {
if postErr := pg.RunTimescaleDBPostRestore(ctx, encryptor); postErr != nil {
- uc.logger.Error(
+ uc.logger.ErrorContext(
+ ctx,
"timescaledb_post_restore failed; target database may be left in restoring mode",
"error", postErr,
)
@@ -162,7 +163,7 @@ func (uc *RestorePostgresqlBackupUsecase) restoreViaStdin(
) error {
logger := uc.logger.With("backup_id", backup.ID)
- logger.Info("restoring via stdin streaming (CPU=1)")
+ logger.InfoContext(parentCtx, "restoring via stdin streaming (CPU=1)")
args := []string{
"-Fc", // expect custom type
@@ -229,7 +230,7 @@ func (uc *RestorePostgresqlBackupUsecase) restoreViaStdin(
}
defer func() {
if err := rawReader.Close(); err != nil {
- logger.Error("failed to close backup reader", "error", err)
+ logger.ErrorContext(parentCtx, "failed to close backup reader", "error", err)
}
}()
@@ -268,11 +269,11 @@ func (uc *RestorePostgresqlBackupUsecase) restoreViaStdin(
}
backupReader = decryptReader
- logger.Info("using decryption for encrypted backup")
+ logger.InfoContext(parentCtx, "using decryption for encrypted backup")
}
cmd := exec.CommandContext(ctx, pgBin, args...)
- logger.Info("executing PostgreSQL restore command via stdin", "command", cmd.String())
+ logger.InfoContext(parentCtx, "executing PostgreSQL restore command via stdin", "command", cmd.String())
// Setup environment variables
uc.setupPgRestoreEnvironment(cmd, credentials, pg)
@@ -396,9 +397,9 @@ func (uc *RestorePostgresqlBackupUsecase) restoreViaFile(
pg *pgtypes.PostgresqlLogicalDatabase,
options restores_core.RestoreOptions,
) error {
- uc.logger.Info(
- "Restoring via file with parallel jobs",
- "backupId",
+ uc.logger.InfoContext(parentCtx,
+ "restoring via file with parallel jobs",
+ "backup_id",
backup.ID,
"cpuCount",
pg.CpuCount,
@@ -463,7 +464,7 @@ func (uc *RestorePostgresqlBackupUsecase) restoreFromStorage(
) error {
logger := uc.logger.With("backup_id", backup.ID)
- logger.Info(
+ logger.InfoContext(parentCtx,
"restoring backup from storage via temporary file",
"pg_bin",
pgBin,
@@ -569,7 +570,8 @@ func (uc *RestorePostgresqlBackupUsecase) downloadBackupToTempFile(
tempBackupFile := filepath.Join(tempDir, "backup.dump")
- logger.Info(
+ logger.InfoContext(
+ ctx,
"downloading backup file from storage to temporary file",
"temp_file",
tempBackupFile,
@@ -586,7 +588,7 @@ func (uc *RestorePostgresqlBackupUsecase) downloadBackupToTempFile(
defer func() {
if err := rawReader.Close(); err != nil {
- logger.Error("failed to close backup reader", "error", err)
+ logger.ErrorContext(ctx, "failed to close backup reader", "error", err)
}
}()
@@ -630,7 +632,7 @@ func (uc *RestorePostgresqlBackupUsecase) downloadBackupToTempFile(
}
backupReader = decryptReader
- logger.Info("using decryption for encrypted backup")
+ logger.InfoContext(ctx, "using decryption for encrypted backup")
}
// Create temporary backup file
@@ -641,7 +643,7 @@ func (uc *RestorePostgresqlBackupUsecase) downloadBackupToTempFile(
}
defer func() {
if err := tempFile.Close(); err != nil {
- logger.Error("failed to close temporary file", "error", err)
+ logger.ErrorContext(ctx, "failed to close temporary file", "error", err)
}
}()
@@ -652,7 +654,7 @@ func (uc *RestorePostgresqlBackupUsecase) downloadBackupToTempFile(
return "", nil, fmt.Errorf("failed to write backup to temporary file: %w", err)
}
- logger.Info("backup file written to temporary location", "temp_file", tempBackupFile)
+ logger.InfoContext(ctx, "backup file written to temporary location", "temp_file", tempBackupFile)
return tempBackupFile, cleanupFunc, nil
}
@@ -673,7 +675,7 @@ func (uc *RestorePostgresqlBackupUsecase) executePgRestore(
pgBin := command.pgBin
cmd := exec.CommandContext(ctx, pgBin, command.args...)
- command.logger.Info("executing pg_restore command", "command", cmd.String())
+ command.logger.InfoContext(ctx, "executing pg_restore command", "command", cmd.String())
// Setup environment variables
uc.setupPgRestoreEnvironment(cmd, command.credentials, command.pgConfig)
@@ -762,7 +764,7 @@ func (uc *RestorePostgresqlBackupUsecase) setupPgRestoreEnvironment(
cmd.Env = append(cmd.Env, postgresql_shared.GetPgHostAddrEnv(pgConfig.CredentialSpec())...)
uc.logger.Info(
"Using temporary .pgpass file for authentication",
- "pgpassFile", credentials.PgpassPath,
+ "pgpass_file", credentials.PgpassPath,
)
cmd.Env = append(cmd.Env,
@@ -784,7 +786,7 @@ func (uc *RestorePostgresqlBackupUsecase) setupPgRestoreEnvironment(
"PGSSLROOTCERT="+credentials.RootCertPath,
"PGSSLCRL=",
)
- uc.logger.Info("Using SSL mode", "sslMode", sslMode)
+ uc.logger.Info("using SSL mode", "ssl_mode", sslMode)
}
type pgRestoreFailure struct {
@@ -971,7 +973,7 @@ func (uc *RestorePostgresqlBackupUsecase) generateFilteredTocList(
pgConfig *pgtypes.PostgresqlLogicalDatabase,
options restores_core.RestoreOptions,
) (string, error) {
- uc.logger.Info("Generating filtered TOC list", "backupFile", backupFile)
+ uc.logger.InfoContext(ctx, "generating filtered TOC list", "backup_file", backupFile)
// Run pg_restore -l to get the TOC list
listCmd := exec.CommandContext(ctx, pgBin, "-l", backupFile)
@@ -1003,12 +1005,12 @@ func (uc *RestorePostgresqlBackupUsecase) generateFilteredTocList(
upperLine := strings.ToUpper(trimmedLine)
if options.IsExcludeExtensions && isExtensionEntry(upperLine) {
- uc.logger.Info("Excluding extension-related entry from restore", "tocLine", trimmedLine)
+ uc.logger.InfoContext(ctx, "excluding extension-related entry from restore", "toc_line", trimmedLine)
continue
}
if options.IsSkipUserMappings && isUserMappingEntry(upperLine) {
- uc.logger.Info("Excluding user mapping entry from restore", "tocLine", trimmedLine)
+ uc.logger.InfoContext(ctx, "excluding user mapping entry from restore", "toc_line", trimmedLine)
continue
}
@@ -1034,10 +1036,10 @@ func (uc *RestorePostgresqlBackupUsecase) generateFilteredTocList(
return "", fmt.Errorf("failed to close TOC list file: %w", err)
}
- uc.logger.Info("Generated filtered TOC list file",
- "tocFile", tocFilePath,
- "originalLines", len(strings.Split(string(tocOutput), "\n")),
- "filteredLines", len(filteredLines),
+ uc.logger.InfoContext(ctx, "generated filtered TOC list file",
+ "toc_file", tocFilePath,
+ "original_lines", len(strings.Split(string(tocOutput), "\n")),
+ "filtered_lines", len(filteredLines),
)
return tocFilePath, nil
diff --git a/backend/internal/features/sshtunnel/forwarder.go b/backend/internal/features/sshtunnel/forwarder.go
index d1fbbe78..dd819b0d 100644
--- a/backend/internal/features/sshtunnel/forwarder.go
+++ b/backend/internal/features/sshtunnel/forwarder.go
@@ -118,6 +118,8 @@ func Open(ctx context.Context, spec OpenSpec) (*Forwarder, error) {
dialBastionConn: dialBastionConnOverTCP,
}
+ forwarderLogger.InfoContext(ctx, "ssh tunnel opened", "local_port", localAddress.Port)
+
if err := forwarder.dialAndCacheBastion(ctx); err != nil {
cancelLifetime()
_ = listener.Close()
@@ -137,6 +139,8 @@ func (f *Forwarder) GetLocalEndpoint() Endpoint {
func (f *Forwarder) Close() {
f.closeOnce.Do(func() {
+ f.logger.Info("ssh tunnel closed")
+
close(f.done)
// Before taking clientMutex: a redial holding it aborts only once its context is cancelled.
f.cancelLifetime()
@@ -275,6 +279,8 @@ func (f *Forwarder) dialAndCacheBastionLocked(ctx context.Context) error {
bastionConn, err := f.dialBastionConn(ctx, f.bastionAddress)
if err != nil {
+ f.logger.ErrorContext(ctx, "failed to dial the ssh tunnel host", "error", err)
+
return fmt.Errorf("failed to dial the SSH tunnel host: %w", err)
}
@@ -288,9 +294,13 @@ func (f *Forwarder) dialAndCacheBastionLocked(ctx context.Context) error {
if err != nil {
_ = bastionConn.Close()
+ f.logger.ErrorContext(ctx, "failed to authenticate with the ssh tunnel host", "error", err)
+
return fmt.Errorf("failed to authenticate with the SSH tunnel host: %w", err)
}
+ f.logger.DebugContext(ctx, "connected to the ssh tunnel host")
+
// The deadline bounded the handshake only. Forwarded traffic must not inherit it, or every
// dump longer than the handshake bound would be cut off mid-stream.
if err := bastionConn.SetDeadline(time.Time{}); err != nil {
diff --git a/backend/internal/features/sshtunnel/reachability.go b/backend/internal/features/sshtunnel/reachability.go
index 8bfeea6c..949808bb 100644
--- a/backend/internal/features/sshtunnel/reachability.go
+++ b/backend/internal/features/sshtunnel/reachability.go
@@ -20,6 +20,10 @@ func (f *Forwarder) IsBastionReachable(ctx context.Context) bool {
bastionConn, err := f.dialBastionConn(ctx, f.bastionAddress)
if err != nil {
+ // Supervision loops blame the bastion for a stream failure based on this, so the reason it
+ // was judged unreachable has to be somewhere.
+ f.logger.DebugContext(ctx, "ssh tunnel host is unreachable", "error", err)
+
return false
}
diff --git a/backend/internal/features/storages/controller.go b/backend/internal/features/storages/controller.go
index 6b7fe316..4f8d2f40 100644
--- a/backend/internal/features/storages/controller.go
+++ b/backend/internal/features/storages/controller.go
@@ -57,7 +57,7 @@ func (c *StorageController) SaveStorage(ctx *gin.Context) {
return
}
- if err := c.storageService.SaveStorage(user, request.WorkspaceID, &request); err != nil {
+ if err := c.storageService.SaveStorage(ctx.Request.Context(), user, request.WorkspaceID, &request); err != nil {
if errors.Is(err, ErrInsufficientPermissionsToManageStorage) ||
errors.Is(err, ErrRcloneStorageRequiresAdmin) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -95,7 +95,7 @@ func (c *StorageController) GetStorage(ctx *gin.Context) {
return
}
- storage, err := c.storageService.GetStorage(user, id)
+ storage, err := c.storageService.GetStorage(ctx.Request.Context(), user, id)
if err != nil {
if errors.Is(err, ErrInsufficientPermissionsToViewStorage) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -139,7 +139,7 @@ func (c *StorageController) GetStorages(ctx *gin.Context) {
return
}
- storages, err := c.storageService.GetStorages(user, workspaceID)
+ storages, err := c.storageService.GetStorages(ctx.Request.Context(), user, workspaceID)
if err != nil {
if errors.Is(err, ErrInsufficientPermissionsToViewStorages) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -177,7 +177,7 @@ func (c *StorageController) DeleteStorage(ctx *gin.Context) {
return
}
- if err := c.storageService.DeleteStorage(user, id); err != nil {
+ if err := c.storageService.DeleteStorage(ctx.Request.Context(), user, id); err != nil {
if errors.Is(err, ErrInsufficientPermissionsToManageStorage) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
@@ -214,7 +214,7 @@ func (c *StorageController) TestStorageConnection(ctx *gin.Context) {
return
}
- if err := c.storageService.TestStorageConnection(user, id); err != nil {
+ if err := c.storageService.TestStorageConnection(ctx.Request.Context(), user, id); err != nil {
if errors.Is(err, ErrInsufficientPermissionsToTestStorage) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
@@ -265,6 +265,7 @@ func (c *StorageController) TransferStorageToWorkspace(ctx *gin.Context) {
}
if err := c.storageService.TransferStorageToWorkspace(
+ ctx.Request.Context(),
user,
id,
request.TargetWorkspaceID,
@@ -313,7 +314,7 @@ func (c *StorageController) TestStorageConnectionDirect(ctx *gin.Context) {
return
}
- canView, _, err := c.workspaceService.CanUserAccessWorkspace(request.WorkspaceID, user)
+ canView, _, err := c.workspaceService.CanUserAccessWorkspace(ctx.Request.Context(), request.WorkspaceID, user)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -326,7 +327,7 @@ func (c *StorageController) TestStorageConnectionDirect(ctx *gin.Context) {
return
}
- if err := c.storageService.TestStorageConnectionDirect(user, &request); err != nil {
+ if err := c.storageService.TestStorageConnectionDirect(ctx.Request.Context(), user, &request); err != nil {
if errors.Is(err, ErrRcloneStorageRequiresAdmin) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
diff --git a/backend/internal/features/storages/controller_test.go b/backend/internal/features/storages/controller_test.go
index 6bb354ed..b050eb66 100644
--- a/backend/internal/features/storages/controller_test.go
+++ b/backend/internal/features/storages/controller_test.go
@@ -37,9 +37,9 @@ func (m *mockStorageDatabaseCounter) GetStorageAttachedDatabasesIDs(
}
func Test_SaveNewStorage_StorageReturnedViaGet(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := createNewStorage(workspace.ID)
var savedStorage Storage
@@ -83,13 +83,13 @@ func Test_SaveNewStorage_StorageReturnedViaGet(t *testing.T) {
assert.Contains(t, storages, savedStorage)
deleteStorage(t, router, savedStorage.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_UpdateExistingStorage_UpdatedStorageReturnedViaGet(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := createNewStorage(workspace.ID)
var savedStorage Storage
@@ -121,15 +121,15 @@ func Test_UpdateExistingStorage_UpdatedStorageReturnedViaGet(t *testing.T) {
assert.Equal(t, savedStorage.ID, updatedStorage.ID)
deleteStorage(t, router, updatedStorage.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_CreateRcloneStorage_OnlyAdminCanCreate_MemberGetsForbidden(t *testing.T) {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- adminWorkspace := workspaces_testing.CreateTestWorkspace("Admin Workspace", admin, router)
- memberWorkspace := workspaces_testing.CreateTestWorkspace("Member Workspace", member, router)
+ adminWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Admin Workspace", admin, router)
+ memberWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Member Workspace", member, router)
adminStorage := createNewRcloneStorage(adminWorkspace.ID)
var savedStorage Storage
@@ -158,16 +158,16 @@ func Test_CreateRcloneStorage_OnlyAdminCanCreate_MemberGetsForbidden(t *testing.
assert.Contains(t, string(resp.Body), "rclone storage can only be managed by administrators")
deleteStorage(t, router, savedStorage.ID, admin.Token)
- workspaces_testing.RemoveTestWorkspace(adminWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(memberWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), adminWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), memberWorkspace, router)
}
func Test_UpdateStorageTypeToRclone_OnlyAdminCanUpdate_MemberGetsForbidden(t *testing.T) {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- adminWorkspace := workspaces_testing.CreateTestWorkspace("Admin Workspace", admin, router)
- memberWorkspace := workspaces_testing.CreateTestWorkspace("Member Workspace", member, router)
+ adminWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Admin Workspace", admin, router)
+ memberWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Member Workspace", member, router)
adminS3Storage := &Storage{
WorkspaceID: adminWorkspace.ID,
@@ -255,14 +255,14 @@ func Test_UpdateStorageTypeToRclone_OnlyAdminCanUpdate_MemberGetsForbidden(t *te
deleteStorage(t, router, adminSaved.ID, admin.Token)
deleteStorage(t, router, memberSaved.ID, member.Token)
- workspaces_testing.RemoveTestWorkspace(adminWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(memberWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), adminWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), memberWorkspace, router)
}
func Test_TestStorageConnectionDirect_RcloneAsMember_ReturnsForbidden(t *testing.T) {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Member Workspace", member, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Member Workspace", member, router)
payload := createNewRcloneStorage(workspace.ID)
resp := test_utils.MakePostRequest(
@@ -275,13 +275,13 @@ func Test_TestStorageConnectionDirect_RcloneAsMember_ReturnsForbidden(t *testing
)
assert.Contains(t, string(resp.Body), "rclone storage can only be managed by administrators")
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_DeleteStorage_StorageNotReturnedViaGet(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := createNewStorage(workspace.ID)
var savedStorage Storage
@@ -312,13 +312,13 @@ func Test_DeleteStorage_StorageNotReturnedViaGet(t *testing.T) {
)
assert.Contains(t, string(response.Body), "error")
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_TestDirectStorageConnection_ConnectionEstablished(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := createNewStorage(workspace.ID)
response := test_utils.MakePostRequest(
t, router, "/api/v1/storages/direct-test", "Bearer "+owner.Token, *storage, http.StatusOK,
@@ -326,13 +326,13 @@ func Test_TestDirectStorageConnection_ConnectionEstablished(t *testing.T) {
assert.Contains(t, string(response.Body), "successful")
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_TestExistingStorageConnection_ConnectionEstablished(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := createNewStorage(workspace.ID)
var savedStorage Storage
@@ -358,7 +358,7 @@ func Test_TestExistingStorageConnection_ConnectionEstablished(t *testing.T) {
assert.Contains(t, string(response.Body), "successful")
deleteStorage(t, router, savedStorage.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_WorkspaceRolePermissions(t *testing.T) {
@@ -417,17 +417,17 @@ func Test_WorkspaceRolePermissions(t *testing.T) {
router := createRouter()
SetStorageDatabaseCountersForTest(&mockStorageDatabaseCounter{})
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
testUser,
@@ -513,16 +513,16 @@ func Test_WorkspaceRolePermissions(t *testing.T) {
if !tt.canDelete {
deleteStorage(t, router, ownerStorage.ID, owner.Token)
}
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
func Test_UserNotInWorkspace_CannotAccessStorages(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- outsider := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ outsider := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
storage := createNewStorage(workspace.ID)
var savedStorage Storage
@@ -570,15 +570,15 @@ func Test_UserNotInWorkspace_CannotAccessStorages(t *testing.T) {
)
deleteStorage(t, router, savedStorage.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_CrossWorkspaceSecurity_CannotAccessStorageFromAnotherWorkspace(t *testing.T) {
- owner1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- owner2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ owner2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
router := createRouter()
- workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", owner1, router)
- workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", owner2, router)
+ workspace1 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 1", owner1, router)
+ workspace2 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 2", owner2, router)
storage1 := createNewStorage(workspace1.ID)
var savedStorage Storage
@@ -603,8 +603,8 @@ func Test_CrossWorkspaceSecurity_CannotAccessStorageFromAnotherWorkspace(t *test
assert.Contains(t, string(response.Body), "insufficient permissions")
deleteStorage(t, router, savedStorage.ID, owner1.Token)
- workspaces_testing.RemoveTestWorkspace(workspace1, router)
- workspaces_testing.RemoveTestWorkspace(workspace2, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace1, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace2, router)
}
func Test_StorageSensitiveDataLifecycle_AllTypes(t *testing.T) {
@@ -992,9 +992,9 @@ func Test_StorageSensitiveDataLifecycle_AllTypes(t *testing.T) {
if tc.storageType == StorageTypeRclone {
ownerRole = users_enums.UserRoleAdmin
}
- owner := users_testing.CreateTestUser(ownerRole)
+ owner := users_testing.CreateTestUser(t.Context(), ownerRole)
router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
// Phase 1: Create storage with sensitive data
initialStorage := tc.createStorage(workspace.ID)
@@ -1014,7 +1014,7 @@ func Test_StorageSensitiveDataLifecycle_AllTypes(t *testing.T) {
// Phase 2: Verify sensitive data is encrypted in repository after creation
repository := &StorageRepository{}
- storageFromDBAfterCreate, err := repository.FindByID(createdStorage.ID)
+ storageFromDBAfterCreate, err := repository.FindByID(t.Context(), createdStorage.ID)
assert.NoError(t, err)
tc.verifySensitiveData(t, storageFromDBAfterCreate)
@@ -1049,7 +1049,7 @@ func Test_StorageSensitiveDataLifecycle_AllTypes(t *testing.T) {
assert.Equal(t, updatedStorage.Name, updateResponse.Name)
// Phase 5: Retrieve directly from repository to verify sensitive data preservation
- storageFromDB, err := repository.FindByID(createdStorage.ID)
+ storageFromDB, err := repository.FindByID(t.Context(), createdStorage.ID)
assert.NoError(t, err)
// Verify original sensitive data is still present in DB
@@ -1072,7 +1072,7 @@ func Test_StorageSensitiveDataLifecycle_AllTypes(t *testing.T) {
// Cleanup
deleteStorage(t, router, createdStorage.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
})
}
}
@@ -1133,15 +1133,15 @@ func Test_TransferStorage_PermissionsEnforced(t *testing.T) {
router := createRouter()
SetStorageDatabaseCountersForTest(&mockStorageDatabaseCounter{})
- sourceOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- targetOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ targetOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- sourceWorkspace := workspaces_testing.CreateTestWorkspace(
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Source Workspace",
sourceOwner,
router,
)
- targetWorkspace := workspaces_testing.CreateTestWorkspace(
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Target Workspace",
targetOwner,
router,
@@ -1161,10 +1161,10 @@ func Test_TransferStorage_PermissionsEnforced(t *testing.T) {
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.sourceRole != nil {
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
sourceWorkspace,
testUser,
@@ -1215,8 +1215,8 @@ func Test_TransferStorage_PermissionsEnforced(t *testing.T) {
deleteStorage(t, router, savedStorage.ID, sourceOwner.Token)
}
- workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
- workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), targetWorkspace, router)
})
}
}
@@ -1225,11 +1225,11 @@ func Test_TransferStorageNotManagableWorkspace_TransferFailed(t *testing.T) {
router := createRouter()
SetStorageDatabaseCountersForTest(&mockStorageDatabaseCounter{})
- userA := users_testing.CreateTestUser(users_enums.UserRoleMember)
- userB := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ userA := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ userB := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", userA, router)
- workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", userB, router)
+ workspace1 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 1", userA, router)
+ workspace2 := workspaces_testing.CreateTestWorkspace(t.Context(), "Workspace 2", userB, router)
storage := createNewStorage(workspace1.ID)
var savedStorage Storage
@@ -1263,8 +1263,8 @@ func Test_TransferStorageNotManagableWorkspace_TransferFailed(t *testing.T) {
)
deleteStorage(t, router, savedStorage.ID, userA.Token)
- workspaces_testing.RemoveTestWorkspace(workspace1, router)
- workspaces_testing.RemoveTestWorkspace(workspace2, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace1, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace2, router)
}
func createRouter() *gin.Engine {
diff --git a/backend/internal/features/storages/interfaces.go b/backend/internal/features/storages/interfaces.go
index db92aed6..3448c5d2 100644
--- a/backend/internal/features/storages/interfaces.go
+++ b/backend/internal/features/storages/interfaces.go
@@ -29,7 +29,12 @@ type StorageFileSaver interface {
fileName string,
) (io.ReadCloser, error)
- DeleteFile(encryptor encryption.FieldEncryptor, fileName string) error
+ DeleteFile(
+ ctx context.Context,
+ encryptor encryption.FieldEncryptor,
+ logger *slog.Logger,
+ fileName string,
+ ) error
Validate(encryptor encryption.FieldEncryptor) error
diff --git a/backend/internal/features/storages/model.go b/backend/internal/features/storages/model.go
index bc9b3cfa..0dd42bb1 100644
--- a/backend/internal/features/storages/model.go
+++ b/backend/internal/features/storages/model.go
@@ -65,8 +65,13 @@ func (s *Storage) GetFile(
return s.getSpecificStorage().GetFile(ctx, encryptor, logger, fileName)
}
-func (s *Storage) DeleteFile(encryptor encryption.FieldEncryptor, fileName string) error {
- return s.getSpecificStorage().DeleteFile(encryptor, fileName)
+func (s *Storage) DeleteFile(
+ ctx context.Context,
+ encryptor encryption.FieldEncryptor,
+ logger *slog.Logger,
+ fileName string,
+) error {
+ return s.getSpecificStorage().DeleteFile(ctx, encryptor, logger, fileName)
}
func (s *Storage) Validate(encryptor encryption.FieldEncryptor) error {
diff --git a/backend/internal/features/storages/model_test.go b/backend/internal/features/storages/model_test.go
index ea322a10..336815e3 100644
--- a/backend/internal/features/storages/model_test.go
+++ b/backend/internal/features/storages/model_test.go
@@ -225,7 +225,7 @@ acl = private`, s3Container.accessKey, s3Container.secretKey, s3Container.endpoi
require.NoError(t, err, "SaveFile should succeed")
t.Cleanup(func() {
- _ = tc.storage.DeleteFile(encryptor, fileID.String())
+ _ = tc.storage.DeleteFile(t.Context(), encryptor, logger.GetLogger(), fileID.String())
})
file, err := tc.storage.GetFile(
@@ -256,7 +256,7 @@ acl = private`, s3Container.accessKey, s3Container.secretKey, s3Container.endpoi
)
require.NoError(t, err, "SaveFile should succeed")
- err = tc.storage.DeleteFile(encryptor, fileID.String())
+ err = tc.storage.DeleteFile(t.Context(), encryptor, logger.GetLogger(), fileID.String())
assert.NoError(t, err, "DeleteFile should succeed")
file, err := tc.storage.GetFile(t.Context(), encryptor, logger.GetLogger(), fileID.String())
@@ -268,7 +268,7 @@ acl = private`, s3Container.accessKey, s3Container.secretKey, s3Container.endpoi
t.Run("Test_TestDeleteNonExistentFile_DoesNotError", func(t *testing.T) {
nonExistentID := uuid.New()
- err := tc.storage.DeleteFile(encryptor, nonExistentID.String())
+ err := tc.storage.DeleteFile(t.Context(), encryptor, logger.GetLogger(), nonExistentID.String())
assert.NoError(t, err, "DeleteFile should not error for non-existent file")
})
})
@@ -433,7 +433,7 @@ acl = private`, s3Container.accessKey, s3Container.endpoint),
encryptor := encryption.GetFieldEncryptor()
- err = rcloneStorage.DeleteFile(encryptor, fileID)
+ err = rcloneStorage.DeleteFile(t.Context(), encryptor, logger.GetLogger(), fileID)
require.Error(t, err)
_, statErr := minioClient.StatObject(
diff --git a/backend/internal/features/storages/models/azure_blob/model.go b/backend/internal/features/storages/models/azure_blob/model.go
index 1bc63047..984a51cf 100644
--- a/backend/internal/features/storages/models/azure_blob/model.go
+++ b/backend/internal/features/storages/models/azure_blob/model.go
@@ -82,9 +82,17 @@ func (s *AzureBlobStorage) SaveFile(
client, err := s.getClient(encryptor)
if err != nil {
+ logger.ErrorContext(ctx, "failed to build the azure blob client",
+ "container", s.ContainerName, "error", err)
+
return err
}
+ startedAt := time.Now().UTC()
+
+ logger.DebugContext(ctx, "saving file to azure blob storage",
+ "file_name", fileName, "container", s.ContainerName)
+
blobName := s.buildBlobName(fileName)
blockBlobClient := client.ServiceClient().
NewContainerClient(s.ContainerName).
@@ -145,16 +153,28 @@ func (s *AzureBlobStorage) SaveFile(
nil,
)
if err != nil {
+ logger.ErrorContext(ctx, "failed to save empty file to azure blob storage",
+ "file_name", fileName, "error", err)
+
return fmt.Errorf("failed to upload empty blob: %w", err)
}
+
+ logger.DebugContext(ctx, "saved empty file to azure blob storage", "file_name", fileName)
+
return nil
}
_, err = blockBlobClient.CommitBlockList(ctx, blockIDs, &blockblob.CommitBlockListOptions{})
if err != nil {
+ logger.ErrorContext(ctx, "failed to save file to azure blob storage",
+ "file_name", fileName, "error", err)
+
return fmt.Errorf("failed to commit block list: %w", err)
}
+ logger.DebugContext(ctx, fmt.Sprintf("saved file to azure blob storage: %d blocks in %s",
+ len(blockIDs), time.Since(startedAt)), "file_name", fileName)
+
return nil
}
@@ -210,7 +230,12 @@ func getBlobSizeOrUnknown(contentLength *int64) int64 {
return *contentLength
}
-func (s *AzureBlobStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileName string) error {
+func (s *AzureBlobStorage) DeleteFile(
+ ctx context.Context,
+ encryptor encryption.FieldEncryptor,
+ logger *slog.Logger,
+ fileName string,
+) error {
client, err := s.getClient(encryptor)
if err != nil {
return err
@@ -218,11 +243,13 @@ func (s *AzureBlobStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileN
blobName := s.buildBlobName(fileName)
- ctx, cancel := context.WithTimeout(context.Background(), azureDeleteTimeout)
+ // Deletes run from cleanup paths whose caller context is often already cancelled, so the
+ // operation carries its own deadline; the caller's ctx stays for log correlation only.
+ deleteCtx, cancel := context.WithTimeout(context.Background(), azureDeleteTimeout)
defer cancel()
_, err = client.DeleteBlob(
- ctx,
+ deleteCtx,
s.ContainerName,
blobName,
nil,
@@ -235,6 +262,8 @@ func (s *AzureBlobStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileN
return fmt.Errorf("failed to delete blob from Azure: %w", err)
}
+ logger.DebugContext(ctx, "deleted file from azure blob storage", "file_name", fileName)
+
return nil
}
diff --git a/backend/internal/features/storages/models/ftp/model.go b/backend/internal/features/storages/models/ftp/model.go
index 77d0bacf..ef8c157d 100644
--- a/backend/internal/features/storages/models/ftp/model.go
+++ b/backend/internal/features/storages/models/ftp/model.go
@@ -53,18 +53,19 @@ func (f *FTPStorage) SaveFile(
default:
}
- logger.Info("Starting to save file to FTP storage", "fileName", fileName, "host", f.Host)
+ logger.InfoContext(ctx, "starting to save file to FTP storage", "file_name", fileName, "host", f.Host)
conn, err := f.connect(encryptor, ftpConnectTimeout)
if err != nil {
- logger.Error("Failed to connect to FTP", "fileName", fileName, "error", err)
+ logger.ErrorContext(ctx, "failed to connect to FTP", "file_name", fileName, "error", err)
return fmt.Errorf("failed to connect to FTP: %w", err)
}
defer func() {
if quitErr := conn.Quit(); quitErr != nil {
- logger.Error(
- "Failed to close FTP connection",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to close FTP connection",
+ "file_name",
fileName,
"error",
quitErr,
@@ -74,9 +75,10 @@ func (f *FTPStorage) SaveFile(
if f.Path != "" {
if err := f.ensureDirectory(conn, f.Path); err != nil {
- logger.Error(
- "Failed to ensure directory",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to ensure directory",
+ "file_name",
fileName,
"path",
f.Path,
@@ -88,7 +90,7 @@ func (f *FTPStorage) SaveFile(
}
filePath := f.getFilePath(fileName)
- logger.Debug("Uploading file to FTP", "fileName", fileName, "filePath", filePath)
+ logger.DebugContext(ctx, "uploading file to FTP", "file_name", fileName, "file_path", filePath)
ctxReader := &contextReader{ctx: ctx, reader: file}
@@ -96,19 +98,20 @@ func (f *FTPStorage) SaveFile(
if err != nil {
select {
case <-ctx.Done():
- logger.Info("FTP upload cancelled", "fileName", fileName)
+ logger.InfoContext(ctx, "FTP upload cancelled", "file_name", fileName)
return ctx.Err()
default:
- logger.Error("Failed to upload file to FTP", "fileName", fileName, "error", err)
+ logger.ErrorContext(ctx, "failed to upload file to FTP", "file_name", fileName, "error", err)
return fmt.Errorf("failed to upload file to FTP: %w", err)
}
}
- logger.Info(
- "Successfully saved file to FTP storage",
- "fileName",
+ logger.InfoContext(
+ ctx,
+ "successfully saved file to FTP storage",
+ "file_name",
fileName,
- "filePath",
+ "file_path",
filePath,
)
return nil
@@ -138,13 +141,13 @@ func (f *FTPStorage) GetFile(
return nil, fmt.Errorf("failed to stat file on FTP: %w", err)
}
- logger.Warn("storage does not support the FTP SIZE command", "file_name", fileName, "error", err)
+ logger.WarnContext(ctx, "storage does not support the FTP SIZE command", "file_name", fileName, "error", err)
totalBytes = io_utils.UnknownTotalBytes
}
if err := conn.Quit(); err != nil {
- logger.Warn("failed to close the FTP connection used for stat", "error", err)
+ logger.WarnContext(ctx, "failed to close the FTP connection used for stat", "error", err)
}
return io_utils.NewResumingReader(io_utils.ResumingReaderSpec{
@@ -158,11 +161,18 @@ func (f *FTPStorage) GetFile(
}), nil
}
-func (f *FTPStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileName string) error {
- ctx, cancel := context.WithTimeout(context.Background(), ftpDeleteTimeout)
+func (f *FTPStorage) DeleteFile(
+ ctx context.Context,
+ encryptor encryption.FieldEncryptor,
+ logger *slog.Logger,
+ fileName string,
+) error {
+ // Deletes run from cleanup paths whose caller context is often already cancelled, so the
+ // operation carries its own deadline; the caller's ctx stays for log correlation only.
+ deleteCtx, cancel := context.WithTimeout(context.Background(), ftpDeleteTimeout)
defer cancel()
- conn, err := f.connectWithContext(ctx, encryptor, ftpDeleteTimeout)
+ conn, err := f.connectWithContext(deleteCtx, encryptor, ftpDeleteTimeout)
if err != nil {
return fmt.Errorf("failed to connect to FTP: %w", err)
}
@@ -182,6 +192,8 @@ func (f *FTPStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileName st
return fmt.Errorf("failed to delete file from FTP: %w", err)
}
+ logger.DebugContext(ctx, "deleted file from ftp storage", "file_name", fileName)
+
return nil
}
diff --git a/backend/internal/features/storages/models/google_drive/model.go b/backend/internal/features/storages/models/google_drive/model.go
index 6e5bc719..4d7f72f9 100644
--- a/backend/internal/features/storages/models/google_drive/model.go
+++ b/backend/internal/features/storages/models/google_drive/model.go
@@ -87,7 +87,8 @@ func (s *GoogleDriveStorage) SaveFile(
return fmt.Errorf("failed to upload file to Google Drive: %w", err)
}
- logger.Info(
+ logger.InfoContext(
+ ctx,
"file uploaded to Google Drive",
"name",
fileName,
@@ -216,20 +217,32 @@ func isRetryableGoogleDriveError(err error) bool {
}
func (s *GoogleDriveStorage) DeleteFile(
+ ctx context.Context,
encryptor encryption.FieldEncryptor,
+ logger *slog.Logger,
fileName string,
) error {
- ctx, cancel := context.WithTimeout(context.Background(), gdDeleteTimeout)
+ // Deletes run from cleanup paths whose caller context is often already cancelled, so the
+ // operation carries its own deadline; the caller's ctx stays for log correlation only.
+ deleteCtx, cancel := context.WithTimeout(context.Background(), gdDeleteTimeout)
defer cancel()
- return s.withRetryOnAuth(ctx, encryptor, func(driveService *drive.Service) error {
+ if err := s.withRetryOnAuth(deleteCtx, encryptor, func(driveService *drive.Service) error {
folderID, err := s.findBackupsFolder(driveService)
if err != nil {
return fmt.Errorf("failed to find backups folder: %w", err)
}
- return s.deleteByName(ctx, driveService, fileName, folderID)
- })
+ return s.deleteByName(deleteCtx, driveService, fileName, folderID)
+ }); err != nil {
+ logger.WarnContext(ctx, "failed to delete file from google drive", "file_name", fileName, "error", err)
+
+ return err
+ }
+
+ logger.DebugContext(ctx, "deleted file from google drive", "file_name", fileName)
+
+ return nil
}
func (s *GoogleDriveStorage) Validate(encryptor encryption.FieldEncryptor) error {
diff --git a/backend/internal/features/storages/models/local/model.go b/backend/internal/features/storages/models/local/model.go
index a0ad7eed..5f7fd7bb 100644
--- a/backend/internal/features/storages/models/local/model.go
+++ b/backend/internal/features/storages/models/local/model.go
@@ -48,7 +48,7 @@ func (l *LocalStorage) SaveFile(
default:
}
- logger.Info("Starting to save file to local storage", "fileName", fileName)
+ logger.InfoContext(ctx, "starting to save file to local storage", "file_name", fileName)
tempFilePath := filepath.Join(config.GetEnv().TempFolder, fileName)
@@ -59,15 +59,16 @@ func (l *LocalStorage) SaveFile(
if err != nil {
return fmt.Errorf("failed to ensure directories: %w", err)
}
- logger.Debug("Creating temp file", "fileName", fileName, "tempPath", tempFilePath)
+ logger.DebugContext(ctx, "creating temp file", "file_name", fileName, "temp_path", tempFilePath)
tempFile, err := os.Create(tempFilePath)
if err != nil {
- logger.Error(
- "Failed to create temp file",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to create temp file",
+ "file_name",
fileName,
- "tempPath",
+ "temp_path",
tempFilePath,
"error",
err,
@@ -78,30 +79,31 @@ func (l *LocalStorage) SaveFile(
_ = tempFile.Close()
}()
- logger.Debug("Copying file data to temp file", "fileName", fileName)
+ logger.DebugContext(ctx, "copying file data to temp file", "file_name", fileName)
_, err = copyWithContext(ctx, tempFile, file)
if err != nil {
- logger.Error("Failed to write to temp file", "fileName", fileName, "error", err)
+ logger.ErrorContext(ctx, "failed to write to temp file", "file_name", fileName, "error", err)
return fmt.Errorf("failed to write to temp file: %w", err)
}
if err = tempFile.Sync(); err != nil {
- logger.Error("Failed to sync temp file", "fileName", fileName, "error", err)
+ logger.ErrorContext(ctx, "failed to sync temp file", "file_name", fileName, "error", err)
return fmt.Errorf("failed to sync temp file: %w", err)
}
// Close the temp file explicitly before moving it (required on Windows)
if err = tempFile.Close(); err != nil {
- logger.Error("Failed to close temp file", "fileName", fileName, "error", err)
+ logger.ErrorContext(ctx, "failed to close temp file", "file_name", fileName, "error", err)
return fmt.Errorf("failed to close temp file: %w", err)
}
finalPath := filepath.Join(config.GetEnv().DataFolder, fileName)
- logger.Debug(
- "Moving file from temp to final location",
- "fileName",
+ logger.DebugContext(
+ ctx,
+ "moving file from temp to final location",
+ "file_name",
fileName,
- "finalPath",
+ "final_path",
finalPath,
)
@@ -111,13 +113,14 @@ func (l *LocalStorage) SaveFile(
// Move the file from temp to backups directory
if err = moveFile(tempFilePath, finalPath); err != nil {
- logger.Error(
- "Failed to move file from temp to backups",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to move file from temp to backups",
+ "file_name",
fileName,
- "tempPath",
+ "temp_path",
tempFilePath,
- "finalPath",
+ "final_path",
finalPath,
"error",
err,
@@ -125,11 +128,12 @@ func (l *LocalStorage) SaveFile(
return fmt.Errorf("failed to move file from temp to backups: %w", err)
}
- logger.Info(
- "Successfully saved file to local storage",
- "fileName",
+ logger.InfoContext(
+ ctx,
+ "successfully saved file to local storage",
+ "file_name",
fileName,
- "finalPath",
+ "final_path",
finalPath,
)
@@ -156,7 +160,12 @@ func (l *LocalStorage) GetFile(
return file, nil
}
-func (l *LocalStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileName string) error {
+func (l *LocalStorage) DeleteFile(
+ ctx context.Context,
+ encryptor encryption.FieldEncryptor,
+ logger *slog.Logger,
+ fileName string,
+) error {
filePath := filepath.Join(config.GetEnv().DataFolder, fileName)
if _, err := os.Stat(filePath); os.IsNotExist(err) {
@@ -167,6 +176,8 @@ func (l *LocalStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileName
return fmt.Errorf("failed to delete file: %w", err)
}
+ logger.DebugContext(ctx, "deleted file from local storage", "file_name", fileName)
+
return nil
}
diff --git a/backend/internal/features/storages/models/nas/model.go b/backend/internal/features/storages/models/nas/model.go
index 5a069381..3d0357b7 100644
--- a/backend/internal/features/storages/models/nas/model.go
+++ b/backend/internal/features/storages/models/nas/model.go
@@ -57,18 +57,19 @@ func (n *NASStorage) SaveFile(
default:
}
- logger.Info("Starting to save file to NAS storage", "fileName", fileName, "host", n.Host)
+ logger.InfoContext(ctx, "starting to save file to NAS storage", "file_name", fileName, "host", n.Host)
session, err := n.createSessionWithContext(ctx, encryptor)
if err != nil {
- logger.Error("Failed to create NAS session", "fileName", fileName, "error", err)
+ logger.ErrorContext(ctx, "failed to create NAS session", "file_name", fileName, "error", err)
return fmt.Errorf("failed to create NAS session: %w", err)
}
defer func() {
if logoffErr := session.Logoff(); logoffErr != nil {
- logger.Error(
- "Failed to logoff NAS session",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to logoff NAS session",
+ "file_name",
fileName,
"error",
logoffErr,
@@ -78,9 +79,10 @@ func (n *NASStorage) SaveFile(
fs, err := session.Mount(n.Share)
if err != nil {
- logger.Error(
- "Failed to mount NAS share",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to mount NAS share",
+ "file_name",
fileName,
"share",
n.Share,
@@ -91,9 +93,10 @@ func (n *NASStorage) SaveFile(
}
defer func() {
if umountErr := fs.Umount(); umountErr != nil {
- logger.Error(
- "Failed to unmount NAS share",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to unmount NAS share",
+ "file_name",
fileName,
"error",
umountErr,
@@ -104,9 +107,10 @@ func (n *NASStorage) SaveFile(
// Ensure the directory exists
if n.Path != "" {
if err := n.ensureDirectory(fs, n.Path); err != nil {
- logger.Error(
- "Failed to ensure directory",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to ensure directory",
+ "file_name",
fileName,
"path",
n.Path,
@@ -118,15 +122,16 @@ func (n *NASStorage) SaveFile(
}
filePath := n.getFilePath(fileName)
- logger.Debug("Creating file on NAS", "fileName", fileName, "filePath", filePath)
+ logger.DebugContext(ctx, "creating file on NAS", "file_name", fileName, "file_path", filePath)
nasFile, err := fs.Create(filePath)
if err != nil {
- logger.Error(
- "Failed to create file on NAS",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to create file on NAS",
+ "file_name",
fileName,
- "filePath",
+ "file_path",
filePath,
"error",
err,
@@ -135,22 +140,23 @@ func (n *NASStorage) SaveFile(
}
defer func() {
if closeErr := nasFile.Close(); closeErr != nil {
- logger.Error("Failed to close NAS file", "fileName", fileName, "error", closeErr)
+ logger.ErrorContext(ctx, "failed to close NAS file", "file_name", fileName, "error", closeErr)
}
}()
- logger.Debug("Copying file data to NAS", "fileName", fileName)
+ logger.DebugContext(ctx, "copying file data to NAS", "file_name", fileName)
_, err = copyWithContext(ctx, nasFile, file)
if err != nil {
- logger.Error("Failed to write file to NAS", "fileName", fileName, "error", err)
+ logger.ErrorContext(ctx, "failed to write file to NAS", "file_name", fileName, "error", err)
return fmt.Errorf("failed to write file to NAS: %w", err)
}
- logger.Info(
- "Successfully saved file to NAS storage",
- "fileName",
+ logger.InfoContext(
+ ctx,
+ "successfully saved file to NAS storage",
+ "file_name",
fileName,
- "filePath",
+ "file_path",
filePath,
)
return nil
@@ -200,11 +206,18 @@ func (n *NASStorage) GetFile(
}), nil
}
-func (n *NASStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileName string) error {
- ctx, cancel := context.WithTimeout(context.Background(), nasDeleteTimeout)
+func (n *NASStorage) DeleteFile(
+ ctx context.Context,
+ encryptor encryption.FieldEncryptor,
+ logger *slog.Logger,
+ fileName string,
+) error {
+ // Deletes run from cleanup paths whose caller context is often already cancelled, so the
+ // operation carries its own deadline; the caller's ctx stays for log correlation only.
+ deleteCtx, cancel := context.WithTimeout(context.Background(), nasDeleteTimeout)
defer cancel()
- session, err := n.createSessionWithContext(ctx, encryptor)
+ session, err := n.createSessionWithContext(deleteCtx, encryptor)
if err != nil {
return fmt.Errorf("failed to create NAS session: %w", err)
}
@@ -232,6 +245,8 @@ func (n *NASStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileName st
return fmt.Errorf("failed to delete file from NAS: %w", err)
}
+ logger.DebugContext(ctx, "deleted file from nas storage", "file_name", fileName)
+
return nil
}
diff --git a/backend/internal/features/storages/models/rclone/model.go b/backend/internal/features/storages/models/rclone/model.go
index 2efa1e58..dc7c9fdb 100644
--- a/backend/internal/features/storages/models/rclone/model.go
+++ b/backend/internal/features/storages/models/rclone/model.go
@@ -51,27 +51,28 @@ func (r *RcloneStorage) SaveFile(
default:
}
- logger.Info("Starting to save file to rclone storage", "fileName", fileName)
+ logger.InfoContext(ctx, "starting to save file to rclone storage", "file_name", fileName)
remoteFs, err := r.getFs(ctx, encryptor)
if err != nil {
- logger.Error("Failed to create rclone filesystem", "fileName", fileName, "error", err)
+ logger.ErrorContext(ctx, "failed to create rclone filesystem", "file_name", fileName, "error", err)
return fmt.Errorf("failed to create rclone filesystem: %w", err)
}
filePath := r.getFilePath(fileName)
- logger.Debug("Uploading file via rclone", "fileName", fileName, "filePath", filePath)
+ logger.DebugContext(ctx, "uploading file via rclone", "file_name", fileName, "file_path", filePath)
_, err = operations.Rcat(ctx, remoteFs, filePath, io.NopCloser(file), time.Now().UTC(), nil)
if err != nil {
select {
case <-ctx.Done():
- logger.Info("Rclone upload cancelled", "fileName", fileName)
+ logger.InfoContext(ctx, "rclone upload cancelled", "file_name", fileName)
return ctx.Err()
default:
- logger.Error(
- "Failed to upload file via rclone",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to upload file via rclone",
+ "file_name",
fileName,
"error",
err,
@@ -80,11 +81,12 @@ func (r *RcloneStorage) SaveFile(
}
}
- logger.Info(
- "Successfully saved file to rclone storage",
- "fileName",
+ logger.InfoContext(
+ ctx,
+ "successfully saved file to rclone storage",
+ "file_name",
fileName,
- "filePath",
+ "file_path",
filePath,
)
return nil
@@ -131,18 +133,25 @@ func isRetryableRcloneError(err error) bool {
!errors.Is(err, fs.ErrorPermissionDenied)
}
-func (r *RcloneStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileName string) error {
- ctx, cancel := context.WithTimeout(context.Background(), rcloneDeleteTimeout)
+func (r *RcloneStorage) DeleteFile(
+ ctx context.Context,
+ encryptor encryption.FieldEncryptor,
+ logger *slog.Logger,
+ fileName string,
+) error {
+ // Deletes run from cleanup paths whose caller context is often already cancelled, so the
+ // operation carries its own deadline; the caller's ctx stays for log correlation only.
+ deleteCtx, cancel := context.WithTimeout(context.Background(), rcloneDeleteTimeout)
defer cancel()
- remoteFs, err := r.getFs(ctx, encryptor)
+ remoteFs, err := r.getFs(deleteCtx, encryptor)
if err != nil {
return fmt.Errorf("failed to create rclone filesystem: %w", err)
}
filePath := r.getFilePath(fileName)
- obj, err := remoteFs.NewObject(ctx, filePath)
+ obj, err := remoteFs.NewObject(deleteCtx, filePath)
if errors.Is(err, fs.ErrorObjectNotFound) {
return nil
}
@@ -150,10 +159,12 @@ func (r *RcloneStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileName
return fmt.Errorf("failed to look up file in rclone: %w", err)
}
- if err := operations.DeleteFile(ctx, obj); err != nil {
+ if err := operations.DeleteFile(deleteCtx, obj); err != nil {
return fmt.Errorf("failed to delete file via rclone: %w", err)
}
+ logger.DebugContext(ctx, "deleted file from rclone storage", "file_name", fileName)
+
return nil
}
diff --git a/backend/internal/features/storages/models/s3/model.go b/backend/internal/features/storages/models/s3/model.go
index ed82d649..b9d054db 100644
--- a/backend/internal/features/storages/models/s3/model.go
+++ b/backend/internal/features/storages/models/s3/model.go
@@ -98,12 +98,19 @@ func (s *S3Storage) SaveFile(
client, err := s.getClient(encryptor)
if err != nil {
+ logger.ErrorContext(ctx, "failed to build the s3 client", "bucket", s.S3Bucket, "error", err)
+
return err
}
baseKey := s.buildObjectKey(fileName)
innerPartSize := s.innerPartSize()
+ startedAt := time.Now().UTC()
+
+ logger.DebugContext(ctx, "saving file to s3", "file_name", fileName,
+ "bucket", s.S3Bucket, "object_key", baseKey)
+
// Look ahead by one inner part to choose the layout. A stream that fits in a single inner part
// (WAL segments, .metadata/.manifest sidecars, small dumps, empty files) is written as one
// plain object {fileName} with no manifest, exactly as legacy backups are. Anything larger is
@@ -115,7 +122,20 @@ func (s *S3Storage) SaveFile(
}
if readErr == io.EOF || readErr == io.ErrUnexpectedEOF {
- return s.uploadSingleObject(ctx, client, baseKey, firstPart[:firstPartLen])
+ if err := s.uploadSingleObject(ctx, client, baseKey, firstPart[:firstPartLen]); err != nil {
+ logger.ErrorContext(ctx, "failed to save file to s3", "file_name", fileName,
+ "object_key", baseKey, "error", err)
+
+ return err
+ }
+
+ reportSaveToS3(
+ ctx,
+ logger,
+ savedObject{FileName: fileName, ObjectKey: baseKey, SizeBytes: int64(firstPartLen), StartedAt: startedAt},
+ )
+
+ return nil
}
// The first part filled exactly: peek one more byte to tell "stream is exactly one inner part"
@@ -127,17 +147,58 @@ func (s *S3Storage) SaveFile(
}
if peekLen == 0 {
- return s.uploadSingleObject(ctx, client, baseKey, firstPart)
+ if err := s.uploadSingleObject(ctx, client, baseKey, firstPart); err != nil {
+ logger.ErrorContext(ctx, "failed to save file to s3", "file_name", fileName,
+ "object_key", baseKey, "error", err)
+
+ return err
+ }
+
+ reportSaveToS3(
+ ctx,
+ logger,
+ savedObject{FileName: fileName, ObjectKey: baseKey, SizeBytes: int64(len(firstPart)), StartedAt: startedAt},
+ )
+
+ return nil
}
coreClient, err := s.getCoreClient(encryptor)
if err != nil {
+ logger.ErrorContext(ctx, "failed to build the s3 core client", "bucket", s.S3Bucket, "error", err)
+
return err
}
source := io.MultiReader(bytes.NewReader(firstPart), bytes.NewReader(peek[:peekLen]), file)
- return s.uploadChunked(ctx, coreClient, client, baseKey, source)
+ logger.DebugContext(ctx, "stream exceeds one part, saving to s3 as a chunked object",
+ "file_name", fileName, "object_key", baseKey)
+
+ if err := s.uploadChunked(ctx, coreClient, client, baseKey, source); err != nil {
+ logger.ErrorContext(ctx, "failed to save chunked file to s3", "file_name", fileName,
+ "object_key", baseKey, "error", err)
+
+ return err
+ }
+
+ logger.DebugContext(ctx, fmt.Sprintf("saved chunked file to s3 in %s", time.Since(startedAt)),
+ "file_name", fileName, "object_key", baseKey)
+
+ return nil
+}
+
+type savedObject struct {
+ FileName string
+ ObjectKey string
+ SizeBytes int64
+ StartedAt time.Time
+}
+
+func reportSaveToS3(ctx context.Context, logger *slog.Logger, saved savedObject) {
+ logger.DebugContext(ctx, fmt.Sprintf("saved file to s3: %.2f MB in %s",
+ float64(saved.SizeBytes)/(1024*1024), time.Since(saved.StartedAt)),
+ "file_name", saved.FileName, "object_key", saved.ObjectKey)
}
func (s *S3Storage) GetFile(
@@ -148,11 +209,15 @@ func (s *S3Storage) GetFile(
) (io.ReadCloser, error) {
coreClient, err := s.getCoreClient(encryptor)
if err != nil {
+ logger.ErrorContext(ctx, "failed to build the s3 core client", "bucket", s.S3Bucket, "error", err)
+
return nil, err
}
baseKey := s.buildObjectKey(fileName)
+ logger.DebugContext(ctx, "reading file from s3", "file_name", fileName, "object_key", baseKey)
+
manifest, hasManifest, err := s.readManifest(ctx, coreClient.Client, baseKey)
if err != nil {
return nil, err
@@ -187,7 +252,12 @@ func (s *S3Storage) GetFile(
}), nil
}
-func (s *S3Storage) DeleteFile(encryptor encryption.FieldEncryptor, fileName string) error {
+func (s *S3Storage) DeleteFile(
+ ctx context.Context,
+ encryptor encryption.FieldEncryptor,
+ logger *slog.Logger,
+ fileName string,
+) error {
client, err := s.getClient(encryptor)
if err != nil {
return err
@@ -195,10 +265,12 @@ func (s *S3Storage) DeleteFile(encryptor encryption.FieldEncryptor, fileName str
baseKey := s.buildObjectKey(fileName)
- ctx, cancel := context.WithTimeout(context.Background(), s3DeleteTimeout)
+ // Deletes run from cleanup paths whose caller context is often already cancelled, so the
+ // operation carries its own deadline; the caller's ctx stays for log correlation only.
+ deleteCtx, cancel := context.WithTimeout(context.Background(), s3DeleteTimeout)
defer cancel()
- manifest, hasManifest, err := s.readManifest(ctx, client, baseKey)
+ manifest, hasManifest, err := s.readManifest(deleteCtx, client, baseKey)
if err != nil {
return err
}
@@ -210,23 +282,34 @@ func (s *S3Storage) DeleteFile(encryptor encryption.FieldEncryptor, fileName str
}
keys = append(keys, manifestObjectKey(baseKey))
- if err := s.removeObjects(ctx, client, keys); err != nil {
+ if err := s.removeObjects(deleteCtx, client, keys); err != nil {
+ logger.WarnContext(ctx, "failed to delete chunked file from s3",
+ "file_name", fileName, "object_key", baseKey, "error", err)
+
return fmt.Errorf("failed to delete chunked backup from S3: %w", err)
}
+ logger.DebugContext(ctx, fmt.Sprintf("deleted chunked file from s3 (%d parts)", len(manifest.Parts)),
+ "file_name", fileName, "object_key", baseKey)
+
return nil
}
err = client.RemoveObject(
- ctx,
+ deleteCtx,
s.S3Bucket,
baseKey,
minio.RemoveObjectOptions{},
)
if err != nil {
+ logger.WarnContext(ctx, "failed to delete file from s3",
+ "file_name", fileName, "object_key", baseKey, "error", err)
+
return fmt.Errorf("failed to delete file from S3: %w", err)
}
+ logger.DebugContext(ctx, "deleted file from s3", "file_name", fileName, "object_key", baseKey)
+
return nil
}
diff --git a/backend/internal/features/storages/models/s3/model_test.go b/backend/internal/features/storages/models/s3/model_test.go
index 72019817..816d1849 100644
--- a/backend/internal/features/storages/models/s3/model_test.go
+++ b/backend/internal/features/storages/models/s3/model_test.go
@@ -19,6 +19,7 @@ import (
"github.com/stretchr/testify/require"
"databasus-backend/internal/util/encryption"
+ "databasus-backend/internal/util/logger"
"databasus-backend/internal/util/testing/containers"
)
@@ -44,7 +45,7 @@ func Test_DeleteFile_LegacySingleObjectWithoutManifest_RemovesObject(t *testing.
fileName := uuid.NewString()
putRawObject(t, rawClient, storage.S3Bucket, fileName, generateBytes(4096))
- require.NoError(t, storage.DeleteFile(encryptor, fileName))
+ require.NoError(t, storage.DeleteFile(t.Context(), encryptor, logger.GetLogger(), fileName))
assert.Empty(t, listObjectKeys(t, rawClient, storage.S3Bucket, fileName))
@@ -142,7 +143,7 @@ func Test_DeleteFile_ChunkedBackup_RemovesAllPartsAndManifest(t *testing.T) {
)
require.NotEmpty(t, listObjectKeys(t, rawClient, storage.S3Bucket, fileName))
- require.NoError(t, storage.DeleteFile(encryptor, fileName))
+ require.NoError(t, storage.DeleteFile(t.Context(), encryptor, logger.GetLogger(), fileName))
assert.Empty(t, listObjectKeys(t, rawClient, storage.S3Bucket, fileName))
}
@@ -196,7 +197,7 @@ func Test_SaveGetDeleteFile_ChunkedWithPrefix_RoundTripsAndCleansUp(t *testing.T
reassembledBytes := readWholeFile(t, storage, encryptor, fileName)
assert.Equal(t, persistedBytes, reassembledBytes)
- require.NoError(t, storage.DeleteFile(encryptor, fileName))
+ require.NoError(t, storage.DeleteFile(t.Context(), encryptor, logger.GetLogger(), fileName))
assert.Empty(t, listObjectKeys(t, rawClient, storage.S3Bucket, "team-a/"))
}
diff --git a/backend/internal/features/storages/models/sftp/model.go b/backend/internal/features/storages/models/sftp/model.go
index bb351334..cd5fc412 100644
--- a/backend/internal/features/storages/models/sftp/model.go
+++ b/backend/internal/features/storages/models/sftp/model.go
@@ -52,27 +52,29 @@ func (s *SFTPStorage) SaveFile(
default:
}
- logger.Info("Starting to save file to SFTP storage", "fileName", fileName, "host", s.Host)
+ logger.InfoContext(ctx, "starting to save file to SFTP storage", "file_name", fileName, "host", s.Host)
client, sshConn, err := s.connect(encryptor, sftpConnectTimeout)
if err != nil {
- logger.Error("Failed to connect to SFTP", "fileName", fileName, "error", err)
+ logger.ErrorContext(ctx, "failed to connect to SFTP", "file_name", fileName, "error", err)
return fmt.Errorf("failed to connect to SFTP: %w", err)
}
defer func() {
if closeErr := client.Close(); closeErr != nil {
- logger.Error(
- "Failed to close SFTP client",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to close SFTP client",
+ "file_name",
fileName,
"error",
closeErr,
)
}
if closeErr := sshConn.Close(); closeErr != nil {
- logger.Error(
- "Failed to close SSH connection",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to close SSH connection",
+ "file_name",
fileName,
"error",
closeErr,
@@ -82,9 +84,10 @@ func (s *SFTPStorage) SaveFile(
if s.Path != "" {
if err := s.ensureDirectory(client, s.Path); err != nil {
- logger.Error(
- "Failed to ensure directory",
- "fileName",
+ logger.ErrorContext(
+ ctx,
+ "failed to ensure directory",
+ "file_name",
fileName,
"path",
s.Path,
@@ -96,11 +99,11 @@ func (s *SFTPStorage) SaveFile(
}
filePath := s.getFilePath(fileName)
- logger.Debug("Uploading file to SFTP", "fileName", fileName, "filePath", filePath)
+ logger.DebugContext(ctx, "uploading file to SFTP", "file_name", fileName, "file_path", filePath)
remoteFile, err := client.Create(filePath)
if err != nil {
- logger.Error("Failed to create remote file", "fileName", fileName, "error", err)
+ logger.ErrorContext(ctx, "failed to create remote file", "file_name", fileName, "error", err)
return fmt.Errorf("failed to create remote file: %w", err)
}
defer func() {
@@ -113,19 +116,20 @@ func (s *SFTPStorage) SaveFile(
if err != nil {
select {
case <-ctx.Done():
- logger.Info("SFTP upload cancelled", "fileName", fileName)
+ logger.InfoContext(ctx, "SFTP upload cancelled", "file_name", fileName)
return ctx.Err()
default:
- logger.Error("Failed to upload file to SFTP", "fileName", fileName, "error", err)
+ logger.ErrorContext(ctx, "failed to upload file to SFTP", "file_name", fileName, "error", err)
return fmt.Errorf("failed to upload file to SFTP: %w", err)
}
}
- logger.Info(
- "Successfully saved file to SFTP storage",
- "fileName",
+ logger.InfoContext(
+ ctx,
+ "successfully saved file to SFTP storage",
+ "file_name",
fileName,
- "filePath",
+ "file_path",
filePath,
)
return nil
@@ -168,11 +172,18 @@ func (s *SFTPStorage) GetFile(
}), nil
}
-func (s *SFTPStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileName string) error {
- ctx, cancel := context.WithTimeout(context.Background(), sftpDeleteTimeout)
+func (s *SFTPStorage) DeleteFile(
+ ctx context.Context,
+ encryptor encryption.FieldEncryptor,
+ logger *slog.Logger,
+ fileName string,
+) error {
+ // Deletes run from cleanup paths whose caller context is often already cancelled, so the
+ // operation carries its own deadline; the caller's ctx stays for log correlation only.
+ deleteCtx, cancel := context.WithTimeout(context.Background(), sftpDeleteTimeout)
defer cancel()
- client, sshConn, err := s.connectWithContext(ctx, encryptor, sftpDeleteTimeout)
+ client, sshConn, err := s.connectWithContext(deleteCtx, encryptor, sftpDeleteTimeout)
if err != nil {
return fmt.Errorf("failed to connect to SFTP: %w", err)
}
@@ -193,6 +204,8 @@ func (s *SFTPStorage) DeleteFile(encryptor encryption.FieldEncryptor, fileName s
return fmt.Errorf("failed to delete file from SFTP: %w", err)
}
+ logger.DebugContext(ctx, "deleted file from sftp storage", "file_name", fileName)
+
return nil
}
diff --git a/backend/internal/features/storages/repository.go b/backend/internal/features/storages/repository.go
index 0dc022f1..254b856a 100644
--- a/backend/internal/features/storages/repository.go
+++ b/backend/internal/features/storages/repository.go
@@ -1,6 +1,8 @@
package storages
import (
+ "context"
+
"github.com/google/uuid"
"gorm.io/gorm"
@@ -130,11 +132,12 @@ func (r *StorageRepository) Save(storage *Storage) (*Storage, error) {
return storage, nil
}
-func (r *StorageRepository) FindByID(id uuid.UUID) (*Storage, error) {
+func (r *StorageRepository) FindByID(ctx context.Context, id uuid.UUID) (*Storage, error) {
var s Storage
if err := db.
GetDb().
+ WithContext(ctx).
Preload("LocalStorage").
Preload("S3Storage").
Preload("GoogleDriveStorage").
diff --git a/backend/internal/features/storages/service.go b/backend/internal/features/storages/service.go
index 65a05832..91b79f86 100644
--- a/backend/internal/features/storages/service.go
+++ b/backend/internal/features/storages/service.go
@@ -1,11 +1,13 @@
package storages
import (
+ "context"
"fmt"
"github.com/google/uuid"
audit_logs "databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
users_enums "databasus-backend/internal/features/users/enums"
users_models "databasus-backend/internal/features/users/models"
workspaces_services "databasus-backend/internal/features/workspaces/services"
@@ -50,7 +52,7 @@ func (s *StorageService) GetStorageAttachedDatabasesIDs(
return merged, nil
}
-func (s *StorageService) IsStorageUsing(storageID uuid.UUID) (bool, error) {
+func (s *StorageService) IsStorageInUse(ctx context.Context, storageID uuid.UUID) (bool, error) {
ids, err := s.GetStorageAttachedDatabasesIDs(storageID)
if err != nil {
return false, err
@@ -59,7 +61,7 @@ func (s *StorageService) IsStorageUsing(storageID uuid.UUID) (bool, error) {
return len(ids) > 0, nil
}
-func (s *StorageService) CountDatabasesForStorage(storageID uuid.UUID) (int, error) {
+func (s *StorageService) CountDatabasesForStorage(ctx context.Context, storageID uuid.UUID) (int, error) {
ids, err := s.GetStorageAttachedDatabasesIDs(storageID)
if err != nil {
return 0, err
@@ -84,11 +86,12 @@ func (s *StorageService) OnBeforeWorkspaceDeletion(workspaceID uuid.UUID) error
}
func (s *StorageService) SaveStorage(
+ ctx context.Context,
user *users_models.User,
workspaceID uuid.UUID,
storage *Storage,
) error {
- canManage, err := s.workspaceService.CanUserManageDBs(workspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, workspaceID, user)
if err != nil {
return err
}
@@ -103,7 +106,7 @@ func (s *StorageService) SaveStorage(
isUpdate := storage.ID != uuid.Nil
if isUpdate {
- existingStorage, err := s.storageRepository.FindByID(storage.ID)
+ existingStorage, err := s.storageRepository.FindByID(ctx, storage.ID)
if err != nil {
return err
}
@@ -130,17 +133,17 @@ func (s *StorageService) SaveStorage(
}
if oldName != existingStorage.Name {
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Storage renamed from '%s' to '%s'", oldName, existingStorage.Name),
- &user.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Storage renamed from '%s' to '%s'", oldName, existingStorage.Name),
+ UserID: &user.ID,
+ WorkspaceID: &workspaceID,
+ })
} else {
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Storage updated: %s", existingStorage.Name),
- &user.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Storage updated: %s", existingStorage.Name),
+ UserID: &user.ID,
+ WorkspaceID: &workspaceID,
+ })
}
} else {
storage.WorkspaceID = workspaceID
@@ -158,26 +161,27 @@ func (s *StorageService) SaveStorage(
return err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Storage created: %s", storage.Name),
- &user.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Storage created: %s", storage.Name),
+ UserID: &user.ID,
+ WorkspaceID: &workspaceID,
+ })
}
return nil
}
func (s *StorageService) DeleteStorage(
+ ctx context.Context,
user *users_models.User,
storageID uuid.UUID,
) error {
- storage, err := s.storageRepository.FindByID(storageID)
+ storage, err := s.storageRepository.FindByID(ctx, storageID)
if err != nil {
return err
}
- canManage, err := s.workspaceService.CanUserManageDBs(storage.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, storage.WorkspaceID, user)
if err != nil {
return err
}
@@ -198,25 +202,26 @@ func (s *StorageService) DeleteStorage(
return err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Storage deleted: %s", storage.Name),
- &user.ID,
- &storage.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Storage deleted: %s", storage.Name),
+ UserID: &user.ID,
+ WorkspaceID: &storage.WorkspaceID,
+ })
return nil
}
func (s *StorageService) GetStorage(
+ ctx context.Context,
user *users_models.User,
id uuid.UUID,
) (*Storage, error) {
- storage, err := s.storageRepository.FindByID(id)
+ storage, err := s.storageRepository.FindByID(ctx, id)
if err != nil {
return nil, err
}
- canView, _, err := s.workspaceService.CanUserAccessWorkspace(storage.WorkspaceID, user)
+ canView, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, storage.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -230,10 +235,11 @@ func (s *StorageService) GetStorage(
}
func (s *StorageService) GetStorages(
+ ctx context.Context,
user *users_models.User,
workspaceID uuid.UUID,
) ([]*Storage, error) {
- canView, _, err := s.workspaceService.CanUserAccessWorkspace(workspaceID, user)
+ canView, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, workspaceID, user)
if err != nil {
return nil, err
}
@@ -254,15 +260,16 @@ func (s *StorageService) GetStorages(
}
func (s *StorageService) TestStorageConnection(
+ ctx context.Context,
user *users_models.User,
storageID uuid.UUID,
) error {
- storage, err := s.storageRepository.FindByID(storageID)
+ storage, err := s.storageRepository.FindByID(ctx, storageID)
if err != nil {
return err
}
- canView, _, err := s.workspaceService.CanUserAccessWorkspace(storage.WorkspaceID, user)
+ canView, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, storage.WorkspaceID, user)
if err != nil {
return err
}
@@ -287,6 +294,7 @@ func (s *StorageService) TestStorageConnection(
}
func (s *StorageService) TestStorageConnectionDirect(
+ ctx context.Context,
user *users_models.User,
storage *Storage,
) error {
@@ -297,7 +305,7 @@ func (s *StorageService) TestStorageConnectionDirect(
var usingStorage *Storage
if storage.ID != uuid.Nil {
- existingStorage, err := s.storageRepository.FindByID(storage.ID)
+ existingStorage, err := s.storageRepository.FindByID(ctx, storage.ID)
if err != nil {
return err
}
@@ -321,9 +329,10 @@ func (s *StorageService) TestStorageConnectionDirect(
}
func (s *StorageService) GetStorageByID(
+ ctx context.Context,
id uuid.UUID,
) (*Storage, error) {
- return s.storageRepository.FindByID(id)
+ return s.storageRepository.FindByID(ctx, id)
}
func (s *StorageService) GetAllStorages() ([]*Storage, error) {
@@ -331,17 +340,18 @@ func (s *StorageService) GetAllStorages() ([]*Storage, error) {
}
func (s *StorageService) TransferStorageToWorkspace(
+ ctx context.Context,
user *users_models.User,
storageID uuid.UUID,
targetWorkspaceID uuid.UUID,
transferingWithDbID *uuid.UUID,
) error {
- existingStorage, err := s.storageRepository.FindByID(storageID)
+ existingStorage, err := s.storageRepository.FindByID(ctx, storageID)
if err != nil {
return err
}
- canManageSource, err := s.workspaceService.CanUserManageDBs(existingStorage.WorkspaceID, user)
+ canManageSource, err := s.workspaceService.CanUserManageDBs(ctx, existingStorage.WorkspaceID, user)
if err != nil {
return err
}
@@ -349,7 +359,7 @@ func (s *StorageService) TransferStorageToWorkspace(
return ErrInsufficientPermissionsInSourceWorkspace
}
- canManageTarget, err := s.workspaceService.CanUserManageDBs(targetWorkspaceID, user)
+ canManageTarget, err := s.workspaceService.CanUserManageDBs(ctx, targetWorkspaceID, user)
if err != nil {
return err
}
@@ -390,19 +400,25 @@ func (s *StorageService) TransferStorageToWorkspace(
return fmt.Errorf("failed to get target workspace: %w", err)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Storage transferred out: %s to workspace '%s'",
- existingStorage.Name, targetWorkspace.Name),
- &user.ID,
- &sourceWorkspaceID,
- )
-
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Storage transferred in: %s from workspace '%s'",
- existingStorage.Name, sourceWorkspace.Name),
- &user.ID,
- &targetWorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf(
+ "Storage transferred out: %s to workspace '%s'",
+ existingStorage.Name,
+ targetWorkspace.Name,
+ ),
+ UserID: &user.ID,
+ WorkspaceID: &sourceWorkspaceID,
+ })
+
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf(
+ "Storage transferred in: %s from workspace '%s'",
+ existingStorage.Name,
+ sourceWorkspace.Name,
+ ),
+ UserID: &user.ID,
+ WorkspaceID: &targetWorkspaceID,
+ })
return nil
}
diff --git a/backend/internal/features/storages/testing.go b/backend/internal/features/storages/testing.go
index eca5c6aa..b837e118 100644
--- a/backend/internal/features/storages/testing.go
+++ b/backend/internal/features/storages/testing.go
@@ -1,6 +1,8 @@
package storages
import (
+ "context"
+
"github.com/google/uuid"
local_storage "databasus-backend/internal/features/storages/models/local"
@@ -62,8 +64,12 @@ func CreateTestFlakyS3Storage(workspaceID uuid.UUID, endpoint string) *Storage {
return saved
}
-func RemoveTestStorage(id uuid.UUID) {
- storage, err := storageRepository.FindByID(id)
+// The context is stripped of cancellation because callers pass t.Context() from a t.Cleanup, and
+// the test context is already cancelled by the time cleanup runs.
+func RemoveTestStorage(ctx context.Context, id uuid.UUID) {
+ ctx = context.WithoutCancel(ctx)
+
+ storage, err := storageRepository.FindByID(ctx, id)
if err != nil {
panic(err)
}
diff --git a/backend/internal/features/system/healthcheck/controller.go b/backend/internal/features/system/healthcheck/controller.go
index 2913b5be..1f35c01e 100644
--- a/backend/internal/features/system/healthcheck/controller.go
+++ b/backend/internal/features/system/healthcheck/controller.go
@@ -35,7 +35,7 @@ func (c *HealthcheckController) CheckHealth(ctx *gin.Context) {
return
}
- err := c.healthcheckService.IsHealthy()
+ err := c.healthcheckService.IsHealthy(ctx.Request.Context())
if err == nil {
ctx.JSON(
diff --git a/backend/internal/features/system/healthcheck/di.go b/backend/internal/features/system/healthcheck/di.go
index 6ed9b4f5..e48a7f40 100644
--- a/backend/internal/features/system/healthcheck/di.go
+++ b/backend/internal/features/system/healthcheck/di.go
@@ -4,12 +4,14 @@ import (
backuping_logical "databasus-backend/internal/features/backups/backups/backuping/logical"
"databasus-backend/internal/features/disk"
verification_agents "databasus-backend/internal/features/verification/agents"
+ "databasus-backend/internal/util/logger"
)
var healthcheckService = &HealthcheckService{
disk.GetDiskService(),
backuping_logical.GetBackupsScheduler(),
verification_agents.GetAgentService(),
+ logger.GetLogger(),
}
var healthcheckController = &HealthcheckController{
diff --git a/backend/internal/features/system/healthcheck/service.go b/backend/internal/features/system/healthcheck/service.go
index 874956ef..ee809c99 100644
--- a/backend/internal/features/system/healthcheck/service.go
+++ b/backend/internal/features/system/healthcheck/service.go
@@ -4,6 +4,7 @@ import (
"context"
"errors"
"fmt"
+ "log/slog"
"strings"
"time"
@@ -20,29 +21,39 @@ type HealthcheckService struct {
diskService *disk.DiskService
backupBackgroundService *backuping_logical.BackupsScheduler
agentService *verification_agents.AgentService
+ logger *slog.Logger
}
-func (s *HealthcheckService) IsHealthy() error {
- return s.performHealthCheck()
+func (s *HealthcheckService) IsHealthy(ctx context.Context) error {
+ return s.performHealthCheck(ctx)
}
-func (s *HealthcheckService) performHealthCheck() error {
- // Check if cache is available with PING
- ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+// Each branch is a degradation the probe exists to surface. Returning the reason to the caller only
+// answers "is it healthy now"; logging it is what leaves a history to read afterwards.
+func (s *HealthcheckService) performHealthCheck(ctx context.Context) error {
+ pingCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
client := cache_utils.GetValkeyClient()
- pingResult := client.Do(ctx, client.B().Ping().Build())
+ pingResult := client.Do(pingCtx, client.B().Ping().Build())
if pingResult.Error() != nil {
+ s.logger.WarnContext(ctx, "healthcheck degraded: cannot connect to valkey",
+ "error", pingResult.Error())
+
return errors.New("cannot connect to valkey")
}
- diskUsage, err := s.diskService.GetDiskUsage()
+ diskUsage, err := s.diskService.GetDiskUsage(ctx)
if err != nil {
+ s.logger.WarnContext(ctx, "healthcheck degraded: cannot get disk usage", "error", err)
+
return errors.New("cannot get disk usage")
}
if float64(diskUsage.UsedSpaceBytes) >= float64(diskUsage.TotalSpaceBytes)*0.95 {
+ s.logger.WarnContext(ctx, fmt.Sprintf("healthcheck degraded: %.1f%% of the disk is used",
+ float64(diskUsage.UsedSpaceBytes)/float64(diskUsage.TotalSpaceBytes)*100))
+
return errors.New("more than 95% of the disk is used")
}
@@ -53,15 +64,21 @@ func (s *HealthcheckService) performHealthCheck() error {
db := storage.GetDb()
err = db.Raw("SELECT 1").Error
if err != nil {
+ s.logger.WarnContext(ctx, "healthcheck degraded: cannot connect to the database", "error", err)
+
return errors.New("cannot connect to the database")
}
if !s.backupBackgroundService.IsSchedulerRunning() {
+ s.logger.WarnContext(ctx, "healthcheck degraded: the backup scheduler has not ticked in 5 minutes")
+
return errors.New("backups are not running for more than 5 minutes")
}
staleAgents, err := s.agentService.GetStaleAgents(verification_runs.StaleAgentThreshold)
if err != nil {
+ s.logger.WarnContext(ctx, "healthcheck degraded: cannot query verification agents", "error", err)
+
return errors.New("cannot query verification agents")
}
diff --git a/backend/internal/features/telemetry/background_service.go b/backend/internal/features/telemetry/background_service.go
index 8927074d..67ea6f3c 100644
--- a/backend/internal/features/telemetry/background_service.go
+++ b/backend/internal/features/telemetry/background_service.go
@@ -8,6 +8,8 @@ import (
"sync/atomic"
"time"
+ "github.com/google/uuid"
+
"databasus-backend/internal/config"
)
@@ -17,6 +19,8 @@ const (
defaultJitter = 10 * time.Minute
defaultInitialBackoff = 1 * time.Minute
defaultMaxBackoff = 24 * time.Hour
+
+ jobName = "telemetry_ping"
)
type TelemetryBackgroundService struct {
@@ -53,7 +57,7 @@ func (s *TelemetryBackgroundService) Run(ctx context.Context) {
}
if config.GetEnv().IsDisableAnonymousTelemetry {
- s.logger.Info("anonymous telemetry is disabled")
+ s.logger.InfoContext(ctx, "anonymous telemetry is disabled")
return
}
@@ -64,16 +68,23 @@ func (s *TelemetryBackgroundService) Run(ctx context.Context) {
backoff := s.InitialBackoff
for {
+ logger := s.logger.With("job_id", uuid.New(), "job_name", jobName)
+
err := s.telemetryService.BuildAndSend(ctx)
var nextDelay time.Duration
if err != nil {
- s.logger.Warn("telemetry ping failed", "error", err, "next_retry", backoff)
nextDelay = backoff
+
+ logger.WarnContext(ctx, fmt.Sprintf("telemetry ping failed, retrying in %s", backoff),
+ "error", err)
+
backoff = min(backoff*2, s.MaxBackoff)
} else {
backoff = s.InitialBackoff
nextDelay = s.SuccessInterval + jitter(s.Jitter)
+
+ logger.InfoContext(ctx, fmt.Sprintf("telemetry ping sent, next in %s", nextDelay))
}
if !sleep(ctx, nextDelay) {
diff --git a/backend/internal/features/telemetry/dto.go b/backend/internal/features/telemetry/dto.go
index bb1438e0..ea1e5baa 100644
--- a/backend/internal/features/telemetry/dto.go
+++ b/backend/internal/features/telemetry/dto.go
@@ -1,6 +1,7 @@
package telemetry
import (
+ "context"
"time"
"github.com/google/uuid"
@@ -77,7 +78,7 @@ type userCounter interface {
}
type verificationAgentLister interface {
- ListAgents() ([]*verification_agents.Agent, error)
+ ListAgents(ctx context.Context) ([]*verification_agents.Agent, error)
}
type verificationConfigLister interface {
diff --git a/backend/internal/features/telemetry/service.go b/backend/internal/features/telemetry/service.go
index 20626e3d..68df713e 100644
--- a/backend/internal/features/telemetry/service.go
+++ b/backend/internal/features/telemetry/service.go
@@ -94,7 +94,7 @@ func (s *TelemetryService) BuildAndSend(ctx context.Context) error {
return err
}
- verificationAgents, err := s.collectVerificationAgents()
+ verificationAgents, err := s.collectVerificationAgents(ctx)
if err != nil {
return err
}
@@ -197,8 +197,8 @@ func buildVerificationEntry(
return entry
}
-func (s *TelemetryService) collectVerificationAgents() ([]VerificationAgentEntry, error) {
- listedAgents, err := s.verificationAgentService.ListAgents()
+func (s *TelemetryService) collectVerificationAgents(ctx context.Context) ([]VerificationAgentEntry, error) {
+ listedAgents, err := s.verificationAgentService.ListAgents(ctx)
if err != nil {
return nil, err
}
diff --git a/backend/internal/features/telemetry/service_test.go b/backend/internal/features/telemetry/service_test.go
index 2709b0d3..8193a6b2 100644
--- a/backend/internal/features/telemetry/service_test.go
+++ b/backend/internal/features/telemetry/service_test.go
@@ -152,7 +152,7 @@ type fakeVerificationAgentLister struct {
err error
}
-func (f *fakeVerificationAgentLister) ListAgents() ([]*verification_agents.Agent, error) {
+func (f *fakeVerificationAgentLister) ListAgents(context.Context) ([]*verification_agents.Agent, error) {
return f.agents, f.err
}
diff --git a/backend/internal/features/tests/logical/mariadb/backup_restore_test.go b/backend/internal/features/tests/logical/mariadb/backup_restore_test.go
index a5c61837..2a90741a 100644
--- a/backend/internal/features/tests/logical/mariadb/backup_restore_test.go
+++ b/backend/internal/features/tests/logical/mariadb/backup_restore_test.go
@@ -130,8 +130,8 @@ func testMariadbBackupRestoreForVersion(
setupMariadbTestData(t, container.DB)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("MariaDB Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "MariaDB Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -201,8 +201,8 @@ func testMariadbBackupRestoreForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testMariadbBackupRestoreWithEncryptionForVersion(
@@ -223,8 +223,8 @@ func testMariadbBackupRestoreWithEncryptionForVersion(
setupMariadbTestData(t, container.DB)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"MariaDB Encrypted Test Workspace",
user,
router,
@@ -299,8 +299,8 @@ func testMariadbBackupRestoreWithEncryptionForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testMariadbBackupRestoreWithReadOnlyUserForVersion(
@@ -321,8 +321,8 @@ func testMariadbBackupRestoreWithReadOnlyUserForVersion(
setupMariadbTestData(t, container.DB)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"MariaDB ReadOnly Test Workspace",
user,
router,
@@ -405,8 +405,8 @@ func testMariadbBackupRestoreWithReadOnlyUserForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func createMariadbDatabaseViaAPI(
@@ -704,8 +704,8 @@ func testMariadbBackupRestoreWithExcludeTablesForVersion(
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"MariaDB Exclude Tables Test Workspace",
user,
router,
@@ -806,8 +806,8 @@ func testMariadbBackupRestoreWithExcludeTablesForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testMariadbBackupRestoreWithExcludeEventsForVersion(
@@ -842,8 +842,8 @@ func testMariadbBackupRestoreWithExcludeEventsForVersion(
}
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"MariaDB Exclude Events Test Workspace",
user,
router,
@@ -946,6 +946,6 @@ func testMariadbBackupRestoreWithExcludeEventsForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
diff --git a/backend/internal/features/tests/logical/mariadb/sshtunnel_test.go b/backend/internal/features/tests/logical/mariadb/sshtunnel_test.go
index 689b6add..1ffe639b 100644
--- a/backend/internal/features/tests/logical/mariadb/sshtunnel_test.go
+++ b/backend/internal/features/tests/logical/mariadb/sshtunnel_test.go
@@ -1,6 +1,7 @@
package mariadb_logical
import (
+ "context"
"fmt"
"net/http"
"os"
@@ -67,12 +68,12 @@ func Test_MariadbBackupRestore_OverSshTunnel_RestoresData(t *testing.T) {
setupMariadbTestData(t, sourceConnection)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("MariaDB SSH Tunnel Workspace", user, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "MariaDB SSH Tunnel Workspace", user, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
storage := storages.CreateTestStorage(workspace.ID)
- t.Cleanup(func() { storages.RemoveTestStorage(storage.ID) })
+ t.Cleanup(func() { storages.RemoveTestStorage(t.Context(), storage.ID) })
database := logicaltesting.SubmitCreateDatabase(t, router, "MariaDB cycle over SSH tunnel",
databases.Database{
diff --git a/backend/internal/features/tests/logical/mariadb/ssl_test.go b/backend/internal/features/tests/logical/mariadb/ssl_test.go
index 0e4a1f90..e96bf68e 100644
--- a/backend/internal/features/tests/logical/mariadb/ssl_test.go
+++ b/backend/internal/features/tests/logical/mariadb/ssl_test.go
@@ -47,8 +47,8 @@ func Test_BackupAndRestoreMariadbSSL_Succeeds(t *testing.T) {
setupMariadbTestData(t, originalDB)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("MariaDB SSL Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "MariaDB SSL Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
dbName := "testdb"
@@ -95,8 +95,8 @@ func Test_BackupAndRestoreMariadbSSL_Succeeds(t *testing.T) {
t, router, "/api/v1/databases/"+database.ID.String(),
"Bearer "+user.Token, http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func createMariadbSSLDatabaseViaAPI(
diff --git a/backend/internal/features/tests/logical/mongodb/backup_restore_test.go b/backend/internal/features/tests/logical/mongodb/backup_restore_test.go
index caa659d5..d73d5fdd 100644
--- a/backend/internal/features/tests/logical/mongodb/backup_restore_test.go
+++ b/backend/internal/features/tests/logical/mongodb/backup_restore_test.go
@@ -102,8 +102,8 @@ func testMongodbBackupRestoreForVersion(
setupMongodbTestData(t, container)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("MongoDB Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "MongoDB Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -157,8 +157,8 @@ func testMongodbBackupRestoreForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testMongodbBackupRestoreWithEncryptionForVersion(
@@ -172,8 +172,8 @@ func testMongodbBackupRestoreWithEncryptionForVersion(
setupMongodbTestData(t, container)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"MongoDB Encrypted Test Workspace",
user,
router,
@@ -231,8 +231,8 @@ func testMongodbBackupRestoreWithEncryptionForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testMongodbBackupRestoreWithReadOnlyUserForVersion(
@@ -246,8 +246,8 @@ func testMongodbBackupRestoreWithReadOnlyUserForVersion(
setupMongodbTestData(t, container)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"MongoDB ReadOnly Test Workspace",
user,
router,
@@ -316,8 +316,8 @@ func testMongodbBackupRestoreWithReadOnlyUserForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testMongodbBackupRestoreWithExcludeCollectionsForVersion(
@@ -344,8 +344,8 @@ func testMongodbBackupRestoreWithExcludeCollectionsForVersion(
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"MongoDB Exclude Collections Test Workspace",
user,
router,
@@ -427,8 +427,8 @@ func testMongodbBackupRestoreWithExcludeCollectionsForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func createMongodbDatabaseViaAPI(
diff --git a/backend/internal/features/tests/logical/mongodb/sshtunnel_test.go b/backend/internal/features/tests/logical/mongodb/sshtunnel_test.go
index ffaf68bb..d0a03081 100644
--- a/backend/internal/features/tests/logical/mongodb/sshtunnel_test.go
+++ b/backend/internal/features/tests/logical/mongodb/sshtunnel_test.go
@@ -1,6 +1,7 @@
package mongodb_logical
import (
+ "context"
"net/http"
"os"
"path/filepath"
@@ -65,12 +66,12 @@ func Test_MongodbBackupRestore_OverSshTunnel_RestoresData(t *testing.T) {
setupMongodbTestData(t, sourceContainer)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("MongoDB SSH Tunnel Workspace", user, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "MongoDB SSH Tunnel Workspace", user, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
storage := storages.CreateTestStorage(workspace.ID)
- t.Cleanup(func() { storages.RemoveTestStorage(storage.ID) })
+ t.Cleanup(func() { storages.RemoveTestStorage(t.Context(), storage.ID) })
database := logicaltesting.SubmitCreateDatabase(t, router, "MongoDB cycle over SSH tunnel",
databases.Database{
diff --git a/backend/internal/features/tests/logical/mongodb/ssl_test.go b/backend/internal/features/tests/logical/mongodb/ssl_test.go
index 968082b6..f4ba3954 100644
--- a/backend/internal/features/tests/logical/mongodb/ssl_test.go
+++ b/backend/internal/features/tests/logical/mongodb/ssl_test.go
@@ -67,8 +67,8 @@ func Test_BackupAndRestoreMongodbSSL_Succeeds(t *testing.T) {
setupMongodbTestData(t, container)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("MongoDB SSL Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "MongoDB SSL Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
database := createMongodbSSLDatabaseViaAPI(
@@ -104,8 +104,8 @@ func Test_BackupAndRestoreMongodbSSL_Succeeds(t *testing.T) {
t, router, "/api/v1/databases/"+database.ID.String(),
"Bearer "+user.Token, http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func createMongodbSSLDatabaseViaAPI(
diff --git a/backend/internal/features/tests/logical/mysql/backup_restore_test.go b/backend/internal/features/tests/logical/mysql/backup_restore_test.go
index 21ef2e48..1309465f 100644
--- a/backend/internal/features/tests/logical/mysql/backup_restore_test.go
+++ b/backend/internal/features/tests/logical/mysql/backup_restore_test.go
@@ -115,8 +115,8 @@ func testMysqlBackupRestoreForVersion(t *testing.T, endpoint containers.Endpoint
setupMysqlTestData(t, container.DB)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("MySQL Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "MySQL Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -186,8 +186,8 @@ func testMysqlBackupRestoreForVersion(t *testing.T, endpoint containers.Endpoint
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testMysqlBackupRestoreWithEncryptionForVersion(
@@ -208,8 +208,8 @@ func testMysqlBackupRestoreWithEncryptionForVersion(
setupMysqlTestData(t, container.DB)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"MySQL Encrypted Test Workspace",
user,
router,
@@ -284,8 +284,8 @@ func testMysqlBackupRestoreWithEncryptionForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testMysqlBackupRestoreWithReadOnlyUserForVersion(
@@ -306,8 +306,8 @@ func testMysqlBackupRestoreWithReadOnlyUserForVersion(
setupMysqlTestData(t, container.DB)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"MySQL ReadOnly Test Workspace",
user,
router,
@@ -390,8 +390,8 @@ func testMysqlBackupRestoreWithReadOnlyUserForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testMysqlBackupRestoreWithExcludeTablesForVersion(
@@ -430,8 +430,8 @@ func testMysqlBackupRestoreWithExcludeTablesForVersion(
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"MySQL Exclude Tables Test Workspace",
user,
router,
@@ -532,8 +532,8 @@ func testMysqlBackupRestoreWithExcludeTablesForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func createMysqlDatabaseViaAPI(
diff --git a/backend/internal/features/tests/logical/mysql/sshtunnel_test.go b/backend/internal/features/tests/logical/mysql/sshtunnel_test.go
index ea11dd5e..1a313d39 100644
--- a/backend/internal/features/tests/logical/mysql/sshtunnel_test.go
+++ b/backend/internal/features/tests/logical/mysql/sshtunnel_test.go
@@ -1,6 +1,7 @@
package mysql_logical
import (
+ "context"
"fmt"
"net/http"
"os"
@@ -67,12 +68,12 @@ func Test_MysqlBackupRestore_OverSshTunnel_RestoresData(t *testing.T) {
setupMysqlTestData(t, sourceConnection)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("MySQL SSH Tunnel Workspace", user, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "MySQL SSH Tunnel Workspace", user, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
storage := storages.CreateTestStorage(workspace.ID)
- t.Cleanup(func() { storages.RemoveTestStorage(storage.ID) })
+ t.Cleanup(func() { storages.RemoveTestStorage(t.Context(), storage.ID) })
database := logicaltesting.SubmitCreateDatabase(t, router, "MySQL cycle over SSH tunnel",
databases.Database{
diff --git a/backend/internal/features/tests/logical/mysql/ssl_test.go b/backend/internal/features/tests/logical/mysql/ssl_test.go
index 910684aa..1f711b77 100644
--- a/backend/internal/features/tests/logical/mysql/ssl_test.go
+++ b/backend/internal/features/tests/logical/mysql/ssl_test.go
@@ -47,8 +47,8 @@ func Test_BackupAndRestoreMysqlSSL_Succeeds(t *testing.T) {
setupMysqlTestData(t, originalDB)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("MySQL SSL Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "MySQL SSL Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
dbName := "testdb"
@@ -95,8 +95,8 @@ func Test_BackupAndRestoreMysqlSSL_Succeeds(t *testing.T) {
t, router, "/api/v1/databases/"+database.ID.String(),
"Bearer "+user.Token, http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func createMysqlSSLDatabaseViaAPI(
diff --git a/backend/internal/features/tests/logical/postgresql/backup_restore_test.go b/backend/internal/features/tests/logical/postgresql/backup_restore_test.go
index 6c9427b7..b6a47b9b 100644
--- a/backend/internal/features/tests/logical/postgresql/backup_restore_test.go
+++ b/backend/internal/features/tests/logical/postgresql/backup_restore_test.go
@@ -204,8 +204,8 @@ func testBackupRestoreForVersion(t *testing.T, endpoint containers.Endpoint, pgV
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -285,8 +285,8 @@ func testBackupRestoreForVersion(t *testing.T, endpoint containers.Endpoint, pgV
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testSchemaSelectionAllSchemasForVersion(t *testing.T, endpoint containers.Endpoint, pgVersion string) {
@@ -322,8 +322,8 @@ func testSchemaSelectionAllSchemasForVersion(t *testing.T, endpoint containers.E
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Schema Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Schema Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -414,8 +414,8 @@ func testSchemaSelectionAllSchemasForVersion(t *testing.T, endpoint containers.E
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testBackupRestoreWithExcludeExtensionsForVersion(t *testing.T, endpoint containers.Endpoint, pgVersion string) {
@@ -451,8 +451,8 @@ func testBackupRestoreWithExcludeExtensionsForVersion(t *testing.T, endpoint con
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Extension Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Extension Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -542,8 +542,8 @@ func testBackupRestoreWithExcludeExtensionsForVersion(t *testing.T, endpoint con
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
// testBackupRestoreSkipUserMappingsForVersion backs up under a role that cannot read a user
@@ -593,8 +593,8 @@ func testBackupRestoreSkipUserMappingsForVersion(t *testing.T, endpoint containe
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Skip User Mappings Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Skip User Mappings Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -668,8 +668,8 @@ func testBackupRestoreSkipUserMappingsForVersion(t *testing.T, endpoint containe
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testBackupRestoreWithoutExcludeExtensionsForVersion(
@@ -707,8 +707,8 @@ func testBackupRestoreWithoutExcludeExtensionsForVersion(
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Extension Recovery Test Workspace",
user,
router,
@@ -818,8 +818,8 @@ func testBackupRestoreWithoutExcludeExtensionsForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testBackupRestoreWithRestoreOwnershipForVersion(t *testing.T, endpoint containers.Endpoint, pgVersion string) {
@@ -855,8 +855,8 @@ func testBackupRestoreWithRestoreOwnershipForVersion(t *testing.T, endpoint cont
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Ownership Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Ownership Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -931,8 +931,8 @@ func testBackupRestoreWithRestoreOwnershipForVersion(t *testing.T, endpoint cont
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testBackupRestoreWithRestorePrivilegesForVersion(t *testing.T, endpoint containers.Endpoint, pgVersion string) {
@@ -968,8 +968,8 @@ func testBackupRestoreWithRestorePrivilegesForVersion(t *testing.T, endpoint con
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Privileges Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Privileges Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -1053,8 +1053,8 @@ func testBackupRestoreWithRestorePrivilegesForVersion(t *testing.T, endpoint con
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testBackupRestoreWithReadOnlyUserForVersion(t *testing.T, endpoint containers.Endpoint, pgVersion string) {
@@ -1075,8 +1075,8 @@ func testBackupRestoreWithReadOnlyUserForVersion(t *testing.T, endpoint containe
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("ReadOnly Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ReadOnly Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -1163,8 +1163,8 @@ func testBackupRestoreWithReadOnlyUserForVersion(t *testing.T, endpoint containe
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
// pg_dump 18.0 and 18.1 emitted wrong sequence values instead of failing when the
@@ -1211,8 +1211,8 @@ func testBackupFailsWhenUserCannotReadSequencesForVersion(
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Sequence Privileges Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Sequence Privileges Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -1262,8 +1262,8 @@ func testBackupFailsWhenUserCannotReadSequencesForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testSchemaSelectionOnlySpecifiedSchemasForVersion(
@@ -1305,8 +1305,8 @@ func testSchemaSelectionOnlySpecifiedSchemasForVersion(
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Schema Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Schema Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -1410,8 +1410,8 @@ func testSchemaSelectionOnlySpecifiedSchemasForVersion(
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testBackupRestoreWithExcludeTablesForVersion(t *testing.T, endpoint containers.Endpoint, pgVersion string) {
@@ -1446,8 +1446,8 @@ func testBackupRestoreWithExcludeTablesForVersion(t *testing.T, endpoint contain
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Exclude Tables Test Workspace",
user,
router,
@@ -1547,8 +1547,8 @@ func testBackupRestoreWithExcludeTablesForVersion(t *testing.T, endpoint contain
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testSchemasWithExcludeTablesForVersion(t *testing.T, endpoint containers.Endpoint, pgVersion string) {
@@ -1586,8 +1586,8 @@ func testSchemasWithExcludeTablesForVersion(t *testing.T, endpoint containers.En
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(),
"Schemas+Exclude Tables Workspace",
user,
router,
@@ -1700,8 +1700,8 @@ func testSchemasWithExcludeTablesForVersion(t *testing.T, endpoint containers.En
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func testBackupRestoreWithEncryptionForVersion(t *testing.T, endpoint containers.Endpoint, pgVersion string) {
@@ -1722,8 +1722,8 @@ func testBackupRestoreWithEncryptionForVersion(t *testing.T, endpoint containers
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
@@ -1801,8 +1801,8 @@ func testBackupRestoreWithEncryptionForVersion(t *testing.T, endpoint containers
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func waitForRestoreCompletion(
diff --git a/backend/internal/features/tests/logical/postgresql/mtls_test.go b/backend/internal/features/tests/logical/postgresql/mtls_test.go
index ee6a0ada..b8a098c7 100644
--- a/backend/internal/features/tests/logical/postgresql/mtls_test.go
+++ b/backend/internal/features/tests/logical/postgresql/mtls_test.go
@@ -53,8 +53,8 @@ func Test_BackupAndRestorePostgresqlMtls_Succeeds(t *testing.T) {
assert.NoError(t, err)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Postgres mTLS Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Postgres mTLS Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
dbName := "testdb"
@@ -99,8 +99,8 @@ func Test_BackupAndRestorePostgresqlMtls_Succeeds(t *testing.T) {
t, router, "/api/v1/databases/"+database.ID.String(),
"Bearer "+user.Token, http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_CreatePostgresqlMtls_WhenClientCertMissing_IsRejected(t *testing.T) {
@@ -114,9 +114,9 @@ func Test_CreatePostgresqlMtls_WhenClientCertMissing_IsRejected(t *testing.T) {
portInt := endpoint.Port
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Postgres mTLS Reject Workspace", user, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Postgres mTLS Reject Workspace", user, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
dbName := "testdb"
request := databases.Database{
diff --git a/backend/internal/features/tests/logical/postgresql/sshtunnel_test.go b/backend/internal/features/tests/logical/postgresql/sshtunnel_test.go
index 4e09976f..634395d3 100644
--- a/backend/internal/features/tests/logical/postgresql/sshtunnel_test.go
+++ b/backend/internal/features/tests/logical/postgresql/sshtunnel_test.go
@@ -1,6 +1,7 @@
package postgresql_logical
import (
+ "context"
"fmt"
"net/http"
"os"
@@ -68,12 +69,12 @@ func Test_PostgresqlBackupRestore_OverSshTunnel_RestoresData(t *testing.T) {
require.NoError(t, err)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("SSH Tunnel Cycle Workspace", user, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "SSH Tunnel Cycle Workspace", user, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
storage := storages.CreateTestStorage(workspace.ID)
- t.Cleanup(func() { storages.RemoveTestStorage(storage.ID) })
+ t.Cleanup(func() { storages.RemoveTestStorage(t.Context(), storage.ID) })
database := logicaltesting.SubmitCreateDatabase(t, router, "Postgres cycle over SSH tunnel",
databases.Database{
diff --git a/backend/internal/features/tests/logical/postgresql/ssl_test.go b/backend/internal/features/tests/logical/postgresql/ssl_test.go
index 44d27113..74deee54 100644
--- a/backend/internal/features/tests/logical/postgresql/ssl_test.go
+++ b/backend/internal/features/tests/logical/postgresql/ssl_test.go
@@ -54,8 +54,8 @@ func Test_BackupAndRestorePostgresqlSSL_Succeeds(t *testing.T) {
assert.NoError(t, err)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Postgres SSL Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Postgres SSL Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
dbName := "testdb"
@@ -102,8 +102,8 @@ func Test_BackupAndRestorePostgresqlSSL_Succeeds(t *testing.T) {
t, router, "/api/v1/databases/"+database.ID.String(),
"Bearer "+user.Token, http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func createPostgresqlSSLDatabaseViaAPI(
diff --git a/backend/internal/features/tests/logical/postgresql/timescaledb_test.go b/backend/internal/features/tests/logical/postgresql/timescaledb_test.go
index 2fef4884..2d636a8b 100644
--- a/backend/internal/features/tests/logical/postgresql/timescaledb_test.go
+++ b/backend/internal/features/tests/logical/postgresql/timescaledb_test.go
@@ -71,8 +71,8 @@ INSERT INTO public.%s (id, label) VALUES (1, 'alpha'), (2, 'beta'), (3, 'gamma')
}()
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
database := createDatabaseWithSchemasViaAPI(
@@ -137,8 +137,8 @@ INSERT INTO public.%s (id, label) VALUES (1, 'alpha'), (2, 'beta'), (3, 'gamma')
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func seedHypertableQuery(tableName string) string {
@@ -183,8 +183,8 @@ func testTimescaleBackupRestoreForCpuCount(t *testing.T, endpoint containers.End
require.Positive(t, sourceRowCount)
router := logicaltesting.CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", user, router)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", user, router)
storage := storages.CreateTestStorage(workspace.ID)
database := createDatabaseWithCpuCountViaAPI(
@@ -247,8 +247,8 @@ func testTimescaleBackupRestoreForCpuCount(t *testing.T, endpoint containers.End
"Bearer "+user.Token,
http.StatusNoContent,
)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ storages.RemoveTestStorage(t.Context(), storage.ID)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func assertHypertableRestored(t *testing.T, restoredDB *sqlx.DB, tableName string, expectedRows int) {
diff --git a/backend/internal/features/tests/logical/shared/hang.go b/backend/internal/features/tests/logical/shared/hang.go
index 462de6d5..5bd140e9 100644
--- a/backend/internal/features/tests/logical/shared/hang.go
+++ b/backend/internal/features/tests/logical/shared/hang.go
@@ -1,6 +1,7 @@
package logicaltesting
import (
+ "context"
"net/http"
"testing"
"time"
@@ -32,14 +33,14 @@ func SetupFlakyBackupTarget(
t.Helper()
router = CreateTestRouter()
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace(workspaceName, user, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), workspaceName, user, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
// The bucket deliberately does not exist on this (reachable) MinIO, so SaveFile fails at upload
// rather than at connect — that is the issue-582 path the assertion below guards.
storage := storages.CreateTestFlakyS3Storage(workspace.ID, s3Endpoint)
- t.Cleanup(func() { storages.RemoveTestStorage(storage.ID) })
+ t.Cleanup(func() { storages.RemoveTestStorage(t.Context(), storage.ID) })
return router, user.Token, workspace.ID, storage.ID
}
diff --git a/backend/internal/features/tests/physical/postgresql/shared/helpers.go b/backend/internal/features/tests/physical/postgresql/shared/helpers.go
index 3de86a30..3ba1b7f3 100644
--- a/backend/internal/features/tests/physical/postgresql/shared/helpers.go
+++ b/backend/internal/features/tests/physical/postgresql/shared/helpers.go
@@ -738,7 +738,8 @@ func createMarkerTable(t *testing.T, ctx context.Context, conn *pgx.Conn) {
_, _ = conn.Exec(context.Background(), `DROP TABLE IF EXISTS restore_marker`)
})
- _, err = conn.Exec(ctx,
+ _, err = conn.Exec(
+ ctx,
`CREATE TABLE restore_marker (phase TEXT PRIMARY KEY, payload TEXT NOT NULL)`)
require.NoError(t, err)
}
@@ -746,7 +747,8 @@ func createMarkerTable(t *testing.T, ctx context.Context, conn *pgx.Conn) {
func insertMarker(t *testing.T, ctx context.Context, conn *pgx.Conn, phase, payload string) {
t.Helper()
- _, err := conn.Exec(ctx,
+ _, err := conn.Exec(
+ ctx,
`INSERT INTO restore_marker (phase, payload) VALUES ($1, $2)`, phase, payload)
require.NoError(t, err)
}
@@ -1034,7 +1036,8 @@ func waitForMarkerOnStandby(
deadline := time.Now().UTC().Add(timeout)
for time.Now().UTC().Before(deadline) {
var exists bool
- if err := standbyConn.QueryRow(ctx,
+ if err := standbyConn.QueryRow(
+ ctx,
`SELECT EXISTS(SELECT 1 FROM restore_marker WHERE phase = $1)`, phase,
).Scan(&exists); err == nil && exists {
return
@@ -1054,7 +1057,8 @@ func PromoteStandby(t *testing.T, ctx context.Context, standbyConn *pgx.Conn) {
t.Helper()
var promoted bool
- require.NoError(t, standbyConn.QueryRow(ctx,
+ require.NoError(t, standbyConn.QueryRow(
+ ctx,
`SELECT pg_promote(wait => true, wait_seconds => 60)`).Scan(&promoted))
require.True(t, promoted, "pg_promote must finish promotion within its wait window")
diff --git a/backend/internal/features/users/controllers/e2e_test.go b/backend/internal/features/users/controllers/e2e_test.go
index 7981dff1..956e3391 100644
--- a/backend/internal/features/users/controllers/e2e_test.go
+++ b/backend/internal/features/users/controllers/e2e_test.go
@@ -1,6 +1,7 @@
package users_controllers
import (
+ "context"
"net/http"
"testing"
@@ -8,6 +9,7 @@ import (
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
users_dto "databasus-backend/internal/features/users/dto"
users_enums "databasus-backend/internal/features/users/enums"
users_middleware "databasus-backend/internal/features/users/middleware"
@@ -19,7 +21,7 @@ import (
func Test_AdminLifecycleE2E_CompletesSuccessfully(t *testing.T) {
router := createE2ETestRouter()
- users_testing.RecreateInitialAdmin()
+ users_testing.RecreateInitialAdmin(t.Context())
// 1. Set initial admin password
adminPasswordRequest := users_dto.SetAdminPasswordRequestDTO{
@@ -117,7 +119,7 @@ func Test_AdminLifecycleE2E_CompletesSuccessfully(t *testing.T) {
func Test_UserLifecycleE2E_CompletesSuccessfully(t *testing.T) {
router := createE2ETestRouter()
- users_testing.ResetSettingsToDefaults()
+ users_testing.ResetSettingsToDefaults(t.Context())
// 1. User registers
userEmail := "testuser" + uuid.New().String() + "@example.com"
@@ -252,10 +254,5 @@ func createE2ETestRouter() *gin.Engine {
type AuditLogWriterStub struct{}
-func (a *AuditLogWriterStub) WriteAuditLog(
- message string,
- userID *uuid.UUID,
- workspaceID *uuid.UUID,
-) {
- // do nothing
+func (a *AuditLogWriterStub) WriteAuditLog(context.Context, audit_logs_models.AuditEntry) {
}
diff --git a/backend/internal/features/users/controllers/management_controller.go b/backend/internal/features/users/controllers/management_controller.go
index 66b4aa29..67f90e5a 100644
--- a/backend/internal/features/users/controllers/management_controller.go
+++ b/backend/internal/features/users/controllers/management_controller.go
@@ -75,6 +75,7 @@ func (c *ManagementController) GetUsers(ctx *gin.Context) {
}
users, total, err := c.managementService.GetUsers(
+ ctx.Request.Context(),
user,
request.Limit,
request.Offset,
@@ -133,7 +134,7 @@ func (c *ManagementController) GetUserProfile(ctx *gin.Context) {
return
}
- user, err := c.managementService.GetUserProfile(userID, currentUser)
+ user, err := c.managementService.GetUserProfile(ctx.Request.Context(), userID, currentUser)
if err != nil {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
@@ -176,7 +177,7 @@ func (c *ManagementController) DeactivateUser(ctx *gin.Context) {
return
}
- if err := c.managementService.DeactivateUser(userID, currentUser); err != nil {
+ if err := c.managementService.DeactivateUser(ctx.Request.Context(), userID, currentUser); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -209,7 +210,7 @@ func (c *ManagementController) ActivateUser(ctx *gin.Context) {
return
}
- if err := c.managementService.ActivateUser(userID, currentUser); err != nil {
+ if err := c.managementService.ActivateUser(ctx.Request.Context(), userID, currentUser); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -251,7 +252,7 @@ func (c *ManagementController) ChangeUserRole(ctx *gin.Context) {
return
}
- if err := c.managementService.ChangeUserRole(userID, request.Role, currentUser); err != nil {
+ if err := c.managementService.ChangeUserRole(ctx.Request.Context(), userID, request.Role, currentUser); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
diff --git a/backend/internal/features/users/controllers/management_controller_test.go b/backend/internal/features/users/controllers/management_controller_test.go
index 3681e309..4509566c 100644
--- a/backend/internal/features/users/controllers/management_controller_test.go
+++ b/backend/internal/features/users/controllers/management_controller_test.go
@@ -25,7 +25,7 @@ func Test_GetUsersList_WhenUserIsAdmin_ReturnsUsers(t *testing.T) {
router := createManagementTestRouter()
// Create admin user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
var response users_dto.ListUsersResponseDTO
test_utils.MakeGetRequestAndUnmarshal(
@@ -45,7 +45,7 @@ func Test_GetUsersList_WhenUserIsMember_ReturnsForbidden(t *testing.T) {
router := createManagementTestRouter()
// Create member user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
resp := test_utils.MakeGetRequest(
t,
@@ -61,7 +61,7 @@ func Test_GetUsersList_WithPagination_RespectsLimits(t *testing.T) {
router := createManagementTestRouter()
// Create admin user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
var response users_dto.ListUsersResponseDTO
test_utils.MakeGetRequestAndUnmarshal(
@@ -81,7 +81,7 @@ func Test_GetUsersList_WithBeforeDateFilter_ReturnsFilteredUsers(t *testing.T) {
router := createManagementTestRouter()
// Create admin user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
// Test with beforeDate filter
beforeDate := "2024-01-01T00:00:00Z"
@@ -106,7 +106,7 @@ func Test_GetUsersList_WithInvalidDateFilter_ReturnsBadRequest(t *testing.T) {
router := createManagementTestRouter()
// Create admin user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
// Test with invalid date format
resp := test_utils.MakeGetRequest(
@@ -123,11 +123,11 @@ func Test_GetUsersList_WithSearchQuery_ReturnsFilteredUsers(t *testing.T) {
router := createManagementTestRouter()
// Create admin user and get token
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
// Create test users with specific emails and names
- user1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- user2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ user2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
// Test searching by email (partial match)
emailPart := user1.Email[:5]
@@ -198,7 +198,7 @@ func Test_GetUserProfile_WhenAccessingOwnProfile_ReturnsProfile(t *testing.T) {
router := createManagementTestRouter()
// Create member user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
var response users_dto.UserProfileResponseDTO
test_utils.MakeGetRequestAndUnmarshal(
@@ -218,8 +218,8 @@ func Test_GetUserProfile_WhenUserIsAdmin_ReturnsProfile(t *testing.T) {
router := createManagementTestRouter()
// Create both admin and regular user
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- regularUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ regularUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
var response users_dto.UserProfileResponseDTO
test_utils.MakeGetRequestAndUnmarshal(
@@ -238,8 +238,8 @@ func Test_GetUserProfile_WhenAccessingOtherUserAsMember_ReturnsForbidden(t *test
router := createManagementTestRouter()
// Create two member users
- user1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- user2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ user2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
test_utils.MakeGetRequest(
t,
@@ -254,7 +254,7 @@ func Test_GetUserProfile_WithNonExistentUser_ReturnsForbidden(t *testing.T) {
router := createManagementTestRouter()
// Create admin user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
// Try to access non-existent user
test_utils.MakeGetRequest(
@@ -270,7 +270,7 @@ func Test_GetUserProfile_WithInvalidUserID_ReturnsBadRequest(t *testing.T) {
router := createManagementTestRouter()
// Create admin user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
resp := test_utils.MakeGetRequest(
t,
@@ -286,8 +286,8 @@ func Test_DeactivateUser_WhenUserIsAdmin_UserDeactivated(t *testing.T) {
router := createManagementTestRouter()
// Create admin and target user
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- targetUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ targetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
resp := test_utils.MakePostRequest(
t,
@@ -304,8 +304,8 @@ func Test_DeactivateUser_WhenUserIsMember_ReturnsForbidden(t *testing.T) {
router := createManagementTestRouter()
// Create two member users
- user1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- user2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ user2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
test_utils.MakePostRequest(
t,
@@ -321,7 +321,7 @@ func Test_DeactivateUser_WhenDeactivatingOwnAccount_ReturnsBadRequest(t *testing
router := createManagementTestRouter()
// Create admin user
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
resp := test_utils.MakePostRequest(
t,
@@ -338,8 +338,8 @@ func Test_ActivateUser_WhenUserIsAdmin_UserActivated(t *testing.T) {
router := createManagementTestRouter()
// Create admin and target user
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- targetUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ targetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
// First deactivate the user
test_utils.MakePostRequest(
@@ -367,8 +367,8 @@ func Test_ActivateUser_WhenUserIsMember_ReturnsForbidden(t *testing.T) {
router := createManagementTestRouter()
// Create two member users
- user1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- user2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ user2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
test_utils.MakePostRequest(
t,
@@ -384,8 +384,8 @@ func Test_ChangeUserRole_WhenUserIsRootAdmin_RoleChanged(t *testing.T) {
router := createManagementTestRouter()
// Create root admin and target user
- rootAdmin := users_testing.ReacreateInitAdminAndGetAccess()
- targetUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ rootAdmin := users_testing.RecreateInitAdminAndGetAccess(t.Context())
+ targetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := users_dto.ChangeUserRoleRequestDTO{
Role: users_enums.UserRoleAdmin,
@@ -406,8 +406,8 @@ func Test_ChangeUserRole_WhenUserIsMember_ReturnsForbidden(t *testing.T) {
router := createManagementTestRouter()
// Create two member users
- user1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- user2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ user2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := users_dto.ChangeUserRoleRequestDTO{
Role: users_enums.UserRoleAdmin,
@@ -427,7 +427,7 @@ func Test_ChangeUserRole_WhenChangingOwnRole_ReturnsBadRequest(t *testing.T) {
router := createManagementTestRouter()
// Create admin user
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
request := users_dto.ChangeUserRoleRequestDTO{
Role: users_enums.UserRoleMember,
@@ -448,8 +448,8 @@ func Test_ChangeUserRole_WithInvalidRole_ReturnsBadRequest(t *testing.T) {
router := createManagementTestRouter()
// Create admin and target user
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- targetUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ targetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
// Test with invalid JSON structure containing invalid role
resp := test_utils.MakeRequest(t, router, test_utils.RequestOptions{
@@ -467,8 +467,8 @@ func Test_ChangeUserRole_WithInvalidJSON_ReturnsBadRequest(t *testing.T) {
router := createManagementTestRouter()
// Create admin and target user
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- targetUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ targetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
// Test with invalid JSON structure
resp := test_utils.MakeRequest(t, router, test_utils.RequestOptions{
@@ -487,8 +487,8 @@ func Test_ChangeUserRole_WhenRegularAdminPromotesToAdmin_ReturnsBadRequest(t *te
router := createManagementTestRouter()
// Create regular admin and target user
- regularAdmin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- targetUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ regularAdmin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ targetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := users_dto.ChangeUserRoleRequestDTO{
Role: users_enums.UserRoleAdmin,
@@ -513,8 +513,8 @@ func Test_ChangeUserRole_WhenRegularAdminDemotesAdmin_ReturnsBadRequest(t *testi
router := createManagementTestRouter()
// Create regular admin and admin target user
- regularAdmin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- adminTargetUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ regularAdmin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ adminTargetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
request := users_dto.ChangeUserRoleRequestDTO{
Role: users_enums.UserRoleMember,
@@ -539,8 +539,8 @@ func Test_DeactivateUser_WhenRegularAdminDeactivatesAdmin_ReturnsBadRequest(t *t
router := createManagementTestRouter()
// Create regular admin and admin target user
- regularAdmin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- adminTargetUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ regularAdmin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ adminTargetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
resp := test_utils.MakePostRequest(
t,
@@ -557,8 +557,8 @@ func Test_ActivateUser_WhenRegularAdminActivatesAdmin_ReturnsBadRequest(t *testi
router := createManagementTestRouter()
// Create regular admin and admin target user
- regularAdmin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- adminTargetUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ regularAdmin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ adminTargetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
resp := test_utils.MakePostRequest(
t,
@@ -575,8 +575,8 @@ func Test_ChangeUserRole_WhenRootAdminPromotesToAdmin_RoleChanged(t *testing.T)
router := createManagementTestRouter()
// Create root admin and target user
- rootAdmin := users_testing.ReacreateInitAdminAndGetAccess()
- targetUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ rootAdmin := users_testing.RecreateInitAdminAndGetAccess(t.Context())
+ targetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := users_dto.ChangeUserRoleRequestDTO{
Role: users_enums.UserRoleAdmin,
@@ -597,8 +597,8 @@ func Test_ChangeUserRole_WhenRootAdminDemotesAdmin_RoleChanged(t *testing.T) {
router := createManagementTestRouter()
// Create root admin and admin target user
- rootAdmin := users_testing.ReacreateInitAdminAndGetAccess()
- adminTargetUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ rootAdmin := users_testing.RecreateInitAdminAndGetAccess(t.Context())
+ adminTargetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
request := users_dto.ChangeUserRoleRequestDTO{
Role: users_enums.UserRoleMember,
@@ -619,8 +619,8 @@ func Test_DeactivateUser_WhenRootAdminDeactivatesAdmin_UserDeactivated(t *testin
router := createManagementTestRouter()
// Create root admin and admin target user
- rootAdmin := users_testing.ReacreateInitAdminAndGetAccess()
- adminTargetUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ rootAdmin := users_testing.RecreateInitAdminAndGetAccess(t.Context())
+ adminTargetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
resp := test_utils.MakePostRequest(
t,
@@ -637,8 +637,8 @@ func Test_ActivateUser_WhenRootAdminActivatesAdmin_UserActivated(t *testing.T) {
router := createManagementTestRouter()
// Create root admin and admin target user
- rootAdmin := users_testing.ReacreateInitAdminAndGetAccess()
- adminTargetUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ rootAdmin := users_testing.RecreateInitAdminAndGetAccess(t.Context())
+ adminTargetUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
// First deactivate the admin user
test_utils.MakePostRequest(
@@ -666,7 +666,7 @@ func Test_ChangeUserRole_WhenRootAdminChangesOwnRole_ReturnsBadRequest(t *testin
router := createManagementTestRouter()
// Create root admin
- rootAdmin := users_testing.ReacreateInitAdminAndGetAccess()
+ rootAdmin := users_testing.RecreateInitAdminAndGetAccess(t.Context())
request := users_dto.ChangeUserRoleRequestDTO{
Role: users_enums.UserRoleMember,
@@ -687,7 +687,7 @@ func Test_DeactivateUser_WhenRootAdminDeactivatesOwnAccount_ReturnsBadRequest(t
router := createManagementTestRouter()
// Create root admin
- rootAdmin := users_testing.ReacreateInitAdminAndGetAccess()
+ rootAdmin := users_testing.RecreateInitAdminAndGetAccess(t.Context())
resp := test_utils.MakePostRequest(
t,
@@ -702,13 +702,13 @@ func Test_DeactivateUser_WhenRootAdminDeactivatesOwnAccount_ReturnsBadRequest(t
func Test_InviteUserToWorkspace_MembershipReceivedAfterSignUp(t *testing.T) {
router := createInviteWorkspaceTestRouter()
- users_testing.EnableMemberInvitations()
- users_testing.EnableExternalRegistrations()
- defer users_testing.ResetSettingsToDefaults()
+ users_testing.EnableMemberInvitations(t.Context())
+ users_testing.EnableExternalRegistrations(t.Context())
+ defer users_testing.ResetSettingsToDefaults(t.Context())
// 1. Create workspace owner and workspace
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(),
"Invite Test Workspace",
owner,
router,
diff --git a/backend/internal/features/users/controllers/password_reset_test.go b/backend/internal/features/users/controllers/password_reset_test.go
index b2508cfa..071cf3d2 100644
--- a/backend/internal/features/users/controllers/password_reset_test.go
+++ b/backend/internal/features/users/controllers/password_reset_test.go
@@ -23,7 +23,7 @@ func Test_SendResetPasswordCode_WithValidEmail_CodeSent(t *testing.T) {
mockEmailSender := users_testing.NewMockEmailSender()
users_services.GetUserService().SetEmailSender(mockEmailSender)
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := users_dto.SendResetPasswordCodeRequestDTO{
Email: user.Email,
@@ -71,7 +71,7 @@ func Test_SendResetPasswordCode_WithInvitedUser_ReturnsBadRequest(t *testing.T)
mockEmailSender := users_testing.NewMockEmailSender()
users_services.GetUserService().SetEmailSender(mockEmailSender)
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
email := "invited" + uuid.New().String() + "@example.com"
inviteRequest := users_dto.InviteUserRequestDTO{
@@ -107,7 +107,7 @@ func Test_SendResetPasswordCode_WithRateLimitExceeded_ReturnsTooManyRequests(t *
mockEmailSender := users_testing.NewMockEmailSender()
users_services.GetUserService().SetEmailSender(mockEmailSender)
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := users_dto.SendResetPasswordCodeRequestDTO{
Email: user.Email,
@@ -241,7 +241,7 @@ func Test_ResetPassword_WithExpiredCode_ReturnsBadRequest(t *testing.T) {
mockEmailSender := users_testing.NewMockEmailSender()
users_services.GetUserService().SetEmailSender(mockEmailSender)
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
// Create expired reset code directly in database
code := "123456"
@@ -342,7 +342,7 @@ func Test_ResetPassword_WithWrongCode_ReturnsBadRequest(t *testing.T) {
mockEmailSender := users_testing.NewMockEmailSender()
users_services.GetUserService().SetEmailSender(mockEmailSender)
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
// Request reset code
sendCodeRequest := users_dto.SendResetPasswordCodeRequestDTO{
@@ -380,7 +380,7 @@ func Test_ResetPassword_WithInvalidNewPassword_ReturnsBadRequest(t *testing.T) {
mockEmailSender := users_testing.NewMockEmailSender()
users_services.GetUserService().SetEmailSender(mockEmailSender)
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
resetRequest := users_dto.ResetPasswordRequestDTO{
Email: user.Email,
@@ -404,7 +404,7 @@ func Test_ResetPassword_EmailSendFailure_ReturnsError(t *testing.T) {
mockEmailSender.ShouldFail = true
users_services.GetUserService().SetEmailSender(mockEmailSender)
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := users_dto.SendResetPasswordCodeRequestDTO{
Email: user.Email,
diff --git a/backend/internal/features/users/controllers/settings_controller.go b/backend/internal/features/users/controllers/settings_controller.go
index 7bf46085..54961855 100644
--- a/backend/internal/features/users/controllers/settings_controller.go
+++ b/backend/internal/features/users/controllers/settings_controller.go
@@ -36,8 +36,10 @@ func (c *SettingsController) RegisterRoutes(router *gin.RouterGroup) {
// @Failure 500 {object} map[string]string "Internal server error"
// @Router /users/settings [get]
func (c *SettingsController) GetUsersSettings(ctx *gin.Context) {
- settings, err := c.settingsService.GetSettings()
+ settings, err := c.settingsService.GetSettings(ctx.Request.Context())
if err != nil {
+ _ = ctx.Error(err)
+
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get settings"})
return
}
@@ -71,7 +73,7 @@ func (c *SettingsController) UpdateUsersSettings(ctx *gin.Context) {
return
}
- settings, err := c.settingsService.UpdateSettings(request, user)
+ settings, err := c.settingsService.UpdateSettings(ctx.Request.Context(), request, user)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
diff --git a/backend/internal/features/users/controllers/settings_controller_test.go b/backend/internal/features/users/controllers/settings_controller_test.go
index 0db8ccd5..8cbbc329 100644
--- a/backend/internal/features/users/controllers/settings_controller_test.go
+++ b/backend/internal/features/users/controllers/settings_controller_test.go
@@ -13,11 +13,11 @@ import (
)
func Test_GetUserSettings_WhenUserIsAdmin_ReturnsSettings(t *testing.T) {
- users_testing.ResetSettingsToDefaults()
+ users_testing.ResetSettingsToDefaults(t.Context())
router := createSettingsTestRouter()
// Create admin user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
var response users_models.UsersSettings
test_utils.MakeGetRequestAndUnmarshal(
@@ -36,11 +36,11 @@ func Test_GetUserSettings_WhenUserIsAdmin_ReturnsSettings(t *testing.T) {
}
func Test_GetUserSettings_WhenUserIsMember_ReturnsSettings(t *testing.T) {
- users_testing.ResetSettingsToDefaults()
+ users_testing.ResetSettingsToDefaults(t.Context())
router := createSettingsTestRouter()
// Create member user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
_ = test_utils.MakeGetRequest(
t,
@@ -52,18 +52,18 @@ func Test_GetUserSettings_WhenUserIsMember_ReturnsSettings(t *testing.T) {
}
func Test_GetUserSettings_WithoutAuth_ReturnsUnauthorized(t *testing.T) {
- users_testing.ResetSettingsToDefaults()
+ users_testing.ResetSettingsToDefaults(t.Context())
router := createSettingsTestRouter()
test_utils.MakeGetRequest(t, router, "/api/v1/users/settings", "", http.StatusUnauthorized)
}
func Test_UpdateUserSettings_WhenUserIsAdmin_SettingsUpdated(t *testing.T) {
- users_testing.ResetSettingsToDefaults()
+ users_testing.ResetSettingsToDefaults(t.Context())
router := createSettingsTestRouter()
// Create admin user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
// Update some settings
request := users_models.UsersSettings{
@@ -90,11 +90,11 @@ func Test_UpdateUserSettings_WhenUserIsAdmin_SettingsUpdated(t *testing.T) {
}
func Test_UpdateUserSettings_WithPartialData_SettingsUpdated(t *testing.T) {
- users_testing.ResetSettingsToDefaults()
+ users_testing.ResetSettingsToDefaults(t.Context())
router := createSettingsTestRouter()
// Create admin user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
// Update only one setting
request := users_models.UsersSettings{
@@ -123,11 +123,11 @@ func Test_UpdateUserSettings_WithPartialData_SettingsUpdated(t *testing.T) {
}
func Test_UpdateUserSettings_WhenUserIsMember_ReturnsForbidden(t *testing.T) {
- users_testing.ResetSettingsToDefaults()
+ users_testing.ResetSettingsToDefaults(t.Context())
router := createSettingsTestRouter()
// Create member user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := users_models.UsersSettings{
IsAllowExternalRegistrations: false,
@@ -145,11 +145,11 @@ func Test_UpdateUserSettings_WhenUserIsMember_ReturnsForbidden(t *testing.T) {
}
func Test_UpdateUserSettings_WithInvalidJSON_ReturnsBadRequest(t *testing.T) {
- users_testing.ResetSettingsToDefaults()
+ users_testing.ResetSettingsToDefaults(t.Context())
router := createSettingsTestRouter()
// Create admin user and get token
- testUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
// Test with invalid JSON structure
resp := test_utils.MakeRequest(t, router, test_utils.RequestOptions{
@@ -164,7 +164,7 @@ func Test_UpdateUserSettings_WithInvalidJSON_ReturnsBadRequest(t *testing.T) {
}
func Test_UpdateUserSettings_WithoutAuth_ReturnsUnauthorized(t *testing.T) {
- users_testing.ResetSettingsToDefaults()
+ users_testing.ResetSettingsToDefaults(t.Context())
router := createSettingsTestRouter()
request := users_models.UsersSettings{
diff --git a/backend/internal/features/users/controllers/user_controller.go b/backend/internal/features/users/controllers/user_controller.go
index cd80ca48..0f209aa8 100644
--- a/backend/internal/features/users/controllers/user_controller.go
+++ b/backend/internal/features/users/controllers/user_controller.go
@@ -84,14 +84,16 @@ func (c *UserController) SignUp(ctx *gin.Context) {
}
}
- user, err := c.userService.SignUp(&request)
+ user, err := c.userService.SignUp(ctx.Request.Context(), &request)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
- response, err := c.userService.GenerateAccessToken(user)
+ response, err := c.userService.GenerateAccessToken(ctx.Request.Context(), user)
if err != nil {
+ _ = ctx.Error(err)
+
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to generate token"})
return
}
@@ -148,7 +150,7 @@ func (c *UserController) SignIn(ctx *gin.Context) {
return
}
- response, err := c.userService.SignIn(&request)
+ response, err := c.userService.SignIn(ctx.Request.Context(), &request)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -159,7 +161,7 @@ func (c *UserController) SignIn(ctx *gin.Context) {
// Admin password endpoints
func (c *UserController) IsAdminHasPassword(ctx *gin.Context) {
- hasPassword, err := c.userService.IsRootAdminHasPassword()
+ hasPassword, err := c.userService.IsRootAdminHasPassword(ctx.Request.Context())
if err != nil {
ctx.JSON(
http.StatusInternalServerError,
@@ -178,7 +180,7 @@ func (c *UserController) SetAdminPassword(ctx *gin.Context) {
return
}
- if err := c.userService.SetRootAdminPassword(request.Password); err != nil {
+ if err := c.userService.SetRootAdminPassword(ctx.Request.Context(), request.Password); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -224,7 +226,7 @@ func (c *UserController) ChangePassword(ctx *gin.Context) {
return
}
- if err := c.userService.ChangeUserPassword(user.ID, request.NewPassword); err != nil {
+ if err := c.userService.ChangeUserPassword(ctx.Request.Context(), user.ID, request.NewPassword); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -258,7 +260,7 @@ func (c *UserController) InviteUser(ctx *gin.Context) {
return
}
- response, err := c.userService.InviteUser(&request, user)
+ response, err := c.userService.InviteUser(ctx.Request.Context(), &request, user)
if err != nil {
if errors.Is(err, users_errors.ErrInsufficientPermissionsToInviteUsers) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -288,7 +290,7 @@ func (c *UserController) GetCurrentUser(ctx *gin.Context) {
return
}
- profile := c.userService.GetCurrentUserProfile(user)
+ profile := c.userService.GetCurrentUserProfile(ctx.Request.Context(), user)
ctx.JSON(http.StatusOK, profile)
}
@@ -322,7 +324,7 @@ func (c *UserController) UpdateUserInfo(ctx *gin.Context) {
return
}
- if err := c.userService.UpdateUserInfo(user.ID, &request); err != nil {
+ if err := c.userService.UpdateUserInfo(ctx.Request.Context(), user.ID, &request); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -354,7 +356,7 @@ func (c *UserController) HandleGitHubOAuth(ctx *gin.Context) {
return
}
- response, err := c.userService.HandleGitHubOAuth(request.Code, request.RedirectUri)
+ response, err := c.userService.HandleGitHubOAuth(ctx.Request.Context(), request.Code, request.RedirectUri)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -387,7 +389,7 @@ func (c *UserController) HandleGoogleOAuth(ctx *gin.Context) {
return
}
- response, err := c.userService.HandleGoogleOAuth(request.Code, request.RedirectUri)
+ response, err := c.userService.HandleGoogleOAuth(ctx.Request.Context(), request.Code, request.RedirectUri)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -450,7 +452,7 @@ func (c *UserController) SendResetPasswordCode(ctx *gin.Context) {
return
}
- err := c.userService.SendResetPasswordCode(request.Email)
+ err := c.userService.SendResetPasswordCode(ctx.Request.Context(), request.Email)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -476,7 +478,7 @@ func (c *UserController) ResetPassword(ctx *gin.Context) {
return
}
- err := c.userService.ResetPassword(request.Email, request.Code, request.NewPassword)
+ err := c.userService.ResetPassword(ctx.Request.Context(), request.Email, request.Code, request.NewPassword)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
diff --git a/backend/internal/features/users/controllers/user_controller_test.go b/backend/internal/features/users/controllers/user_controller_test.go
index cdad166a..c11ccb32 100644
--- a/backend/internal/features/users/controllers/user_controller_test.go
+++ b/backend/internal/features/users/controllers/user_controller_test.go
@@ -233,7 +233,7 @@ func Test_SignInUser_WithInvalidJSON_ReturnsBadRequest(t *testing.T) {
func Test_CheckAdminHasPassword_WhenAdminHasNoPassword_ReturnsFalse(t *testing.T) {
router := createUserTestRouter()
- users_testing.RecreateInitialAdmin()
+ users_testing.RecreateInitialAdmin(t.Context())
var response users_dto.IsAdminHasPasswordResponseDTO
test_utils.MakeGetRequestAndUnmarshal(
@@ -251,7 +251,7 @@ func Test_CheckAdminHasPassword_WhenAdminHasNoPassword_ReturnsFalse(t *testing.T
func Test_SetAdminPassword_WithValidPassword_PasswordSet(t *testing.T) {
router := createUserTestRouter()
- users_testing.RecreateInitialAdmin()
+ users_testing.RecreateInitialAdmin(t.Context())
request := users_dto.SetAdminPasswordRequestDTO{
Password: "adminpassword123",
@@ -419,7 +419,7 @@ func Test_ChangeUserPassword_WithoutAuth_ReturnsUnauthorized(t *testing.T) {
func Test_ChangeUserPassword_WithInvalidJSON_ReturnsBadRequest(t *testing.T) {
router := createUserTestRouter()
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
// Test with invalid JSON structure
resp := test_utils.MakeRequest(t, router, test_utils.RequestOptions{
@@ -435,7 +435,7 @@ func Test_ChangeUserPassword_WithInvalidJSON_ReturnsBadRequest(t *testing.T) {
func Test_ChangeUserPassword_WithValidationErrors_ReturnsBadRequest(t *testing.T) {
router := createUserTestRouter()
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testCases := []struct {
name string
@@ -469,7 +469,7 @@ func Test_ChangeUserPassword_WithValidationErrors_ReturnsBadRequest(t *testing.T
func Test_InviteUser_WhenUserIsAdmin_UserInvited(t *testing.T) {
router := createUserTestRouter()
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
workspaceID := uuid.New()
workspaceRole := users_enums.WorkspaceRoleMember
@@ -515,19 +515,19 @@ func Test_InviteUser_WithoutAuth_ReturnsUnauthorized(t *testing.T) {
func Test_InviteUser_WithoutPermission_ReturnsForbidden(t *testing.T) {
router := createUserTestRouter()
- defer users_testing.ResetSettingsToDefaults()
+ defer users_testing.ResetSettingsToDefaults(t.Context())
- memberUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ memberUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
uniqueID := uuid.New().String()[:8]
request := users_dto.InviteUserRequestDTO{
Email: fmt.Sprintf("invited_%[email protected]", uniqueID),
}
- users_testing.DisableMemberInvitations()
+ users_testing.DisableMemberInvitations(t.Context())
settingsService := users_services.GetSettingsService()
- settings, err := settingsService.GetSettings()
+ settings, err := settingsService.GetSettings(t.Context())
assert.NoError(t, err)
if settings.IsAllowMemberInvitations {
@@ -549,7 +549,7 @@ func Test_InviteUser_WithoutPermission_ReturnsForbidden(t *testing.T) {
func Test_InviteUser_WithInvalidJSON_ReturnsBadRequest(t *testing.T) {
router := createUserTestRouter()
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
// Test with invalid JSON structure
resp := test_utils.MakeRequest(t, router, test_utils.RequestOptions{
@@ -565,7 +565,7 @@ func Test_InviteUser_WithInvalidJSON_ReturnsBadRequest(t *testing.T) {
func Test_InviteUser_WithValidationErrors_ReturnsBadRequest(t *testing.T) {
router := createUserTestRouter()
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testCases := []struct {
name string
@@ -601,7 +601,7 @@ func Test_InviteUser_WithValidationErrors_ReturnsBadRequest(t *testing.T) {
func Test_InviteUser_WithDuplicateEmail_ReturnsBadRequest(t *testing.T) {
router := createUserTestRouter()
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
email := "duplicate-invite" + uuid.New().String() + "@example.com"
request := users_dto.InviteUserRequestDTO{
@@ -632,7 +632,7 @@ func Test_InviteUser_WithDuplicateEmail_ReturnsBadRequest(t *testing.T) {
func Test_UpdateUserInfo_WithValidName_NameUpdated(t *testing.T) {
router := createUserTestRouter()
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
newName := "Updated Name"
request := users_dto.UpdateUserInfoRequestDTO{
@@ -663,7 +663,7 @@ func Test_UpdateUserInfo_WithValidName_NameUpdated(t *testing.T) {
func Test_UpdateUserInfo_WithValidEmail_EmailUpdated(t *testing.T) {
router := createUserTestRouter()
- testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ testUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
newEmail := "newemail" + uuid.New().String() + "@example.com"
request := users_dto.UpdateUserInfoRequestDTO{
@@ -694,8 +694,8 @@ func Test_UpdateUserInfo_WithValidEmail_EmailUpdated(t *testing.T) {
func Test_UpdateUserInfo_WithTakenEmail_ReturnsBadRequest(t *testing.T) {
router := createUserTestRouter()
- user1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- user2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ user2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
request := users_dto.UpdateUserInfoRequestDTO{
Email: &user2.Email,
@@ -715,7 +715,7 @@ func Test_UpdateUserInfo_WithTakenEmail_ReturnsBadRequest(t *testing.T) {
func Test_UpdateUserInfo_WhenAdminTriesToChangeEmail_ReturnsBadRequest(t *testing.T) {
router := createUserTestRouter()
- adminUser := users_testing.ReacreateInitAdminAndGetAccess()
+ adminUser := users_testing.RecreateInitAdminAndGetAccess(t.Context())
newEmail := "[email protected]"
request := users_dto.UpdateUserInfoRequestDTO{
@@ -769,6 +769,7 @@ func Test_GitHubOAuth_WithValidCode_ReturnsToken(t *testing.T) {
userService := users_services.GetUserService()
response, err := userService.HandleGitHubOAuthWithMockEndpoint(
+ t.Context(),
"test-code",
"http://localhost:3000/auth/callback",
endpoint,
@@ -824,6 +825,7 @@ func Test_GitHubOAuth_WithExistingEmail_LinksAccount(t *testing.T) {
userService := users_services.GetUserService()
response, err := userService.HandleGitHubOAuthWithMockEndpoint(
+ t.Context(),
"test-code",
"http://localhost:3000/auth/callback",
endpoint,
@@ -838,7 +840,7 @@ func Test_GitHubOAuth_WithExistingEmail_LinksAccount(t *testing.T) {
func Test_GitHubOAuth_WithInvitedUser_ActivatesUser(t *testing.T) {
router := createUserTestRouter()
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testID := uuid.New().String()[:8]
email := "invited-" + testID + "@example.com"
testOAuthID := int64(uuid.New().ID())
@@ -885,6 +887,7 @@ func Test_GitHubOAuth_WithInvitedUser_ActivatesUser(t *testing.T) {
userService := users_services.GetUserService()
response, err := userService.HandleGitHubOAuthWithMockEndpoint(
+ t.Context(),
"test-code",
"http://localhost:3000/auth/callback",
endpoint,
@@ -943,6 +946,7 @@ func Test_GitHubOAuth_WithNoPublicEmail_FetchesFromEmailsEndpoint(t *testing.T)
userService := users_services.GetUserService()
response, err := userService.HandleGitHubOAuthWithMockEndpoint(
+ t.Context(),
"test-code",
"http://localhost:3000/auth/callback",
endpoint,
@@ -956,8 +960,8 @@ func Test_GitHubOAuth_WithNoPublicEmail_FetchesFromEmailsEndpoint(t *testing.T)
}
func Test_GitHubOAuth_WhenRegistrationDisabled_ReturnsBadRequest(t *testing.T) {
- defer users_testing.ResetSettingsToDefaults()
- users_testing.DisableExternalRegistrations()
+ defer users_testing.ResetSettingsToDefaults(t.Context())
+ users_testing.DisableExternalRegistrations(t.Context())
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/login/oauth/access_token" {
@@ -989,6 +993,7 @@ func Test_GitHubOAuth_WhenRegistrationDisabled_ReturnsBadRequest(t *testing.T) {
userService := users_services.GetUserService()
response, err := userService.HandleGitHubOAuthWithMockEndpoint(
+ t.Context(),
"test-code",
"http://localhost:3000/auth/callback",
endpoint,
@@ -1034,6 +1039,7 @@ func Test_GoogleOAuth_WithValidCode_ReturnsToken(t *testing.T) {
userService := users_services.GetUserService()
response, err := userService.HandleGoogleOAuthWithMockEndpoint(
+ t.Context(),
"test-code",
"http://localhost:3000/auth/callback",
endpoint,
@@ -1088,6 +1094,7 @@ func Test_GoogleOAuth_WithExistingEmail_LinksAccount(t *testing.T) {
userService := users_services.GetUserService()
response, err := userService.HandleGoogleOAuthWithMockEndpoint(
+ t.Context(),
"test-code",
"http://localhost:3000/auth/callback",
endpoint,
@@ -1102,7 +1109,7 @@ func Test_GoogleOAuth_WithExistingEmail_LinksAccount(t *testing.T) {
func Test_GoogleOAuth_WithInvitedUser_ActivatesUser(t *testing.T) {
router := createUserTestRouter()
- adminUser := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ adminUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testID := uuid.New().String()[:8]
email := "invited-google-" + testID + "@example.com"
testOAuthID := "google-" + testID + "-789"
@@ -1148,6 +1155,7 @@ func Test_GoogleOAuth_WithInvitedUser_ActivatesUser(t *testing.T) {
userService := users_services.GetUserService()
response, err := userService.HandleGoogleOAuthWithMockEndpoint(
+ t.Context(),
"test-code",
"http://localhost:3000/auth/callback",
endpoint,
diff --git a/backend/internal/features/users/interfaces/interfaces.go b/backend/internal/features/users/interfaces/interfaces.go
index 4b606377..d1c720f7 100644
--- a/backend/internal/features/users/interfaces/interfaces.go
+++ b/backend/internal/features/users/interfaces/interfaces.go
@@ -1,11 +1,13 @@
package users_interfaces
import (
- "github.com/google/uuid"
+ "context"
+
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
)
type AuditLogWriter interface {
- WriteAuditLog(message string, userID, workspaceID *uuid.UUID)
+ WriteAuditLog(ctx context.Context, entry audit_logs_models.AuditEntry)
}
type EmailSender interface {
diff --git a/backend/internal/features/users/middleware/middleware.go b/backend/internal/features/users/middleware/middleware.go
index 43e41ced..841d689c 100644
--- a/backend/internal/features/users/middleware/middleware.go
+++ b/backend/internal/features/users/middleware/middleware.go
@@ -8,13 +8,16 @@ import (
users_enums "databasus-backend/internal/features/users/enums"
users_models "databasus-backend/internal/features/users/models"
users_services "databasus-backend/internal/features/users/services"
+ "databasus-backend/internal/util/logger"
)
-// AuthMiddleware validates JWT token and adds user to context
func AuthMiddleware(userService *users_services.UserService) gin.HandlerFunc {
return func(ctx *gin.Context) {
token := ctx.GetHeader("Authorization")
if token == "" {
+ logger.GetLogger().WarnContext(ctx.Request.Context(),
+ "rejected a request with no authorization header", "client_ip", ctx.ClientIP())
+
ctx.JSON(http.StatusUnauthorized, gin.H{"error": "Authorization token required"})
ctx.Abort()
return
@@ -25,14 +28,24 @@ func AuthMiddleware(userService *users_services.UserService) gin.HandlerFunc {
token = token[7:]
}
- user, err := userService.GetUserFromToken(token)
+ user, err := userService.GetUserFromToken(ctx.Request.Context(), token)
if err != nil {
+ logger.GetLogger().WarnContext(ctx.Request.Context(),
+ "rejected a request with an invalid token", "client_ip", ctx.ClientIP(), "error", err)
+
ctx.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid token"})
ctx.Abort()
return
}
ctx.Set("user", user)
+
+ // Puts the principal on the context the controllers already pass into services, so every
+ // downstream record carries it without a scoped logger.
+ ctx.Request = ctx.Request.WithContext(
+ logger.ContextWithUserID(ctx.Request.Context(), user.ID.String()),
+ )
+
ctx.Next()
}
}
@@ -54,6 +67,11 @@ func RequireRole(requiredRole users_enums.UserRole) gin.HandlerFunc {
}
if user.Role != requiredRole {
+ logger.GetLogger().WarnContext(ctx.Request.Context(),
+ "rejected a request from a user without the required role",
+ "user_id", user.ID, "required_role", requiredRole, "user_role", user.Role,
+ "client_ip", ctx.ClientIP())
+
ctx.JSON(http.StatusForbidden, gin.H{"error": "Insufficient permissions"})
ctx.Abort()
return
diff --git a/backend/internal/features/users/repositories/user_repository.go b/backend/internal/features/users/repositories/user_repository.go
index f4a9faf6..4218b5ca 100644
--- a/backend/internal/features/users/repositories/user_repository.go
+++ b/backend/internal/features/users/repositories/user_repository.go
@@ -1,6 +1,7 @@
package users_repositories
import (
+ "context"
"errors"
"fmt"
"time"
@@ -28,10 +29,10 @@ func (r *UserRepository) CreateUser(user *users_models.User) error {
return storage.GetDb().Create(user).Error
}
-func (r *UserRepository) GetUserByEmail(email string) (*users_models.User, error) {
+func (r *UserRepository) GetUserByEmail(ctx context.Context, email string) (*users_models.User, error) {
var user users_models.User
- if err := storage.GetDb().Where("email = ?", email).First(&user).Error; err != nil {
+ if err := storage.GetDb().WithContext(ctx).Where("email = ?", email).First(&user).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
}
@@ -42,10 +43,10 @@ func (r *UserRepository) GetUserByEmail(email string) (*users_models.User, error
return &user, nil
}
-func (r *UserRepository) GetUserByID(userID uuid.UUID) (*users_models.User, error) {
+func (r *UserRepository) GetUserByID(ctx context.Context, userID uuid.UUID) (*users_models.User, error) {
var user users_models.User
- if err := storage.GetDb().Where("id = ?", userID).First(&user).Error; err != nil {
+ if err := storage.GetDb().WithContext(ctx).Where("id = ?", userID).First(&user).Error; err != nil {
return nil, err
}
@@ -61,8 +62,8 @@ func (r *UserRepository) UpdateUserPassword(userID uuid.UUID, hashedPassword str
}).Error
}
-func (r *UserRepository) CreateInitialAdmin() error {
- admin, err := r.GetUserByEmail("admin")
+func (r *UserRepository) CreateInitialAdmin(ctx context.Context) error {
+ admin, err := r.GetUserByEmail(ctx, "admin")
if err != nil {
return fmt.Errorf("failed to get admin user: %w", err)
}
@@ -86,6 +87,7 @@ func (r *UserRepository) CreateInitialAdmin() error {
}
func (r *UserRepository) GetUsers(
+ ctx context.Context,
limit, offset int,
beforeCreatedAt *time.Time,
query string,
@@ -93,7 +95,7 @@ func (r *UserRepository) GetUsers(
var users []*users_models.User
var total int64
- countQuery := storage.GetDb().Model(&users_models.User{})
+ countQuery := storage.GetDb().WithContext(ctx).Model(&users_models.User{})
if beforeCreatedAt != nil {
countQuery = countQuery.Where("created_at < ?", *beforeCreatedAt)
}
@@ -106,7 +108,7 @@ func (r *UserRepository) GetUsers(
return nil, 0, err
}
- dataQuery := storage.GetDb().
+ dataQuery := storage.GetDb().WithContext(ctx).
Limit(limit).
Offset(offset).
Order("created_at DESC")
diff --git a/backend/internal/features/users/repositories/users_settings_repository.go b/backend/internal/features/users/repositories/users_settings_repository.go
index 2df61fb2..78d79869 100644
--- a/backend/internal/features/users/repositories/users_settings_repository.go
+++ b/backend/internal/features/users/repositories/users_settings_repository.go
@@ -1,6 +1,7 @@
package users_repositories
import (
+ "context"
"errors"
"github.com/google/uuid"
@@ -12,12 +13,11 @@ import (
type UsersSettingsRepository struct{}
-func (r *UsersSettingsRepository) GetSettings() (*user_models.UsersSettings, error) {
+func (r *UsersSettingsRepository) GetSettings(ctx context.Context) (*user_models.UsersSettings, error) {
var settings user_models.UsersSettings
- if err := storage.GetDb().First(&settings).Error; err != nil {
+ if err := storage.GetDb().WithContext(ctx).First(&settings).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
- // Create default settings if none exist
defaultSettings := &user_models.UsersSettings{
ID: uuid.New(),
IsAllowExternalRegistrations: true,
@@ -25,7 +25,7 @@ func (r *UsersSettingsRepository) GetSettings() (*user_models.UsersSettings, err
IsMemberAllowedToCreateWorkspaces: true,
}
- if createErr := storage.GetDb().Create(defaultSettings).Error; createErr != nil {
+ if createErr := storage.GetDb().WithContext(ctx).Create(defaultSettings).Error; createErr != nil {
return nil, createErr
}
@@ -37,13 +37,13 @@ func (r *UsersSettingsRepository) GetSettings() (*user_models.UsersSettings, err
return &settings, nil
}
-func (r *UsersSettingsRepository) UpdateSettings(settings *user_models.UsersSettings) error {
- existingSettings, err := r.GetSettings()
+func (r *UsersSettingsRepository) UpdateSettings(ctx context.Context, settings *user_models.UsersSettings) error {
+ existingSettings, err := r.GetSettings(ctx)
if err != nil {
return err
}
settings.ID = existingSettings.ID
- return storage.GetDb().Save(settings).Error
+ return storage.GetDb().WithContext(ctx).Save(settings).Error
}
diff --git a/backend/internal/features/users/services/di.go b/backend/internal/features/users/services/di.go
index 893f8e4d..d61937c8 100644
--- a/backend/internal/features/users/services/di.go
+++ b/backend/internal/features/users/services/di.go
@@ -4,6 +4,7 @@ import (
"databasus-backend/internal/features/email"
"databasus-backend/internal/features/encryption/secrets"
users_repositories "databasus-backend/internal/features/users/repositories"
+ "databasus-backend/internal/util/logger"
)
var userService = &UserService{
@@ -13,6 +14,7 @@ var userService = &UserService{
nil,
email.GetEmailSMTPSender(),
users_repositories.GetPasswordResetRepository(),
+ logger.GetLogger(),
}
var settingsService = &SettingsService{
diff --git a/backend/internal/features/users/services/management_service.go b/backend/internal/features/users/services/management_service.go
index b2dc09da..cd77b745 100644
--- a/backend/internal/features/users/services/management_service.go
+++ b/backend/internal/features/users/services/management_service.go
@@ -1,12 +1,14 @@
package users_services
import (
+ "context"
"errors"
"fmt"
"time"
"github.com/google/uuid"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
user_enums "databasus-backend/internal/features/users/enums"
user_interfaces "databasus-backend/internal/features/users/interfaces"
user_models "databasus-backend/internal/features/users/models"
@@ -23,6 +25,7 @@ func (s *UserManagementService) SetAuditLogWriter(writer user_interfaces.AuditLo
}
func (s *UserManagementService) GetUsers(
+ ctx context.Context,
currentUser *user_models.User,
limit, offset int,
beforeCreatedAt *time.Time,
@@ -32,10 +35,11 @@ func (s *UserManagementService) GetUsers(
return nil, 0, errors.New("insufficient permissions to list users")
}
- return s.userRepository.GetUsers(limit, offset, beforeCreatedAt, query)
+ return s.userRepository.GetUsers(ctx, limit, offset, beforeCreatedAt, query)
}
func (s *UserManagementService) GetUserProfile(
+ ctx context.Context,
userID uuid.UUID,
requestedBy *user_models.User,
) (*user_models.User, error) {
@@ -44,10 +48,11 @@ func (s *UserManagementService) GetUserProfile(
return nil, errors.New("insufficient permissions to view user profile")
}
- return s.userRepository.GetUserByID(userID)
+ return s.userRepository.GetUserByID(ctx, userID)
}
func (s *UserManagementService) DeactivateUser(
+ ctx context.Context,
userID uuid.UUID,
deactivatedBy *user_models.User,
) error {
@@ -60,7 +65,7 @@ func (s *UserManagementService) DeactivateUser(
return errors.New("cannot deactivate your own account")
}
- user, err := s.userRepository.GetUserByID(userID)
+ user, err := s.userRepository.GetUserByID(ctx, userID)
if err != nil {
return fmt.Errorf("failed to get user: %w", err)
}
@@ -75,17 +80,18 @@ func (s *UserManagementService) DeactivateUser(
}
if s.auditLogWriter != nil {
- s.auditLogWriter.WriteAuditLog(
- fmt.Sprintf("User deactivated: %s", user.Email),
- &deactivatedBy.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("User deactivated: %s", user.Email),
+ UserID: &deactivatedBy.ID,
+ WorkspaceID: nil,
+ })
}
return nil
}
func (s *UserManagementService) ActivateUser(
+ ctx context.Context,
userID uuid.UUID,
activatedBy *user_models.User,
) error {
@@ -93,7 +99,7 @@ func (s *UserManagementService) ActivateUser(
return errors.New("insufficient permissions to activate users")
}
- user, err := s.userRepository.GetUserByID(userID)
+ user, err := s.userRepository.GetUserByID(ctx, userID)
if err != nil {
return fmt.Errorf("failed to get user: %w", err)
}
@@ -108,17 +114,18 @@ func (s *UserManagementService) ActivateUser(
}
if s.auditLogWriter != nil {
- s.auditLogWriter.WriteAuditLog(
- fmt.Sprintf("User activated: %s", user.Email),
- &activatedBy.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("User activated: %s", user.Email),
+ UserID: &activatedBy.ID,
+ WorkspaceID: nil,
+ })
}
return nil
}
func (s *UserManagementService) ChangeUserRole(
+ ctx context.Context,
userID uuid.UUID,
newRole user_enums.UserRole,
changedBy *user_models.User,
@@ -137,7 +144,7 @@ func (s *UserManagementService) ChangeUserRole(
return errors.New("cannot change your own role")
}
- user, err := s.userRepository.GetUserByID(userID)
+ user, err := s.userRepository.GetUserByID(ctx, userID)
if err != nil {
return fmt.Errorf("failed to get user: %w", err)
}
@@ -155,11 +162,11 @@ func (s *UserManagementService) ChangeUserRole(
}
if s.auditLogWriter != nil {
- s.auditLogWriter.WriteAuditLog(
- fmt.Sprintf("User role changed: %s from %s to %s", user.Email, user.Role, newRole),
- &changedBy.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("User role changed: %s from %s to %s", user.Email, user.Role, newRole),
+ UserID: &changedBy.ID,
+ WorkspaceID: nil,
+ })
}
return nil
diff --git a/backend/internal/features/users/services/oauth_testing.go b/backend/internal/features/users/services/oauth_testing.go
index e5eef165..9a17ec5e 100644
--- a/backend/internal/features/users/services/oauth_testing.go
+++ b/backend/internal/features/users/services/oauth_testing.go
@@ -1,23 +1,27 @@
package users_services
import (
+ "context"
+
"golang.org/x/oauth2"
users_dto "databasus-backend/internal/features/users/dto"
)
func (s *UserService) HandleGitHubOAuthWithMockEndpoint(
+ ctx context.Context,
code, redirectUri string,
endpoint oauth2.Endpoint,
userAPIURL string,
) (*users_dto.OAuthCallbackResponseDTO, error) {
- return s.handleGitHubOAuthWithEndpoint(code, redirectUri, endpoint, userAPIURL)
+ return s.handleGitHubOAuthWithEndpoint(ctx, code, redirectUri, endpoint, userAPIURL)
}
func (s *UserService) HandleGoogleOAuthWithMockEndpoint(
+ ctx context.Context,
code, redirectUri string,
endpoint oauth2.Endpoint,
userAPIURL string,
) (*users_dto.OAuthCallbackResponseDTO, error) {
- return s.handleGoogleOAuthWithEndpoint(code, redirectUri, endpoint, userAPIURL)
+ return s.handleGoogleOAuthWithEndpoint(ctx, code, redirectUri, endpoint, userAPIURL)
}
diff --git a/backend/internal/features/users/services/settings_service.go b/backend/internal/features/users/services/settings_service.go
index 538a6fdc..957ed4db 100644
--- a/backend/internal/features/users/services/settings_service.go
+++ b/backend/internal/features/users/services/settings_service.go
@@ -1,8 +1,10 @@
package users_services
import (
+ "context"
"fmt"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
users_interfaces "databasus-backend/internal/features/users/interfaces"
users_models "databasus-backend/internal/features/users/models"
users_repositories "databasus-backend/internal/features/users/repositories"
@@ -17,11 +19,12 @@ func (s *SettingsService) SetAuditLogWriter(writer users_interfaces.AuditLogWrit
s.auditLogWriter = writer
}
-func (s *SettingsService) GetSettings() (*users_models.UsersSettings, error) {
- return s.userSettingsRepository.GetSettings()
+func (s *SettingsService) GetSettings(ctx context.Context) (*users_models.UsersSettings, error) {
+ return s.userSettingsRepository.GetSettings(ctx)
}
func (s *SettingsService) UpdateSettings(
+ ctx context.Context,
request users_models.UsersSettings,
updatedBy *users_models.User,
) (*users_models.UsersSettings, error) {
@@ -29,7 +32,7 @@ func (s *SettingsService) UpdateSettings(
return nil, fmt.Errorf("insufficient permissions to update settings")
}
- existingSettings, err := s.userSettingsRepository.GetSettings()
+ existingSettings, err := s.userSettingsRepository.GetSettings(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get current settings: %w", err)
}
@@ -64,16 +67,16 @@ func (s *SettingsService) UpdateSettings(
existingSettings.IsMemberAllowedToCreateWorkspaces = request.IsMemberAllowedToCreateWorkspaces
}
- if err := s.userSettingsRepository.UpdateSettings(existingSettings); err != nil {
+ if err := s.userSettingsRepository.UpdateSettings(ctx, existingSettings); err != nil {
return nil, fmt.Errorf("failed to update settings: %w", err)
}
for _, message := range auditLogMessages {
- s.auditLogWriter.WriteAuditLog(
- message,
- &updatedBy.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: message,
+ UserID: &updatedBy.ID,
+ WorkspaceID: nil,
+ })
}
return existingSettings, nil
diff --git a/backend/internal/features/users/services/user_services.go b/backend/internal/features/users/services/user_services.go
index 3b8a0f8e..de5cae86 100644
--- a/backend/internal/features/users/services/user_services.go
+++ b/backend/internal/features/users/services/user_services.go
@@ -7,6 +7,7 @@ import (
"errors"
"fmt"
"io"
+ "log/slog"
"net/http"
"time"
@@ -18,6 +19,7 @@ import (
"golang.org/x/oauth2/google"
"databasus-backend/internal/config"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
"databasus-backend/internal/features/encryption/secrets"
users_dto "databasus-backend/internal/features/users/dto"
users_enums "databasus-backend/internal/features/users/enums"
@@ -34,6 +36,7 @@ type UserService struct {
auditLogWriter users_interfaces.AuditLogWriter
emailSender users_interfaces.EmailSender
passwordResetRepository *users_repositories.PasswordResetRepository
+ logger *slog.Logger
}
func (s *UserService) SetAuditLogWriter(writer users_interfaces.AuditLogWriter) {
@@ -44,8 +47,8 @@ func (s *UserService) SetEmailSender(sender users_interfaces.EmailSender) {
s.emailSender = sender
}
-func (s *UserService) SignUp(request *users_dto.SignUpRequestDTO) (*users_models.User, error) {
- existingUser, err := s.userRepository.GetUserByEmail(request.Email)
+func (s *UserService) SignUp(ctx context.Context, request *users_dto.SignUpRequestDTO) (*users_models.User, error) {
+ existingUser, err := s.userRepository.GetUserByEmail(ctx, request.Email)
if err != nil {
return nil, fmt.Errorf("failed to check existing user: %w", err)
}
@@ -83,22 +86,22 @@ func (s *UserService) SignUp(request *users_dto.SignUpRequestDTO) (*users_models
}
// Fetch updated user to ensure we have the latest data
- updatedUser, err := s.userRepository.GetUserByID(existingUser.ID)
+ updatedUser, err := s.userRepository.GetUserByID(ctx, existingUser.ID)
if err != nil {
return nil, fmt.Errorf("failed to get updated user: %w", err)
}
- s.auditLogWriter.WriteAuditLog(
- fmt.Sprintf("Invited user completed registration: %s", updatedUser.Email),
- &updatedUser.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Invited user completed registration: %s", updatedUser.Email),
+ UserID: &updatedUser.ID,
+ WorkspaceID: nil,
+ })
return updatedUser, nil
}
// Get settings to check registration policy for new users
- settings, err := s.settingsService.GetSettings()
+ settings, err := s.settingsService.GetSettings(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get settings: %w", err)
}
@@ -123,20 +126,25 @@ func (s *UserService) SignUp(request *users_dto.SignUpRequestDTO) (*users_models
return nil, fmt.Errorf("failed to create user: %w", err)
}
- s.auditLogWriter.WriteAuditLog(
- fmt.Sprintf("User registered with email: %s", user.Email),
- &user.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("User registered with email: %s", user.Email),
+ UserID: &user.ID,
+ WorkspaceID: nil,
+ })
return user, nil
}
func (s *UserService) SignIn(
+ ctx context.Context,
request *users_dto.SignInRequestDTO,
) (*users_dto.SignInResponseDTO, error) {
- user, err := s.userRepository.GetUserByEmail(request.Email)
+ // Failed sign-ins are the only signal that someone is guessing credentials, so every branch that
+ // refuses one is logged. The handler's addresses are masked centrally by the log handler.
+ user, err := s.userRepository.GetUserByEmail(ctx, request.Email)
if err != nil {
+ s.logger.WarnContext(ctx, "sign-in refused: email lookup failed", "email", request.Email, "error", err)
+
return nil, errors.New("user with this email does not exist")
}
@@ -152,37 +160,48 @@ func (s *UserService) SignIn(
)
}
+ s.logger.WarnContext(ctx, "sign-in refused: no user with this email", "email", request.Email)
+
return nil, errors.New("user with this email does not exist")
}
if user.Status == users_enums.UserStatusInvited {
+ s.logger.WarnContext(ctx, "sign-in refused: the account has not completed sign-up",
+ "user_id", user.ID)
+
return nil, errors.New("user account is not passed sign up yet")
}
if user.Status != users_enums.UserStatusActive {
+ s.logger.WarnContext(ctx, "sign-in refused: the account is deactivated", "user_id", user.ID)
+
return nil, errors.New("user account is deactivated")
}
err = bcrypt.CompareHashAndPassword([]byte(*user.HashedPassword), []byte(request.Password))
if err != nil {
+ s.logger.WarnContext(ctx, "sign-in refused: incorrect password", "user_id", user.ID)
+
return nil, errors.New("password is incorrect")
}
- response, err := s.GenerateAccessToken(user)
+ s.logger.InfoContext(ctx, "user signed in", "user_id", user.ID)
+
+ response, err := s.GenerateAccessToken(ctx, user)
if err != nil {
return nil, err
}
- s.auditLogWriter.WriteAuditLog(
- fmt.Sprintf("User signed in with email: %s", user.Email),
- &user.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("User signed in with email: %s", user.Email),
+ UserID: &user.ID,
+ WorkspaceID: nil,
+ })
return response, nil
}
-func (s *UserService) GetUserFromToken(token string) (*users_models.User, error) {
+func (s *UserService) GetUserFromToken(ctx context.Context, token string) (*users_models.User, error) {
secretKey, err := s.secretKeyService.GetSecretKey()
if err != nil {
return nil, fmt.Errorf("failed to get secret key: %w", err)
@@ -209,7 +228,7 @@ func (s *UserService) GetUserFromToken(token string) (*users_models.User, error)
return nil, errors.New("invalid token claims")
}
- user, err := s.userRepository.GetUserByID(userID)
+ user, err := s.userRepository.GetUserByID(ctx, userID)
if err != nil {
return nil, err
}
@@ -239,6 +258,7 @@ func (s *UserService) GetUserFromToken(token string) (*users_models.User, error)
}
func (s *UserService) GenerateAccessToken(
+ ctx context.Context,
user *users_models.User,
) (*users_dto.SignInResponseDTO, error) {
secretKey, err := s.secretKeyService.GetSecretKey()
@@ -268,16 +288,16 @@ func (s *UserService) GenerateAccessToken(
}, nil
}
-func (s *UserService) CreateInitialAdmin() error {
- return s.userRepository.CreateInitialAdmin()
+func (s *UserService) CreateInitialAdmin(ctx context.Context) error {
+ return s.userRepository.CreateInitialAdmin(ctx)
}
func (s *UserService) GetUsersCount() (int64, error) {
return s.userRepository.GetUsersCount()
}
-func (s *UserService) IsRootAdminHasPassword() (bool, error) {
- admin, err := s.userRepository.GetUserByEmail("admin")
+func (s *UserService) IsRootAdminHasPassword(ctx context.Context) (bool, error) {
+ admin, err := s.userRepository.GetUserByEmail(ctx, "admin")
if err != nil {
return false, fmt.Errorf("failed to get admin user: %w", err)
}
@@ -289,8 +309,8 @@ func (s *UserService) IsRootAdminHasPassword() (bool, error) {
return admin.HasPassword(), nil
}
-func (s *UserService) SetRootAdminPassword(password string) error {
- admin, err := s.userRepository.GetUserByEmail("admin")
+func (s *UserService) SetRootAdminPassword(ctx context.Context, password string) error {
+ admin, err := s.userRepository.GetUserByEmail(ctx, "admin")
if err != nil {
return fmt.Errorf("failed to get admin user: %w", err)
}
@@ -313,26 +333,26 @@ func (s *UserService) SetRootAdminPassword(password string) error {
}
if s.auditLogWriter != nil {
- s.auditLogWriter.WriteAuditLog(
- "Admin password set",
- &admin.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: "Admin password set",
+ UserID: &admin.ID,
+ WorkspaceID: nil,
+ })
}
return nil
}
-func (s *UserService) ChangeUserPasswordByEmail(email, newPassword string) error {
- user, err := s.userRepository.GetUserByEmail(email)
+func (s *UserService) ChangeUserPasswordByEmail(ctx context.Context, email, newPassword string) error {
+ user, err := s.userRepository.GetUserByEmail(ctx, email)
if err != nil {
return fmt.Errorf("failed to get user: %w", err)
}
- return s.ChangeUserPassword(user.ID, newPassword)
+ return s.ChangeUserPassword(ctx, user.ID, newPassword)
}
-func (s *UserService) ChangeUserPassword(userID uuid.UUID, newPassword string) error {
+func (s *UserService) ChangeUserPassword(ctx context.Context, userID uuid.UUID, newPassword string) error {
hashedPassword, err := bcrypt.GenerateFromPassword([]byte(newPassword), bcrypt.DefaultCost)
if err != nil {
return fmt.Errorf("failed to hash new password: %w", err)
@@ -342,21 +362,22 @@ func (s *UserService) ChangeUserPassword(userID uuid.UUID, newPassword string) e
return fmt.Errorf("failed to update password: %w", err)
}
- s.auditLogWriter.WriteAuditLog(
- "Password changed",
- &userID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: "Password changed",
+ UserID: &userID,
+ WorkspaceID: nil,
+ })
return nil
}
func (s *UserService) InviteUser(
+ ctx context.Context,
request *users_dto.InviteUserRequestDTO,
invitedBy *users_models.User,
) (*users_dto.InviteUserResponseDTO, error) {
// Get settings to check permissions
- settings, err := s.settingsService.GetSettings()
+ settings, err := s.settingsService.GetSettings(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get settings: %w", err)
}
@@ -367,7 +388,7 @@ func (s *UserService) InviteUser(
}
// Check if user already exists
- existingUser, err := s.userRepository.GetUserByEmail(request.Email)
+ existingUser, err := s.userRepository.GetUserByEmail(ctx, request.Email)
if err != nil {
return nil, fmt.Errorf("failed to check existing user: %w", err)
}
@@ -394,11 +415,11 @@ func (s *UserService) InviteUser(
if request.IntendedWorkspaceID != nil {
message += " for workspace"
}
- s.auditLogWriter.WriteAuditLog(
- message,
- &invitedBy.ID,
- request.IntendedWorkspaceID,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: message,
+ UserID: &invitedBy.ID,
+ WorkspaceID: request.IntendedWorkspaceID,
+ })
return &users_dto.InviteUserResponseDTO{
ID: user.ID,
@@ -409,15 +430,16 @@ func (s *UserService) InviteUser(
}, nil
}
-func (s *UserService) GetUserByID(userID uuid.UUID) (*users_models.User, error) {
- return s.userRepository.GetUserByID(userID)
+func (s *UserService) GetUserByID(ctx context.Context, userID uuid.UUID) (*users_models.User, error) {
+ return s.userRepository.GetUserByID(ctx, userID)
}
-func (s *UserService) GetUserByEmail(email string) (*users_models.User, error) {
- return s.userRepository.GetUserByEmail(email)
+func (s *UserService) GetUserByEmail(ctx context.Context, email string) (*users_models.User, error) {
+ return s.userRepository.GetUserByEmail(ctx, email)
}
func (s *UserService) GetCurrentUserProfile(
+ ctx context.Context,
user *users_models.User,
) *users_dto.UserProfileResponseDTO {
return &users_dto.UserProfileResponseDTO{
@@ -431,10 +453,11 @@ func (s *UserService) GetCurrentUserProfile(
}
func (s *UserService) UpdateUserInfo(
+ ctx context.Context,
userID uuid.UUID,
request *users_dto.UpdateUserInfoRequestDTO,
) error {
- user, err := s.userRepository.GetUserByID(userID)
+ user, err := s.userRepository.GetUserByID(ctx, userID)
if err != nil {
return fmt.Errorf("failed to get user: %w", err)
}
@@ -447,7 +470,7 @@ func (s *UserService) UpdateUserInfo(
}
if request.Email != nil && *request.Email != user.Email {
- existingUser, err := s.userRepository.GetUserByEmail(*request.Email)
+ existingUser, err := s.userRepository.GetUserByEmail(ctx, *request.Email)
if err != nil {
return fmt.Errorf("failed to check email: %w", err)
}
@@ -476,19 +499,29 @@ func (s *UserService) UpdateUserInfo(
if len(auditMessages) > 0 {
for _, message := range auditMessages {
- s.auditLogWriter.WriteAuditLog(message, &userID, nil)
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: message,
+ UserID: &userID,
+ WorkspaceID: nil,
+ })
}
} else {
- s.auditLogWriter.WriteAuditLog("User info updated", &userID, nil)
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: "User info updated",
+ UserID: &userID,
+ WorkspaceID: nil,
+ })
}
return nil
}
func (s *UserService) HandleGitHubOAuth(
+ ctx context.Context,
code, redirectUri string,
) (*users_dto.OAuthCallbackResponseDTO, error) {
return s.handleGitHubOAuthWithEndpoint(
+ ctx,
code,
redirectUri,
github.Endpoint,
@@ -497,9 +530,11 @@ func (s *UserService) HandleGitHubOAuth(
}
func (s *UserService) HandleGoogleOAuth(
+ ctx context.Context,
code, redirectUri string,
) (*users_dto.OAuthCallbackResponseDTO, error) {
return s.handleGoogleOAuthWithEndpoint(
+ ctx,
code,
redirectUri,
google.Endpoint,
@@ -507,8 +542,8 @@ func (s *UserService) HandleGoogleOAuth(
)
}
-func (s *UserService) SendResetPasswordCode(email string) error {
- user, err := s.userRepository.GetUserByEmail(email)
+func (s *UserService) SendResetPasswordCode(ctx context.Context, email string) error {
+ user, err := s.userRepository.GetUserByEmail(ctx, email)
if err != nil {
return fmt.Errorf("failed to get user: %w", err)
}
@@ -614,18 +649,18 @@ func (s *UserService) SendResetPasswordCode(email string) error {
// Audit log
if s.auditLogWriter != nil {
- s.auditLogWriter.WriteAuditLog(
- fmt.Sprintf("Password reset code sent to: %s", user.Email),
- &user.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Password reset code sent to: %s", user.Email),
+ UserID: &user.ID,
+ WorkspaceID: nil,
+ })
}
return nil
}
-func (s *UserService) ResetPassword(email, code, newPassword string) error {
- user, err := s.userRepository.GetUserByEmail(email)
+func (s *UserService) ResetPassword(ctx context.Context, email, code, newPassword string) error {
+ user, err := s.userRepository.GetUserByEmail(ctx, email)
if err != nil {
return fmt.Errorf("failed to get user: %w", err)
}
@@ -652,23 +687,24 @@ func (s *UserService) ResetPassword(email, code, newPassword string) error {
}
// Update user password
- if err := s.ChangeUserPassword(user.ID, newPassword); err != nil {
+ if err := s.ChangeUserPassword(ctx, user.ID, newPassword); err != nil {
return fmt.Errorf("failed to update password: %w", err)
}
// Audit log
if s.auditLogWriter != nil {
- s.auditLogWriter.WriteAuditLog(
- "Password reset via email code",
- &user.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: "Password reset via email code",
+ UserID: &user.ID,
+ WorkspaceID: nil,
+ })
}
return nil
}
func (s *UserService) handleGitHubOAuthWithEndpoint(
+ ctx context.Context,
code, redirectUri string,
endpoint oauth2.Endpoint,
userAPIURL string,
@@ -683,18 +719,22 @@ func (s *UserService) handleGitHubOAuthWithEndpoint(
Scopes: []string{"user:email"},
}
- token, err := oauthConfig.Exchange(context.Background(), code)
+ token, err := oauthConfig.Exchange(ctx, code)
if err != nil {
+ s.logger.ErrorContext(ctx, "oauth code exchange failed", "error", err)
+
return nil, fmt.Errorf("failed to exchange code: %w", err)
}
- client := oauthConfig.Client(context.Background(), token)
- githubReq, err := http.NewRequestWithContext(context.Background(), "GET", userAPIURL, nil)
+ client := oauthConfig.Client(ctx, token)
+ githubReq, err := http.NewRequestWithContext(ctx, "GET", userAPIURL, nil)
if err != nil {
return nil, fmt.Errorf("failed to create user info request: %w", err)
}
resp, err := client.Do(githubReq)
if err != nil {
+ s.logger.ErrorContext(ctx, "oauth user info request failed", "error", err)
+
return nil, fmt.Errorf("failed to get user info: %w", err)
}
defer func() {
@@ -723,7 +763,7 @@ func (s *UserService) handleGitHubOAuthWithEndpoint(
email := githubUser.Email
if email == "" {
- email, err = s.fetchGitHubPrimaryEmail(client, userAPIURL)
+ email, err = s.fetchGitHubPrimaryEmail(ctx, client, userAPIURL)
if err != nil {
return nil, err
}
@@ -735,10 +775,11 @@ func (s *UserService) handleGitHubOAuthWithEndpoint(
}
oauthID := fmt.Sprintf("%d", githubUser.ID)
- return s.getOrCreateUserFromOAuth(oauthID, email, name, "github")
+ return s.getOrCreateUserFromOAuth(ctx, oauthID, email, name, "github")
}
func (s *UserService) handleGoogleOAuthWithEndpoint(
+ ctx context.Context,
code, redirectUri string,
endpoint oauth2.Endpoint,
userAPIURL string,
@@ -756,18 +797,22 @@ func (s *UserService) handleGoogleOAuthWithEndpoint(
},
}
- token, err := oauthConfig.Exchange(context.Background(), code)
+ token, err := oauthConfig.Exchange(ctx, code)
if err != nil {
+ s.logger.ErrorContext(ctx, "oauth code exchange failed", "error", err)
+
return nil, fmt.Errorf("failed to exchange code: %w", err)
}
- client := oauthConfig.Client(context.Background(), token)
- googleReq, err := http.NewRequestWithContext(context.Background(), "GET", userAPIURL, nil)
+ client := oauthConfig.Client(ctx, token)
+ googleReq, err := http.NewRequestWithContext(ctx, "GET", userAPIURL, nil)
if err != nil {
return nil, fmt.Errorf("failed to create user info request: %w", err)
}
resp, err := client.Do(googleReq)
if err != nil {
+ s.logger.ErrorContext(ctx, "oauth user info request failed", "error", err)
+
return nil, fmt.Errorf("failed to get user info: %w", err)
}
defer func() {
@@ -802,10 +847,11 @@ func (s *UserService) handleGoogleOAuthWithEndpoint(
name = "User"
}
- return s.getOrCreateUserFromOAuth(googleUser.ID, googleUser.Email, name, "google")
+ return s.getOrCreateUserFromOAuth(ctx, googleUser.ID, googleUser.Email, name, "google")
}
func (s *UserService) getOrCreateUserFromOAuth(
+ ctx context.Context,
oauthID, email, name, provider string,
) (*users_dto.OAuthCallbackResponseDTO, error) {
var existingUser *users_models.User
@@ -822,17 +868,17 @@ func (s *UserService) getOrCreateUserFromOAuth(
}
if existingUser != nil {
- tokenResponse, err := s.GenerateAccessToken(existingUser)
+ tokenResponse, err := s.GenerateAccessToken(ctx, existingUser)
if err != nil {
return nil, err
}
if s.auditLogWriter != nil {
- s.auditLogWriter.WriteAuditLog(
- fmt.Sprintf("User signed in via %s", provider),
- &existingUser.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("User signed in via %s", provider),
+ UserID: &existingUser.ID,
+ WorkspaceID: nil,
+ })
}
return &users_dto.OAuthCallbackResponseDTO{
@@ -843,7 +889,7 @@ func (s *UserService) getOrCreateUserFromOAuth(
}, nil
}
- userByEmail, err := s.userRepository.GetUserByEmail(email)
+ userByEmail, err := s.userRepository.GetUserByEmail(ctx, email)
if err != nil {
return nil, fmt.Errorf("failed to check email: %w", err)
}
@@ -871,22 +917,22 @@ func (s *UserService) getOrCreateUserFromOAuth(
return nil, fmt.Errorf("failed to link OAuth ID: %w", err)
}
- user, err := s.userRepository.GetUserByID(userByEmail.ID)
+ user, err := s.userRepository.GetUserByID(ctx, userByEmail.ID)
if err != nil {
return nil, fmt.Errorf("failed to get updated user: %w", err)
}
- tokenResponse, err := s.GenerateAccessToken(user)
+ tokenResponse, err := s.GenerateAccessToken(ctx, user)
if err != nil {
return nil, err
}
if s.auditLogWriter != nil {
- s.auditLogWriter.WriteAuditLog(
- fmt.Sprintf("%s OAuth linked to existing account", provider),
- &user.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("%s OAuth linked to existing account", provider),
+ UserID: &user.ID,
+ WorkspaceID: nil,
+ })
}
return &users_dto.OAuthCallbackResponseDTO{
@@ -897,7 +943,7 @@ func (s *UserService) getOrCreateUserFromOAuth(
}, nil
}
- settings, err := s.settingsService.GetSettings()
+ settings, err := s.settingsService.GetSettings(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get settings: %w", err)
}
@@ -931,17 +977,17 @@ func (s *UserService) getOrCreateUserFromOAuth(
return nil, fmt.Errorf("failed to create user: %w", err)
}
- tokenResponse, err := s.GenerateAccessToken(newUser)
+ tokenResponse, err := s.GenerateAccessToken(ctx, newUser)
if err != nil {
return nil, err
}
if s.auditLogWriter != nil {
- s.auditLogWriter.WriteAuditLog(
- fmt.Sprintf("User registered via %s OAuth: %s", provider, email),
- &newUser.ID,
- nil,
- )
+ s.auditLogWriter.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("User registered via %s OAuth: %s", provider, email),
+ UserID: &newUser.ID,
+ WorkspaceID: nil,
+ })
}
return &users_dto.OAuthCallbackResponseDTO{
@@ -953,6 +999,7 @@ func (s *UserService) getOrCreateUserFromOAuth(
}
func (s *UserService) fetchGitHubPrimaryEmail(
+ ctx context.Context,
client *http.Client,
userAPIURL string,
) (string, error) {
@@ -962,7 +1009,7 @@ func (s *UserService) fetchGitHubPrimaryEmail(
emailsURL = baseURL + "/user/emails"
}
- emailsReq, err := http.NewRequestWithContext(context.Background(), "GET", emailsURL, nil)
+ emailsReq, err := http.NewRequestWithContext(ctx, "GET", emailsURL, nil)
if err != nil {
return "", fmt.Errorf("failed to create user emails request: %w", err)
}
diff --git a/backend/internal/features/users/testing/settings_utils.go b/backend/internal/features/users/testing/settings_utils.go
index 53716e87..307d9393 100644
--- a/backend/internal/features/users/testing/settings_utils.go
+++ b/backend/internal/features/users/testing/settings_utils.go
@@ -1,36 +1,38 @@
package users_testing
import (
+ "context"
+
users_repositories "databasus-backend/internal/features/users/repositories"
)
-func EnableMemberInvitations() {
- updateUsersSetting("is_allow_member_invitations", true)
+func EnableMemberInvitations(ctx context.Context) {
+ updateUsersSetting(ctx, "is_allow_member_invitations", true)
}
-func DisableMemberInvitations() {
- updateUsersSetting("is_allow_member_invitations", false)
+func DisableMemberInvitations(ctx context.Context) {
+ updateUsersSetting(ctx, "is_allow_member_invitations", false)
}
-func EnableExternalRegistrations() {
- updateUsersSetting("is_allow_external_registrations", true)
+func EnableExternalRegistrations(ctx context.Context) {
+ updateUsersSetting(ctx, "is_allow_external_registrations", true)
}
-func DisableExternalRegistrations() {
- updateUsersSetting("is_allow_external_registrations", false)
+func DisableExternalRegistrations(ctx context.Context) {
+ updateUsersSetting(ctx, "is_allow_external_registrations", false)
}
-func EnableMemberWorkspaceCreation() {
- updateUsersSetting("is_member_allowed_to_create_workspaces", true)
+func EnableMemberWorkspaceCreation(ctx context.Context) {
+ updateUsersSetting(ctx, "is_member_allowed_to_create_workspaces", true)
}
-func DisableMemberWorkspaceCreation() {
- updateUsersSetting("is_member_allowed_to_create_workspaces", false)
+func DisableMemberWorkspaceCreation(ctx context.Context) {
+ updateUsersSetting(ctx, "is_member_allowed_to_create_workspaces", false)
}
-func ResetSettingsToDefaults() {
+func ResetSettingsToDefaults(ctx context.Context) {
repository := &users_repositories.UsersSettingsRepository{}
- settings, err := repository.GetSettings()
+ settings, err := repository.GetSettings(ctx)
if err != nil {
panic(err)
}
@@ -39,15 +41,15 @@ func ResetSettingsToDefaults() {
settings.IsAllowMemberInvitations = true
settings.IsMemberAllowedToCreateWorkspaces = true
- err = repository.UpdateSettings(settings)
+ err = repository.UpdateSettings(ctx, settings)
if err != nil {
panic(err)
}
}
-func updateUsersSetting(column string, value bool) {
+func updateUsersSetting(ctx context.Context, column string, value bool) {
repository := &users_repositories.UsersSettingsRepository{}
- settings, err := repository.GetSettings()
+ settings, err := repository.GetSettings(ctx)
if err != nil {
panic(err)
}
@@ -61,7 +63,7 @@ func updateUsersSetting(column string, value bool) {
settings.IsMemberAllowedToCreateWorkspaces = value
}
- err = repository.UpdateSettings(settings)
+ err = repository.UpdateSettings(ctx, settings)
if err != nil {
panic(err)
}
diff --git a/backend/internal/features/users/testing/user_utils.go b/backend/internal/features/users/testing/user_utils.go
index 6f4add2e..33873b2a 100644
--- a/backend/internal/features/users/testing/user_utils.go
+++ b/backend/internal/features/users/testing/user_utils.go
@@ -1,6 +1,7 @@
package users_testing
import (
+ "context"
"fmt"
"strings"
"time"
@@ -14,7 +15,7 @@ import (
users_services "databasus-backend/internal/features/users/services"
)
-func CreateTestUser(role users_enums.UserRole) *users_dto.SignInResponseDTO {
+func CreateTestUser(ctx context.Context, role users_enums.UserRole) *users_dto.SignInResponseDTO {
userID := uuid.New()
email := fmt.Sprintf("%s-%[email protected]", strings.ToLower(string(role)), userID.String()[:8])
@@ -36,7 +37,7 @@ func CreateTestUser(role users_enums.UserRole) *users_dto.SignInResponseDTO {
panic(err)
}
- response, err := users_services.GetUserService().GenerateAccessToken(user)
+ response, err := users_services.GetUserService().GenerateAccessToken(ctx, user)
if err != nil {
panic(err)
}
@@ -46,16 +47,16 @@ func CreateTestUser(role users_enums.UserRole) *users_dto.SignInResponseDTO {
return response
}
-func ReacreateInitAdminAndGetAccess() *users_dto.SignInResponseDTO {
- RecreateInitialAdmin()
+func RecreateInitAdminAndGetAccess(ctx context.Context) *users_dto.SignInResponseDTO {
+ RecreateInitialAdmin(ctx)
userRepository := &users_repositories.UserRepository{}
- user, err := userRepository.GetUserByEmail("admin")
+ user, err := userRepository.GetUserByEmail(ctx, "admin")
if err != nil {
panic(err)
}
- response, err := users_services.GetUserService().GenerateAccessToken(user)
+ response, err := users_services.GetUserService().GenerateAccessToken(ctx, user)
if err != nil {
panic(err)
}
@@ -63,7 +64,7 @@ func ReacreateInitAdminAndGetAccess() *users_dto.SignInResponseDTO {
return response
}
-func RecreateInitialAdmin() {
+func RecreateInitialAdmin(ctx context.Context) {
userRepository := &users_repositories.UserRepository{}
err := userRepository.RenameUserEmailForTests("admin", "admin-"+uuid.New().String())
if err != nil {
@@ -71,7 +72,7 @@ func RecreateInitialAdmin() {
}
userService := users_services.GetUserService()
- err = userService.CreateInitialAdmin()
+ err = userService.CreateInitialAdmin(ctx)
if err != nil {
panic(err)
}
diff --git a/backend/internal/features/verification/agents/agent_controller.go b/backend/internal/features/verification/agents/agent_controller.go
index c1cec932..50c9827a 100644
--- a/backend/internal/features/verification/agents/agent_controller.go
+++ b/backend/internal/features/verification/agents/agent_controller.go
@@ -45,8 +45,9 @@ func (c *AgentFacingController) Heartbeat(ctx *gin.Context) {
return
}
- seenAt, abortVerificationIDs, err := c.agentService.Heartbeat(agent, &request)
+ seenAt, abortVerificationIDs, err := c.agentService.Heartbeat(ctx.Request.Context(), agent, &request)
if err != nil {
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
diff --git a/backend/internal/features/verification/agents/agent_controller_test.go b/backend/internal/features/verification/agents/agent_controller_test.go
index 5080116d..a9b12c8a 100644
--- a/backend/internal/features/verification/agents/agent_controller_test.go
+++ b/backend/internal/features/verification/agents/agent_controller_test.go
@@ -20,7 +20,7 @@ func Test_Heartbeat_WhenTokenIsValid_UpdatesCapacityAndLastSeen(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-ok-"+uuid.New().String())
@@ -65,7 +65,7 @@ func Test_Heartbeat_TwiceUpdatesSameRow(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-twice-"+uuid.New().String())
heartbeatPath := heartbeatPathFor(createdAgent.Agent.ID)
@@ -107,7 +107,7 @@ func Test_Heartbeat_PersistsRamAsGb_NotMb(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-gb-"+uuid.New().String())
@@ -130,7 +130,7 @@ func Test_Heartbeat_WhenNoToken_ReturnsUnauthorized(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-notoken-"+uuid.New().String())
@@ -145,7 +145,7 @@ func Test_Heartbeat_WhenInvalidToken_ReturnsUnauthorized(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-bad-"+uuid.New().String())
@@ -161,7 +161,7 @@ func Test_Heartbeat_WhenUserJwtInsteadOfAgentToken_ReturnsUnauthorized(t *testin
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-jwt-"+uuid.New().String())
@@ -201,7 +201,7 @@ func Test_Heartbeat_WhenAgentIdMismatchesToken_ReturnsUnauthorized(t *testing.T)
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
agentA := CreateTestVerificationAgent(t, router, admin.Token, "hb-mix-a-"+uuid.New().String())
agentB := CreateTestVerificationAgent(t, router, admin.Token, "hb-mix-b-"+uuid.New().String())
@@ -241,7 +241,7 @@ func Test_Heartbeat_AfterRotateToken_OldTokenReturnsUnauthorized(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-rotate-"+uuid.New().String())
originalToken := createdAgent.Token
@@ -270,7 +270,7 @@ func Test_Heartbeat_AfterDelete_ReturnsUnauthorized(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-deleted-"+uuid.New().String())
@@ -292,7 +292,7 @@ func Test_Heartbeat_AfterDelete_DoesNotUpdateLastSeen(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-no-update-"+uuid.New().String())
heartbeatPath := heartbeatPathFor(createdAgent.Agent.ID)
@@ -339,7 +339,7 @@ func Test_Heartbeat_RejectsNegativeCapacity(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-neg-"+uuid.New().String())
@@ -353,7 +353,7 @@ func Test_Heartbeat_OverPerAgentRateLimit_Returns429(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-burst-"+uuid.New().String())
heartbeatPath := heartbeatPathFor(createdAgent.Agent.ID)
@@ -384,7 +384,7 @@ func Test_Heartbeat_InvalidUuidDoesNotConsumeRateLimit(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hb-garbage-"+uuid.New().String())
@@ -409,7 +409,7 @@ func Test_AdminEndpoint_WithAgentToken_ReturnsUnauthorized(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "cross-"+uuid.New().String())
diff --git a/backend/internal/features/verification/agents/controller.go b/backend/internal/features/verification/agents/controller.go
index 5eee7d98..e3fc5015 100644
--- a/backend/internal/features/verification/agents/controller.go
+++ b/backend/internal/features/verification/agents/controller.go
@@ -38,8 +38,9 @@ func (c *AgentController) RegisterRoutes(router *gin.RouterGroup) {
// @Failure 401 {object} map[string]string
// @Router /verification/agents/availability [get]
func (c *AgentController) GetAvailability(ctx *gin.Context) {
- count, err := c.agentService.CountLiveAgents()
+ count, err := c.agentService.CountLiveAgents(ctx.Request.Context())
if err != nil {
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
@@ -76,8 +77,9 @@ func (c *AgentController) CreateAgent(ctx *gin.Context) {
return
}
- response, err := c.agentService.CreateAgent(user, &request)
+ response, err := c.agentService.CreateAgent(ctx.Request.Context(), user, &request)
if err != nil {
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
@@ -96,8 +98,9 @@ func (c *AgentController) CreateAgent(ctx *gin.Context) {
// @Failure 403 {object} map[string]string
// @Router /verification/agents [get]
func (c *AgentController) ListAgents(ctx *gin.Context) {
- agents, err := c.agentService.ListAgents()
+ agents, err := c.agentService.ListAgents(ctx.Request.Context())
if err != nil {
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
@@ -131,13 +134,14 @@ func (c *AgentController) RotateToken(ctx *gin.Context) {
return
}
- token, err := c.agentService.RotateToken(user, agentID)
+ token, err := c.agentService.RotateToken(ctx.Request.Context(), user, agentID)
if err != nil {
if errors.Is(err, ErrAgentNotFound) {
ctx.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
return
}
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
@@ -171,12 +175,13 @@ func (c *AgentController) DeleteAgent(ctx *gin.Context) {
return
}
- if err := c.agentService.DeleteAgent(user, agentID); err != nil {
+ if err := c.agentService.DeleteAgent(ctx.Request.Context(), user, agentID); err != nil {
if errors.Is(err, ErrAgentNotFound) {
ctx.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
return
}
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
diff --git a/backend/internal/features/verification/agents/controller_test.go b/backend/internal/features/verification/agents/controller_test.go
index b2ca972c..8b5897ba 100644
--- a/backend/internal/features/verification/agents/controller_test.go
+++ b/backend/internal/features/verification/agents/controller_test.go
@@ -57,7 +57,7 @@ func Test_CreateAgent_WhenUserIsAdmin_AgentCreated(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
name := "test-agent-" + uuid.New().String()
var createResponse CreatedAgentResponse
@@ -97,7 +97,7 @@ func Test_CreateAgent_ResponseJSON_NeverIncludesTokenHashOrDeletedAt(t *testing.
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createResponse := test_utils.MakePostRequest(
t, router,
@@ -120,7 +120,7 @@ func Test_CreateAgent_WhenUserIsMember_ReturnsForbidden(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
test_utils.MakePostRequest(
t, router,
@@ -149,9 +149,9 @@ func Test_CreateAgent_WhenUserIsWorkspaceOwner_StillReturnsForbidden(t *testing.
cleanupAgents(t)
router := createTestRouter()
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("ws-"+uuid.New().String(), member, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws-"+uuid.New().String(), member, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
test_utils.MakePostRequest(
t, router,
@@ -166,7 +166,7 @@ func Test_ListAgents_WhenUserIsAdmin_ReturnsAll(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
CreateTestVerificationAgent(t, router, admin.Token, "agent-a-"+uuid.New().String())
CreateTestVerificationAgent(t, router, admin.Token, "agent-b-"+uuid.New().String())
@@ -186,7 +186,7 @@ func Test_ListAgents_WhenUserIsMember_ReturnsForbidden(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
test_utils.MakeGetRequest(
t, router,
@@ -213,7 +213,7 @@ func Test_RotateToken_WhenUserIsAdmin_ReturnsNewToken_InvalidatesOld(t *testing.
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "rotate-test-"+uuid.New().String())
originalToken := createdAgent.Token
@@ -246,8 +246,8 @@ func Test_RotateToken_WhenUserIsMember_ReturnsForbidden(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "rotate-forbid-"+uuid.New().String())
@@ -295,7 +295,7 @@ func Test_RotateToken_OnUnknownID_Returns404(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
test_utils.MakePostRequest(
t, router,
@@ -310,7 +310,7 @@ func Test_RotateToken_OnSoftDeletedAgent_Returns404(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "rotate-deleted-"+uuid.New().String())
@@ -334,7 +334,7 @@ func Test_DeleteAgent_WhenUserIsAdmin_RemovesFromList(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "delete-test-"+uuid.New().String())
@@ -361,8 +361,8 @@ func Test_DeleteAgent_WhenUserIsMember_ReturnsForbidden(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "delete-forbid-"+uuid.New().String())
@@ -407,7 +407,7 @@ func Test_DeleteAgent_OnUnknownID_Returns404(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
test_utils.MakeDeleteRequest(
t, router,
@@ -421,7 +421,7 @@ func Test_DeleteAgent_Twice_SecondCallReturns404(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "delete-twice-"+uuid.New().String())
@@ -453,7 +453,7 @@ func Test_ListAgents_ExcludesSoftDeletedAgents(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
keptAgent := CreateTestVerificationAgent(t, router, admin.Token, "kept-"+uuid.New().String())
deletedAgent := CreateTestVerificationAgent(t, router, admin.Token, "deleted-"+uuid.New().String())
@@ -498,7 +498,7 @@ func Test_CreateAgent_WritesAuditLog(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
name := "audit-test-" + uuid.New().String()
CreateTestVerificationAgent(t, router, admin.Token, name)
@@ -524,7 +524,7 @@ func Test_CreateAgent_TokenIsHex32(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "hex-token-"+uuid.New().String())
@@ -536,8 +536,8 @@ func Test_GetAvailability_WhenUserIsMember_ReturnsCountWithoutAgentDetails(t *te
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
CreateTestVerificationAgent(t, router, admin.Token, "avail-a-"+uuid.New().String())
CreateTestVerificationAgent(t, router, admin.Token, "avail-b-"+uuid.New().String())
@@ -566,7 +566,7 @@ func Test_GetAvailability_WhenNoAgents_ReturnsZeroAndFalse(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
var availability AvailabilityResponse
test_utils.MakeGetRequestAndUnmarshal(
@@ -597,8 +597,8 @@ func Test_GetAvailability_ExcludesSoftDeletedAgents(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
keptAgent := CreateTestVerificationAgent(t, router, admin.Token, "avail-kept-"+uuid.New().String())
deletedAgent := CreateTestVerificationAgent(t, router, admin.Token, "avail-deleted-"+uuid.New().String())
@@ -628,7 +628,7 @@ func Test_ListAgents_JSONShape_NoInternalFields(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
CreateTestVerificationAgent(t, router, admin.Token, "shape-"+uuid.New().String())
diff --git a/backend/internal/features/verification/agents/listeners.go b/backend/internal/features/verification/agents/listeners.go
index c16eb30e..6af80d65 100644
--- a/backend/internal/features/verification/agents/listeners.go
+++ b/backend/internal/features/verification/agents/listeners.go
@@ -1,7 +1,11 @@
package verification_agents
-import "github.com/google/uuid"
+import (
+ "context"
+
+ "github.com/google/uuid"
+)
type AgentHeartbeatedListener interface {
- OnAgentHeartbeated(agent *Agent, currentVerificationIDs []uuid.UUID) ([]uuid.UUID, error)
+ OnAgentHeartbeated(ctx context.Context, agent *Agent, currentVerificationIDs []uuid.UUID) ([]uuid.UUID, error)
}
diff --git a/backend/internal/features/verification/agents/middleware.go b/backend/internal/features/verification/agents/middleware.go
index af518ee6..d09027a4 100644
--- a/backend/internal/features/verification/agents/middleware.go
+++ b/backend/internal/features/verification/agents/middleware.go
@@ -25,7 +25,7 @@ func (s *AgentService) RequireAgentAuth() gin.HandlerFunc {
agentID, err := uuid.Parse(ctx.Param("agentId"))
if err != nil {
- s.logger.Warn("verification agent auth failure",
+ s.logger.WarnContext(ctx.Request.Context(), "verification agent auth failure",
"client_ip", clientIP, "reason", "invalid_uuid")
ctx.AbortWithStatusJSON(http.StatusUnauthorized,
gin.H{"error": genericAuthError})
@@ -38,10 +38,10 @@ func (s *AgentService) RequireAgentAuth() gin.HandlerFunc {
rateLimitAgentMax, rateLimitAgentWindow,
)
if rateLimitErr != nil {
- s.logger.Error("verification agent rate limit check failed",
+ s.logger.ErrorContext(ctx.Request.Context(), "verification agent rate limit check failed",
"error", rateLimitErr, "agent_id", agentID, "client_ip", clientIP)
} else if !isAllowed {
- s.logger.Warn("verification agent per-agent rate limit hit",
+ s.logger.WarnContext(ctx.Request.Context(), "verification agent per-agent rate limit hit",
"agent_id", agentID, "client_ip", clientIP)
ctx.AbortWithStatusJSON(http.StatusTooManyRequests,
gin.H{"error": "too many requests"})
@@ -52,7 +52,7 @@ func (s *AgentService) RequireAgentAuth() gin.HandlerFunc {
header := ctx.GetHeader("Authorization")
token := strings.TrimPrefix(header, "Bearer ")
if token == "" || token == header {
- s.logger.Warn("verification agent auth failure",
+ s.logger.WarnContext(ctx.Request.Context(), "verification agent auth failure",
"client_ip", clientIP, "agent_id", agentID, "reason", "missing_token")
ctx.AbortWithStatusJSON(http.StatusUnauthorized,
gin.H{"error": genericAuthError})
@@ -62,7 +62,7 @@ func (s *AgentService) RequireAgentAuth() gin.HandlerFunc {
agent, err := s.VerifyAgentCredentials(agentID, token)
if err != nil {
- s.logger.Warn("verification agent auth failure",
+ s.logger.WarnContext(ctx.Request.Context(), "verification agent auth failure",
"client_ip", clientIP, "agent_id", agentID, "reason", "invalid_credentials")
ctx.AbortWithStatusJSON(http.StatusUnauthorized,
gin.H{"error": genericAuthError})
diff --git a/backend/internal/features/verification/agents/repository.go b/backend/internal/features/verification/agents/repository.go
index 61dba724..1b83b6dc 100644
--- a/backend/internal/features/verification/agents/repository.go
+++ b/backend/internal/features/verification/agents/repository.go
@@ -1,6 +1,7 @@
package verification_agents
import (
+ "context"
"errors"
"time"
@@ -20,10 +21,10 @@ func (r *AgentRepository) Create(agent *Agent) error {
return storage.GetDb().Create(agent).Error
}
-func (r *AgentRepository) FindAll() ([]*Agent, error) {
+func (r *AgentRepository) FindAll(ctx context.Context) ([]*Agent, error) {
agents := make([]*Agent, 0)
- err := storage.GetDb().
+ err := storage.GetDb().WithContext(ctx).
Where("deleted_at IS NULL").
Order("created_at DESC").
Find(&agents).Error
@@ -31,10 +32,10 @@ func (r *AgentRepository) FindAll() ([]*Agent, error) {
return agents, err
}
-func (r *AgentRepository) CountLive() (int64, error) {
+func (r *AgentRepository) CountLive(ctx context.Context) (int64, error) {
var count int64
- err := storage.GetDb().
+ err := storage.GetDb().WithContext(ctx).
Model(&Agent{}).
Where("deleted_at IS NULL").
Count(&count).Error
diff --git a/backend/internal/features/verification/agents/service.go b/backend/internal/features/verification/agents/service.go
index c17e90f3..f13e011b 100644
--- a/backend/internal/features/verification/agents/service.go
+++ b/backend/internal/features/verification/agents/service.go
@@ -1,6 +1,7 @@
package verification_agents
import (
+ "context"
"crypto/sha256"
"crypto/subtle"
"fmt"
@@ -11,6 +12,7 @@ import (
"github.com/google/uuid"
audit_logs "databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
users_models "databasus-backend/internal/features/users/models"
cache_utils "databasus-backend/internal/util/cache"
)
@@ -29,6 +31,7 @@ func (s *AgentService) AddAgentHeartbeatedListener(listener AgentHeartbeatedList
}
func (s *AgentService) CreateAgent(
+ ctx context.Context,
user *users_models.User,
req *CreateAgentRequest,
) (*CreatedAgentResponse, error) {
@@ -46,11 +49,11 @@ func (s *AgentService) CreateAgent(
return nil, err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("verification agent created: %s", agent.Name),
- &user.ID,
- nil,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("verification agent created: %s", agent.Name),
+ UserID: &user.ID,
+ WorkspaceID: nil,
+ })
return &CreatedAgentResponse{
Agent: agent,
@@ -58,12 +61,12 @@ func (s *AgentService) CreateAgent(
}, nil
}
-func (s *AgentService) ListAgents() ([]*Agent, error) {
- return s.agentRepository.FindAll()
+func (s *AgentService) ListAgents(ctx context.Context) ([]*Agent, error) {
+ return s.agentRepository.FindAll(ctx)
}
-func (s *AgentService) CountLiveAgents() (int64, error) {
- return s.agentRepository.CountLive()
+func (s *AgentService) CountLiveAgents(ctx context.Context) (int64, error) {
+ return s.agentRepository.CountLive(ctx)
}
func (s *AgentService) GetStaleAgents(threshold time.Duration) ([]*Agent, error) {
@@ -71,6 +74,7 @@ func (s *AgentService) GetStaleAgents(threshold time.Duration) ([]*Agent, error)
}
func (s *AgentService) RotateToken(
+ ctx context.Context,
user *users_models.User,
agentID uuid.UUID,
) (string, error) {
@@ -89,16 +93,16 @@ func (s *AgentService) RotateToken(
return "", err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("verification agent token rotated: %s", agent.Name),
- &user.ID,
- nil,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("verification agent token rotated: %s", agent.Name),
+ UserID: &user.ID,
+ WorkspaceID: nil,
+ })
return plainToken, nil
}
-func (s *AgentService) DeleteAgent(user *users_models.User, agentID uuid.UUID) error {
+func (s *AgentService) DeleteAgent(ctx context.Context, user *users_models.User, agentID uuid.UUID) error {
agent, err := s.agentRepository.FindByID(agentID)
if err != nil {
return err
@@ -111,11 +115,11 @@ func (s *AgentService) DeleteAgent(user *users_models.User, agentID uuid.UUID) e
return err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("verification agent deleted: %s", agent.Name),
- &user.ID,
- nil,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("verification agent deleted: %s", agent.Name),
+ UserID: &user.ID,
+ WorkspaceID: nil,
+ })
return nil
}
@@ -149,6 +153,7 @@ func (s *AgentService) GetAgentByID(id uuid.UUID) (*Agent, error) {
}
func (s *AgentService) Heartbeat(
+ ctx context.Context,
agent *Agent,
req *HeartbeatRequest,
) (seenAt time.Time, abortVerificationIDs []uuid.UUID, err error) {
@@ -170,9 +175,10 @@ func (s *AgentService) Heartbeat(
abortSet := make(map[uuid.UUID]struct{})
for _, listener := range s.heartbeatListeners {
- listenerAborts, listenerErr := listener.OnAgentHeartbeated(agent, req.CurrentVerificationIDs)
+ listenerAborts, listenerErr := listener.OnAgentHeartbeated(ctx, agent, req.CurrentVerificationIDs)
if listenerErr != nil {
- s.logger.Error(
+ s.logger.ErrorContext(
+ ctx,
"agent heartbeated listener failed",
"error", listenerErr,
"agent_id", agent.ID,
diff --git a/backend/internal/features/verification/agents/service_test.go b/backend/internal/features/verification/agents/service_test.go
index 71db42e1..42fb7139 100644
--- a/backend/internal/features/verification/agents/service_test.go
+++ b/backend/internal/features/verification/agents/service_test.go
@@ -35,7 +35,7 @@ func Test_GetStaleAgents_WhenAgentHeartbeatedRecently_ReturnsEmpty(t *testing.T)
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "fresh-"+uuid.New().String())
recentHeartbeat := time.Now().UTC().Add(-1 * time.Minute)
@@ -51,7 +51,7 @@ func Test_GetStaleAgents_WhenAgentLastSeenBeforeThreshold_ReturnsAgent(t *testin
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "stale-"+uuid.New().String())
oldHeartbeat := time.Now().UTC().Add(-10 * time.Minute)
@@ -68,7 +68,7 @@ func Test_GetStaleAgents_WhenAgentNeverHeartbeatedButCreatedRecently_ReturnsEmpt
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "newborn-"+uuid.New().String())
setAgentTimestamps(t, createdAgent.Agent.ID, nil, time.Now().UTC())
@@ -83,7 +83,7 @@ func Test_GetStaleAgents_WhenAgentNeverHeartbeatedAndCreatedOld_ReturnsAgent(t *
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "ghost-"+uuid.New().String())
setAgentTimestamps(t, createdAgent.Agent.ID, nil, time.Now().UTC().Add(-10*time.Minute))
@@ -99,7 +99,7 @@ func Test_GetStaleAgents_WhenStaleAgentSoftDeleted_ReturnsEmpty(t *testing.T) {
cleanupAgents(t)
router := createTestRouter()
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
createdAgent := CreateTestVerificationAgent(t, router, admin.Token, "retired-"+uuid.New().String())
oldHeartbeat := time.Now().UTC().Add(-10 * time.Minute)
diff --git a/backend/internal/features/verification/config/controller.go b/backend/internal/features/verification/config/controller.go
index 3e6b4742..3338b361 100644
--- a/backend/internal/features/verification/config/controller.go
+++ b/backend/internal/features/verification/config/controller.go
@@ -42,7 +42,7 @@ func (c *VerificationConfigController) GetByDatabaseID(ctx *gin.Context) {
return
}
- config, err := c.verificationConfigService.GetByDatabaseID(user, databaseID)
+ config, err := c.verificationConfigService.GetByDatabaseID(ctx.Request.Context(), user, databaseID)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -83,7 +83,7 @@ func (c *VerificationConfigController) Save(ctx *gin.Context) {
return
}
- config, err := c.verificationConfigService.Save(user, databaseID, &req)
+ config, err := c.verificationConfigService.Save(ctx.Request.Context(), user, databaseID, &req)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
diff --git a/backend/internal/features/verification/config/controller_test.go b/backend/internal/features/verification/config/controller_test.go
index ba817a4a..99d9676e 100644
--- a/backend/internal/features/verification/config/controller_test.go
+++ b/backend/internal/features/verification/config/controller_test.go
@@ -77,8 +77,8 @@ func createTestDatabaseViaAPI(
func Test_GetByDatabaseID_WhenNoRowExists_LazyCreatesDisabledDefault(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
var response BackupVerificationConfig
@@ -105,17 +105,17 @@ func Test_GetByDatabaseID_WhenNoRowExists_LazyCreatesDisabledDefault(t *testing.
response.SendNotificationsOn,
)
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_GetByDatabaseID_WhenUserNotInWorkspace_ReturnsError(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
resp := test_utils.MakeGetRequest(
t,
@@ -126,14 +126,14 @@ func Test_GetByDatabaseID_WhenUserNotInWorkspace_ReturnsError(t *testing.T) {
)
assert.Contains(t, string(resp.Body), "insufficient permissions")
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_Save_AsOwner_PersistsAndReturns(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
request := newEnabledRequest()
@@ -182,17 +182,17 @@ func Test_Save_AsOwner_PersistsAndReturns(t *testing.T) {
fetched.SendNotificationsOn,
)
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_Save_AsViewer_RejectedWithPermissionError(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
- viewer := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ viewer := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
viewer,
@@ -211,14 +211,14 @@ func Test_Save_AsViewer_RejectedWithPermissionError(t *testing.T) {
)
assert.Contains(t, string(resp.Body), "insufficient permissions")
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_Save_WhenEnabled_WithInvalidInterval_ReturnsValidationError(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
request := newEnabledRequest()
@@ -236,14 +236,14 @@ func Test_Save_WhenEnabled_WithInvalidInterval_ReturnsValidationError(t *testing
)
assert.Contains(t, string(resp.Body), "cron expression")
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_Save_WithInvalidNotificationType_ReturnsValidationError(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
request := newEnabledRequest()
@@ -261,14 +261,14 @@ func Test_Save_WithInvalidNotificationType_ReturnsValidationError(t *testing.T)
)
assert.Contains(t, string(resp.Body), "invalid verification notification type")
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_Save_WhenScheduleTypeAfterBackup_SkipsIntervalValidationAndPersists(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
request := SaveBackupVerificationConfigDTO{
@@ -304,14 +304,14 @@ func Test_Save_WhenScheduleTypeAfterBackup_SkipsIntervalValidationAndPersists(t
)
assert.Equal(t, VerificationScheduleAfterBackup, fetched.ScheduleType)
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_Save_WhenScheduleTypeInvalid_ReturnsValidationError(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
request := newEnabledRequest()
@@ -327,14 +327,14 @@ func Test_Save_WhenScheduleTypeInvalid_ReturnsValidationError(t *testing.T) {
)
assert.Contains(t, string(resp.Body), "invalid verification schedule type")
- databases.RemoveTestDatabase(database)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), database)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
func Test_OnDatabaseCopied_CopiesConfigOntoNewDatabase(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "Test Workspace", owner, router)
source := createTestDatabaseViaAPI("Source Database", workspace.ID, owner.Token, router)
target := createTestDatabaseViaAPI("Target Database", workspace.ID, owner.Token, router)
@@ -355,7 +355,7 @@ func Test_OnDatabaseCopied_CopiesConfigOntoNewDatabase(t *testing.T) {
&saved,
)
- verificationConfigService.OnDatabaseCopied(source.ID, target.ID)
+ verificationConfigService.OnDatabaseCopied(t.Context(), source.ID, target.ID)
copied, err := verificationConfigRepository.GetByDatabaseID(target.ID)
assert.NoError(t, err)
@@ -371,7 +371,7 @@ func Test_OnDatabaseCopied_CopiesConfigOntoNewDatabase(t *testing.T) {
copied.SendNotificationsOn,
)
- databases.RemoveTestDatabase(source)
- databases.RemoveTestDatabase(target)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ databases.RemoveTestDatabase(t.Context(), source)
+ databases.RemoveTestDatabase(t.Context(), target)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
diff --git a/backend/internal/features/verification/config/service.go b/backend/internal/features/verification/config/service.go
index 2383527b..eec662ab 100644
--- a/backend/internal/features/verification/config/service.go
+++ b/backend/internal/features/verification/config/service.go
@@ -1,6 +1,7 @@
package verification_config
import (
+ "context"
"errors"
"fmt"
"log/slog"
@@ -8,6 +9,7 @@ import (
"github.com/google/uuid"
"databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
"databasus-backend/internal/features/databases"
"databasus-backend/internal/features/intervals"
users_models "databasus-backend/internal/features/users/models"
@@ -23,6 +25,7 @@ type VerificationConfigService struct {
}
func (s *VerificationConfigService) GetByDatabaseID(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
) (*BackupVerificationConfig, error) {
@@ -35,7 +38,7 @@ func (s *VerificationConfigService) GetByDatabaseID(
return nil, errors.New("cannot access verification config for databases without workspace")
}
- canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(*database.WorkspaceID, user)
+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, *database.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -63,6 +66,7 @@ func (s *VerificationConfigService) GetByDatabaseID(
}
func (s *VerificationConfigService) Save(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
req *SaveBackupVerificationConfigDTO,
@@ -76,7 +80,7 @@ func (s *VerificationConfigService) Save(
return nil, errors.New("cannot modify verification config for databases without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -113,11 +117,11 @@ func (s *VerificationConfigService) Save(
return nil, err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Backup verification config updated for database '%s'", database.Name),
- &user.ID,
- database.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Backup verification config updated for database '%s'", database.Name),
+ UserID: &user.ID,
+ WorkspaceID: database.WorkspaceID,
+ })
return config, nil
}
@@ -132,10 +136,11 @@ func (s *VerificationConfigService) ListEnabled() ([]*BackupVerificationConfig,
return s.verificationConfigRepository.FindAllEnabled()
}
-func (s *VerificationConfigService) OnDatabaseCopied(originalDatabaseID, newDatabaseID uuid.UUID) {
+func (s *VerificationConfigService) OnDatabaseCopied(ctx context.Context, originalDatabaseID, newDatabaseID uuid.UUID) {
originalConfig, err := s.verificationConfigRepository.GetByDatabaseID(originalDatabaseID)
if err != nil {
- s.logger.Error(
+ s.logger.ErrorContext(
+ ctx,
"failed to load source verification config on database copy",
"error", err,
"database_id", originalDatabaseID,
@@ -145,7 +150,8 @@ func (s *VerificationConfigService) OnDatabaseCopied(originalDatabaseID, newData
if originalConfig == nil {
if err := s.initializeDefaultConfig(newDatabaseID); err != nil {
- s.logger.Error(
+ s.logger.ErrorContext(
+ ctx,
"failed to initialize default verification config on database copy",
"error", err,
"database_id", newDatabaseID,
@@ -157,7 +163,8 @@ func (s *VerificationConfigService) OnDatabaseCopied(originalDatabaseID, newData
newConfig := originalConfig.Copy(newDatabaseID)
if err := s.verificationConfigRepository.Save(newConfig); err != nil {
- s.logger.Error(
+ s.logger.ErrorContext(
+ ctx,
"failed to save verification config on database copy",
"error", err,
"database_id", newDatabaseID,
diff --git a/backend/internal/features/verification/runs/after_backup_verification_test.go b/backend/internal/features/verification/runs/after_backup_verification_test.go
index 7f27f103..c040815f 100644
--- a/backend/internal/features/verification/runs/after_backup_verification_test.go
+++ b/backend/internal/features/verification/runs/after_backup_verification_test.go
@@ -18,6 +18,7 @@ import (
users_testing "databasus-backend/internal/features/users/testing"
verification_config "databasus-backend/internal/features/verification/config"
workspaces_testing "databasus-backend/internal/features/workspaces/testing"
+ "databasus-backend/internal/util/logger"
)
func enableAfterBackupVerificationViaAPI(
@@ -37,25 +38,25 @@ func enableAfterBackupVerificationViaAPI(
func Test_CreateScheduledRuns_WhenScheduleTypeAfterBackup_DoesNotCreateTimeBasedRun(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
enableAfterBackupVerificationViaAPI(t, router, owner.Token, database.ID)
scheduler := GetVerificationScheduler()
- require.NoError(t, scheduler.createScheduledRuns())
+ require.NoError(t, scheduler.createScheduledRuns(t.Context(), logger.GetLogger()))
rows := ListVerificationsByDatabaseViaAPI(t, router, owner.Token, database.ID)
assert.Empty(t, rows, "after-backup config must never get a time-based scheduled run")
@@ -63,18 +64,18 @@ func Test_CreateScheduledRuns_WhenScheduleTypeAfterBackup_DoesNotCreateTimeBased
func Test_OnBackupCompleted_WhenScheduleTypeAfterBackup_EnqueuesPendingRun(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -91,18 +92,18 @@ func Test_OnBackupCompleted_WhenScheduleTypeAfterBackup_EnqueuesPendingRun(t *te
func Test_OnBackupCompleted_WhenPendingAfterBackupExists_CancelsOldAndEnqueuesNew(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
firstBackup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -142,18 +143,18 @@ func Test_OnBackupCompleted_WhenManualVerificationPending_LeavesItAndStillEnqueu
t *testing.T,
) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -187,18 +188,18 @@ func Test_OnBackupCompleted_WhenManualVerificationPending_LeavesItAndStillEnqueu
func Test_OnBackupCompleted_WhenScheduleTypeInterval_DoesNothing(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -212,18 +213,18 @@ func Test_OnBackupCompleted_WhenScheduleTypeInterval_DoesNothing(t *testing.T) {
func Test_OnBackupCompleted_WhenDisabled_DoesNothing(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -243,20 +244,20 @@ func Test_MakeBackup_WhenAfterBackupConfigured_SchedulesAndReplacesPendingVerifi
t *testing.T,
) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
- backups_config_logical.EnableBackupsForTestDatabase(database.ID, testStorage)
+ backups_config_logical.EnableBackupsForTestDatabase(t.Context(), database.ID, testStorage)
enableAfterBackupVerificationViaAPI(t, router, owner.Token, database.ID)
// Start the real backups scheduler singleton so it subscribes to the
@@ -272,7 +273,7 @@ func Test_MakeBackup_WhenAfterBackupConfigured_SchedulesAndReplacesPendingVerifi
// the registered listeners — the seam the verification listener is wired onto.
completeBackup := func() uuid.UUID {
backup := backuping_logical.SeedInProgressTestBackup(t, database.ID, testStorage.ID)
- backuper.MakeBackup(backup.ID, false)
+ backuper.MakeBackup(t.Context(), backup.ID, false)
backuping_logical.TriggerBackupCompletedForTest(backup.ID)
return backup.ID
diff --git a/backend/internal/features/verification/runs/agent_controller.go b/backend/internal/features/verification/runs/agent_controller.go
index 701d8a3f..561a0aed 100644
--- a/backend/internal/features/verification/runs/agent_controller.go
+++ b/backend/internal/features/verification/runs/agent_controller.go
@@ -54,8 +54,9 @@ func (c *VerificationAgentController) Claim(ctx *gin.Context) {
return
}
- assignment, err := c.verificationService.ClaimVerification(agent, &req)
+ assignment, err := c.verificationService.ClaimVerification(ctx.Request.Context(), agent, &req)
if err != nil {
+ _ = ctx.Error(err)
ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
return
}
@@ -102,7 +103,8 @@ func (c *VerificationAgentController) BackupStream(ctx *gin.Context) {
defer func() {
if closeErr := reader.Close(); closeErr != nil {
- c.logger.Error(
+ c.logger.ErrorContext(
+ ctx.Request.Context(),
"failed to close backup reader",
"error", closeErr,
"verification_id", verificationID,
@@ -117,7 +119,8 @@ func (c *VerificationAgentController) BackupStream(ctx *gin.Context) {
)
if _, err := io.Copy(ctx.Writer, reader); err != nil {
- c.logger.Error(
+ c.logger.ErrorContext(
+ ctx.Request.Context(),
"failed to stream backup to agent",
"error", err,
"verification_id", verificationID,
@@ -159,7 +162,7 @@ func (c *VerificationAgentController) Report(ctx *gin.Context) {
return
}
- if err := c.verificationService.SubmitReport(agent, verificationID, &req); err != nil {
+ if err := c.verificationService.SubmitReport(ctx.Request.Context(), agent, verificationID, &req); err != nil {
if err.Error() == "verification gone" {
ctx.JSON(http.StatusGone, gin.H{"reason": "gone"})
return
diff --git a/backend/internal/features/verification/runs/agent_controller_test.go b/backend/internal/features/verification/runs/agent_controller_test.go
index 5d64d9ab..96bbed14 100644
--- a/backend/internal/features/verification/runs/agent_controller_test.go
+++ b/backend/internal/features/verification/runs/agent_controller_test.go
@@ -20,6 +20,7 @@ import (
verification_agents "databasus-backend/internal/features/verification/agents"
workspaces_testing "databasus-backend/internal/features/workspaces/testing"
"databasus-backend/internal/storage"
+ "databasus-backend/internal/util/logger"
test_utils "databasus-backend/internal/util/testing"
)
@@ -33,18 +34,18 @@ func reportPathFor(agentID, verificationID uuid.UUID) string {
func Test_ClaimVerification_WhenPendingFitsBudget_ReturnsJobAssignment(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -75,18 +76,18 @@ func Test_ClaimVerification_WhenPendingFitsBudget_ReturnsJobAssignment(t *testin
func Test_ClaimVerification_WhenBackupUsesTimescaleDB_ForwardsTimescaledbVersion(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
backup.TimescaledbVersion = "2.17.0"
@@ -107,18 +108,18 @@ func Test_ClaimVerification_WhenBackupUsesTimescaleDB_ForwardsTimescaledbVersion
func Test_ClaimVerification_WhenBackupTooBigForBudget_DoNotAssignJobWithoutError(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
largeBackup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100*1024)
@@ -138,20 +139,20 @@ func Test_ClaimVerification_WhenBackupTooBigForBudget_DoNotAssignJobWithoutError
func Test_ClaimVerification_WhenMultiplePendingFit_ReturnsOldestThatFitsBudget(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
databaseSmall := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(databaseSmall)
+ defer databases.RemoveTestDatabase(t.Context(), databaseSmall)
databaseBig := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(databaseBig)
+ defer databases.RemoveTestDatabase(t.Context(), databaseBig)
oldBig := backuping_logical.SeedTestBackup(t, databaseBig.ID, testStorage.ID, 4*1024)
youngSmall := backuping_logical.SeedTestBackup(t, databaseSmall.ID, testStorage.ID, 100)
@@ -180,20 +181,20 @@ func Test_ClaimVerification_WhenMultiplePendingFit_ReturnsOldestThatFitsBudget(t
func Test_ClaimVerification_WhenAgentHasRunningRows_DeductsTheirSizeFromBudget(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
databaseRunning := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(databaseRunning)
+ defer databases.RemoveTestDatabase(t.Context(), databaseRunning)
databasePending := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(databasePending)
+ defer databases.RemoveTestDatabase(t.Context(), databasePending)
bigBackup := backuping_logical.SeedTestBackup(t, databaseRunning.ID, testStorage.ID, 1000)
pendingBackup := backuping_logical.SeedTestBackup(t, databasePending.ID, testStorage.ID, 1000)
@@ -230,18 +231,18 @@ func Test_ClaimVerification_WhenAgentHasRunningRows_DeductsTheirSizeFromBudget(t
func Test_ClaimVerification_WhenAlreadyClaimedByAnotherAgent_OnlyReassignsAfterCancelAndReschedule(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -295,18 +296,18 @@ func Test_ClaimVerification_WhenAlreadyClaimedByAnotherAgent_OnlyReassignsAfterC
func Test_SubmitReport_WhenStatusCompleted_PersistsResultsAndTableStats(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
agent := verification_agents.CreateTestVerificationAgent(t, router, owner.Token, "report-"+uuid.New().String())
@@ -365,18 +366,18 @@ func Test_SubmitReport_WhenStatusCompleted_PersistsResultsAndTableStats(t *testi
func Test_SubmitReport_WhenCompletedWithNonZeroExitCode_MarksCompleted(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
agent := verification_agents.CreateTestVerificationAgent(t, router, owner.Token, "report-"+uuid.New().String())
@@ -426,18 +427,18 @@ func Test_SubmitReport_WhenCompletedWithNonZeroExitCode_MarksCompleted(t *testin
func Test_SubmitReport_WhenRowWasReapedWhileAgentWasSilent_Returns410(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -450,7 +451,7 @@ func Test_SubmitReport_WhenRowWasReapedWhileAgentWasSilent_Returns410(t *testing
AgentCapacity{MaxCPU: 4, MaxRAMMb: 4096, MaxDiskGb: 50, MaxConcurrentJobs: 2},
)
- require.NoError(t, GetVerificationScheduler().reapStaleRuns())
+ require.NoError(t, GetVerificationScheduler().reapStaleRuns(t.Context(), logger.GetLogger()))
test_utils.MakePostRequest(
t, router,
@@ -463,18 +464,18 @@ func Test_SubmitReport_WhenRowWasReapedWhileAgentWasSilent_Returns410(t *testing
func Test_SubmitReport_WhenAgentReportsBackupRejected_StoresMessageVerbatimAndTerminal(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
agent := verification_agents.CreateTestVerificationAgent(t, router, owner.Token, "fail-"+uuid.New().String())
@@ -524,18 +525,18 @@ func Test_SubmitReport_WhenAgentReportsBackupRejected_StoresMessageVerbatimAndTe
func Test_SubmitReport_WhenAgentReportsDiskLimitExceeded_MarksTerminalWithoutRetry(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
agent := verification_agents.CreateTestVerificationAgent(t, router, owner.Token, "disk-"+uuid.New().String())
@@ -588,18 +589,18 @@ func Test_SubmitReport_WhenAgentReportsDiskLimitExceeded_MarksTerminalWithoutRet
func Test_SubmitReport_WhenAgentSetupFailedWithRetriesRemaining_RequeuesVerification(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
agent := verification_agents.CreateTestVerificationAgent(t, router, owner.Token, "retry-"+uuid.New().String())
@@ -640,18 +641,18 @@ func Test_SubmitReport_WhenAgentSetupFailedWithRetriesRemaining_RequeuesVerifica
func Test_SubmitReport_WhenAgentSetupFailedRepeatedly_MarksTerminalAfterMaxAttempts(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
agent := verification_agents.CreateTestVerificationAgent(t, router, owner.Token, "exhaust-"+uuid.New().String())
@@ -700,18 +701,18 @@ func Test_SubmitReport_WhenAgentSetupFailedRepeatedly_MarksTerminalAfterMaxAttem
func Test_SubmitReport_WhenCompletedButRestoredSizeBelow20Percent_MarksTerminalWithoutRetry(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
// Backup with a recorded raw DB size of 100 MB ≈ 104_857_600 bytes — the 20%
// floor is therefore ~20 MB. Reporting a 1 MB restored DB must trip the guard.
@@ -762,20 +763,20 @@ func Test_SubmitReport_WhenCompletedButRestoredSizeBelow20Percent_MarksTerminalW
func Test_Heartbeat_WhenReportedJobIsCanceledOrDeleted_ReturnsItAsAbortID(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
databaseRunning := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(databaseRunning)
+ defer databases.RemoveTestDatabase(t.Context(), databaseRunning)
databaseCanceled := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(databaseCanceled)
+ defer databases.RemoveTestDatabase(t.Context(), databaseCanceled)
runningBackup := backuping_logical.SeedTestBackup(t, databaseRunning.ID, testStorage.ID, 100)
canceledBackup := backuping_logical.SeedTestBackup(t, databaseCanceled.ID, testStorage.ID, 100)
@@ -828,18 +829,18 @@ func Test_Heartbeat_WhenReportedJobIsCanceledOrDeleted_ReturnsItAsAbortID(t *tes
func Test_CancelVerification_WhenRunning_AgentHeartbeatReturnsIDAsAbort(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -889,18 +890,18 @@ func Test_CancelVerification_WhenRunning_AgentHeartbeatReturnsIDAsAbort(t *testi
func Test_GetBackups_WhenBackupNeverVerified_StatusIsNotVerified(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
diff --git a/backend/internal/features/verification/runs/claim_sanitization_test.go b/backend/internal/features/verification/runs/claim_sanitization_test.go
index 1810ccae..a5e22896 100644
--- a/backend/internal/features/verification/runs/claim_sanitization_test.go
+++ b/backend/internal/features/verification/runs/claim_sanitization_test.go
@@ -22,18 +22,18 @@ import (
// notifier secrets must be empty when the JobAssignment leaves the server.
func Test_ClaimVerification_AssignmentDatabase_StripsSensitiveData(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
require.NotNil(t, database.PostgresqlLogical)
require.NotEmpty(t, database.PostgresqlLogical.Password,
diff --git a/backend/internal/features/verification/runs/controller.go b/backend/internal/features/verification/runs/controller.go
index 30293cbd..d4465ae9 100644
--- a/backend/internal/features/verification/runs/controller.go
+++ b/backend/internal/features/verification/runs/controller.go
@@ -45,7 +45,7 @@ func (c *VerificationController) EnqueueManual(ctx *gin.Context) {
return
}
- verification, err := c.verificationService.EnqueueManualVerification(user, req.BackupID)
+ verification, err := c.verificationService.EnqueueManualVerification(ctx.Request.Context(), user, req.BackupID)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -78,7 +78,7 @@ func (c *VerificationController) Cancel(ctx *gin.Context) {
return
}
- if err := c.verificationService.CancelVerification(user, verificationID); err != nil {
+ if err := c.verificationService.CancelVerification(ctx.Request.Context(), user, verificationID); err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
@@ -110,7 +110,7 @@ func (c *VerificationController) GetByID(ctx *gin.Context) {
return
}
- verification, err := c.verificationService.GetVerificationByID(user, verificationID)
+ verification, err := c.verificationService.GetVerificationByID(ctx.Request.Context(), user, verificationID)
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
@@ -151,7 +151,13 @@ func (c *VerificationController) ListByDatabase(ctx *gin.Context) {
return
}
- response, err := c.verificationService.GetVerificationsByDatabaseID(user, databaseID, req.Limit, req.Offset)
+ response, err := c.verificationService.GetVerificationsByDatabaseID(
+ ctx.Request.Context(),
+ user,
+ databaseID,
+ req.Limit,
+ req.Offset,
+ )
if err != nil {
ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
diff --git a/backend/internal/features/verification/runs/controller_test.go b/backend/internal/features/verification/runs/controller_test.go
index ad31d04e..1aa24997 100644
--- a/backend/internal/features/verification/runs/controller_test.go
+++ b/backend/internal/features/verification/runs/controller_test.go
@@ -58,18 +58,18 @@ func createTestRouter() *gin.Engine {
func Test_EnqueueManualVerification_AsOwner_CreatesPendingRow(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 500)
@@ -92,18 +92,18 @@ func Test_EnqueueManualVerification_AsOwner_CreatesPendingRow(t *testing.T) {
func Test_EnqueueManualVerification_WhenManualPendingExists_Returns400(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
firstBackup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
secondBackup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 200)
@@ -132,18 +132,18 @@ func Test_EnqueueManualVerification_WhenManualPendingExists_Returns400(t *testin
func Test_EnqueueManualVerification_WhenRunningExists_Returns400(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -166,18 +166,18 @@ func Test_EnqueueManualVerification_WhenRunningExists_Returns400(t *testing.T) {
func Test_EnqueueManualVerification_WhenScheduledNonTerminalExists_DoesNotDisplaceIt(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -230,22 +230,22 @@ func Test_EnqueueManualVerification_WhenScheduledNonTerminalExists_DoesNotDispla
func Test_EnqueueManualVerification_AsNonWorkspaceMember_ReturnsForbidden(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
- outsider := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ outsider := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
resp := test_utils.MakePostRequest(
t, router, "/api/v1/verifications/enqueue", "Bearer "+outsider.Token,
@@ -257,18 +257,18 @@ func Test_EnqueueManualVerification_AsNonWorkspaceMember_ReturnsForbidden(t *tes
func Test_GetVerificationByID_ReturnsTableStats_WhileListByDatabaseOmitsThem(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
agent := verification_agents.CreateTestVerificationAgent(t, router, owner.Token, "stats-"+uuid.New().String())
@@ -317,18 +317,18 @@ func Test_GetVerificationByID_ReturnsTableStats_WhileListByDatabaseOmitsThem(t *
func Test_ListVerificationsByDatabase_WithLimit_CapsRowsAndReturnsTotal(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -354,18 +354,18 @@ func Test_ListVerificationsByDatabase_WithLimit_CapsRowsAndReturnsTotal(t *testi
func Test_CancelVerification_AsOwner_FlipsToCanceled(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -382,18 +382,18 @@ func Test_CancelVerification_AsOwner_FlipsToCanceled(t *testing.T) {
func Test_CancelVerification_WhenAlreadyCompleted_Returns400(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
agent := verification_agents.CreateTestVerificationAgent(
@@ -433,23 +433,23 @@ func Test_CancelVerification_WhenAlreadyCompleted_Returns400(t *testing.T) {
func Test_CancelVerification_AsNonWorkspaceMember_ReturnsForbidden(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
enqueued := EnqueueManualVerificationViaAPI(t, router, owner.Token, backup.ID)
- outsider := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ outsider := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
resp := test_utils.MakePostRequest(
t, router,
@@ -466,18 +466,18 @@ func Test_CancelVerification_AsNonWorkspaceMember_ReturnsForbidden(t *testing.T)
func Test_CancelVerification_WithAgentToken_Returns401(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
enqueued := EnqueueManualVerificationViaAPI(t, router, owner.Token, backup.ID)
@@ -501,12 +501,12 @@ func Test_CancelVerification_WithAgentToken_Returns401(t *testing.T) {
func Test_DeleteDatabase_RemovesVerifications_ViaCascade(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
@@ -533,18 +533,18 @@ func Test_DeleteDatabase_RemovesVerifications_ViaCascade(t *testing.T) {
func Test_DeleteBackup_RemovesVerifications_ViaCascade(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
enqueued := EnqueueManualVerificationViaAPI(t, router, owner.Token, backup.ID)
diff --git a/backend/internal/features/verification/runs/heartbeat_reclaim_test.go b/backend/internal/features/verification/runs/heartbeat_reclaim_test.go
index dbb4d4f8..236195ae 100644
--- a/backend/internal/features/verification/runs/heartbeat_reclaim_test.go
+++ b/backend/internal/features/verification/runs/heartbeat_reclaim_test.go
@@ -1,6 +1,7 @@
package verification_runs
import (
+ "context"
"testing"
"time"
@@ -35,19 +36,19 @@ func newReclaimFixture(
t.Helper()
router = createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(workspace, router) })
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ t.Cleanup(func() { workspaces_testing.RemoveTestWorkspace(context.Background(), workspace, router) })
testStorage := storages.CreateTestStorage(workspace.ID)
- t.Cleanup(func() { storages.RemoveTestStorage(testStorage.ID) })
+ t.Cleanup(func() { storages.RemoveTestStorage(t.Context(), testStorage.ID) })
notifier := notifiers.CreateTestNotifier(workspace.ID)
t.Cleanup(func() { notifiers.RemoveTestNotifier(notifier) })
database = databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- t.Cleanup(func() { databases.RemoveTestDatabase(database) })
+ t.Cleanup(func() { databases.RemoveTestDatabase(t.Context(), database) })
return router, owner.Token, database, testStorage.ID
}
@@ -105,7 +106,7 @@ func Test_OnAgentHeartbeated_WhenLiveAgentDropsRunningJobPastGrace_Requeues(t *t
assignment := claimRunningJob(t, router, ownerToken, agent, backup.ID)
backdateStartedAt(t, assignment.VerificationID)
- _, err := GetVerificationService().OnAgentHeartbeated(agent.Agent, nil)
+ _, err := GetVerificationService().OnAgentHeartbeated(t.Context(), agent.Agent, nil)
require.NoError(t, err)
requeued := GetVerificationByIDViaAPI(t, router, ownerToken, assignment.VerificationID)
@@ -125,7 +126,7 @@ func Test_OnAgentHeartbeated_WhenJobStillReportedByAgent_DoesNotRequeue(t *testi
assignment := claimRunningJob(t, router, ownerToken, agent, backup.ID)
backdateStartedAt(t, assignment.VerificationID)
- _, err := GetVerificationService().OnAgentHeartbeated(
+ _, err := GetVerificationService().OnAgentHeartbeated(t.Context(),
agent.Agent, []uuid.UUID{assignment.VerificationID},
)
require.NoError(t, err)
@@ -147,7 +148,7 @@ func Test_OnAgentHeartbeated_WhenRunningJobWithinGrace_DoesNotRequeue(t *testing
backup := backuping_logical.SeedTestBackup(t, database.ID, storageID, 100)
assignment := claimRunningJob(t, router, ownerToken, agent, backup.ID)
- _, err := GetVerificationService().OnAgentHeartbeated(agent.Agent, nil)
+ _, err := GetVerificationService().OnAgentHeartbeated(t.Context(), agent.Agent, nil)
require.NoError(t, err)
stillRunning := GetVerificationByIDViaAPI(t, router, ownerToken, assignment.VerificationID)
@@ -173,7 +174,7 @@ func Test_OnAgentHeartbeated_WhenDroppedJobAtMaxAttempts_MarksTerminal(t *testin
"started_at": time.Now().UTC().Add(-1 * time.Hour),
}).Error)
- _, err := GetVerificationService().OnAgentHeartbeated(agent.Agent, nil)
+ _, err := GetVerificationService().OnAgentHeartbeated(t.Context(), agent.Agent, nil)
require.NoError(t, err)
final := GetVerificationByIDViaAPI(t, router, ownerToken, assignment.VerificationID)
@@ -202,7 +203,7 @@ func Test_OnAgentHeartbeated_WhenJobAlreadyCompleted_DoesNotResurrect(t *testing
"started_at": time.Now().UTC().Add(-1 * time.Hour),
}).Error)
- _, err := GetVerificationService().OnAgentHeartbeated(agent.Agent, nil)
+ _, err := GetVerificationService().OnAgentHeartbeated(t.Context(), agent.Agent, nil)
require.NoError(t, err)
final := GetVerificationByIDViaAPI(t, router, ownerToken, assignment.VerificationID)
@@ -214,21 +215,21 @@ func Test_OnAgentHeartbeated_WhenAgentDropsOneStillRunsAnother_ReclaimsOnlyDropp
shrinkReclaimGrace(t, 1*time.Millisecond)
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
databaseKept := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(databaseKept)
+ defer databases.RemoveTestDatabase(t.Context(), databaseKept)
databaseDropped := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(databaseDropped)
+ defer databases.RemoveTestDatabase(t.Context(), databaseDropped)
agent := newReclaimAgent(t, router, owner.Token)
@@ -240,7 +241,7 @@ func Test_OnAgentHeartbeated_WhenAgentDropsOneStillRunsAnother_ReclaimsOnlyDropp
backdateStartedAt(t, kept.VerificationID)
backdateStartedAt(t, dropped.VerificationID)
- aborts, err := GetVerificationService().OnAgentHeartbeated(
+ aborts, err := GetVerificationService().OnAgentHeartbeated(t.Context(),
agent.Agent, []uuid.UUID{kept.VerificationID},
)
require.NoError(t, err)
@@ -273,7 +274,7 @@ func Test_OnAgentHeartbeated_WhenAgentReportsNoLongerOwnedJob_ReturnsItInAbortLi
"finished_at": time.Now().UTC(),
}).Error)
- aborts, err := GetVerificationService().OnAgentHeartbeated(
+ aborts, err := GetVerificationService().OnAgentHeartbeated(t.Context(),
agent.Agent, []uuid.UUID{assignment.VerificationID},
)
require.NoError(t, err)
diff --git a/backend/internal/features/verification/runs/interfaces.go b/backend/internal/features/verification/runs/interfaces.go
index 4b6861f6..e4a20354 100644
--- a/backend/internal/features/verification/runs/interfaces.go
+++ b/backend/internal/features/verification/runs/interfaces.go
@@ -1,10 +1,12 @@
package verification_runs
import (
+ "context"
+
"databasus-backend/internal/features/notifiers"
notifier_models "databasus-backend/internal/features/notifiers/models"
)
type NotificationSender interface {
- SendNotification(notifier *notifiers.Notifier, notification notifier_models.Notification)
+ SendNotification(ctx context.Context, notifier *notifiers.Notifier, notification notifier_models.Notification)
}
diff --git a/backend/internal/features/verification/runs/notification_test.go b/backend/internal/features/verification/runs/notification_test.go
index 32a6b87e..814a5d5f 100644
--- a/backend/internal/features/verification/runs/notification_test.go
+++ b/backend/internal/features/verification/runs/notification_test.go
@@ -1,6 +1,7 @@
package verification_runs
import (
+ "context"
"net/http"
"sync"
"testing"
@@ -23,6 +24,7 @@ import (
verification_config "databasus-backend/internal/features/verification/config"
workspaces_testing "databasus-backend/internal/features/workspaces/testing"
"databasus-backend/internal/storage"
+ "databasus-backend/internal/util/logger"
test_utils "databasus-backend/internal/util/testing"
)
@@ -42,6 +44,7 @@ func newRecordingNotificationSender() *recordingNotificationSender {
}
func (s *recordingNotificationSender) SendNotification(
+ _ context.Context,
notifier *notifiers.Notifier,
notification notifier_models.Notification,
) {
@@ -110,18 +113,18 @@ func enableFailureNotificationsViaAPI(
func Test_SubmitReport_WhenBackupRejected_SendsFailureNotification(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
enableFailureNotificationsViaAPI(t, router, owner.Token, database.ID)
@@ -168,18 +171,18 @@ func Test_SubmitReport_WhenBackupRejected_SendsFailureNotification(t *testing.T)
func Test_SubmitReport_WhenRestoredTooSmall_SendsFailureNotification(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
enableFailureNotificationsViaAPI(t, router, owner.Token, database.ID)
@@ -219,18 +222,18 @@ func Test_SubmitReport_WhenRestoredTooSmall_SendsFailureNotification(t *testing.
func Test_SubmitReport_WhenAgentSetupFailedRepeatedly_SendsFailureNotificationOnlyAtTerminal(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
enableFailureNotificationsViaAPI(t, router, owner.Token, database.ID)
@@ -284,18 +287,18 @@ func Test_ReapStaleRuns_WhenAgentLostContact_SendsFailureNotificationOnlyAtTermi
shrinkThresholds(t, 1*time.Hour, 1*time.Millisecond)
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
enableFailureNotificationsViaAPI(t, router, owner.Token, database.ID)
@@ -323,7 +326,7 @@ func Test_ReapStaleRuns_WhenAgentLostContact_SendsFailureNotificationOnlyAtTermi
Where("id = ?", agent.Agent.ID).
Update("last_seen_at", time.Now().UTC().Add(-1*time.Hour)).Error)
- require.NoError(t, GetVerificationScheduler().reapStaleRuns())
+ require.NoError(t, GetVerificationScheduler().reapStaleRuns(t.Context(), logger.GetLogger()))
if attempt < MaxAgentSideAttempts-1 {
time.Sleep(50 * time.Millisecond)
@@ -344,18 +347,18 @@ func Test_ReapStaleRuns_WhenAgentLostContact_SendsFailureNotificationOnlyAtTermi
func Test_SubmitReport_WhenFailureNotificationsDisabled_DoesNotSend(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
// Default config has IsScheduledVerificationEnabled=false and no notification types.
// Do not call enableFailureNotificationsViaAPI — failure notification must NOT fire.
diff --git a/backend/internal/features/verification/runs/repository.go b/backend/internal/features/verification/runs/repository.go
index fa9c0a78..99e0f984 100644
--- a/backend/internal/features/verification/runs/repository.go
+++ b/backend/internal/features/verification/runs/repository.go
@@ -1,6 +1,7 @@
package verification_runs
import (
+ "context"
"errors"
"maps"
"time"
@@ -23,10 +24,10 @@ func (r *VerificationRepository) Create(verification *RestoreVerification) error
return storage.GetDb().Create(verification).Error
}
-func (r *VerificationRepository) FindByID(id uuid.UUID) (*RestoreVerification, error) {
+func (r *VerificationRepository) FindByID(ctx context.Context, id uuid.UUID) (*RestoreVerification, error) {
var verification RestoreVerification
- err := storage.GetDb().
+ err := storage.GetDb().WithContext(ctx).
Preload("TableStats").
Where("id = ?", id).
First(&verification).Error
diff --git a/backend/internal/features/verification/runs/scheduler.go b/backend/internal/features/verification/runs/scheduler.go
index 93883390..5bcf8571 100644
--- a/backend/internal/features/verification/runs/scheduler.go
+++ b/backend/internal/features/verification/runs/scheduler.go
@@ -42,29 +42,35 @@ func (s *VerificationScheduler) Run(ctx context.Context) {
ticker := time.NewTicker(schedulerTickInterval)
defer ticker.Stop()
+ lifecycleLogger := s.logger.With("job_name", jobName)
+
+ lifecycleLogger.InfoContext(ctx, "verification scheduler started")
+
for {
select {
case <-ctx.Done():
+ lifecycleLogger.InfoContext(ctx, "verification scheduler stopped")
+
return
case <-ticker.C:
tickLogger := s.logger.With("job_id", uuid.New(), "job_name", jobName)
- if err := s.createScheduledRuns(); err != nil {
- tickLogger.Error("createScheduledRuns failed", "error", err)
+ if err := s.createScheduledRuns(ctx, tickLogger); err != nil {
+ tickLogger.ErrorContext(ctx, "failed to create scheduled verification runs", "error", err)
}
- if err := s.reapStaleRuns(); err != nil {
- tickLogger.Error("reapStaleRuns failed", "error", err)
+ if err := s.reapStaleRuns(ctx, tickLogger); err != nil {
+ tickLogger.ErrorContext(ctx, "failed to reap stale verification runs", "error", err)
}
- if err := s.sweepCanceledByDisabledConfig(); err != nil {
- tickLogger.Error("sweepCanceledByDisabledConfig failed", "error", err)
+ if err := s.sweepCanceledByDisabledConfig(ctx, tickLogger); err != nil {
+ tickLogger.ErrorContext(ctx, "failed to cancel verifications for disabled configs", "error", err)
}
}
}
}
-func (s *VerificationScheduler) createScheduledRuns() error {
+func (s *VerificationScheduler) createScheduledRuns(ctx context.Context, logger *slog.Logger) error {
configsWithEnabledVerifications, err := s.verificaionConfigService.ListEnabled()
if err != nil {
return err
@@ -73,8 +79,8 @@ func (s *VerificationScheduler) createScheduledRuns() error {
now := time.Now().UTC()
for _, config := range configsWithEnabledVerifications {
- if err := s.createScheduledRunForConfig(config, now); err != nil {
- s.logger.Error(
+ if err := s.createScheduledRunForConfig(ctx, logger, config, now); err != nil {
+ logger.ErrorContext(ctx,
"failed to evaluate scheduled run for database",
"error", err,
"database_id", config.DatabaseID,
@@ -86,6 +92,8 @@ func (s *VerificationScheduler) createScheduledRuns() error {
}
func (s *VerificationScheduler) createScheduledRunForConfig(
+ ctx context.Context,
+ logger *slog.Logger,
config *verification_config.BackupVerificationConfig,
now time.Time,
) error {
@@ -124,10 +132,8 @@ func (s *VerificationScheduler) createScheduledRunForConfig(
}
if backup == nil {
- s.logger.Info(
- "skipping scheduled verification: no verifiable backup yet",
- "database_id", config.DatabaseID,
- )
+ logger.DebugContext(ctx, "skipping scheduled verification: no verifiable backup yet",
+ "database_id", config.DatabaseID)
return nil
}
@@ -138,11 +144,8 @@ func (s *VerificationScheduler) createScheduledRunForConfig(
}
if err := validateDatabaseIsVerifiable(database); err != nil {
- s.logger.Warn(
- "skipping scheduled verification: database not verifiable",
- "database_id", config.DatabaseID,
- "error", err,
- )
+ logger.DebugContext(ctx, "skipping scheduled verification: database not verifiable",
+ "database_id", config.DatabaseID, "error", err)
return nil
}
@@ -160,7 +163,7 @@ func (s *VerificationScheduler) createScheduledRunForConfig(
return s.repo.Create(verification)
}
-func (s *VerificationScheduler) reapStaleRuns() error {
+func (s *VerificationScheduler) reapStaleRuns(ctx context.Context, logger *slog.Logger) error {
runningRows, err := s.repo.FindAllRunning()
if err != nil {
return err
@@ -176,7 +179,7 @@ func (s *VerificationScheduler) reapStaleRuns() error {
agent, lookupErr := s.agentService.GetAgentByID(*row.AgentID)
if lookupErr != nil {
- s.logger.Error(
+ logger.ErrorContext(ctx,
"failed to load agent during reap",
"error", lookupErr,
"verification_id", row.ID,
@@ -190,8 +193,8 @@ func (s *VerificationScheduler) reapStaleRuns() error {
// The owning agent is gone, but Requeue clears agent_id so a
// different agent can pick the run up. If none does, the stale
// PENDING reaper retires it after maxPendingDuration.
- if failErr := s.service.RequeueOrFail(row, FailureReasonAgentRemoved, nil); failErr != nil {
- s.logger.Error(
+ if failErr := s.service.RequeueOrFail(ctx, row, FailureReasonAgentRemoved, nil); failErr != nil {
+ logger.ErrorContext(ctx,
"failed to requeue or fail RUNNING verification for removed agent",
"error", failErr,
"verification_id", row.ID,
@@ -202,8 +205,8 @@ func (s *VerificationScheduler) reapStaleRuns() error {
}
if agent.LastSeenAt == nil || agent.LastSeenAt.Before(staleBefore) {
- if failErr := s.service.RequeueOrFail(row, FailureReasonAgentLostContact, nil); failErr != nil {
- s.logger.Error(
+ if failErr := s.service.RequeueOrFail(ctx, row, FailureReasonAgentLostContact, nil); failErr != nil {
+ logger.ErrorContext(ctx,
"failed to requeue or fail stale RUNNING verification",
"error", failErr,
"verification_id", row.ID,
@@ -220,8 +223,8 @@ func (s *VerificationScheduler) reapStaleRuns() error {
}
for _, row := range stalePending {
- if failErr := s.service.RequeueOrFail(row, FailureReasonUnclaimedTooLong, nil); failErr != nil {
- s.logger.Error(
+ if failErr := s.service.RequeueOrFail(ctx, row, FailureReasonUnclaimedTooLong, nil); failErr != nil {
+ logger.ErrorContext(ctx,
"failed to fail stale PENDING verification",
"error", failErr,
"verification_id", row.ID,
@@ -234,17 +237,22 @@ func (s *VerificationScheduler) reapStaleRuns() error {
// sweepCanceledByDisabledConfig sends no notification
// — disable is user-initiated, not a failure.
-func (s *VerificationScheduler) sweepCanceledByDisabledConfig() error {
+func (s *VerificationScheduler) sweepCanceledByDisabledConfig(ctx context.Context, logger *slog.Logger) error {
rows, err := s.repo.FindNonTerminalForDisabledConfigs()
if err != nil {
return err
}
+ if len(rows) > 0 {
+ logger.InfoContext(ctx, fmt.Sprintf(
+ "cancelling %d verifications whose config was disabled", len(rows)))
+ }
+
for _, row := range rows {
if cancelErr := s.repo.MarkTerminal(nil, row.ID, VerificationStatusCanceled, map[string]any{
"fail_message": cancelMessageScheduleDisabled,
}); cancelErr != nil {
- s.logger.Error(
+ logger.Error(
"failed to mark verification CANCELED",
"error", cancelErr,
"verification_id", row.ID,
diff --git a/backend/internal/features/verification/runs/scheduler_test.go b/backend/internal/features/verification/runs/scheduler_test.go
index d87c6f43..e207bc4e 100644
--- a/backend/internal/features/verification/runs/scheduler_test.go
+++ b/backend/internal/features/verification/runs/scheduler_test.go
@@ -21,6 +21,7 @@ import (
verification_config "databasus-backend/internal/features/verification/config"
workspaces_testing "databasus-backend/internal/features/workspaces/testing"
"databasus-backend/internal/storage"
+ "databasus-backend/internal/util/logger"
test_utils "databasus-backend/internal/util/testing"
)
@@ -57,18 +58,18 @@ func enableHourlyVerificationViaAPI(
func Test_CreateScheduledRuns_WhenMultipleBackupsExist_PicksLatestForVerification(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
older := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 50)
older.CreatedAt = time.Now().UTC().Add(-2 * time.Hour)
@@ -79,7 +80,7 @@ func Test_CreateScheduledRuns_WhenMultipleBackupsExist_PicksLatestForVerificatio
enableHourlyVerificationViaAPI(t, router, owner.Token, database.ID)
scheduler := GetVerificationScheduler()
- require.NoError(t, scheduler.createScheduledRuns())
+ require.NoError(t, scheduler.createScheduledRuns(t.Context(), logger.GetLogger()))
rows := ListVerificationsByDatabaseViaAPI(t, router, owner.Token, database.ID)
require.Len(t, rows, 1)
@@ -90,26 +91,26 @@ func Test_CreateScheduledRuns_WhenMultipleBackupsExist_PicksLatestForVerificatio
func Test_CreateScheduledRuns_WhenScheduledPendingAlreadyExists_DoesNotInsertNewRun(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
enableHourlyVerificationViaAPI(t, router, owner.Token, database.ID)
scheduler := GetVerificationScheduler()
- require.NoError(t, scheduler.createScheduledRuns())
- require.NoError(t, scheduler.createScheduledRuns())
+ require.NoError(t, scheduler.createScheduledRuns(t.Context(), logger.GetLogger()))
+ require.NoError(t, scheduler.createScheduledRuns(t.Context(), logger.GetLogger()))
rows := ListVerificationsByDatabaseViaAPI(t, router, owner.Token, database.ID)
assert.Len(t, rows, 1, "second tick must not insert a second row while a SCHEDULED PENDING exists")
@@ -117,18 +118,18 @@ func Test_CreateScheduledRuns_WhenScheduledPendingAlreadyExists_DoesNotInsertNew
func Test_CreateScheduledRuns_WhenManualPendingExists_StillCreatesScheduledRun(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -137,7 +138,7 @@ func Test_CreateScheduledRuns_WhenManualPendingExists_StillCreatesScheduledRun(t
enableHourlyVerificationViaAPI(t, router, owner.Token, database.ID)
scheduler := GetVerificationScheduler()
- require.NoError(t, scheduler.createScheduledRuns())
+ require.NoError(t, scheduler.createScheduledRuns(t.Context(), logger.GetLogger()))
rows := ListVerificationsByDatabaseViaAPI(t, router, owner.Token, database.ID)
require.Len(t, rows, 2, "manual non-terminal row must not block scheduled creation")
@@ -161,18 +162,18 @@ func Test_ReapStaleRuns_WhenPendingExceedsMaxDuration_MarksFailedWithoutRetry(t
shrinkThresholds(t, 5*time.Millisecond, 5*time.Second)
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
@@ -183,7 +184,7 @@ func Test_ReapStaleRuns_WhenPendingExceedsMaxDuration_MarksFailedWithoutRetry(t
Update("created_at", time.Now().UTC().Add(-1*time.Hour)).Error)
scheduler := GetVerificationScheduler()
- require.NoError(t, scheduler.reapStaleRuns())
+ require.NoError(t, scheduler.reapStaleRuns(t.Context(), logger.GetLogger()))
final := GetVerificationByIDViaAPI(t, router, owner.Token, stalePending.ID)
assert.Equal(t, VerificationStatusFailed, final.Status)
@@ -195,18 +196,18 @@ func Test_ReapStaleRuns_WhenOwningAgentRemoved_RequeuesThenRetiresIfUnclaimed(t
shrinkThresholds(t, 5*time.Millisecond, 1*time.Millisecond)
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backup := backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
agent := verification_agents.CreateTestVerificationAgent(t, router, owner.Token, "soft-del-"+uuid.New().String())
@@ -226,7 +227,7 @@ func Test_ReapStaleRuns_WhenOwningAgentRemoved_RequeuesThenRetiresIfUnclaimed(t
)
scheduler := GetVerificationScheduler()
- require.NoError(t, scheduler.reapStaleRuns())
+ require.NoError(t, scheduler.reapStaleRuns(t.Context(), logger.GetLogger()))
requeued := GetVerificationByIDViaAPI(t, router, owner.Token, assignment.VerificationID)
assert.Equal(
@@ -245,7 +246,7 @@ func Test_ReapStaleRuns_WhenOwningAgentRemoved_RequeuesThenRetiresIfUnclaimed(t
Model(&RestoreVerification{}).
Where("id = ?", assignment.VerificationID).
Update("created_at", time.Now().UTC().Add(-1*time.Hour)).Error)
- require.NoError(t, scheduler.reapStaleRuns())
+ require.NoError(t, scheduler.reapStaleRuns(t.Context(), logger.GetLogger()))
final := GetVerificationByIDViaAPI(t, router, owner.Token, assignment.VerificationID)
assert.Equal(t, VerificationStatusFailed, final.Status)
@@ -257,18 +258,18 @@ func Test_ReapStaleRuns_WhenAgentLostContactWithRetriesRemaining_RequeuesVerific
shrinkThresholds(t, 1*time.Hour, 1*time.Millisecond)
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
enableHourlyVerificationViaAPI(t, router, owner.Token, database.ID)
@@ -292,7 +293,7 @@ func Test_ReapStaleRuns_WhenAgentLostContactWithRetriesRemaining_RequeuesVerific
Where("id = ?", agent.Agent.ID).
Update("last_seen_at", time.Now().UTC().Add(-1*time.Hour)).Error)
- require.NoError(t, GetVerificationScheduler().reapStaleRuns())
+ require.NoError(t, GetVerificationScheduler().reapStaleRuns(t.Context(), logger.GetLogger()))
requeued := GetVerificationByIDViaAPI(t, router, owner.Token, assignment.VerificationID)
assert.Equal(t, VerificationStatusPending, requeued.Status, "must requeue, not go terminal — retries left")
@@ -305,18 +306,18 @@ func Test_ReapStaleRuns_WhenPendingExceedsMaxDuration_MarksTerminalRegardlessOfP
shrinkThresholds(t, 5*time.Millisecond, 5*time.Second)
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
enableHourlyVerificationViaAPI(t, router, owner.Token, database.ID)
@@ -327,7 +328,7 @@ func Test_ReapStaleRuns_WhenPendingExceedsMaxDuration_MarksTerminalRegardlessOfP
Where("id = ?", stalePending.ID).
Update("created_at", time.Now().UTC().Add(-1*time.Hour)).Error)
- require.NoError(t, GetVerificationScheduler().reapStaleRuns())
+ require.NoError(t, GetVerificationScheduler().reapStaleRuns(t.Context(), logger.GetLogger()))
final := GetVerificationByIDViaAPI(t, router, owner.Token, stalePending.ID)
assert.Equal(t, VerificationStatusFailed, final.Status,
@@ -339,25 +340,25 @@ func Test_ReapStaleRuns_WhenPendingExceedsMaxDuration_MarksTerminalRegardlessOfP
func Test_SweepCanceledByDisabledConfig_WhenScheduledVerificationDisabled_CancelsNonTerminalRows(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
enableHourlyVerificationViaAPI(t, router, owner.Token, database.ID)
scheduler := GetVerificationScheduler()
- require.NoError(t, scheduler.createScheduledRuns())
+ require.NoError(t, scheduler.createScheduledRuns(t.Context(), logger.GetLogger()))
rows := ListVerificationsByDatabaseViaAPI(t, router, owner.Token, database.ID)
require.Len(t, rows, 1)
@@ -370,7 +371,7 @@ func Test_SweepCanceledByDisabledConfig_WhenScheduledVerificationDisabled_Cancel
VerificationInterval: intervals.Interval{Type: intervals.IntervalHourly},
})
- require.NoError(t, scheduler.sweepCanceledByDisabledConfig())
+ require.NoError(t, scheduler.sweepCanceledByDisabledConfig(t.Context(), logger.GetLogger()))
final := GetVerificationByIDViaAPI(t, router, owner.Token, scheduledRowID)
assert.Equal(t, VerificationStatusCanceled, final.Status)
@@ -380,25 +381,25 @@ func Test_SweepCanceledByDisabledConfig_WhenScheduledVerificationDisabled_Cancel
func Test_CreateScheduledRuns_AfterUserCancel_DoesNotImmediatelyRecreate(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
enableHourlyVerificationViaAPI(t, router, owner.Token, database.ID)
scheduler := GetVerificationScheduler()
- require.NoError(t, scheduler.createScheduledRuns())
+ require.NoError(t, scheduler.createScheduledRuns(t.Context(), logger.GetLogger()))
rows := ListVerificationsByDatabaseViaAPI(t, router, owner.Token, database.ID)
require.Len(t, rows, 1)
@@ -406,7 +407,7 @@ func Test_CreateScheduledRuns_AfterUserCancel_DoesNotImmediatelyRecreate(t *test
CancelVerificationViaAPI(t, router, owner.Token, scheduledRowID)
- require.NoError(t, scheduler.createScheduledRuns())
+ require.NoError(t, scheduler.createScheduledRuns(t.Context(), logger.GetLogger()))
rowsAfter := ListVerificationsByDatabaseViaAPI(t, router, owner.Token, database.ID)
assert.Len(
@@ -420,25 +421,25 @@ func Test_CreateScheduledRuns_AfterUserCancel_DoesNotImmediatelyRecreate(t *test
func Test_CreateScheduledRuns_AfterUserCancel_DoesNotRequeueOrRestart(t *testing.T) {
router := createTestRouter()
- owner := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- workspace := workspaces_testing.CreateTestWorkspace("ws "+uuid.New().String(), owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ workspace := workspaces_testing.CreateTestWorkspace(t.Context(), "ws "+uuid.New().String(), owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
testStorage := storages.CreateTestStorage(workspace.ID)
- defer storages.RemoveTestStorage(testStorage.ID)
+ defer storages.RemoveTestStorage(t.Context(), testStorage.ID)
notifier := notifiers.CreateTestNotifier(workspace.ID)
defer notifiers.RemoveTestNotifier(notifier)
database := databases.CreateTestDatabase(workspace.ID, testStorage, notifier)
- defer databases.RemoveTestDatabase(database)
+ defer databases.RemoveTestDatabase(t.Context(), database)
backuping_logical.SeedTestBackup(t, database.ID, testStorage.ID, 100)
enableHourlyVerificationViaAPI(t, router, owner.Token, database.ID)
scheduler := GetVerificationScheduler()
- require.NoError(t, scheduler.createScheduledRuns())
+ require.NoError(t, scheduler.createScheduledRuns(t.Context(), logger.GetLogger()))
rows := ListVerificationsByDatabaseViaAPI(t, router, owner.Token, database.ID)
require.Len(t, rows, 1)
@@ -452,9 +453,9 @@ func Test_CreateScheduledRuns_AfterUserCancel_DoesNotRequeueOrRestart(t *testing
cancelledFinishedAt := *cancelled.FinishedAt
cancelledAttemptCount := cancelled.AttemptCount
- require.NoError(t, scheduler.createScheduledRuns())
- require.NoError(t, scheduler.reapStaleRuns())
- require.NoError(t, scheduler.sweepCanceledByDisabledConfig())
+ require.NoError(t, scheduler.createScheduledRuns(t.Context(), logger.GetLogger()))
+ require.NoError(t, scheduler.reapStaleRuns(t.Context(), logger.GetLogger()))
+ require.NoError(t, scheduler.sweepCanceledByDisabledConfig(t.Context(), logger.GetLogger()))
final := GetVerificationByIDViaAPI(t, router, owner.Token, scheduledRowID)
assert.Equal(t, VerificationStatusCanceled, final.Status)
diff --git a/backend/internal/features/verification/runs/service.go b/backend/internal/features/verification/runs/service.go
index 5bfbc615..90287113 100644
--- a/backend/internal/features/verification/runs/service.go
+++ b/backend/internal/features/verification/runs/service.go
@@ -13,6 +13,7 @@ import (
"gorm.io/gorm"
"databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
backups_core_logical "databasus-backend/internal/features/backups/backups/core/logical"
backups_services "databasus-backend/internal/features/backups/backups/services"
"databasus-backend/internal/features/databases"
@@ -36,6 +37,7 @@ type VerificationService struct {
}
func (s *VerificationService) EnqueueManualVerification(
+ ctx context.Context,
user *users_models.User,
backupID uuid.UUID,
) (*RestoreVerification, error) {
@@ -57,7 +59,7 @@ func (s *VerificationService) EnqueueManualVerification(
return nil, errors.New("cannot verify backup for database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -106,11 +108,11 @@ func (s *VerificationService) EnqueueManualVerification(
return nil, err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("manual backup verification enqueued for database %q", database.Name),
- &user.ID,
- database.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("manual backup verification enqueued for database %q", database.Name),
+ UserID: &user.ID,
+ WorkspaceID: database.WorkspaceID,
+ })
return created, nil
}
@@ -120,10 +122,11 @@ func (s *VerificationService) OnBackupCompleted(backupID uuid.UUID) {
}
func (s *VerificationService) CancelVerification(
+ ctx context.Context,
user *users_models.User,
verificationID uuid.UUID,
) error {
- verification, err := s.verificationRepository.FindByID(verificationID)
+ verification, err := s.verificationRepository.FindByID(ctx, verificationID)
if err != nil {
return err
}
@@ -141,7 +144,7 @@ func (s *VerificationService) CancelVerification(
return errors.New("cannot cancel verification for database without workspace")
}
- canManage, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ canManage, err := s.workspaceService.CanUserManageDBs(ctx, *database.WorkspaceID, user)
if err != nil {
return err
}
@@ -159,16 +162,17 @@ func (s *VerificationService) CancelVerification(
return err
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("backup verification canceled for database %q", database.Name),
- &user.ID,
- database.WorkspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("backup verification canceled for database %q", database.Name),
+ UserID: &user.ID,
+ WorkspaceID: database.WorkspaceID,
+ })
return nil
}
func (s *VerificationService) GetVerificationsByDatabaseID(
+ ctx context.Context,
user *users_models.User,
databaseID uuid.UUID,
limit, offset int,
@@ -182,7 +186,7 @@ func (s *VerificationService) GetVerificationsByDatabaseID(
return nil, errors.New("cannot list verifications for database without workspace")
}
- canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(*database.WorkspaceID, user)
+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, *database.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -216,10 +220,11 @@ func (s *VerificationService) GetVerificationsByDatabaseID(
}
func (s *VerificationService) GetVerificationByID(
+ ctx context.Context,
user *users_models.User,
verificationID uuid.UUID,
) (*RestoreVerification, error) {
- verification, err := s.verificationRepository.FindByID(verificationID)
+ verification, err := s.verificationRepository.FindByID(ctx, verificationID)
if err != nil {
return nil, err
}
@@ -237,7 +242,7 @@ func (s *VerificationService) GetVerificationByID(
return nil, errors.New("cannot view verification for database without workspace")
}
- canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(*database.WorkspaceID, user)
+ canAccess, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, *database.WorkspaceID, user)
if err != nil {
return nil, err
}
@@ -249,6 +254,7 @@ func (s *VerificationService) GetVerificationByID(
}
func (s *VerificationService) ClaimVerification(
+ ctx context.Context,
agent *verification_agents.Agent,
req *ClaimRequest,
) (*JobAssignment, error) {
@@ -276,7 +282,8 @@ func (s *VerificationService) ClaimVerification(
}
if validateErr := validateDatabaseIsVerifiable(database); validateErr != nil {
- s.logger.Warn(
+ s.logger.WarnContext(
+ ctx,
"skipping claim: database not verifiable",
"verification_id", candidate.Verification.ID,
"database_id", candidate.Verification.DatabaseID,
@@ -318,6 +325,7 @@ func (s *VerificationService) ClaimVerification(
}
func (s *VerificationService) OnAgentHeartbeated(
+ ctx context.Context,
agent *verification_agents.Agent,
currentVerificationIDs []uuid.UUID,
) ([]uuid.UUID, error) {
@@ -346,7 +354,7 @@ func (s *VerificationService) OnAgentHeartbeated(
}
}
- s.reclaimDroppedRunningJobs(agent, ownedRunning, reportedVerifications)
+ s.reclaimDroppedRunningJobs(ctx, agent, ownedRunning, reportedVerifications)
return verificationsToAbort, nil
}
@@ -356,7 +364,7 @@ func (s *VerificationService) GetBackupFile(
agent *verification_agents.Agent,
verificationID uuid.UUID,
) (io.ReadCloser, error) {
- verification, err := s.verificationRepository.FindByID(verificationID)
+ verification, err := s.verificationRepository.FindByID(ctx, verificationID)
if err != nil {
return nil, err
}
@@ -382,11 +390,12 @@ func (s *VerificationService) GetBackupFile(
}
func (s *VerificationService) SubmitReport(
+ ctx context.Context,
agent *verification_agents.Agent,
verificationID uuid.UUID,
req *ReportRequest,
) error {
- verification, err := s.verificationRepository.FindByID(verificationID)
+ verification, err := s.verificationRepository.FindByID(ctx, verificationID)
if err != nil {
return err
}
@@ -396,24 +405,25 @@ func (s *VerificationService) SubmitReport(
}
if req.Status == VerificationStatusFailed {
- return s.RequeueOrFail(verification, classifyAgentReport(req), req.FailMessage)
+ return s.RequeueOrFail(ctx, verification, classifyAgentReport(req), req.FailMessage)
}
if restoredDbTooSmall, sizeMessage := s.isRestoredTooSmall(verification, req); restoredDbTooSmall {
- return s.RequeueOrFail(verification, FailureReasonRestoredTooSmall, &sizeMessage)
+ return s.RequeueOrFail(ctx, verification, FailureReasonRestoredTooSmall, &sizeMessage)
}
if err := s.verificationRepository.WriteSuccessReport(verificationID, agent.ID, req); err != nil {
return err
}
- s.syncBackupVerificationStatus(verification, VerificationStatusCompleted)
- s.notifyTerminal(verification, VerificationStatusCompleted, nil)
+ s.syncBackupVerificationStatus(ctx, verification, VerificationStatusCompleted)
+ s.notifyTerminal(ctx, verification, VerificationStatusCompleted, nil)
return nil
}
func (s *VerificationService) RequeueOrFail(
+ ctx context.Context,
row *RestoreVerification,
reason FailureReason,
agentMessage *string,
@@ -431,13 +441,13 @@ func (s *VerificationService) RequeueOrFail(
}
// Re-read so the notification body reflects the row's freshly stamped finished_at.
- updated, err := s.verificationRepository.FindByID(row.ID)
+ updated, err := s.verificationRepository.FindByID(ctx, row.ID)
if err == nil && updated != nil {
row = updated
}
- s.syncBackupVerificationStatus(row, VerificationStatusFailed)
- s.notifyTerminal(row, VerificationStatusFailed, &failMessage)
+ s.syncBackupVerificationStatus(ctx, row, VerificationStatusFailed)
+ s.notifyTerminal(ctx, row, VerificationStatusFailed, &failMessage)
return nil
}
@@ -449,6 +459,7 @@ func (s *VerificationService) RequeueOrFail(
// report the job, so a just-claimed row is legitimately unreported for one
// cycle. Best-effort: it logs its own errors and never fails the heartbeat.
func (s *VerificationService) reclaimDroppedRunningJobs(
+ ctx context.Context,
agent *verification_agents.Agent,
ownedRunning []*RestoreVerification,
reported map[uuid.UUID]struct{},
@@ -465,10 +476,10 @@ func (s *VerificationService) reclaimDroppedRunningJobs(
}
logger := s.logger.With("verification_id", row.ID, "agent_id", agent.ID)
- logger.Info("reclaiming dropped verification")
+ logger.InfoContext(ctx, "reclaiming dropped verification")
- if err := s.RequeueOrFail(row, FailureReasonAgentDroppedJob, nil); err != nil {
- logger.Error("failed to reclaim dropped verification", "error", err)
+ if err := s.RequeueOrFail(ctx, row, FailureReasonAgentDroppedJob, nil); err != nil {
+ logger.ErrorContext(ctx, "failed to reclaim dropped verification", "error", err)
}
}
}
@@ -620,6 +631,7 @@ func (s *VerificationService) isRestoredTooSmall(
}
func (s *VerificationService) syncBackupVerificationStatus(
+ ctx context.Context,
verification *RestoreVerification,
terminalStatus VerificationStatus,
) {
@@ -635,7 +647,8 @@ func (s *VerificationService) syncBackupVerificationStatus(
}
if err := s.backupService.SetRestoreVerificationStatus(verification.BackupID, status); err != nil {
- s.logger.Error(
+ s.logger.ErrorContext(
+ ctx,
"failed to sync backup restore-verification status",
"error", err,
"verification_id", verification.ID,
@@ -645,6 +658,7 @@ func (s *VerificationService) syncBackupVerificationStatus(
}
func (s *VerificationService) notifyTerminal(
+ ctx context.Context,
verification *RestoreVerification,
terminalStatus VerificationStatus,
failMessage *string,
@@ -655,7 +669,7 @@ func (s *VerificationService) notifyTerminal(
config, err := s.configService.GetByDatabaseIDNoAuth(verification.DatabaseID)
if err != nil {
- s.logger.Error(
+ s.logger.ErrorContext(ctx,
"failed to load verification config for notification",
"error", err,
"verification_id", verification.ID,
@@ -679,7 +693,7 @@ func (s *VerificationService) notifyTerminal(
database, err := s.databaseService.GetDatabaseByID(verification.DatabaseID)
if err != nil {
- s.logger.Error(
+ s.logger.ErrorContext(ctx,
"failed to load database for notification",
"error", err,
"verification_id", verification.ID,
@@ -705,9 +719,13 @@ func (s *VerificationService) notifyTerminal(
Message: body,
}
+ // The goroutine outlives the request, so it must not inherit its cancellation: the handler
+ // returning would otherwise cancel the notifier lookup and drop the notification.
+ notifyCtx := context.WithoutCancel(ctx)
+
for i := range database.Notifiers {
notifier := database.Notifiers[i]
- go s.notifierService.SendNotification(&notifier, notification)
+ go s.notifierService.SendNotification(notifyCtx, &notifier, notification)
}
}
diff --git a/backend/internal/features/workspaces/controllers/e2e_test.go b/backend/internal/features/workspaces/controllers/e2e_test.go
index d897c240..3f1e5576 100644
--- a/backend/internal/features/workspaces/controllers/e2e_test.go
+++ b/backend/internal/features/workspaces/controllers/e2e_test.go
@@ -20,11 +20,11 @@ func Test_WorkspaceLifecycleE2E_CompletesSuccessfully(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- users_testing.EnableMemberWorkspaceCreation()
- defer users_testing.ResetSettingsToDefaults()
+ users_testing.EnableMemberWorkspaceCreation(t.Context())
+ defer users_testing.ResetSettingsToDefaults(t.Context())
// 1. Create workspace owner
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
// 2. Owner creates workspace
createRequest := workspaces_dto.CreateWorkspaceRequestDTO{
@@ -66,7 +66,7 @@ func Test_WorkspaceLifecycleE2E_CompletesSuccessfully(t *testing.T) {
assert.True(t, inviteResponse.Status == workspaces_dto.AddStatusInvited)
// 4. Add existing user to workspace
- existingMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ existingMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
addMemberRequest := workspaces_dto.AddMemberRequestDTO{
Email: existingMember.Email,
Role: users_enums.WorkspaceRoleViewer,
@@ -185,12 +185,12 @@ func Test_AdminWorkspaceManagementE2E_CompletesSuccessfully(t *testing.T) {
)
// 1. Create admin and regular user
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- regularUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ regularUser := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
// 2. Regular user creates workspace (with member creation disabled)
- users_testing.DisableMemberWorkspaceCreation()
- defer users_testing.ResetSettingsToDefaults()
+ users_testing.DisableMemberWorkspaceCreation(t.Context())
+ defer users_testing.ResetSettingsToDefaults(t.Context())
// Regular user cannot create workspace
createRequest := workspaces_dto.CreateWorkspaceRequestDTO{
@@ -226,8 +226,8 @@ func Test_AdminWorkspaceManagementE2E_CompletesSuccessfully(t *testing.T) {
adminWorkspaceID := adminWorkspaceResponse.ID
// 4. Admin can view any workspace (even not a member)
- regularUser2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- users_testing.EnableMemberWorkspaceCreation()
+ regularUser2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ users_testing.EnableMemberWorkspaceCreation(t.Context())
regularUserCreateRequest := workspaces_dto.CreateWorkspaceRequestDTO{
Name: "Regular User Workspace 2",
diff --git a/backend/internal/features/workspaces/controllers/membership_controller.go b/backend/internal/features/workspaces/controllers/membership_controller.go
index 8315d0a6..c764544a 100644
--- a/backend/internal/features/workspaces/controllers/membership_controller.go
+++ b/backend/internal/features/workspaces/controllers/membership_controller.go
@@ -53,7 +53,7 @@ func (c *MembershipController) ListMembers(ctx *gin.Context) {
return
}
- response, err := c.membershipService.GetMembers(workspaceID, user)
+ response, err := c.membershipService.GetMembers(ctx.Request.Context(), workspaceID, user)
if err != nil {
if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToViewMembers) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -105,7 +105,7 @@ func (c *MembershipController) AddMember(ctx *gin.Context) {
return
}
- response, err := c.membershipService.AddMember(workspaceID, &request, user)
+ response, err := c.membershipService.AddMember(ctx.Request.Context(), workspaceID, &request, user)
if err != nil {
if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToManageMembers) ||
errors.Is(err, workspaces_errors.ErrOnlyOwnerCanAddManageAdmins) {
@@ -162,6 +162,7 @@ func (c *MembershipController) ChangeMemberRole(ctx *gin.Context) {
}
if err := c.membershipService.ChangeMemberRole(
+ ctx.Request.Context(),
workspaceID,
userID,
&request,
@@ -212,7 +213,7 @@ func (c *MembershipController) RemoveMember(ctx *gin.Context) {
return
}
- if err := c.membershipService.RemoveMember(workspaceID, userID, user); err != nil {
+ if err := c.membershipService.RemoveMember(ctx.Request.Context(), workspaceID, userID, user); err != nil {
if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToRemoveMembers) ||
errors.Is(err, workspaces_errors.ErrOnlyOwnerCanRemoveAdmins) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -259,7 +260,7 @@ func (c *MembershipController) TransferOwnership(ctx *gin.Context) {
return
}
- if err := c.membershipService.TransferOwnership(workspaceID, &request, user); err != nil {
+ if err := c.membershipService.TransferOwnership(ctx.Request.Context(), workspaceID, &request, user); err != nil {
if errors.Is(err, workspaces_errors.ErrOnlyOwnerOrAdminCanTransferOwnership) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
diff --git a/backend/internal/features/workspaces/controllers/membership_controller_test.go b/backend/internal/features/workspaces/controllers/membership_controller_test.go
index f2fcaffb..9f205894 100644
--- a/backend/internal/features/workspaces/controllers/membership_controller_test.go
+++ b/backend/internal/features/workspaces/controllers/membership_controller_test.go
@@ -76,24 +76,24 @@ func Test_GetWorkspaceMembers_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(),
"Test Workspace",
owner,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
member,
*tt.workspaceRole,
@@ -101,7 +101,7 @@ func Test_GetWorkspaceMembers_PermissionsEnforced(t *testing.T) {
)
testUserToken = member.Token
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUserToken = nonMember.Token
}
@@ -140,7 +140,7 @@ func Test_GetWorkspaceMembers_WithInvalidWorkspaceID_ReturnsBadRequest(t *testin
GetWorkspaceController(),
GetMembershipController(),
)
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
resp := test_utils.MakeGetRequest(
t,
@@ -205,25 +205,25 @@ func Test_AddMemberToWorkspace_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- newMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ newMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(),
"Test Workspace",
owner,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.requesterRole != nil && *tt.requesterRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.requesterRole != nil {
- requester := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ requester := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
requester,
*tt.requesterRole,
@@ -270,13 +270,13 @@ func Test_AddMemberToWorkspace_WhenUserIsAlreadyMember_ReturnsBadRequest(t *test
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
member,
users_enums.WorkspaceRoleViewer,
@@ -305,10 +305,10 @@ func Test_AddMemberToWorkspace_WithNonExistentUser_ReturnsInvited(t *testing.T)
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
request := workspaces_dto.AddMemberRequestDTO{
Email: uuid.New().String() + "@example.com", // Non-existent user
@@ -334,14 +334,14 @@ func Test_AddMemberToWorkspace_WhenWorkspaceAdminTriesToAddAdmin_ReturnsBadReque
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaceAdmin := users_testing.CreateTestUser(users_enums.UserRoleMember)
- newMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaceAdmin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ newMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
workspaceAdmin,
users_enums.WorkspaceRoleAdmin,
@@ -372,14 +372,14 @@ func Test_AddMemberToWorkspace_WhenWorkspaceAdminTriesToAddWorkspaceAdmin_Return
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaceAdmin := users_testing.CreateTestUser(users_enums.UserRoleMember)
- newMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaceAdmin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ newMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
workspaceAdmin,
users_enums.WorkspaceRoleAdmin,
@@ -454,25 +454,25 @@ func Test_AddWorkspaceAdmin_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- newMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ newMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(),
"Test Workspace",
owner,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.requesterRole != nil && *tt.requesterRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.requesterRole != nil {
- requester := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ requester := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
requester,
*tt.requesterRole,
@@ -565,26 +565,26 @@ func Test_InviteMemberToWorkspace_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- users_testing.EnableMemberInvitations()
- defer users_testing.ResetSettingsToDefaults()
+ users_testing.EnableMemberInvitations(t.Context())
+ defer users_testing.ResetSettingsToDefaults(t.Context())
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(),
"Test Workspace",
owner,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.requesterRole != nil && *tt.requesterRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.requesterRole != nil {
- requester := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ requester := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
requester,
*tt.requesterRole,
@@ -679,16 +679,16 @@ func Test_ChangeMemberRole_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- targetMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ targetMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(),
"Test Workspace",
owner,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
targetMember,
users_enums.WorkspaceRoleViewer,
@@ -697,13 +697,13 @@ func Test_ChangeMemberRole_PermissionsEnforced(t *testing.T) {
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.requesterRole != nil && *tt.requesterRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.requesterRole != nil {
- requester := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ requester := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
requester,
*tt.requesterRole,
@@ -782,16 +782,16 @@ func Test_ChangeMemberRoleToAdmin_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- targetMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ targetMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(),
"Test Workspace",
owner,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
targetMember,
users_enums.WorkspaceRoleViewer,
@@ -800,13 +800,13 @@ func Test_ChangeMemberRoleToAdmin_PermissionsEnforced(t *testing.T) {
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.requesterRole != nil && *tt.requesterRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.requesterRole != nil {
- requester := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ requester := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
requester,
*tt.requesterRole,
@@ -846,9 +846,9 @@ func Test_ChangeMemberRole_WhenChangingOwnRole_ReturnsBadRequest(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
request := workspaces_dto.ChangeMemberRoleRequestDTO{
Role: users_enums.WorkspaceRoleMember,
@@ -874,11 +874,11 @@ func Test_ChangeMemberRole_WhenChangingOwnerRole_ReturnsBadRequest(t *testing.T)
GetWorkspaceController(),
GetMembershipController(),
)
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
request := workspaces_dto.ChangeMemberRoleRequestDTO{
Role: users_enums.WorkspaceRoleMember,
@@ -952,16 +952,16 @@ func Test_RemoveMemberFromWorkspace_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- targetMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ targetMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(),
"Test Workspace",
owner,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
targetMember,
users_enums.WorkspaceRoleViewer,
@@ -970,13 +970,13 @@ func Test_RemoveMemberFromWorkspace_PermissionsEnforced(t *testing.T) {
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.requesterRole != nil && *tt.requesterRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.requesterRole != nil {
- requester := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ requester := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
requester,
*tt.requesterRole,
@@ -1010,11 +1010,11 @@ func Test_RemoveMemberFromWorkspace_WhenRemovingOwner_ReturnsBadRequest(t *testi
GetWorkspaceController(),
GetMembershipController(),
)
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
resp := test_utils.MakeRequest(t, router, test_utils.RequestOptions{
Method: "DELETE",
@@ -1074,16 +1074,16 @@ func Test_RemoveWorkspaceAdmin_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- targetAdmin := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ targetAdmin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(),
"Test Workspace",
owner,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
targetAdmin,
users_enums.WorkspaceRoleAdmin,
@@ -1092,13 +1092,13 @@ func Test_RemoveWorkspaceAdmin_PermissionsEnforced(t *testing.T) {
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.requesterRole != nil && *tt.requesterRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.requesterRole != nil {
- requester := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ requester := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
requester,
*tt.requesterRole,
@@ -1179,16 +1179,16 @@ func Test_TransferWorkspaceOwnership_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- newOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ newOwner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(),
"Test Workspace",
owner,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
newOwner,
users_enums.WorkspaceRoleMember,
@@ -1197,13 +1197,13 @@ func Test_TransferWorkspaceOwnership_PermissionsEnforced(t *testing.T) {
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.requesterRole != nil && *tt.requesterRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.requesterRole != nil {
- requester := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ requester := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
requester,
*tt.requesterRole,
@@ -1243,11 +1243,11 @@ func Test_TransferWorkspaceOwnership_WhenNewOwnerIsNotMember_ReturnsBadRequest(t
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
request := workspaces_dto.TransferOwnershipRequestDTO{
NewOwnerEmail: nonMember.Email,
@@ -1269,13 +1269,13 @@ func Test_TransferWorkspaceOwnership_ThereIsOnlyOneOwner_OldOwnerBecomeAdmin(t *
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI("Test Workspace", owner, router)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceViaAPI(t.Context(), "Test Workspace", owner, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
- workspaces_testing.AddMemberToWorkspaceViaOwner(
+ workspaces_testing.AddMemberToWorkspaceViaOwner(t.Context(),
workspace,
member,
users_enums.WorkspaceRoleMember,
diff --git a/backend/internal/features/workspaces/controllers/workspace_controller.go b/backend/internal/features/workspaces/controllers/workspace_controller.go
index cf757539..0a4eb830 100644
--- a/backend/internal/features/workspaces/controllers/workspace_controller.go
+++ b/backend/internal/features/workspaces/controllers/workspace_controller.go
@@ -56,7 +56,7 @@ func (c *WorkspaceController) CreateWorkspace(ctx *gin.Context) {
return
}
- response, err := c.workspaceService.CreateWorkspace(&request, user)
+ response, err := c.workspaceService.CreateWorkspace(ctx.Request.Context(), &request, user)
if err != nil {
if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToCreateWorkspaces) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -86,8 +86,10 @@ func (c *WorkspaceController) GetWorkspaces(ctx *gin.Context) {
return
}
- response, err := c.workspaceService.GetUserWorkspaces(user)
+ response, err := c.workspaceService.GetUserWorkspaces(ctx.Request.Context(), user)
if err != nil {
+ _ = ctx.Error(err)
+
ctx.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to retrieve workspaces"})
return
}
@@ -121,7 +123,7 @@ func (c *WorkspaceController) GetWorkspace(ctx *gin.Context) {
return
}
- workspace, err := c.workspaceService.GetWorkspace(workspaceID, user)
+ workspace, err := c.workspaceService.GetWorkspace(ctx.Request.Context(), workspaceID, user)
if err != nil {
if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToViewWorkspace) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -168,7 +170,7 @@ func (c *WorkspaceController) UpdateWorkspace(ctx *gin.Context) {
return
}
- updatedWorkspace, err := c.workspaceService.UpdateWorkspace(workspaceID, &workspace, user)
+ updatedWorkspace, err := c.workspaceService.UpdateWorkspace(ctx.Request.Context(), workspaceID, &workspace, user)
if err != nil {
if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToUpdateWorkspace) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
@@ -206,7 +208,7 @@ func (c *WorkspaceController) DeleteWorkspace(ctx *gin.Context) {
return
}
- if err := c.workspaceService.DeleteWorkspace(workspaceID, user); err != nil {
+ if err := c.workspaceService.DeleteWorkspace(ctx.Request.Context(), workspaceID, user); err != nil {
if errors.Is(err, workspaces_errors.ErrOnlyOwnerOrAdminCanDeleteWorkspace) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
@@ -254,7 +256,7 @@ func (c *WorkspaceController) GetWorkspaceAuditLogs(ctx *gin.Context) {
return
}
- response, err := c.workspaceService.GetWorkspaceAuditLogs(workspaceID, user, request)
+ response, err := c.workspaceService.GetWorkspaceAuditLogs(ctx.Request.Context(), workspaceID, user, request)
if err != nil {
if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToViewWorkspaceAuditLogs) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
diff --git a/backend/internal/features/workspaces/controllers/workspace_controller_test.go b/backend/internal/features/workspaces/controllers/workspace_controller_test.go
index 671fab42..198e1da2 100644
--- a/backend/internal/features/workspaces/controllers/workspace_controller_test.go
+++ b/backend/internal/features/workspaces/controllers/workspace_controller_test.go
@@ -1,6 +1,7 @@
package workspaces_controllers
import (
+ "context"
"fmt"
"net/http"
"testing"
@@ -9,6 +10,7 @@ import (
"github.com/stretchr/testify/assert"
audit_logs "databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
users_dto "databasus-backend/internal/features/users/dto"
users_enums "databasus-backend/internal/features/users/enums"
users_models "databasus-backend/internal/features/users/models"
@@ -62,13 +64,13 @@ func Test_CreateWorkspace_PermissionsEnforced(t *testing.T) {
)
if tt.memberCreationEnabled {
- users_testing.EnableMemberWorkspaceCreation()
+ users_testing.EnableMemberWorkspaceCreation(t.Context())
} else {
- users_testing.DisableMemberWorkspaceCreation()
+ users_testing.DisableMemberWorkspaceCreation(t.Context())
}
- defer users_testing.ResetSettingsToDefaults()
+ defer users_testing.ResetSettingsToDefaults(t.Context())
- user := users_testing.CreateTestUser(tt.userRole)
+ user := users_testing.CreateTestUser(t.Context(), tt.userRole)
uniqueID := uuid.New().String()[:8]
workspaceName := tt.expectedWorkspaceName + " " + uniqueID
@@ -94,7 +96,7 @@ func Test_CreateWorkspace_PermissionsEnforced(t *testing.T) {
// Cleanup created workspace
workspace := &workspaces_models.Workspace{ID: response.ID}
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
} else {
resp := test_utils.MakePostRequest(
t,
@@ -119,7 +121,7 @@ func Test_CreateWorkspace_WithInvalidJSON_ReturnsBadRequest(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- user := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
resp := test_utils.MakeRequest(t, router, test_utils.RequestOptions{
Method: "POST",
@@ -157,21 +159,21 @@ func Test_GetUserWorkspaces_WhenUserHasWorkspaces_ReturnsWorkspacesList(t *testi
GetWorkspaceController(),
GetMembershipController(),
)
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace1, _ := workspaces_testing.CreateTestWorkspaceWithToken(
+ workspace1, _ := workspaces_testing.CreateTestWorkspaceWithToken(t.Context(),
"Workspace 1",
user.Token,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace1, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace1, router)
- workspace2, _ := workspaces_testing.CreateTestWorkspaceWithToken(
+ workspace2, _ := workspaces_testing.CreateTestWorkspaceWithToken(t.Context(),
"Workspace 2",
user.Token,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace2, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace2, router)
var response workspaces_dto.ListWorkspacesResponseDTO
test_utils.MakeGetRequestAndUnmarshal(
@@ -259,22 +261,22 @@ func Test_GetSingleWorkspace_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(t.Context(),
"Test Workspace",
owner.Token,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -284,7 +286,7 @@ func Test_GetSingleWorkspace_PermissionsEnforced(t *testing.T) {
)
testUserToken = member.Token
} else {
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
testUserToken = nonMember.Token
}
@@ -320,7 +322,7 @@ func Test_GetSingleWorkspace_WithInvalidWorkspaceID_ReturnsBadRequest(t *testing
GetWorkspaceController(),
GetMembershipController(),
)
- user := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ user := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
resp := test_utils.MakeGetRequest(
t,
@@ -371,19 +373,19 @@ func Test_UpdateWorkspace_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(t.Context(),
"Original Name",
owner.Token,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
var testUserToken string
if tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -475,25 +477,25 @@ func Test_DeleteWorkspace_PermissionsEnforced(t *testing.T) {
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(t.Context(),
"Test Workspace",
owner.Token,
router,
)
// Only cleanup if the test doesn't successfully delete the workspace
if !tt.expectSuccess {
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
}
var testUserToken string
if tt.isGlobalAdmin {
- admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ admin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
testUserToken = admin.Token
} else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
testUserToken = owner.Token
} else if tt.workspaceRole != nil {
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
workspaces_testing.AddMemberToWorkspace(
workspace,
member,
@@ -529,17 +531,17 @@ func Test_GetWorkspaceAuditLogs_WhenUserIsWorkspaceAdmin_ReturnsAuditLogs(t *tes
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- workspaceAdmin := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ workspaceAdmin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
uniqueID := uuid.New()
workspaceName := fmt.Sprintf("WorkspaceAdmin Test %s", uniqueID.String()[:8])
- workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(
+ workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(t.Context(),
workspaceName,
owner.Token,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
workspaces_testing.AddMemberToWorkspace(
workspace,
@@ -566,27 +568,27 @@ func Test_GetWorkspaceAuditLogs_WithMultipleWorkspaces_ReturnsOnlyWorkspaceSpeci
GetWorkspaceController(),
GetMembershipController(),
)
- owner1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
- owner2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner1 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ owner2 := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
uniqueID1 := uuid.New()
uniqueID2 := uuid.New()
workspaceName1 := fmt.Sprintf("Workspace Test %s", uniqueID1.String()[:8])
workspaceName2 := fmt.Sprintf("Workspace Test %s", uniqueID2.String()[:8])
- workspace1, _ := workspaces_testing.CreateTestWorkspaceWithToken(
+ workspace1, _ := workspaces_testing.CreateTestWorkspaceWithToken(t.Context(),
workspaceName1,
owner1.Token,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace1, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace1, router)
- workspace2, _ := workspaces_testing.CreateTestWorkspaceWithToken(
+ workspace2, _ := workspaces_testing.CreateTestWorkspaceWithToken(t.Context(),
workspaceName2,
owner2.Token,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace2, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace2, router)
updateWorkspace1 := workspaces_models.Workspace{
Name: "Updated " + workspace1.Name,
@@ -661,19 +663,19 @@ func Test_GetWorkspaceAuditLogs_WithDifferentUserRoles_EnforcesPermissionsCorrec
GetWorkspaceController(),
GetMembershipController(),
)
- globalAdmin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
- nonMember := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ globalAdmin := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleAdmin)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ member := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
+ nonMember := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
uniqueID := uuid.New()
workspaceName := fmt.Sprintf("Audit Test Workspace %s", uniqueID.String()[:8])
- workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(
+ workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(t.Context(),
workspaceName,
owner.Token,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
workspaces_testing.AddMemberToWorkspace(
workspace,
@@ -714,14 +716,14 @@ func Test_GetWorkspaceAuditLogs_WithoutAuthToken_ReturnsUnauthorized(t *testing.
GetWorkspaceController(),
GetMembershipController(),
)
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ owner := users_testing.CreateTestUser(t.Context(), users_enums.UserRoleMember)
- workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(
+ workspace, _ := workspaces_testing.CreateTestWorkspaceWithToken(t.Context(),
"Test Workspace",
owner.Token,
router,
)
- defer workspaces_testing.RemoveTestWorkspace(workspace, router)
+ defer workspaces_testing.RemoveTestWorkspace(t.Context(), workspace, router)
test_utils.MakeGetRequest(t, router,
"/api/v1/workspaces/"+workspace.ID.String()+"/audit-logs",
@@ -736,9 +738,9 @@ func extractAuditLogMessages(logs []*audit_logs.AuditLogDTO) []string {
return messages
}
-func getUserFromSignInResponse(response *users_dto.SignInResponseDTO) *users_models.User {
+func getUserFromSignInResponse(ctx context.Context, response *users_dto.SignInResponseDTO) *users_models.User {
userService := users_services.GetUserService()
- user, err := userService.GetUserByID(response.UserID)
+ user, err := userService.GetUserByID(ctx, response.UserID)
if err != nil {
panic(err)
}
@@ -747,9 +749,5 @@ func getUserFromSignInResponse(response *users_dto.SignInResponseDTO) *users_mod
type AuditLogWriterStub struct{}
-func (a *AuditLogWriterStub) WriteAuditLog(
- message string,
- userID *uuid.UUID,
- workspaceID *uuid.UUID,
-) {
+func (a *AuditLogWriterStub) WriteAuditLog(context.Context, audit_logs_models.AuditEntry) {
}
diff --git a/backend/internal/features/workspaces/repositories/membership_repository.go b/backend/internal/features/workspaces/repositories/membership_repository.go
index 3b008729..d4091504 100644
--- a/backend/internal/features/workspaces/repositories/membership_repository.go
+++ b/backend/internal/features/workspaces/repositories/membership_repository.go
@@ -1,6 +1,7 @@
package workspaces_repositories
import (
+ "context"
"errors"
"time"
@@ -76,10 +77,11 @@ func (r *MembershipRepository) RemoveMember(userID, workspaceID uuid.UUID) error
}
func (r *MembershipRepository) GetUserWorkspaceRole(
+ ctx context.Context,
workspaceID, userID uuid.UUID,
) (*users_enums.WorkspaceRole, error) {
var membership workspaces_models.WorkspaceMembership
- err := storage.GetDb().
+ err := storage.GetDb().WithContext(ctx).
Where("workspace_id = ? AND user_id = ?", workspaceID, userID).
First(&membership).Error
if err != nil {
@@ -109,17 +111,18 @@ func (r *MembershipRepository) GetWorkspaceOwner(
}
func (r *MembershipRepository) GetWorkspacesWithRolesByUserID(
+ ctx context.Context,
userRole users_enums.UserRole,
userID uuid.UUID,
) ([]workspaces_dto.WorkspaceResponseDTO, error) {
results := make([]workspaces_dto.WorkspaceResponseDTO, 0)
if userRole == users_enums.UserRoleAdmin {
- err := storage.GetDb().Table("workspaces").Order("name ASC").Scan(&results).Error
+ err := storage.GetDb().WithContext(ctx).Table("workspaces").Order("name ASC").Scan(&results).Error
return results, err
}
- err := storage.GetDb().
+ err := storage.GetDb().WithContext(ctx).
Table("workspaces w").
Select("w.id, w.name, w.created_at, wm.role as user_role").
Joins("JOIN workspace_memberships wm ON w.id = wm.workspace_id").
diff --git a/backend/internal/features/workspaces/services/membership_service.go b/backend/internal/features/workspaces/services/membership_service.go
index b39d83d4..dccdafaf 100644
--- a/backend/internal/features/workspaces/services/membership_service.go
+++ b/backend/internal/features/workspaces/services/membership_service.go
@@ -1,6 +1,7 @@
package workspaces_services
import (
+ "context"
"fmt"
"log/slog"
@@ -8,6 +9,7 @@ import (
"databasus-backend/internal/config"
audit_logs "databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
users_dto "databasus-backend/internal/features/users/dto"
users_enums "databasus-backend/internal/features/users/enums"
users_models "databasus-backend/internal/features/users/models"
@@ -31,10 +33,11 @@ type MembershipService struct {
}
func (s *MembershipService) GetMembers(
+ ctx context.Context,
workspaceID uuid.UUID,
user *users_models.User,
) (*workspaces_dto.GetMembersResponseDTO, error) {
- canView, _, err := s.workspaceService.CanUserAccessWorkspace(workspaceID, user)
+ canView, _, err := s.workspaceService.CanUserAccessWorkspace(ctx, workspaceID, user)
if err != nil {
return nil, err
}
@@ -58,22 +61,23 @@ func (s *MembershipService) GetMembers(
}
func (s *MembershipService) AddMember(
+ ctx context.Context,
workspaceID uuid.UUID,
request *workspaces_dto.AddMemberRequestDTO,
addedBy *users_models.User,
) (*workspaces_dto.AddMemberResponseDTO, error) {
- if err := s.validateCanManageMembership(workspaceID, addedBy, request.Role); err != nil {
+ if err := s.validateCanManageMembership(ctx, workspaceID, addedBy, request.Role); err != nil {
return nil, err
}
- targetUser, err := s.userService.GetUserByEmail(request.Email)
+ targetUser, err := s.userService.GetUserByEmail(ctx, request.Email)
if err != nil {
return nil, err
}
if targetUser == nil {
// User doesn't exist, invite them
- settings, err := s.settingsService.GetSettings()
+ settings, err := s.settingsService.GetSettings(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get settings: %w", err)
}
@@ -94,7 +98,7 @@ func (s *MembershipService) AddMember(
IntendedWorkspaceRole: &request.Role,
}
- inviteResponse, err := s.userService.InviteUser(inviteRequest, addedBy)
+ inviteResponse, err := s.userService.InviteUser(ctx, inviteRequest, addedBy)
if err != nil {
return nil, err
}
@@ -104,7 +108,7 @@ func (s *MembershipService) AddMember(
body := s.buildInvitationEmailHTML(workspace.Name, addedBy.Name, string(request.Role))
if err := s.emailSender.SendEmail(request.Email, subject, body); err != nil {
- s.logger.Error("Failed to send invitation email", "email", request.Email, "error", err)
+ s.logger.ErrorContext(ctx, "failed to send invitation email", "email", request.Email, "error", err)
}
membership := &workspaces_models.WorkspaceMembership{
@@ -117,15 +121,11 @@ func (s *MembershipService) AddMember(
return nil, fmt.Errorf("failed to add member: %w", err)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf(
- "User invited to workspace: %s and added as %s",
- request.Email,
- request.Role,
- ),
- &addedBy.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("User invited to workspace: %s and added as %s", request.Email, request.Role),
+ UserID: &addedBy.ID,
+ WorkspaceID: &workspaceID,
+ })
return &workspaces_dto.AddMemberResponseDTO{
Status: workspaces_dto.AddStatusInvited,
@@ -150,11 +150,11 @@ func (s *MembershipService) AddMember(
return nil, fmt.Errorf("failed to add member: %w", err)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("User added to workspace: %s as %s", targetUser.Email, request.Role),
- &addedBy.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("User added to workspace: %s as %s", targetUser.Email, request.Role),
+ UserID: &addedBy.ID,
+ WorkspaceID: &workspaceID,
+ })
return &workspaces_dto.AddMemberResponseDTO{
Status: workspaces_dto.AddStatusAdded,
@@ -162,12 +162,13 @@ func (s *MembershipService) AddMember(
}
func (s *MembershipService) ChangeMemberRole(
+ ctx context.Context,
workspaceID uuid.UUID,
memberUserID uuid.UUID,
request *workspaces_dto.ChangeMemberRoleRequestDTO,
changedBy *users_models.User,
) error {
- if err := s.validateCanManageMembership(workspaceID, changedBy, request.Role); err != nil {
+ if err := s.validateCanManageMembership(ctx, workspaceID, changedBy, request.Role); err != nil {
return err
}
@@ -187,7 +188,7 @@ func (s *MembershipService) ChangeMemberRole(
return workspaces_errors.ErrCannotChangeOwnerRole
}
- targetUser, err := s.userService.GetUserByID(memberUserID)
+ targetUser, err := s.userService.GetUserByID(ctx, memberUserID)
if err != nil {
return workspaces_errors.ErrUserNotFound
}
@@ -200,26 +201,27 @@ func (s *MembershipService) ChangeMemberRole(
return fmt.Errorf("failed to update member role: %w", err)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf(
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf(
"Member role changed: %s from %s to %s",
targetUser.Email,
existingMembership.Role,
request.Role,
),
- &changedBy.ID,
- &workspaceID,
- )
+ UserID: &changedBy.ID,
+ WorkspaceID: &workspaceID,
+ })
return nil
}
func (s *MembershipService) RemoveMember(
+ ctx context.Context,
workspaceID uuid.UUID,
memberUserID uuid.UUID,
removedBy *users_models.User,
) error {
- canManage, err := s.workspaceService.CanUserManageMembership(workspaceID, removedBy)
+ canManage, err := s.workspaceService.CanUserManageMembership(ctx, workspaceID, removedBy)
if err != nil {
return err
}
@@ -241,7 +243,7 @@ func (s *MembershipService) RemoveMember(
}
if existingMembership.Role == users_enums.WorkspaceRoleAdmin {
- canManageAdmins, err := s.workspaceService.CanUserManageAdmins(workspaceID, removedBy)
+ canManageAdmins, err := s.workspaceService.CanUserManageAdmins(ctx, workspaceID, removedBy)
if err != nil {
return err
}
@@ -250,7 +252,7 @@ func (s *MembershipService) RemoveMember(
}
}
- targetUser, err := s.userService.GetUserByID(memberUserID)
+ targetUser, err := s.userService.GetUserByID(ctx, memberUserID)
if err != nil {
return workspaces_errors.ErrUserNotFound
}
@@ -259,21 +261,22 @@ func (s *MembershipService) RemoveMember(
return fmt.Errorf("failed to remove member: %w", err)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Member removed from workspace: %s", targetUser.Email),
- &removedBy.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Member removed from workspace: %s", targetUser.Email),
+ UserID: &removedBy.ID,
+ WorkspaceID: &workspaceID,
+ })
return nil
}
func (s *MembershipService) TransferOwnership(
+ ctx context.Context,
workspaceID uuid.UUID,
request *workspaces_dto.TransferOwnershipRequestDTO,
user *users_models.User,
) error {
- currentRole, err := s.membershipRepository.GetUserWorkspaceRole(workspaceID, user.ID)
+ currentRole, err := s.membershipRepository.GetUserWorkspaceRole(ctx, workspaceID, user.ID)
if err != nil {
return fmt.Errorf("failed to get current user role: %w", err)
}
@@ -283,7 +286,7 @@ func (s *MembershipService) TransferOwnership(
return workspaces_errors.ErrOnlyOwnerOrAdminCanTransferOwnership
}
- newOwner, err := s.userService.GetUserByEmail(request.NewOwnerEmail)
+ newOwner, err := s.userService.GetUserByEmail(ctx, request.NewOwnerEmail)
if err != nil {
return workspaces_errors.ErrNewOwnerNotFound
}
@@ -322,22 +325,23 @@ func (s *MembershipService) TransferOwnership(
return fmt.Errorf("failed to update previous owner role: %w", err)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Workspace ownership transferred to: %s", newOwner.Email),
- &user.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Workspace ownership transferred to: %s", newOwner.Email),
+ UserID: &user.ID,
+ WorkspaceID: &workspaceID,
+ })
return nil
}
func (s *MembershipService) validateCanManageMembership(
+ ctx context.Context,
workspaceID uuid.UUID,
user *users_models.User,
changesRoleTo users_enums.WorkspaceRole,
) error {
if changesRoleTo == users_enums.WorkspaceRoleAdmin {
- canManageAdmins, err := s.workspaceService.CanUserManageAdmins(workspaceID, user)
+ canManageAdmins, err := s.workspaceService.CanUserManageAdmins(ctx, workspaceID, user)
if err != nil {
return err
}
@@ -347,7 +351,7 @@ func (s *MembershipService) validateCanManageMembership(
return nil
}
- canManageMembership, err := s.workspaceService.CanUserManageMembership(workspaceID, user)
+ canManageMembership, err := s.workspaceService.CanUserManageMembership(ctx, workspaceID, user)
if err != nil {
return err
}
diff --git a/backend/internal/features/workspaces/services/workspace_service.go b/backend/internal/features/workspaces/services/workspace_service.go
index 937a77e4..6deea098 100644
--- a/backend/internal/features/workspaces/services/workspace_service.go
+++ b/backend/internal/features/workspaces/services/workspace_service.go
@@ -1,12 +1,14 @@
package workspaces_services
import (
+ "context"
"fmt"
"time"
"github.com/google/uuid"
audit_logs "databasus-backend/internal/features/audit_logs"
+ audit_logs_models "databasus-backend/internal/features/audit_logs/models"
users_enums "databasus-backend/internal/features/users/enums"
users_models "databasus-backend/internal/features/users/models"
users_services "databasus-backend/internal/features/users/services"
@@ -33,10 +35,11 @@ func (s *WorkspaceService) AddWorkspaceDeletionListener(
}
func (s *WorkspaceService) CreateWorkspace(
+ ctx context.Context,
request *workspaces_dto.CreateWorkspaceRequestDTO,
creator *users_models.User,
) (*workspaces_dto.WorkspaceResponseDTO, error) {
- settings, err := s.settingsService.GetSettings()
+ settings, err := s.settingsService.GetSettings(ctx)
if err != nil {
return nil, fmt.Errorf("failed to get settings: %w", err)
}
@@ -66,11 +69,11 @@ func (s *WorkspaceService) CreateWorkspace(
return nil, fmt.Errorf("failed to create workspace membership: %w", err)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Workspace created: %s", workspace.Name),
- &creator.ID,
- &workspace.ID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Workspace created: %s", workspace.Name),
+ UserID: &creator.ID,
+ WorkspaceID: &workspace.ID,
+ })
ownerRole := users_enums.WorkspaceRoleOwner
return &workspaces_dto.WorkspaceResponseDTO{
@@ -82,10 +85,11 @@ func (s *WorkspaceService) CreateWorkspace(
}
func (s *WorkspaceService) GetWorkspace(
+ ctx context.Context,
workspaceID uuid.UUID,
user *users_models.User,
) (*workspaces_models.Workspace, error) {
- canView, _, err := s.CanUserAccessWorkspace(workspaceID, user)
+ canView, _, err := s.CanUserAccessWorkspace(ctx, workspaceID, user)
if err != nil {
return nil, err
}
@@ -97,9 +101,10 @@ func (s *WorkspaceService) GetWorkspace(
}
func (s *WorkspaceService) GetUserWorkspaces(
+ ctx context.Context,
user *users_models.User,
) (*workspaces_dto.ListWorkspacesResponseDTO, error) {
- workspaces, err := s.membershipRepository.GetWorkspacesWithRolesByUserID(user.Role, user.ID)
+ workspaces, err := s.membershipRepository.GetWorkspacesWithRolesByUserID(ctx, user.Role, user.ID)
if err != nil {
return nil, fmt.Errorf("failed to get user workspaces: %w", err)
}
@@ -110,11 +115,12 @@ func (s *WorkspaceService) GetUserWorkspaces(
}
func (s *WorkspaceService) UpdateWorkspace(
+ ctx context.Context,
workspaceID uuid.UUID,
updateDTO *workspaces_models.Workspace,
user *users_models.User,
) (*workspaces_models.Workspace, error) {
- canManage, err := s.CanUserManageWorkspace(workspaceID, user)
+ canManage, err := s.CanUserManageWorkspace(ctx, workspaceID, user)
if err != nil {
return nil, err
}
@@ -139,25 +145,25 @@ func (s *WorkspaceService) UpdateWorkspace(
}
if oldName != updateDTO.Name {
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Workspace updated and renamed from '%s' to '%s'", oldName, updateDTO.Name),
- &user.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Workspace updated and renamed from '%s' to '%s'", oldName, updateDTO.Name),
+ UserID: &user.ID,
+ WorkspaceID: &workspaceID,
+ })
} else {
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Workspace updated: %s", updateDTO.Name),
- &user.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Workspace updated: %s", updateDTO.Name),
+ UserID: &user.ID,
+ WorkspaceID: &workspaceID,
+ })
}
return existingWorkspace, nil
}
-func (s *WorkspaceService) DeleteWorkspace(workspaceID uuid.UUID, user *users_models.User) error {
+func (s *WorkspaceService) DeleteWorkspace(ctx context.Context, workspaceID uuid.UUID, user *users_models.User) error {
if user.Role != users_enums.UserRoleAdmin {
- userWorkspaceRole, err := s.GetUserWorkspaceRole(workspaceID, user.ID)
+ userWorkspaceRole, err := s.GetUserWorkspaceRole(ctx, workspaceID, user.ID)
if err != nil {
return fmt.Errorf("failed to get user role: %w", err)
}
@@ -182,23 +188,25 @@ func (s *WorkspaceService) DeleteWorkspace(workspaceID uuid.UUID, user *users_mo
return fmt.Errorf("failed to delete workspace: %w", err)
}
- s.auditLogService.WriteAuditLog(
- fmt.Sprintf("Workspace deleted: %s", workspace.Name),
- &user.ID,
- &workspaceID,
- )
+ s.auditLogService.WriteAuditLog(ctx, audit_logs_models.AuditEntry{
+ Message: fmt.Sprintf("Workspace deleted: %s", workspace.Name),
+ UserID: &user.ID,
+ WorkspaceID: &workspaceID,
+ })
return nil
}
func (s *WorkspaceService) GetUserWorkspaceRole(
+ ctx context.Context,
workspaceID uuid.UUID,
userID uuid.UUID,
) (*users_enums.WorkspaceRole, error) {
- return s.membershipRepository.GetUserWorkspaceRole(workspaceID, userID)
+ return s.membershipRepository.GetUserWorkspaceRole(ctx, workspaceID, userID)
}
func (s *WorkspaceService) CanUserAccessWorkspace(
+ ctx context.Context,
workspaceID uuid.UUID,
user *users_models.User,
) (bool, *users_enums.WorkspaceRole, error) {
@@ -207,7 +215,7 @@ func (s *WorkspaceService) CanUserAccessWorkspace(
return true, &adminRole, nil
}
- role, err := s.membershipRepository.GetUserWorkspaceRole(workspaceID, user.ID)
+ role, err := s.membershipRepository.GetUserWorkspaceRole(ctx, workspaceID, user.ID)
if err != nil {
return false, nil, nil
}
@@ -216,6 +224,7 @@ func (s *WorkspaceService) CanUserAccessWorkspace(
}
func (s *WorkspaceService) CanUserManageWorkspace(
+ ctx context.Context,
workspaceID uuid.UUID,
user *users_models.User,
) (bool, error) {
@@ -223,7 +232,7 @@ func (s *WorkspaceService) CanUserManageWorkspace(
return true, nil
}
- role, err := s.membershipRepository.GetUserWorkspaceRole(workspaceID, user.ID)
+ role, err := s.membershipRepository.GetUserWorkspaceRole(ctx, workspaceID, user.ID)
if err != nil {
return false, err
}
@@ -237,6 +246,7 @@ func (s *WorkspaceService) CanUserManageWorkspace(
}
func (s *WorkspaceService) CanUserManageDBs(
+ ctx context.Context,
workspaceID uuid.UUID,
user *users_models.User,
) (bool, error) {
@@ -244,7 +254,7 @@ func (s *WorkspaceService) CanUserManageDBs(
return true, nil
}
- role, err := s.membershipRepository.GetUserWorkspaceRole(workspaceID, user.ID)
+ role, err := s.membershipRepository.GetUserWorkspaceRole(ctx, workspaceID, user.ID)
if err != nil {
return false, err
}
@@ -258,6 +268,7 @@ func (s *WorkspaceService) CanUserManageDBs(
}
func (s *WorkspaceService) CanUserManageMembership(
+ ctx context.Context,
workspaceID uuid.UUID,
user *users_models.User,
) (bool, error) {
@@ -265,7 +276,7 @@ func (s *WorkspaceService) CanUserManageMembership(
return true, nil
}
- role, err := s.membershipRepository.GetUserWorkspaceRole(workspaceID, user.ID)
+ role, err := s.membershipRepository.GetUserWorkspaceRole(ctx, workspaceID, user.ID)
if err != nil {
return false, err
}
@@ -278,6 +289,7 @@ func (s *WorkspaceService) CanUserManageMembership(
}
func (s *WorkspaceService) CanUserManageAdmins(
+ ctx context.Context,
workspaceID uuid.UUID,
user *users_models.User,
) (bool, error) {
@@ -285,7 +297,7 @@ func (s *WorkspaceService) CanUserManageAdmins(
return true, nil
}
- role, err := s.membershipRepository.GetUserWorkspaceRole(workspaceID, user.ID)
+ role, err := s.membershipRepository.GetUserWorkspaceRole(ctx, workspaceID, user.ID)
if err != nil {
return false, err
}
@@ -298,11 +310,12 @@ func (s *WorkspaceService) CanUserManageAdmins(
}
func (s *WorkspaceService) GetWorkspaceAuditLogs(
+ ctx context.Context,
workspaceID uuid.UUID,
user *users_models.User,
request *audit_logs.GetAuditLogsRequest,
) (*audit_logs.GetAuditLogsResponse, error) {
- canView, _, err := s.CanUserAccessWorkspace(workspaceID, user)
+ canView, _, err := s.CanUserAccessWorkspace(ctx, workspaceID, user)
if err != nil {
return nil, err
}
@@ -310,7 +323,7 @@ func (s *WorkspaceService) GetWorkspaceAuditLogs(
return nil, workspaces_errors.ErrInsufficientPermissionsToViewWorkspaceAuditLogs
}
- return s.auditLogService.GetWorkspaceAuditLogs(workspaceID, request)
+ return s.auditLogService.GetWorkspaceAuditLogs(ctx, workspaceID, request)
}
func (s *WorkspaceService) GetAllWorkspaces() ([]*workspaces_models.Workspace, error) {
diff --git a/backend/internal/features/workspaces/testing/testing.go b/backend/internal/features/workspaces/testing/testing.go
index 169f669f..48f182f9 100644
--- a/backend/internal/features/workspaces/testing/testing.go
+++ b/backend/internal/features/workspaces/testing/testing.go
@@ -41,39 +41,43 @@ func CreateTestRouter(controllers ...ControllerInterface) *gin.Engine {
}
func CreateTestWorkspace(
+ ctx context.Context,
name string,
owner *users_dto.SignInResponseDTO,
router *gin.Engine,
) *workspaces_models.Workspace {
- workspace, _ := CreateTestWorkspaceViaAPI(name, owner, router)
+ workspace, _ := CreateTestWorkspaceViaAPI(ctx, name, owner, router)
return workspace
}
func CreateTestWorkspaceViaAPI(
+ ctx context.Context,
name string,
owner *users_dto.SignInResponseDTO,
router *gin.Engine,
) (*workspaces_models.Workspace, string) {
- return createTestWorkspaceViaAPI(name, owner, router, true)
+ return createTestWorkspaceViaAPI(ctx, name, owner, router, true)
}
func CreateTestWorkspaceViaAPIWithoutSettingsChange(
+ ctx context.Context,
name string,
owner *users_dto.SignInResponseDTO,
router *gin.Engine,
) (*workspaces_models.Workspace, string) {
- return createTestWorkspaceViaAPI(name, owner, router, false)
+ return createTestWorkspaceViaAPI(ctx, name, owner, router, false)
}
func createTestWorkspaceViaAPI(
+ ctx context.Context,
name string,
owner *users_dto.SignInResponseDTO,
router *gin.Engine,
enableMemberCreation bool,
) (*workspaces_models.Workspace, string) {
if enableMemberCreation {
- users_testing.EnableMemberWorkspaceCreation()
- defer users_testing.ResetSettingsToDefaults()
+ users_testing.EnableMemberWorkspaceCreation(ctx)
+ defer users_testing.ResetSettingsToDefaults(ctx)
}
request := workspaces_dto.CreateWorkspaceRequestDTO{Name: name}
@@ -103,30 +107,33 @@ func createTestWorkspaceViaAPI(
}
func CreateTestWorkspaceWithToken(
+ ctx context.Context,
name string,
token string,
router *gin.Engine,
) (*workspaces_models.Workspace, string) {
- return createTestWorkspaceWithToken(name, token, router, true)
+ return createTestWorkspaceWithToken(ctx, name, token, router, true)
}
func CreateTestWorkspaceWithTokenWithoutSettingsChange(
+ ctx context.Context,
name string,
token string,
router *gin.Engine,
) (*workspaces_models.Workspace, string) {
- return createTestWorkspaceWithToken(name, token, router, false)
+ return createTestWorkspaceWithToken(ctx, name, token, router, false)
}
func createTestWorkspaceWithToken(
+ ctx context.Context,
name string,
token string,
router *gin.Engine,
enableMemberCreation bool,
) (*workspaces_models.Workspace, string) {
if enableMemberCreation {
- users_testing.EnableMemberWorkspaceCreation()
- defer users_testing.ResetSettingsToDefaults()
+ users_testing.EnableMemberWorkspaceCreation(ctx)
+ defer users_testing.ResetSettingsToDefaults(ctx)
}
request := workspaces_dto.CreateWorkspaceRequestDTO{Name: name}
@@ -181,6 +188,7 @@ func AddMemberToWorkspace(
}
func AddMemberToWorkspaceViaOwner(
+ ctx context.Context,
workspace *workspaces_models.Workspace,
member *users_dto.SignInResponseDTO,
role users_enums.WorkspaceRole,
@@ -197,12 +205,12 @@ func AddMemberToWorkspaceViaOwner(
if m.Role == users_enums.WorkspaceRoleOwner {
userService := users_services.GetUserService()
- owner, err := userService.GetUserByID(m.UserID)
+ owner, err := userService.GetUserByID(ctx, m.UserID)
if err != nil {
panic("Failed to get owner user: " + err.Error())
}
- tokenResponse, err := userService.GenerateAccessToken(owner)
+ tokenResponse, err := userService.GenerateAccessToken(ctx, owner)
if err != nil {
panic("Failed to generate owner token: " + err.Error())
}
@@ -372,7 +380,11 @@ func DeleteWorkspace(
}
}
-func RemoveTestWorkspace(workspace *workspaces_models.Workspace, router *gin.Engine) {
+// The context is stripped of cancellation because callers pass t.Context() from a t.Cleanup, and
+// the test context is already cancelled by the time cleanup runs.
+func RemoveTestWorkspace(ctx context.Context, workspace *workspaces_models.Workspace, router *gin.Engine) {
+ ctx = context.WithoutCancel(ctx)
+
membershipRepo := &workspaces_repositories.MembershipRepository{}
workspaceMembers, err := membershipRepo.GetWorkspaceMembers(workspace.ID)
if err != nil {
@@ -390,14 +402,14 @@ func RemoveTestWorkspace(workspace *workspaces_models.Workspace, router *gin.Eng
if m.Role == users_enums.WorkspaceRoleOwner {
userService := users_services.GetUserService()
- owner, err := userService.GetUserByID(m.UserID)
+ owner, err := userService.GetUserByID(ctx, m.UserID)
if err != nil {
// Owner user not found, workspace might be in inconsistent state, try direct deletion
_ = RemoveTestWorkspaceDirect(workspace.ID)
return
}
- tokenResponse, err := userService.GenerateAccessToken(owner)
+ tokenResponse, err := userService.GenerateAccessToken(ctx, owner)
if err != nil {
// Cannot generate token, try direct deletion
_ = RemoveTestWorkspaceDirect(workspace.ID)
diff --git a/backend/internal/storage/storage.go b/backend/internal/storage/storage.go
index 2e95ace2..ad6a62ae 100644
--- a/backend/internal/storage/storage.go
+++ b/backend/internal/storage/storage.go
@@ -1,7 +1,6 @@
package storage
import (
- "os"
"sync"
"gorm.io/driver/postgres"
@@ -30,20 +29,20 @@ func loadDbs() {
func LoadMainDb() {
dbDsn := config.GetEnv().DatabaseDsn
- log.Info("Connection to database...")
+ log.Info("connection to database")
database, err := gorm.Open(postgres.Open(dbDsn), &gorm.Config{
Logger: gormLogger.Default.LogMode(gormLogger.Silent),
})
if err != nil {
log.Error("error on connecting to database", "error", err)
- os.Exit(1)
+ logger.ExitAfterFlush(1)
}
sqlDB, err := database.DB()
if err != nil {
log.Error("error getting underlying sql.DB", "error", err)
- os.Exit(1)
+ logger.ExitAfterFlush(1)
}
sqlDB.SetMaxOpenConns(10)
@@ -51,5 +50,5 @@ func LoadMainDb() {
db = database
- log.Info("Main database connected successfully!")
+ log.Info("main database connected successfully")
}
diff --git a/backend/internal/util/cache/pubsub.go b/backend/internal/util/cache/pubsub.go
index f541c34e..89d411b6 100644
--- a/backend/internal/util/cache/pubsub.go
+++ b/backend/internal/util/cache/pubsub.go
@@ -96,7 +96,7 @@ func (m *PubSubManager) Publish(ctx context.Context, channel, message string) er
result := m.client.Do(ctx, cmd)
if err := result.Error(); err != nil {
- m.logger.Error("Failed to publish message to Redis", "channel", channel, "error", err)
+ m.logger.ErrorContext(ctx, "failed to publish message to Redis", "channel", channel, "error", err)
return fmt.Errorf("failed to publish message: %w", err)
}
@@ -122,11 +122,11 @@ func (m *PubSubManager) subscriptionLoop(
) {
defer func() {
if r := recover(); r != nil {
- m.logger.Error("Panic in subscription handler", "channel", channel, "panic", r)
+ m.logger.ErrorContext(ctx, "panic in subscription handler", "channel", channel, "panic", r)
}
}()
- m.logger.Info("Starting subscription", "channel", channel)
+ m.logger.InfoContext(ctx, "starting subscription", "channel", channel)
err := m.client.Receive(
ctx,
@@ -134,7 +134,7 @@ func (m *PubSubManager) subscriptionLoop(
func(msg valkey.PubSubMessage) {
defer func() {
if r := recover(); r != nil {
- m.logger.Error("Panic in message handler", "channel", channel, "panic", r)
+ m.logger.ErrorContext(ctx, "panic in message handler", "channel", channel, "panic", r)
}
}()
@@ -143,9 +143,9 @@ func (m *PubSubManager) subscriptionLoop(
)
if err != nil && ctx.Err() == nil {
- m.logger.Error("Subscription error", "channel", channel, "error", err)
+ m.logger.ErrorContext(ctx, "subscription error", "channel", channel, "error", err)
} else if ctx.Err() != nil {
- m.logger.Info("Subscription cancelled", "channel", channel)
+ m.logger.InfoContext(ctx, "subscription cancelled", "channel", channel)
}
m.mu.Lock()
diff --git a/backend/internal/util/cache/utils.go b/backend/internal/util/cache/utils.go
index a16aaaa4..cd65d4c9 100644
--- a/backend/internal/util/cache/utils.go
+++ b/backend/internal/util/cache/utils.go
@@ -6,6 +6,8 @@ import (
"time"
"github.com/valkey-io/valkey-go"
+
+ "databasus-backend/internal/util/logger"
)
const (
@@ -37,17 +39,27 @@ func (c *CacheUtil[T]) Get(key string) *T {
fullKey := c.prefix + key
result := c.client.Do(ctx, c.client.B().Get().Key(fullKey).Build())
- if result.Error() != nil {
+ if err := result.Error(); err != nil {
+ // A missing key is the normal case and says nothing; anything else means the cache is down,
+ // which is otherwise indistinguishable from a miss at every call site.
+ if !valkey.IsValkeyNil(err) {
+ logger.GetLogger().Warn("cache read failed", "cache_key", fullKey, "error", err)
+ }
+
return nil
}
data, err := result.AsBytes()
if err != nil {
+ logger.GetLogger().Warn("cache read returned an unreadable value", "cache_key", fullKey, "error", err)
+
return nil
}
var item T
if err := json.Unmarshal(data, &item); err != nil {
+ logger.GetLogger().Warn("cache read returned malformed json", "cache_key", fullKey, "error", err)
+
return nil
}
diff --git a/backend/internal/util/io/resuming_reader.go b/backend/internal/util/io/resuming_reader.go
index f2e4f778..ed8ffdce 100644
--- a/backend/internal/util/io/resuming_reader.go
+++ b/backend/internal/util/io/resuming_reader.go
@@ -225,7 +225,8 @@ func (r *ResumingReader) resumeAfterFailure(cause error) error {
)
}
- r.logger.Warn(
+ r.logger.WarnContext(
+ r.streamCtx,
fmt.Sprintf(
"storage read failed, resuming from offset %d (attempt %d of %d)",
r.deliveredBytes,
diff --git a/backend/internal/util/tools/common.go b/backend/internal/util/tools/common.go
index 3fce4be4..f9afaf9d 100644
--- a/backend/internal/util/tools/common.go
+++ b/backend/internal/util/tools/common.go
@@ -7,6 +7,8 @@ import (
"os"
"path/filepath"
"strings"
+
+ "databasus-backend/internal/util/logger"
)
// ToolCheckResult is one DB-version bundle's verification outcome. A bundle
@@ -64,15 +66,14 @@ func CheckAllClientTools() []ToolCheckResult {
return results
}
-// LogAndExitIfClientToolsBroken logs every check result and exits the process
-// if any fatal-tier (Postgres) bundle has errors. Non-fatal bundles only warn.
-// Used by config at application startup.
-func LogAndExitIfClientToolsBroken(logger *slog.Logger, isShowLogs bool) {
+// Only the Postgres bundle is fatal: the others degrade to a warning because an instance that
+// backs up no MySQL database has no reason to refuse to start over a missing mysqldump.
+func LogAndExitIfClientToolsBroken(toolsLogger *slog.Logger, isShowLogs bool) {
results := CheckAllClientTools()
hasFatalError := false
for _, r := range results {
- log := logger.With("db", r.Db, "version", r.Version, "path", r.BinDir)
+ log := toolsLogger.With("db", r.Db, "version", r.Version, "path", r.BinDir)
if len(r.Errors) == 0 {
if isShowLogs {
@@ -93,7 +94,7 @@ func LogAndExitIfClientToolsBroken(logger *slog.Logger, isShowLogs bool) {
}
if hasFatalError {
- os.Exit(1)
+ logger.ExitAfterFlush(1)
}
}