func()

in internal/execution/executor.go [30:78]

• 41 lines of code
• 9 McCabe index (conditional complexity)

func (e *Executor) Synthesize(ctx context.Context, env *Env) error {
	logger := logr.FromContextOrDiscard(ctx)

	comp := &apiv1.Composition{}
	comp.Name = env.CompositionName
	comp.Namespace = env.CompositionNamespace
	err := e.Reader.Get(ctx, client.ObjectKeyFromObject(comp), comp)
	if err != nil {
		return fmt.Errorf("fetching composition: %w", err)
	}

	syn := &apiv1.Synthesizer{}
	syn.Name = comp.Spec.Synthesizer.Name
	err = e.Reader.Get(ctx, client.ObjectKeyFromObject(syn), syn)
	if err != nil {
		return fmt.Errorf("fetching synthesizer: %w", err)
	}

	if reason, skip := skipSynthesis(comp, syn, env); skip {
		logger.V(0).Info("synthesis is no longer relevant - skipping", "reason", reason)
		return nil
	}

	input, revs, err := e.buildPodInput(ctx, comp, syn)
	if err != nil {
		return fmt.Errorf("building synthesizer input: %w", err)
	}

	output, err := e.Handler(ctx, syn, input)
	if err != nil {
		return fmt.Errorf("executing synthesizer: %w", err)
	}
	resultErr := findResultError(output)

	var sliceRefs []*apiv1.ResourceSliceRef
	if resultErr == nil {
		sliceRefs, err = e.writeSlices(ctx, comp, output)
		if err != nil {
			return err
		}
	}

	err = e.updateComposition(ctx, env, comp, syn, sliceRefs, revs, output)
	if err != nil {
		return err
	}

	return resultErr
}