models/admin/task.go - master - uzer_007/Rixea

models/admin/task.go
174 строки5 KB
uzer_007
feat: первая версия Rixea
02 авг 2026, 22:16
02 авг 2026, 22:16d4f7504
// Copyright 2026 Uzer_007. All rights reserved.
// SPDX-License-Identifier: MIT

package admin

import (
	"context"
	"fmt"

	repo_model "gitverse.ru/uzer_007/Rixea/models/repo"
	user_model "gitverse.ru/uzer_007/Rixea/models/user"
	"gitverse.ru/uzer_007/Rixea/modules/json"
	"gitverse.ru/uzer_007/Rixea/modules/log"
	"gitverse.ru/uzer_007/Rixea/modules/migration"
	"gitverse.ru/uzer_007/Rixea/modules/secret"
	"gitverse.ru/uzer_007/Rixea/modules/setting"
	"gitverse.ru/uzer_007/Rixea/modules/structs"
	"gitverse.ru/uzer_007/Rixea/modules/timeutil"
	"gitverse.ru/uzer_007/Rixea/modules/util"
)

// Task represents a task
type Task struct {
	ID             int64
	DoerID         int64 // operator
	Doer           *user_model.User
	OwnerID        int64 // repo owner id, when creating, the repoID maybe zero
	Owner          *user_model.User
	RepoID         int64
	Repo           *repo_model.Repository
	Type           structs.TaskType
	Status         structs.TaskStatus
	StartTime      timeutil.TimeStamp
	EndTime        timeutil.TimeStamp
	PayloadContent string
	Message        string // if task failed, saved the error reason, it could be a JSON string of TranslatableMessage or a plain message
	Created        timeutil.TimeStamp
}

// TranslatableMessage represents JSON struct that can be translated with a Locale
type TranslatableMessage struct {
	Format string
	Args   []any `json:",omitempty"`
}

// LoadRepo loads repository of the task
func (task *Task) LoadRepo(ctx context.Context) error {
	if task.Repo != nil {
		return nil
	}
	repo, err := repo_model.GetRepositoryByID(ctx, task.RepoID)
	if err == nil {
		task.Repo = repo
	}
	return err
}

// LoadDoer loads do user
func (task *Task) LoadDoer(ctx context.Context) error {
	if task.Doer != nil {
		return nil
	}

	doer, err := user_model.GetUserByID(ctx, task.DoerID)
	if err == nil {
		task.Doer = doer
	}
	return err
}

// LoadOwner loads owner user
func (task *Task) LoadOwner(ctx context.Context) error {
	if task.Owner != nil {
		return nil
	}

	owner, err := user_model.GetUserByID(ctx, task.OwnerID)
	if err == nil {
		task.Owner = owner
	}
	return err
}

// UpdateCols updates some columns
func (task *Task) UpdateCols(ctx context.Context, cols ...string) error {
	return updateReindexerTaskCols(ctx, task, cols...)
}

// MigrateConfig returns task config when migrate repository
func (task *Task) MigrateConfig() (*migration.MigrateOptions, error) {
	if task.Type == structs.TaskTypeMigrateRepo {
		var opts migration.MigrateOptions
		err := json.Unmarshal([]byte(task.PayloadContent), &opts)
		if err != nil {
			return nil, err
		}

		// decrypt credentials
		if opts.CloneAddrEncrypted != "" {
			if opts.CloneAddr, err = secret.DecryptSecret(setting.SecretKey, secret.PurposeMigrationCloneURL, opts.CloneAddrEncrypted); err != nil {
				log.Error("Unable to decrypt CloneAddr, maybe SECRET_KEY is wrong: %v", err)
			}
		}
		if opts.AuthPasswordEncrypted != "" {
			if opts.AuthPassword, err = secret.DecryptSecret(setting.SecretKey, secret.PurposeMigrationPassword, opts.AuthPasswordEncrypted); err != nil {
				log.Error("Unable to decrypt AuthPassword, maybe SECRET_KEY is wrong: %v", err)
			}
		}
		if opts.AuthTokenEncrypted != "" {
			if opts.AuthToken, err = secret.DecryptSecret(setting.SecretKey, secret.PurposeMigrationAuthToken, opts.AuthTokenEncrypted); err != nil {
				log.Error("Unable to decrypt AuthToken, maybe SECRET_KEY is wrong: %v", err)
			}
		}
		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
}

// IsErrTaskDoesNotExist checks if an error is a ErrTaskDoesNotExist.
func IsErrTaskDoesNotExist(err error) bool {
	_, ok := err.(ErrTaskDoesNotExist)
	return ok
}

func (err ErrTaskDoesNotExist) Error() string {
	return fmt.Sprintf("task does not exist [id: %d, repo_id: %d, type: %d]",
		err.ID, err.RepoID, err.Type)
}

func (err ErrTaskDoesNotExist) Unwrap() error {
	return util.ErrNotExist
}

// GetMigratingTask returns the migrating task by repo's id
func GetMigratingTask(ctx context.Context, repoID int64) (*Task, error) {
	return getReindexerMigratingTask(ctx, repoID)
}

// CreateTask creates a task on database
func CreateTask(ctx context.Context, task *Task) error {
	return createReindexerTask(ctx, task)
}

// FinishMigrateTask updates database when migrate task finished
func FinishMigrateTask(ctx context.Context, task *Task) error {
	task.Status = structs.TaskStatusFinished
	task.EndTime = timeutil.TimeStampNow()

	// delete credentials when we're done, they're a liability.
	conf, err := task.MigrateConfig()
	if err != nil {
		return err
	}
	conf.AuthPassword = ""
	conf.AuthToken = ""
	conf.CloneAddr = util.SanitizeCredentialURLs(conf.CloneAddr)
	conf.AuthPasswordEncrypted = ""
	conf.AuthTokenEncrypted = ""
	conf.CloneAddrEncrypted = ""
	confBytes, err := json.Marshal(conf)
	if err != nil {
		return err
	}
	task.PayloadContent = string(confBytes)

	return task.UpdateCols(ctx, "status", "end_time", "payload_content")
}