shithub Public

Watch 1 Fork 0 Star 0
Go · 16729 bytes Raw Blame History
1 // Code generated by sqlc. DO NOT EDIT.
2 // versions:
3 // sqlc v1.31.1
4 // source: workflow_jobs.sql
5
6 package actionsdb
7
8 import (
9 "context"
10
11 "github.com/jackc/pgx/v5/pgtype"
12 )
13
14 const claimQueuedWorkflowJob = `-- name: ClaimQueuedWorkflowJob :one
15 WITH candidate AS (
16 SELECT j.id
17 FROM workflow_jobs j
18 JOIN workflow_runs r ON r.id = j.run_id
19 JOIN repos repo ON repo.id = r.repo_id
20 LEFT JOIN actions_site_policy sp ON sp.id = true
21 LEFT JOIN actions_org_policies op ON op.org_id = repo.owner_org_id
22 LEFT JOIN actions_repo_policies rp ON rp.repo_id = r.repo_id
23 WHERE j.status = 'queued'
24 AND r.status IN ('queued', 'running')
25 AND (r.need_approval = false OR r.approved_by_user_id IS NOT NULL)
26 AND j.cancel_requested = false
27 AND j.runner_id IS NULL
28 AND CASE
29 WHEN COALESCE(rp.actions_enabled, 'inherit'::actions_policy_state) = 'enabled' THEN true
30 WHEN COALESCE(rp.actions_enabled, 'inherit'::actions_policy_state) = 'disabled' THEN false
31 WHEN COALESCE(op.actions_enabled, 'inherit'::actions_policy_state) = 'enabled' THEN true
32 WHEN COALESCE(op.actions_enabled, 'inherit'::actions_policy_state) = 'disabled' THEN false
33 ELSE COALESCE(sp.actions_enabled, true)
34 END
35 AND (
36 SELECT COUNT(*)::integer
37 FROM workflow_jobs running_job
38 JOIN workflow_runs running_run ON running_run.id = running_job.run_id
39 WHERE running_job.status = 'running'
40 AND running_run.repo_id = r.repo_id
41 ) < COALESCE(rp.max_repo_concurrent_jobs, op.max_repo_concurrent_jobs, sp.max_repo_concurrent_jobs, 20)
42 AND (
43 SELECT COUNT(*)::integer
44 FROM workflow_jobs running_job
45 JOIN workflow_runs running_run ON running_run.id = running_job.run_id
46 JOIN repos running_repo ON running_repo.id = running_run.repo_id
47 WHERE running_job.status = 'running'
48 AND (
49 (repo.owner_user_id IS NOT NULL AND running_repo.owner_user_id = repo.owner_user_id)
50 OR (repo.owner_org_id IS NOT NULL AND running_repo.owner_org_id = repo.owner_org_id)
51 )
52 ) < COALESCE(rp.max_owner_concurrent_jobs, op.max_owner_concurrent_jobs, sp.max_owner_concurrent_jobs, 100)
53 AND (j.runs_on = '' OR j.runs_on = ANY($1::text[]))
54 AND NOT EXISTS (
55 SELECT 1
56 FROM workflow_jobs dep
57 WHERE dep.run_id = j.run_id
58 AND dep.job_key = ANY(j.needs_jobs)
59 AND (dep.status <> 'completed' OR dep.conclusion <> 'success')
60 )
61 AND NOT EXISTS (
62 SELECT 1
63 FROM workflow_runs blocker
64 WHERE r.concurrency_group <> ''
65 AND blocker.repo_id = r.repo_id
66 AND blocker.concurrency_group = r.concurrency_group
67 AND blocker.id <> r.id
68 AND blocker.status IN ('queued', 'running')
69 AND (blocker.created_at, blocker.id) < (r.created_at, r.id)
70 AND EXISTS (
71 SELECT 1
72 FROM workflow_jobs blocker_job
73 WHERE blocker_job.run_id = blocker.id
74 AND blocker_job.status IN ('queued', 'running')
75 AND blocker_job.cancel_requested = false
76 )
77 )
78 ORDER BY j.created_at ASC, j.id ASC
79 FOR UPDATE OF j SKIP LOCKED
80 LIMIT 1
81 ),
82 claimed AS (
83 UPDATE workflow_jobs j
84 SET runner_id = $2::bigint,
85 status = 'running',
86 started_at = COALESCE(j.started_at, now()),
87 version = j.version + 1,
88 updated_at = now()
89 FROM candidate c
90 WHERE j.id = c.id
91 RETURNING j.id, j.run_id, j.job_index, j.job_key, j.job_name, j.runs_on,
92 j.runner_id, j.needs_jobs, j.if_expr, j.timeout_minutes,
93 j.permissions, j.job_env, j.status, j.conclusion,
94 j.cancel_requested, j.started_at, j.completed_at, j.version,
95 j.created_at, j.updated_at
96 )
97 SELECT c.id, c.run_id, c.job_index, c.job_key, c.job_name, c.runs_on,
98 c.runner_id, c.needs_jobs, c.if_expr, c.timeout_minutes,
99 c.permissions, c.job_env, c.status, c.conclusion,
100 c.cancel_requested, c.started_at, c.completed_at, c.version,
101 c.created_at, c.updated_at,
102 r.repo_id, r.run_index, r.workflow_file, r.workflow_name,
103 r.head_sha, r.head_ref, r.event, r.event_payload,
104 COALESCE(owner_user.username, owner_org.slug)::text AS repo_owner,
105 repo.name AS repo_name
106 FROM claimed c
107 JOIN workflow_runs r ON r.id = c.run_id
108 JOIN repos repo ON repo.id = r.repo_id
109 LEFT JOIN users owner_user ON owner_user.id = repo.owner_user_id
110 LEFT JOIN orgs owner_org ON owner_org.id = repo.owner_org_id
111 `
112
113 type ClaimQueuedWorkflowJobParams struct {
114 Labels []string
115 RunnerID int64
116 }
117
118 type ClaimQueuedWorkflowJobRow struct {
119 ID int64
120 RunID int64
121 JobIndex int32
122 JobKey string
123 JobName string
124 RunsOn string
125 RunnerID pgtype.Int8
126 NeedsJobs []string
127 IfExpr string
128 TimeoutMinutes int32
129 Permissions []byte
130 JobEnv []byte
131 Status WorkflowJobStatus
132 Conclusion NullCheckConclusion
133 CancelRequested bool
134 StartedAt pgtype.Timestamptz
135 CompletedAt pgtype.Timestamptz
136 Version int32
137 CreatedAt pgtype.Timestamptz
138 UpdatedAt pgtype.Timestamptz
139 RepoID int64
140 RunIndex int64
141 WorkflowFile string
142 WorkflowName string
143 HeadSha string
144 HeadRef string
145 Event WorkflowRunEvent
146 EventPayload []byte
147 RepoOwner string
148 RepoName string
149 }
150
151 func (q *Queries) ClaimQueuedWorkflowJob(ctx context.Context, db DBTX, arg ClaimQueuedWorkflowJobParams) (ClaimQueuedWorkflowJobRow, error) {
152 row := db.QueryRow(ctx, claimQueuedWorkflowJob, arg.Labels, arg.RunnerID)
153 var i ClaimQueuedWorkflowJobRow
154 err := row.Scan(
155 &i.ID,
156 &i.RunID,
157 &i.JobIndex,
158 &i.JobKey,
159 &i.JobName,
160 &i.RunsOn,
161 &i.RunnerID,
162 &i.NeedsJobs,
163 &i.IfExpr,
164 &i.TimeoutMinutes,
165 &i.Permissions,
166 &i.JobEnv,
167 &i.Status,
168 &i.Conclusion,
169 &i.CancelRequested,
170 &i.StartedAt,
171 &i.CompletedAt,
172 &i.Version,
173 &i.CreatedAt,
174 &i.UpdatedAt,
175 &i.RepoID,
176 &i.RunIndex,
177 &i.WorkflowFile,
178 &i.WorkflowName,
179 &i.HeadSha,
180 &i.HeadRef,
181 &i.Event,
182 &i.EventPayload,
183 &i.RepoOwner,
184 &i.RepoName,
185 )
186 return i, err
187 }
188
189 const countRunningJobsForRunner = `-- name: CountRunningJobsForRunner :one
190 SELECT COUNT(*)::integer
191 FROM workflow_jobs
192 WHERE runner_id = $1::bigint AND status = 'running'
193 `
194
195 func (q *Queries) CountRunningJobsForRunner(ctx context.Context, db DBTX, runnerID int64) (int32, error) {
196 row := db.QueryRow(ctx, countRunningJobsForRunner, runnerID)
197 var column_1 int32
198 err := row.Scan(&column_1)
199 return column_1, err
200 }
201
202 const getWorkflowJobByID = `-- name: GetWorkflowJobByID :one
203 SELECT id, run_id, job_index, job_key, job_name, runs_on,
204 runner_id, needs_jobs, if_expr, timeout_minutes, permissions,
205 job_env, status, conclusion, cancel_requested,
206 started_at, completed_at, version, created_at, updated_at
207 FROM workflow_jobs
208 WHERE id = $1
209 `
210
211 func (q *Queries) GetWorkflowJobByID(ctx context.Context, db DBTX, id int64) (WorkflowJob, error) {
212 row := db.QueryRow(ctx, getWorkflowJobByID, id)
213 var i WorkflowJob
214 err := row.Scan(
215 &i.ID,
216 &i.RunID,
217 &i.JobIndex,
218 &i.JobKey,
219 &i.JobName,
220 &i.RunsOn,
221 &i.RunnerID,
222 &i.NeedsJobs,
223 &i.IfExpr,
224 &i.TimeoutMinutes,
225 &i.Permissions,
226 &i.JobEnv,
227 &i.Status,
228 &i.Conclusion,
229 &i.CancelRequested,
230 &i.StartedAt,
231 &i.CompletedAt,
232 &i.Version,
233 &i.CreatedAt,
234 &i.UpdatedAt,
235 )
236 return i, err
237 }
238
239 const insertWorkflowJob = `-- name: InsertWorkflowJob :one
240
241 INSERT INTO workflow_jobs (
242 run_id, job_index, job_key, job_name,
243 runs_on, needs_jobs, if_expr, timeout_minutes,
244 permissions, job_env
245 ) VALUES (
246 $1, $2, $3, $4, $5, $6, $7, $8, $9, $10
247 )
248 RETURNING id, run_id, job_index, job_key, job_name, runs_on,
249 runner_id, needs_jobs, if_expr, timeout_minutes, permissions,
250 job_env, status, conclusion, cancel_requested,
251 started_at, completed_at, version, created_at, updated_at
252 `
253
254 type InsertWorkflowJobParams struct {
255 RunID int64
256 JobIndex int32
257 JobKey string
258 JobName string
259 RunsOn string
260 NeedsJobs []string
261 IfExpr string
262 TimeoutMinutes int32
263 Permissions []byte
264 JobEnv []byte
265 }
266
267 // SPDX-License-Identifier: AGPL-3.0-or-later
268 func (q *Queries) InsertWorkflowJob(ctx context.Context, db DBTX, arg InsertWorkflowJobParams) (WorkflowJob, error) {
269 row := db.QueryRow(ctx, insertWorkflowJob,
270 arg.RunID,
271 arg.JobIndex,
272 arg.JobKey,
273 arg.JobName,
274 arg.RunsOn,
275 arg.NeedsJobs,
276 arg.IfExpr,
277 arg.TimeoutMinutes,
278 arg.Permissions,
279 arg.JobEnv,
280 )
281 var i WorkflowJob
282 err := row.Scan(
283 &i.ID,
284 &i.RunID,
285 &i.JobIndex,
286 &i.JobKey,
287 &i.JobName,
288 &i.RunsOn,
289 &i.RunnerID,
290 &i.NeedsJobs,
291 &i.IfExpr,
292 &i.TimeoutMinutes,
293 &i.Permissions,
294 &i.JobEnv,
295 &i.Status,
296 &i.Conclusion,
297 &i.CancelRequested,
298 &i.StartedAt,
299 &i.CompletedAt,
300 &i.Version,
301 &i.CreatedAt,
302 &i.UpdatedAt,
303 )
304 return i, err
305 }
306
307 const listJobsForRun = `-- name: ListJobsForRun :many
308 SELECT id, run_id, job_index, job_key, job_name, runs_on, status,
309 conclusion, cancel_requested, needs_jobs, started_at, completed_at, created_at, updated_at
310 FROM workflow_jobs
311 WHERE run_id = $1
312 ORDER BY job_index ASC
313 `
314
315 type ListJobsForRunRow struct {
316 ID int64
317 RunID int64
318 JobIndex int32
319 JobKey string
320 JobName string
321 RunsOn string
322 Status WorkflowJobStatus
323 Conclusion NullCheckConclusion
324 CancelRequested bool
325 NeedsJobs []string
326 StartedAt pgtype.Timestamptz
327 CompletedAt pgtype.Timestamptz
328 CreatedAt pgtype.Timestamptz
329 UpdatedAt pgtype.Timestamptz
330 }
331
332 func (q *Queries) ListJobsForRun(ctx context.Context, db DBTX, runID int64) ([]ListJobsForRunRow, error) {
333 rows, err := db.Query(ctx, listJobsForRun, runID)
334 if err != nil {
335 return nil, err
336 }
337 defer rows.Close()
338 items := []ListJobsForRunRow{}
339 for rows.Next() {
340 var i ListJobsForRunRow
341 if err := rows.Scan(
342 &i.ID,
343 &i.RunID,
344 &i.JobIndex,
345 &i.JobKey,
346 &i.JobName,
347 &i.RunsOn,
348 &i.Status,
349 &i.Conclusion,
350 &i.CancelRequested,
351 &i.NeedsJobs,
352 &i.StartedAt,
353 &i.CompletedAt,
354 &i.CreatedAt,
355 &i.UpdatedAt,
356 ); err != nil {
357 return nil, err
358 }
359 items = append(items, i)
360 }
361 if err := rows.Err(); err != nil {
362 return nil, err
363 }
364 return items, nil
365 }
366
367 const listQueuedWorkflowJobRunsOn = `-- name: ListQueuedWorkflowJobRunsOn :many
368 SELECT
369 COALESCE(NULLIF(j.runs_on, ''), '(none)')::text AS runs_on,
370 COUNT(*)::integer AS queued_jobs,
371 COUNT(DISTINCT wr.id)::integer AS matching_runner_count,
372 MIN(j.created_at)::timestamptz AS oldest_queued_at
373 FROM workflow_jobs j
374 LEFT JOIN workflow_runners wr
375 ON (j.runs_on = '' OR j.runs_on = ANY(wr.labels))
376 AND wr.status IN ('idle', 'busy')
377 AND wr.draining_at IS NULL
378 AND wr.revoked_at IS NULL
379 WHERE j.status = 'queued'
380 AND j.cancel_requested = false
381 AND j.runner_id IS NULL
382 GROUP BY COALESCE(NULLIF(j.runs_on, ''), '(none)')
383 ORDER BY queued_jobs DESC, runs_on ASC
384 `
385
386 type ListQueuedWorkflowJobRunsOnRow struct {
387 RunsOn string
388 QueuedJobs int32
389 MatchingRunnerCount int32
390 OldestQueuedAt pgtype.Timestamptz
391 }
392
393 func (q *Queries) ListQueuedWorkflowJobRunsOn(ctx context.Context, db DBTX) ([]ListQueuedWorkflowJobRunsOnRow, error) {
394 rows, err := db.Query(ctx, listQueuedWorkflowJobRunsOn)
395 if err != nil {
396 return nil, err
397 }
398 defer rows.Close()
399 items := []ListQueuedWorkflowJobRunsOnRow{}
400 for rows.Next() {
401 var i ListQueuedWorkflowJobRunsOnRow
402 if err := rows.Scan(
403 &i.RunsOn,
404 &i.QueuedJobs,
405 &i.MatchingRunnerCount,
406 &i.OldestQueuedAt,
407 ); err != nil {
408 return nil, err
409 }
410 items = append(items, i)
411 }
412 if err := rows.Err(); err != nil {
413 return nil, err
414 }
415 return items, nil
416 }
417
418 const requestWorkflowJobCancel = `-- name: RequestWorkflowJobCancel :one
419 UPDATE workflow_jobs
420 SET cancel_requested = true,
421 status = CASE
422 WHEN status = 'queued' THEN 'cancelled'::workflow_job_status
423 ELSE status
424 END,
425 conclusion = CASE
426 WHEN status = 'queued' THEN 'cancelled'::check_conclusion
427 ELSE conclusion
428 END,
429 started_at = CASE
430 WHEN status = 'queued' THEN COALESCE(started_at, now())
431 ELSE started_at
432 END,
433 completed_at = CASE
434 WHEN status = 'queued' THEN COALESCE(completed_at, now())
435 ELSE completed_at
436 END,
437 version = version + 1,
438 updated_at = now()
439 WHERE id = $1
440 AND status IN ('queued', 'running')
441 AND (status = 'queued' OR cancel_requested = false)
442 RETURNING id, run_id, job_index, job_key, job_name, runs_on,
443 runner_id, needs_jobs, if_expr, timeout_minutes, permissions,
444 job_env, status, conclusion, cancel_requested,
445 started_at, completed_at, version, created_at, updated_at
446 `
447
448 func (q *Queries) RequestWorkflowJobCancel(ctx context.Context, db DBTX, id int64) (WorkflowJob, error) {
449 row := db.QueryRow(ctx, requestWorkflowJobCancel, id)
450 var i WorkflowJob
451 err := row.Scan(
452 &i.ID,
453 &i.RunID,
454 &i.JobIndex,
455 &i.JobKey,
456 &i.JobName,
457 &i.RunsOn,
458 &i.RunnerID,
459 &i.NeedsJobs,
460 &i.IfExpr,
461 &i.TimeoutMinutes,
462 &i.Permissions,
463 &i.JobEnv,
464 &i.Status,
465 &i.Conclusion,
466 &i.CancelRequested,
467 &i.StartedAt,
468 &i.CompletedAt,
469 &i.Version,
470 &i.CreatedAt,
471 &i.UpdatedAt,
472 )
473 return i, err
474 }
475
476 const requestWorkflowRunCancel = `-- name: RequestWorkflowRunCancel :many
477 UPDATE workflow_jobs
478 SET cancel_requested = true,
479 status = CASE
480 WHEN status = 'queued' THEN 'cancelled'::workflow_job_status
481 ELSE status
482 END,
483 conclusion = CASE
484 WHEN status = 'queued' THEN 'cancelled'::check_conclusion
485 ELSE conclusion
486 END,
487 started_at = CASE
488 WHEN status = 'queued' THEN COALESCE(started_at, now())
489 ELSE started_at
490 END,
491 completed_at = CASE
492 WHEN status = 'queued' THEN COALESCE(completed_at, now())
493 ELSE completed_at
494 END,
495 version = version + 1,
496 updated_at = now()
497 WHERE run_id = $1
498 AND status IN ('queued', 'running')
499 AND (status = 'queued' OR cancel_requested = false)
500 RETURNING id, run_id, job_index, job_key, job_name, runs_on,
501 runner_id, needs_jobs, if_expr, timeout_minutes, permissions,
502 job_env, status, conclusion, cancel_requested,
503 started_at, completed_at, version, created_at, updated_at
504 `
505
506 func (q *Queries) RequestWorkflowRunCancel(ctx context.Context, db DBTX, runID int64) ([]WorkflowJob, error) {
507 rows, err := db.Query(ctx, requestWorkflowRunCancel, runID)
508 if err != nil {
509 return nil, err
510 }
511 defer rows.Close()
512 items := []WorkflowJob{}
513 for rows.Next() {
514 var i WorkflowJob
515 if err := rows.Scan(
516 &i.ID,
517 &i.RunID,
518 &i.JobIndex,
519 &i.JobKey,
520 &i.JobName,
521 &i.RunsOn,
522 &i.RunnerID,
523 &i.NeedsJobs,
524 &i.IfExpr,
525 &i.TimeoutMinutes,
526 &i.Permissions,
527 &i.JobEnv,
528 &i.Status,
529 &i.Conclusion,
530 &i.CancelRequested,
531 &i.StartedAt,
532 &i.CompletedAt,
533 &i.Version,
534 &i.CreatedAt,
535 &i.UpdatedAt,
536 ); err != nil {
537 return nil, err
538 }
539 items = append(items, i)
540 }
541 if err := rows.Err(); err != nil {
542 return nil, err
543 }
544 return items, nil
545 }
546
547 const updateWorkflowJobStatus = `-- name: UpdateWorkflowJobStatus :one
548 UPDATE workflow_jobs
549 SET status = $2,
550 conclusion = $3::check_conclusion,
551 started_at = $4::timestamptz,
552 completed_at = $5::timestamptz,
553 version = version + 1,
554 updated_at = now()
555 WHERE id = $1
556 RETURNING id, run_id, job_index, job_key, job_name, runs_on,
557 runner_id, needs_jobs, if_expr, timeout_minutes, permissions,
558 job_env, status, conclusion, cancel_requested,
559 started_at, completed_at, version, created_at, updated_at
560 `
561
562 type UpdateWorkflowJobStatusParams struct {
563 ID int64
564 Status WorkflowJobStatus
565 Conclusion NullCheckConclusion
566 StartedAt pgtype.Timestamptz
567 CompletedAt pgtype.Timestamptz
568 }
569
570 func (q *Queries) UpdateWorkflowJobStatus(ctx context.Context, db DBTX, arg UpdateWorkflowJobStatusParams) (WorkflowJob, error) {
571 row := db.QueryRow(ctx, updateWorkflowJobStatus,
572 arg.ID,
573 arg.Status,
574 arg.Conclusion,
575 arg.StartedAt,
576 arg.CompletedAt,
577 )
578 var i WorkflowJob
579 err := row.Scan(
580 &i.ID,
581 &i.RunID,
582 &i.JobIndex,
583 &i.JobKey,
584 &i.JobName,
585 &i.RunsOn,
586 &i.RunnerID,
587 &i.NeedsJobs,
588 &i.IfExpr,
589 &i.TimeoutMinutes,
590 &i.Permissions,
591 &i.JobEnv,
592 &i.Status,
593 &i.Conclusion,
594 &i.CancelRequested,
595 &i.StartedAt,
596 &i.CompletedAt,
597 &i.Version,
598 &i.CreatedAt,
599 &i.UpdatedAt,
600 )
601 return i, err
602 }
603