add bucket encryption

.travis.yml

@@ -13,11 +13,13 @@ install:
 - if [[ $TRAVIS_GO_VERSION = '1.7' || $TRAVIS_GO_VERSION > '1.7' ]]; then go get golang.org/x/time/rate
   ; fi
 script:
-- if [ -n "$OSS_TEST_ACCESS_KEY_ID" ]; then
-    cd oss;
-    travis_wait 30 go test -v -covermode=count -coverprofile=coverage.out -timeout=30m;
-    $HOME/gopath/bin/goveralls -coverprofile=coverage.out -service=travis-ci;
-  fi
+- if [[ ! -n "$OSS_TEST_ACCESS_KEY_ID" ]]; then exit 0
+  ; fi
+  
+- cd oss
+- travis_wait 30 go test -v -covermode=count -coverprofile=coverage.out -timeout=30m
+- "$HOME/gopath/bin/goveralls -coverprofile=coverage.out -service=travis-ci"
+
 env:
   global:
   - secure: ZCL5egxJmZA+o1ujsaJe//AIh1ag/exSUJ2FzoKPF3O9c84hMc2k5EYO2rGzTNn1ML6M89Mo5hAvHQhyJEHjRuMtjc1QrfxAaA3mqm4scGXIXesPMqYGuvuPSh++6/fkAwaVBAhrk5GaDG1/FuxHE5zusGx3SvGegnCwO7n/2YCfXco6DWgVCdrz4p1EpPkAM3JIdHFUzsDWiimVuiNAvJmAT8+IeOPTT+WgusCJj4ORS3X3LddTjttBP+hRrp/pGSoNqPMzfysWybtaL2SJ8URtvsxW0Mo5BwocHAxAhPP+M2OscQbDzthSAezCLngYvrfBplfIyWlahlgzNz/FjXz5pQwWdYVNoibyxLLMOH685n75LNONN/xVO/GFmVPx7DMGapkN5NzIWS62D4v8QrRkwtms42OUkyEUHjDh8Evui3K2MNJVXA3TI9zOAR+C0krD7OEyS37qrppodhRxJSqFUlgXnk//wLldMC7vleDd7L2UQSWjqyBHqFOgsVaiLU2KRTY3zvv7ke+dqb5VF31mH6qAr8lJTR9un8M1att0VwCEKxoIRT4cKJCpEtZd8ovXOVt1uE695ThVXE9I5e00GXdTzqXOuv6zT4hv/dgmbz9JN9MYeCwmokEoIUmJKNYERa/bNVVefdnJt7h+dm+KpyPAS+XvPLzjbnWdYNA=

oss/bucket.go

@@ -935,7 +935,7 @@ func (bucket Bucket) ProcessObject(objectKey string, process string) (ProcessObj
 //
 // error        nil if success, otherwise error
 //
-func (bucket Bucket) PutObjectTagging(objectKey string, tagging ObjectTagging) error {
+func (bucket Bucket) PutObjectTagging(objectKey string, tagging Tagging) error {
 	bs, err := xml.Marshal(tagging)
 	if err != nil {
 		return err
@@ -963,8 +963,8 @@ func (bucket Bucket) PutObjectTagging(objectKey string, tagging ObjectTagging) e
 // Tagging
 // error      nil if success, otherwise error
 //
-func (bucket Bucket) GetObjectTagging(objectKey string) (ObjectTagging, error) {
-	var out ObjectTagging
+func (bucket Bucket) GetObjectTagging(objectKey string) (GetObjectTaggingResult, error) {
+	var out GetObjectTaggingResult
 	params := map[string]interface{}{}
 	params["tagging"] = nil
 

oss/bucket_test.go

@@ -2790,10 +2790,10 @@ func (s *OssBucketSuite) TestPutObjectTagging(c *C) {
 		Key:   randStr(8),
 		Value: randStr(16),
 	}
-	tagging := ObjectTagging{
+	tagging := Tagging{
 		Tags: []Tag{tag1, tag2},
 	}
-	err := s.bucket.PutObject(objectName, strings.NewReader(randStr(1024)), Tagging(tagging))
+	err := s.bucket.PutObject(objectName, strings.NewReader(randStr(1024)), SetTagging(tagging))
 	c.Assert(err, IsNil)
 
 	headers, err := s.bucket.GetObjectDetailedMeta(objectName)
@@ -2801,6 +2801,24 @@ func (s *OssBucketSuite) TestPutObjectTagging(c *C) {
 	c.Assert(err, IsNil)
 	c.Assert(taggingCount, Equals, 2)
 
+	// copy object with default option
+	destObjectName := objectNamePrefix + randStr(8)
+	_, err = s.bucket.CopyObject(objectName, destObjectName)
+	c.Assert(err, IsNil)
+	headers, err = s.bucket.GetObjectDetailedMeta(destObjectName)
+	taggingCount, err = strconv.Atoi(headers["X-Oss-Tagging-Count"][0])
+	c.Assert(err, IsNil)
+	c.Assert(taggingCount, Equals, 2)
+
+	// delete object tagging
+	err = s.bucket.DeleteObjectTagging(objectName)
+	c.Assert(err, IsNil)
+
+	// get object tagging again
+	taggingResult, err := s.bucket.GetObjectTagging(objectName)
+	c.Assert(err, IsNil)
+	c.Assert(len(taggingResult.Tags), Equals, 0)
+
 	// put tagging
 	tag := Tag{
 		Key:   randStr(8),
@@ -2810,10 +2828,10 @@ func (s *OssBucketSuite) TestPutObjectTagging(c *C) {
 	err = s.bucket.PutObjectTagging(objectName, tagging)
 	c.Assert(err, IsNil)
 
-	tagging, err = s.bucket.GetObjectTagging(objectName)
-	c.Assert(len(tagging.Tags), Equals, 1)
-	c.Assert(tagging.Tags[0].Key, Equals, tag.Key)
-	c.Assert(tagging.Tags[0].Value, Equals, tag.Value)
+	taggingResult, err = s.bucket.GetObjectTagging(objectName)
+	c.Assert(len(taggingResult.Tags), Equals, 1)
+	c.Assert(taggingResult.Tags[0].Key, Equals, tag.Key)
+	c.Assert(taggingResult.Tags[0].Value, Equals, tag.Value)
 
 	//put tagging, the length of the key exceeds 128
 	tag = Tag{
@@ -2876,6 +2894,7 @@ func (s *OssBucketSuite) TestPutObjectTagging(c *C) {
 	err = s.bucket.PutObjectTagging(objectName, tagging)
 	c.Assert(err, NotNil)
 
+	s.bucket.DeleteObject(destObjectName)
 	s.bucket.DeleteObject(objectName)
 }
 
@@ -2890,13 +2909,15 @@ func (s *OssBucketSuite) TestGetObjectTagging(c *C) {
 		Key:   randStr(8),
 		Value: randStr(16),
 	}
-	tagging := ObjectTagging{
+
+	taggingInfo := Tagging{
 		Tags: []Tag{tag1, tag2},
 	}
-	err := s.bucket.PutObject(objectName, strings.NewReader(randStr(1024)), Tagging(tagging))
+
+	err := s.bucket.PutObject(objectName, strings.NewReader(randStr(1024)), SetTagging(taggingInfo))
 	c.Assert(err, IsNil)
 
-	tagging, err = s.bucket.GetObjectTagging(objectName)
+	tagging, err := s.bucket.GetObjectTagging(objectName)
 	c.Assert(len(tagging.Tags), Equals, 2)
 	if tagging.Tags[0].Key == tag1.Key {
 		c.Assert(tagging.Tags[0].Value, Equals, tag1.Value)
@@ -2927,7 +2948,7 @@ func (s *OssBucketSuite) TestGetObjectTagging(c *C) {
 	// copy object, with tagging option
 	destObjectName := objectName + "-dest"
 	tagging.Tags = []Tag{tag1, tag2}
-	_, err = s.bucket.CopyObject(objectName, destObjectName, Tagging(tagging))
+	_, err = s.bucket.CopyObject(objectName, destObjectName, SetTagging(taggingInfo))
 	c.Assert(err, IsNil)
 	tagging, err = s.bucket.GetObjectTagging(objectName)
 	c.Assert(err, IsNil)
@@ -2935,7 +2956,7 @@ func (s *OssBucketSuite) TestGetObjectTagging(c *C) {
 
 	// copy object, with tagging option, the value of tagging directive is "REPLACE"
 	tagging.Tags = []Tag{tag1, tag2}
-	_, err = s.bucket.CopyObject(objectName, destObjectName, Tagging(tagging), TaggingDirective(TaggingReplace))
+	_, err = s.bucket.CopyObject(objectName, destObjectName, SetTagging(taggingInfo), TaggingDirective(TaggingReplace))
 	c.Assert(err, IsNil)
 	tagging, err = s.bucket.GetObjectTagging(destObjectName)
 	c.Assert(err, IsNil)
@@ -2966,16 +2987,16 @@ func (s *OssBucketSuite) TestDeleteObjectTagging(c *C) {
 		Key:   randStr(8),
 		Value: randStr(16),
 	}
-	tagging := ObjectTagging{
+	tagging := Tagging{
 		Tags: []Tag{tag},
 	}
-	err = s.bucket.PutObject(objectName, strings.NewReader(randStr(1024)), Tagging(tagging))
+	err = s.bucket.PutObject(objectName, strings.NewReader(randStr(1024)), SetTagging(tagging))
 	c.Assert(err, IsNil)
 	err = s.bucket.DeleteObjectTagging(objectName)
 	c.Assert(err, IsNil)
-	tagging, err = s.bucket.GetObjectTagging(objectName)
+	taggingResult, err := s.bucket.GetObjectTagging(objectName)
 	c.Assert(err, IsNil)
-	c.Assert(len(tagging.Tags), Equals, 0)
+	c.Assert(len(taggingResult.Tags), Equals, 0)
 
 	//delete object tagging again
 	err = s.bucket.DeleteObjectTagging(objectName)

oss/client.go

@@ -651,6 +651,97 @@ func (client Client) GetBucketInfo(bucketName string) (GetBucketInfoResult, erro
 	}
 	defer resp.Body.Close()
 
+	err = xmlUnmarshal(resp.Body, &out)
+
+	// convert None to ""
+	if err == nil {
+		if out.BucketInfo.SseRule.KMSMasterKeyID == "None" {
+			out.BucketInfo.SseRule.KMSMasterKeyID = ""
+		}
+
+		if out.BucketInfo.SseRule.SSEAlgorithm == "None" {
+			out.BucketInfo.SseRule.SSEAlgorithm = ""
+		}
+	}
+	return out, err
+}
+
+// SetBucketEncryption set bucket encryption config
+// bucketName    the bucket name.
+// error    it's nil if no error, otherwise it's an error object.
+func (client Client) SetBucketEncryption(bucketName string, encryptionRule ServerEncryptionRule) error {
+	var err error
+	var bs []byte
+	bs, err = xml.Marshal(encryptionRule)
+
+	if err != nil {
+		return err
+	}
+
+	buffer := new(bytes.Buffer)
+	buffer.Write(bs)
+
+	contentType := http.DetectContentType(buffer.Bytes())
+	headers := map[string]string{}
+	headers[HTTPHeaderContentType] = contentType
+
+	params := map[string]interface{}{}
+	params["encryption"] = nil
+	resp, err := client.do("PUT", bucketName, params, headers, buffer)
+
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return checkRespCode(resp.StatusCode, []int{http.StatusOK})
+}
+
+// GetBucketEncryption get bucket encryption config
+// bucketName    the bucket name.
+// error    it's nil if no error, otherwise it's an error object.
+func (client Client) GetBucketEncryption(bucketName string) (GetBucketEncryptionResult, error) {
+	var out GetBucketEncryptionResult
+	params := map[string]interface{}{}
+	params["encryption"] = nil
+	resp, err := client.do("GET", bucketName, params, nil, nil)
+
+	if err != nil {
+		return out, err
+	}
+	defer resp.Body.Close()
+
+	err = xmlUnmarshal(resp.Body, &out)
+	return out, err
+}
+
+// DeleteBucketEncryption delete bucket encryption config
+// bucketName    the bucket name.
+// error    it's nil if no error, otherwise it's an error object.
+func (client Client) DeleteBucketEncryption(bucketName string) error {
+	params := map[string]interface{}{}
+	params["encryption"] = nil
+	resp, err := client.do("DELETE", bucketName, params, nil, nil)
+
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	return checkRespCode(resp.StatusCode, []int{http.StatusNoContent})
+}
+
+// GetBucketStat get bucket stat
+// bucketName    the bucket name.
+// error    it's nil if no error, otherwise it's an error object.
+func (client Client) GetBucketStat(bucketName string) (GetBucketStatResult, error) {
+	var out GetBucketStatResult
+	params := map[string]interface{}{}
+	params["stat"] = nil
+	resp, err := client.do("GET", bucketName, params, nil, nil)
+	if err != nil {
+		return out, err
+	}
+	defer resp.Body.Close()
+
 	err = xmlUnmarshal(resp.Body, &out)
 	return out, err
 }

oss/client_test.go

@@ -1839,3 +1839,181 @@ func (s *OssClientSuite) TestSetLimitUploadSpeed(c *C) {
 		c.Assert(err, NotNil)
 	}
 }
+
+func (s *OssClientSuite) TestBucketEncyptionError(c *C) {
+	client, err := New(endpoint, accessID, accessKey)
+	c.Assert(err, IsNil)
+
+	bucketName := bucketNamePrefix + randLowStr(5)
+	err = client.CreateBucket(bucketName)
+	c.Assert(err, IsNil)
+
+	// SetBucketEncryption:AES256 ,"123"
+	encryptionRule := ServerEncryptionRule{}
+	encryptionRule.SSEDefault.SSEAlgorithm = string(AESAlgorithm)
+	encryptionRule.SSEDefault.KMSMasterKeyID = "123"
+
+	err = client.SetBucketEncryption(bucketName, encryptionRule)
+	c.Assert(err, NotNil)
+
+	// GetBucketEncryption
+	_, err = client.GetBucketEncryption(bucketName)
+	c.Assert(err, NotNil)
+
+	// Get default bucket info
+	bucketResult, err := client.GetBucketInfo(bucketName)
+	c.Assert(err, IsNil)
+
+	c.Assert(bucketResult.BucketInfo.SseRule.SSEAlgorithm, Equals, "")
+	c.Assert(bucketResult.BucketInfo.SseRule.KMSMasterKeyID, Equals, "")
+
+	err = client.DeleteBucket(bucketName)
+	c.Assert(err, IsNil)
+}
+
+func (s *OssClientSuite) TestBucketEncyptionPutAndGetAndDelete(c *C) {
+	client, err := New(endpoint, accessID, accessKey)
+	c.Assert(err, IsNil)
+
+	bucketName := bucketNamePrefix + randLowStr(5)
+	err = client.CreateBucket(bucketName)
+	c.Assert(err, IsNil)
+
+	// SetBucketEncryption:KMS ,""
+	encryptionRule := ServerEncryptionRule{}
+	encryptionRule.SSEDefault.SSEAlgorithm = string(KMSAlgorithm)
+
+	err = client.SetBucketEncryption(bucketName, encryptionRule)
+	c.Assert(err, IsNil)
+
+	// GetBucketEncryption
+	getResult, err := client.GetBucketEncryption(bucketName)
+	c.Assert(err, IsNil)
+
+	// check encryption value
+	c.Assert(encryptionRule.SSEDefault.SSEAlgorithm, Equals, getResult.SSEDefault.SSEAlgorithm)
+	c.Assert(encryptionRule.SSEDefault.KMSMasterKeyID, Equals, getResult.SSEDefault.KMSMasterKeyID)
+
+	// delete bucket encyption
+	err = client.DeleteBucketEncryption(bucketName)
+	c.Assert(err, IsNil)
+
+	// GetBucketEncryption failure
+	_, err = client.GetBucketEncryption(bucketName)
+	c.Assert(err, NotNil)
+
+	// Get default bucket info
+	bucketResult, err := client.GetBucketInfo(bucketName)
+	c.Assert(err, IsNil)
+
+	c.Assert(bucketResult.BucketInfo.SseRule.SSEAlgorithm, Equals, "")
+	c.Assert(bucketResult.BucketInfo.SseRule.KMSMasterKeyID, Equals, "")
+
+	err = client.DeleteBucket(bucketName)
+	c.Assert(err, IsNil)
+}
+
+func (s *OssClientSuite) TestBucketEncyptionPutObjectSuccess(c *C) {
+	client, err := New(endpoint, accessID, accessKey)
+	c.Assert(err, IsNil)
+
+	bucketName := bucketNamePrefix + randLowStr(5)
+	err = client.CreateBucket(bucketName)
+	c.Assert(err, IsNil)
+
+	// SetBucketEncryption:KMS ,""
+	encryptionRule := ServerEncryptionRule{}
+	encryptionRule.SSEDefault.SSEAlgorithm = string(KMSAlgorithm)
+
+	err = client.SetBucketEncryption(bucketName, encryptionRule)
+	c.Assert(err, IsNil)
+
+	// GetBucketEncryption
+	getResult, err := client.GetBucketEncryption(bucketName)
+	c.Assert(err, IsNil)
+
+	// check encryption value
+	c.Assert(encryptionRule.SSEDefault.SSEAlgorithm, Equals, getResult.SSEDefault.SSEAlgorithm)
+	c.Assert(encryptionRule.SSEDefault.KMSMasterKeyID, Equals, getResult.SSEDefault.KMSMasterKeyID)
+
+	// Get default bucket info
+	bucketResult, err := client.GetBucketInfo(bucketName)
+	c.Assert(err, IsNil)
+
+	c.Assert(bucketResult.BucketInfo.SseRule.SSEAlgorithm, Equals, "KMS")
+	c.Assert(bucketResult.BucketInfo.SseRule.KMSMasterKeyID, Equals, "")
+	err = client.DeleteBucket(bucketName)
+	c.Assert(err, IsNil)
+}
+
+func (s *OssClientSuite) TestBucketEncyptionPutObjectError(c *C) {
+	client, err := New(endpoint, accessID, accessKey)
+	c.Assert(err, IsNil)
+
+	bucketName := bucketNamePrefix + randLowStr(5)
+	err = client.CreateBucket(bucketName)
+	c.Assert(err, IsNil)
+
+	// SetBucketEncryption:KMS ,""
+	encryptionRule := ServerEncryptionRule{}
+	encryptionRule.SSEDefault.SSEAlgorithm = string(KMSAlgorithm)
+	encryptionRule.SSEDefault.KMSMasterKeyID = "123"
+
+	err = client.SetBucketEncryption(bucketName, encryptionRule)
+	c.Assert(err, IsNil)
+
+	// GetBucketEncryption
+	getResult, err := client.GetBucketEncryption(bucketName)
+	c.Assert(err, IsNil)
+
+	// check encryption value
+	c.Assert(encryptionRule.SSEDefault.SSEAlgorithm, Equals, getResult.SSEDefault.SSEAlgorithm)
+	c.Assert(encryptionRule.SSEDefault.KMSMasterKeyID, Equals, getResult.SSEDefault.KMSMasterKeyID)
+
+	// Get default bucket info
+	bucketResult, err := client.GetBucketInfo(bucketName)
+	c.Assert(err, IsNil)
+
+	c.Assert(bucketResult.BucketInfo.SseRule.SSEAlgorithm, Equals, "KMS")
+	c.Assert(bucketResult.BucketInfo.SseRule.KMSMasterKeyID, Equals, "123")
+
+	// put and get object failure
+	bucket, err := client.Bucket(bucketName)
+	c.Assert(err, IsNil)
+
+	// put object failure
+	objectName := objectNamePrefix + randStr(8)
+	context := randStr(100)
+	err = bucket.PutObject(objectName, strings.NewReader(context))
+	c.Assert(err, NotNil)
+
+	err = client.DeleteBucket(bucketName)
+	c.Assert(err, IsNil)
+}
+
+func (s *OssClientSuite) TestGetBucketStat(c *C) {
+	client, err := New(endpoint, accessID, accessKey)
+	c.Assert(err, IsNil)
+
+	bucketName := bucketNamePrefix + randLowStr(5)
+	err = client.CreateBucket(bucketName)
+	c.Assert(err, IsNil)
+
+	bucket, err := client.Bucket(bucketName)
+	c.Assert(err, IsNil)
+
+	// put object
+	objectName := objectNamePrefix + randLowStr(5)
+	err = bucket.PutObject(objectName, strings.NewReader(randStr(10)))
+	c.Assert(err, IsNil)
+
+	bucket.DeleteObject(objectName)
+	err = bucket.PutObject(objectName, strings.NewReader(randStr(10)))
+	c.Assert(err, IsNil)
+	bucket.DeleteObject(objectName)
+
+	_, err = client.GetBucketStat(bucketName)
+	c.Assert(err, IsNil)
+
+	client.DeleteBucket(bucketName)
+}

oss/conn.go

@@ -27,7 +27,16 @@ type Conn struct {
 	client *http.Client
 }
 
-var signKeyList = []string{"acl", "uploads", "location", "cors", "logging", "website", "referer", "lifecycle", "delete", "append", "tagging", "objectMeta", "uploadId", "partNumber", "security-token", "position", "img", "style", "styleName", "replication", "replicationProgress", "replicationLocation", "cname", "bucketInfo", "comp", "qos", "live", "status", "vod", "startTime", "endTime", "symlink", "x-oss-process", "response-content-type", "response-content-language", "response-expires", "response-cache-control", "response-content-disposition", "response-content-encoding", "udf", "udfName", "udfImage", "udfId", "udfImageDesc", "udfApplication", "comp", "udfApplicationLog", "restore", "callback", "callback-var", "policy", "tagging"}
+var signKeyList = []string{"acl", "uploads", "location", "cors", "logging",
+	"website", "referer", "lifecycle", "delete", "append", "tagging", "objectMeta",
+	"uploadId", "partNumber", "security-token", "position", "img", "style", "styleName",
+	"replication", "replicationProgress", "replicationLocation", "cname", "bucketInfo",
+	"comp", "qos", "live", "status", "vod", "startTime", "endTime", "symlink",
+	"x-oss-process", "response-content-type", "response-content-language",
+	"response-expires", "response-cache-control", "response-content-disposition",
+	"response-content-encoding", "udf", "udfName", "udfImage", "udfId", "udfImageDesc",
+	"udfApplication", "comp", "udfApplicationLog", "restore", "callback", "callback-var",
+	"policy", "tagging", "stat", "encryption"}
 
 // init initializes Conn
 func (conn *Conn) init(config *Config, urlMaker *urlMaker, client *http.Client) error {

oss/const.go

@@ -41,6 +41,14 @@ const (
 	TaggingReplace TaggingDirectiveType = "REPLACE"
 )
 
+// AlgorithmType specifying the server side encryption algorithm name
+type AlgorithmType string
+
+const (
+	KMSAlgorithm AlgorithmType = "KMS"
+	AESAlgorithm AlgorithmType = "AES256"
+)
+
 // StorageClassType bucket storage type
 type StorageClassType string
 

oss/option.go

@@ -203,8 +203,8 @@ func RequestPayer(payerType PayerType) Option {
 	return setHeader(HTTPHeaderOssRequester, string(payerType))
 }
 
-// Tagging is an option to set object tagging
-func Tagging(tagging ObjectTagging) Option {
+// SetTagging is an option to set object tagging
+func SetTagging(tagging Tagging) Option {
 	if len(tagging.Tags) == 0 {
 		return nil
 	}

oss/type.go

@@ -228,14 +228,21 @@ type GetBucketInfoResult struct {
 // BucketInfo defines Bucket information
 type BucketInfo struct {
 	XMLName          xml.Name  `xml:"Bucket"`
-	Name             string    `xml:"Name"`                    // Bucket name
-	Location         string    `xml:"Location"`                // Bucket datacenter
-	CreationDate     time.Time `xml:"CreationDate"`            // Bucket creation time
-	ExtranetEndpoint string    `xml:"ExtranetEndpoint"`        // Bucket external endpoint
-	IntranetEndpoint string    `xml:"IntranetEndpoint"`        // Bucket internal endpoint
-	ACL              string    `xml:"AccessControlList>Grant"` // Bucket ACL
-	Owner            Owner     `xml:"Owner"`                   // Bucket owner
-	StorageClass     string    `xml:"StorageClass"`            // Bucket storage class
+	Name             string    `xml:"Name"`                     // Bucket name
+	Location         string    `xml:"Location"`                 // Bucket datacenter
+	CreationDate     time.Time `xml:"CreationDate"`             // Bucket creation time
+	ExtranetEndpoint string    `xml:"ExtranetEndpoint"`         // Bucket external endpoint
+	IntranetEndpoint string    `xml:"IntranetEndpoint"`         // Bucket internal endpoint
+	ACL              string    `xml:"AccessControlList>Grant"`  // Bucket ACL
+	Owner            Owner     `xml:"Owner"`                    // Bucket owner
+	StorageClass     string    `xml:"StorageClass"`             // Bucket storage class
+	SseRule          SSERule   `xml:"ServerSideEncryptionRule"` // Bucket ServerSideEncryptionRule
+}
+
+type SSERule struct {
+	XMLName        xml.Name `xml:"ServerSideEncryptionRule"` // Bucket ServerSideEncryptionRule
+	KMSMasterKeyID string   `xml:"KMSMasterKeyID"`           // Bucket KMSMasterKeyID
+	SSEAlgorithm   string   `xml:"SSEAlgorithm"`             // Bucket SSEAlgorithm
 }
 
 // ListObjectsResult defines the result from ListObjects request
@@ -603,7 +610,32 @@ type Tag struct {
 }
 
 // ObjectTagging tagset for the object
-type ObjectTagging struct {
+type Tagging struct {
 	XMLName xml.Name `xml:"Tagging"`
 	Tags    []Tag    `xml:"TagSet>Tag,omitempty"`
 }
+
+type GetObjectTaggingResult Tagging
+
+// Server Encryption rule for the bucket
+type ServerEncryptionRule struct {
+	XMLName    xml.Name       `xml:"ServerSideEncryptionRule"`
+	SSEDefault SSEDefaultRule `xml:"ApplyServerSideEncryptionByDefault"`
+}
+
+// Server Encryption deafult rule for the bucket
+type SSEDefaultRule struct {
+	XMLName        xml.Name `xml:"ApplyServerSideEncryptionByDefault"`
+	SSEAlgorithm   string   `xml:"SSEAlgorithm"`
+	KMSMasterKeyID string   `xml:"KMSMasterKeyID"`
+}
+
+type GetBucketEncryptionResult ServerEncryptionRule
+
+type BucketStat struct {
+	XMLName              xml.Name `xml:"BucketStat"`
+	Storage              int64    `xml:"Storage"`
+	ObjectCount          int64    `xml:ObjectCount`
+	MultipartUploadCount int64    `xml:MultipartUploadCount`
+}
+type GetBucketStatResult BucketStat

sample.go

@@ -12,26 +12,27 @@ import (
 
 // sampleMap contains all samples
 var sampleMap = map[string]interface{}{
-	"CreateBucketSample":    sample.CreateBucketSample,
-	"NewBucketSample":       sample.NewBucketSample,
-	"ListBucketsSample":     sample.ListBucketsSample,
-	"BucketACLSample":       sample.BucketACLSample,
-	"BucketLifecycleSample": sample.BucketLifecycleSample,
-	"BucketRefererSample":   sample.BucketRefererSample,
-	"BucketLoggingSample":   sample.BucketLoggingSample,
-	"BucketCORSSample":      sample.BucketCORSSample,
-	"ObjectACLSample":       sample.ObjectACLSample,
-	"ObjectMetaSample":      sample.ObjectMetaSample,
-	"ListObjectsSample":     sample.ListObjectsSample,
-	"DeleteObjectSample":    sample.DeleteObjectSample,
-	"AppendObjectSample":    sample.AppendObjectSample,
-	"CopyObjectSample":      sample.CopyObjectSample,
-	"PutObjectSample":       sample.PutObjectSample,
-	"GetObjectSample":       sample.GetObjectSample,
-	"CnameSample":           sample.CnameSample,
-	"SignURLSample":         sample.SignURLSample,
-	"ArchiveSample":         sample.ArchiveSample,
-	"ObjectTaggingSample":   sample.ObjectTaggingSample,
+	"CreateBucketSample":     sample.CreateBucketSample,
+	"NewBucketSample":        sample.NewBucketSample,
+	"ListBucketsSample":      sample.ListBucketsSample,
+	"BucketACLSample":        sample.BucketACLSample,
+	"BucketLifecycleSample":  sample.BucketLifecycleSample,
+	"BucketRefererSample":    sample.BucketRefererSample,
+	"BucketLoggingSample":    sample.BucketLoggingSample,
+	"BucketCORSSample":       sample.BucketCORSSample,
+	"ObjectACLSample":        sample.ObjectACLSample,
+	"ObjectMetaSample":       sample.ObjectMetaSample,
+	"ListObjectsSample":      sample.ListObjectsSample,
+	"DeleteObjectSample":     sample.DeleteObjectSample,
+	"AppendObjectSample":     sample.AppendObjectSample,
+	"CopyObjectSample":       sample.CopyObjectSample,
+	"PutObjectSample":        sample.PutObjectSample,
+	"GetObjectSample":        sample.GetObjectSample,
+	"CnameSample":            sample.CnameSample,
+	"SignURLSample":          sample.SignURLSample,
+	"ArchiveSample":          sample.ArchiveSample,
+	"ObjectTaggingSample":    sample.ObjectTaggingSample,
+	"BucketEncryptionSample": sample.BucketEncryptionSample,
 }
 
 func main() {

sample/bucket_encryption.go

@@ -0,0 +1,51 @@
+package sample
+
+import (
+	"fmt"
+
+	"github.com/aliyun/aliyun-oss-go-sdk/oss"
+)
+
+// BucketEncryptionSample shows how to get and set the bucket encryption Algorithm
+func BucketEncryptionSample() {
+	// New client
+	client, err := oss.New(endpoint, accessID, accessKey)
+	if err != nil {
+		HandleError(err)
+	}
+
+	// Create a bucket with default parameters
+	err = client.CreateBucket(bucketName)
+	if err != nil {
+		HandleError(err)
+	}
+
+	// SetBucketEncryption:AES256 ,"123"
+	encryptionRule := oss.ServerEncryptionRule{}
+	encryptionRule.SSEDefault.SSEAlgorithm = string(oss.AESAlgorithm)
+	err = client.SetBucketEncryption(bucketName, encryptionRule)
+	if err != nil {
+		HandleError(err)
+	}
+
+	// Get bucket encryption
+	encryptionResult, err := client.GetBucketEncryption(bucketName)
+	if err != nil {
+		HandleError(err)
+	}
+	fmt.Println("Bucket Encryption:", encryptionResult)
+
+	// Delete the bucket
+	err = client.DeleteBucketEncryption(bucketName)
+	if err != nil {
+		HandleError(err)
+	}
+
+	// Delete the object and bucket
+	err = DeleteTestBucketAndObject(bucketName)
+	if err != nil {
+		HandleError(err)
+	}
+
+	fmt.Println("BucketEncryptionSample completed")
+}

sample/copy_object.go

@@ -120,10 +120,10 @@ func CopyObjectSample() {
 		Key:   "key2",
 		Value: "value2",
 	}
-	tagging := oss.ObjectTagging{
+	tagging := oss.Tagging{
 		Tags: []oss.Tag{tag1, tag2},
 	}
-	_, err = bucket.CopyObject(objectKey, objectKey+"WithTagging", oss.Tagging(tagging), oss.TaggingDirective(oss.TaggingReplace))
+	_, err = bucket.CopyObject(objectKey, objectKey+"WithTagging", oss.SetTagging(tagging), oss.TaggingDirective(oss.TaggingReplace))
 	if err != nil {
 		HandleError(err)
 	}

sample/object_tagging.go

@@ -30,7 +30,7 @@ func ObjectTaggingSample() {
 		Key:   "key2",
 		Value: "value2",
 	}
-	tagging := oss.ObjectTagging{
+	tagging := oss.Tagging{
 		Tags: []oss.Tag{tag1, tag2},
 	}
 	err = bucket.PutObjectTagging(objectKey, tagging)
@@ -39,11 +39,11 @@ func ObjectTaggingSample() {
 	}
 
 	// Case 2: Get Tagging of object
-	tagging, err = bucket.GetObjectTagging(objectKey)
+	taggingResult, err := bucket.GetObjectTagging(objectKey)
 	if err != nil {
 		HandleError(err)
 	}
-	fmt.Printf("Object Tagging: %v\n", tagging)
+	fmt.Printf("Object Tagging: %v\n", taggingResult)
 
 	tag3 := oss.Tag{
 		Key:   "key3",
@@ -51,10 +51,10 @@ func ObjectTaggingSample() {
 	}
 
 	// Case 3: Put object with tagging
-	tagging = oss.ObjectTagging{
+	tagging = oss.Tagging{
 		Tags: []oss.Tag{tag1, tag2, tag3},
 	}
-	err = bucket.PutObject(objectKey, strings.NewReader("ObjectTaggingSample"), oss.Tagging(tagging))
+	err = bucket.PutObject(objectKey, strings.NewReader("ObjectTaggingSample"), oss.SetTagging(tagging))
 	if err != nil {
 		HandleError(err)
 	}