Bucket       string   `xml:"Bucket" json:"Bucket"`
	StorageClass string   `xml:"StorageClass" json:"StorageClass"`
	ARN          string
	// EncryptionConfiguration TODO: not needed for MinIO
}

func (d Destination) isValidStorageClass() bool {
	if d.StorageClass == "" {
		return true
	}
	return d.StorageClass == "STANDARD" || d.StorageClass == "REDUCED_REDUNDANCY"
}

			HiddenIfEmpty: true,
		},
	}
)

// StorageClass - holds storage class information
type StorageClass struct {
	Parity int
}

// ConfigLock is a global lock for storage-class config
var ConfigLock sync.RWMutex

// Config storage class configuration
type Config struct {
	Standard    StorageClass `json:"standard"`
	RRS         StorageClass `json:"rrs"`
	Optimize    string       `json:"optimize"`

package storageclass

import (
	"errors"
	"reflect"
	"testing"
)

func TestParseStorageClass(t *testing.T) {
	tests := []struct {
		storageClassEnv string
		wantSc          StorageClass
		expectedError   error
	}{
		{
			"EC:3",
			StorageClass{
				Parity: 3,
			},
			nil,
		},
		{
			"EC:4",
			StorageClass{
				Parity: 4,
			},
			nil,
		},

	trTests := []struct {
		input string
		err   error
	}{
		{
			input: `<Transition>
			<Days>0</Days>
			<StorageClass>S3TIER-1</StorageClass>
		  </Transition>`,
			err: nil,
		},
		{
			input: `<Transition>
			<Days>1</Days>
			<Date>2021-01-01T00:00:00Z</Date>
			<StorageClass>S3TIER-1</StorageClass>
		  </Transition>`,
			err: errTransitionInvalid,
		},
		{
			input: `<Transition>
			<Days>1</Days>

	object6 := "object6"
	metadata6 := make(map[string]string)
	metadata6["x-amz-storage-class"] = storageclass.STANDARD
	globalStorageClass.Update(storageclass.Config{
		Standard: storageclass.StorageClass{
			Parity: 4,
		},
		RRS: storageclass.StorageClass{
			Parity: 2,
		},
	})

  resources:
    requests:
      storage: {{ .Values.persistence.size | quote }}
  {{- if .Values.persistence.storageClass }}
  {{- if (eq "-" .Values.persistence.storageClass) }}
  storageClassName: ""
  {{- else }}
  storageClassName: "{{ .Values.persistence.storageClass }}"
  {{- end }}
  {{- end }}
  {{- if .Values.persistence.volumeName }}
  volumeName: "{{ .Values.persistence.volumeName }}"
  {{- end }}

			prefix:      "foodir/foobject/foo.txt",
			want:        true,
		},
		{
			inputConfig: `<LifecycleConfiguration><Rule><Status>Enabled</Status><Filter></Filter><NoncurrentVersionTransition><StorageClass>S3TIER-1</StorageClass></NoncurrentVersionTransition></Rule></LifecycleConfiguration>`,

	}
	return nil
}

// NoncurrentVersionTransition - an action for lifecycle configuration rule.
type NoncurrentVersionTransition struct {
	NoncurrentDays TransitionDays `xml:"NoncurrentDays"`
	StorageClass   string         `xml:"StorageClass"`
	set            bool
}

// MarshalXML is extended to leave out
// <NoncurrentVersionTransition></NoncurrentVersionTransition> tags

					events = append(events, Event{
						Action:       TransitionVersionAction,
						RuleID:       rule.ID,
						Due:          due,
						StorageClass: rule.NoncurrentVersionTransition.StorageClass,
					})
				}
			}
		}

		// Remove the object or simply add a delete marker (once) in a versioned bucket
		if obj.IsLatest && !obj.DeleteMarker {
			switch {

// For a given StorageClass, this describes the available capacity in a
// particular topology segment.  This can be used when considering where to
// instantiate new PersistentVolumes.
//
// For example this can express things like:
// - StorageClass "standard" has "1234 GiB" available in "topology.kubernetes.io/zone=us-east1"