commit 55bf820453ac7b21fbba9f1284a73ed7b52ca86a · julien.rbrt.fr/tangled-core

+11 -9

spindle/engine/engine.go

···

       18
       18
        
       	"github.com/docker/docker/pkg/stdcopy"

     

       19
       19
        
       	"golang.org/x/sync/errgroup"

     

       20
       20
        
       	"tangled.sh/tangled.sh/core/api/tangled"

     

       21
       21
       +
       	"tangled.sh/tangled.sh/core/knotserver/notifier"

     

       21
       22
        
       	"tangled.sh/tangled.sh/core/log"

     

       22
       23
        
       	"tangled.sh/tangled.sh/core/spindle/db"

     

       23
       24
        
       )

     
···

       30
       31
        
       	docker client.APIClient

     

       31
       32
        
       	l      *slog.Logger

     

       32
       33
        
       	db     *db.DB

     

       34
       34
       +
       	n      *notifier.Notifier

     

       33
       35
        
       }

     

       34
       36
        
       

     

       35
       35
       -
       func New(ctx context.Context, db *db.DB) (*Engine, error) {

     

       37
       37
       +
       func New(ctx context.Context, db *db.DB, n *notifier.Notifier) (*Engine, error) {

     

       36
       38
        
       	dcli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())

     

       37
       39
        
       	if err != nil {

     

       38
       40
        
       		return nil, err

     
···

       40
       42
        
       

     

       41
       43
        
       	l := log.FromContext(ctx).With("component", "spindle")

     

       42
       44
        
       

     

       43
       43
       -
       	return &Engine{docker: dcli, l: l, db: db}, nil

     

       45
       45
       +
       	return &Engine{docker: dcli, l: l, db: db, n: n}, nil

     

       44
       46
        
       }

     

       45
       47
        
       

     

       46
       48
        
       // SetupPipeline sets up a new network for the pipeline, and possibly volumes etc.

     
···

       71
       73
        
       		return err

     

       72
       74
        
       	}

     

       73
       75
        
       

     

       74
       74
       -
       	err = e.db.CreatePipeline(id)

     

       76
       76
       +
       	err = e.db.CreatePipeline(id, e.n)

     

       75
       77
        
       	return err

     

       76
       78
        
       }

     

       77
       79
        
       

     

       78
       80
        
       func (e *Engine) StartWorkflows(ctx context.Context, pipeline *tangled.Pipeline, id string) error {

     

       79
       81
        
       	e.l.Info("starting all workflows in parallel", "pipeline", id)

     

       80
       82
        
       

     

       81
       81
       -
       	err := e.db.MarkPipelineRunning(id)

     

       83
       83
       +
       	err := e.db.MarkPipelineRunning(id, e.n)

     

       82
       84
        
       	if err != nil {

     

       83
       85
        
       		return err

     

       84
       86
        
       	}

     
···

       101
       103
        
       			reader, err := e.docker.ImagePull(ctx, cimg, image.PullOptions{})

     

       102
       104
        
       			if err != nil {

     

       103
       105
        
       				e.l.Error("pipeline failed!", "id", id, "error", err.Error())

     

       104
       104
       -
       				err := e.db.MarkPipelineFailed(id, -1, err.Error())

     

       106
       106
       +
       				err := e.db.MarkPipelineFailed(id, -1, err.Error(), e.n)

     

       105
       107
        
       				if err != nil {

     

       106
       108
        
       					return err

     

       107
       109
        
       				}

     
···

       113
       115
        
       			err = e.StartSteps(ctx, w.Steps, id, cimg)

     

       114
       116
        
       			if err != nil {

     

       115
       117
        
       				e.l.Error("pipeline failed!", "id", id, "error", err.Error())

     

       116
       116
       -
       				return e.db.MarkPipelineFailed(id, -1, err.Error())

     

       118
       118
       +
       				return e.db.MarkPipelineFailed(id, -1, err.Error(), e.n)

     

       117
       119
        
       			}

     

       118
       120
        
       

     

       119
       121
        
       			return nil

     
···

       123
       125
        
       	err = g.Wait()

     

       124
       126
        
       	if err != nil {

     

       125
       127
        
       		e.l.Error("pipeline failed!", "id", id, "error", err.Error())

     

       126
       126
       -
       		return e.db.MarkPipelineFailed(id, -1, err.Error())

     

       128
       128
       +
       		return e.db.MarkPipelineFailed(id, -1, err.Error(), e.n)

     

       127
       129
        
       	}

     

       128
       130
        
       

     

       129
       131
        
       	e.l.Info("pipeline success!", "id", id)

     

       130
       130
       -
       	return e.db.MarkPipelineSuccess(id)

     

       132
       132
       +
       	return e.db.MarkPipelineSuccess(id, e.n)

     

       131
       133
        
       }

     

       132
       134
        
       

     

       133
       135
        
       // StartSteps starts all steps sequentially with the same base image.

     
···

       181
       183
        
       

     

       182
       184
        
       		if state.ExitCode != 0 {

     

       183
       185
        
       			e.l.Error("pipeline failed!", "id", id, "error", state.Error, "exit_code", state.ExitCode)

     

       184
       184
       -
       			return e.db.MarkPipelineFailed(id, state.ExitCode, state.Error)

     

       186
       186
       +
       			return e.db.MarkPipelineFailed(id, state.ExitCode, state.Error, e.n)

     

       185
       187
        
       		}

     

       186
       188
        
       	}

     

       187
       189

+1 -1

spindle/server.go

···

       53
       53
        
       

     

       54
       54
        
       	n := notifier.New()

     

       55
       55
        
       

     

       56
       56
       -
       	eng, err := engine.New(ctx, d)

     

       56
       56
       +
       	eng, err := engine.New(ctx, d, &n)

     

       57
       57
        
       	if err != nil {

     

       58
       58
        
       		return err

     

       59
       59
        
       	}