From 6e52d4196894d28d13985781f8ff77c187fc09ef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sybren=20A=2E=20St=C3=BCvel?= Date: Sun, 30 Jun 2024 21:14:28 +0200 Subject: [PATCH] Manager: more sqlc to gorm conversionfunctions for jobs & tasks Some reorganisation to make it easier to convert a job & its tasks from sqlc to gorm data structures. The persistence layer is being converted to sqlc. Once that is done, the remainder of the code can switch over from using gorm structs to sqlc structs. Then this code will no longer be necessary. --- internal/manager/persistence/jobs.go | 100 ++++++++++++++++++--------- 1 file changed, 67 insertions(+), 33 deletions(-) diff --git a/internal/manager/persistence/jobs.go b/internal/manager/persistence/jobs.go index 30a1af21..0a512db4 100644 --- a/internal/manager/persistence/jobs.go +++ b/internal/manager/persistence/jobs.go @@ -307,7 +307,11 @@ func (db *DB) FetchJob(ctx context.Context, jobUUID string) (*Job, error) { return nil, jobError(err, "fetching job") } - return convertSqlcJob(sqlcJob) + gormJob, err := convertSqlcJob(sqlcJob) + if err != nil { + return nil, err + } + return &gormJob, nil } // FetchJobShamanCheckoutID fetches the job's Shaman Checkout ID. @@ -443,7 +447,7 @@ func (db *DB) FetchJobsInStatus(ctx context.Context, jobStatuses ...api.JobStatu if err != nil { return nil, jobError(err, "converting fetched jobs in status %q", jobStatuses) } - jobs = append(jobs, job) + jobs = append(jobs, &job) } return jobs, nil @@ -522,39 +526,60 @@ func (db *DB) FetchTask(ctx context.Context, taskUUID string) (*Task, error) { return nil, taskError(err, "fetching task %s", taskUUID) } - convertedTask, err := convertSqlcTask(taskRow.Task, taskRow.JobUUID.String, taskRow.WorkerUUID.String) + return convertSqlTaskWithJobAndWorker(ctx, queries, taskRow.Task) +} + +// TODO: remove this code, and let the code that calls into the persistence +// service fetch the job/worker explicitly when needed. +func convertSqlTaskWithJobAndWorker( + ctx context.Context, + queries *sqlc.Queries, + task sqlc.Task, +) (*Task, error) { + var ( + gormJob Job + gormWorker Worker + ) + + // Fetch & convert the Job. + if task.JobID > 0 { + sqlcJob, err := queries.FetchJobByID(ctx, task.JobID) + if err != nil { + return nil, jobError(err, "fetching job of task %s", task.UUID) + } + + gormJob, err = convertSqlcJob(sqlcJob) + if err != nil { + return nil, jobError(err, "converting job of task %s", task.UUID) + } + } + + // Fetch & convert the Worker. + if task.WorkerID.Valid && task.WorkerID.Int64 > 0 { + sqlcWorker, err := queries.FetchWorkerUnconditionalByID(ctx, task.WorkerID.Int64) + if err != nil { + return nil, taskError(err, "fetching worker assigned to task %s", task.UUID) + } + gormWorker = convertSqlcWorker(sqlcWorker) + } + + // Convert the Task. + gormTask, err := convertSqlcTask(task, gormJob.UUID, gormWorker.UUID) if err != nil { return nil, err } - // TODO: remove this code, and let the caller fetch the job explicitly when needed. - if taskRow.Task.JobID > 0 { - dbJob, err := queries.FetchJobByID(ctx, taskRow.Task.JobID) - if err != nil { - return nil, jobError(err, "fetching job of task %s", taskUUID) - } - - convertedJob, err := convertSqlcJob(dbJob) - if err != nil { - return nil, jobError(err, "converting job of task %s", taskUUID) - } - convertedTask.Job = convertedJob - if convertedTask.JobUUID != convertedJob.UUID { - panic("Conversion to SQLC is incomplete") - } + // Put the Job & Worker into the Task. + if gormJob.ID > 0 { + gormTask.Job = &gormJob + gormTask.JobUUID = gormJob.UUID + } + if gormWorker.ID > 0 { + gormTask.Worker = &gormWorker + gormTask.WorkerUUID = gormWorker.UUID } - // TODO: remove this code, and let the caller fetch the Worker explicitly when needed. - if taskRow.WorkerUUID.Valid { - worker, err := queries.FetchWorkerUnconditional(ctx, taskRow.WorkerUUID.String) - if err != nil { - return nil, taskError(err, "fetching worker assigned to task %s", taskUUID) - } - convertedWorker := convertSqlcWorker(worker) - convertedTask.Worker = &convertedWorker - } - - return convertedTask, nil + return gormTask, nil } // FetchTaskJobUUID fetches the job UUID of the given task. @@ -1031,7 +1056,7 @@ func (db *DB) FetchTaskFailureList(ctx context.Context, t *Task) ([]*Worker, err // expected by the rest of the code. This is mostly in place to aid in the GORM // to SQLC migration. It is intended that eventually the rest of the code will // use the same SQLC-generated model. -func convertSqlcJob(job sqlc.Job) (*Job, error) { +func convertSqlcJob(job sqlc.Job) (Job, error) { dbJob := Job{ Model: Model{ ID: uint(job.ID), @@ -1051,11 +1076,11 @@ func convertSqlcJob(job sqlc.Job) (*Job, error) { } if err := json.Unmarshal(job.Settings, &dbJob.Settings); err != nil { - return nil, jobError(err, fmt.Sprintf("job %s has invalid settings: %v", job.UUID, err)) + return Job{}, jobError(err, fmt.Sprintf("job %s has invalid settings: %v", job.UUID, err)) } if err := json.Unmarshal(job.Metadata, &dbJob.Metadata); err != nil { - return nil, jobError(err, fmt.Sprintf("job %s has invalid metadata: %v", job.UUID, err)) + return Job{}, jobError(err, fmt.Sprintf("job %s has invalid metadata: %v", job.UUID, err)) } if job.WorkerTagID.Valid { @@ -1063,7 +1088,7 @@ func convertSqlcJob(job sqlc.Job) (*Job, error) { dbJob.WorkerTagID = &workerTagID } - return &dbJob, nil + return dbJob, nil } // convertSqlcTask converts a FetchTaskRow from the SQLC-generated model to the @@ -1114,3 +1139,12 @@ func convertTaskStatuses(taskStatuses []api.TaskStatus) []string { } return statusesAsStrings } + +// convertJobStatuses converts from []api.JobStatus to []string for feeding to sqlc. +func convertJobStatuses(jobStatuses []api.JobStatus) []string { + statusesAsStrings := make([]string, len(jobStatuses)) + for index := range jobStatuses { + statusesAsStrings[index] = string(jobStatuses[index]) + } + return statusesAsStrings +}