cfg := Config{}
	if err = config.CheckValidKeys(config.CompressionSubSys, kvs, DefaultKVS); err != nil {
		return cfg, err
	}

	compress := env.Get(EnvCompressState, kvs.Get(config.Enable))
	if compress == "" {
		compress = env.Get(EnvCompress, "")
	}
	cfg.Enabled, err = config.ParseBool(compress)
	if err != nil {
		// Parsing failures happen due to empty KVS, ignore it.
		if kvs.Empty() {
			return cfg, nil
		}

Harshavardhana <******@****.***> 1699046298 -0700

      - name: multipart uploads test
        run: |
          ${GITHUB_WORKSPACE}/.github/workflows/multipart/migrate.sh "${{ steps.vars.outputs.sha_short }}"

      - name: compress and encrypt
        run: |
          ${GITHUB_WORKSPACE}/.github/workflows/run-mint.sh "compress-encrypt" "minio" "minio123" "${{ steps.vars.outputs.sha_short }}"

      - name: multiple pools
        run: |

			t.Fatalf("case[%v]: Expected key.Name: %v, got %v", i, testCase.expectedKey.Name, key.Name)
		}
		if testCase.expectedKey.Compress != key.Compress {
			t.Fatalf("case[%v]: Expected key.Compress: %v, got %v", i, testCase.expectedKey.Compress, key.Compress)
		}
		if testCase.expectedKey.Extension != key.Extension {

	// Notification queue configuration.
	Notify notify.Config `json:"notify"`

	// Logger configuration
	Logger logger.Config `json:"logger"`

	// Compression configuration
	Compression compress.Config `json:"compress"`

	// OpenID configuration
	OpenID openid.Config `json:"openid"`

	// External policy enforcements.
	Policy struct {
		// OPA configuration.
		OPA opa.Args `json:"opa"`

					return
				}
			}
		case "Compress":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "Compress")
					return
				}
				z.Compress = nil
			} else {
				if z.Compress == nil {
					z.Compress = new(bool)
				}
				*z.Compress, err = dc.ReadBool()
				if err != nil {
					err = msgp.WrapError(err, "Compress")
					return
				}
			}

	if w.f != nil {
		if err := w.closeCurrentFile(); err != nil {
			return err
		}

		// This function is a no-op if opts.Compress is false
		// writes an error in JSON form to stderr, if we cannot
		// compress.
		if err := w.compress(); err != nil {
			msg := fmt.Sprintf("unable to compress log file %v: %v, ignoring and moving on", w.f.Name(), err)
			stdErrEnc.Encode(&log.Entry{
				Level:   ErrorKind,
				Message: msg,

MinIO server allows streaming compression to ensure efficient disk space usage.
Compression happens inflight, i.e objects are compressed before being written to disk(s).
MinIO uses [`klauspost/compress/s2`](https://github.com/klauspost/compress/tree/master/s2)
streaming compression due to its stability and performance.

This algorithm is specifically optimized for machine generated content.
Write throughput is typically at least 500MB/s per CPU core,

	}
	keys = store.List()
	if len(keys) != 1 {
		t.Fatalf("expected len(store.List())=1; but got %v", len(keys))
	}
	key := keys[0]
	if !key.Compress {
		t.Fatal("expected key.Compress=true; but got false")
	}
	if key.ItemCount != int(limit) {
		t.Fatalf("expected key.ItemCount=%d; but got %v", limit, key.ItemCount)
	}
	items, err := store.GetMultiple(key)
	if err != nil {

github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/klauspost/compress v1.17.8 h1:YcnTYrq7MikUT7k0Yb5eceMmALQPYBW/Xltxn0NAMnU=
github.com/klauspost/compress v1.17.8/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
github.com/klauspost/cpuid/v2 v2.0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=