commit 6d10fb1cc026d0ba09793643d35e33e2bf2d58f9 · julien.rbrt.fr/tangled-core

+4

spindle/db/events.go

···

       135
       135
        
       func (d *DB) StatusSuccess(workflowId models.WorkflowId, n *notifier.Notifier) error {

     

       136
       136
        
       	return d.createStatusEvent(workflowId, models.StatusKindSuccess, nil, nil, n)

     

       137
       137
        
       }

     

       138
       138
       +
       

     

       139
       139
       +
       func (d *DB) StatusTimeout(workflowId models.WorkflowId, n *notifier.Notifier) error {

     

       140
       140
       +
       	return d.createStatusEvent(workflowId, models.StatusKindTimeout, nil, nil, n)

     

       141
       141
       +
       }

+15 -7

spindle/engine/engine.go

···

       104
       104
        
       

     

       105
       105
        
       			err = e.StartSteps(ctx, w.Steps, wid, w.Image)

     

       106
       106
        
       			if err != nil {

     

       107
       107
       -
       				e.l.Error("workflow failed!", "wid", wid.String(), "error", err.Error())

     

       108
       108
       -
       

     

       109
       109
       -
       				dbErr := e.db.StatusFailed(wid, err.Error(), -1, e.n)

     

       110
       110
       -
       				if dbErr != nil {

     

       111
       111
       -
       					return dbErr

     

       107
       107
       +
       				if errors.Is(err, ErrTimedOut) {

     

       108
       108
       +
       					dbErr := e.db.StatusTimeout(wid, e.n)

     

       109
       109
       +
       					if dbErr != nil {

     

       110
       110
       +
       						return dbErr

     

       111
       111
       +
       					}

     

       112
       112
       +
       				} else {

     

       113
       113
       +
       					dbErr := e.db.StatusFailed(wid, err.Error(), -1, e.n)

     

       114
       114
       +
       					if dbErr != nil {

     

       115
       115
       +
       						return dbErr

     

       116
       116
       +
       					}

     

       112
       117
        
       				}

     

       113
       118
        
       

     

       114
       119
        
       				return fmt.Errorf("starting steps image: %w", err)

     
···

       245
       250
        
       			<-tailDone

     

       246
       251
        
       

     

       247
       252
        
       			stepCancel()

     

       248
       248
       -
       			return fmt.Errorf("step timed out after %v", stepTimeout)

     

       253
       253
       +
       			return ErrTimedOut

     

       249
       254
        
       		}

     

       250
       255
        
       

     

       251
       256
        
       		if waitErr != nil {

     
···

       259
       264
        
       

     

       260
       265
        
       		if state.ExitCode != 0 {

     

       261
       266
        
       			e.l.Error("workflow failed!", "workflow_id", wid.String(), "error", state.Error, "exit_code", state.ExitCode, "oom_killed", state.OOMKilled)

     

       262
       262
       -
       			return fmt.Errorf("error: %s, exit code: %d, oom: %t", state.Error, state.ExitCode, state.OOMKilled)

     

       267
       267
       +
       			if state.OOMKilled {

     

       268
       268
       +
       				return ErrOOMKilled

     

       269
       269
       +
       			}

     

       270
       270
       +
       			return ErrWorkflowFailed

     

       263
       271
        
       		}

     

       264
       272
        
       	}

     

       265
       273

+9

spindle/engine/errors.go

···

       1
       1
       +
       package engine

     

       2
       2
       +
       

     

       3
       3
       +
       import "errors"

     

       4
       4
       +
       

     

       5
       5
       +
       var (

     

       6
       6
       +
       	ErrOOMKilled      = errors.New("oom killed")

     

       7
       7
       +
       	ErrTimedOut       = errors.New("timed out")

     

       8
       8
       +
       	ErrWorkflowFailed = errors.New("workflow failed")

     

       9
       9
       +
       )