830c3fe794
As it was decided that the name "tags" would be better for the clarity of the feature, all files and code named "cluster" or "worker cluster" have been removed and replaced with "tag" and "worker tag". This is only a name change, no other features were touched. This addresses part of #104204. Reviewed-on: https://projects.blender.org/studio/flamenco/pulls/104223 As a note to anyone who already ran a pre-release version of Flamenco and configured some worker clusters, with the help of an SQLite client you can migrate the clusters to tags. First build Flamenco Manager and start it, to create the new database schema. Then run these SQL queries via an sqlite commandline client: ```sql insert into worker_tags (id, created_at, updated_at, uuid, name, description) select id, created_at, updated_at, uuid, name, description from worker_clusters; insert into worker_tag_membership (worker_tag_id, worker_id) select worker_cluster_id, worker_id from worker_cluster_membership; ```
97 lines
3.0 KiB
Go
97 lines
3.0 KiB
Go
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
package persistence
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
var (
|
|
ErrJobNotFound = PersistenceError{Message: "job not found", Err: gorm.ErrRecordNotFound}
|
|
ErrTaskNotFound = PersistenceError{Message: "task not found", Err: gorm.ErrRecordNotFound}
|
|
ErrWorkerNotFound = PersistenceError{Message: "worker not found", Err: gorm.ErrRecordNotFound}
|
|
ErrWorkerTagNotFound = PersistenceError{Message: "worker tag not found", Err: gorm.ErrRecordNotFound}
|
|
)
|
|
|
|
type PersistenceError struct {
|
|
Message string // The error message.
|
|
Err error // Any wrapped error.
|
|
}
|
|
|
|
func (e PersistenceError) Error() string {
|
|
return fmt.Sprintf("%s: %v", e.Message, e.Err)
|
|
}
|
|
|
|
func (e PersistenceError) Is(err error) bool {
|
|
return err == e.Err
|
|
}
|
|
|
|
func jobError(errorToWrap error, message string, msgArgs ...interface{}) error {
|
|
return wrapError(translateGormJobError(errorToWrap), message, msgArgs...)
|
|
}
|
|
|
|
func taskError(errorToWrap error, message string, msgArgs ...interface{}) error {
|
|
return wrapError(translateGormTaskError(errorToWrap), message, msgArgs...)
|
|
}
|
|
|
|
func workerError(errorToWrap error, message string, msgArgs ...interface{}) error {
|
|
return wrapError(translateGormWorkerError(errorToWrap), message, msgArgs...)
|
|
}
|
|
|
|
func workerTagError(errorToWrap error, message string, msgArgs ...interface{}) error {
|
|
return wrapError(translateGormWorkerTagError(errorToWrap), message, msgArgs...)
|
|
}
|
|
|
|
func wrapError(errorToWrap error, message string, format ...interface{}) error {
|
|
// Only format if there are arguments for formatting.
|
|
var formattedMsg string
|
|
if len(format) > 0 {
|
|
formattedMsg = fmt.Sprintf(message, format...)
|
|
} else {
|
|
formattedMsg = message
|
|
}
|
|
|
|
return PersistenceError{
|
|
Message: formattedMsg,
|
|
Err: errorToWrap,
|
|
}
|
|
}
|
|
|
|
// translateGormJobError translates a Gorm error to a persistence layer error.
|
|
// This helps to keep Gorm as "implementation detail" of the persistence layer.
|
|
func translateGormJobError(gormError error) error {
|
|
if errors.Is(gormError, gorm.ErrRecordNotFound) {
|
|
return ErrJobNotFound
|
|
}
|
|
return gormError
|
|
}
|
|
|
|
// translateGormTaskError translates a Gorm error to a persistence layer error.
|
|
// This helps to keep Gorm as "implementation detail" of the persistence layer.
|
|
func translateGormTaskError(gormError error) error {
|
|
if errors.Is(gormError, gorm.ErrRecordNotFound) {
|
|
return ErrTaskNotFound
|
|
}
|
|
return gormError
|
|
}
|
|
|
|
// translateGormWorkerError translates a Gorm error to a persistence layer error.
|
|
// This helps to keep Gorm as "implementation detail" of the persistence layer.
|
|
func translateGormWorkerError(gormError error) error {
|
|
if errors.Is(gormError, gorm.ErrRecordNotFound) {
|
|
return ErrWorkerNotFound
|
|
}
|
|
return gormError
|
|
}
|
|
|
|
// translateGormWorkerTagError translates a Gorm error to a persistence layer error.
|
|
// This helps to keep Gorm as "implementation detail" of the persistence layer.
|
|
func translateGormWorkerTagError(gormError error) error {
|
|
if errors.Is(gormError, gorm.ErrRecordNotFound) {
|
|
return ErrWorkerTagNotFound
|
|
}
|
|
return gormError
|
|
}
|