c573122e01
This just changes the version comments in the generated files. Now they're consistent with the version of sqlc tracked in go.mod. No functional changes.
936 lines
22 KiB
Go
Generated
936 lines
22 KiB
Go
Generated
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.29.0
|
|
// source: query_workers.sql
|
|
|
|
package sqlc
|
|
|
|
import (
|
|
"context"
|
|
"database/sql"
|
|
"strings"
|
|
"time"
|
|
|
|
"projects.blender.org/studio/flamenco/pkg/api"
|
|
"projects.blender.org/studio/flamenco/pkg/time_of_day"
|
|
)
|
|
|
|
const countWorkerTags = `-- name: CountWorkerTags :one
|
|
SELECT count(id) as count FROM worker_tags
|
|
`
|
|
|
|
func (q *Queries) CountWorkerTags(ctx context.Context) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, countWorkerTags)
|
|
var count int64
|
|
err := row.Scan(&count)
|
|
return count, err
|
|
}
|
|
|
|
const createWorker = `-- name: CreateWorker :one
|
|
INSERT INTO workers (
|
|
created_at,
|
|
uuid,
|
|
secret,
|
|
name,
|
|
address,
|
|
platform,
|
|
software,
|
|
status,
|
|
last_seen_at,
|
|
status_requested,
|
|
lazy_status_request,
|
|
supported_task_types,
|
|
deleted_at,
|
|
can_restart
|
|
) values (
|
|
?1,
|
|
?2,
|
|
?3,
|
|
?4,
|
|
?5,
|
|
?6,
|
|
?7,
|
|
?8,
|
|
?9,
|
|
?10,
|
|
?11,
|
|
?12,
|
|
?13,
|
|
?14
|
|
)
|
|
RETURNING id
|
|
`
|
|
|
|
type CreateWorkerParams struct {
|
|
CreatedAt time.Time
|
|
UUID string
|
|
Secret string
|
|
Name string
|
|
Address string
|
|
Platform string
|
|
Software string
|
|
Status api.WorkerStatus
|
|
LastSeenAt sql.NullTime
|
|
StatusRequested api.WorkerStatus
|
|
LazyStatusRequest bool
|
|
SupportedTaskTypes string
|
|
DeletedAt sql.NullTime
|
|
CanRestart bool
|
|
}
|
|
|
|
func (q *Queries) CreateWorker(ctx context.Context, arg CreateWorkerParams) (int64, error) {
|
|
row := q.db.QueryRowContext(ctx, createWorker,
|
|
arg.CreatedAt,
|
|
arg.UUID,
|
|
arg.Secret,
|
|
arg.Name,
|
|
arg.Address,
|
|
arg.Platform,
|
|
arg.Software,
|
|
arg.Status,
|
|
arg.LastSeenAt,
|
|
arg.StatusRequested,
|
|
arg.LazyStatusRequest,
|
|
arg.SupportedTaskTypes,
|
|
arg.DeletedAt,
|
|
arg.CanRestart,
|
|
)
|
|
var id int64
|
|
err := row.Scan(&id)
|
|
return id, err
|
|
}
|
|
|
|
const createWorkerTag = `-- name: CreateWorkerTag :execlastid
|
|
INSERT INTO worker_tags (
|
|
created_at,
|
|
uuid,
|
|
name,
|
|
description
|
|
) VALUES (
|
|
?1,
|
|
?2,
|
|
?3,
|
|
?4
|
|
)
|
|
`
|
|
|
|
type CreateWorkerTagParams struct {
|
|
CreatedAt time.Time
|
|
UUID string
|
|
Name string
|
|
Description string
|
|
}
|
|
|
|
func (q *Queries) CreateWorkerTag(ctx context.Context, arg CreateWorkerTagParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, createWorkerTag,
|
|
arg.CreatedAt,
|
|
arg.UUID,
|
|
arg.Name,
|
|
arg.Description,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const deleteWorkerTag = `-- name: DeleteWorkerTag :execrows
|
|
DELETE FROM worker_tags
|
|
WHERE uuid=?1
|
|
`
|
|
|
|
func (q *Queries) DeleteWorkerTag(ctx context.Context, uuid string) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, deleteWorkerTag, uuid)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const fetchSleepSchedulesToCheck = `-- name: FetchSleepSchedulesToCheck :many
|
|
SELECT sleep_schedules.id, sleep_schedules.created_at, sleep_schedules.updated_at, sleep_schedules.worker_id, sleep_schedules.is_active, sleep_schedules.days_of_week, sleep_schedules.start_time, sleep_schedules.end_time, sleep_schedules.next_check, workers.uuid as workeruuid, workers.name as worker_name
|
|
FROM sleep_schedules
|
|
LEFT JOIN workers ON workers.id = sleep_schedules.worker_id
|
|
WHERE is_active
|
|
AND (next_check <= ?1 OR next_check IS NULL OR next_check = '')
|
|
`
|
|
|
|
type FetchSleepSchedulesToCheckRow struct {
|
|
SleepSchedule SleepSchedule
|
|
WorkerUUID sql.NullString
|
|
WorkerName sql.NullString
|
|
}
|
|
|
|
func (q *Queries) FetchSleepSchedulesToCheck(ctx context.Context, nextCheck sql.NullTime) ([]FetchSleepSchedulesToCheckRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, fetchSleepSchedulesToCheck, nextCheck)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []FetchSleepSchedulesToCheckRow
|
|
for rows.Next() {
|
|
var i FetchSleepSchedulesToCheckRow
|
|
if err := rows.Scan(
|
|
&i.SleepSchedule.ID,
|
|
&i.SleepSchedule.CreatedAt,
|
|
&i.SleepSchedule.UpdatedAt,
|
|
&i.SleepSchedule.WorkerID,
|
|
&i.SleepSchedule.IsActive,
|
|
&i.SleepSchedule.DaysOfWeek,
|
|
&i.SleepSchedule.StartTime,
|
|
&i.SleepSchedule.EndTime,
|
|
&i.SleepSchedule.NextCheck,
|
|
&i.WorkerUUID,
|
|
&i.WorkerName,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const fetchTagsOfWorker = `-- name: FetchTagsOfWorker :many
|
|
SELECT worker_tags.id, worker_tags.created_at, worker_tags.updated_at, worker_tags.uuid, worker_tags.name, worker_tags.description
|
|
FROM worker_tags
|
|
LEFT JOIN worker_tag_membership m ON (m.worker_tag_id = worker_tags.id)
|
|
LEFT JOIN workers on (m.worker_id = workers.id)
|
|
WHERE workers.uuid = ?1
|
|
`
|
|
|
|
func (q *Queries) FetchTagsOfWorker(ctx context.Context, uuid string) ([]WorkerTag, error) {
|
|
rows, err := q.db.QueryContext(ctx, fetchTagsOfWorker, uuid)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []WorkerTag
|
|
for rows.Next() {
|
|
var i WorkerTag
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.UUID,
|
|
&i.Name,
|
|
&i.Description,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const fetchTimedOutWorkers = `-- name: FetchTimedOutWorkers :many
|
|
SELECT id, created_at, updated_at, uuid, secret, name, address, platform, software, status, last_seen_at, status_requested, lazy_status_request, supported_task_types, deleted_at, can_restart
|
|
FROM workers
|
|
WHERE
|
|
last_seen_at <= ?1
|
|
AND deleted_at IS NULL
|
|
AND status NOT IN (/*SLICE:worker_statuses_no_timeout*/?)
|
|
`
|
|
|
|
type FetchTimedOutWorkersParams struct {
|
|
LastSeenBefore sql.NullTime
|
|
WorkerStatusesNoTimeout []api.WorkerStatus
|
|
}
|
|
|
|
func (q *Queries) FetchTimedOutWorkers(ctx context.Context, arg FetchTimedOutWorkersParams) ([]Worker, error) {
|
|
query := fetchTimedOutWorkers
|
|
var queryParams []interface{}
|
|
queryParams = append(queryParams, arg.LastSeenBefore)
|
|
if len(arg.WorkerStatusesNoTimeout) > 0 {
|
|
for _, v := range arg.WorkerStatusesNoTimeout {
|
|
queryParams = append(queryParams, v)
|
|
}
|
|
query = strings.Replace(query, "/*SLICE:worker_statuses_no_timeout*/?", strings.Repeat(",?", len(arg.WorkerStatusesNoTimeout))[1:], 1)
|
|
} else {
|
|
query = strings.Replace(query, "/*SLICE:worker_statuses_no_timeout*/?", "NULL", 1)
|
|
}
|
|
rows, err := q.db.QueryContext(ctx, query, queryParams...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Worker
|
|
for rows.Next() {
|
|
var i Worker
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.UUID,
|
|
&i.Secret,
|
|
&i.Name,
|
|
&i.Address,
|
|
&i.Platform,
|
|
&i.Software,
|
|
&i.Status,
|
|
&i.LastSeenAt,
|
|
&i.StatusRequested,
|
|
&i.LazyStatusRequest,
|
|
&i.SupportedTaskTypes,
|
|
&i.DeletedAt,
|
|
&i.CanRestart,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const fetchWorker = `-- name: FetchWorker :one
|
|
SELECT id, created_at, updated_at, uuid, secret, name, address, platform, software, status, last_seen_at, status_requested, lazy_status_request, supported_task_types, deleted_at, can_restart FROM workers WHERE workers.uuid = ?1 and deleted_at is NULL
|
|
`
|
|
|
|
// FetchWorker only returns the worker if it wasn't soft-deleted.
|
|
func (q *Queries) FetchWorker(ctx context.Context, uuid string) (Worker, error) {
|
|
row := q.db.QueryRowContext(ctx, fetchWorker, uuid)
|
|
var i Worker
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.UUID,
|
|
&i.Secret,
|
|
&i.Name,
|
|
&i.Address,
|
|
&i.Platform,
|
|
&i.Software,
|
|
&i.Status,
|
|
&i.LastSeenAt,
|
|
&i.StatusRequested,
|
|
&i.LazyStatusRequest,
|
|
&i.SupportedTaskTypes,
|
|
&i.DeletedAt,
|
|
&i.CanRestart,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const fetchWorkerByID = `-- name: FetchWorkerByID :one
|
|
SELECT id, created_at, updated_at, uuid, secret, name, address, platform, software, status, last_seen_at, status_requested, lazy_status_request, supported_task_types, deleted_at, can_restart FROM workers WHERE workers.id = ?1 and deleted_at is NULL
|
|
`
|
|
|
|
// FetchWorkerByID only returns the worker if it wasn't soft-deleted.
|
|
func (q *Queries) FetchWorkerByID(ctx context.Context, workerID int64) (Worker, error) {
|
|
row := q.db.QueryRowContext(ctx, fetchWorkerByID, workerID)
|
|
var i Worker
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.UUID,
|
|
&i.Secret,
|
|
&i.Name,
|
|
&i.Address,
|
|
&i.Platform,
|
|
&i.Software,
|
|
&i.Status,
|
|
&i.LastSeenAt,
|
|
&i.StatusRequested,
|
|
&i.LazyStatusRequest,
|
|
&i.SupportedTaskTypes,
|
|
&i.DeletedAt,
|
|
&i.CanRestart,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const fetchWorkerSleepSchedule = `-- name: FetchWorkerSleepSchedule :one
|
|
SELECT sleep_schedules.id, sleep_schedules.created_at, sleep_schedules.updated_at, sleep_schedules.worker_id, sleep_schedules.is_active, sleep_schedules.days_of_week, sleep_schedules.start_time, sleep_schedules.end_time, sleep_schedules.next_check
|
|
FROM sleep_schedules
|
|
INNER JOIN workers on workers.id = sleep_schedules.worker_id
|
|
WHERE workers.uuid = ?1
|
|
`
|
|
|
|
func (q *Queries) FetchWorkerSleepSchedule(ctx context.Context, workeruuid string) (SleepSchedule, error) {
|
|
row := q.db.QueryRowContext(ctx, fetchWorkerSleepSchedule, workeruuid)
|
|
var i SleepSchedule
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.WorkerID,
|
|
&i.IsActive,
|
|
&i.DaysOfWeek,
|
|
&i.StartTime,
|
|
&i.EndTime,
|
|
&i.NextCheck,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const fetchWorkerTagByID = `-- name: FetchWorkerTagByID :one
|
|
SELECT id, created_at, updated_at, uuid, name, description
|
|
FROM worker_tags
|
|
WHERE id=?1
|
|
`
|
|
|
|
func (q *Queries) FetchWorkerTagByID(ctx context.Context, workerTagID int64) (WorkerTag, error) {
|
|
row := q.db.QueryRowContext(ctx, fetchWorkerTagByID, workerTagID)
|
|
var i WorkerTag
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.UUID,
|
|
&i.Name,
|
|
&i.Description,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const fetchWorkerTagByUUID = `-- name: FetchWorkerTagByUUID :one
|
|
SELECT id, created_at, updated_at, uuid, name, description
|
|
FROM worker_tags
|
|
WHERE worker_tags.uuid = ?1
|
|
`
|
|
|
|
func (q *Queries) FetchWorkerTagByUUID(ctx context.Context, uuid string) (WorkerTag, error) {
|
|
row := q.db.QueryRowContext(ctx, fetchWorkerTagByUUID, uuid)
|
|
var i WorkerTag
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.UUID,
|
|
&i.Name,
|
|
&i.Description,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const fetchWorkerTags = `-- name: FetchWorkerTags :many
|
|
SELECT id, created_at, updated_at, uuid, name, description
|
|
FROM worker_tags
|
|
`
|
|
|
|
func (q *Queries) FetchWorkerTags(ctx context.Context) ([]WorkerTag, error) {
|
|
rows, err := q.db.QueryContext(ctx, fetchWorkerTags)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []WorkerTag
|
|
for rows.Next() {
|
|
var i WorkerTag
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.UUID,
|
|
&i.Name,
|
|
&i.Description,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const fetchWorkerTagsByUUIDs = `-- name: FetchWorkerTagsByUUIDs :many
|
|
SELECT id, created_at, updated_at, uuid, name, description
|
|
FROM worker_tags
|
|
WHERE uuid in (/*SLICE:uuids*/?)
|
|
`
|
|
|
|
func (q *Queries) FetchWorkerTagsByUUIDs(ctx context.Context, uuids []string) ([]WorkerTag, error) {
|
|
query := fetchWorkerTagsByUUIDs
|
|
var queryParams []interface{}
|
|
if len(uuids) > 0 {
|
|
for _, v := range uuids {
|
|
queryParams = append(queryParams, v)
|
|
}
|
|
query = strings.Replace(query, "/*SLICE:uuids*/?", strings.Repeat(",?", len(uuids))[1:], 1)
|
|
} else {
|
|
query = strings.Replace(query, "/*SLICE:uuids*/?", "NULL", 1)
|
|
}
|
|
rows, err := q.db.QueryContext(ctx, query, queryParams...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []WorkerTag
|
|
for rows.Next() {
|
|
var i WorkerTag
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.UUID,
|
|
&i.Name,
|
|
&i.Description,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const fetchWorkerUnconditional = `-- name: FetchWorkerUnconditional :one
|
|
SELECT id, created_at, updated_at, uuid, secret, name, address, platform, software, status, last_seen_at, status_requested, lazy_status_request, supported_task_types, deleted_at, can_restart FROM workers WHERE workers.uuid = ?1
|
|
`
|
|
|
|
// FetchWorkerUnconditional ignores soft-deletion status and just returns the worker.
|
|
func (q *Queries) FetchWorkerUnconditional(ctx context.Context, uuid string) (Worker, error) {
|
|
row := q.db.QueryRowContext(ctx, fetchWorkerUnconditional, uuid)
|
|
var i Worker
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.UUID,
|
|
&i.Secret,
|
|
&i.Name,
|
|
&i.Address,
|
|
&i.Platform,
|
|
&i.Software,
|
|
&i.Status,
|
|
&i.LastSeenAt,
|
|
&i.StatusRequested,
|
|
&i.LazyStatusRequest,
|
|
&i.SupportedTaskTypes,
|
|
&i.DeletedAt,
|
|
&i.CanRestart,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const fetchWorkerUnconditionalByID = `-- name: FetchWorkerUnconditionalByID :one
|
|
SELECT id, created_at, updated_at, uuid, secret, name, address, platform, software, status, last_seen_at, status_requested, lazy_status_request, supported_task_types, deleted_at, can_restart FROM workers WHERE workers.id = ?1
|
|
`
|
|
|
|
// FetchWorkerUnconditional ignores soft-deletion status and just returns the worker.
|
|
func (q *Queries) FetchWorkerUnconditionalByID(ctx context.Context, workerID int64) (Worker, error) {
|
|
row := q.db.QueryRowContext(ctx, fetchWorkerUnconditionalByID, workerID)
|
|
var i Worker
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.UUID,
|
|
&i.Secret,
|
|
&i.Name,
|
|
&i.Address,
|
|
&i.Platform,
|
|
&i.Software,
|
|
&i.Status,
|
|
&i.LastSeenAt,
|
|
&i.StatusRequested,
|
|
&i.LazyStatusRequest,
|
|
&i.SupportedTaskTypes,
|
|
&i.DeletedAt,
|
|
&i.CanRestart,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const fetchWorkers = `-- name: FetchWorkers :many
|
|
SELECT id, created_at, updated_at, uuid, secret, name, address, platform, software, status, last_seen_at, status_requested, lazy_status_request, supported_task_types, deleted_at, can_restart FROM workers
|
|
WHERE deleted_at IS NULL
|
|
`
|
|
|
|
func (q *Queries) FetchWorkers(ctx context.Context) ([]Worker, error) {
|
|
rows, err := q.db.QueryContext(ctx, fetchWorkers)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Worker
|
|
for rows.Next() {
|
|
var i Worker
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.UUID,
|
|
&i.Secret,
|
|
&i.Name,
|
|
&i.Address,
|
|
&i.Platform,
|
|
&i.Software,
|
|
&i.Status,
|
|
&i.LastSeenAt,
|
|
&i.StatusRequested,
|
|
&i.LazyStatusRequest,
|
|
&i.SupportedTaskTypes,
|
|
&i.DeletedAt,
|
|
&i.CanRestart,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const saveWorker = `-- name: SaveWorker :exec
|
|
UPDATE workers SET
|
|
updated_at=?1,
|
|
uuid=?2,
|
|
secret=?3,
|
|
name=?4,
|
|
address=?5,
|
|
platform=?6,
|
|
software=?7,
|
|
status=?8,
|
|
last_seen_at=?9,
|
|
status_requested=?10,
|
|
lazy_status_request=?11,
|
|
supported_task_types=?12,
|
|
can_restart=?13
|
|
WHERE id=?14
|
|
`
|
|
|
|
type SaveWorkerParams struct {
|
|
UpdatedAt sql.NullTime
|
|
UUID string
|
|
Secret string
|
|
Name string
|
|
Address string
|
|
Platform string
|
|
Software string
|
|
Status api.WorkerStatus
|
|
LastSeenAt sql.NullTime
|
|
StatusRequested api.WorkerStatus
|
|
LazyStatusRequest bool
|
|
SupportedTaskTypes string
|
|
CanRestart bool
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) SaveWorker(ctx context.Context, arg SaveWorkerParams) error {
|
|
_, err := q.db.ExecContext(ctx, saveWorker,
|
|
arg.UpdatedAt,
|
|
arg.UUID,
|
|
arg.Secret,
|
|
arg.Name,
|
|
arg.Address,
|
|
arg.Platform,
|
|
arg.Software,
|
|
arg.Status,
|
|
arg.LastSeenAt,
|
|
arg.StatusRequested,
|
|
arg.LazyStatusRequest,
|
|
arg.SupportedTaskTypes,
|
|
arg.CanRestart,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const saveWorkerStatus = `-- name: SaveWorkerStatus :exec
|
|
UPDATE workers SET
|
|
updated_at=?1,
|
|
status=?2,
|
|
status_requested=?3,
|
|
lazy_status_request=?4
|
|
WHERE id=?5
|
|
`
|
|
|
|
type SaveWorkerStatusParams struct {
|
|
UpdatedAt sql.NullTime
|
|
Status api.WorkerStatus
|
|
StatusRequested api.WorkerStatus
|
|
LazyStatusRequest bool
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) SaveWorkerStatus(ctx context.Context, arg SaveWorkerStatusParams) error {
|
|
_, err := q.db.ExecContext(ctx, saveWorkerStatus,
|
|
arg.UpdatedAt,
|
|
arg.Status,
|
|
arg.StatusRequested,
|
|
arg.LazyStatusRequest,
|
|
arg.ID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const saveWorkerTag = `-- name: SaveWorkerTag :exec
|
|
UPDATE worker_tags
|
|
SET
|
|
updated_at=?1,
|
|
uuid=?2,
|
|
name=?3,
|
|
description=?4
|
|
WHERE id=?5
|
|
`
|
|
|
|
type SaveWorkerTagParams struct {
|
|
UpdatedAt sql.NullTime
|
|
UUID string
|
|
Name string
|
|
Description string
|
|
WorkerTagID int64
|
|
}
|
|
|
|
func (q *Queries) SaveWorkerTag(ctx context.Context, arg SaveWorkerTagParams) error {
|
|
_, err := q.db.ExecContext(ctx, saveWorkerTag,
|
|
arg.UpdatedAt,
|
|
arg.UUID,
|
|
arg.Name,
|
|
arg.Description,
|
|
arg.WorkerTagID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const setWorkerSleepSchedule = `-- name: SetWorkerSleepSchedule :execlastid
|
|
INSERT INTO sleep_schedules (
|
|
created_at,
|
|
updated_at,
|
|
worker_id,
|
|
is_active,
|
|
days_of_week,
|
|
start_time,
|
|
end_time,
|
|
next_check
|
|
) VALUES (
|
|
?1,
|
|
?2,
|
|
?3,
|
|
?4,
|
|
?5,
|
|
?6,
|
|
?7,
|
|
?8
|
|
)
|
|
ON CONFLICT DO UPDATE
|
|
SET updated_at=?2, is_active=?4, days_of_week=?5, start_time=?6, end_time=?7, next_check=?8
|
|
WHERE worker_id=?3
|
|
`
|
|
|
|
type SetWorkerSleepScheduleParams struct {
|
|
CreatedAt time.Time
|
|
UpdatedAt sql.NullTime
|
|
WorkerID int64
|
|
IsActive bool
|
|
DaysOfWeek string
|
|
StartTime time_of_day.TimeOfDay
|
|
EndTime time_of_day.TimeOfDay
|
|
NextCheck sql.NullTime
|
|
}
|
|
|
|
// Note that the use of ?2 and ?3 in the SQL is not desirable, and should be
|
|
// replaced with @updated_at and @job_id as soon as sqlc issue #3334 is fixed.
|
|
// See https://github.com/sqlc-dev/sqlc/issues/3334 for more info.
|
|
func (q *Queries) SetWorkerSleepSchedule(ctx context.Context, arg SetWorkerSleepScheduleParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, setWorkerSleepSchedule,
|
|
arg.CreatedAt,
|
|
arg.UpdatedAt,
|
|
arg.WorkerID,
|
|
arg.IsActive,
|
|
arg.DaysOfWeek,
|
|
arg.StartTime,
|
|
arg.EndTime,
|
|
arg.NextCheck,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const setWorkerSleepScheduleNextCheck = `-- name: SetWorkerSleepScheduleNextCheck :execrows
|
|
UPDATE sleep_schedules
|
|
SET next_check=?1
|
|
WHERE ID=?2
|
|
`
|
|
|
|
type SetWorkerSleepScheduleNextCheckParams struct {
|
|
NextCheck sql.NullTime
|
|
ScheduleID int64
|
|
}
|
|
|
|
func (q *Queries) SetWorkerSleepScheduleNextCheck(ctx context.Context, arg SetWorkerSleepScheduleNextCheckParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, setWorkerSleepScheduleNextCheck, arg.NextCheck, arg.ScheduleID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const softDeleteWorker = `-- name: SoftDeleteWorker :execrows
|
|
UPDATE workers SET deleted_at=?1
|
|
WHERE uuid=?2
|
|
`
|
|
|
|
type SoftDeleteWorkerParams struct {
|
|
DeletedAt sql.NullTime
|
|
UUID string
|
|
}
|
|
|
|
func (q *Queries) SoftDeleteWorker(ctx context.Context, arg SoftDeleteWorkerParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, softDeleteWorker, arg.DeletedAt, arg.UUID)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected()
|
|
}
|
|
|
|
const summarizeWorkerStatuses = `-- name: SummarizeWorkerStatuses :many
|
|
SELECT status, count(id) as status_count FROM workers
|
|
WHERE deleted_at is NULL
|
|
GROUP BY status
|
|
`
|
|
|
|
type SummarizeWorkerStatusesRow struct {
|
|
Status api.WorkerStatus
|
|
StatusCount int64
|
|
}
|
|
|
|
func (q *Queries) SummarizeWorkerStatuses(ctx context.Context) ([]SummarizeWorkerStatusesRow, error) {
|
|
rows, err := q.db.QueryContext(ctx, summarizeWorkerStatuses)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []SummarizeWorkerStatusesRow
|
|
for rows.Next() {
|
|
var i SummarizeWorkerStatusesRow
|
|
if err := rows.Scan(&i.Status, &i.StatusCount); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Close(); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const test_CreateWorkerSleepSchedule = `-- name: Test_CreateWorkerSleepSchedule :execlastid
|
|
INSERT INTO sleep_schedules (
|
|
created_at,
|
|
worker_id,
|
|
is_active,
|
|
days_of_week,
|
|
start_time,
|
|
end_time,
|
|
next_check
|
|
) VALUES (
|
|
?1,
|
|
?2,
|
|
?3,
|
|
?4,
|
|
?5,
|
|
?6,
|
|
?7
|
|
)
|
|
`
|
|
|
|
type Test_CreateWorkerSleepScheduleParams struct {
|
|
CreatedAt time.Time
|
|
WorkerID int64
|
|
IsActive bool
|
|
DaysOfWeek string
|
|
StartTime time_of_day.TimeOfDay
|
|
EndTime time_of_day.TimeOfDay
|
|
NextCheck sql.NullTime
|
|
}
|
|
|
|
func (q *Queries) Test_CreateWorkerSleepSchedule(ctx context.Context, arg Test_CreateWorkerSleepScheduleParams) (int64, error) {
|
|
result, err := q.db.ExecContext(ctx, test_CreateWorkerSleepSchedule,
|
|
arg.CreatedAt,
|
|
arg.WorkerID,
|
|
arg.IsActive,
|
|
arg.DaysOfWeek,
|
|
arg.StartTime,
|
|
arg.EndTime,
|
|
arg.NextCheck,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.LastInsertId()
|
|
}
|
|
|
|
const workerAddTagMembership = `-- name: WorkerAddTagMembership :exec
|
|
INSERT INTO worker_tag_membership (worker_tag_id, worker_id)
|
|
VALUES (?1, ?2)
|
|
`
|
|
|
|
type WorkerAddTagMembershipParams struct {
|
|
WorkerTagID int64
|
|
WorkerID int64
|
|
}
|
|
|
|
func (q *Queries) WorkerAddTagMembership(ctx context.Context, arg WorkerAddTagMembershipParams) error {
|
|
_, err := q.db.ExecContext(ctx, workerAddTagMembership, arg.WorkerTagID, arg.WorkerID)
|
|
return err
|
|
}
|
|
|
|
const workerRemoveTagMemberships = `-- name: WorkerRemoveTagMemberships :exec
|
|
DELETE
|
|
FROM worker_tag_membership
|
|
WHERE worker_id=?1
|
|
`
|
|
|
|
func (q *Queries) WorkerRemoveTagMemberships(ctx context.Context, workerID int64) error {
|
|
_, err := q.db.ExecContext(ctx, workerRemoveTagMemberships, workerID)
|
|
return err
|
|
}
|
|
|
|
const workerSeen = `-- name: WorkerSeen :exec
|
|
UPDATE workers SET
|
|
updated_at=?1,
|
|
last_seen_at=?2
|
|
WHERE id=?3
|
|
`
|
|
|
|
type WorkerSeenParams struct {
|
|
UpdatedAt sql.NullTime
|
|
LastSeenAt sql.NullTime
|
|
ID int64
|
|
}
|
|
|
|
func (q *Queries) WorkerSeen(ctx context.Context, arg WorkerSeenParams) error {
|
|
_, err := q.db.ExecContext(ctx, workerSeen, arg.UpdatedAt, arg.LastSeenAt, arg.ID)
|
|
return err
|
|
}
|