Function CreateFallbackValidationContext

internal/validate/vsa/fallback.go:110–147

createFallbackValidationContext precomputes the fallback validation context once

(ctx context.Context, config *FallbackConfig)

// createFallbackValidationContext precomputes the fallback validation context once
func CreateFallbackValidationContext(ctx context.Context, config *FallbackConfig) (*FallbackValidationContext, error) {
	log.Debugf("🔄 Precomputing fallback validation context...")

	// Get policy configuration (same as VSA command)
	policyConfiguration, err := getPolicyConfig(ctx, config.PolicyConfig)
	if err != nil {
		return nil, fmt.Errorf("fallback validation: failed to get policy configuration: %w", err)
	}

	log.Debugf("🔄 Fallback context: Policy configuration resolved to: %s", policyConfiguration)

	// Create policy options with fallback public key
	policyOptions := policy.Options{
		IgnoreRekor:   true,
		EffectiveTime: config.EffectiveTime,
		PolicyRef:     policyConfiguration,
		PublicKey:     config.FallbackPublicKey, // Different public key for fallback
	}

	log.Debugf("🔄 Fallback context: Policy options: %+v", policyOptions)

	// Process policy with fallback public key
	fallbackPolicy, _, err := policy.PreProcessPolicy(ctx, policyOptions)
	if err != nil {
		return nil, fmt.Errorf("fallback validation: failed to process policy: %w", err)
	}

	log.Debugf("🔄 Fallback context: Policy processed successfully")
	log.Debugf("🔄 Fallback context: Policy spec sources count: %d", len(fallbackPolicy.Spec().Sources))

	// Note: evaluators will be created per-worker for thread safety
	log.Debugf("🔄 Fallback context: Evaluators will be created per-worker for thread safety")

	return &FallbackValidationContext{
		PolicyConfiguration: policyConfiguration,
		FallbackPolicy:      fallbackPolicy,
	}, nil
}

// createWorkerFallbackContext creates evaluators once per worker thread
// This ensures thread safety while reusing evaluators within the worker