Files
pipelines/internal/server/resources.go
T

73 lines
2.5 KiB
Go

package server
import (
"context"
"errors"
"time"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
"git.a-wan.net/alan/pipelines/internal/stage"
)
func (r *runner) acquireResource(ctx context.Context, visit pipeline.ResourceVisit, workspace string, completed int) (pipeline.ResourceLease, error) {
return r.acquireResourceWithPool(ctx, visit, "", workspace, completed)
}
func (r *runner) acquireResourceWithPool(ctx context.Context, visit pipeline.ResourceVisit, pool string, workspace string, completed int) (pipeline.ResourceLease, error) {
var lease pipeline.ResourceLease
var ready <-chan pipeline.ResourceLease
var wait *protocol.ResourceWait
var err error
if pool != "" {
lease, ready, wait, err = r.store.RequestResourcePool(ctx, pool, visit)
} else {
lease, ready, wait, err = r.store.RequestResource(ctx, visit)
}
if err != nil {
return lease, err
}
if ready != nil {
r.emitRun(protocol.RunEventFrame{RunID: visit.RunID, Workspace: workspace, Status: protocol.RunStatusQueued, CurrentStage: visit.Stage, CompletedSteps: completed, ResourceWaitSet: true, ResourceWait: wait}, false)
select {
case lease = <-ready:
r.store.AcceptResource(lease)
case <-ctx.Done():
cleanup, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := r.store.CancelResource(cleanup, visit); err != nil {
return lease, errors.Join(ctx.Err(), err)
}
return lease, ctx.Err()
}
}
if ctx.Err() != nil {
err := r.releaseResource(lease, true) // Never launched, including a concurrent grant.
return pipeline.ResourceLease{}, errors.Join(ctx.Err(), err)
}
r.emitRun(protocol.RunEventFrame{RunID: visit.RunID, Workspace: workspace, ResourceWaitSet: true}, false)
return lease, nil
}
func (r *runner) releaseResource(lease pipeline.ResourceLease, confirmed bool) error {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := r.store.SetResourceCleanup(ctx, lease, confirmed); err != nil {
return err
}
if confirmed {
return r.store.ReleaseResource(ctx, lease)
}
return nil
}
func (r *runner) resourceQuiescent(id int64, executionErr error, panicked bool) bool {
if panicked || errors.Is(executionErr, stage.ErrStageCleanup) {
return false
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
sessions, err := r.store.ActiveAgentSessionsForRun(ctx, id)
return err == nil && len(sessions) == 0
}