internal/envoy: support multiple HTTP compression algorithms

[anonrig]

Thanks for contributing to Contour!

Adds compression.algorithms so Contour can program more than one Envoy compressor filter and negotiate the encoding from Accept-Encoding.

The existing algorithm field is unchanged as a single-algorithm shorthand, including disabled. The two fields are mutually exclusive.

When more than one algorithm is configured:

• Contour installs one compressor filter per entry
• List order is the preference when q-values are equal (choose_first on the first entry)
• Accept-Encoding is stripped on the last filter so backends do not compress first and hide the other encodings

Also documents the brotli and zstd Envoy compressor extensions in the compatibility matrix.

Fixes #7698

[anonrig]

@tsaarni would you mind taking a look?

[codecov]

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 84.03%. Comparing base (c8e9765) to head (042ce5d).
⚠️ Report is 1 commits behind head on main.

Additional details and impacted files

@@            Coverage Diff             @@
##             main    #7699      +/-   ##
==========================================
- Coverage   84.04%   84.03%   -0.02%     
==========================================
  Files         131      131              
  Lines       14190    14187       -3     
==========================================
- Hits        11926    11922       -4     
- Misses       2264     2265       +1     

Files with missing lines	Coverage Δ
cmd/contour/servecontext.go	91.64% <100.00%> (-0.16%)	⬇️
internal/envoy/v3/listener.go	95.62% <100.00%> (-0.04%)	⬇️
pkg/config/parameters.go	90.82% <100.00%> (-0.13%)	⬇️

🚀 New features to boost your workflow:

• ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
• 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

[tsaarni]

@anonrig Thanks for contributing!

I've done a partial review and the PR looks good. I left some inline comments.
One larger suggestion: I think algorithms should be a pointer to a slice so it becomes a "tri-state":

• omitted for Envoy default
• empty list to disable compression
• populated list to use the listed algorithms

 Algorithms *[]CompressionAlgorithm `json:"algorithms,omitempty"`

This would let users disable compression via algorithms: [] instead of using different attribute for that. We can mark algorithm field deprecated.

Also same tri-state would make sense for the config file struct.

[tsaarni]

We could give early feedback by adding this CEL expression here

Suggested change

	// EnvoyCompression defines configuration related to compression in the default HTTP Listener filter chain.
	type EnvoyCompression struct {
	// EnvoyCompression defines configuration related to compression in the default HTTP Listener filter chain.
	// +kubebuilder:validation:XValidation:rule="!(has(self.algorithm) && has(self.algorithms))",message="compression algorithm and algorithms are mutually exclusive"
	type EnvoyCompression struct {

[anonrig]

Added. EnvoyCompression now has this CEL rule so the API server rejects algorithm and algorithms together.

[tsaarni]

To test that DefaultFilters() sets "choose first" and "remove accept-encoding" flags correctly we could have the different scenarios here:

func TestHTTPConnectionManagerCompressionAlgorithms(t *testing.T) {
	envoyGen := NewEnvoyGen(EnvoyGenOpt{
		XDSClusterName: DefaultXDSClusterName,
	})

	type compressorExpectation struct {
		name                  string
		compressorLibraryName string
		compressorLibrary     proto.Message
		chooseFirst           bool
		removeAcceptEncoding  bool
	}

	tests := map[string]struct {
		algorithms []contour_v1alpha1.CompressionAlgorithm
		want       []compressorExpectation
	}{
		"one algorithm": {
			algorithms: []contour_v1alpha1.CompressionAlgorithm{contour_v1alpha1.ZstdCompression},
			want: []compressorExpectation{
				{name: CompressorFilterName, compressorLibraryName: "zstd", compressorLibrary: &envoy_compression_zstd_compressor_v3.Zstd{}},
			},
		},
		"two algorithms": {
			algorithms: []contour_v1alpha1.CompressionAlgorithm{
				contour_v1alpha1.BrotliCompression,
				contour_v1alpha1.GzipCompression,
			},
			want: []compressorExpectation{
				{name: CompressorFilterName + ".brotli", compressorLibraryName: "brotli", compressorLibrary: &envoy_compression_brotli_compressor_v3.Brotli{}, chooseFirst: true},
				{name: CompressorFilterName + ".gzip", compressorLibraryName: "gzip", compressorLibrary: &envoy_compression_gzip_compressor_v3.Gzip{}, removeAcceptEncoding: true},
			},
		},
		"three algorithms": {
			algorithms: []contour_v1alpha1.CompressionAlgorithm{
				contour_v1alpha1.GzipCompression,
				contour_v1alpha1.BrotliCompression,
				contour_v1alpha1.ZstdCompression,
			},
			want: []compressorExpectation{
				{name: CompressorFilterName + ".gzip", compressorLibraryName: "gzip", compressorLibrary: &envoy_compression_gzip_compressor_v3.Gzip{}, chooseFirst: true},
				{name: CompressorFilterName + ".brotli", compressorLibraryName: "brotli", compressorLibrary: &envoy_compression_brotli_compressor_v3.Brotli{}},
				{name: CompressorFilterName + ".zstd", compressorLibraryName: "zstd", compressorLibrary: &envoy_compression_zstd_compressor_v3.Zstd{}, removeAcceptEncoding: true},
			},
		},
	}

	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			gotFilter := envoyGen.HTTPConnectionManagerBuilder().
				Compression(&contour_v1alpha1.EnvoyCompression{Algorithms: tc.algorithms}).
				DefaultFilters().
				Get()

			var got envoy_filter_network_http_connection_manager_v3.HttpConnectionManager
			require.NoError(t, gotFilter.GetTypedConfig().UnmarshalTo(&got))
			require.GreaterOrEqual(t, len(got.HttpFilters), len(tc.want)+1)
			assert.Equal(t, GRPCWebFilterName, got.HttpFilters[len(tc.want)].Name)

			for i, want := range tc.want {
				var compressor envoy_filter_http_compressor_v3.Compressor
				require.NoError(t, got.HttpFilters[i].GetTypedConfig().UnmarshalTo(&compressor))

				assert.Equal(t, want.name, got.HttpFilters[i].Name)
				require.NotNil(t, compressor.CompressorLibrary)
				require.NotNil(t, compressor.CompressorLibrary.TypedConfig)
				assert.Equal(t, want.compressorLibraryName, compressor.CompressorLibrary.Name)
				assert.True(t, compressor.CompressorLibrary.TypedConfig.MessageIs(want.compressorLibrary))
				assert.Equal(t, want.chooseFirst, compressor.ChooseFirst)
				assert.Equal(t, want.removeAcceptEncoding, compressor.ResponseDirectionConfig.RemoveAcceptEncodingHeader)
			}
		})
	}
}

[anonrig]

Added, including the one/two/three algorithm cases plus an empty-list case now that algorithms: [] disables compression.

[tsaarni]

For clarity:

Suggested change

	// Allowable values are defined as names of well known compression algorithms.

since the same type is used for both Algorithm and Algorithms, where in one case disable is allowed and in the other it is not.

[anonrig]

Updated. The type comment no longer mentions disabled, since that value is only valid on the deprecated algorithm field.

[anonrig]

Sounds good. I'll update the PR. Thank you for the review.

[anonrig]

@tsaarni thanks for the review. I updated the PR to match the feedback:

• algorithms is now *[]CompressionAlgorithm (same tri-state on the config-file struct): omitted keeps the Envoy default, [] disables compression, and a populated list programs those encodings
• algorithm is deprecated; algorithm and algorithms remain mutually exclusive, with CEL validation on the CRD
• added the choose_first / remove_accept_encoding compressor tests you suggested, plus coverage for the empty-list disable path

[anonrig]

@tsaarni can you re-review?