func()

in pkg/api/service/service.go [49:105]

• 46 lines of code
• 10 McCabe index (conditional complexity)

func (s *StepRunnerService) Run(ctx context.Context, request *proto.RunRequest) (response *proto.RunResponse, err error) {
	if _, ok := s.jobs.Get(request.Id); ok {
		return &proto.RunResponse{}, nil
	}

	specDef, err := s.loadSteps(request.Steps, request)
	if err != nil {
		return nil, fmt.Errorf("loading step: %w", err)
	}

	jobOpts := []func(*jobs.Job){}
	if s.runExitWaitTime != 0 {
		jobOpts = append(jobOpts, jobs.WithRunExitWaitTime(s.runExitWaitTime))
	}

	job, err := jobs.New(request.Id, specDef.Dir(), jobOpts...)
	if err != nil {
		return nil, fmt.Errorf("initializing request: %w", err)
	}

	defer func() {
		if err != nil {
			job.Close()
		}
	}()

	jobVars, err := variables.Prepare(request.Job, job.TmpDir)
	if err != nil {
		return nil, fmt.Errorf("preparing environment: %w", err)
	}

	env, err := runner.GlobalEnvironment(s.env, jobVars)
	if err != nil {
		return nil, fmt.Errorf("initializing global environment: %w", err)
	}

	globalCtxEnv := env.AddLexicalScope(request.Env)
	stdout, stderr := job.Logs()
	globCtx := runner.NewGlobalContext(job.WorkDir, jobVars, globalCtxEnv, stdout, stderr)

	params := &runner.Params{}
	step, err := s.stepParser.Parse(globCtx, specDef, params, runner.StepDefinedInGitLabJob)
	if err != nil {
		return nil, fmt.Errorf("failed to start step runner service: %w", err)
	}

	inputs := params.NewInputsWithDefault(specDef.SpecInputs())
	stepsCtx, err := runner.NewStepsContext(globCtx, specDef.Dir(), inputs, globCtx.Env())
	if err != nil {
		return nil, err
	}

	// actually execute the steps request
	s.jobs.Put(request.Id, job)
	s.execute(func() { job.Run(stepsCtx, step) })
	return &proto.RunResponse{}, nil
}