2019-10-13 21:23:14 +08:00
|
|
|
// Copyright 2019 Gitea. All rights reserved.
|
2022-11-28 02:20:29 +08:00
|
|
|
// SPDX-License-Identifier: MIT
|
2019-10-13 21:23:14 +08:00
|
|
|
|
2022-08-25 10:31:57 +08:00
|
|
|
package admin
|
2019-10-13 21:23:14 +08:00
|
|
|
|
|
|
|
import (
|
2022-05-20 22:08:52 +08:00
|
|
|
"context"
|
2019-10-13 21:23:14 +08:00
|
|
|
"fmt"
|
|
|
|
|
2021-09-19 19:49:59 +08:00
|
|
|
"code.gitea.io/gitea/models/db"
|
2021-12-10 09:27:50 +08:00
|
|
|
repo_model "code.gitea.io/gitea/models/repo"
|
2021-11-24 17:49:20 +08:00
|
|
|
user_model "code.gitea.io/gitea/models/user"
|
2021-07-25 00:03:58 +08:00
|
|
|
"code.gitea.io/gitea/modules/json"
|
2021-11-16 23:25:33 +08:00
|
|
|
"code.gitea.io/gitea/modules/migration"
|
2021-05-31 16:25:47 +08:00
|
|
|
"code.gitea.io/gitea/modules/secret"
|
|
|
|
"code.gitea.io/gitea/modules/setting"
|
2019-10-13 21:23:14 +08:00
|
|
|
"code.gitea.io/gitea/modules/structs"
|
|
|
|
"code.gitea.io/gitea/modules/timeutil"
|
2021-05-31 16:25:47 +08:00
|
|
|
"code.gitea.io/gitea/modules/util"
|
2019-10-13 21:23:14 +08:00
|
|
|
)
|
|
|
|
|
|
|
|
// Task represents a task
|
|
|
|
type Task struct {
|
|
|
|
ID int64
|
2021-12-10 09:27:50 +08:00
|
|
|
DoerID int64 `xorm:"index"` // operator
|
|
|
|
Doer *user_model.User `xorm:"-"`
|
|
|
|
OwnerID int64 `xorm:"index"` // repo owner id, when creating, the repoID maybe zero
|
|
|
|
Owner *user_model.User `xorm:"-"`
|
|
|
|
RepoID int64 `xorm:"index"`
|
|
|
|
Repo *repo_model.Repository `xorm:"-"`
|
2019-10-13 21:23:14 +08:00
|
|
|
Type structs.TaskType
|
|
|
|
Status structs.TaskStatus `xorm:"index"`
|
|
|
|
StartTime timeutil.TimeStamp
|
|
|
|
EndTime timeutil.TimeStamp
|
|
|
|
PayloadContent string `xorm:"TEXT"`
|
2023-05-11 16:25:46 +08:00
|
|
|
Message string `xorm:"TEXT"` // if task failed, saved the error reason, it could be a JSON string of TranslatableMessage or a plain message
|
2019-10-13 21:23:14 +08:00
|
|
|
Created timeutil.TimeStamp `xorm:"created"`
|
|
|
|
}
|
|
|
|
|
2021-09-19 19:49:59 +08:00
|
|
|
func init() {
|
|
|
|
db.RegisterModel(new(Task))
|
|
|
|
}
|
|
|
|
|
2021-06-17 06:02:24 +08:00
|
|
|
// TranslatableMessage represents JSON struct that can be translated with a Locale
|
|
|
|
type TranslatableMessage struct {
|
|
|
|
Format string
|
2023-07-05 11:41:32 +08:00
|
|
|
Args []any `json:"omitempty"`
|
2021-06-17 06:02:24 +08:00
|
|
|
}
|
|
|
|
|
2019-10-13 21:23:14 +08:00
|
|
|
// LoadRepo loads repository of the task
|
|
|
|
func (task *Task) LoadRepo() error {
|
2022-05-20 22:08:52 +08:00
|
|
|
return task.loadRepo(db.DefaultContext)
|
2019-10-13 21:23:14 +08:00
|
|
|
}
|
|
|
|
|
2022-05-20 22:08:52 +08:00
|
|
|
func (task *Task) loadRepo(ctx context.Context) error {
|
2019-10-13 21:23:14 +08:00
|
|
|
if task.Repo != nil {
|
|
|
|
return nil
|
|
|
|
}
|
2021-12-10 09:27:50 +08:00
|
|
|
var repo repo_model.Repository
|
2022-05-20 22:08:52 +08:00
|
|
|
has, err := db.GetEngine(ctx).ID(task.RepoID).Get(&repo)
|
2019-10-13 21:23:14 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if !has {
|
2021-12-10 09:27:50 +08:00
|
|
|
return repo_model.ErrRepoNotExist{
|
2019-10-13 21:23:14 +08:00
|
|
|
ID: task.RepoID,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
task.Repo = &repo
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// LoadDoer loads do user
|
|
|
|
func (task *Task) LoadDoer() error {
|
|
|
|
if task.Doer != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-11-24 17:49:20 +08:00
|
|
|
var doer user_model.User
|
2021-09-23 23:45:36 +08:00
|
|
|
has, err := db.GetEngine(db.DefaultContext).ID(task.DoerID).Get(&doer)
|
2019-10-13 21:23:14 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if !has {
|
2021-11-24 17:49:20 +08:00
|
|
|
return user_model.ErrUserNotExist{
|
2019-10-13 21:23:14 +08:00
|
|
|
UID: task.DoerID,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
task.Doer = &doer
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// LoadOwner loads owner user
|
|
|
|
func (task *Task) LoadOwner() error {
|
|
|
|
if task.Owner != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2021-11-24 17:49:20 +08:00
|
|
|
var owner user_model.User
|
2021-09-23 23:45:36 +08:00
|
|
|
has, err := db.GetEngine(db.DefaultContext).ID(task.OwnerID).Get(&owner)
|
2019-10-13 21:23:14 +08:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if !has {
|
2021-11-24 17:49:20 +08:00
|
|
|
return user_model.ErrUserNotExist{
|
2019-10-13 21:23:14 +08:00
|
|
|
UID: task.OwnerID,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
task.Owner = &owner
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// UpdateCols updates some columns
|
|
|
|
func (task *Task) UpdateCols(cols ...string) error {
|
2021-09-23 23:45:36 +08:00
|
|
|
_, err := db.GetEngine(db.DefaultContext).ID(task.ID).Cols(cols...).Update(task)
|
2019-10-13 21:23:14 +08:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// MigrateConfig returns task config when migrate repository
|
2020-09-11 06:29:19 +08:00
|
|
|
func (task *Task) MigrateConfig() (*migration.MigrateOptions, error) {
|
2019-10-13 21:23:14 +08:00
|
|
|
if task.Type == structs.TaskTypeMigrateRepo {
|
2020-09-11 06:29:19 +08:00
|
|
|
var opts migration.MigrateOptions
|
2019-10-13 21:23:14 +08:00
|
|
|
err := json.Unmarshal([]byte(task.PayloadContent), &opts)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2021-05-31 16:25:47 +08:00
|
|
|
|
|
|
|
// decrypt credentials
|
|
|
|
if opts.CloneAddrEncrypted != "" {
|
|
|
|
if opts.CloneAddr, err = secret.DecryptSecret(setting.SecretKey, opts.CloneAddrEncrypted); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if opts.AuthPasswordEncrypted != "" {
|
|
|
|
if opts.AuthPassword, err = secret.DecryptSecret(setting.SecretKey, opts.AuthPasswordEncrypted); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if opts.AuthTokenEncrypted != "" {
|
|
|
|
if opts.AuthToken, err = secret.DecryptSecret(setting.SecretKey, opts.AuthTokenEncrypted); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-13 21:23:14 +08:00
|
|
|
return &opts, nil
|
|
|
|
}
|
|
|
|
return nil, fmt.Errorf("Task type is %s, not Migrate Repo", task.Type.Name())
|
|
|
|
}
|
|
|
|
|
|
|
|
// ErrTaskDoesNotExist represents a "TaskDoesNotExist" kind of error.
|
|
|
|
type ErrTaskDoesNotExist struct {
|
|
|
|
ID int64
|
|
|
|
RepoID int64
|
|
|
|
Type structs.TaskType
|
|
|
|
}
|
|
|
|
|
2022-06-24 21:51:37 +08:00
|
|
|
// IsErrTaskDoesNotExist checks if an error is a ErrTaskDoesNotExist.
|
2019-10-13 21:23:14 +08:00
|
|
|
func IsErrTaskDoesNotExist(err error) bool {
|
|
|
|
_, ok := err.(ErrTaskDoesNotExist)
|
|
|
|
return ok
|
|
|
|
}
|
|
|
|
|
|
|
|
func (err ErrTaskDoesNotExist) Error() string {
|
2022-06-24 21:51:37 +08:00
|
|
|
return fmt.Sprintf("task does not exist [id: %d, repo_id: %d, type: %d]",
|
2019-10-13 21:23:14 +08:00
|
|
|
err.ID, err.RepoID, err.Type)
|
|
|
|
}
|
|
|
|
|
2022-10-18 13:50:37 +08:00
|
|
|
func (err ErrTaskDoesNotExist) Unwrap() error {
|
|
|
|
return util.ErrNotExist
|
|
|
|
}
|
|
|
|
|
2019-10-13 21:23:14 +08:00
|
|
|
// GetMigratingTask returns the migrating task by repo's id
|
|
|
|
func GetMigratingTask(repoID int64) (*Task, error) {
|
2021-03-15 02:52:12 +08:00
|
|
|
task := Task{
|
2019-10-13 21:23:14 +08:00
|
|
|
RepoID: repoID,
|
|
|
|
Type: structs.TaskTypeMigrateRepo,
|
|
|
|
}
|
2021-09-23 23:45:36 +08:00
|
|
|
has, err := db.GetEngine(db.DefaultContext).Get(&task)
|
2019-10-13 21:23:14 +08:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
} else if !has {
|
|
|
|
return nil, ErrTaskDoesNotExist{0, repoID, task.Type}
|
|
|
|
}
|
|
|
|
return &task, nil
|
|
|
|
}
|
|
|
|
|
2020-10-24 07:46:35 +08:00
|
|
|
// GetMigratingTaskByID returns the migrating task by repo's id
|
|
|
|
func GetMigratingTaskByID(id, doerID int64) (*Task, *migration.MigrateOptions, error) {
|
2021-03-15 02:52:12 +08:00
|
|
|
task := Task{
|
2020-10-24 07:46:35 +08:00
|
|
|
ID: id,
|
|
|
|
DoerID: doerID,
|
|
|
|
Type: structs.TaskTypeMigrateRepo,
|
|
|
|
}
|
2021-09-23 23:45:36 +08:00
|
|
|
has, err := db.GetEngine(db.DefaultContext).Get(&task)
|
2020-10-24 07:46:35 +08:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
} else if !has {
|
|
|
|
return nil, nil, ErrTaskDoesNotExist{id, 0, task.Type}
|
|
|
|
}
|
|
|
|
|
|
|
|
var opts migration.MigrateOptions
|
|
|
|
if err := json.Unmarshal([]byte(task.PayloadContent), &opts); err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
return &task, &opts, nil
|
|
|
|
}
|
|
|
|
|
2020-01-12 20:11:17 +08:00
|
|
|
// CreateTask creates a task on database
|
|
|
|
func CreateTask(task *Task) error {
|
2022-05-20 22:08:52 +08:00
|
|
|
return db.Insert(db.DefaultContext, task)
|
2019-10-13 21:23:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// FinishMigrateTask updates database when migrate task finished
|
|
|
|
func FinishMigrateTask(task *Task) error {
|
|
|
|
task.Status = structs.TaskStatusFinished
|
|
|
|
task.EndTime = timeutil.TimeStampNow()
|
2021-05-31 16:25:47 +08:00
|
|
|
|
|
|
|
// delete credentials when we're done, they're a liability.
|
|
|
|
conf, err := task.MigrateConfig()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
conf.AuthPassword = ""
|
|
|
|
conf.AuthToken = ""
|
2022-03-31 10:25:40 +08:00
|
|
|
conf.CloneAddr = util.SanitizeCredentialURLs(conf.CloneAddr)
|
2021-05-31 16:25:47 +08:00
|
|
|
conf.AuthPasswordEncrypted = ""
|
|
|
|
conf.AuthTokenEncrypted = ""
|
|
|
|
conf.CloneAddrEncrypted = ""
|
|
|
|
confBytes, err := json.Marshal(conf)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
task.PayloadContent = string(confBytes)
|
|
|
|
|
2021-11-21 23:41:00 +08:00
|
|
|
_, err = db.GetEngine(db.DefaultContext).ID(task.ID).Cols("status", "end_time", "payload_content").Update(task)
|
|
|
|
return err
|
2019-10-13 21:23:14 +08:00
|
|
|
}
|