!96 删除数据库备份和恢复历史

* feat: 删除数据库备份历史
* refactor dbScheduler
* feat: 从数据库备份历史中恢复数据库
* feat: 删除数据库恢复历史记录
* refactor dbScheuler

server/internal/db/application/db_scheduler.go

@@ -4,10 +4,10 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"gorm.io/gorm"
 	"mayfly-go/internal/db/dbm/dbi"
 	"mayfly-go/internal/db/domain/entity"
 	"mayfly-go/internal/db/domain/repository"
-	"mayfly-go/pkg/logx"
 	"mayfly-go/pkg/runner"
 	"reflect"
 	"sync"
@@ -35,6 +35,7 @@ func newDbScheduler() *dbScheduler {
 	scheduler.runner = runner.NewRunner[entity.DbJob](maxRunning, scheduler.runJob,
 		runner.WithScheduleJob[entity.DbJob](scheduler.scheduleJob),
 		runner.WithRunnableJob[entity.DbJob](scheduler.runnableJob),
+		runner.WithUpdateJob[entity.DbJob](scheduler.updateJob),
 	)
 	return scheduler
 }
@@ -43,27 +44,11 @@ func (s *dbScheduler) scheduleJob(job entity.DbJob) (time.Time, error) {
 	return job.Schedule()
 }
 
-func (s *dbScheduler) repo(typ entity.DbJobType) repository.DbJob {
-	switch typ {
-	case entity.DbJobTypeBackup:
-		return s.backupRepo
-	case entity.DbJobTypeRestore:
-		return s.restoreRepo
-	case entity.DbJobTypeBinlog:
-		return s.binlogRepo
-	default:
-		panic(fmt.Errorf("无效的数据库任务类型: %v", typ))
-	}
-}
-
 func (s *dbScheduler) UpdateJob(ctx context.Context, job entity.DbJob) error {
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
 
-	if err := s.repo(job.GetJobType()).UpdateById(ctx, job); err != nil {
-		return err
-	}
-	_ = s.runner.UpdateOrAdd(ctx, job)
+	_ = s.runner.Update(ctx, job)
 	return nil
 }
 
@@ -71,28 +56,20 @@ func (s *dbScheduler) Close() {
 	s.runner.Close()
 }
 
-func (s *dbScheduler) AddJob(ctx context.Context, saving bool, jobType entity.DbJobType, jobs any) error {
+func (s *dbScheduler) AddJob(ctx context.Context, jobs any) error {
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
 
-	if saving {
-		if err := s.repo(jobType).AddJob(ctx, jobs); err != nil {
-			return err
-		}
-	}
-
 	reflectValue := reflect.ValueOf(jobs)
 	switch reflectValue.Kind() {
 	case reflect.Array, reflect.Slice:
 		reflectLen := reflectValue.Len()
 		for i := 0; i < reflectLen; i++ {
 			job := reflectValue.Index(i).Interface().(entity.DbJob)
-			job.SetJobType(jobType)
 			_ = s.runner.Add(ctx, job)
 		}
 	default:
 		job := jobs.(entity.DbJob)
-		job.SetJobType(jobType)
 		_ = s.runner.Add(ctx, job)
 	}
 	return nil
@@ -103,29 +80,16 @@ func (s *dbScheduler) RemoveJob(ctx context.Context, jobType entity.DbJobType, j
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
 
-	if err := s.repo(jobType).DeleteById(ctx, jobId); err != nil {
+	if err := s.runner.Remove(ctx, entity.FormatJobKey(jobType, jobId)); err != nil {
 		return err
 	}
-	_ = s.runner.Remove(ctx, entity.FormatJobKey(jobType, jobId))
 	return nil
 }
 
-func (s *dbScheduler) EnableJob(ctx context.Context, jobType entity.DbJobType, jobId uint64) error {
+func (s *dbScheduler) EnableJob(ctx context.Context, job entity.DbJob) error {
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
 
-	repo := s.repo(jobType)
-	job := entity.NewDbJob(jobType)
-	if err := repo.GetById(job, jobId); err != nil {
-		return err
-	}
-	if job.IsEnabled() {
-		return nil
-	}
-	job.SetEnabled(true)
-	if err := repo.UpdateEnabled(ctx, jobId, true); err != nil {
-		return err
-	}
 	_ = s.runner.Add(ctx, job)
 	return nil
 }
@@ -134,37 +98,19 @@ func (s *dbScheduler) DisableJob(ctx context.Context, jobType entity.DbJobType,
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
 
-	repo := s.repo(jobType)
-	job := entity.NewDbJob(jobType)
-	if err := repo.GetById(job, jobId); err != nil {
-		return err
-	}
-	if !job.IsEnabled() {
-		return nil
-	}
-	if err := repo.UpdateEnabled(ctx, jobId, false); err != nil {
-		return err
-	}
-	_ = s.runner.Remove(ctx, job.GetKey())
+	_ = s.runner.Remove(ctx, entity.FormatJobKey(jobType, jobId))
 	return nil
 }
 
-func (s *dbScheduler) StartJobNow(ctx context.Context, jobType entity.DbJobType, jobId uint64) error {
+func (s *dbScheduler) StartJobNow(ctx context.Context, job entity.DbJob) error {
 	s.mutex.Lock()
 	defer s.mutex.Unlock()
 
-	job := entity.NewDbJob(jobType)
-	if err := s.repo(jobType).GetById(job, jobId); err != nil {
-		return err
-	}
-	if !job.IsEnabled() {
-		return errors.New("任务未启用")
-	}
 	_ = s.runner.StartNow(ctx, job)
 	return nil
 }
 
-func (s *dbScheduler) backupMysql(ctx context.Context, job entity.DbJob) error {
+func (s *dbScheduler) backup(ctx context.Context, dbProgram dbi.DbProgram, job entity.DbJob) error {
 	id, err := NewIncUUID()
 	if err != nil {
 		return err
@@ -176,19 +122,14 @@ func (s *dbScheduler) backupMysql(ctx context.Context, job entity.DbJob) error {
 		DbInstanceId: backup.DbInstanceId,
 		DbName:       backup.DbName,
 	}
-	conn, err := s.dbApp.GetDbConnByInstanceId(backup.DbInstanceId)
-	if err != nil {
-		return err
-	}
-	dbProgram := conn.GetDialect().GetDbProgram()
 	binlogInfo, err := dbProgram.Backup(ctx, history)
 	if err != nil {
 		return err
 	}
 	now := time.Now()
-	name := backup.Name
-	if len(name) == 0 {
-		name = backup.DbName
+	name := backup.DbName
+	if len(backup.Name) > 0 {
+		name = fmt.Sprintf("%s-%s", backup.DbName, backup.Name)
 	}
 	history.Name = fmt.Sprintf("%s[%s]", name, now.Format(time.DateTime))
 	history.CreateTime = now
@@ -202,54 +143,59 @@ func (s *dbScheduler) backupMysql(ctx context.Context, job entity.DbJob) error {
 	return nil
 }
 
-func (s *dbScheduler) restoreMysql(ctx context.Context, job entity.DbJob) error {
+func (s *dbScheduler) restore(ctx context.Context, dbProgram dbi.DbProgram, job entity.DbJob) error {
 	restore := job.(*entity.DbRestore)
-	conn, err := s.dbApp.GetDbConnByInstanceId(restore.DbInstanceId)
-	if err != nil {
-		return err
-	}
-	dbProgram := conn.GetDialect().GetDbProgram()
 	if restore.PointInTime.Valid {
-		if enabled, err := dbProgram.CheckBinlogEnabled(ctx); err != nil {
-			return err
-		} else if !enabled {
-			return errors.New("数据库未启用 BINLOG")
-		}
-		if enabled, err := dbProgram.CheckBinlogRowFormat(ctx); err != nil {
-			return err
-		} else if !enabled {
-			return errors.New("数据库未启用 BINLOG 行模式")
-		}
-
-		latestBinlogSequence, earliestBackupSequence := int64(-1), int64(-1)
-		binlogHistory, ok, err := s.binlogHistoryRepo.GetLatestHistory(restore.DbInstanceId)
-		if err != nil {
-			return err
-		}
-		if ok {
-			latestBinlogSequence = binlogHistory.Sequence
-		} else {
-			backupHistory, ok, err := s.backupHistoryRepo.GetEarliestHistory(restore.DbInstanceId)
-			if err != nil {
-				return err
-			}
-			if !ok {
-				return nil
-			}
-			earliestBackupSequence = backupHistory.BinlogSequence
-		}
-		binlogFiles, err := dbProgram.FetchBinlogs(ctx, true, earliestBackupSequence, latestBinlogSequence)
-		if err != nil {
-			return err
-		}
-		if err := s.binlogHistoryRepo.InsertWithBinlogFiles(ctx, restore.DbInstanceId, binlogFiles); err != nil {
+		//if enabled, err := dbProgram.CheckBinlogEnabled(ctx); err != nil {
+		//	return err
+		//} else if !enabled {
+		//	return errors.New("数据库未启用 BINLOG")
+		//}
+		//if enabled, err := dbProgram.CheckBinlogRowFormat(ctx); err != nil {
+		//	return err
+		//} else if !enabled {
+		//	return errors.New("数据库未启用 BINLOG 行模式")
+		//}
+		//
+		//latestBinlogSequence, earliestBackupSequence := int64(-1), int64(-1)
+		//binlogHistory, ok, err := s.binlogHistoryRepo.GetLatestHistory(restore.DbInstanceId)
+		//if err != nil {
+		//	return err
+		//}
+		//if ok {
+		//	latestBinlogSequence = binlogHistory.Sequence
+		//} else {
+		//	backupHistory, ok, err := s.backupHistoryRepo.GetEarliestHistory(restore.DbInstanceId)
+		//	if err != nil {
+		//		return err
+		//	}
+		//	if !ok {
+		//		return nil
+		//	}
+		//	earliestBackupSequence = backupHistory.BinlogSequence
+		//}
+		//binlogFiles, err := dbProgram.FetchBinlogs(ctx, true, earliestBackupSequence, latestBinlogSequence)
+		//if err != nil {
+		//	return err
+		//}
+		//if err := s.binlogHistoryRepo.InsertWithBinlogFiles(ctx, restore.DbInstanceId, binlogFiles); err != nil {
+		//	return err
+		//}
+		if err := s.fetchBinlog(ctx, dbProgram, job.GetInstanceId(), true); err != nil {
 			return err
 		}
 		if err := s.restorePointInTime(ctx, dbProgram, restore); err != nil {
 			return err
 		}
 	} else {
-		if err := s.restoreBackupHistory(ctx, dbProgram, restore); err != nil {
+		backupHistory := &entity.DbBackupHistory{}
+		if err := s.backupHistoryRepo.GetById(backupHistory, restore.DbBackupHistoryId); err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				err = errors.New("备份历史已删除")
+			}
+			return err
+		}
+		if err := s.restoreBackupHistory(ctx, dbProgram, backupHistory); err != nil {
 			return err
 		}
 	}
@@ -264,76 +210,108 @@ func (s *dbScheduler) restoreMysql(ctx context.Context, job entity.DbJob) error
 	return nil
 }
 
-func (s *dbScheduler) runJob(ctx context.Context, job entity.DbJob) {
-	job.SetLastStatus(entity.DbJobRunning, nil)
-	if err := s.repo(job.GetJobType()).UpdateLastStatus(ctx, job); err != nil {
-		logx.Errorf("failed to update job status: %v", err)
-		return
-	}
+//func (s *dbScheduler) updateLastStatus(ctx context.Context, job entity.DbJob) error {
+//	switch typ := job.GetJobType(); typ {
+//	case entity.DbJobTypeBackup:
+//		return s.backupRepo.UpdateLastStatus(ctx, job)
+//	case entity.DbJobTypeRestore:
+//		return s.restoreRepo.UpdateLastStatus(ctx, job)
+//	case entity.DbJobTypeBinlog:
+//		return s.binlogRepo.UpdateLastStatus(ctx, job)
+//	default:
+//		panic(fmt.Errorf("无效的数据库任务类型: %v", typ))
+//	}
+//}
 
-	var errRun error
+func (s *dbScheduler) updateJob(ctx context.Context, job entity.DbJob) error {
 	switch typ := job.GetJobType(); typ {
 	case entity.DbJobTypeBackup:
-		errRun = s.backupMysql(ctx, job)
+		return s.backupRepo.UpdateById(ctx, job)
 	case entity.DbJobTypeRestore:
-		errRun = s.restoreMysql(ctx, job)
+		return s.restoreRepo.UpdateById(ctx, job)
 	case entity.DbJobTypeBinlog:
-		errRun = s.fetchBinlogMysql(ctx, job)
+		return s.binlogRepo.UpdateById(ctx, job)
 	default:
-		errRun = fmt.Errorf("无效的数据库任务类型: %v", typ)
-	}
-	status := entity.DbJobSuccess
-	if errRun != nil {
-		status = entity.DbJobFailed
-	}
-	job.SetLastStatus(status, errRun)
-	if err := s.repo(job.GetJobType()).UpdateLastStatus(ctx, job); err != nil {
-		logx.Errorf("failed to update job status: %v", err)
-		return
+		return fmt.Errorf("无效的数据库任务类型: %v", typ)
 	}
 }
 
-func (s *dbScheduler) runnableJob(job entity.DbJob, next runner.NextJobFunc[entity.DbJob]) bool {
+func (s *dbScheduler) runJob(ctx context.Context, job entity.DbJob) error {
+	//job.SetLastStatus(entity.DbJobRunning, nil)
+	//if err := s.updateLastStatus(ctx, job); err != nil {
+	//	logx.Errorf("failed to update job status: %v", err)
+	//	return
+	//}
+
+	//var errRun error
+	conn, err := s.dbApp.GetDbConnByInstanceId(job.GetInstanceId())
+	if err != nil {
+		return err
+	}
+	dbProgram := conn.GetDialect().GetDbProgram()
+	switch typ := job.GetJobType(); typ {
+	case entity.DbJobTypeBackup:
+		return s.backup(ctx, dbProgram, job)
+	case entity.DbJobTypeRestore:
+		return s.restore(ctx, dbProgram, job)
+	case entity.DbJobTypeBinlog:
+		return s.fetchBinlog(ctx, dbProgram, job.GetInstanceId(), false)
+	default:
+		return fmt.Errorf("无效的数据库任务类型: %v", typ)
+	}
+	//status := entity.DbJobSuccess
+	//if errRun != nil {
+	//	status = entity.DbJobFailed
+	//}
+	//job.SetLastStatus(status, errRun)
+	//if err := s.updateLastStatus(ctx, job); err != nil {
+	//	logx.Errorf("failed to update job status: %v", err)
+	//	return
+	//}
+}
+
+func (s *dbScheduler) runnableJob(job entity.DbJob, next runner.NextJobFunc[entity.DbJob]) (bool, error) {
+	if job.IsExpired() {
+		return false, runner.ErrJobExpired
+	}
 	const maxCountByInstanceId = 4
 	const maxCountByDbName = 1
 	var countByInstanceId, countByDbName int
-	jobBase := job.GetJobBase()
 	for item, ok := next(); ok; item, ok = next() {
-		itemBase := item.GetJobBase()
-		if jobBase.DbInstanceId == itemBase.DbInstanceId {
+		if job.GetInstanceId() == item.GetInstanceId() {
 			countByInstanceId++
 			if countByInstanceId >= maxCountByInstanceId {
-				return false
+				return false, nil
 			}
 
 			if relatedToBinlog(job.GetJobType()) {
 				// todo: 恢复数据库前触发 BINLOG 同步，BINLOG 同步完成后才能恢复数据库
 				if relatedToBinlog(item.GetJobType()) {
-					return false
+					return false, nil
 				}
 			}
 
 			if job.GetDbName() == item.GetDbName() {
 				countByDbName++
 				if countByDbName >= maxCountByDbName {
-					return false
+					return false, nil
 				}
 			}
 		}
 	}
-	return true
+	return true, nil
 }
 
 func relatedToBinlog(typ entity.DbJobType) bool {
 	return typ == entity.DbJobTypeRestore || typ == entity.DbJobTypeBinlog
 }
 
-func (s *dbScheduler) restorePointInTime(ctx context.Context, program dbi.DbProgram, job *entity.DbRestore) error {
+func (s *dbScheduler) restorePointInTime(ctx context.Context, dbProgram dbi.DbProgram, job *entity.DbRestore) error {
 	binlogHistory, err := s.binlogHistoryRepo.GetHistoryByTime(job.DbInstanceId, job.PointInTime.Time)
 	if err != nil {
 		return err
 	}
-	position, err := program.GetBinlogEventPositionAtOrAfterTime(ctx, binlogHistory.FileName, job.PointInTime.Time)
+	position, err := dbProgram.GetBinlogEventPositionAtOrAfterTime(ctx, binlogHistory.FileName, job.PointInTime.Time)
 	if err != nil {
 		return err
 	}
@@ -362,40 +340,63 @@ func (s *dbScheduler) restorePointInTime(ctx context.Context, program dbi.DbProg
 		TargetPosition:  target.Position,
 		TargetTime:      job.PointInTime.Time,
 	}
-	if err := program.RestoreBackupHistory(ctx, backupHistory.DbName, backupHistory.DbBackupId, backupHistory.Uuid); err != nil {
+	if err := dbProgram.ReplayBinlog(ctx, job.DbName, job.DbName, restoreInfo); err != nil {
 		return err
 	}
-	if err := program.ReplayBinlog(ctx, job.DbName, job.DbName, restoreInfo); err != nil {
+	if err := s.restoreBackupHistory(ctx, dbProgram, backupHistory); err != nil {
 		return err
 	}
-
 	// 由于 ReplayBinlog 未记录 BINLOG 事件，系统自动备份，避免数据丢失
 	backup := &entity.DbBackup{
-		DbJobBaseImpl: entity.NewDbBJobBase(backupHistory.DbInstanceId, entity.DbJobTypeBackup),
-		DbName:        backupHistory.DbName,
-		Enabled:       true,
-		Repeated:      false,
-		StartTime:     time.Now(),
-		Interval:      0,
-		Name:          fmt.Sprintf("%s-系统自动备份", backupHistory.DbName),
+		DbInstanceId: backupHistory.DbInstanceId,
+		DbName:       backupHistory.DbName,
+		Enabled:      true,
+		Repeated:     false,
+		StartTime:    time.Now(),
+		Interval:     0,
+		Name:         "系统备份",
 	}
 	backup.Id = backupHistory.DbBackupId
-	if err := s.backupMysql(ctx, backup); err != nil {
+	if err := s.backup(ctx, dbProgram, backup); err != nil {
 		return err
 	}
 	return nil
 }
 
-func (s *dbScheduler) restoreBackupHistory(ctx context.Context, program dbi.DbProgram, job *entity.DbRestore) error {
-	backupHistory := &entity.DbBackupHistory{}
-	if err := s.backupHistoryRepo.GetById(backupHistory, job.DbBackupHistoryId); err != nil {
+func (s *dbScheduler) restoreBackupHistory(ctx context.Context, program dbi.DbProgram, backupHistory *entity.DbBackupHistory) (retErr error) {
+	ok, err := s.backupHistoryRepo.UpdateRestoring(true, backupHistory.Id)
+	if err != nil {
 		return err
 	}
+	defer func() {
+		_, err = s.backupHistoryRepo.UpdateRestoring(false, backupHistory.Id)
+		if err == nil {
+			return
+		}
+		if retErr == nil {
+			retErr = err
+			return
+		}
+		retErr = fmt.Errorf("%w, %w", retErr, err)
+	}()
+	if !ok {
+		return errors.New("关联的数据库备份历史已删除")
+	}
 	return program.RestoreBackupHistory(ctx, backupHistory.DbName, backupHistory.DbBackupId, backupHistory.Uuid)
 }
 
-func (s *dbScheduler) fetchBinlogMysql(ctx context.Context, backup entity.DbJob) error {
-	instanceId := backup.GetJobBase().DbInstanceId
+func (s *dbScheduler) fetchBinlog(ctx context.Context, dbProgram dbi.DbProgram, instanceId uint64, downloadLatestBinlogFile bool) error {
+	if enabled, err := dbProgram.CheckBinlogEnabled(ctx); err != nil {
+		return err
+	} else if !enabled {
+		return errors.New("数据库未启用 BINLOG")
+	}
+	if enabled, err := dbProgram.CheckBinlogRowFormat(ctx); err != nil {
+		return err
+	} else if !enabled {
+		return errors.New("数据库未启用 BINLOG 行模式")
+	}
+
 	latestBinlogSequence, earliestBackupSequence := int64(-1), int64(-1)
 	binlogHistory, ok, err := s.binlogHistoryRepo.GetLatestHistory(instanceId)
 	if err != nil {
@@ -413,12 +414,7 @@ func (s *dbScheduler) fetchBinlogMysql(ctx context.Context, backup entity.DbJob)
 		}
 		earliestBackupSequence = backupHistory.BinlogSequence
 	}
-	conn, err := s.dbApp.GetDbConnByInstanceId(instanceId)
-	if err != nil {
-		return err
-	}
-	dbProgram := conn.GetDialect().GetDbProgram()
-	binlogFiles, err := dbProgram.FetchBinlogs(ctx, false, earliestBackupSequence, latestBinlogSequence)
+	binlogFiles, err := dbProgram.FetchBinlogs(ctx, downloadLatestBinlogFile, earliestBackupSequence, latestBinlogSequence)
 	if err != nil {
 		return err
 	}