Introduce ExtensionFeatureMetadata struct

[kkk777-7]

What would you like to be added:
Introduce ExtensionFeatureMetadata struct.

type ExtensionFeatureMetadata struct {
	emitted bool
	source *ExtensionFeatureSource
}

type ExtensionFeatureSource struct {
	IngressNN     types.NamespacedName
	AnnotationKey []string
}

func (m *ExtensionFeatureMetadata) SetEmitted() {
	m.emitted = true
}
func (m *ExtensionFeatureMetadata) IsEmitted() bool {
	return m.emitted
}
func (m *ExtensionFeatureMetadata) GetSource() *ExtensionFeatureSource {
	return m.source
}
func (m *ExtensionFeatureMetadata) SetSource(source *ExtensionFeatureSource) {
	m.source = source
}

Why this is needed:
currently, we're implementing extension features, like below

• PathRewrite
  • https://github.com/kubernetes-sigs/ingress2gateway/pull/290/files
• RequestTimeout
  • https://github.com/kubernetes-sigs/ingress2gateway/pull/289/files
• Buffer body size
  • https://github.com/kubernetes-sigs/ingress2gateway/pull/305/files

It’s unclear which emitter should apply the extensions.
so, we should append metadata into extensions to handle correctly.

Each extension embeds the metadata above in the struct, allowing the emitter to tell that it has already been processed.

e.g.

type BodySize struct {
    ExtensionFeatureMetadata
	BufferSize *resource.Quantity
	MaxSize    *resource.Quantity
}

[kkk777-7]

With this mechanism, once an extension becomes supported by the Gateway API spec, the common emitter can take priority over the custom emitter when processing it.

Processing Flow

sequenceDiagram
    participant Provider
    participant Extension as Extension Feature
    participant CommonEmitter as Common Emitter
    participant CustomEmitter as Custom Emitter
    participant Core as Core Logic

    Note over Provider,Core: Parse Phase
    Provider->>Extension: Create extension
    Provider->>Extension: SetSource(IngressNN, AnnotationKeys)
    Note over Extension: emitted = false

    Note over Provider,Core: Emit Phase
    CommonEmitter->>Extension: Process extension
    CommonEmitter->>Extension: SetEmitted()
    Note over Extension: emitted = true

    CustomEmitter->>Extension: IsEmitted()?
    Extension-->>CustomEmitter: true
    Note over CustomEmitter: Skip processing (already handled)

    Note over Provider,Core: Output Phase
    Core->>Extension: IsEmitted()?
    alt emitted == false
        Core->>Core: Warn: Emitter doesn't support this extension
    end

Loading

Responsibility

Provider

• When creating the extension settings, set the source information (e.g., ingressNN, annotations)

Common Emitter

• When the common emitter processes an extension, set the emitted flag

Custom Emitter (e.g. envoy gateway)

• Check the emitted flag
  • If it is true, the custom emitter must not process the extension

ingress2gateway core logic

• Emit a warning if an extension was not processed by any emitter

[Stevenjin8]

@kkk777-7 ok I though about this more and I think we can implement this in a much simpler way: just have each feature have a "source" or a GetSource method. We can nil out the field to say that its been implemented. the IR has gone through the pipeline, we just look at each IR field. If its no nil, we just print out a message using the GetSource method.

[kkk777-7]

@Stevenjin8 +1, your idea is simpler and better!