[utils/compression] Remove gzip compressor (#2839)

dhrubabasu · web-flow · commit b15c7431c1ca · 2024-03-09T00:15:54.000Z
diff --git a/config/config.go b/config/config.go
@@ -88,7 +88,6 @@ var (
 	errCannotReadDirectory                    = errors.New("cannot read directory")
 	errUnmarshalling                          = errors.New("unmarshalling failed")
 	errFileDoesNotExist                       = errors.New("file does not exist")
-	errGzipDeprecatedMsg                      = errors.New("gzip compression is not supported, use zstd or no compression")
 )
 
 func getConsensusConfig(v *viper.Viper) snowball.Parameters {
@@ -266,9 +265,6 @@ func getNetworkConfig(
 	if err != nil {
 		return network.Config{}, err
 	}
-	if compressionType == compression.TypeGzip {
-		return network.Config{}, errGzipDeprecatedMsg
-	}
 
 	allowPrivateIPs := !constants.ProductionNetworkIDs.Contains(networkID)
 	if v.IsSet(NetworkAllowPrivateIPsKey) {
diff --git a/message/messages.go b/message/messages.go
@@ -131,10 +131,6 @@ func (m *outboundMessage) BytesSavedCompression() int {
 type msgBuilder struct {
 	log logging.Logger
 
-	// TODO: Remove gzip once v1.11.x is out.
-	gzipCompressor            compression.Compressor
-	gzipDecompressTimeMetrics map[Op]metric.Averager
-
 	zstdCompressor            compression.Compressor
 	zstdCompressTimeMetrics   map[Op]metric.Averager
 	zstdDecompressTimeMetrics map[Op]metric.Averager
@@ -148,10 +144,6 @@ func newMsgBuilder(
 	metrics prometheus.Registerer,
 	maxMessageTimeout time.Duration,
 ) (*msgBuilder, error) {
-	gzipCompressor, err := compression.NewGzipCompressor(constants.DefaultMaxMessageSize)
-	if err != nil {
-		return nil, err
-	}
 	zstdCompressor, err := compression.NewZstdCompressor(constants.DefaultMaxMessageSize)
 	if err != nil {
 		return nil, err
@@ -160,9 +152,6 @@ func newMsgBuilder(
 	mb := &msgBuilder{
 		log: log,
 
-		gzipCompressor:            gzipCompressor,
-		gzipDecompressTimeMetrics: make(map[Op]metric.Averager, len(ExternalOps)),
-
 		zstdCompressor:            zstdCompressor,
 		zstdCompressTimeMetrics:   make(map[Op]metric.Averager, len(ExternalOps)),
 		zstdDecompressTimeMetrics: make(map[Op]metric.Averager, len(ExternalOps)),
@@ -172,13 +161,6 @@ func newMsgBuilder(
 
 	errs := wrappers.Errs{}
 	for _, op := range ExternalOps {
-		mb.gzipDecompressTimeMetrics[op] = metric.NewAveragerWithErrs(
-			namespace,
-			fmt.Sprintf("gzip_%s_decompress_time", op),
-			fmt.Sprintf("time (in ns) to decompress %s messages with gzip", op),
-			metrics,
-			&errs,
-		)
 		mb.zstdCompressTimeMetrics[op] = metric.NewAveragerWithErrs(
 			namespace,
 			fmt.Sprintf("zstd_%s_compress_time", op),
@@ -271,14 +253,9 @@ func (mb *msgBuilder) unmarshal(b []byte) (*p2p.Message, int, Op, error) {
 		opToDecompressTimeMetrics map[Op]metric.Averager
 		compressor                compression.Compressor
 		compressedBytes           []byte
-		gzipCompressed            = m.GetCompressedGzip()
 		zstdCompressed            = m.GetCompressedZstd()
 	)
 	switch {
-	case len(gzipCompressed) > 0:
-		opToDecompressTimeMetrics = mb.gzipDecompressTimeMetrics
-		compressor = mb.gzipCompressor
-		compressedBytes = gzipCompressed
 	case len(zstdCompressed) > 0:
 		opToDecompressTimeMetrics = mb.zstdDecompressTimeMetrics
 		compressor = mb.zstdCompressor
diff --git a/proto/p2p/p2p.proto b/proto/p2p/p2p.proto
@@ -8,16 +8,12 @@ option go_package = "github.com/ava-labs/avalanchego/proto/pb/p2p";
 // Represents peer-to-peer messages.
 // Only one type can be non-null.
 message Message {
+  reserved 1; // Until E upgrade is activated.
   reserved 36; // Next unused field number.
   // NOTES
   // Use "oneof" for each message type and set rest to null if not used.
   // That is because when the compression is enabled, we don't want to include uncompressed fields.
   oneof message {
-    // Gzip-compressed bytes of a "p2p.Message" whose "oneof" "message" field is
-    // NOT compressed_* BUT one of the message types (e.g. ping, pong, etc.).
-    // This field is only set if the message type supports compression.
-    bytes compressed_gzip = 1;
-
     // zstd-compressed bytes of a "p2p.Message" whose "oneof" "message" field is
     // NOT compressed_* BUT one of the message types (e.g. ping, pong, etc.).
     // This field is only set if the message type supports compression.
diff --git a/proto/pb/p2p/p2p.pb.go b/proto/pb/p2p/p2p.pb.go
diff --git a/utils/compression/compressor_test.go b/utils/compression/compressor_test.go
@@ -24,18 +24,13 @@ var (
 		TypeNone: func(int64) (Compressor, error) { //nolint:unparam // an error is needed to be returned to compile
 			return NewNoCompressor(), nil
 		},
-		TypeGzip: NewGzipCompressor,
 		TypeZstd: NewZstdCompressor,
 	}
 
-	//go:embed gzip_zip_bomb.bin
-	gzipZipBomb []byte
-
 	//go:embed zstd_zip_bomb.bin
 	zstdZipBomb []byte
 
 	zipBombs = map[Type][]byte{
-		TypeGzip: gzipZipBomb,
 		TypeZstd: zstdZipBomb,
 	}
 )
@@ -154,10 +149,6 @@ func TestNewCompressorWithInvalidLimit(t *testing.T) {
 	}
 }
 
-func FuzzGzipCompressor(f *testing.F) {
-	fuzzHelper(f, TypeGzip)
-}
-
 func FuzzZstdCompressor(f *testing.F) {
 	fuzzHelper(f, TypeZstd)
 }
@@ -168,9 +159,6 @@ func fuzzHelper(f *testing.F, compressionType Type) {
 		err        error
 	)
 	switch compressionType {
-	case TypeGzip:
-		compressor, err = NewGzipCompressor(maxMessageSize)
-		require.NoError(f, err)
 	case TypeZstd:
 		compressor, err = NewZstdCompressor(maxMessageSize)
 		require.NoError(f, err)
diff --git a/utils/compression/gzip_compressor.go b/utils/compression/gzip_compressor.go
diff --git a/utils/compression/gzip_zip_bomb.bin b/utils/compression/gzip_zip_bomb.bin
diff --git a/utils/compression/no_compressor.go b/utils/compression/no_compressor.go
@@ -7,17 +7,14 @@ var _ Compressor = (*noCompressor)(nil)
 
 type noCompressor struct{}
 
-// Compress returns [msg]
 func (*noCompressor) Compress(msg []byte) ([]byte, error) {
 	return msg, nil
 }
 
-// Decompress returns [msg].
 func (*noCompressor) Decompress(msg []byte) ([]byte, error) {
 	return msg, nil
 }
 
-// NewNoCompressor returns a Compressor that does nothing
 func NewNoCompressor() Compressor {
 	return &noCompressor{}
 }
diff --git a/utils/compression/type.go b/utils/compression/type.go
@@ -14,16 +14,13 @@ type Type byte
 
 const (
 	TypeNone Type = iota + 1
-	TypeGzip      // Remove once v1.11.x is out.
 	TypeZstd
 )
 
 func (t Type) String() string {
 	switch t {
 	case TypeNone:
 		return "none"
-	case TypeGzip:
-		return "gzip"
 	case TypeZstd:
 		return "zstd"
 	default:
@@ -35,8 +32,6 @@ func TypeFromString(s string) (Type, error) {
 	switch s {
 	case TypeNone.String():
 		return TypeNone, nil
-	case TypeGzip.String():
-		return TypeGzip, nil
 	case TypeZstd.String():
 		return TypeZstd, nil
 	default:
diff --git a/utils/compression/type_test.go b/utils/compression/type_test.go
@@ -12,7 +12,7 @@ import (
 func TestTypeString(t *testing.T) {
 	require := require.New(t)
 
-	for _, compressionType := range []Type{TypeNone, TypeGzip, TypeZstd} {
+	for _, compressionType := range []Type{TypeNone, TypeZstd} {
 		s := compressionType.String()
 		parsedType, err := TypeFromString(s)
 		require.NoError(err)
@@ -34,10 +34,6 @@ func TestTypeMarshalJSON(t *testing.T) {
 			Type:     TypeNone,
 			expected: `"none"`,
 		},
-		{
-			Type:     TypeGzip,
-			expected: `"gzip"`,
-		},
 		{
 			Type:     TypeZstd,
 			expected: `"zstd"`,
diff --git a/utils/compression/zstd_compressor.go b/utils/compression/zstd_compressor.go
@@ -5,14 +5,21 @@ package compression
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"io"
 	"math"
 
 	"github.com/DataDog/zstd"
 )
 
-var _ Compressor = (*zstdCompressor)(nil)
+var (
+	_ Compressor = (*zstdCompressor)(nil)
+
+	ErrInvalidMaxSizeCompressor = errors.New("invalid compressor max size")
+	ErrDecompressedMsgTooLarge  = errors.New("decompressed msg too large")
+	ErrMsgTooLarge              = errors.New("msg too large to be compressed")
+)
 
 func NewZstdCompressor(maxSize int64) (Compressor, error) {
 	if maxSize == math.MaxInt64 {

Original file line number	Diff line number	Diff line change
`@@ -24,18 +24,13 @@ var (`
`24`	`24`	`TypeNone: func(int64) (Compressor, error) { //nolint:unparam // an error is needed to be returned to compile`
`25`	`25`	`return NewNoCompressor(), nil`
`26`	`26`	`},`
`27`		`- TypeGzip: NewGzipCompressor,`
`28`	`27`	`TypeZstd: NewZstdCompressor,`
`29`	`28`	`}`
`30`	`29`
`31`		`- //go:embed gzip_zip_bomb.bin`
`32`		`- gzipZipBomb []byte`
`33`		`-`
`34`	`30`	`//go:embed zstd_zip_bomb.bin`
`35`	`31`	`zstdZipBomb []byte`
`36`	`32`
`37`	`33`	`zipBombs = map[Type][]byte{`
`38`		`- TypeGzip: gzipZipBomb,`
`39`	`34`	`TypeZstd: zstdZipBomb,`
`40`	`35`	`}`
`41`	`36`	`)`
`@@ -154,10 +149,6 @@ func TestNewCompressorWithInvalidLimit(t *testing.T) {`
`154`	`149`	`}`
`155`	`150`	`}`
`156`	`151`
`157`		`-func FuzzGzipCompressor(f *testing.F) {`
`158`		`- fuzzHelper(f, TypeGzip)`
`159`		`-}`
`160`		`-`
`161`	`152`	`func FuzzZstdCompressor(f *testing.F) {`
`162`	`153`	`fuzzHelper(f, TypeZstd)`
`163`	`154`	`}`
`@@ -168,9 +159,6 @@ func fuzzHelper(f *testing.F, compressionType Type) {`
`168`	`159`	`err error`
`169`	`160`	`)`
`170`	`161`	`switch compressionType {`
`171`		`- case TypeGzip:`
`172`		`- compressor, err = NewGzipCompressor(maxMessageSize)`
`173`		`- require.NoError(f, err)`
`174`	`162`	`case TypeZstd:`
`175`	`163`	`compressor, err = NewZstdCompressor(maxMessageSize)`
`176`	`164`	`require.NoError(f, err)`
Original file line number	Diff line number	Diff line change
`@@ -7,17 +7,14 @@ var _ Compressor = (*noCompressor)(nil)`
`7`	`7`
`8`	`8`	`type noCompressor struct{}`
`9`	`9`
`10`		`-// Compress returns [msg]`
`11`	`10`	`func (*noCompressor) Compress(msg []byte) ([]byte, error) {`
`12`	`11`	`return msg, nil`
`13`	`12`	`}`
`14`	`13`
`15`		`-// Decompress returns [msg].`
`16`	`14`	`func (*noCompressor) Decompress(msg []byte) ([]byte, error) {`
`17`	`15`	`return msg, nil`
`18`	`16`	`}`
`19`	`17`
`20`		`-// NewNoCompressor returns a Compressor that does nothing`
`21`	`18`	`func NewNoCompressor() Compressor {`
`22`	`19`	`return &noCompressor{}`
`23`	`20`	`}`