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
168 lines
4.6 KiB
Go
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
|
|
}
|