Files
Kazier/backend/repository/ocr_jobs.go
T
m a6b7f2002b
CI / lint-backend (push) Failing after 1m39s
CI / lint-mobile (push) Canceled after 11m8s
CI / test-backend (push) Canceled after 0s
CI / test-mobile (push) Canceled after 0s
CI / build-backend (push) Canceled after 0s
CI / docker (push) Canceled after 0s
fix backend audit findings (auth, upload, sync, data, ocr, contract)
2026-09-21 19:59:52 +02:00

168 lines
4.6 KiB
Go

package repository
import (
"database/sql"
"errors"
"time"
)
// OcrJobRow maps ocr_jobs.
type OcrJobRow struct {
ID string
FileID string
DeviceID string
Status string
Text *string
Error *string
}
// ErrJobNotFound marks an OCR job absent or owned by another device.
var ErrJobNotFound = errors.New("ocr job not found")
// ErrNoQueuedJobs marks an OCR queue drained (no job to claim).
var ErrNoQueuedJobs = errors.New("no queued ocr jobs")
// ErrJobStateConflict marks a guarded transition attempted from an
// unexpected state (double Complete, Fail of a non-processing job,
// TouchProcessing of a non-queued job). Terminal states are sticky:
// a second transition never overwrites the first.
var ErrJobStateConflict = errors.New("ocr job state conflict")
type OcrJobs struct{ DB *sql.DB }
func (o *OcrJobs) Create(jobID, deviceID, fileID string) error {
_, err := o.DB.Exec(
`INSERT INTO ocr_jobs (job_id, device_id, file_id) VALUES ($1, $2, $3)`,
jobID, deviceID, fileID,
)
return err
}
// Get returns a job scoped by device (no-rows → ErrJobNotFound).
func (o *OcrJobs) Get(deviceID, jobID string) (OcrJobRow, error) {
var row OcrJobRow
var text, errMsg sql.NullString
err := o.DB.QueryRow(
`SELECT job_id, file_id, device_id, status,
NULLIF(text, ''), NULLIF(error, '')
FROM ocr_jobs WHERE job_id = $1 AND device_id = $2`,
jobID, deviceID,
).Scan(&row.ID, &row.FileID, &row.DeviceID, &row.Status, &text, &errMsg)
if err == sql.ErrNoRows {
return OcrJobRow{}, ErrJobNotFound
}
if err != nil {
return OcrJobRow{}, err
}
if text.Valid {
row.Text = &text.String
}
if errMsg.Valid {
row.Error = &errMsg.String
}
return row, nil
}
func (o *OcrJobs) TouchProcessing(deviceID, jobID string) error {
res, err := o.DB.Exec(
`UPDATE ocr_jobs SET status = 'processing', started_at = NOW()
WHERE job_id = $1 AND device_id = $2 AND status = 'queued'`,
jobID, deviceID,
)
if err != nil {
return err
}
affected, err := res.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrJobStateConflict
}
return nil
}
// ClaimNext atomically picks the oldest queued job (FIFO) and moves it to
// `processing`. Safe for concurrent workers: `FOR UPDATE SKIP LOCKED` blocks
// the row as part of the same statement. Empty queue → ErrNoQueuedJobs.
func (o *OcrJobs) ClaimNext() (OcrJobRow, error) {
var row OcrJobRow
err := o.DB.QueryRow(
`WITH next AS (
SELECT job_id FROM ocr_jobs
WHERE status = 'queued'
ORDER BY created_at, job_id
LIMIT 1
FOR UPDATE SKIP LOCKED
)
UPDATE ocr_jobs
SET status = 'processing', started_at = NOW()
FROM next
WHERE ocr_jobs.job_id = next.job_id
RETURNING ocr_jobs.job_id, ocr_jobs.file_id, ocr_jobs.device_id, ocr_jobs.status`,
).Scan(&row.ID, &row.FileID, &row.DeviceID, &row.Status)
if err == sql.ErrNoRows {
return OcrJobRow{}, ErrNoQueuedJobs
}
if err != nil {
return OcrJobRow{}, err
}
return row, nil
}
// ResetStaleProcessing requeues jobs stuck in `processing` (worker crash /
// processus redémarré) et plus vieux que `olderThan`. Retourne le nb de jobs
// requeued. La comparaison utilise l'horloge DB (NOW(), pas time.Now() du
// process) pour rester correcte même si les horloges divergent. Les jobs sans
// `started_at` (claim sans timestamp, anomalie) sont aussi requeued.
func (o *OcrJobs) ResetStaleProcessing(olderThan time.Duration) (int64, error) {
res, err := o.DB.Exec(
`UPDATE ocr_jobs SET status = 'queued', started_at = NULL
WHERE status = 'processing'
AND (started_at IS NULL OR started_at < NOW() - ($1::bigint * INTERVAL '1 millisecond'))`,
olderThan.Milliseconds(),
)
if err != nil {
return 0, err
}
return res.RowsAffected()
}
func (o *OcrJobs) Complete(deviceID, jobID, text string) error {
res, err := o.DB.Exec(
`UPDATE ocr_jobs SET status = 'done', text = NULLIF($3, ''), started_at = COALESCE(started_at, NOW()), completed_at = NOW()
WHERE job_id = $1 AND device_id = $2 AND status = 'processing'`,
jobID, deviceID, text,
)
if err != nil {
return err
}
affected, err := res.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrJobStateConflict
}
return nil
}
func (o *OcrJobs) Fail(deviceID, jobID, message string) error {
res, err := o.DB.Exec(
`UPDATE ocr_jobs SET status = 'failed', error = NULLIF($3, ''), started_at = COALESCE(started_at, NOW()), completed_at = NOW()
WHERE job_id = $1 AND device_id = $2 AND status = 'processing'`,
jobID, deviceID, message,
)
if err != nil {
return err
}
affected, err := res.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return ErrJobStateConflict
}
return nil
}