Create lifecycle rules using the NewLifecycleRule method

oss/client_test.go

@@ -655,15 +655,9 @@ func (s *OssClientSuite) TestSetBucketLifecycle(c *C) {
 	c.Assert(err, IsNil)
 }
 
-// TestSetBucketLifecycle
+// TestSetBucketLifecycleNew
 func (s *OssClientSuite) TestSetBucketLifecycleNew(c *C) {
 	var bucketNameTest = bucketNamePrefix + randLowStr(6)
-	rule1, err := NewLifecycleRuleByCreateBeforeDate("rule1", "one", true, 2015, 11, 11, LRTExpriration)
-	c.Assert(err, IsNil)
-	rule2, err := NewLifecycleRuleByDays("rule2", "two", true, 3, LRTAbortMultiPartUpload)
-	c.Assert(err, IsNil)
-	rule3, err := NewLifecycleRuleByDays("rule3", "three", true, 3, LRTTransition, StorageIA)
-	c.Assert(err, IsNil)
 
 	client, err := New(endpoint, accessID, accessKey)
 	c.Assert(err, IsNil)
@@ -671,11 +665,48 @@ func (s *OssClientSuite) TestSetBucketLifecycleNew(c *C) {
 	err = client.CreateBucket(bucketNameTest)
 	c.Assert(err, IsNil)
 
-	// Set single rule
-	var rules = []LifecycleRule{*rule1}
+	expiration := LifecycleExpiration{
+		CreatedBeforeDate: randStr(10),
+	}
+	rule, err := NewLifecycleRule("rule1", "one", true, &expiration, nil)
+	c.Assert(err, IsNil)
+	rules := []LifecycleRule{*rule}
+	err = client.SetBucketLifecycle(bucketNameTest, rules)
+	c.Assert(err, NotNil)
+
+	abortMPU := LifecycleAbortMultipartUpload{
+		Days: -30,
+	}
+	rule, err = NewLifecycleRule("rule2", "two", true, nil, &abortMPU)
+	c.Assert(err, IsNil)
+	rules = []LifecycleRule{*rule}
 	err = client.SetBucketLifecycle(bucketNameTest, rules)
+	c.Assert(err, NotNil)
+
+	expiration = LifecycleExpiration{
+		CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
+	}
+	rule1, err := NewLifecycleRule("rule1", "one", true, &expiration, nil)
 	c.Assert(err, IsNil)
-	// Double set rule
+	abortMPU = LifecycleAbortMultipartUpload{
+		Days: 30,
+	}
+	rule2, err := NewLifecycleRule("rule2", "two", true, &expiration, &abortMPU)
+	c.Assert(err, IsNil)
+
+	transition1 := LifecycleTransition{
+		Days:         3,
+		StorageClass: StorageIA,
+	}
+	transition2 := LifecycleTransition{
+		Days:         30,
+		StorageClass: StorageArchive,
+	}
+	rule3, err := NewLifecycleRule("rule3", "three", true, nil, &abortMPU, &transition1, &transition2)
+	c.Assert(err, IsNil)
+
+	// Set single rule
+	rules = []LifecycleRule{*rule1}
 	err = client.SetBucketLifecycle(bucketNameTest, rules)
 	c.Assert(err, IsNil)
 
@@ -684,27 +715,35 @@ func (s *OssClientSuite) TestSetBucketLifecycleNew(c *C) {
 	c.Assert(len(res.Rules), Equals, 1)
 	c.Assert(res.Rules[0].ID, Equals, "rule1")
 	c.Assert(res.Rules[0].Expiration, NotNil)
+	c.Assert(res.Rules[0].Expiration.CreatedBeforeDate, Equals, "2015-11-11T00:00:00.000Z")
 
 	err = client.DeleteBucketLifecycle(bucketNameTest)
 	c.Assert(err, IsNil)
 
-	// Set two rules
+	// Set three rules
 	rules = []LifecycleRule{*rule1, *rule2, *rule3}
 	err = client.SetBucketLifecycle(bucketNameTest, rules)
 	c.Assert(err, IsNil)
 
-	// Eliminate effect of cache
-	time.Sleep(timeoutInOperation)
-
 	res, err = client.GetBucketLifecycle(bucketNameTest)
 	c.Assert(err, IsNil)
 	c.Assert(len(res.Rules), Equals, 3)
 	c.Assert(res.Rules[0].ID, Equals, "rule1")
 	c.Assert(res.Rules[0].Expiration, NotNil)
+	c.Assert(res.Rules[0].Expiration.CreatedBeforeDate, Equals, "2015-11-11T00:00:00.000Z")
 	c.Assert(res.Rules[1].ID, Equals, "rule2")
+	c.Assert(res.Rules[1].Expiration, NotNil)
+	c.Assert(res.Rules[1].Expiration.CreatedBeforeDate, Equals, "2015-11-11T00:00:00.000Z")
 	c.Assert(res.Rules[1].AbortMultipartUpload, NotNil)
+	c.Assert(res.Rules[1].AbortMultipartUpload.Days, Equals, 30)
 	c.Assert(res.Rules[2].ID, Equals, "rule3")
+	c.Assert(res.Rules[2].AbortMultipartUpload, NotNil)
+	c.Assert(res.Rules[2].AbortMultipartUpload.Days, Equals, 30)
 	c.Assert(res.Rules[2].Transition, NotNil)
+	c.Assert(res.Rules[2].Transition[0].StorageClass, Equals, StorageIA)
+	c.Assert(res.Rules[2].Transition[0].Days, Equals, 3)
+	c.Assert(res.Rules[2].Transition[1].StorageClass, Equals, StorageArchive)
+	c.Assert(res.Rules[2].Transition[1].Days, Equals, 30)
 
 	err = client.DeleteBucket(bucketNameTest)
 	c.Assert(err, IsNil)
@@ -723,14 +762,14 @@ func (s *OssClientSuite) TestDeleteBucketLifecycle(c *C) {
 
 	err = client.CreateBucket(bucketNameTest)
 	c.Assert(err, IsNil)
-	time.Sleep(timeoutInOperation)
+	//time.Sleep(timeoutInOperation)
 
 	err = client.DeleteBucketLifecycle(bucketNameTest)
 	c.Assert(err, IsNil)
 
 	err = client.SetBucketLifecycle(bucketNameTest, rules)
 	c.Assert(err, IsNil)
-	time.Sleep(timeoutInOperation)
+	//time.Sleep(timeoutInOperation)
 
 	res, err := client.GetBucketLifecycle(bucketNameTest)
 	c.Assert(err, IsNil)
@@ -740,12 +779,12 @@ func (s *OssClientSuite) TestDeleteBucketLifecycle(c *C) {
 	err = client.DeleteBucketLifecycle(bucketNameTest)
 	c.Assert(err, IsNil)
 
-	time.Sleep(timeoutInOperation)
+	//time.Sleep(timeoutInOperation)
 	res, err = client.GetBucketLifecycle(bucketNameTest)
 	c.Assert(err, NotNil)
 
 	// Eliminate effect of cache
-	time.Sleep(timeoutInOperation)
+	//time.Sleep(timeoutInOperation)
 
 	// Delete when not set
 	err = client.DeleteBucketLifecycle(bucketNameTest)

oss/const.go

@@ -72,18 +72,6 @@ const (
 	HTTPDelete HTTPMethod = "DELETE"
 )
 
-// LifecycleRuleType rule type of lifecycle
-type LifecycleRuleType string
-
-const (
-	// LRTExpriration Expriation
-	LRTExpriration LifecycleRuleType = "Expriation"
-	// LRTTransition Transition
-	LRTTransition LifecycleRuleType = "Transition"
-	// LRTAbortMultiPartUpload AbortMultiPartUpload
-	LRTAbortMultiPartUpload LifecycleRuleType = "AbortMultiPartUpload"
-)
-
 // HTTP headers
 const (
 	HTTPHeaderAcceptEncoding     string = "Accept-Encoding"

oss/type.go

@@ -48,35 +48,31 @@ type LifecycleRule struct {
 	Prefix               string                         `xml:"Prefix"`                         // The object key prefix
 	Status               string                         `xml:"Status"`                         // The rule status (enabled or not)
 	Expiration           *LifecycleExpiration           `xml:"Expiration,omitempty"`           // The expiration property
-	Transition           *LifecycleTransition           `xml:"Transition,omitempty"`           // The transition property
+	Transition           []*LifecycleTransition         `xml:"Transition,omitempty"`           // The transition property
 	AbortMultipartUpload *LifecycleAbortMultipartUpload `xml:"AbortMultipartUpload,omitempty"` // The AbortMultipartUpload property
 }
 
 // LifecycleExpiration defines the rule's expiration property
 type LifecycleExpiration struct {
-	XMLName xml.Name `xml:"Expiration"`
-	Days    int      `xml:"Days,omitempty"` // Relative expiration time: The expiration time in days after the last modified time
-	//Date              *time.Time `xml:"Date,omitempty"`              // Absolute expiration time: The expiration time in date.
-	//CreatedBeforeDate *time.Time `xml:"CreatedBeforeDate,omitempty"` // objects created before the date will be expired
-	Date              string `xml:"Date,omitempty"`              // Absolute expiration time: The expiration time in date.
-	CreatedBeforeDate string `xml:"CreatedBeforeDate,omitempty"` // objects created before the date will be expired
+	XMLName           xml.Name `xml:"Expiration"`
+	Days              int      `xml:"Days,omitempty"`              // Relative expiration time: The expiration time in days after the last modified time
+	Date              string   `xml:"Date,omitempty"`              // Absolute expiration time: The expiration time in date, not recommended
+	CreatedBeforeDate string   `xml:"CreatedBeforeDate,omitempty"` // objects created before the date will be expired
 }
 
 // LifecycleTransition defines the rule's transition propery
 type LifecycleTransition struct {
-	XMLName xml.Name `xml:"Transition"`
-	Days    int      `xml:"Days,omitempty"` // Relative transition time: The transition time in days after the last modified time
-	//CreatedBeforeDate *time.Time `xml:"CreatedBeforeDate,omitempty"` // objects created before the date will be restored
+	XMLName           xml.Name         `xml:"Transition"`
+	Days              int              `xml:"Days,omitempty"`              // Relative transition time: The transition time in days after the last modified time
 	CreatedBeforeDate string           `xml:"CreatedBeforeDate,omitempty"` // objects created before the date will be expired
 	StorageClass      StorageClassType `xml:"StorageClass,omitempty"`      // Specifies the target storage type
 }
 
 // LifecycleAbortMultipartUpload defines the rule's abort multipart upload propery
 type LifecycleAbortMultipartUpload struct {
-	XMLName xml.Name `xml:"AbortMultipartUpload"`
-	Days    int      `xml:"Days,omitempty"` // Relative expiration time: The expiration time in days after the last modified time
-	//CreatedBeforeDate *time.Time `xml:"CreatedBeforeDate,omitempty"` // objects created before the date will be expired
-	CreatedBeforeDate string `xml:"CreatedBeforeDate,omitempty"` // objects created before the date will be expired
+	XMLName           xml.Name `xml:"AbortMultipartUpload"`
+	Days              int      `xml:"Days,omitempty"`              // Relative expiration time: The expiration time in days after the last modified time
+	CreatedBeforeDate string   `xml:"CreatedBeforeDate,omitempty"` // objects created before the date will be expired
 }
 
 const iso8601DateFormat = "2006-01-02T15:04:05.000Z"
@@ -102,80 +98,57 @@ func BuildLifecycleRuleByDate(id, prefix string, status bool, year, month, day i
 		Expiration: &LifecycleExpiration{Date: date}}
 }
 
-// NewLifecycleRuleByDays builds a lifecycle rule objects will expiration in days after the last modified time
-func NewLifecycleRuleByDays(id, prefix string, status bool, days int, lrt LifecycleRuleType, sc ...StorageClassType) (*LifecycleRule, error) {
-	if len(sc) > 1 {
-		return nil, fmt.Errorf("invalid count of storage class type, the count should be 0 or 1")
-	}
-
-	var statusStr = "Enabled"
+// NewLifecycleRule build a lifecycle rule
+func NewLifecycleRule(id, prefix string, status bool, expiration *LifecycleExpiration, abortMPU *LifecycleAbortMultipartUpload, transitions ...*LifecycleTransition) (*LifecycleRule, error) {
+	statusStr := "Enabled"
 	if !status {
 		statusStr = "Disabled"
 	}
-	switch lrt {
-	case LRTExpriration:
-		if len(sc) == 1 {
-			return nil, fmt.Errorf("the count of storage class type should be 0")
-		}
-		return &LifecycleRule{ID: id, Prefix: prefix, Status: statusStr,
-			Expiration: &LifecycleExpiration{Days: days}}, nil
-	case LRTTransition:
-		if len(sc) == 0 {
-			return nil, fmt.Errorf("miss storage class of transition lifecycle rule")
-		}
-		if sc[0] != StorageIA && sc[0] != StorageArchive {
-			return nil, fmt.Errorf("invalid storage class of transition lifecycle rule,  storage class: %v", sc)
-		}
-		return &LifecycleRule{ID: id, Prefix: prefix, Status: statusStr,
-			Transition: &LifecycleTransition{Days: days, StorageClass: sc[0]}}, nil
-	case LRTAbortMultiPartUpload:
-		if len(sc) == 1 {
-			return nil, fmt.Errorf("the count of storage class type should be 0")
-		}
-		return &LifecycleRule{ID: id, Prefix: prefix, Status: statusStr,
-			AbortMultipartUpload: &LifecycleAbortMultipartUpload{Days: days}}, nil
-	default:
-		return nil, fmt.Errorf("invalid type of lifecycle rule: %v", lrt)
+	rule := LifecycleRule{
+		ID:     id,
+		Prefix: prefix,
+		Status: statusStr,
 	}
-}
 
-// NewLifecycleRuleByCreateBeforeDate builds a lifecycle rule objects created before the date will be expired.
-func NewLifecycleRuleByCreateBeforeDate(id, prefix string, status bool, year, month, day int, lrt LifecycleRuleType, sc ...StorageClassType) (*LifecycleRule, error) {
-	if len(sc) > 1 {
-		return nil, fmt.Errorf("invalid count of storage class type, the cound should be 0 or 1")
+	if expiration != nil {
+		if (expiration.Days != 0 && expiration.CreatedBeforeDate != "") || (expiration.Days == 0 && expiration.CreatedBeforeDate == "") {
+			return nil, fmt.Errorf("invalid expiration lifecycle, must be set one of CreatedBeforeDate and Days")
+		}
+		rule.Expiration = expiration
 	}
 
-	var statusStr = "Enabled"
-	if !status {
-		statusStr = "Disabled"
+	if abortMPU != nil {
+		if (abortMPU.Days != 0 && abortMPU.CreatedBeforeDate != "") || (abortMPU.Days == 0 && abortMPU.CreatedBeforeDate == "") {
+			return nil, fmt.Errorf("invalid abort multipart upload lifecycle, must be set one of CreatedBeforeDate and Days")
+		}
+		rule.AbortMultipartUpload = abortMPU
 	}
 
-	date := time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC).Format(iso8601DateFormat)
-	switch lrt {
-	case LRTExpriration:
-		if len(sc) == 1 {
-			return nil, fmt.Errorf("the count of storage class type should be 0")
-		}
-		return &LifecycleRule{ID: id, Prefix: prefix, Status: statusStr,
-			Expiration: &LifecycleExpiration{CreatedBeforeDate: date}}, nil
-	case LRTTransition:
-		if len(sc) == 0 {
-			return nil, fmt.Errorf("miss storage class of transition lifecycle rule")
-		}
-		if sc[0] != StorageIA && sc[0] != StorageArchive {
-			return nil, fmt.Errorf("invalid storage class of transition lifecycle rule,  storage class: %v", sc)
+	if len(transitions) > 0 {
+		if len(transitions) > 2 {
+			return nil, fmt.Errorf("invalid count of transition lifecycles, the count must than less than 3")
 		}
-		return &LifecycleRule{ID: id, Prefix: prefix, Status: statusStr,
-			Transition: &LifecycleTransition{CreatedBeforeDate: date, StorageClass: sc[0]}}, nil
-	case LRTAbortMultiPartUpload:
-		if len(sc) == 1 {
-			return nil, fmt.Errorf("the count of storage class type should be 0")
+
+		for _, transition := range transitions {
+			if transition == nil {
+				return nil, fmt.Errorf("invalid transitions, there is a transition not be initiated")
+			}
+			if (transition.Days != 0 && transition.CreatedBeforeDate != "") || (transition.Days == 0 && transition.CreatedBeforeDate == "") {
+				return nil, fmt.Errorf("invalid transition lifecycle, must be set one of CreatedBeforeDate and Days")
+			}
+			if transition.StorageClass != StorageIA && transition.StorageClass != StorageArchive {
+				return nil, fmt.Errorf("invalid transition lifecylce, the value of storage class must be IA or Archive")
+			}
 		}
-		return &LifecycleRule{ID: id, Prefix: prefix, Status: statusStr,
-			AbortMultipartUpload: &LifecycleAbortMultipartUpload{CreatedBeforeDate: date}}, nil
-	default:
-		return nil, fmt.Errorf("invalid type of lifecycle rule: %v", lrt)
+
+		rule.Transition = transitions
 	}
+
+	if rule.Expiration == nil && rule.AbortMultipartUpload == nil && len(rule.Transition) == 0 {
+		return nil, fmt.Errorf("invalid lifecycle rule, must be set one of Expiration, AbortMultipartUpload and Transition")
+	}
+
+	return &rule, nil
 }
 
 // GetBucketLifecycleResult defines GetBucketLifecycle's result object

oss/type_test.go

@@ -107,70 +107,143 @@ func (s *OssTypeSuite) TestSortUploadPart(c *C) {
 	c.Assert(parts[4].ETag, Equals, "E5")
 }
 
-func (s *OssTypeSuite) TestNewLifecleRuleByDays(c *C) {
-	_, err := NewLifecycleRuleByDays("rule1", "one", true, 30, LRTExpriration)
-	c.Assert(err, IsNil)
+func (s *OssTypeSuite) TestNewLifecleRule(c *C) {
+	expiration := LifecycleExpiration{
+		Days:              30,
+		CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
+	}
+	_, err := NewLifecycleRule("ruleID", "prefix", true, &expiration, nil)
+	c.Assert(err, NotNil)
 
-	_, err = NewLifecycleRuleByDays("rule2", "two", true, 30, LRTAbortMultiPartUpload)
-	c.Assert(err, IsNil)
+	expiration = LifecycleExpiration{
+		Days:              0,
+		CreatedBeforeDate: "",
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, &expiration, nil)
+	c.Assert(err, NotNil)
 
-	_, err = NewLifecycleRuleByDays("rule3", "three", true, 30, LRTTransition, StorageIA)
-	c.Assert(err, IsNil)
+	abortMPU := LifecycleAbortMultipartUpload{
+		Days:              30,
+		CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, nil, &abortMPU)
+	c.Assert(err, NotNil)
 
-	_, err = NewLifecycleRuleByDays("rule4", "four", true, 30, LRTTransition, StorageArchive)
-	c.Assert(err, IsNil)
+	abortMPU = LifecycleAbortMultipartUpload{
+		Days:              0,
+		CreatedBeforeDate: "",
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, nil, &abortMPU)
+	c.Assert(err, NotNil)
 
-	// expiration lifecycle type, set storage class type
-	_, err = NewLifecycleRuleByDays("rule5", "five", true, 30, LRTExpriration, StorageIA)
+	transition := LifecycleTransition{
+		Days:              30,
+		CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
+		StorageClass:      StorageIA,
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, nil, nil, &transition)
 	c.Assert(err, NotNil)
 
-	// abort multipart upload lifecycle type, set storage class type
-	_, err = NewLifecycleRuleByDays("rule6", "six", true, 30, LRTAbortMultiPartUpload, StorageIA)
+	transition = LifecycleTransition{
+		Days:              0,
+		CreatedBeforeDate: "",
+		StorageClass:      StorageIA,
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, nil, nil, &transition)
 	c.Assert(err, NotNil)
 
-	// transition lifecycle type, the value of storage class type is StorageStandard
-	_, err = NewLifecycleRuleByDays("rule7", "seven", true, 30, LRTTransition, StorageStandard)
+	transition = LifecycleTransition{
+		Days:         30,
+		StorageClass: StorageStandard,
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, nil, nil, &transition)
 	c.Assert(err, NotNil)
 
-	// transition lifecycle type, do not set storage class type
-	_, err = NewLifecycleRuleByDays("rule8", "eight", true, 30, LRTTransition)
+	transition = LifecycleTransition{
+		CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
+		StorageClass:      StorageStandard,
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, nil, nil, &transition)
 	c.Assert(err, NotNil)
 
-	// transition lifecycle type，set two storage class type
-	_, err = NewLifecycleRuleByDays("rule9", "nine", true, 30, LRTTransition, StorageIA, StorageArchive)
+	transition1 := LifecycleTransition{
+		Days:         30,
+		StorageClass: StorageIA,
+	}
+	transition2 := LifecycleTransition{
+		Days:         60,
+		StorageClass: StorageArchive,
+	}
+	transition3 := LifecycleTransition{
+		Days:         100,
+		StorageClass: StorageArchive,
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, nil, nil, &transition1, &transition2, &transition3)
 	c.Assert(err, NotNil)
-}
 
-func (s *OssTypeSuite) TestNewLifecycleRuleByCreateBeforeDate(c *C) {
-	_, err := NewLifecycleRuleByCreateBeforeDate("rule1", "one", true, 2019, 3, 30, LRTExpriration)
-	c.Assert(err, IsNil)
+	_, err = NewLifecycleRule("ruleID", "prefix", true, nil, nil)
+	c.Assert(err, NotNil)
 
-	_, err = NewLifecycleRuleByCreateBeforeDate("rule2", "two", true, 2019, 3, 30, LRTAbortMultiPartUpload)
+	expiration = LifecycleExpiration{
+		Days: 30,
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, &expiration, nil)
 	c.Assert(err, IsNil)
 
-	_, err = NewLifecycleRuleByCreateBeforeDate("rule3", "three", true, 2019, 3, 30, LRTTransition, StorageIA)
+	expiration = LifecycleExpiration{
+		CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, &expiration, nil)
 	c.Assert(err, IsNil)
 
-	_, err = NewLifecycleRuleByCreateBeforeDate("rule4", "four", true, 2019, 3, 30, LRTTransition, StorageArchive)
+	abortMPU = LifecycleAbortMultipartUpload{
+		Days: 30,
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, nil, &abortMPU)
 	c.Assert(err, IsNil)
 
-	// expiration lifecycle type, set storage class type
-	_, err = NewLifecycleRuleByCreateBeforeDate("rule5", "five", true, 2019, 3, 30, LRTExpriration, StorageIA)
-	c.Assert(err, NotNil)
-
-	// abort multipart upload lifecycle type, set storage class type
-	_, err = NewLifecycleRuleByCreateBeforeDate("rule6", "six", true, 2019, 3, 30, LRTAbortMultiPartUpload, StorageIA)
-	c.Assert(err, NotNil)
+	abortMPU = LifecycleAbortMultipartUpload{
+		CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, nil, &abortMPU)
+	c.Assert(err, IsNil)
 
-	// transition lifecycle type, the value of storage class type is StorageStandard
-	_, err = NewLifecycleRuleByCreateBeforeDate("rule7", "seven", true, 2019, 3, 30, LRTTransition, StorageStandard)
-	c.Assert(err, NotNil)
+	expiration = LifecycleExpiration{
+		Days: 30,
+	}
+	abortMPU = LifecycleAbortMultipartUpload{
+		Days: 30,
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, &expiration, &abortMPU)
+	c.Assert(err, IsNil)
 
-	// transition lifecycle type, do not set storage class type
-	_, err = NewLifecycleRuleByCreateBeforeDate("rule8", "eight", true, 2019, 3, 30, LRTTransition)
-	c.Assert(err, NotNil)
+	expiration = LifecycleExpiration{
+		CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
+	}
+	abortMPU = LifecycleAbortMultipartUpload{
+		Days: 30,
+	}
+	transition = LifecycleTransition{
+		Days:         30,
+		StorageClass: StorageIA,
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, &expiration, &abortMPU)
+	c.Assert(err, IsNil)
 
-	// transition lifecycle type，set two storage class type
-	_, err = NewLifecycleRuleByCreateBeforeDate("rule9", "nine", true, 2019, 3, 30, LRTTransition, StorageIA, StorageArchive)
-	c.Assert(err, NotNil)
+	expiration = LifecycleExpiration{
+		CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
+	}
+	abortMPU = LifecycleAbortMultipartUpload{
+		Days: 30,
+	}
+	transition1 = LifecycleTransition{
+		Days:         30,
+		StorageClass: StorageIA,
+	}
+	transition2 = LifecycleTransition{
+		Days:         60,
+		StorageClass: StorageArchive,
+	}
+	_, err = NewLifecycleRule("ruleID", "prefix", true, &expiration, &abortMPU, &transition1, &transition2)
+	c.Assert(err, IsNil)
 }

sample/bucket_lifecycle.go

@@ -20,9 +20,11 @@ func BucketLifecycleSample() {
 		HandleError(err)
 	}
 
-	// Case 1: Set the lifecycle. The rule ID is id1 and the applied objects' prefix is one and expired time is 11/11/2015
-	//var rule1 = oss.BuildLifecycleRuleByDate("id1", "one", true, 2015, 11, 11)
-	rule1, err := oss.NewLifecycleRuleByCreateBeforeDate("id1", "one", true, 2015, 11, 11, oss.LRTExpriration)
+	// Case 1: Set the lifecycle. The rule ID is rule1 and the applied objects' prefix is one and expired time is 11/11/2015
+	expriation := oss.LifecycleExpiration{
+		CreatedBeforeDate: "2015-11-11T00:00:00.000Z",
+	}
+	rule1, err := oss.NewLifecycleRule("rule1", "one", true, &expriation, nil)
 	if err != nil {
 		HandleError(err)
 	}
@@ -32,9 +34,23 @@ func BucketLifecycleSample() {
 		HandleError(err)
 	}
 
+	// Get the bucket's lifecycle
+	lc, err := client.GetBucketLifecycle(bucketName)
+	if err != nil {
+		HandleError(err)
+	}
+	fmt.Printf("Bucket Lifecycle:%v, %v\n", lc.Rules, *lc.Rules[0].Expiration)
+
 	// Case 2: Set the lifecycle, The rule ID is id2 and the applied objects' prefix is two and the expired time is three days after the object created.
-	//var rule2 = oss.BuildLifecycleRuleByDays("id2", "two", true, 3)
-	rule2, err := oss.NewLifecycleRuleByDays("id2", "two", true, 3, oss.LRTTransition, oss.StorageIA)
+	transitionIA := oss.LifecycleTransition{
+		Days:         3,
+		StorageClass: oss.StorageIA,
+	}
+	transitionArch := oss.LifecycleTransition{
+		Days:         30,
+		StorageClass: oss.StorageArchive,
+	}
+	rule2, err := oss.NewLifecycleRule("rule2", "two", true, nil, nil, &transitionIA, &transitionArch)
 	if err != nil {
 		HandleError(err)
 	}
@@ -45,13 +61,16 @@ func BucketLifecycleSample() {
 	}
 
 	// Get the bucket's lifecycle
-	lc, err := client.GetBucketLifecycle(bucketName)
+	lc, err = client.GetBucketLifecycle(bucketName)
 	if err != nil {
 		HandleError(err)
 	}
-	fmt.Println("Bucket Lifecycle:", lc.Rules)
+	fmt.Printf("Bucket Lifecycle:%v, %v, %v\n", lc.Rules, *lc.Rules[0].Transition[0], *lc.Rules[0].Transition[1])
 
-	rule3, err := oss.NewLifecycleRuleByDays("id3", "three", true, 3, oss.LRTAbortMultiPartUpload)
+	abortMPU := oss.LifecycleAbortMultipartUpload{
+		Days: 3,
+	}
+	rule3, err := oss.NewLifecycleRule("rule3", "three", true, nil, &abortMPU)
 	if err != nil {
 		HandleError(err)
 	}
@@ -66,7 +85,7 @@ func BucketLifecycleSample() {
 	if err != nil {
 		HandleError(err)
 	}
-	fmt.Println("Bucket Lifecycle:", lc.Rules)
+	fmt.Printf("Bucket Lifecycle:%v, %v, %v, %v\n", lc.Rules, *lc.Rules[0].Transition[0], *lc.Rules[0].Transition[1], *lc.Rules[1].AbortMultipartUpload)
 
 	// Delete bucket's Lifecycle
 	err = client.DeleteBucketLifecycle(bucketName)