diff --git a/mayfly_go_web/src/views/ops/db/DbBackupEdit.vue b/mayfly_go_web/src/views/ops/db/DbBackupEdit.vue
index 6fad3187..6ad17b2b 100644
--- a/mayfly_go_web/src/views/ops/db/DbBackupEdit.vue
+++ b/mayfly_go_web/src/views/ops/db/DbBackupEdit.vue
@@ -23,7 +23,7 @@
-
+
@@ -101,7 +101,7 @@ const state = reactive({
id: 0,
dbId: 0,
dbNames: '',
- name: null as any,
+ name: '',
intervalDay: null,
startTime: null as any,
repeated: null as any,
diff --git a/server/internal/db/api/db_backup.go b/server/internal/db/api/db_backup.go
index ff4fdf06..07dcb7f4 100644
--- a/server/internal/db/api/db_backup.go
+++ b/server/internal/db/api/db_backup.go
@@ -14,8 +14,8 @@ import (
)
type DbBackup struct {
- DbBackupApp *application.DbBackupApp `inject:""`
- DbApp application.Db `inject:""`
+ dbBackupApp *application.DbBackupApp `inject:"DbBackupApp"`
+ dbApp application.Db `inject:"DbApp"`
}
// todo: 鉴权，避免未经授权进行数据库备份和恢复
@@ -25,13 +25,13 @@ type DbBackup struct {
func (d *DbBackup) GetPageList(rc *req.Ctx) {
dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
biz.IsTrue(dbId > 0, "无效的 dbId: %v", dbId)
- db, err := d.DbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
+ db, err := d.dbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
queryCond, page := ginx.BindQueryAndPage[*entity.DbJobQuery](rc.GinCtx, new(entity.DbJobQuery))
queryCond.DbInstanceId = db.InstanceId
queryCond.InDbNames = strings.Fields(db.Database)
- res, err := d.DbBackupApp.GetPageList(queryCond, page, new([]vo.DbBackup))
+ res, err := d.dbBackupApp.GetPageList(queryCond, page, new([]vo.DbBackup))
biz.ErrIsNilAppendErr(err, "获取数据库备份任务失败: %v")
rc.ResData = res
}
@@ -48,7 +48,7 @@ func (d *DbBackup) Create(rc *req.Ctx) {
dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
biz.IsTrue(dbId > 0, "无效的 dbId: %v", dbId)
- db, err := d.DbApp.GetById(new(entity.Db), dbId, "instanceId")
+ db, err := d.dbApp.GetById(new(entity.Db), dbId, "instanceId")
biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
jobs := make([]*entity.DbBackup, 0, len(dbNames))
@@ -64,7 +64,7 @@ func (d *DbBackup) Create(rc *req.Ctx) {
}
jobs = append(jobs, job)
}
- biz.ErrIsNilAppendErr(d.DbBackupApp.Create(rc.MetaCtx, jobs), "添加数据库备份任务失败: %v")
+ biz.ErrIsNilAppendErr(d.dbBackupApp.Create(rc.MetaCtx, jobs), "添加数据库备份任务失败: %v")
}
// Update 保存数据库备份任务
@@ -79,7 +79,7 @@ func (d *DbBackup) Update(rc *req.Ctx) {
job.Name = backupForm.Name
job.StartTime = backupForm.StartTime
job.Interval = backupForm.Interval
- biz.ErrIsNilAppendErr(d.DbBackupApp.Update(rc.MetaCtx, job), "保存数据库备份任务失败: %v")
+ biz.ErrIsNilAppendErr(d.dbBackupApp.Update(rc.MetaCtx, job), "保存数据库备份任务失败: %v")
}
func (d *DbBackup) walk(rc *req.Ctx, fn func(ctx context.Context, backupId uint64) error) error {
@@ -104,28 +104,28 @@ func (d *DbBackup) walk(rc *req.Ctx, fn func(ctx context.Context, backupId uint6
// Delete 删除数据库备份任务
// @router /api/dbs/:dbId/backups/:backupId [DELETE]
func (d *DbBackup) Delete(rc *req.Ctx) {
- err := d.walk(rc, d.DbBackupApp.Delete)
+ err := d.walk(rc, d.dbBackupApp.Delete)
biz.ErrIsNilAppendErr(err, "删除数据库备份任务失败: %v")
}
// Enable 启用数据库备份任务
// @router /api/dbs/:dbId/backups/:backupId/enable [PUT]
func (d *DbBackup) Enable(rc *req.Ctx) {
- err := d.walk(rc, d.DbBackupApp.Enable)
+ err := d.walk(rc, d.dbBackupApp.Enable)
biz.ErrIsNilAppendErr(err, "启用数据库备份任务失败: %v")
}
// Disable 禁用数据库备份任务
// @router /api/dbs/:dbId/backups/:backupId/disable [PUT]
func (d *DbBackup) Disable(rc *req.Ctx) {
- err := d.walk(rc, d.DbBackupApp.Disable)
+ err := d.walk(rc, d.dbBackupApp.Disable)
biz.ErrIsNilAppendErr(err, "禁用数据库备份任务失败: %v")
}
// Start 禁用数据库备份任务
// @router /api/dbs/:dbId/backups/:backupId/start [PUT]
func (d *DbBackup) Start(rc *req.Ctx) {
- err := d.walk(rc, d.DbBackupApp.Start)
+ err := d.walk(rc, d.dbBackupApp.Start)
biz.ErrIsNilAppendErr(err, "运行数据库备份任务失败: %v")
}
@@ -133,10 +133,10 @@ func (d *DbBackup) Start(rc *req.Ctx) {
// @router /api/dbs/:dbId/db-names-without-backup [GET]
func (d *DbBackup) GetDbNamesWithoutBackup(rc *req.Ctx) {
dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
- db, err := d.DbApp.GetById(new(entity.Db), dbId, "instance_id", "database")
+ db, err := d.dbApp.GetById(new(entity.Db), dbId, "instance_id", "database")
biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
dbNames := strings.Fields(db.Database)
- dbNamesWithoutBackup, err := d.DbBackupApp.GetDbNamesWithoutBackup(db.InstanceId, dbNames)
+ dbNamesWithoutBackup, err := d.dbBackupApp.GetDbNamesWithoutBackup(db.InstanceId, dbNames)
biz.ErrIsNilAppendErr(err, "获取未配置定时备份的数据库名称失败: %v")
rc.ResData = dbNamesWithoutBackup
}
@@ -146,13 +146,13 @@ func (d *DbBackup) GetDbNamesWithoutBackup(rc *req.Ctx) {
func (d *DbBackup) GetHistoryPageList(rc *req.Ctx) {
dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
biz.IsTrue(dbId > 0, "无效的 dbId: %v", dbId)
- db, err := d.DbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
+ db, err := d.dbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
queryCond, page := ginx.BindQueryAndPage[*entity.DbBackupHistoryQuery](rc.GinCtx, new(entity.DbBackupHistoryQuery))
queryCond.DbInstanceId = db.InstanceId
queryCond.InDbNames = strings.Fields(db.Database)
- res, err := d.DbBackupApp.GetHistoryPageList(queryCond, page, new([]vo.DbBackupHistory))
+ res, err := d.dbBackupApp.GetHistoryPageList(queryCond, page, new([]vo.DbBackupHistory))
biz.ErrIsNilAppendErr(err, "获取数据库备份历史失败: %v")
rc.ResData = res
}
diff --git a/server/internal/db/api/db_restore.go b/server/internal/db/api/db_restore.go
index 56258290..24d64584 100644
--- a/server/internal/db/api/db_restore.go
+++ b/server/internal/db/api/db_restore.go
@@ -14,8 +14,8 @@ import (
)
type DbRestore struct {
- DbRestoreApp *application.DbRestoreApp `inject:""`
- DbApp application.Db `inject:""`
+ restoreApp *application.DbRestoreApp `inject:"DbRestoreApp"`
+ dbApp application.Db `inject:"DbApp"`
}
// GetPageList 获取数据库恢复任务
@@ -23,14 +23,14 @@ type DbRestore struct {
func (d *DbRestore) GetPageList(rc *req.Ctx) {
dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
biz.IsTrue(dbId > 0, "无效的 dbId: %v", dbId)
- db, err := d.DbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
+ db, err := d.dbApp.GetById(new(entity.Db), dbId, "db_instance_id", "database")
biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
var restores []vo.DbRestore
queryCond, page := ginx.BindQueryAndPage[*entity.DbJobQuery](rc.GinCtx, new(entity.DbJobQuery))
queryCond.DbInstanceId = db.InstanceId
queryCond.InDbNames = strings.Fields(db.Database)
- res, err := d.DbRestoreApp.GetPageList(queryCond, page, &restores)
+ res, err := d.restoreApp.GetPageList(queryCond, page, &restores)
biz.ErrIsNilAppendErr(err, "获取数据库恢复任务失败: %v")
rc.ResData = res
}
@@ -44,7 +44,7 @@ func (d *DbRestore) Create(rc *req.Ctx) {
dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
biz.IsTrue(dbId > 0, "无效的 dbId: %v", dbId)
- db, err := d.DbApp.GetById(new(entity.Db), dbId, "instanceId")
+ db, err := d.dbApp.GetById(new(entity.Db), dbId, "instanceId")
biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
job := &entity.DbRestore{
@@ -59,7 +59,7 @@ func (d *DbRestore) Create(rc *req.Ctx) {
DbBackupHistoryName: restoreForm.DbBackupHistoryName,
}
job.DbName = restoreForm.DbName
- biz.ErrIsNilAppendErr(d.DbRestoreApp.Create(rc.MetaCtx, job), "添加数据库恢复任务失败: %v")
+ biz.ErrIsNilAppendErr(d.restoreApp.Create(rc.MetaCtx, job), "添加数据库恢复任务失败: %v")
}
// Update 保存数据库恢复任务
@@ -73,7 +73,7 @@ func (d *DbRestore) Update(rc *req.Ctx) {
job.Id = restoreForm.Id
job.StartTime = restoreForm.StartTime
job.Interval = restoreForm.Interval
- biz.ErrIsNilAppendErr(d.DbRestoreApp.Update(rc.MetaCtx, job), "保存数据库恢复任务失败: %v")
+ biz.ErrIsNilAppendErr(d.restoreApp.Update(rc.MetaCtx, job), "保存数据库恢复任务失败: %v")
}
func (d *DbRestore) walk(rc *req.Ctx, fn func(ctx context.Context, restoreId uint64) error) error {
@@ -98,21 +98,21 @@ func (d *DbRestore) walk(rc *req.Ctx, fn func(ctx context.Context, restoreId uin
// Delete 删除数据库恢复任务
// @router /api/dbs/:dbId/restores/:restoreId [DELETE]
func (d *DbRestore) Delete(rc *req.Ctx) {
- err := d.walk(rc, d.DbRestoreApp.Delete)
+ err := d.walk(rc, d.restoreApp.Delete)
biz.ErrIsNilAppendErr(err, "删除数据库恢复任务失败: %v")
}
// Enable 启用数据库恢复任务
// @router /api/dbs/:dbId/restores/:restoreId/enable [PUT]
func (d *DbRestore) Enable(rc *req.Ctx) {
- err := d.walk(rc, d.DbRestoreApp.Enable)
+ err := d.walk(rc, d.restoreApp.Enable)
biz.ErrIsNilAppendErr(err, "启用数据库恢复任务失败: %v")
}
// Disable 禁用数据库恢复任务
// @router /api/dbs/:dbId/restores/:restoreId/disable [PUT]
func (d *DbRestore) Disable(rc *req.Ctx) {
- err := d.walk(rc, d.DbRestoreApp.Disable)
+ err := d.walk(rc, d.restoreApp.Disable)
biz.ErrIsNilAppendErr(err, "禁用数据库恢复任务失败: %v")
}
@@ -120,10 +120,10 @@ func (d *DbRestore) Disable(rc *req.Ctx) {
// @router /api/dbs/:dbId/db-names-without-backup [GET]
func (d *DbRestore) GetDbNamesWithoutRestore(rc *req.Ctx) {
dbId := uint64(ginx.PathParamInt(rc.GinCtx, "dbId"))
- db, err := d.DbApp.GetById(new(entity.Db), dbId, "instance_id", "database")
+ db, err := d.dbApp.GetById(new(entity.Db), dbId, "instance_id", "database")
biz.ErrIsNilAppendErr(err, "获取数据库信息失败: %v")
dbNames := strings.Fields(db.Database)
- dbNamesWithoutRestore, err := d.DbRestoreApp.GetDbNamesWithoutRestore(db.InstanceId, dbNames)
+ dbNamesWithoutRestore, err := d.restoreApp.GetDbNamesWithoutRestore(db.InstanceId, dbNames)
biz.ErrIsNilAppendErr(err, "获取未配置定时备份的数据库名称失败: %v")
rc.ResData = dbNamesWithoutRestore
}
@@ -134,7 +134,7 @@ func (d *DbRestore) GetHistoryPageList(rc *req.Ctx) {
queryCond := &entity.DbRestoreHistoryQuery{
DbRestoreId: uint64(ginx.PathParamInt(rc.GinCtx, "restoreId")),
}
- res, err := d.DbRestoreApp.GetHistoryPageList(queryCond, ginx.GetPageParam(rc.GinCtx), new([]vo.DbRestoreHistory))
+ res, err := d.restoreApp.GetHistoryPageList(queryCond, ginx.GetPageParam(rc.GinCtx), new([]vo.DbRestoreHistory))
biz.ErrIsNilAppendErr(err, "获取数据库备份历史失败: %v")
rc.ResData = res
}
diff --git a/server/internal/db/application/db_backup.go b/server/internal/db/application/db_backup.go
index e729b95d..ed5d5143 100644
--- a/server/internal/db/application/db_backup.go
+++ b/server/internal/db/application/db_backup.go
@@ -10,66 +10,66 @@ import (
)
type DbBackupApp struct {
- DbApp Db `inject:"DbApp"`
- Scheduler *dbScheduler `inject:"DbScheduler"`
- InstanceRepo repository.Instance `inject:"DbInstanceRepo"`
- BackupRepo repository.DbBackup `inject:"DbBackupRepo"`
- BackupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
+ dbApp Db `inject:"DbApp"`
+ scheduler *dbScheduler `inject:"DbScheduler"`
+ instanceRepo repository.Instance `inject:"DbInstanceRepo"`
+ backupRepo repository.DbBackup `inject:"DbBackupRepo"`
+ backupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
}
func (app *DbBackupApp) Init() error {
var jobs []*entity.DbBackup
- if err := app.BackupRepo.ListToDo(&jobs); err != nil {
+ if err := app.backupRepo.ListToDo(&jobs); err != nil {
return err
}
- if err := app.Scheduler.AddJob(context.Background(), false, entity.DbJobTypeBackup, jobs); err != nil {
+ if err := app.scheduler.AddJob(context.Background(), false, entity.DbJobTypeBackup, jobs); err != nil {
return err
}
return nil
}
func (app *DbBackupApp) Close() {
- app.Scheduler.Close()
+ app.scheduler.Close()
}
func (app *DbBackupApp) Create(ctx context.Context, jobs []*entity.DbBackup) error {
- return app.Scheduler.AddJob(ctx, true /* 保存到数据库 */, entity.DbJobTypeBackup, jobs)
+ return app.scheduler.AddJob(ctx, true /* 保存到数据库 */, entity.DbJobTypeBackup, jobs)
}
func (app *DbBackupApp) Update(ctx context.Context, job *entity.DbBackup) error {
- return app.Scheduler.UpdateJob(ctx, job)
+ return app.scheduler.UpdateJob(ctx, job)
}
func (app *DbBackupApp) Delete(ctx context.Context, jobId uint64) error {
// todo: 删除数据库备份历史文件
- return app.Scheduler.RemoveJob(ctx, entity.DbJobTypeBackup, jobId)
+ return app.scheduler.RemoveJob(ctx, entity.DbJobTypeBackup, jobId)
}
func (app *DbBackupApp) Enable(ctx context.Context, jobId uint64) error {
- return app.Scheduler.EnableJob(ctx, entity.DbJobTypeBackup, jobId)
+ return app.scheduler.EnableJob(ctx, entity.DbJobTypeBackup, jobId)
}
func (app *DbBackupApp) Disable(ctx context.Context, jobId uint64) error {
- return app.Scheduler.DisableJob(ctx, entity.DbJobTypeBackup, jobId)
+ return app.scheduler.DisableJob(ctx, entity.DbJobTypeBackup, jobId)
}
func (app *DbBackupApp) Start(ctx context.Context, jobId uint64) error {
- return app.Scheduler.StartJobNow(ctx, entity.DbJobTypeBackup, jobId)
+ return app.scheduler.StartJobNow(ctx, entity.DbJobTypeBackup, jobId)
}
// GetPageList 分页获取数据库备份任务
func (app *DbBackupApp) GetPageList(condition *entity.DbJobQuery, pageParam *model.PageParam, toEntity any, orderBy ...string) (*model.PageResult[any], error) {
- return app.BackupRepo.GetPageList(condition, pageParam, toEntity, orderBy...)
+ return app.backupRepo.GetPageList(condition, pageParam, toEntity, orderBy...)
}
// GetDbNamesWithoutBackup 获取未配置定时备份的数据库名称
func (app *DbBackupApp) GetDbNamesWithoutBackup(instanceId uint64, dbNames []string) ([]string, error) {
- return app.BackupRepo.GetDbNamesWithoutBackup(instanceId, dbNames)
+ return app.backupRepo.GetDbNamesWithoutBackup(instanceId, dbNames)
}
// GetHistoryPageList 分页获取数据库备份历史
func (app *DbBackupApp) GetHistoryPageList(condition *entity.DbBackupHistoryQuery, pageParam *model.PageParam, toEntity any, orderBy ...string) (*model.PageResult[any], error) {
- return app.BackupHistoryRepo.GetHistories(condition, pageParam, toEntity, orderBy...)
+ return app.backupHistoryRepo.GetHistories(condition, pageParam, toEntity, orderBy...)
}
func NewIncUUID() (uuid.UUID, error) {
diff --git a/server/internal/db/application/db_binlog.go b/server/internal/db/application/db_binlog.go
index 51a52d68..711b3626 100644
--- a/server/internal/db/application/db_binlog.go
+++ b/server/internal/db/application/db_binlog.go
@@ -11,12 +11,12 @@ import (
)
type DbBinlogApp struct {
- DbApp Db `inject:"DbApp"`
- Scheduler *dbScheduler `inject:"DbScheduler"`
- BinlogRepo repository.DbBinlog `inject:"DbBinlogRepo"`
- BinlogHistoryRepo repository.DbBinlogHistory `inject:"DbBinlogHistoryRepo"`
- BackupRepo repository.DbBackup `inject:"DbBackupRepo"`
- BackupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
+ dbApp Db `inject:"DbApp"`
+ scheduler *dbScheduler `inject:"DbScheduler"`
+ binlogRepo repository.DbBinlog `inject:"DbBinlogRepo"`
+ binlogHistoryRepo repository.DbBinlogHistory `inject:"DbBinlogHistoryRepo"`
+ backupRepo repository.DbBackup `inject:"DbBackupRepo"`
+ backupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
context context.Context
cancel context.CancelFunc
waitGroup sync.WaitGroup
@@ -48,7 +48,7 @@ func (app *DbBinlogApp) run() {
if app.closed() {
break
}
- if err := app.Scheduler.AddJob(app.context, false, entity.DbJobTypeBinlog, jobs); err != nil {
+ if err := app.scheduler.AddJob(app.context, false, entity.DbJobTypeBinlog, jobs); err != nil {
logx.Error("DbBinlogApp: 添加 BINLOG 同步任务失败: ", err.Error())
}
timex.SleepWithContext(app.context, entity.BinlogDownloadInterval)
@@ -57,7 +57,7 @@ func (app *DbBinlogApp) run() {
func (app *DbBinlogApp) loadJobs() ([]*entity.DbBinlog, error) {
var instanceIds []uint64
- if err := app.BackupRepo.ListDbInstances(true, true, &instanceIds); err != nil {
+ if err := app.backupRepo.ListDbInstances(true, true, &instanceIds); err != nil {
return nil, err
}
jobs := make([]*entity.DbBinlog, 0, len(instanceIds))
@@ -84,7 +84,7 @@ func (app *DbBinlogApp) closed() bool {
}
func (app *DbBinlogApp) AddJobIfNotExists(ctx context.Context, job *entity.DbBinlog) error {
- if err := app.BinlogRepo.AddJobIfNotExists(ctx, job); err != nil {
+ if err := app.binlogRepo.AddJobIfNotExists(ctx, job); err != nil {
return err
}
if job.Id == 0 {
@@ -95,7 +95,7 @@ func (app *DbBinlogApp) AddJobIfNotExists(ctx context.Context, job *entity.DbBin
func (app *DbBinlogApp) Delete(ctx context.Context, jobId uint64) error {
// todo: 删除 Binlog 历史文件
- if err := app.BinlogRepo.DeleteById(ctx, jobId); err != nil {
+ if err := app.binlogRepo.DeleteById(ctx, jobId); err != nil {
return err
}
return nil
diff --git a/server/internal/db/application/db_restore.go b/server/internal/db/application/db_restore.go
index 896ffd93..e486d324 100644
--- a/server/internal/db/application/db_restore.go
+++ b/server/internal/db/application/db_restore.go
@@ -8,62 +8,62 @@ import (
)
type DbRestoreApp struct {
- DbApp Db `inject:"DbApp"`
- Scheduler *dbScheduler `inject:"DbScheduler"`
- InstanceRepo repository.Instance `inject:"DbInstanceRepo"`
- BackupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
- RestoreRepo repository.DbRestore `inject:"DbRestoreRepo"`
- RestoreHistoryRepo repository.DbRestoreHistory `inject:"DbRestoreHistoryRepo"`
- BinlogHistoryRepo repository.DbBinlogHistory `inject:"DbBinlogHistoryRepo"`
+ dbApp Db `inject:"DbApp"`
+ scheduler *dbScheduler `inject:"DbScheduler"`
+ instanceRepo repository.Instance `inject:"DbInstanceRepo"`
+ backupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
+ restoreRepo repository.DbRestore `inject:"DbRestoreRepo"`
+ restoreHistoryRepo repository.DbRestoreHistory `inject:"DbRestoreHistoryRepo"`
+ binlogHistoryRepo repository.DbBinlogHistory `inject:"DbBinlogHistoryRepo"`
}
func (app *DbRestoreApp) Init() error {
var jobs []*entity.DbRestore
- if err := app.RestoreRepo.ListToDo(&jobs); err != nil {
+ if err := app.restoreRepo.ListToDo(&jobs); err != nil {
return err
}
- if err := app.Scheduler.AddJob(context.Background(), false, entity.DbJobTypeRestore, jobs); err != nil {
+ if err := app.scheduler.AddJob(context.Background(), false, entity.DbJobTypeRestore, jobs); err != nil {
return err
}
return nil
}
func (app *DbRestoreApp) Close() {
- app.Scheduler.Close()
+ app.scheduler.Close()
}
func (app *DbRestoreApp) Create(ctx context.Context, job *entity.DbRestore) error {
- return app.Scheduler.AddJob(ctx, true /* 保存到数据库 */, entity.DbJobTypeRestore, job)
+ return app.scheduler.AddJob(ctx, true /* 保存到数据库 */, entity.DbJobTypeRestore, job)
}
func (app *DbRestoreApp) Update(ctx context.Context, job *entity.DbRestore) error {
- return app.Scheduler.UpdateJob(ctx, job)
+ return app.scheduler.UpdateJob(ctx, job)
}
func (app *DbRestoreApp) Delete(ctx context.Context, jobId uint64) error {
// todo: 删除数据库恢复历史文件
- return app.Scheduler.RemoveJob(ctx, entity.DbJobTypeRestore, jobId)
+ return app.scheduler.RemoveJob(ctx, entity.DbJobTypeRestore, jobId)
}
func (app *DbRestoreApp) Enable(ctx context.Context, jobId uint64) error {
- return app.Scheduler.EnableJob(ctx, entity.DbJobTypeRestore, jobId)
+ return app.scheduler.EnableJob(ctx, entity.DbJobTypeRestore, jobId)
}
func (app *DbRestoreApp) Disable(ctx context.Context, jobId uint64) error {
- return app.Scheduler.DisableJob(ctx, entity.DbJobTypeRestore, jobId)
+ return app.scheduler.DisableJob(ctx, entity.DbJobTypeRestore, jobId)
}
// GetPageList 分页获取数据库恢复任务
func (app *DbRestoreApp) GetPageList(condition *entity.DbJobQuery, pageParam *model.PageParam, toEntity any, orderBy ...string) (*model.PageResult[any], error) {
- return app.RestoreRepo.GetPageList(condition, pageParam, toEntity, orderBy...)
+ return app.restoreRepo.GetPageList(condition, pageParam, toEntity, orderBy...)
}
// GetDbNamesWithoutRestore 获取未配置定时恢复的数据库名称
func (app *DbRestoreApp) GetDbNamesWithoutRestore(instanceId uint64, dbNames []string) ([]string, error) {
- return app.RestoreRepo.GetDbNamesWithoutRestore(instanceId, dbNames)
+ return app.restoreRepo.GetDbNamesWithoutRestore(instanceId, dbNames)
}
// GetHistoryPageList 分页获取数据库备份历史
func (app *DbRestoreApp) GetHistoryPageList(condition *entity.DbRestoreHistoryQuery, pageParam *model.PageParam, toEntity any, orderBy ...string) (*model.PageResult[any], error) {
- return app.RestoreHistoryRepo.GetDbRestoreHistories(condition, pageParam, toEntity, orderBy...)
+ return app.restoreHistoryRepo.GetDbRestoreHistories(condition, pageParam, toEntity, orderBy...)
}
diff --git a/server/internal/db/application/db_scheduler.go b/server/internal/db/application/db_scheduler.go
index a9e52d3c..c97e130c 100644
--- a/server/internal/db/application/db_scheduler.go
+++ b/server/internal/db/application/db_scheduler.go
@@ -21,13 +21,13 @@ const (
type dbScheduler struct {
mutex sync.Mutex
runner *runner.Runner[entity.DbJob]
- DbApp Db `inject:"DbApp"`
- BackupRepo repository.DbBackup `inject:"DbBackupRepo"`
- BackupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
- RestoreRepo repository.DbRestore `inject:"DbRestoreRepo"`
- RestoreHistoryRepo repository.DbRestoreHistory `inject:"DbRestoreHistoryRepo"`
- BinlogRepo repository.DbBinlog `inject:"DbBinlogRepo"`
- BinlogHistoryRepo repository.DbBinlogHistory `inject:"DbBinlogHistoryRepo"`
+ dbApp Db `inject:"DbApp"`
+ backupRepo repository.DbBackup `inject:"DbBackupRepo"`
+ backupHistoryRepo repository.DbBackupHistory `inject:"DbBackupHistoryRepo"`
+ restoreRepo repository.DbRestore `inject:"DbRestoreRepo"`
+ restoreHistoryRepo repository.DbRestoreHistory `inject:"DbRestoreHistoryRepo"`
+ binlogRepo repository.DbBinlog `inject:"DbBinlogRepo"`
+ binlogHistoryRepo repository.DbBinlogHistory `inject:"DbBinlogHistoryRepo"`
binlogTimes map[uint64]time.Time
}
@@ -47,11 +47,11 @@ func (s *dbScheduler) scheduleJob(job entity.DbJob) (time.Time, error) {
func (s *dbScheduler) repo(typ entity.DbJobType) repository.DbJob {
switch typ {
case entity.DbJobTypeBackup:
- return s.BackupRepo
+ return s.backupRepo
case entity.DbJobTypeRestore:
- return s.RestoreRepo
+ return s.restoreRepo
case entity.DbJobTypeBinlog:
- return s.BinlogRepo
+ return s.binlogRepo
default:
panic(errors.New(fmt.Sprintf("无效的数据库任务类型: %v", typ)))
}
@@ -177,7 +177,7 @@ func (s *dbScheduler) backupMysql(ctx context.Context, job entity.DbJob) error {
DbInstanceId: backup.DbInstanceId,
DbName: backup.DbName,
}
- conn, err := s.DbApp.GetDbConnByInstanceId(backup.DbInstanceId)
+ conn, err := s.dbApp.GetDbConnByInstanceId(backup.DbInstanceId)
if err != nil {
return err
}
@@ -197,7 +197,7 @@ func (s *dbScheduler) backupMysql(ctx context.Context, job entity.DbJob) error {
history.BinlogSequence = binlogInfo.Sequence
history.BinlogPosition = binlogInfo.Position
- if err := s.BackupHistoryRepo.Insert(ctx, history); err != nil {
+ if err := s.backupHistoryRepo.Insert(ctx, history); err != nil {
return err
}
return nil
@@ -205,7 +205,7 @@ func (s *dbScheduler) backupMysql(ctx context.Context, job entity.DbJob) error {
func (s *dbScheduler) restoreMysql(ctx context.Context, job entity.DbJob) error {
restore := job.(*entity.DbRestore)
- conn, err := s.DbApp.GetDbConnByInstanceId(restore.DbInstanceId)
+ conn, err := s.dbApp.GetDbConnByInstanceId(restore.DbInstanceId)
if err != nil {
return err
}
@@ -223,14 +223,14 @@ func (s *dbScheduler) restoreMysql(ctx context.Context, job entity.DbJob) error
}
latestBinlogSequence, earliestBackupSequence := int64(-1), int64(-1)
- binlogHistory, ok, err := s.BinlogHistoryRepo.GetLatestHistory(restore.DbInstanceId)
+ 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)
+ backupHistory, ok, err := s.backupHistoryRepo.GetEarliestHistory(restore.DbInstanceId)
if err != nil {
return err
}
@@ -243,7 +243,7 @@ func (s *dbScheduler) restoreMysql(ctx context.Context, job entity.DbJob) error
if err != nil {
return err
}
- if err := s.BinlogHistoryRepo.InsertWithBinlogFiles(ctx, restore.DbInstanceId, binlogFiles); err != nil {
+ if err := s.binlogHistoryRepo.InsertWithBinlogFiles(ctx, restore.DbInstanceId, binlogFiles); err != nil {
return err
}
if err := s.restorePointInTime(ctx, dbProgram, restore); err != nil {
@@ -259,7 +259,7 @@ func (s *dbScheduler) restoreMysql(ctx context.Context, job entity.DbJob) error
CreateTime: time.Now(),
DbRestoreId: restore.Id,
}
- if err := s.RestoreHistoryRepo.Insert(ctx, history); err != nil {
+ if err := s.restoreHistoryRepo.Insert(ctx, history); err != nil {
return err
}
return nil
@@ -330,7 +330,7 @@ func relatedToBinlog(typ entity.DbJobType) bool {
}
func (s *dbScheduler) restorePointInTime(ctx context.Context, program dbi.DbProgram, job *entity.DbRestore) error {
- binlogHistory, err := s.BinlogHistoryRepo.GetHistoryByTime(job.DbInstanceId, job.PointInTime.Time)
+ binlogHistory, err := s.binlogHistoryRepo.GetHistoryByTime(job.DbInstanceId, job.PointInTime.Time)
if err != nil {
return err
}
@@ -343,7 +343,7 @@ func (s *dbScheduler) restorePointInTime(ctx context.Context, program dbi.DbProg
Sequence: binlogHistory.Sequence,
Position: position,
}
- backupHistory, err := s.BackupHistoryRepo.GetLatestHistory(job.DbInstanceId, job.DbName, target)
+ backupHistory, err := s.backupHistoryRepo.GetLatestHistory(job.DbInstanceId, job.DbName, target)
if err != nil {
return err
}
@@ -352,7 +352,7 @@ func (s *dbScheduler) restorePointInTime(ctx context.Context, program dbi.DbProg
Sequence: backupHistory.BinlogSequence,
Position: backupHistory.BinlogPosition,
}
- binlogHistories, err := s.BinlogHistoryRepo.GetHistories(job.DbInstanceId, start, target)
+ binlogHistories, err := s.binlogHistoryRepo.GetHistories(job.DbInstanceId, start, target)
if err != nil {
return err
}
@@ -389,7 +389,7 @@ func (s *dbScheduler) restorePointInTime(ctx context.Context, program dbi.DbProg
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 {
+ if err := s.backupHistoryRepo.GetById(backupHistory, job.DbBackupHistoryId); err != nil {
return err
}
return program.RestoreBackupHistory(ctx, backupHistory.DbName, backupHistory.DbBackupId, backupHistory.Uuid)
@@ -398,14 +398,14 @@ func (s *dbScheduler) restoreBackupHistory(ctx context.Context, program dbi.DbPr
func (s *dbScheduler) fetchBinlogMysql(ctx context.Context, backup entity.DbJob) error {
instanceId := backup.GetJobBase().DbInstanceId
latestBinlogSequence, earliestBackupSequence := int64(-1), int64(-1)
- binlogHistory, ok, err := s.BinlogHistoryRepo.GetLatestHistory(instanceId)
+ binlogHistory, ok, err := s.binlogHistoryRepo.GetLatestHistory(instanceId)
if err != nil {
return err
}
if ok {
latestBinlogSequence = binlogHistory.Sequence
} else {
- backupHistory, ok, err := s.BackupHistoryRepo.GetEarliestHistory(instanceId)
+ backupHistory, ok, err := s.backupHistoryRepo.GetEarliestHistory(instanceId)
if err != nil {
return err
}
@@ -414,7 +414,7 @@ func (s *dbScheduler) fetchBinlogMysql(ctx context.Context, backup entity.DbJob)
}
earliestBackupSequence = backupHistory.BinlogSequence
}
- conn, err := s.DbApp.GetDbConnByInstanceId(instanceId)
+ conn, err := s.dbApp.GetDbConnByInstanceId(instanceId)
if err != nil {
return err
}
@@ -423,5 +423,5 @@ func (s *dbScheduler) fetchBinlogMysql(ctx context.Context, backup entity.DbJob)
if err != nil {
return err
}
- return s.BinlogHistoryRepo.InsertWithBinlogFiles(ctx, instanceId, binlogFiles)
+ return s.binlogHistoryRepo.InsertWithBinlogFiles(ctx, instanceId, binlogFiles)
}
diff --git a/server/internal/db/router/db_backup.go b/server/internal/db/router/db_backup.go
index cd586dfa..c21482e4 100644
--- a/server/internal/db/router/db_backup.go
+++ b/server/internal/db/router/db_backup.go
@@ -12,10 +12,7 @@ import (
func InitDbBackupRouter(router *gin.RouterGroup) {
dbs := router.Group("/dbs")
- d := &api.DbBackup{
- //DbBackupApp: application.GetDbBackupApp(),
- //DbApp: application.GetDbApp(),
- }
+ d := &api.DbBackup{}
biz.ErrIsNil(ioc.Inject(d))
reqs := []*req.Conf{
diff --git a/server/internal/db/router/db_restore.go b/server/internal/db/router/db_restore.go
index 0af5468a..cc68e668 100644
--- a/server/internal/db/router/db_restore.go
+++ b/server/internal/db/router/db_restore.go
@@ -12,10 +12,7 @@ import (
func InitDbRestoreRouter(router *gin.RouterGroup) {
dbs := router.Group("/dbs")
- d := &api.DbRestore{
- //DbRestoreApp: application.GetDbRestoreApp(),
- //DbApp: application.GetDbApp(),
- }
+ d := &api.DbRestore{}
biz.ErrIsNil(ioc.Inject(d))
reqs := []*req.Conf{
diff --git a/server/pkg/ioc/ioc.go b/server/pkg/ioc/ioc.go
index 34e29478..05099dfb 100644
--- a/server/pkg/ioc/ioc.go
+++ b/server/pkg/ioc/ioc.go
@@ -108,12 +108,13 @@ func (c *Container) injectWithField(objValue reflect.Value) error {
return fmt.Errorf("%s error: 注入类型不一致(期望类型->%s.%s, 组件类型->%s.%s)", injectInfo, field.Type.PkgPath(), field.Type.Name(), componentType.PkgPath(), componentType.Name())
}
- objValueField := objValue.Field(i)
- if !objValueField.IsValid() || !objValueField.CanSet() {
+ fieldValue := objValue.Field(i)
+ fieldPtrValue := reflect.NewAt(fieldValue.Type(), fieldValue.Addr().UnsafePointer())
+ fieldValue = fieldPtrValue.Elem()
+ if !fieldValue.IsValid() || !fieldValue.CanSet() {
return fmt.Errorf("%s error: 字段无效或为不可导出类型", injectInfo)
}
-
- objValueField.Set(reflect.ValueOf(component))
+ fieldValue.Set(reflect.ValueOf(component))
}
return nil