apitech
/
loki
mirror of https://github.com/grafana/loki
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

fix(deps): update module github.com/baidubce/bce-sdk-go to v0.9.186 (#13864)

Browse Source 
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
pull/13865/head
renovate[bot] 10 months ago committed by GitHub
parent 6f791941ee
commit 3c0e3e2c13
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
14 changed files with 941 additions and 304 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      go.mod
  2. 4
      go.sum
  3. 5
      vendor/github.com/baidubce/bce-sdk-go/bce/client.go
  4. 4
      vendor/github.com/baidubce/bce-sdk-go/bce/config.go
  5. 19
      vendor/github.com/baidubce/bce-sdk-go/http/client.go
  6. 4
      vendor/github.com/baidubce/bce-sdk-go/http/constants.go
  7. 4
      vendor/github.com/baidubce/bce-sdk-go/http/request.go
  8. 335
      vendor/github.com/baidubce/bce-sdk-go/services/bos/api/bucket.go
  9. 80
      vendor/github.com/baidubce/bce-sdk-go/services/bos/api/model.go
  10. 48
      vendor/github.com/baidubce/bce-sdk-go/services/bos/api/multipart.go
  11. 223
      vendor/github.com/baidubce/bce-sdk-go/services/bos/api/object.go
  12. 169
      vendor/github.com/baidubce/bce-sdk-go/services/bos/api/util.go
  13. 322
      vendor/github.com/baidubce/bce-sdk-go/services/bos/client.go
  14. 2
      vendor/modules.txt

2
go.mod
Unescape View File

@ -19,7 +19,7 @@ require (
github.com/alicebob/miniredis/v2 v2.30.4
github.com/aliyun/aliyun-oss-go-sdk v2.2.10+incompatible
github.com/aws/aws-sdk-go v1.54.19
github.com/baidubce/bce-sdk-go v0.9.141
github.com/baidubce/bce-sdk-go v0.9.186
github.com/bmatcuk/doublestar v1.3.4
github.com/c2h5oh/datasize v0.0.0-20231215233829-aa82cc1e6500
github.com/cespare/xxhash v1.1.0

4
go.sum
Unescape View File

@ -385,8 +385,8 @@ github.com/aws/smithy-go v1.11.1 h1:IQ+lPZVkSM3FRtyaDox41R8YS6iwPMYIreejOgPW49g=
github.com/aws/smithy-go v1.11.1/go.mod h1:3xHYmszWVx2c0kIwQeEVf9uSm4fYZt67FBJnwub1bgM=
github.com/axiomhq/hyperloglog v0.0.0-20240507144631-af9851f82b27 h1:60m4tnanN1ctzIu4V3bfCNJ39BiOPSm1gHFlFjTkRE0=
github.com/axiomhq/hyperloglog v0.0.0-20240507144631-af9851f82b27/go.mod h1:k08r+Yj1PRAmuayFiRK6MYuR5Ve4IuZtTfxErMIh0+c=
github.com/baidubce/bce-sdk-go v0.9.141 h1:EV5BH5lfymIGPSmYDo9xYdsVlvWAW6nFeiA6t929zBE=
github.com/baidubce/bce-sdk-go v0.9.141/go.mod h1:zbYJMQwE4IZuyrJiFO8tO8NbtYiKTFTbwh4eIsqjVdg=
github.com/baidubce/bce-sdk-go v0.9.186 h1:GVJTwH34UhsY0Plh9avlNw1V3F2N20p7hzcrRTf2zpk=
github.com/baidubce/bce-sdk-go v0.9.186/go.mod h1:zbYJMQwE4IZuyrJiFO8tO8NbtYiKTFTbwh4eIsqjVdg=
github.com/baiyubin/aliyun-sts-go-sdk v0.0.0-20180326062324-cfa1a18b161f/go.mod h1:AuiFmCCPBSrqvVMvuqFuk0qogytodnVFVSN5CeJB8Gc=
github.com/bboreham/go-loser v0.0.0-20230920113527-fcc2c21820a3 h1:6df1vn4bBlDDo4tARvBm7l6KA9iVMnE3NWizDeWSrps=
github.com/bboreham/go-loser v0.0.0-20230920113527-fcc2c21820a3/go.mod h1:CIWtjkly68+yqLPbvwwR/fjNJA/idrtULjZWh2v1ys0=

5
vendor/github.com/baidubce/bce-sdk-go/bce/client.go generated vendored
Unescape View File

@ -155,6 +155,11 @@ func (c *BceClient) SendRequest(req *BceRequest, resp *BceResponse) error {
log.Infof("receive http response: status: %s, debugId: %s, requestId: %s, elapsed: %v",
resp.StatusText(), resp.DebugId(), resp.RequestId(), resp.ElapsedTime())
if resp.ElapsedTime().Milliseconds() > DEFAULT_WARN_LOG_TIMEOUT_IN_MILLS {
log.Warnf("request time more than 5 second, debugId: %s, requestId: %s, elapsed: %v",
resp.DebugId(), resp.RequestId(), resp.ElapsedTime())
}
for k, v := range resp.Headers() {
log.Debugf("%s=%s", k, v)
}

4
vendor/github.com/baidubce/bce-sdk-go/bce/config.go generated vendored
Unescape View File

@ -26,13 +26,15 @@ import (
// Constants and default values for the package bce
const (
SDK_VERSION = "0.9.141"
SDK_VERSION = "0.9.186"
URI_PREFIX = "/" // now support uri without prefix "v1" so just set root path
DEFAULT_DOMAIN = "baidubce.com"
DEFAULT_PROTOCOL = "http"
HTTPS_PROTOCAL = "https"
DEFAULT_REGION = "bj"
DEFAULT_CONTENT_TYPE = "application/json;charset=utf-8"
DEFAULT_CONNECTION_TIMEOUT_IN_MILLIS = 1200 * 1000
DEFAULT_WARN_LOG_TIMEOUT_IN_MILLS = 5 * 1000
)
var (

19
vendor/github.com/baidubce/bce-sdk-go/http/client.go generated vendored
Unescape View File

@ -172,3 +172,22 @@ func Execute(request *Request) (*Response, error) {
response := &Response{httpResponse, end.Sub(start)}
return response, nil
}
func SetResponseHeaderTimeout(t int) {
transport = &http.Transport{
MaxIdleConnsPerHost: defaultMaxIdleConnsPerHost,
ResponseHeaderTimeout: time.Duration(t) * time.Second,
Dial: func(network, address string) (net.Conn, error) {
conn, err := net.DialTimeout(network, address, defaultDialTimeout)
if err != nil {
return nil, err
}
tc := &timeoutConn{conn, defaultSmallInterval, defaultLargeInterval}
err = tc.SetReadDeadline(time.Now().Add(defaultLargeInterval))
if err != nil {
return nil, err
}
return tc, nil
},
}
httpClient.Transport = transport
}

4
vendor/github.com/baidubce/bce-sdk-go/http/constants.go generated vendored
Unescape View File

@ -61,6 +61,7 @@ const (
BCE_USER_METADATA_PREFIX = "x-bce-meta-"
BCE_SECURITY_TOKEN = "x-bce-security-token"
BCE_DATE = "x-bce-date"
BCE_TAG = "x-bce-tag-list"
// BOS HTTP Headers
BCE_COPY_METADATA_DIRECTIVE = "x-bce-metadata-directive"
@ -80,5 +81,8 @@ const (
BCE_RESTORE = "x-bce-restore"
BCE_FORBID_OVERWRITE = "x-bce-forbid-overwrite"
BCE_SYMLINK_TARGET = "x-bce-symlink-target"
BCE_SYMLINK_BUCKET = "x-bce-symlink-bucket"
BCE_TRAFFIC_LIMIT = "x-bce-traffic-limit"
BCE_BUCKET_TYPE = "x-bce-bucket-type"
BCE_OBJECT_TAGGING = "x-bce-tagging"
)

4
vendor/github.com/baidubce/bce-sdk-go/http/request.go generated vendored
Unescape View File

@ -149,8 +149,12 @@ func (r *Request) SetParam(key, value string) {
func (r *Request) QueryString() string {
buf := make([]string, 0, len(r.params))
for k, v := range r.params {
if len(v) == 0 {
buf = append(buf, util.UriEncode(k, true))
} else {
buf = append(buf, util.UriEncode(k, true)+"="+util.UriEncode(v, true))
}
}
return strings.Join(buf, "&")
}

335
vendor/github.com/baidubce/bce-sdk-go/services/bos/api/bucket.go generated vendored
Unescape View File

@ -32,11 +32,11 @@ import (
// RETURNS:
// - *ListBucketsResult: the result bucket list structure
// - error: nil if ok otherwise the specific error
func ListBuckets(cli bce.Client) (*ListBucketsResult, error) {
func ListBuckets(cli bce.Client, ctx *BosContext) (*ListBucketsResult, error) {
req := &bce.BceRequest{}
req.SetMethod(http.GET)
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -59,11 +59,11 @@ func ListBuckets(cli bce.Client) (*ListBucketsResult, error) {
// - *ListObjectsResult: the result object list structure
// - error: nil if ok otherwise the specific error
func ListObjects(cli bce.Client, bucket string,
args *ListObjectsArgs) (*ListObjectsResult, error) {
args *ListObjectsArgs, ctx *BosContext) (*ListObjectsResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
ctx.Bucket = bucket
// Optional arguments settings
if args != nil {
if len(args.Delimiter) != 0 {
@ -85,7 +85,7 @@ func ListObjects(cli bce.Client, bucket string,
// Send the request and get result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -106,19 +106,20 @@ func ListObjects(cli bce.Client, bucket string,
// - bucket: the bucket name
// RETURNS:
// - error: nil if exists and have authority otherwise the specific error
func HeadBucket(cli bce.Client, bucket string) error {
func HeadBucket(cli bce.Client, bucket string, ctx *BosContext) (error, *bce.BceResponse) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.HEAD)
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
return err
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err, resp
}
if resp.IsFail() {
return resp.ServiceError()
return resp.ServiceError(), resp
}
defer func() { resp.Body().Close() }()
return nil
return nil, resp
}
// PutBucket - create a new bucket with the given name
@ -129,12 +130,18 @@ func HeadBucket(cli bce.Client, bucket string) error {
// RETURNS:
// - string: the location of the new bucket if create success
// - error: nil if create success otherwise the specific error
func PutBucket(cli bce.Client, bucket string) (string, error) {
func PutBucket(cli bce.Client, bucket string, args *PutBucketArgs, ctx *BosContext) (string, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
ctx.Bucket = bucket
if args != nil {
if len(args.TagList) != 0 {
req.SetHeader(http.BCE_TAG, args.TagList)
}
}
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return "", err
}
if resp.IsFail() {
@ -151,12 +158,13 @@ func PutBucket(cli bce.Client, bucket string) (string, error) {
// - bucket: the bucket name to be deleted
// RETURNS:
// - error: nil if delete success otherwise the specific error
func DeleteBucket(cli bce.Client, bucket string) error {
func DeleteBucket(cli bce.Client, bucket string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -174,13 +182,14 @@ func DeleteBucket(cli bce.Client, bucket string) error {
// RETURNS:
// - string: the location of the bucket
// - error: nil if delete success otherwise the specific error
func GetBucketLocation(cli bce.Client, bucket string) (string, error) {
func GetBucketLocation(cli bce.Client, bucket string, ctx *BosContext) (string, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("location", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return "", err
}
if resp.IsFail() {
@ -203,12 +212,12 @@ func GetBucketLocation(cli bce.Client, bucket string) (string, error) {
// - aclBody: the acl file body
// RETURNS:
// - error: nil if delete success otherwise the specific error
func PutBucketAcl(cli bce.Client, bucket, cannedAcl string, aclBody *bce.Body) error {
func PutBucketAcl(cli bce.Client, bucket, cannedAcl string, aclBody *bce.Body, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("acl", "")
ctx.Bucket = bucket
// The acl setting
if len(cannedAcl) != 0 && aclBody != nil {
return bce.NewBceClientError("BOS does not support cannedAcl and acl file at the same time")
@ -222,7 +231,7 @@ func PutBucketAcl(cli bce.Client, bucket, cannedAcl string, aclBody *bce.Body) e
}
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -240,14 +249,14 @@ func PutBucketAcl(cli bce.Client, bucket, cannedAcl string, aclBody *bce.Body) e
// RETURNS:
// - *GetBucketAclResult: the result of the bucket acl
// - error: nil if success otherwise the specific error
func GetBucketAcl(cli bce.Client, bucket string) (*GetBucketAclResult, error) {
func GetBucketAcl(cli bce.Client, bucket string, ctx *BosContext) (*GetBucketAclResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("acl", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -269,14 +278,15 @@ func GetBucketAcl(cli bce.Client, bucket string) (*GetBucketAclResult, error) {
// - logging: the logging prefix json string body
// RETURNS:
// - error: nil if success otherwise the specific error
func PutBucketLogging(cli bce.Client, bucket string, logging *bce.Body) error {
func PutBucketLogging(cli bce.Client, bucket string, logging *bce.Body, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("logging", "")
req.SetBody(logging)
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -294,14 +304,14 @@ func PutBucketLogging(cli bce.Client, bucket string, logging *bce.Body) error {
// RETURNS:
// - *GetBucketLoggingResult: the logging setting of the bucket
// - error: nil if success otherwise the specific error
func GetBucketLogging(cli bce.Client, bucket string) (*GetBucketLoggingResult, error) {
func GetBucketLogging(cli bce.Client, bucket string, ctx *BosContext) (*GetBucketLoggingResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("logging", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -321,13 +331,14 @@ func GetBucketLogging(cli bce.Client, bucket string) (*GetBucketLoggingResult, e
// - bucket: the bucket name
// RETURNS:
// - error: nil if success otherwise the specific error
func DeleteBucketLogging(cli bce.Client, bucket string) error {
func DeleteBucketLogging(cli bce.Client, bucket string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
req.SetParam("logging", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -345,14 +356,15 @@ func DeleteBucketLogging(cli bce.Client, bucket string) error {
// - lifecycle: the lifecycle rule json string body
// RETURNS:
// - error: nil if success otherwise the specific error
func PutBucketLifecycle(cli bce.Client, bucket string, lifecycle *bce.Body) error {
func PutBucketLifecycle(cli bce.Client, bucket string, lifecycle *bce.Body, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("lifecycle", "")
req.SetBody(lifecycle)
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -370,14 +382,14 @@ func PutBucketLifecycle(cli bce.Client, bucket string, lifecycle *bce.Body) erro
// RETURNS:
// - *GetBucketLifecycleResult: the lifecycle rule of the bucket
// - error: nil if success otherwise the specific error
func GetBucketLifecycle(cli bce.Client, bucket string) (*GetBucketLifecycleResult, error) {
func GetBucketLifecycle(cli bce.Client, bucket string, ctx *BosContext) (*GetBucketLifecycleResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("lifecycle", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -397,13 +409,14 @@ func GetBucketLifecycle(cli bce.Client, bucket string) (*GetBucketLifecycleResul
// - bucket: the bucket name
// RETURNS:
// - error: nil if success otherwise the specific error
func DeleteBucketLifecycle(cli bce.Client, bucket string) error {
func DeleteBucketLifecycle(cli bce.Client, bucket string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
req.SetParam("lifecycle", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -421,12 +434,12 @@ func DeleteBucketLifecycle(cli bce.Client, bucket string) error {
// - storageClass: the storage class string
// RETURNS:
// - error: nil if success otherwise the specific error
func PutBucketStorageclass(cli bce.Client, bucket, storageClass string) error {
func PutBucketStorageclass(cli bce.Client, bucket, storageClass string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("storageClass", "")
ctx.Bucket = bucket
obj := &StorageClassType{storageClass}
jsonBytes, jsonErr := json.Marshal(obj)
if jsonErr != nil {
@ -439,7 +452,7 @@ func PutBucketStorageclass(cli bce.Client, bucket, storageClass string) error {
req.SetBody(body)
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -457,14 +470,14 @@ func PutBucketStorageclass(cli bce.Client, bucket, storageClass string) error {
// RETURNS:
// - string: the storage class of the bucket
// - error: nil if success otherwise the specific error
func GetBucketStorageclass(cli bce.Client, bucket string) (string, error) {
func GetBucketStorageclass(cli bce.Client, bucket string, ctx *BosContext) (string, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("storageClass", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return "", err
}
if resp.IsFail() {
@ -486,11 +499,12 @@ func GetBucketStorageclass(cli bce.Client, bucket string) (string, error) {
// - replicationRuleId: the replication rule id composed of [0-9 A-Z a-z _ -]
// RETURNS:
// - error: nil if success otherwise the specific error
func PutBucketReplication(cli bce.Client, bucket string, replicationConf *bce.Body, replicationRuleId string) error {
func PutBucketReplication(cli bce.Client, bucket string, replicationConf *bce.Body, replicationRuleId string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("replication", "")
ctx.Bucket = bucket
if len(replicationRuleId) > 0 {
req.SetParam("id", replicationRuleId)
}
@ -501,7 +515,7 @@ func PutBucketReplication(cli bce.Client, bucket string, replicationConf *bce.Bo
}
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -520,17 +534,18 @@ func PutBucketReplication(cli bce.Client, bucket string, replicationConf *bce.Bo
// RETURNS:
// - *GetBucketReplicationResult: the result of the bucket replication config
// - error: nil if success otherwise the specific error
func GetBucketReplication(cli bce.Client, bucket string, replicationRuleId string) (*GetBucketReplicationResult, error) {
func GetBucketReplication(cli bce.Client, bucket string, replicationRuleId string, ctx *BosContext) (*GetBucketReplicationResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("replication", "")
ctx.Bucket = bucket
if len(replicationRuleId) > 0 {
req.SetParam("id", replicationRuleId)
}
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -550,12 +565,13 @@ func GetBucketReplication(cli bce.Client, bucket string, replicationRuleId strin
// - bucket: the bucket name
// RETURNS:
// - error: nil if success otherwise the specific error
func ListBucketReplication(cli bce.Client, bucket string) (*ListBucketReplicationResult, error) {
func ListBucketReplication(cli bce.Client, bucket string, ctx *BosContext) (*ListBucketReplicationResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("replication", "")
req.SetParam("list", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := cli.SendRequest(req, resp); err != nil {
return nil, err
@ -578,16 +594,17 @@ func ListBucketReplication(cli bce.Client, bucket string) (*ListBucketReplicatio
// - replicationRuleId: the replication rule id composed of [0-9 A-Z a-z _ -]
// RETURNS:
// - error: nil if success otherwise the specific error
func DeleteBucketReplication(cli bce.Client, bucket string, replicationRuleId string) error {
func DeleteBucketReplication(cli bce.Client, bucket string, replicationRuleId string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
req.SetParam("replication", "")
ctx.Bucket = bucket
if len(replicationRuleId) > 0 {
req.SetParam("id", replicationRuleId)
}
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -606,18 +623,19 @@ func DeleteBucketReplication(cli bce.Client, bucket string, replicationRuleId st
// RETURNS:
// - *GetBucketReplicationProgressResult: the result of the bucket replication process
// - error: nil if success otherwise the specific error
func GetBucketReplicationProgress(cli bce.Client, bucket string, replicationRuleId string) (
func GetBucketReplicationProgress(cli bce.Client, bucket string, replicationRuleId string, ctx *BosContext) (
*GetBucketReplicationProgressResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("replicationProgress", "")
ctx.Bucket = bucket
if len(replicationRuleId) > 0 {
req.SetParam("id", replicationRuleId)
}
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -638,12 +656,12 @@ func GetBucketReplicationProgress(cli bce.Client, bucket string, replicationRule
// - algorithm: the encryption algorithm
// RETURNS:
// - error: nil if success otherwise the specific error
func PutBucketEncryption(cli bce.Client, bucket, algorithm string) error {
func PutBucketEncryption(cli bce.Client, bucket, algorithm string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("encryption", "")
ctx.Bucket = bucket
obj := &BucketEncryptionType{algorithm}
jsonBytes, jsonErr := json.Marshal(obj)
if jsonErr != nil {
@ -657,7 +675,7 @@ func PutBucketEncryption(cli bce.Client, bucket, algorithm string) error {
req.SetBody(body)
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -675,14 +693,14 @@ func PutBucketEncryption(cli bce.Client, bucket, algorithm string) error {
// RETURNS:
// - algorithm: the bucket encryption algorithm
// - error: nil if success otherwise the specific error
func GetBucketEncryption(cli bce.Client, bucket string) (string, error) {
func GetBucketEncryption(cli bce.Client, bucket string, ctx *BosContext) (string, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("encryption", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return "", err
}
if resp.IsFail() {
@ -702,13 +720,14 @@ func GetBucketEncryption(cli bce.Client, bucket string) (string, error) {
// - bucket: the bucket name
// RETURNS:
// - error: nil if success otherwise the specific error
func DeleteBucketEncryption(cli bce.Client, bucket string) error {
func DeleteBucketEncryption(cli bce.Client, bucket string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
req.SetParam("encryption", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -726,18 +745,19 @@ func DeleteBucketEncryption(cli bce.Client, bucket string) error {
// - confBody: the static website config body stream
// RETURNS:
// - error: nil if success otherwise the specific error
func PutBucketStaticWebsite(cli bce.Client, bucket string, confBody *bce.Body) error {
func PutBucketStaticWebsite(cli bce.Client, bucket string, confBody *bce.Body, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("website", "")
ctx.Bucket = bucket
if confBody != nil {
req.SetHeader(http.CONTENT_TYPE, bce.DEFAULT_CONTENT_TYPE)
req.SetBody(confBody)
}
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -755,15 +775,15 @@ func PutBucketStaticWebsite(cli bce.Client, bucket string, confBody *bce.Body) e
// RETURNS:
// - result: the bucket static website config result object
// - error: nil if success otherwise the specific error
func GetBucketStaticWebsite(cli bce.Client, bucket string) (
func GetBucketStaticWebsite(cli bce.Client, bucket string, ctx *BosContext) (
*GetBucketStaticWebsiteResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("website", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -783,13 +803,14 @@ func GetBucketStaticWebsite(cli bce.Client, bucket string) (
// - bucket: the bucket name
// RETURNS:
// - error: nil if success otherwise the specific error
func DeleteBucketStaticWebsite(cli bce.Client, bucket string) error {
func DeleteBucketStaticWebsite(cli bce.Client, bucket string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
req.SetParam("website", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -807,18 +828,19 @@ func DeleteBucketStaticWebsite(cli bce.Client, bucket string) error {
// - confBody: the CORS config body stream
// RETURNS:
// - error: nil if success otherwise the specific error
func PutBucketCors(cli bce.Client, bucket string, confBody *bce.Body) error {
func PutBucketCors(cli bce.Client, bucket string, confBody *bce.Body, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("cors", "")
ctx.Bucket = bucket
if confBody != nil {
req.SetHeader(http.CONTENT_TYPE, bce.DEFAULT_CONTENT_TYPE)
req.SetBody(confBody)
}
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -836,15 +858,15 @@ func PutBucketCors(cli bce.Client, bucket string, confBody *bce.Body) error {
// RETURNS:
// - result: the bucket CORS config result object
// - error: nil if success otherwise the specific error
func GetBucketCors(cli bce.Client, bucket string) (
func GetBucketCors(cli bce.Client, bucket string, ctx *BosContext) (
*GetBucketCorsResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("cors", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -864,13 +886,14 @@ func GetBucketCors(cli bce.Client, bucket string) (
// - bucket: the bucket name
// RETURNS:
// - error: nil if success otherwise the specific error
func DeleteBucketCors(cli bce.Client, bucket string) error {
func DeleteBucketCors(cli bce.Client, bucket string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
req.SetParam("cors", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -888,11 +911,12 @@ func DeleteBucketCors(cli bce.Client, bucket string) error {
// - resources: the resource items in the bucket to be protected
// RETURNS:
// - error: nil if success otherwise the specific error
func PutBucketCopyrightProtection(cli bce.Client, bucket string, resources ...string) error {
func PutBucketCopyrightProtection(cli bce.Client, ctx *BosContext, bucket string, resources ...string) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("copyrightProtection", "")
ctx.Bucket = bucket
if len(resources) == 0 {
return bce.NewBceClientError("the resource to set copyright protection is empty")
}
@ -909,7 +933,7 @@ func PutBucketCopyrightProtection(cli bce.Client, bucket string, resources ...st
req.SetBody(body)
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -927,14 +951,14 @@ func PutBucketCopyrightProtection(cli bce.Client, bucket string, resources ...st
// RETURNS:
// - result: the bucket copyright protection resources array
// - error: nil if success otherwise the specific error
func GetBucketCopyrightProtection(cli bce.Client, bucket string) ([]string, error) {
func GetBucketCopyrightProtection(cli bce.Client, bucket string, ctx *BosContext) ([]string, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("copyrightProtection", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -954,13 +978,14 @@ func GetBucketCopyrightProtection(cli bce.Client, bucket string) ([]string, erro
// - bucket: the bucket name
// RETURNS:
// - error: nil if success otherwise the specific error
func DeleteBucketCopyrightProtection(cli bce.Client, bucket string) error {
func DeleteBucketCopyrightProtection(cli bce.Client, bucket string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
req.SetParam("copyrightProtection", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -978,11 +1003,12 @@ func DeleteBucketCopyrightProtection(cli bce.Client, bucket string) error {
// - trashDir: the trash dir name
// RETURNS:
// - error: nil if success otherwise the specific error
func PutBucketTrash(cli bce.Client, bucket string, trashReq PutBucketTrashReq) error {
func PutBucketTrash(cli bce.Client, bucket string, trashReq PutBucketTrashReq, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("trash", "")
ctx.Bucket = bucket
reqByte, _ := json.Marshal(trashReq)
body, err := bce.NewBodyFromString(string(reqByte))
if err != nil {
@ -990,7 +1016,7 @@ func PutBucketTrash(cli bce.Client, bucket string, trashReq PutBucketTrashReq) e
}
req.SetBody(body)
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -1000,13 +1026,14 @@ func PutBucketTrash(cli bce.Client, bucket string, trashReq PutBucketTrashReq) e
return nil
}
func GetBucketTrash(cli bce.Client, bucket string) (*GetBucketTrashResult, error) {
func GetBucketTrash(cli bce.Client, bucket string, ctx *BosContext) (*GetBucketTrashResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("trash", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -1019,13 +1046,14 @@ func GetBucketTrash(cli bce.Client, bucket string) (*GetBucketTrashResult, error
return result, nil
}
func DeleteBucketTrash(cli bce.Client, bucket string) error {
func DeleteBucketTrash(cli bce.Client, bucket string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
req.SetParam("trash", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -1035,11 +1063,12 @@ func DeleteBucketTrash(cli bce.Client, bucket string) error {
return nil
}
func PutBucketNotification(cli bce.Client, bucket string, putBucketNotificationReq PutBucketNotificationReq) error {
func PutBucketNotification(cli bce.Client, bucket string, putBucketNotificationReq PutBucketNotificationReq, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("notification", "")
ctx.Bucket = bucket
reqByte, _ := json.Marshal(putBucketNotificationReq)
body, err := bce.NewBodyFromString(string(reqByte))
if err != nil {
@ -1047,7 +1076,7 @@ func PutBucketNotification(cli bce.Client, bucket string, putBucketNotificationR
}
req.SetBody(body)
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -1057,13 +1086,14 @@ func PutBucketNotification(cli bce.Client, bucket string, putBucketNotificationR
return nil
}
func GetBucketNotification(cli bce.Client, bucket string) (*PutBucketNotificationReq, error) {
func GetBucketNotification(cli bce.Client, bucket string, ctx *BosContext) (*PutBucketNotificationReq, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("notification", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -1076,13 +1106,134 @@ func GetBucketNotification(cli bce.Client, bucket string) (*PutBucketNotificatio
return result, nil
}
func DeleteBucketNotification(cli bce.Client, bucket string) error {
func DeleteBucketNotification(cli bce.Client, bucket string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
req.SetParam("notification", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
return resp.ServiceError()
}
defer func() { resp.Body().Close() }()
return nil
}
func PutBucketMirror(cli bce.Client, bucket string, putBucketMirrorArgs *PutBucketMirrorArgs, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("mirroring", "")
ctx.Bucket = bucket
reqByte, _ := json.Marshal(putBucketMirrorArgs)
body, err := bce.NewBodyFromString(string(reqByte))
if err != nil {
return err
}
req.SetBody(body)
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
return resp.ServiceError()
}
defer func() { resp.Body().Close() }()
return nil
}
func GetBucketMirror(cli bce.Client, bucket string, ctx *BosContext) (*PutBucketMirrorArgs, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("mirroring", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
return nil, resp.ServiceError()
}
result := &PutBucketMirrorArgs{}
if err := resp.ParseJsonBody(result); err != nil {
return nil, err
}
return result, nil
}
func DeleteBucketMirror(cli bce.Client, bucket string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
req.SetParam("mirroring", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
return resp.ServiceError()
}
defer func() { resp.Body().Close() }()
return nil
}
func PutBucketTag(cli bce.Client, bucket string, putBucketTagArgs *PutBucketTagArgs, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.PUT)
req.SetParam("tagging", "")
ctx.Bucket = bucket
reqByte, _ := json.Marshal(putBucketTagArgs)
body, err := bce.NewBodyFromString(string(reqByte))
if err != nil {
return err
}
req.SetBody(body)
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
return resp.ServiceError()
}
defer func() { resp.Body().Close() }()
return nil
}
func GetBucketTag(cli bce.Client, bucket string, ctx *BosContext) (*GetBucketTagResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("tagging", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
return nil, resp.ServiceError()
}
result := &GetBucketTagResult{}
if err := resp.ParseJsonBody(result); err != nil {
return nil, err
}
return result, nil
}
func DeleteBucketTag(cli bce.Client, bucket string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.DELETE)
req.SetParam("tagging", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {

80
vendor/github.com/baidubce/bce-sdk-go/services/bos/api/model.go generated vendored
Unescape View File

@ -58,6 +58,10 @@ type PrefixType struct {
Prefix string `json:"prefix"`
}
type PutBucketArgs struct {
TagList string
}
// ListObjectsResult defines the result structure of ListObjects api.
type ListObjectsResult struct {
Name string `json:"name"`
@ -172,6 +176,7 @@ type StorageClassType struct {
type BucketReplicationDescriptor struct {
Bucket string `json:"bucket,omitempty"`
StorageClass string `json:"storageClass,omitempty"`
Prefix string `json:"prefix,omitempty"`
}
// BucketReplicationType defines the data structure for Put and Get of bucket replication
@ -179,6 +184,7 @@ type BucketReplicationType struct {
Id string `json:"id"`
Status string `json:"status"`
Resource []string `json:"resource"`
NotIncludeResource []string `json:"notIncludeResource,omitempty"`
ReplicateDeletes string `json:"replicateDeletes"`
Destination *BucketReplicationDescriptor `json:"destination,omitempty"`
ReplicateHistory *BucketReplicationDescriptor `json:"replicateHistory,omitempty"`
@ -259,6 +265,8 @@ type PutObjectArgs struct {
ContentCrc32 string
StorageClass string
Process string
CannedAcl string
ObjectTagging string
TrafficLimit int64
}
@ -271,12 +279,21 @@ type CopyObjectArgs struct {
IfModifiedSince string
IfUnmodifiedSince string
TrafficLimit int64
CannedAcl string
}
type MultiCopyObjectArgs struct {
StorageClass string
}
type CallbackResult struct {
Result string `json:"result"`
}
type PutObjectResult struct {
Callback CallbackResult `json:"callback"`
}
// CopyObjectResult defines the result json structure for the copy object api.
type CopyObjectResult struct {
LastModified string `json:"lastModified"`
@ -469,6 +486,7 @@ type PutSymlinkArgs struct {
ForbidOverwrite string
StorageClass string
UserMeta map[string]string
SymlinkBucket string
}
// UploadInfoType defines an uploaded part info structure.
@ -583,3 +601,65 @@ type PutBucketNotificationAppsSt struct {
EventUrl string `json:"eventUrl"`
XVars string `json:"xVars"`
}
type MirrorConfigurationRule struct {
Prefix string `json:"prefix,omitempty"`
SourceUrl string `json:"sourceUrl"`
PassQueryString bool `json:"passQuerystring"`
Mode string `json:"mode"`
StorageClass string `json:"storageClass"`
PassHeaders []string `json:"passHeaders"`
IgnoreHeaders []string `json:"ignoreHeaders"`
CustomHeaders []HeaderPair `json:"customHeaders"`
BackSourceUrl string `json:"backSourceUrl"`
Resource string `json:"resource"`
Suffix string `json:"suffix"`
FixedKey string `json:"fixedKey"`
PrefixReplace string `json:"prefixReplace"`
Version string `json:"version"`
}
type HeaderPair struct {
HeaderName string `json:"headerName"`
HeaderValue string `json:"headerValue"`
}
type PutBucketMirrorArgs struct {
BucketMirroringConfiguration []MirrorConfigurationRule `json:"bucketMirroringConfiguration"`
}
type PutBucketTagArgs struct {
Tags []Tag `json:"tags"`
}
type Tag struct {
TagKey string `json:"tagKey"`
TagValue string `json:"tagValue"`
}
type GetBucketTagResult struct {
Tags []BucketTag `json:"tag"`
}
type BucketTag struct {
TagKey string `json:"tag_key"`
TagValue string `json:"tag_value"`
}
type BosContext struct {
Bucket string
PathStyleEnable bool
}
type PutObjectTagArgs struct {
ObjectTags []ObjectTags `json:"tagSet"`
}
type ObjectTags struct {
TagInfo []ObjectTag `json:"tagInfo"`
}
type ObjectTag struct {
Key string `json:"key"`
Value string `json:"value"`
}

48
vendor/github.com/baidubce/bce-sdk-go/services/bos/api/multipart.go generated vendored
Unescape View File

@ -39,11 +39,12 @@ import (
// - *InitiateMultipartUploadResult: the result data structure
// - error: nil if ok otherwise the specific error
func InitiateMultipartUpload(cli bce.Client, bucket, object, contentType string,
args *InitiateMultipartUploadArgs) (*InitiateMultipartUploadResult, error) {
args *InitiateMultipartUploadArgs, ctx *BosContext) (*InitiateMultipartUploadResult, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.POST)
req.SetParam("uploads", "")
ctx.Bucket = bucket
if len(contentType) == 0 {
contentType = RAW_CONTENT_TYPE
}
@ -69,7 +70,7 @@ func InitiateMultipartUpload(cli bce.Client, bucket, object, contentType string,
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -97,12 +98,13 @@ func InitiateMultipartUpload(cli bce.Client, bucket, object, contentType string,
// - string: the etag of the uploaded part
// - error: nil if ok otherwise the specific error
func UploadPart(cli bce.Client, bucket, object, uploadId string, partNumber int,
content *bce.Body, args *UploadPartArgs) (string, error) {
content *bce.Body, args *UploadPartArgs, ctx *BosContext) (string, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.PUT)
req.SetParam("uploadId", uploadId)
req.SetParam("partNumber", fmt.Sprintf("%d", partNumber))
ctx.Bucket = bucket
if content == nil {
return "", bce.NewBceClientError("upload part content should not be empty")
}
@ -130,7 +132,7 @@ func UploadPart(cli bce.Client, bucket, object, uploadId string, partNumber int,
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return "", err
}
if resp.IsFail() {
@ -154,12 +156,13 @@ func UploadPart(cli bce.Client, bucket, object, uploadId string, partNumber int,
// - string: the etag of the uploaded part
// - error: nil if ok otherwise the specific error
func UploadPartFromBytes(cli bce.Client, bucket, object, uploadId string, partNumber int,
content []byte, args *UploadPartArgs) (string, error) {
content []byte, args *UploadPartArgs, ctx *BosContext) (string, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.PUT)
req.SetParam("uploadId", uploadId)
req.SetParam("partNumber", fmt.Sprintf("%d", partNumber))
ctx.Bucket = bucket
if content == nil {
return "", bce.NewBceClientError("upload part content should not be empty")
}
@ -188,6 +191,14 @@ func UploadPartFromBytes(cli bce.Client, bucket, object, uploadId string, partNu
http.BCE_CONTENT_SHA256: args.ContentSha256,
http.BCE_CONTENT_CRC32: args.ContentCrc32,
})
//set traffic-limit
if args.TrafficLimit > 0 {
if args.TrafficLimit > TRAFFIC_LIMIT_MAX || args.TrafficLimit < TRAFFIC_LIMIT_MIN {
return "", bce.NewBceClientError(fmt.Sprintf("TrafficLimit must between %d ~ %d, current value:%d",
TRAFFIC_LIMIT_MIN, TRAFFIC_LIMIT_MAX, args.TrafficLimit))
}
req.SetHeader(http.BCE_TRAFFIC_LIMIT, fmt.Sprintf("%d", args.TrafficLimit))
}
}
// Send request and get the result
resp := &bce.BceResponse{}
@ -215,12 +226,13 @@ func UploadPartFromBytes(cli bce.Client, bucket, object, uploadId string, partNu
// - *CopyObjectResult: the lastModified and eTag of the part
// - error: nil if ok otherwise the specific error
func UploadPartCopy(cli bce.Client, bucket, object, source, uploadId string, partNumber int,
args *UploadPartCopyArgs) (*CopyObjectResult, error) {
args *UploadPartCopyArgs, ctx *BosContext) (*CopyObjectResult, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.PUT)
req.SetParam("uploadId", uploadId)
req.SetParam("partNumber", fmt.Sprintf("%d", partNumber))
ctx.Bucket = bucket
if len(source) == 0 {
return nil, bce.NewBceClientError("upload part copy source should not be empty")
}
@ -246,7 +258,7 @@ func UploadPartCopy(cli bce.Client, bucket, object, source, uploadId string, par
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -272,11 +284,12 @@ func UploadPartCopy(cli bce.Client, bucket, object, source, uploadId string, par
// - *CompleteMultipartUploadResult: the result data
// - error: nil if ok otherwise the specific error
func CompleteMultipartUpload(cli bce.Client, bucket, object, uploadId string,
body *bce.Body, args *CompleteMultipartUploadArgs) (*CompleteMultipartUploadResult, error) {
body *bce.Body, args *CompleteMultipartUploadArgs, ctx *BosContext) (*CompleteMultipartUploadResult, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.POST)
req.SetParam("uploadId", uploadId)
ctx.Bucket = bucket
if body == nil {
return nil, bce.NewBceClientError("upload body info should not be emtpy")
}
@ -300,7 +313,7 @@ func CompleteMultipartUpload(cli bce.Client, bucket, object, uploadId string,
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -326,14 +339,14 @@ func CompleteMultipartUpload(cli bce.Client, bucket, object, uploadId string,
// - uploadId: the multipart upload id
// RETURNS:
// - error: nil if ok otherwise the specific error
func AbortMultipartUpload(cli bce.Client, bucket, object, uploadId string) error {
func AbortMultipartUpload(cli bce.Client, bucket, object, uploadId string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.DELETE)
req.SetParam("uploadId", uploadId)
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -357,12 +370,12 @@ func AbortMultipartUpload(cli bce.Client, bucket, object, uploadId string) error
// - *ListPartsResult: the uploaded parts info result
// - error: nil if ok otherwise the specific error
func ListParts(cli bce.Client, bucket, object, uploadId string,
args *ListPartsArgs) (*ListPartsResult, error) {
args *ListPartsArgs, ctx *BosContext) (*ListPartsResult, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.GET)
req.SetParam("uploadId", uploadId)
ctx.Bucket = bucket
// Optional arguments settings
if args != nil {
if len(args.PartNumberMarker) > 0 {
@ -375,7 +388,7 @@ func ListParts(cli bce.Client, bucket, object, uploadId string,
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -398,11 +411,12 @@ func ListParts(cli bce.Client, bucket, object, uploadId string,
// - *ListMultipartUploadsResult: the unfinished uploaded parts info result
// - error: nil if ok otherwise the specific error
func ListMultipartUploads(cli bce.Client, bucket string,
args *ListMultipartUploadsArgs) (*ListMultipartUploadsResult, error) {
args *ListMultipartUploadsArgs, ctx *BosContext) (*ListMultipartUploadsResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.GET)
req.SetParam("uploads", "")
ctx.Bucket = bucket
// Optional arguments settings
if args != nil {
@ -422,7 +436,7 @@ func ListMultipartUploads(cli bce.Client, bucket string,
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {

223
vendor/github.com/baidubce/bce-sdk-go/services/bos/api/object.go generated vendored
Unescape View File

@ -19,6 +19,7 @@ package api
import (
"encoding/json"
"fmt"
"io/ioutil"
"net"
"strconv"
"strings"
@ -41,12 +42,14 @@ import (
// - string: the etag of the object
// - error: nil if ok otherwise the specific error
func PutObject(cli bce.Client, bucket, object string, body *bce.Body,
args *PutObjectArgs) (string, error) {
args *PutObjectArgs, ctx *BosContext) (string, *PutObjectResult, error) {
req := &bce.BceRequest{}
NeedReturnCallback := false
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.PUT)
ctx.Bucket = bucket
if body == nil {
return "", bce.NewBceClientError("PutObject body should not be emtpy")
return "", nil, bce.NewBceClientError("PutObject body should not be emtpy")
}
if body.Size() >= THRESHOLD_100_CONTINUE {
req.SetHeader("Expect", "100-continue")
@ -68,11 +71,11 @@ func PutObject(cli bce.Client, bucket, object string, body *bce.Body,
// be reset. The `net/http.Client' does not support the Content-Length bigger than the
// body size.
if args.ContentLength > body.Size() {
return "", bce.NewBceClientError(fmt.Sprintf("ContentLength %d is bigger than body size %d", args.ContentLength, body.Size()))
return "", nil, bce.NewBceClientError(fmt.Sprintf("ContentLength %d is bigger than body size %d", args.ContentLength, body.Size()))
}
body, err := bce.NewBodyFromSizedReader(body.Stream(), args.ContentLength)
if err != nil {
return "", bce.NewBceClientError(err.Error())
return "", nil, bce.NewBceClientError(err.Error())
}
req.SetHeader(http.CONTENT_LENGTH, fmt.Sprintf("%d", args.ContentLength))
req.SetBody(body) // re-assign body
@ -81,7 +84,7 @@ func PutObject(cli bce.Client, bucket, object string, body *bce.Body,
//set traffic-limit
if args.TrafficLimit > 0 {
if args.TrafficLimit > TRAFFIC_LIMIT_MAX || args.TrafficLimit < TRAFFIC_LIMIT_MIN {
return "", bce.NewBceClientError(fmt.Sprintf("TrafficLimit must between %d ~ %d, current value:%d", TRAFFIC_LIMIT_MIN, TRAFFIC_LIMIT_MAX, args.TrafficLimit))
return "", nil, bce.NewBceClientError(fmt.Sprintf("TrafficLimit must between %d ~ %d, current value:%d", TRAFFIC_LIMIT_MIN, TRAFFIC_LIMIT_MAX, args.TrafficLimit))
}
req.SetHeader(http.BCE_TRAFFIC_LIMIT, fmt.Sprintf("%d", args.TrafficLimit))
}
@ -95,17 +98,30 @@ func PutObject(cli bce.Client, bucket, object string, body *bce.Body,
req.SetHeader(http.BCE_STORAGE_CLASS, args.StorageClass)
} else {
if len(args.StorageClass) != 0 {
return "", bce.NewBceClientError("invalid storage class value: " +
return "", nil, bce.NewBceClientError("invalid storage class value: " +
args.StorageClass)
}
}
if err := setUserMetadata(req, args.UserMeta); err != nil {
return "", err
return "", nil, err
}
if len(args.Process) != 0 {
req.SetHeader(http.BCE_PROCESS, args.Process)
if strings.HasPrefix(args.Process, "callback") {
NeedReturnCallback = true
}
}
if len(args.CannedAcl) != 0 {
if validCannedAcl(args.CannedAcl) {
req.SetHeader(http.BCE_ACL, args.CannedAcl)
}
}
if len(args.ObjectTagging) != 0 {
if ok, encodeTagging := validObjectTagging(args.ObjectTagging); ok {
req.SetHeader(http.BCE_OBJECT_TAGGING, encodeTagging)
}
}
}
// add content-type if not assigned by user
@ -114,14 +130,21 @@ func PutObject(cli bce.Client, bucket, object string, body *bce.Body,
}
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
return "", err
if err := SendRequest(cli, req, resp, ctx); err != nil {
return "", nil, err
}
if resp.IsFail() {
return "", resp.ServiceError()
return "", nil, resp.ServiceError()
}
defer func() { resp.Body().Close() }()
return strings.Trim(resp.Header(http.ETAG), "\""), nil
if NeedReturnCallback {
jsonBody := &PutObjectResult{}
if err := resp.ParseJsonBody(jsonBody); err != nil {
return "", nil, err
}
return strings.Trim(resp.Header(http.ETAG), "\""), jsonBody, nil
}
return strings.Trim(resp.Header(http.ETAG), "\""), nil, nil
}
// CopyObject - copy one object to a new object with new bucket and/or name. It can alse set the
@ -137,10 +160,11 @@ func PutObject(cli bce.Client, bucket, object string, body *bce.Body,
// - *CopyObjectResult: the result object which contains etag and lastmodified
// - error: nil if ok otherwise the specific error
func CopyObject(cli bce.Client, bucket, object, source string,
args *CopyObjectArgs) (*CopyObjectResult, error) {
args *CopyObjectArgs, ctx *BosContext) (*CopyObjectResult, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.PUT)
ctx.Bucket = bucket
if len(source) == 0 {
return nil, bce.NewBceClientError("copy source should not be null")
}
@ -194,6 +218,10 @@ func CopyObject(cli bce.Client, bucket, object, source string,
req.SetHeader(http.BCE_TRAFFIC_LIMIT, fmt.Sprintf("%d", args.TrafficLimit))
}
if validCannedAcl(args.CannedAcl) {
req.SetHeader(http.BCE_ACL, args.CannedAcl)
}
if err := setUserMetadata(req, args.UserMeta); err != nil {
return nil, err
}
@ -201,7 +229,7 @@ func CopyObject(cli bce.Client, bucket, object, source string,
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -220,12 +248,12 @@ func CopyObject(cli bce.Client, bucket, object, source string,
// - cli: the client agent which can perform sending request
// - bucket: the bucket name of the object
// - object: the name of the object
// - responseHeaders: the optional response headers to get the given object
// - args: the optional args in querysring
// - ranges: the optional range start and end to get the given object
// RETURNS:
// - *GetObjectResult: the output content result of the object
// - error: nil if ok otherwise the specific error
func GetObject(cli bce.Client, bucket, object string, responseHeaders map[string]string,
func GetObject(cli bce.Client, bucket, object string, ctx *BosContext, args map[string]string, // nolint:gocyclo
ranges ...int64) (*GetObjectResult, error) {
if object == "" {
@ -235,13 +263,16 @@ func GetObject(cli bce.Client, bucket, object string, responseHeaders map[string
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.GET)
ctx.Bucket = bucket
// Optional arguments settings
if responseHeaders != nil {
for k, v := range responseHeaders {
if args != nil {
for k, v := range args {
if _, ok := GET_OBJECT_ALLOWED_RESPONSE_HEADERS[k]; ok {
req.SetParam("response"+k, v)
}
if strings.HasPrefix(k, http.BCE_PREFIX) {
req.SetParam(k, v)
}
}
}
if len(ranges) != 0 {
@ -256,7 +287,7 @@ func GetObject(cli bce.Client, bucket, object string, responseHeaders map[string
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -336,14 +367,14 @@ func GetObject(cli bce.Client, bucket, object string, responseHeaders map[string
// RETURNS:
// - *GetObjectMetaResult: the result of this api
// - error: nil if ok otherwise the specific error
func GetObjectMeta(cli bce.Client, bucket, object string) (*GetObjectMetaResult, error) {
func GetObjectMeta(cli bce.Client, bucket, object string, ctx *BosContext) (*GetObjectMetaResult, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.HEAD)
ctx.Bucket = bucket
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -427,13 +458,13 @@ func GetObjectMeta(cli bce.Client, bucket, object string) (*GetObjectMetaResult,
// RETURNS:
// - *SelectObjectResult: the output select content result of the object
// - error: nil if ok otherwise the specific error
func SelectObject(cli bce.Client, bucket, object string, args *SelectObjectArgs) (*SelectObjectResult, error) {
func SelectObject(cli bce.Client, bucket, object string, args *SelectObjectArgs, ctx *BosContext) (*SelectObjectResult, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.POST)
req.SetParam("select", "")
req.SetParam("type", args.SelectType)
ctx.Bucket = bucket
jsonBytes, jsonErr := json.Marshal(args)
if jsonErr != nil {
return nil, jsonErr
@ -446,7 +477,7 @@ func SelectObject(cli bce.Client, bucket, object string, args *SelectObjectArgs)
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -471,11 +502,12 @@ func SelectObject(cli bce.Client, bucket, object string, args *SelectObjectArgs)
// - *FetchObjectArgs: the result of this api
// - error: nil if ok otherwise the specific error
func FetchObject(cli bce.Client, bucket, object, source string,
args *FetchObjectArgs) (*FetchObjectResult, error) {
args *FetchObjectArgs, ctx *BosContext) (*FetchObjectResult, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.POST)
req.SetParam("fetch", "")
ctx.Bucket = bucket
if len(source) == 0 {
return nil, bce.NewBceClientError("invalid fetch source value: " + source)
}
@ -502,7 +534,7 @@ func FetchObject(cli bce.Client, bucket, object, source string,
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -527,11 +559,12 @@ func FetchObject(cli bce.Client, bucket, object, source string,
// - *AppendObjectResult: the result status for this api
// - error: nil if ok otherwise the specific error
func AppendObject(cli bce.Client, bucket, object string, content *bce.Body,
args *AppendObjectArgs) (*AppendObjectResult, error) {
args *AppendObjectArgs, ctx *BosContext) (*AppendObjectResult, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.POST)
req.SetParam("append", "")
ctx.Bucket = bucket
if content == nil {
return nil, bce.NewBceClientError("AppendObject body should not be emtpy")
}
@ -581,7 +614,7 @@ func AppendObject(cli bce.Client, bucket, object string, content *bce.Body,
// Send request and get the result
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -619,13 +652,13 @@ func AppendObject(cli bce.Client, bucket, object string, content *bce.Body,
// - object: the name of the object
// RETURNS:
// - error: nil if ok otherwise the specific error
func DeleteObject(cli bce.Client, bucket, object string) error {
func DeleteObject(cli bce.Client, bucket, object string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.DELETE)
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -645,12 +678,13 @@ func DeleteObject(cli bce.Client, bucket, object string) error {
// - *DeleteMultipleObjectsResult: the objects failed to delete
// - error: nil if ok otherwise the specific error
func DeleteMultipleObjects(cli bce.Client, bucket string,
objectListStream *bce.Body) (*DeleteMultipleObjectsResult, error) {
objectListStream *bce.Body, ctx *BosContext) (*DeleteMultipleObjectsResult, error) {
req := &bce.BceRequest{}
req.SetUri(getBucketUri(bucket))
req.SetMethod(http.POST)
req.SetParam("delete", "")
req.SetHeader(http.CONTENT_TYPE, "application/json; charset=utf-8")
ctx.Bucket = bucket
if objectListStream == nil {
return nil, bce.NewBceClientError("DeleteMultipleObjects body should not be emtpy")
}
@ -660,13 +694,18 @@ func DeleteMultipleObjects(cli bce.Client, bucket string,
req.SetBody(objectListStream)
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
return nil, resp.ServiceError()
}
jsonBody := &DeleteMultipleObjectsResult{}
if resp.Header(http.CONTENT_LENGTH) == "0" {
resp.Body().Close()
return jsonBody, nil
}
if err := resp.ParseJsonBody(jsonBody); err != nil {
return nil, err
}
@ -772,12 +811,12 @@ func GeneratePresignedUrlInternal(conf *bce.BceClientConfiguration, signer auth.
// RETURNS:
// - error: nil if success otherwise the specific error
func PutObjectAcl(cli bce.Client, bucket, object, cannedAcl string,
grantRead, grantFullControl []string, aclBody *bce.Body) error {
grantRead, grantFullControl []string, aclBody *bce.Body, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.PUT)
req.SetParam("acl", "")
ctx.Bucket = bucket
// Joiner for generate the user id list string for grant acl header
joiner := func(ids []string) string {
for i := range ids {
@ -813,7 +852,7 @@ func PutObjectAcl(cli bce.Client, bucket, object, cannedAcl string,
// Do sending request
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -832,14 +871,14 @@ func PutObjectAcl(cli bce.Client, bucket, object, cannedAcl string,
// RETURNS:
// - result: the object acl result object
// - error: nil if success otherwise the specific error
func GetObjectAcl(cli bce.Client, bucket, object string) (*GetObjectAclResult, error) {
func GetObjectAcl(cli bce.Client, bucket, object string, ctx *BosContext) (*GetObjectAclResult, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.GET)
req.SetParam("acl", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
@ -860,13 +899,14 @@ func GetObjectAcl(cli bce.Client, bucket, object string) (*GetObjectAclResult, e
// - object: the object name
// RETURNS:
// - error: nil if success otherwise the specific error
func DeleteObjectAcl(cli bce.Client, bucket, object string) error {
func DeleteObjectAcl(cli bce.Client, bucket, object string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.DELETE)
req.SetParam("acl", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -885,16 +925,16 @@ func DeleteObjectAcl(cli bce.Client, bucket, object string) error {
// - args: the restore args
// RETURNS:
// - error: nil if success otherwise the specific error
func RestoreObject(cli bce.Client, bucket string, object string, args ArchiveRestoreArgs) error {
func RestoreObject(cli bce.Client, bucket string, object string, args ArchiveRestoreArgs, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetParam("restore", "")
req.SetMethod(http.POST)
req.SetHeader(http.BCE_RESTORE_DAYS, strconv.Itoa(args.RestoreDays))
req.SetHeader(http.BCE_RESTORE_TIER, args.RestoreTier)
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -914,11 +954,12 @@ func RestoreObject(cli bce.Client, bucket string, object string, args ArchiveRes
// - symlinkArgs: the optional arguments of this api
// RETURNS:
// - error: nil if ok otherwise the specific error
func PutObjectSymlink(cli bce.Client, bucket string, object string, symlinkKey string, symlinkArgs *PutSymlinkArgs) error {
func PutObjectSymlink(cli bce.Client, bucket string, object string, symlinkKey string, symlinkArgs *PutSymlinkArgs, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, symlinkKey))
req.SetParam("symlink", "")
req.SetMethod(http.PUT)
ctx.Bucket = bucket
if symlinkArgs != nil {
if len(symlinkArgs.ForbidOverwrite) != 0 {
if !validForbidOverwrite(symlinkArgs.ForbidOverwrite) {
@ -942,11 +983,14 @@ func PutObjectSymlink(cli bce.Client, bucket string, object string, symlinkKey s
return err
}
}
if len(symlinkArgs.SymlinkBucket) != 0 {
req.SetHeader(http.BCE_SYMLINK_BUCKET, symlinkArgs.SymlinkBucket)
}
}
req.SetHeader(http.BCE_SYMLINK_TARGET, object)
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
@ -965,18 +1009,99 @@ func PutObjectSymlink(cli bce.Client, bucket string, object string, symlinkKey s
// RETURNS:
// - string: the name of the target object
// - error: nil if ok otherwise the specific error
func GetObjectSymlink(cli bce.Client, bucket string, symlinkKey string) (string, error) {
func GetObjectSymlink(cli bce.Client, bucket string, symlinkKey string, ctx *BosContext) (string, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, symlinkKey))
req.SetParam("symlink", "")
req.SetMethod(http.GET)
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp); err != nil {
if err := SendRequest(cli, req, resp, ctx); err != nil {
return "", err
}
if resp.IsFail() {
return "", resp.ServiceError()
}
defer func() { resp.Body().Close() }()
if resp.Header(http.BCE_SYMLINK_BUCKET) != "" {
result := BOS_CONFIG_PREFIX + resp.Header(http.BCE_SYMLINK_BUCKET) + "/" + resp.Header(http.BCE_SYMLINK_TARGET)
return result, nil
}
return resp.Header(http.BCE_SYMLINK_TARGET), nil
}
// PutObjectTag - set tag for given object
//
// PARAMS:
// - cli: the client agent which can perform sending request
// - bucket: the bucket name of the object
// - object: the name of the object
// - putObjectTagArgs: the arguments of object tag
// RETURNS:
// - error: nil if ok otherwise the specific error
func PutObjectTag(cli bce.Client, bucket, object string, putObjectTagArgs *PutObjectTagArgs, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.PUT)
req.SetParam("tagging", "")
ctx.Bucket = bucket
reqByte, _ := json.Marshal(putObjectTagArgs)
body, err := bce.NewBodyFromString(string(reqByte))
if err != nil {
return err
}
req.SetBody(body)
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
return resp.ServiceError()
}
defer func() { resp.Body().Close() }()
return nil
}
func GetObjectTag(cli bce.Client, bucket, object string, ctx *BosContext) (map[string]interface{}, error) {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.GET)
req.SetParam("tagging", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp, ctx); err != nil {
return nil, err
}
if resp.IsFail() {
return nil, resp.ServiceError()
}
defer func() { resp.Body().Close() }()
bodyBytes, err := ioutil.ReadAll(resp.Body())
if err != nil {
return nil, err
}
result, err := ParseObjectTagResult(bodyBytes)
if err != nil {
return nil, err
}
return result, nil
}
func DeleteObjectTag(cli bce.Client, bucket, object string, ctx *BosContext) error {
req := &bce.BceRequest{}
req.SetUri(getObjectUri(bucket, object))
req.SetMethod(http.DELETE)
req.SetParam("tagging", "")
ctx.Bucket = bucket
resp := &bce.BceResponse{}
if err := SendRequest(cli, req, resp, ctx); err != nil {
return err
}
if resp.IsFail() {
return resp.ServiceError()
}
defer func() { resp.Body().Close() }()
return nil
}

169
vendor/github.com/baidubce/bce-sdk-go/services/bos/api/util.go generated vendored
Unescape View File

@ -18,7 +18,11 @@ package api
import (
"bytes"
"encoding/json"
"fmt"
"net"
net_http "net/http"
"net/url"
"strings"
"github.com/baidubce/bce-sdk-go/bce"
@ -59,6 +63,9 @@ const (
FORBID_OVERWRITE_FALSE = "false"
FORBID_OVERWRITE_TRUE = "true"
NAMESPACE_BUCKET = "namespace"
BOS_CONFIG_PREFIX = "bos://"
)
var DEFAULT_CNAME_LIKE_LIST = []string{
@ -150,6 +157,29 @@ func validCannedAcl(val string) bool {
return false
}
func validObjectTagging(tagging string) (bool, string) {
if len(tagging) > 4000 {
return false, ""
}
encodeTagging := []string{}
pair := strings.Split(tagging, "&")
for _, p := range pair {
kv := strings.Split(p, "=")
if len(kv) != 2 {
return false, ""
}
key := kv[0]
value := kv[1]
encodeKey := url.QueryEscape(key)
encodeValue := url.QueryEscape(value)
if len(encodeKey) > 128 || len(encodeValue) > 256 {
return false, ""
}
encodeTagging = append(encodeTagging, encodeKey+"="+encodeValue)
}
return true, strings.Join(encodeTagging, "&")
}
func toHttpHeaderKey(key string) string {
var result bytes.Buffer
needToUpper := true
@ -235,22 +265,18 @@ func isCnameLikeHost(host string) bool {
return true
}
}
if isVirtualHost(host) {
return true
}
return false
}
func SendRequest(cli bce.Client, req *bce.BceRequest, resp *bce.BceResponse) error {
func SendRequest(cli bce.Client, req *bce.BceRequest, resp *bce.BceResponse, ctx *BosContext) error {
var (
err error
need_retry bool
)
req.SetEndpoint(cli.GetBceClientConfig().Endpoint)
origin_uri := req.Uri()
// set uri for cname or cdn endpoint
if cli.GetBceClientConfig().CnameEnabled || isCnameLikeHost(cli.GetBceClientConfig().Endpoint) {
req.SetUri(getCnameUri(origin_uri))
}
setUriAndEndpoint(cli, req, ctx, cli.GetBceClientConfig().Endpoint)
if err = cli.SendRequest(req, resp); err != nil {
if serviceErr, isServiceErr := err.(*bce.BceServiceError); isServiceErr {
if serviceErr.StatusCode == net_http.StatusInternalServerError ||
@ -265,10 +291,7 @@ func SendRequest(cli bce.Client, req *bce.BceRequest, resp *bce.BceResponse) err
}
// retry backup endpoint
if need_retry && cli.GetBceClientConfig().BackupEndpoint != "" {
req.SetEndpoint(cli.GetBceClientConfig().BackupEndpoint)
if cli.GetBceClientConfig().CnameEnabled || isCnameLikeHost(cli.GetBceClientConfig().BackupEndpoint) {
req.SetUri(getCnameUri(origin_uri))
}
setUriAndEndpoint(cli, req, ctx, cli.GetBceClientConfig().BackupEndpoint)
if err = cli.SendRequest(req, resp); err != nil {
return err
}
@ -277,6 +300,102 @@ func SendRequest(cli bce.Client, req *bce.BceRequest, resp *bce.BceResponse) err
return err
}
func isVirtualHost(host string) bool {
domain := getDomainWithoutPort(host)
arr := strings.Split(domain, ".")
if len(arr) != 4 {
return false
}
// bucket max length is 64
if len(arr[0]) == 0 || len(arr[0]) > 64 {
return false
}
if arr[2] != "bcebos" || arr[3] != "com" {
return false
}
return true
}
func isIpHost(host string) bool {
domain := getDomainWithoutPort(host)
validIp := net.ParseIP(domain)
return validIp != nil
}
func isBosHost(host string) bool {
domain := getDomainWithoutPort(host)
arr := strings.Split(domain, ".")
if len(arr) != 3 {
return false
}
if arr[1] != "bcebos" || arr[2] != "com" {
return false
}
return true
}
func getDomainWithoutPort(host string) string {
end := 0
if end = strings.Index(host, ":"); end == -1 {
end = len(host)
}
return host[:end]
}
func needCompatibleBucketAndEndpoint(bucket, endpoint string) bool {
if bucket == "" {
return false
}
if !isVirtualHost(endpoint) {
return false
}
if strings.Split(endpoint, ".")[0] == bucket {
return false
}
// bucket from sdk and from endpoint is different
return true
}
// replace endpoint by bucket, only effective when two bucket are in same region, otherwise server return NoSuchBucket error
func replaceEndpointByBucket(bucket, endpoint string) string {
arr := strings.Split(endpoint, ".")
arr[0] = bucket
return strings.Join(arr, ".")
}
func setUriAndEndpoint(cli bce.Client, req *bce.BceRequest, ctx *BosContext, endpoint string) {
origin_uri := req.Uri()
bucket := ctx.Bucket
// deal with protocal
if strings.HasPrefix(endpoint, "https://") {
req.SetProtocol(bce.HTTPS_PROTOCAL)
endpoint = strings.TrimPrefix(endpoint, "https://")
} else if strings.HasPrefix(endpoint, "http://") {
req.SetProtocol(bce.DEFAULT_PROTOCOL)
endpoint = strings.TrimPrefix(endpoint, "http://")
}
// set uri, endpoint for cname, cdn, virtual host
if cli.GetBceClientConfig().CnameEnabled || isCnameLikeHost(endpoint) {
req.SetEndpoint(endpoint)
// if virtual host endpoint and bucket is not empty, compatible bucket and endpoint
if needCompatibleBucketAndEndpoint(bucket, endpoint) {
req.SetEndpoint(replaceEndpointByBucket(bucket, endpoint))
}
req.SetUri(getCnameUri(origin_uri))
} else if isIpHost(endpoint) {
// set endpoint for ip host
req.SetEndpoint(endpoint)
} else if isBosHost(endpoint) {
// endpoint is xx.bcebos.com, set endpoint depends on PathStyleEnable
if bucket != "" && !ctx.PathStyleEnable {
req.SetEndpoint(bucket + "." + endpoint)
req.SetUri(getCnameUri(origin_uri))
} else {
req.SetEndpoint(endpoint)
}
}
}
func getDefaultContentType(object string) string {
dot := strings.LastIndex(object, ".")
if dot == -1 {
@ -290,3 +409,27 @@ func getDefaultContentType(object string) string {
return "application/octet-stream"
}
func ParseObjectTagResult(rawData []byte) (map[string]interface{}, error) {
var data map[string]interface{}
err := json.Unmarshal(rawData, &data)
if err != nil {
return nil, err
}
tagSet, ok := data["tagSet"].([]interface{})
if !ok || len(tagSet) == 0 {
return nil, fmt.Errorf("decode tagSet error")
}
tagInfoMap, ok := tagSet[0].(map[string]interface{})
if !ok {
return nil, fmt.Errorf("decode tagInfo error")
}
tags, ok := tagInfoMap["tagInfo"].(map[string]interface{})
if !ok {
return nil, fmt.Errorf("decode tags error")
}
return tags, nil
}

322
vendor/github.com/baidubce/bce-sdk-go/services/bos/client.go generated vendored
View File

File diff suppressed because it is too large Load Diff

2
vendor/modules.txt vendored
Unescape View File

@ -467,7 +467,7 @@ github.com/aws/smithy-go/transport/http/internal/io
# github.com/axiomhq/hyperloglog v0.0.0-20240507144631-af9851f82b27
## explicit; go 1.12
github.com/axiomhq/hyperloglog
# github.com/baidubce/bce-sdk-go v0.9.141
# github.com/baidubce/bce-sdk-go v0.9.186
## explicit; go 1.11
github.com/baidubce/bce-sdk-go/auth
github.com/baidubce/bce-sdk-go/bce

Write Preview
Loading…
Cancel
Save