fix: lifecycle config can not support multiple LifecycleVersionTransition

oss/client.go

@@ -345,6 +345,14 @@ func (client Client) GetBucketLifecycle(bucketName string) (GetBucketLifecycleRe
 	defer resp.Body.Close()
 
 	err = xmlUnmarshal(resp.Body, &out)
+
+	// NonVersionTransition is not suggested to use
+	// to keep compatible
+	for k, rule := range out.Rules {
+		if len(rule.NonVersionTransitions) > 0 {
+			out.Rules[k].NonVersionTransition = &(out.Rules[k].NonVersionTransitions[0])
+		}
+	}
 	return out, err
 }
 

oss/client_test.go

@@ -1016,6 +1016,104 @@ func (s *OssClientSuite) TestSetBucketLifecycleAboutVersionObject(c *C) {
 	c.Assert(err, IsNil)
 }
 
+// TestSetBucketLifecycleAboutVersionObject
+func (s *OssClientSuite) TestSetBucketLifecycleAboutVersionObjectError(c *C) {
+	var bucketNameTest = bucketNamePrefix + RandLowStr(6)
+
+	client, err := New(endpoint, accessID, accessKey)
+	c.Assert(err, IsNil)
+
+	err = client.CreateBucket(bucketNameTest)
+	c.Assert(err, IsNil)
+
+	deleteMark := true
+	expiration := LifecycleExpiration{
+		ExpiredObjectDeleteMarker: &deleteMark,
+	}
+
+	versionExpiration := LifecycleVersionExpiration{
+		NoncurrentDays: 20,
+	}
+
+	versionTransition := LifecycleVersionTransition{
+		NoncurrentDays: 10,
+		StorageClass:   "IA",
+	}
+
+	// NonVersionTransition and NonVersionTransitions can not both have value
+	rule := LifecycleRule{
+		Status:                "Enabled",
+		Expiration:            &expiration,
+		NonVersionExpiration:  &versionExpiration,
+		NonVersionTransition:  &versionTransition,
+		NonVersionTransitions: []LifecycleVersionTransition{versionTransition},
+	}
+	rules := []LifecycleRule{rule}
+
+	err = client.SetBucketLifecycle(bucketNameTest, rules)
+	c.Assert(err, NotNil)
+
+	err = client.DeleteBucket(bucketNameTest)
+	c.Assert(err, IsNil)
+}
+
+// TestSetBucketLifecycleAboutVersionObject
+func (s *OssClientSuite) TestSetBucketLifecycleAboutVersionObjectNew(c *C) {
+	var bucketNameTest = bucketNamePrefix + RandLowStr(6)
+
+	client, err := New(endpoint, accessID, accessKey)
+	c.Assert(err, IsNil)
+
+	err = client.CreateBucket(bucketNameTest)
+	c.Assert(err, IsNil)
+
+	deleteMark := true
+	expiration := LifecycleExpiration{
+		ExpiredObjectDeleteMarker: &deleteMark,
+	}
+
+	versionExpiration := LifecycleVersionExpiration{
+		NoncurrentDays: 20,
+	}
+
+	versionTransition1 := LifecycleVersionTransition{
+		NoncurrentDays: 10,
+		StorageClass:   "IA",
+	}
+
+	versionTransition2 := LifecycleVersionTransition{
+		NoncurrentDays: 20,
+		StorageClass:   "ColdArchive",
+	}
+
+	rule := LifecycleRule{
+		Status:                "Enabled",
+		Expiration:            &expiration,
+		NonVersionExpiration:  &versionExpiration,
+		NonVersionTransitions: []LifecycleVersionTransition{versionTransition1, versionTransition2},
+	}
+	rules := []LifecycleRule{rule}
+
+	err = client.SetBucketLifecycle(bucketNameTest, rules)
+	c.Assert(err, IsNil)
+
+	res, err := client.GetBucketLifecycle(bucketNameTest)
+	c.Assert(err, IsNil)
+
+	c.Assert(res.Rules[0].Expiration, NotNil)
+	c.Assert(res.Rules[0].Expiration.Days, Equals, 0)
+	c.Assert(res.Rules[0].Expiration.Date, Equals, "")
+	c.Assert(*(res.Rules[0].Expiration.ExpiredObjectDeleteMarker), Equals, true)
+
+	c.Assert(res.Rules[0].NonVersionExpiration.NoncurrentDays, Equals, 20)
+	c.Assert(res.Rules[0].NonVersionTransition.NoncurrentDays, Equals, 10)
+	c.Assert(res.Rules[0].NonVersionTransition.StorageClass, Equals, StorageClassType("IA"))
+	c.Assert(len(res.Rules[0].NonVersionTransitions),Equals, 2)
+
+	err = client.DeleteBucket(bucketNameTest)
+	c.Assert(err, IsNil)
+}
+
 // TestDeleteBucketLifecycle
 func (s *OssClientSuite) TestDeleteBucketLifecycle(c *C) {
 	var bucketNameTest = bucketNamePrefix + RandLowStr(6)

oss/const.go

@@ -224,7 +224,7 @@ const (
 
 	NullVersion = "null"
 
-	Version = "v2.1.3" // Go SDK version
+	Version = "v2.1.4" // Go SDK version
 )
 
 // FrameType

oss/type.go

@@ -44,16 +44,17 @@ type LifecycleConfiguration struct {
 
 // LifecycleRule defines Lifecycle rules
 type LifecycleRule struct {
-	XMLName              xml.Name                       `xml:"Rule"`
-	ID                   string                         `xml:"ID,omitempty"`                   // The rule ID
-	Prefix               string                         `xml:"Prefix"`                         // The object key prefix
-	Status               string                         `xml:"Status"`                         // The rule status (enabled or not)
-	Tags                 []Tag                          `xml:"Tag,omitempty"`                  // the tags property
-	Expiration           *LifecycleExpiration           `xml:"Expiration,omitempty"`           // The expiration property
-	Transitions          []LifecycleTransition          `xml:"Transition,omitempty"`           // The transition property
-	AbortMultipartUpload *LifecycleAbortMultipartUpload `xml:"AbortMultipartUpload,omitempty"` // The AbortMultipartUpload property
-	NonVersionExpiration *LifecycleVersionExpiration    `xml:"NoncurrentVersionExpiration,omitempty"`
-	NonVersionTransition *LifecycleVersionTransition    `xml:"NoncurrentVersionTransition,omitempty"`
+	XMLName               xml.Name                       `xml:"Rule"`
+	ID                    string                         `xml:"ID,omitempty"`                   // The rule ID
+	Prefix                string                         `xml:"Prefix"`                         // The object key prefix
+	Status                string                         `xml:"Status"`                         // The rule status (enabled or not)
+	Tags                  []Tag                          `xml:"Tag,omitempty"`                  // the tags property
+	Expiration            *LifecycleExpiration           `xml:"Expiration,omitempty"`           // The expiration property
+	Transitions           []LifecycleTransition          `xml:"Transition,omitempty"`           // The transition property
+	AbortMultipartUpload  *LifecycleAbortMultipartUpload `xml:"AbortMultipartUpload,omitempty"` // The AbortMultipartUpload property
+	NonVersionExpiration  *LifecycleVersionExpiration    `xml:"NoncurrentVersionExpiration,omitempty"`
+	NonVersionTransition  *LifecycleVersionTransition    `xml:"-"` // NonVersionTransition is not suggested to use
+	NonVersionTransitions []LifecycleVersionTransition   `xml:"NoncurrentVersionTransition,omitempty"`
 }
 
 // LifecycleExpiration defines the rule's expiration property
@@ -121,7 +122,7 @@ func verifyLifecycleRules(rules []LifecycleRule) error {
 	if len(rules) == 0 {
 		return fmt.Errorf("invalid rules, the length of rules is zero")
 	}
-	for _, rule := range rules {
+	for k, rule := range rules {
 		if rule.Status != "Enabled" && rule.Status != "Disabled" {
 			return fmt.Errorf("invalid rule, the value of status must be Enabled or Disabled")
 		}
@@ -135,17 +136,19 @@ func verifyLifecycleRules(rules []LifecycleRule) error {
 
 		transitions := rule.Transitions
 		if len(transitions) > 0 {
-			if len(transitions) > 2 {
-				return fmt.Errorf("invalid count of transition lifecycles, the count must than less than 3")
-			}
-
 			for _, transition := range transitions {
 				if (transition.Days != 0 && transition.CreatedBeforeDate != "") || (transition.Days == 0 && transition.CreatedBeforeDate == "") {
 					return fmt.Errorf("invalid transition lifecycle, must be set one of CreatedBeforeDate and Days")
 				}
 			}
-		} else if rule.Expiration == nil && abortMPU == nil && rule.NonVersionExpiration == nil && rule.NonVersionTransition == nil {
-			return fmt.Errorf("invalid rule, must set one of Expiration, AbortMultipartUplaod, NonVersionExpiration, NonVersionTransition and Transitions")
+		}
+
+		// NonVersionTransition is not suggested to use
+		// to keep compatible
+		if rule.NonVersionTransition != nil && len(rule.NonVersionTransitions) > 0 {
+			return fmt.Errorf("NonVersionTransition and NonVersionTransitions cannot both have values")
+		} else if rule.NonVersionTransition != nil {
+			rules[k].NonVersionTransitions = append(rules[k].NonVersionTransitions, *rule.NonVersionTransition)
 		}
 	}
 

oss/type_test.go

@@ -235,7 +235,7 @@ func (s *OssTypeSuite) TestValidateLifecleRules(c *C) {
 	}
 	rules = []LifecycleRule{rule}
 	err = verifyLifecycleRules(rules)
-	c.Assert(err, NotNil)
+	c.Assert(err, IsNil)
 
 	transition1 := LifecycleTransition{
 		Days:         30,
@@ -257,7 +257,7 @@ func (s *OssTypeSuite) TestValidateLifecleRules(c *C) {
 	}
 	rules = []LifecycleRule{rule}
 	err = verifyLifecycleRules(rules)
-	c.Assert(err, NotNil)
+	c.Assert(err, IsNil)
 
 	rule = LifecycleRule{
 		ID:     "ruleID",
@@ -266,7 +266,7 @@ func (s *OssTypeSuite) TestValidateLifecleRules(c *C) {
 	}
 	rules = []LifecycleRule{rule}
 	err = verifyLifecycleRules(rules)
-	c.Assert(err, NotNil)
+	c.Assert(err, IsNil)
 
 	rules = []LifecycleRule{}
 	err1 := verifyLifecycleRules(rules)