feat: 实现数据库备份和恢复并发调度 (#84)

server/internal/db/domain/entity/db_backup.go

@@ -1,29 +1,27 @@
 package entity
 
-var _ DbTask = (*DbBackup)(nil)
+import (
+	"context"
+	"mayfly-go/pkg/runner"
+)
+
+var _ DbJob = (*DbBackup)(nil)
 
 // DbBackup 数据库备份任务
 type DbBackup struct {
-	*DbTaskBase
+	*DbJobBaseImpl
 
-	Name         string `json:"name"`         // 备份任务名称
-	DbName       string `json:"dbName"`       // 数据库名
-	DbInstanceId uint64 `json:"dbInstanceId"` // 数据库实例ID
+	Name string `json:"Name"` // 数据库备份名称
 }
 
-func (*DbBackup) MessageWithStatus(status TaskStatus) string {
-	var result string
-	switch status {
-	case TaskDelay:
-		result = "等待备份数据库"
-	case TaskReady:
-		result = "准备备份数据库"
-	case TaskReserved:
-		result = "数据库备份中"
-	case TaskSuccess:
-		result = "数据库备份成功"
-	case TaskFailed:
-		result = "数据库备份失败"
+func (d *DbBackup) SetRun(fn func(ctx context.Context, job DbJob)) {
+	d.run = func(ctx context.Context) {
+		fn(ctx, d)
+	}
+}
+
+func (d *DbBackup) SetRunnable(fn func(job DbJob, next runner.NextFunc) bool) {
+	d.runnable = func(next runner.NextFunc) bool {
+		return fn(d, next)
 	}
-	return result
 }

server/internal/db/domain/entity/db_binlog.go

@@ -10,17 +10,17 @@ import (
 type DbBinlog struct {
 	model.Model
 
-	LastStatus   TaskStatus     // 最近一次执行状态
+	LastStatus   DbJobStatus    // 最近一次执行状态
 	LastResult   string         // 最近一次执行结果
 	LastTime     timex.NullTime // 最近一次执行时间
 	DbInstanceId uint64         `json:"dbInstanceId"` // 数据库实例ID
 }
 
 func NewDbBinlog(instanceId uint64) *DbBinlog {
-	binlogTask := &DbBinlog{}
-	binlogTask.Id = instanceId
-	binlogTask.DbInstanceId = instanceId
-	return binlogTask
+	job := &DbBinlog{}
+	job.Id = instanceId
+	job.DbInstanceId = instanceId
+	return job
 }
 
 // BinlogFile is the metadata of the MySQL binlog file.

server/internal/db/domain/entity/db_job.go

@@ -0,0 +1,235 @@
+package entity
+
+import (
+	"context"
+	"fmt"
+	"mayfly-go/pkg/model"
+	"mayfly-go/pkg/runner"
+	"mayfly-go/pkg/utils/stringx"
+	"mayfly-go/pkg/utils/timex"
+	"time"
+)
+
+const LastResultSize = 256
+
+type DbJobKey = runner.JobKey
+
+type DbJobStatus = runner.JobStatus
+
+const (
+	DbJobUnknown = runner.JobUnknown
+	DbJobDelay   = runner.JobDelay
+	DbJobReady   = runner.JobWaiting
+	DbJobRunning = runner.JobRunning
+	DbJobRemoved = runner.JobRemoved
+)
+
+const (
+	DbJobSuccess DbJobStatus = 0x20 + iota
+	DbJobFailed
+)
+
+type DbJobType = string
+
+const (
+	DbJobTypeBackup  DbJobType = "db-backup"
+	DbJobTypeRestore DbJobType = "db-restore"
+)
+
+const (
+	DbJobNameBackup  = "数据库备份"
+	DbJobNameRestore = "数据库恢复"
+)
+
+var _ runner.Job = (DbJob)(nil)
+
+type DbJobBase interface {
+	model.ModelI
+	runner.Job
+
+	GetId() uint64
+	GetJobType() DbJobType
+	SetJobType(typ DbJobType)
+	GetJobBase() *DbJobBaseImpl
+	SetLastStatus(status DbJobStatus, err error)
+	IsEnabled() bool
+}
+
+type DbJob interface {
+	DbJobBase
+
+	SetRun(fn func(ctx context.Context, job DbJob))
+	SetRunnable(fn func(job DbJob, next runner.NextFunc) bool)
+}
+
+func NewDbJob(typ DbJobType) DbJob {
+	switch typ {
+	case DbJobTypeBackup:
+		return &DbBackup{
+			DbJobBaseImpl: &DbJobBaseImpl{
+				jobType: DbJobTypeBackup},
+		}
+	case DbJobTypeRestore:
+		return &DbRestore{
+			DbJobBaseImpl: &DbJobBaseImpl{
+				jobType: DbJobTypeRestore},
+		}
+	default:
+		panic(fmt.Sprintf("invalid DbJobType: %v", typ))
+	}
+}
+
+var _ DbJobBase = (*DbJobBaseImpl)(nil)
+
+type DbJobBaseImpl struct {
+	model.Model
+
+	DbInstanceId uint64         // 数据库实例ID
+	DbName       string         // 数据库名称
+	Enabled      bool           // 是否启用
+	StartTime    time.Time      // 开始时间
+	Interval     time.Duration  // 间隔时间
+	Repeated     bool           // 是否重复执行
+	LastStatus   DbJobStatus    // 最近一次执行状态
+	LastResult   string         // 最近一次执行结果
+	LastTime     timex.NullTime // 最近一次执行时间
+	Deadline     time.Time      `gorm:"-" json:"-"` // 计划执行时间
+	run          runner.RunFunc
+	runnable     runner.RunnableFunc
+	jobType      DbJobType
+	jobKey       runner.JobKey
+	jobStatus    runner.JobStatus
+}
+
+func NewDbBJobBase(instanceId uint64, dbName string, jobType DbJobType, enabled bool, repeated bool, startTime time.Time, interval time.Duration) *DbJobBaseImpl {
+	return &DbJobBaseImpl{
+		DbInstanceId: instanceId,
+		DbName:       dbName,
+		jobType:      jobType,
+		Enabled:      enabled,
+		Repeated:     repeated,
+		StartTime:    startTime,
+		Interval:     interval,
+	}
+}
+
+func (d *DbJobBaseImpl) GetJobType() DbJobType {
+	return d.jobType
+}
+
+func (d *DbJobBaseImpl) SetJobType(typ DbJobType) {
+	d.jobType = typ
+}
+
+func (d *DbJobBaseImpl) SetLastStatus(status DbJobStatus, err error) {
+	var statusName, jobName string
+	switch status {
+	case DbJobRunning:
+		statusName = "运行中"
+	case DbJobSuccess:
+		statusName = "成功"
+	case DbJobFailed:
+		statusName = "失败"
+	default:
+		return
+	}
+	switch d.jobType {
+	case DbJobTypeBackup:
+		jobName = DbJobNameBackup
+	case DbJobTypeRestore:
+		jobName = DbJobNameRestore
+	default:
+		jobName = d.jobType
+	}
+	d.LastStatus = status
+	var result = jobName + statusName
+	if err != nil {
+		result = fmt.Sprintf("%s: %v", result, err)
+	}
+	d.LastResult = stringx.TruncateStr(result, LastResultSize)
+	d.LastTime = timex.NewNullTime(time.Now())
+}
+
+func (d *DbJobBaseImpl) GetId() uint64 {
+	if d == nil {
+		return 0
+	}
+	return d.Id
+}
+
+func (d *DbJobBaseImpl) GetDeadline() time.Time {
+	return d.Deadline
+}
+
+func (d *DbJobBaseImpl) Schedule() bool {
+	if d.IsFinished() || !d.Enabled {
+		return false
+	}
+	switch d.LastStatus {
+	case DbJobSuccess:
+		if d.Interval == 0 {
+			return false
+		}
+		lastTime := d.LastTime.Time
+		if lastTime.Sub(d.StartTime) < 0 {
+			lastTime = d.StartTime.Add(-d.Interval)
+		}
+		d.Deadline = lastTime.Add(d.Interval - lastTime.Sub(d.StartTime)%d.Interval)
+	case DbJobFailed:
+		d.Deadline = time.Now().Add(time.Minute)
+	default:
+		d.Deadline = d.StartTime
+	}
+	return true
+}
+
+func (d *DbJobBaseImpl) IsFinished() bool {
+	return !d.Repeated && d.LastStatus == DbJobSuccess
+}
+
+func (d *DbJobBaseImpl) Renew(job runner.Job) {
+	jobBase := job.(DbJob).GetJobBase()
+	d.StartTime = jobBase.StartTime
+	d.Interval = jobBase.Interval
+}
+
+func (d *DbJobBaseImpl) GetJobBase() *DbJobBaseImpl {
+	return d
+}
+
+func (d *DbJobBaseImpl) IsEnabled() bool {
+	return d.Enabled
+}
+
+func (d *DbJobBaseImpl) Run(ctx context.Context) {
+	if d.run == nil {
+		return
+	}
+	d.run(ctx)
+}
+
+func (d *DbJobBaseImpl) Runnable(next runner.NextFunc) bool {
+	if d.runnable == nil {
+		return true
+	}
+	return d.runnable(next)
+}
+
+func FormatJobKey(typ DbJobType, jobId uint64) DbJobKey {
+	return fmt.Sprintf("%v-%d", typ, jobId)
+}
+
+func (d *DbJobBaseImpl) GetKey() DbJobKey {
+	if len(d.jobKey) == 0 {
+		d.jobKey = FormatJobKey(d.jobType, d.Id)
+	}
+	return d.jobKey
+}
+
+func (d *DbJobBaseImpl) GetStatus() DbJobStatus {
+	return d.jobStatus
+}
+
+func (d *DbJobBaseImpl) SetStatus(status DbJobStatus) {
+	d.jobStatus = status
+}

server/internal/db/domain/entity/db_restore.go

@@ -1,36 +1,31 @@
 package entity
 
 import (
+	"context"
+	"mayfly-go/pkg/runner"
 	"mayfly-go/pkg/utils/timex"
 )
 
-var _ DbTask = (*DbRestore)(nil)
+var _ DbJob = (*DbRestore)(nil)
 
 // DbRestore 数据库恢复任务
 type DbRestore struct {
-	*DbTaskBase
+	*DbJobBaseImpl
 
-	DbName              string         `json:"dbName"`              // 数据库名
 	PointInTime         timex.NullTime `json:"pointInTime"`         // 指定数据库恢复的时间点
 	DbBackupId          uint64         `json:"dbBackupId"`          // 用于恢复的数据库恢复任务ID
 	DbBackupHistoryId   uint64         `json:"dbBackupHistoryId"`   // 用于恢复的数据库恢复历史ID
 	DbBackupHistoryName string         `json:"dbBackupHistoryName"` // 数据库恢复历史名称
-	DbInstanceId        uint64         `json:"dbInstanceId"`        // 数据库实例ID
 }
 
-func (*DbRestore) MessageWithStatus(status TaskStatus) string {
-	var result string
-	switch status {
-	case TaskDelay:
-		result = "等待恢复数据库"
-	case TaskReady:
-		result = "准备恢复数据库"
-	case TaskReserved:
-		result = "数据库恢复中"
-	case TaskSuccess:
-		result = "数据库恢复成功"
-	case TaskFailed:
-		result = "数据库恢复失败"
+func (d *DbRestore) SetRun(fn func(ctx context.Context, job DbJob)) {
+	d.run = func(ctx context.Context) {
+		fn(ctx, d)
+	}
+}
+
+func (d *DbRestore) SetRunnable(fn func(job DbJob, next runner.NextFunc) bool) {
+	d.runnable = func(next runner.NextFunc) bool {
+		return fn(d, next)
 	}
-	return result
 }

server/internal/db/domain/entity/db_task_base.go

@@ -1,109 +0,0 @@
-package entity
-
-import (
-	"mayfly-go/pkg/model"
-	"mayfly-go/pkg/utils/timex"
-	"time"
-)
-
-type TaskStatus int
-
-const (
-	TaskDelay TaskStatus = iota
-	TaskReady
-	TaskReserved
-	TaskSuccess
-	TaskFailed
-)
-
-const LastResultSize = 256
-
-type DbTask interface {
-	model.ModelI
-
-	GetId() uint64
-	GetDeadline() time.Time
-	IsFinished() bool
-	Schedule() bool
-	Update(task DbTask)
-	GetTaskBase() *DbTaskBase
-	MessageWithStatus(status TaskStatus) string
-	IsEnabled() bool
-}
-
-func NewDbBTaskBase(enabled bool, repeated bool, startTime time.Time, interval time.Duration) *DbTaskBase {
-	return &DbTaskBase{
-		Enabled:   enabled,
-		Repeated:  repeated,
-		StartTime: startTime,
-		Interval:  interval,
-	}
-}
-
-type DbTaskBase struct {
-	model.Model
-
-	Enabled    bool           // 是否启用
-	StartTime  time.Time      // 开始时间
-	Interval   time.Duration  // 间隔时间
-	Repeated   bool           // 是否重复执行
-	LastStatus TaskStatus     // 最近一次执行状态
-	LastResult string         // 最近一次执行结果
-	LastTime   timex.NullTime // 最近一次执行时间
-	Deadline   time.Time      `gorm:"-" json:"-"` // 计划执行时间
-}
-
-func (d *DbTaskBase) GetId() uint64 {
-	if d == nil {
-		return 0
-	}
-	return d.Id
-}
-
-func (d *DbTaskBase) GetDeadline() time.Time {
-	return d.Deadline
-}
-
-func (d *DbTaskBase) Schedule() bool {
-	if d.IsFinished() || !d.Enabled {
-		return false
-	}
-	switch d.LastStatus {
-	case TaskSuccess:
-		if d.Interval == 0 {
-			return false
-		}
-		lastTime := d.LastTime.Time
-		if lastTime.Sub(d.StartTime) < 0 {
-			lastTime = d.StartTime.Add(-d.Interval)
-		}
-		d.Deadline = lastTime.Add(d.Interval - lastTime.Sub(d.StartTime)%d.Interval)
-	case TaskFailed:
-		d.Deadline = time.Now().Add(time.Minute)
-	default:
-		d.Deadline = d.StartTime
-	}
-	return true
-}
-
-func (d *DbTaskBase) IsFinished() bool {
-	return !d.Repeated && d.LastStatus == TaskSuccess
-}
-
-func (d *DbTaskBase) Update(task DbTask) {
-	t := task.GetTaskBase()
-	d.StartTime = t.StartTime
-	d.Interval = t.Interval
-}
-
-func (d *DbTaskBase) GetTaskBase() *DbTaskBase {
-	return d
-}
-
-func (*DbTaskBase) MessageWithStatus(_ TaskStatus) string {
-	return ""
-}
-
-func (d *DbTaskBase) IsEnabled() bool {
-	return d.Enabled
-}

server/internal/db/domain/entity/query.go

@@ -40,8 +40,8 @@ type DbSqlExecQuery struct {
 	CreatorId uint64
 }
 
-// DbBackupQuery 数据库备份任务查询
-type DbBackupQuery struct {
+// DbJobQuery 数据库备份任务查询
+type DbJobQuery struct {
 	Id           uint64   `json:"id" form:"id"`
 	DbName       string   `json:"dbName" form:"dbName"`
 	IntervalDay  int      `json:"intervalDay" form:"intervalDay"`
@@ -61,13 +61,13 @@ type DbBackupHistoryQuery struct {
 }
 
 // DbRestoreQuery 数据库备份任务查询
-type DbRestoreQuery struct {
-	Id           uint64   `json:"id" form:"id"`
-	DbName       string   `json:"dbName" form:"dbName"`
-	InDbNames    []string `json:"-" form:"-"`
-	DbInstanceId uint64   `json:"-" form:"-"`
-	Repeated     bool     `json:"repeated" form:"repeated"` // 是否重复执行
-}
+//type DbRestoreQuery struct {
+//	Id           uint64   `json:"id" form:"id"`
+//	DbName       string   `json:"dbName" form:"dbName"`
+//	InDbNames    []string `json:"-" form:"-"`
+//	DbInstanceId uint64   `json:"-" form:"-"`
+//	Repeated     bool     `json:"repeated" form:"repeated"` // 是否重复执行
+//}
 
 // DbRestoreHistoryQuery 数据库备份任务查询
 type DbRestoreHistoryQuery struct {