Rename pkg/{tagging,lifecycle} to pkg/bucket sub-directory (#8892)

Rename to allow for more such features to come in a more
proper hierarchical manner.

pkg/bucket/lifecycle/and.go

@@ -0,0 +1,42 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import (
+	"encoding/xml"
+	"errors"
+)
+
+// And - a tag to combine a prefix and multiple tags for lifecycle configuration rule.
+type And struct {
+	XMLName xml.Name `xml:"And"`
+	Prefix  string   `xml:"Prefix,omitempty"`
+	Tags    []Tag    `xml:"Tag,omitempty"`
+}
+
+var errAndUnsupported = errors.New("Specifying <And></And> tag is not supported")
+
+// UnmarshalXML is extended to indicate lack of support for And xml
+// tag in object lifecycle configuration
+func (a And) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	return errAndUnsupported
+}
+
+// MarshalXML is extended to leave out <And></And> tags
+func (a And) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+	return nil
+}

pkg/bucket/lifecycle/expiration.go

@@ -0,0 +1,135 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import (
+	"encoding/xml"
+	"errors"
+	"time"
+)
+
+var (
+	errLifecycleInvalidDate       = errors.New("Date must be provided in ISO 8601 format")
+	errLifecycleInvalidDays       = errors.New("Days must be positive integer when used with Expiration")
+	errLifecycleInvalidExpiration = errors.New("At least one of Days or Date should be present inside Expiration")
+	errLifecycleDateNotMidnight   = errors.New(" 'Date' must be at midnight GMT")
+)
+
+// ExpirationDays is a type alias to unmarshal Days in Expiration
+type ExpirationDays int
+
+// UnmarshalXML parses number of days from Expiration and validates if
+// greater than zero
+func (eDays *ExpirationDays) UnmarshalXML(d *xml.Decoder, startElement xml.StartElement) error {
+	var numDays int
+	err := d.DecodeElement(&numDays, &startElement)
+	if err != nil {
+		return err
+	}
+	if numDays <= 0 {
+		return errLifecycleInvalidDays
+	}
+	*eDays = ExpirationDays(numDays)
+	return nil
+}
+
+// MarshalXML encodes number of days to expire if it is non-zero and
+// encodes empty string otherwise
+func (eDays *ExpirationDays) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
+	if *eDays == ExpirationDays(0) {
+		return nil
+	}
+	return e.EncodeElement(int(*eDays), startElement)
+}
+
+// ExpirationDate is a embedded type containing time.Time to unmarshal
+// Date in Expiration
+type ExpirationDate struct {
+	time.Time
+}
+
+// UnmarshalXML parses date from Expiration and validates date format
+func (eDate *ExpirationDate) UnmarshalXML(d *xml.Decoder, startElement xml.StartElement) error {
+	var dateStr string
+	err := d.DecodeElement(&dateStr, &startElement)
+	if err != nil {
+		return err
+	}
+	// While AWS documentation mentions that the date specified
+	// must be present in ISO 8601 format, in reality they allow
+	// users to provide RFC 3339 compliant dates.
+	expDate, err := time.Parse(time.RFC3339, dateStr)
+	if err != nil {
+		return errLifecycleInvalidDate
+	}
+	// Allow only date timestamp specifying midnight GMT
+	hr, min, sec := expDate.Clock()
+	nsec := expDate.Nanosecond()
+	loc := expDate.Location()
+	if !(hr == 0 && min == 0 && sec == 0 && nsec == 0 && loc.String() == time.UTC.String()) {
+		return errLifecycleDateNotMidnight
+	}
+
+	*eDate = ExpirationDate{expDate}
+	return nil
+}
+
+// MarshalXML encodes expiration date if it is non-zero and encodes
+// empty string otherwise
+func (eDate *ExpirationDate) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
+	if *eDate == (ExpirationDate{time.Time{}}) {
+		return nil
+	}
+	return e.EncodeElement(eDate.Format(time.RFC3339), startElement)
+}
+
+// Expiration - expiration actions for a rule in lifecycle configuration.
+type Expiration struct {
+	XMLName xml.Name       `xml:"Expiration"`
+	Days    ExpirationDays `xml:"Days,omitempty"`
+	Date    ExpirationDate `xml:"Date,omitempty"`
+}
+
+// Validate - validates the "Expiration" element
+func (e Expiration) Validate() error {
+	// Neither expiration days or date is specified
+	if e.IsDaysNull() && e.IsDateNull() {
+		return errLifecycleInvalidExpiration
+	}
+
+	// Both expiration days and date are specified
+	if !e.IsDaysNull() && !e.IsDateNull() {
+		return errLifecycleInvalidExpiration
+	}
+	return nil
+}
+
+// IsDaysNull returns true if days field is null
+func (e Expiration) IsDaysNull() bool {
+	return e.Days == ExpirationDays(0)
+
+}
+
+// IsDateNull returns true if date field is null
+func (e Expiration) IsDateNull() bool {
+	return e.Date == ExpirationDate{time.Time{}}
+}
+
+// IsNull returns true if both date and days fields are null
+func (e Expiration) IsNull() bool {
+	return e.IsDaysNull() && e.IsDateNull()
+}

pkg/bucket/lifecycle/expiration_test.go

@@ -0,0 +1,105 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import (
+	"encoding/xml"
+	"fmt"
+	"testing"
+)
+
+// appropriate errors on validation
+func TestInvalidExpiration(t *testing.T) {
+	testCases := []struct {
+		inputXML    string
+		expectedErr error
+	}{
+		{ // Expiration with zero days
+			inputXML: ` <Expiration>
+                                    <Days>0</Days>
+                                    </Expiration>`,
+			expectedErr: errLifecycleInvalidDays,
+		},
+		{ // Expiration with invalid date
+			inputXML: ` <Expiration>
+                                    <Date>invalid date</Date>
+                                    </Expiration>`,
+			expectedErr: errLifecycleInvalidDate,
+		},
+		{ // Expiration with both number of days nor a date
+			inputXML: `<Expiration>
+		                    <Date>2019-04-20T00:01:00Z</Date>
+		                    </Expiration>`,
+			expectedErr: errLifecycleDateNotMidnight,
+		},
+	}
+
+	for i, tc := range testCases {
+		t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) {
+			var expiration Expiration
+			err := xml.Unmarshal([]byte(tc.inputXML), &expiration)
+			if err != tc.expectedErr {
+				t.Fatalf("%d: Expected %v but got %v", i+1, tc.expectedErr, err)
+			}
+		})
+
+	}
+
+	validationTestCases := []struct {
+		inputXML    string
+		expectedErr error
+	}{
+		{ // Expiration with a valid ISO 8601 date
+			inputXML: `<Expiration>
+                                    <Date>2019-04-20T00:00:00Z</Date>
+                                    </Expiration>`,
+			expectedErr: nil,
+		},
+		{ // Expiration with a valid number of days
+			inputXML: `<Expiration>
+                                    <Days>3</Days>
+                                    </Expiration>`,
+			expectedErr: nil,
+		},
+		{ // Expiration with neither number of days nor a date
+			inputXML: `<Expiration>
+                                    </Expiration>`,
+			expectedErr: errLifecycleInvalidExpiration,
+		},
+		{ // Expiration with both number of days nor a date
+			inputXML: `<Expiration>
+                                    <Days>3</Days>
+                                    <Date>2019-04-20T00:00:00Z</Date>
+                                    </Expiration>`,
+			expectedErr: errLifecycleInvalidExpiration,
+		},
+	}
+	for i, tc := range validationTestCases {
+		t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) {
+			var expiration Expiration
+			err := xml.Unmarshal([]byte(tc.inputXML), &expiration)
+			if err != nil {
+				t.Fatalf("%d: %v", i+1, err)
+			}
+
+			err = expiration.Validate()
+			if err != tc.expectedErr {
+				t.Fatalf("%d: %v", i+1, err)
+			}
+		})
+	}
+}

pkg/bucket/lifecycle/filter.go

@@ -0,0 +1,32 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import "encoding/xml"
+
+// Filter - a filter for a lifecycle configuration Rule.
+type Filter struct {
+	XMLName xml.Name `xml:"Filter"`
+	And     And      `xml:"And,omitempty"`
+	Prefix  string   `xml:"Prefix"`
+	Tag     Tag      `xml:"Tag,omitempty"`
+}
+
+// Validate - validates the filter element
+func (f Filter) Validate() error {
+	return nil
+}

pkg/bucket/lifecycle/filter_test.go

@@ -0,0 +1,56 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import (
+	"encoding/xml"
+	"fmt"
+	"testing"
+)
+
+// TestUnsupportedFilters checks if parsing Filter xml with
+// unsupported elements returns appropriate errors
+func TestUnsupportedFilters(t *testing.T) {
+	testCases := []struct {
+		inputXML    string
+		expectedErr error
+	}{
+		{ // Filter with And tags
+			inputXML: ` <Filter>
+	                     <And>
+	                     <Prefix></Prefix>
+	                     </And>
+	                    </Filter>`,
+			expectedErr: errAndUnsupported,
+		},
+		{ // Filter with Tag tags
+			inputXML: ` <Filter>
+	                     <Tag></Tag>
+	                    </Filter>`,
+			expectedErr: errTagUnsupported,
+		},
+	}
+	for i, tc := range testCases {
+		t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) {
+			var filter Filter
+			err := xml.Unmarshal([]byte(tc.inputXML), &filter)
+			if err != tc.expectedErr {
+				t.Fatalf("%d: Expected %v but got %v", i+1, tc.expectedErr, err)
+			}
+		})
+	}
+}

pkg/bucket/lifecycle/lifecycle.go

@@ -0,0 +1,130 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import (
+	"encoding/xml"
+	"errors"
+	"io"
+	"strings"
+	"time"
+)
+
+var (
+	errLifecycleTooManyRules      = errors.New("Lifecycle configuration allows a maximum of 1000 rules")
+	errLifecycleNoRule            = errors.New("Lifecycle configuration should have at least one rule")
+	errLifecycleOverlappingPrefix = errors.New("Lifecycle configuration has rules with overlapping prefix")
+)
+
+// Action represents a delete action or other transition
+// actions that will be implemented later.
+type Action int
+
+const (
+	// NoneAction means no action required after evaluting lifecycle rules
+	NoneAction Action = iota
+	// DeleteAction means the object needs to be removed after evaluting lifecycle rules
+	DeleteAction
+)
+
+// Lifecycle - Configuration for bucket lifecycle.
+type Lifecycle struct {
+	XMLName xml.Name `xml:"LifecycleConfiguration"`
+	Rules   []Rule   `xml:"Rule"`
+}
+
+// IsEmpty - returns whether policy is empty or not.
+func (lc Lifecycle) IsEmpty() bool {
+	return len(lc.Rules) == 0
+}
+
+// ParseLifecycleConfig - parses data in given reader to Lifecycle.
+func ParseLifecycleConfig(reader io.Reader) (*Lifecycle, error) {
+	var lc Lifecycle
+	if err := xml.NewDecoder(reader).Decode(&lc); err != nil {
+		return nil, err
+	}
+	if err := lc.Validate(); err != nil {
+		return nil, err
+	}
+	return &lc, nil
+}
+
+// Validate - validates the lifecycle configuration
+func (lc Lifecycle) Validate() error {
+	// Lifecycle config can't have more than 1000 rules
+	if len(lc.Rules) > 1000 {
+		return errLifecycleTooManyRules
+	}
+	// Lifecycle config should have at least one rule
+	if len(lc.Rules) == 0 {
+		return errLifecycleNoRule
+	}
+	// Validate all the rules in the lifecycle config
+	for _, r := range lc.Rules {
+		if err := r.Validate(); err != nil {
+			return err
+		}
+	}
+	// Compare every rule's prefix with every other rule's prefix
+	for i := range lc.Rules {
+		if i == len(lc.Rules)-1 {
+			break
+		}
+		// N B Empty prefixes overlap with all prefixes
+		otherRules := lc.Rules[i+1:]
+		for _, otherRule := range otherRules {
+			if strings.HasPrefix(lc.Rules[i].Filter.Prefix, otherRule.Filter.Prefix) ||
+				strings.HasPrefix(otherRule.Filter.Prefix, lc.Rules[i].Filter.Prefix) {
+				return errLifecycleOverlappingPrefix
+			}
+		}
+	}
+	return nil
+}
+
+// FilterRuleActions returns the expiration and transition from the object name
+// after evaluating all rules.
+func (lc Lifecycle) FilterRuleActions(objName string) (Expiration, Transition) {
+	for _, rule := range lc.Rules {
+		if strings.ToLower(rule.Status) != "enabled" {
+			continue
+		}
+		if strings.HasPrefix(objName, rule.Filter.Prefix) {
+			return rule.Expiration, Transition{}
+		}
+	}
+	return Expiration{}, Transition{}
+}
+
+// ComputeAction returns the action to perform by evaluating all lifecycle rules
+// against the object name and its modification time.
+func (lc Lifecycle) ComputeAction(objName string, modTime time.Time) Action {
+	var action = NoneAction
+	exp, _ := lc.FilterRuleActions(objName)
+	if !exp.IsDateNull() {
+		if time.Now().After(exp.Date.Time) {
+			action = DeleteAction
+		}
+	}
+	if !exp.IsDaysNull() {
+		if time.Now().After(modTime.Add(time.Duration(exp.Days) * 24 * time.Hour)) {
+			action = DeleteAction
+		}
+	}
+	return action
+}

pkg/bucket/lifecycle/lifecycle_test.go

@@ -0,0 +1,230 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import (
+	"bytes"
+	"encoding/xml"
+	"fmt"
+	"testing"
+	"time"
+)
+
+func TestParseLifecycleConfig(t *testing.T) {
+	// Test for  lifecycle config with more than 1000 rules
+	var manyRules []Rule
+	rule := Rule{
+		Status:     "Enabled",
+		Expiration: Expiration{Days: ExpirationDays(3)},
+	}
+	for i := 0; i < 1001; i++ {
+		manyRules = append(manyRules, rule)
+	}
+
+	manyRuleLcConfig, err := xml.Marshal(Lifecycle{Rules: manyRules})
+	if err != nil {
+		t.Fatal("Failed to marshal lifecycle config with more than 1000 rules")
+	}
+
+	// Test for lifecycle config with rules containing overlapping prefixes
+	rule1 := Rule{
+		Status:     "Enabled",
+		Expiration: Expiration{Days: ExpirationDays(3)},
+		Filter: Filter{
+			Prefix: "/a/b",
+		},
+	}
+	rule2 := Rule{
+		Status:     "Enabled",
+		Expiration: Expiration{Days: ExpirationDays(3)},
+		Filter: Filter{
+			Prefix: "/a/b/c",
+		},
+	}
+	overlappingRules := []Rule{rule1, rule2}
+	overlappingLcConfig, err := xml.Marshal(Lifecycle{Rules: overlappingRules})
+	if err != nil {
+		t.Fatal("Failed to marshal lifecycle config with rules having overlapping prefix")
+	}
+
+	testCases := []struct {
+		inputConfig string
+		expectedErr error
+	}{
+		{ // Valid lifecycle config
+			inputConfig: `<LifecycleConfiguration>
+	                              <Rule>
+	                              <Filter>
+	                                 <Prefix>prefix</Prefix>
+	                              </Filter>
+	                              <Status>Enabled</Status>
+	                              <Expiration><Days>3</Days></Expiration>
+	                              </Rule>
+                                      <Rule>
+	                              <Filter>
+	                                 <Prefix>another-prefix</Prefix>
+	                              </Filter>
+	                              <Status>Enabled</Status>
+	                              <Expiration><Days>3</Days></Expiration>
+	                              </Rule>
+	                              </LifecycleConfiguration>`,
+			expectedErr: nil,
+		},
+		{ // lifecycle config with no rules
+			inputConfig: `<LifecycleConfiguration>
+	                              </LifecycleConfiguration>`,
+			expectedErr: errLifecycleNoRule,
+		},
+		{ // lifecycle config with more than 1000 rules
+			inputConfig: string(manyRuleLcConfig),
+			expectedErr: errLifecycleTooManyRules,
+		},
+		{ // lifecycle config with rules having overlapping prefix
+			inputConfig: string(overlappingLcConfig),
+			expectedErr: errLifecycleOverlappingPrefix,
+		},
+	}
+
+	for i, tc := range testCases {
+		t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) {
+			var err error
+			if _, err = ParseLifecycleConfig(bytes.NewReader([]byte(tc.inputConfig))); err != tc.expectedErr {
+				t.Fatalf("%d: Expected %v but got %v", i+1, tc.expectedErr, err)
+			}
+
+		})
+
+	}
+}
+
+// TestMarshalLifecycleConfig checks if lifecycleconfig xml
+// marshaling/unmarshaling can handle output from each other
+func TestMarshalLifecycleConfig(t *testing.T) {
+	// Time at midnight UTC
+	midnightTS := ExpirationDate{time.Date(2019, time.April, 20, 0, 0, 0, 0, time.UTC)}
+	lc := Lifecycle{
+		Rules: []Rule{
+			{
+				Status:     "Enabled",
+				Filter:     Filter{Prefix: "prefix-1"},
+				Expiration: Expiration{Days: ExpirationDays(3)},
+			},
+			{
+				Status:     "Enabled",
+				Filter:     Filter{Prefix: "prefix-1"},
+				Expiration: Expiration{Date: ExpirationDate(midnightTS)},
+			},
+		},
+	}
+	b, err := xml.MarshalIndent(&lc, "", "\t")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var lc1 Lifecycle
+	err = xml.Unmarshal(b, &lc1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ruleSet := make(map[string]struct{})
+	for _, rule := range lc.Rules {
+		ruleBytes, err := xml.Marshal(rule)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ruleSet[string(ruleBytes)] = struct{}{}
+	}
+	for _, rule := range lc1.Rules {
+		ruleBytes, err := xml.Marshal(rule)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, ok := ruleSet[string(ruleBytes)]; !ok {
+			t.Fatalf("Expected %v to be equal to %v, %v missing", lc, lc1, rule)
+		}
+	}
+}
+
+func TestComputeActions(t *testing.T) {
+	testCases := []struct {
+		inputConfig    string
+		objectName     string
+		objectModTime  time.Time
+		expectedAction Action
+	}{
+		// Empty object name (unexpected case) should always return NoneAction
+		{
+			inputConfig:    `<LifecycleConfiguration><Rule><Filter><Prefix>prefix</Prefix></Filter><Status>Enabled</Status><Expiration><Days>5</Days></Expiration></Rule></LifecycleConfiguration>`,
+			expectedAction: NoneAction,
+		},
+		// Disabled should always return NoneAction
+		{
+			inputConfig:    `<LifecycleConfiguration><Rule><Filter><Prefix>foodir/</Prefix></Filter><Status>Disabled</Status><Expiration><Days>5</Days></Expiration></Rule></LifecycleConfiguration>`,
+			objectName:     "foodir/fooobject",
+			objectModTime:  time.Now().UTC().Add(-10 * 24 * time.Hour), // Created 10 days ago
+			expectedAction: NoneAction,
+		},
+		// Prefix not matched
+		{
+			inputConfig:    `<LifecycleConfiguration><Rule><Filter><Prefix>foodir/</Prefix></Filter><Status>Enabled</Status><Expiration><Days>5</Days></Expiration></Rule></LifecycleConfiguration>`,
+			objectName:     "foxdir/fooobject",
+			objectModTime:  time.Now().UTC().Add(-10 * 24 * time.Hour), // Created 10 days ago
+			expectedAction: NoneAction,
+		},
+		// Too early to remove (test Days)
+		{
+			inputConfig:    `<LifecycleConfiguration><Rule><Filter><Prefix>foodir/</Prefix></Filter><Status>Enabled</Status><Expiration><Days>5</Days></Expiration></Rule></LifecycleConfiguration>`,
+			objectName:     "foxdir/fooobject",
+			objectModTime:  time.Now().UTC().Add(-10 * 24 * time.Hour), // Created 10 days ago
+			expectedAction: NoneAction,
+		},
+		// Should remove (test Days)
+		{
+			inputConfig:    `<LifecycleConfiguration><Rule><Filter><Prefix>foodir/</Prefix></Filter><Status>Enabled</Status><Expiration><Days>5</Days></Expiration></Rule></LifecycleConfiguration>`,
+			objectName:     "foodir/fooobject",
+			objectModTime:  time.Now().UTC().Add(-6 * 24 * time.Hour), // Created 6 days ago
+			expectedAction: DeleteAction,
+		},
+		// Too early to remove (test Date)
+		{
+			inputConfig:    `<LifecycleConfiguration><Rule><Filter><Prefix>foodir/</Prefix></Filter><Status>Enabled</Status><Expiration><Date>` + time.Now().Truncate(24*time.Hour).UTC().Add(24*time.Hour).Format(time.RFC3339) + `</Date></Expiration></Rule></LifecycleConfiguration>`,
+			objectName:     "foodir/fooobject",
+			objectModTime:  time.Now().UTC().Add(-24 * time.Hour), // Created 1 day ago
+			expectedAction: NoneAction,
+		},
+		// Should remove (test Days)
+		{
+			inputConfig:    `<LifecycleConfiguration><Rule><Filter><Prefix>foodir/</Prefix></Filter><Status>Enabled</Status><Expiration><Date>` + time.Now().Truncate(24*time.Hour).UTC().Add(-24*time.Hour).Format(time.RFC3339) + `</Date></Expiration></Rule></LifecycleConfiguration>`,
+			objectName:     "foodir/fooobject",
+			objectModTime:  time.Now().UTC().Add(-24 * time.Hour), // Created 1 day ago
+			expectedAction: DeleteAction,
+		},
+	}
+
+	for i, tc := range testCases {
+		t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) {
+			lc, err := ParseLifecycleConfig(bytes.NewReader([]byte(tc.inputConfig)))
+			if err != nil {
+				t.Fatalf("%d: Got unexpected error: %v", i+1, err)
+			}
+			if resultAction := lc.ComputeAction(tc.objectName, tc.objectModTime); resultAction != tc.expectedAction {
+				t.Fatalf("%d: Expected action: `%v`, got: `%v`", i+1, tc.expectedAction, resultAction)
+			}
+		})
+
+	}
+}

pkg/bucket/lifecycle/noncurrentversion.go

@@ -0,0 +1,65 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import (
+	"encoding/xml"
+	"errors"
+)
+
+// NoncurrentVersionExpiration - an action for lifecycle configuration rule.
+type NoncurrentVersionExpiration struct {
+	XMLName        xml.Name `xml:"NoncurrentVersionExpiration"`
+	NoncurrentDays int      `xml:"NoncurrentDays,omitempty"`
+}
+
+// NoncurrentVersionTransition - an action for lifecycle configuration rule.
+type NoncurrentVersionTransition struct {
+	NoncurrentDays int    `xml:"NoncurrentDays"`
+	StorageClass   string `xml:"StorageClass"`
+}
+
+var (
+	errNoncurrentVersionExpirationUnsupported = errors.New("Specifying <NoncurrentVersionExpiration></NoncurrentVersionExpiration> is not supported")
+	errNoncurrentVersionTransitionUnsupported = errors.New("Specifying <NoncurrentVersionTransition></NoncurrentVersionTransition> is not supported")
+)
+
+// UnmarshalXML is extended to indicate lack of support for
+// NoncurrentVersionExpiration xml tag in object lifecycle
+// configuration
+func (n NoncurrentVersionExpiration) UnmarshalXML(d *xml.Decoder, startElement xml.StartElement) error {
+	return errNoncurrentVersionExpirationUnsupported
+}
+
+// UnmarshalXML is extended to indicate lack of support for
+// NoncurrentVersionTransition xml tag in object lifecycle
+// configuration
+func (n NoncurrentVersionTransition) UnmarshalXML(d *xml.Decoder, startElement xml.StartElement) error {
+	return errNoncurrentVersionTransitionUnsupported
+}
+
+// MarshalXML is extended to leave out
+// <NoncurrentVersionTransition></NoncurrentVersionTransition> tags
+func (n NoncurrentVersionTransition) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+	return nil
+}
+
+// MarshalXML is extended to leave out
+// <NoncurrentVersionExpiration></NoncurrentVersionExpiration> tags
+func (n NoncurrentVersionExpiration) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+	return nil
+}

pkg/bucket/lifecycle/rule.go

@@ -0,0 +1,86 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import (
+	"encoding/xml"
+	"errors"
+)
+
+// Rule - a rule for lifecycle configuration.
+type Rule struct {
+	XMLName    xml.Name   `xml:"Rule"`
+	ID         string     `xml:"ID,omitempty"`
+	Status     string     `xml:"Status"`
+	Filter     Filter     `xml:"Filter"`
+	Expiration Expiration `xml:"Expiration,omitempty"`
+	Transition Transition `xml:"Transition,omitempty"`
+	// FIXME: add a type to catch unsupported AbortIncompleteMultipartUpload AbortIncompleteMultipartUpload `xml:"AbortIncompleteMultipartUpload,omitempty"`
+	NoncurrentVersionExpiration NoncurrentVersionExpiration `xml:"NoncurrentVersionExpiration,omitempty"`
+	NoncurrentVersionTransition NoncurrentVersionTransition `xml:"NoncurrentVersionTransition,omitempty"`
+}
+
+var (
+	errInvalidRuleID           = errors.New("ID must be less than 255 characters")
+	errEmptyRuleStatus         = errors.New("Status should not be empty")
+	errInvalidRuleStatus       = errors.New("Status must be set to either Enabled or Disabled")
+	errMissingExpirationAction = errors.New("No expiration action found")
+)
+
+// isIDValid - checks if ID is valid or not.
+func (r Rule) validateID() error {
+	// cannot be longer than 255 characters
+	if len(string(r.ID)) > 255 {
+		return errInvalidRuleID
+	}
+	return nil
+}
+
+// isStatusValid - checks if status is valid or not.
+func (r Rule) validateStatus() error {
+	// Status can't be empty
+	if len(r.Status) == 0 {
+		return errEmptyRuleStatus
+	}
+
+	// Status must be one of Enabled or Disabled
+	if r.Status != "Enabled" && r.Status != "Disabled" {
+		return errInvalidRuleStatus
+	}
+	return nil
+}
+
+func (r Rule) validateAction() error {
+	if r.Expiration == (Expiration{}) {
+		return errMissingExpirationAction
+	}
+	return nil
+}
+
+// Validate - validates the rule element
+func (r Rule) Validate() error {
+	if err := r.validateID(); err != nil {
+		return err
+	}
+	if err := r.validateStatus(); err != nil {
+		return err
+	}
+	if err := r.validateAction(); err != nil {
+		return err
+	}
+	return nil
+}

pkg/bucket/lifecycle/rule_test.go

@@ -0,0 +1,112 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import (
+	"encoding/xml"
+	"fmt"
+	"testing"
+)
+
+// TestUnsupportedRules checks if Rule xml with unsuported tags return
+// appropriate errors on parsing
+func TestUnsupportedRules(t *testing.T) {
+	// NoncurrentVersionTransition, NoncurrentVersionExpiration
+	// and Transition tags aren't supported
+	unsupportedTestCases := []struct {
+		inputXML    string
+		expectedErr error
+	}{
+		{ // Rule with unsupported NoncurrentVersionTransition
+			inputXML: ` <Rule>
+	                     <NoncurrentVersionTransition></NoncurrentVersionTransition>
+	                    </Rule>`,
+			expectedErr: errNoncurrentVersionTransitionUnsupported,
+		},
+		{ // Rule with unsupported NoncurrentVersionExpiration
+
+			inputXML: ` <Rule>
+	                     <NoncurrentVersionExpiration></NoncurrentVersionExpiration>
+	                    </Rule>`,
+			expectedErr: errNoncurrentVersionExpirationUnsupported,
+		},
+		{ // Rule with unsupported Transition action
+			inputXML: ` <Rule>
+	                     <Transition></Transition>
+	                    </Rule>`,
+			expectedErr: errTransitionUnsupported,
+		},
+	}
+
+	for i, tc := range unsupportedTestCases {
+		t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) {
+			var rule Rule
+			err := xml.Unmarshal([]byte(tc.inputXML), &rule)
+			if err != tc.expectedErr {
+				t.Fatalf("%d: Expected %v but got %v", i+1, tc.expectedErr, err)
+			}
+		})
+	}
+}
+
+// TestInvalidRules checks if Rule xml with invalid elements returns
+// appropriate errors on validation
+func TestInvalidRules(t *testing.T) {
+	invalidTestCases := []struct {
+		inputXML    string
+		expectedErr error
+	}{
+		{ // Rule without expiration action
+			inputXML: ` <Rule>
+                            <Status>Enabled</Status>
+	                    </Rule>`,
+			expectedErr: errMissingExpirationAction,
+		},
+		{ // Rule with ID longer than 255 characters
+			inputXML: ` <Rule>
+	                    <ID> babababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab </ID>
+	                    </Rule>`,
+			expectedErr: errInvalidRuleID,
+		},
+		{ // Rule with empty status
+			inputXML: ` <Rule>
+                              <Status></Status>
+	                    </Rule>`,
+			expectedErr: errEmptyRuleStatus,
+		},
+		{ // Rule with invalid status
+			inputXML: ` <Rule>
+                              <Status>OK</Status>
+	                    </Rule>`,
+			expectedErr: errInvalidRuleStatus,
+		},
+	}
+
+	for i, tc := range invalidTestCases {
+		t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) {
+			var rule Rule
+			err := xml.Unmarshal([]byte(tc.inputXML), &rule)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			if err := rule.Validate(); err != tc.expectedErr {
+				t.Fatalf("%d: Expected %v but got %v", i+1, tc.expectedErr, err)
+			}
+		})
+	}
+}

pkg/bucket/lifecycle/tag.go

@@ -0,0 +1,42 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import (
+	"encoding/xml"
+	"errors"
+)
+
+// Tag - a tag for a lifecycle configuration Rule filter.
+type Tag struct {
+	XMLName xml.Name `xml:"Tag"`
+	Key     string   `xml:"Key,omitempty"`
+	Value   string   `xml:"Value,omitempty"`
+}
+
+var errTagUnsupported = errors.New("Specifying <Tag></Tag> is not supported")
+
+// UnmarshalXML is extended to indicate lack of support for Tag
+// xml tag in object lifecycle configuration
+func (t Tag) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	return errTagUnsupported
+}
+
+// MarshalXML is extended to leave out <Tag></Tag> tags
+func (t Tag) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+	return nil
+}

pkg/bucket/lifecycle/transition.go

@@ -0,0 +1,43 @@
+/*
+ * MinIO Cloud Storage, (C) 2019 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package lifecycle
+
+import (
+	"encoding/xml"
+	"errors"
+)
+
+// Transition - transition actions for a rule in lifecycle configuration.
+type Transition struct {
+	XMLName      xml.Name `xml:"Transition"`
+	Days         int      `xml:"Days,omitempty"`
+	Date         string   `xml:"Date,omitempty"`
+	StorageClass string   `xml:"StorageClass"`
+}
+
+var errTransitionUnsupported = errors.New("Specifying <Transition></Transition> tag is not supported")
+
+// UnmarshalXML is extended to indicate lack of support for Transition
+// xml tag in object lifecycle configuration
+func (t Transition) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
+	return errTransitionUnsupported
+}
+
+// MarshalXML is extended to leave out <Transition></Transition> tags
+func (t Transition) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
+	return nil
+}