vendor/github.com/aliyun/aliyun-oss-go-sdk/oss/option.go

   1 package oss
   2
   3 import (
   4         "fmt"
   5         "net/http"
   6         "net/url"
   7         "strconv"
   8         "strings"
   9         "time"
  10 )
  11
  12 type optionType string
  13
  14 const (
  15         optionParam optionType = "HTTPParameter" // URL parameter
  16         optionHTTP  optionType = "HTTPHeader"    // HTTP header
  17         optionArg   optionType = "FuncArgument"  // Function argument
  18 )
  19
  20 const (
  21         deleteObjectsQuiet = "delete-objects-quiet"
  22         routineNum         = "x-routine-num"
  23         checkpointConfig   = "x-cp-config"
  24         initCRC64          = "init-crc64"
  25         progressListener   = "x-progress-listener"
  26         storageClass       = "storage-class"
  27         responseHeader     = "x-response-header"
  28         redundancyType     = "redundancy-type"
  29 )
  30
  31 type (
  32         optionValue struct {
  33                 Value interface{}
  34                 Type  optionType
  35         }
  36
  37         // Option HTTP option
  38         Option func(map[string]optionValue) error
  39 )
  40
  41 // ACL is an option to set X-Oss-Acl header
  42 func ACL(acl ACLType) Option {
  43         return setHeader(HTTPHeaderOssACL, string(acl))
  44 }
  45
  46 // ContentType is an option to set Content-Type header
  47 func ContentType(value string) Option {
  48         return setHeader(HTTPHeaderContentType, value)
  49 }
  50
  51 // ContentLength is an option to set Content-Length header
  52 func ContentLength(length int64) Option {
  53         return setHeader(HTTPHeaderContentLength, strconv.FormatInt(length, 10))
  54 }
  55
  56 // CacheControl is an option to set Cache-Control header
  57 func CacheControl(value string) Option {
  58         return setHeader(HTTPHeaderCacheControl, value)
  59 }
  60
  61 // ContentDisposition is an option to set Content-Disposition header
  62 func ContentDisposition(value string) Option {
  63         return setHeader(HTTPHeaderContentDisposition, value)
  64 }
  65
  66 // ContentEncoding is an option to set Content-Encoding header
  67 func ContentEncoding(value string) Option {
  68         return setHeader(HTTPHeaderContentEncoding, value)
  69 }
  70
  71 // ContentLanguage is an option to set Content-Language header
  72 func ContentLanguage(value string) Option {
  73         return setHeader(HTTPHeaderContentLanguage, value)
  74 }
  75
  76 // ContentMD5 is an option to set Content-MD5 header
  77 func ContentMD5(value string) Option {
  78         return setHeader(HTTPHeaderContentMD5, value)
  79 }
  80
  81 // Expires is an option to set Expires header
  82 func Expires(t time.Time) Option {
  83         return setHeader(HTTPHeaderExpires, t.Format(http.TimeFormat))
  84 }
  85
  86 // Meta is an option to set Meta header
  87 func Meta(key, value string) Option {
  88         return setHeader(HTTPHeaderOssMetaPrefix+key, value)
  89 }
  90
  91 // Range is an option to set Range header, [start, end]
  92 func Range(start, end int64) Option {
  93         return setHeader(HTTPHeaderRange, fmt.Sprintf("bytes=%d-%d", start, end))
  94 }
  95
  96 // NormalizedRange is an option to set Range header, such as 1024-2048 or 1024- or -2048
  97 func NormalizedRange(nr string) Option {
  98         return setHeader(HTTPHeaderRange, fmt.Sprintf("bytes=%s", strings.TrimSpace(nr)))
  99 }
 100
 101 // AcceptEncoding is an option to set Accept-Encoding header
 102 func AcceptEncoding(value string) Option {
 103         return setHeader(HTTPHeaderAcceptEncoding, value)
 104 }
 105
 106 // IfModifiedSince is an option to set If-Modified-Since header
 107 func IfModifiedSince(t time.Time) Option {
 108         return setHeader(HTTPHeaderIfModifiedSince, t.Format(http.TimeFormat))
 109 }
 110
 111 // IfUnmodifiedSince is an option to set If-Unmodified-Since header
 112 func IfUnmodifiedSince(t time.Time) Option {
 113         return setHeader(HTTPHeaderIfUnmodifiedSince, t.Format(http.TimeFormat))
 114 }
 115
 116 // IfMatch is an option to set If-Match header
 117 func IfMatch(value string) Option {
 118         return setHeader(HTTPHeaderIfMatch, value)
 119 }
 120
 121 // IfNoneMatch is an option to set IfNoneMatch header
 122 func IfNoneMatch(value string) Option {
 123         return setHeader(HTTPHeaderIfNoneMatch, value)
 124 }
 125
 126 // CopySource is an option to set X-Oss-Copy-Source header
 127 func CopySource(sourceBucket, sourceObject string) Option {
 128         return setHeader(HTTPHeaderOssCopySource, "/"+sourceBucket+"/"+sourceObject)
 129 }
 130
 131 // CopySourceVersion is an option to set X-Oss-Copy-Source header,include versionId
 132 func CopySourceVersion(sourceBucket, sourceObject string, versionId string) Option {
 133         return setHeader(HTTPHeaderOssCopySource, "/"+sourceBucket+"/"+sourceObject+"?"+"versionId="+versionId)
 134 }
 135
 136 // CopySourceRange is an option to set X-Oss-Copy-Source header
 137 func CopySourceRange(startPosition, partSize int64) Option {
 138         val := "bytes=" + strconv.FormatInt(startPosition, 10) + "-" +
 139                 strconv.FormatInt((startPosition+partSize-1), 10)
 140         return setHeader(HTTPHeaderOssCopySourceRange, val)
 141 }
 142
 143 // CopySourceIfMatch is an option to set X-Oss-Copy-Source-If-Match header
 144 func CopySourceIfMatch(value string) Option {
 145         return setHeader(HTTPHeaderOssCopySourceIfMatch, value)
 146 }
 147
 148 // CopySourceIfNoneMatch is an option to set X-Oss-Copy-Source-If-None-Match header
 149 func CopySourceIfNoneMatch(value string) Option {
 150         return setHeader(HTTPHeaderOssCopySourceIfNoneMatch, value)
 151 }
 152
 153 // CopySourceIfModifiedSince is an option to set X-Oss-CopySource-If-Modified-Since header
 154 func CopySourceIfModifiedSince(t time.Time) Option {
 155         return setHeader(HTTPHeaderOssCopySourceIfModifiedSince, t.Format(http.TimeFormat))
 156 }
 157
 158 // CopySourceIfUnmodifiedSince is an option to set X-Oss-Copy-Source-If-Unmodified-Since header
 159 func CopySourceIfUnmodifiedSince(t time.Time) Option {
 160         return setHeader(HTTPHeaderOssCopySourceIfUnmodifiedSince, t.Format(http.TimeFormat))
 161 }
 162
 163 // MetadataDirective is an option to set X-Oss-Metadata-Directive header
 164 func MetadataDirective(directive MetadataDirectiveType) Option {
 165         return setHeader(HTTPHeaderOssMetadataDirective, string(directive))
 166 }
 167
 168 // ServerSideEncryption is an option to set X-Oss-Server-Side-Encryption header
 169 func ServerSideEncryption(value string) Option {
 170         return setHeader(HTTPHeaderOssServerSideEncryption, value)
 171 }
 172
 173 // ServerSideEncryptionKeyID is an option to set X-Oss-Server-Side-Encryption-Key-Id header
 174 func ServerSideEncryptionKeyID(value string) Option {
 175         return setHeader(HTTPHeaderOssServerSideEncryptionKeyID, value)
 176 }
 177
 178 // ServerSideDataEncryption is an option to set X-Oss-Server-Side-Data-Encryption header
 179 func ServerSideDataEncryption(value string) Option {
 180         return setHeader(HTTPHeaderOssServerSideDataEncryption, value)
 181 }
 182
 183 // SSECAlgorithm is an option to set X-Oss-Server-Side-Encryption-Customer-Algorithm header
 184 func SSECAlgorithm(value string) Option {
 185         return setHeader(HTTPHeaderSSECAlgorithm, value)
 186 }
 187
 188 // SSECKey is an option to set X-Oss-Server-Side-Encryption-Customer-Key header
 189 func SSECKey(value string) Option {
 190         return setHeader(HTTPHeaderSSECKey, value)
 191 }
 192
 193 // SSECKeyMd5 is an option to set X-Oss-Server-Side-Encryption-Customer-Key-Md5 header
 194 func SSECKeyMd5(value string) Option {
 195         return setHeader(HTTPHeaderSSECKeyMd5, value)
 196 }
 197
 198 // ObjectACL is an option to set X-Oss-Object-Acl header
 199 func ObjectACL(acl ACLType) Option {
 200         return setHeader(HTTPHeaderOssObjectACL, string(acl))
 201 }
 202
 203 // symlinkTarget is an option to set X-Oss-Symlink-Target
 204 func symlinkTarget(targetObjectKey string) Option {
 205         return setHeader(HTTPHeaderOssSymlinkTarget, targetObjectKey)
 206 }
 207
 208 // Origin is an option to set Origin header
 209 func Origin(value string) Option {
 210         return setHeader(HTTPHeaderOrigin, value)
 211 }
 212
 213 // ObjectStorageClass is an option to set the storage class of object
 214 func ObjectStorageClass(storageClass StorageClassType) Option {
 215         return setHeader(HTTPHeaderOssStorageClass, string(storageClass))
 216 }
 217
 218 // Callback is an option to set callback values
 219 func Callback(callback string) Option {
 220         return setHeader(HTTPHeaderOssCallback, callback)
 221 }
 222
 223 // CallbackVar is an option to set callback user defined values
 224 func CallbackVar(callbackVar string) Option {
 225         return setHeader(HTTPHeaderOssCallbackVar, callbackVar)
 226 }
 227
 228 // RequestPayer is an option to set payer who pay for the request
 229 func RequestPayer(payerType PayerType) Option {
 230         return setHeader(HTTPHeaderOssRequester, strings.ToLower(string(payerType)))
 231 }
 232
 233 // RequestPayerParam is an option to set payer who pay for the request
 234 func RequestPayerParam(payerType PayerType) Option {
 235         return addParam(strings.ToLower(HTTPHeaderOssRequester), strings.ToLower(string(payerType)))
 236 }
 237
 238 // SetTagging is an option to set object tagging
 239 func SetTagging(tagging Tagging) Option {
 240         if len(tagging.Tags) == 0 {
 241                 return nil
 242         }
 243
 244         taggingValue := ""
 245         for index, tag := range tagging.Tags {
 246                 if index != 0 {
 247                         taggingValue += "&"
 248                 }
 249                 taggingValue += url.QueryEscape(tag.Key) + "=" + url.QueryEscape(tag.Value)
 250         }
 251         return setHeader(HTTPHeaderOssTagging, taggingValue)
 252 }
 253
 254 // TaggingDirective is an option to set X-Oss-Metadata-Directive header
 255 func TaggingDirective(directive TaggingDirectiveType) Option {
 256         return setHeader(HTTPHeaderOssTaggingDirective, string(directive))
 257 }
 258
 259 // ACReqMethod is an option to set Access-Control-Request-Method header
 260 func ACReqMethod(value string) Option {
 261         return setHeader(HTTPHeaderACReqMethod, value)
 262 }
 263
 264 // ACReqHeaders is an option to set Access-Control-Request-Headers header
 265 func ACReqHeaders(value string) Option {
 266         return setHeader(HTTPHeaderACReqHeaders, value)
 267 }
 268
 269 // TrafficLimitHeader is an option to set X-Oss-Traffic-Limit
 270 func TrafficLimitHeader(value int64) Option {
 271         return setHeader(HTTPHeaderOssTrafficLimit, strconv.FormatInt(value, 10))
 272 }
 273
 274 // UserAgentHeader is an option to set HTTPHeaderUserAgent
 275 func UserAgentHeader(ua string) Option {
 276         return setHeader(HTTPHeaderUserAgent, ua)
 277 }
 278
 279 // ForbidOverWrite  is an option to set X-Oss-Forbid-Overwrite
 280 func ForbidOverWrite(forbidWrite bool) Option {
 281         if forbidWrite {
 282                 return setHeader(HTTPHeaderOssForbidOverWrite, "true")
 283         } else {
 284                 return setHeader(HTTPHeaderOssForbidOverWrite, "false")
 285         }
 286 }
 287
 288 // RangeBehavior  is an option to set Range value, such as "standard"
 289 func RangeBehavior(value string) Option {
 290         return setHeader(HTTPHeaderOssRangeBehavior, value)
 291 }
 292
 293 // Delimiter is an option to set delimiler parameter
 294 func Delimiter(value string) Option {
 295         return addParam("delimiter", value)
 296 }
 297
 298 // Marker is an option to set marker parameter
 299 func Marker(value string) Option {
 300         return addParam("marker", value)
 301 }
 302
 303 // MaxKeys is an option to set maxkeys parameter
 304 func MaxKeys(value int) Option {
 305         return addParam("max-keys", strconv.Itoa(value))
 306 }
 307
 308 // Prefix is an option to set prefix parameter
 309 func Prefix(value string) Option {
 310         return addParam("prefix", value)
 311 }
 312
 313 // EncodingType is an option to set encoding-type parameter
 314 func EncodingType(value string) Option {
 315         return addParam("encoding-type", value)
 316 }
 317
 318 // MaxUploads is an option to set max-uploads parameter
 319 func MaxUploads(value int) Option {
 320         return addParam("max-uploads", strconv.Itoa(value))
 321 }
 322
 323 // KeyMarker is an option to set key-marker parameter
 324 func KeyMarker(value string) Option {
 325         return addParam("key-marker", value)
 326 }
 327
 328 // VersionIdMarker is an option to set version-id-marker parameter
 329 func VersionIdMarker(value string) Option {
 330         return addParam("version-id-marker", value)
 331 }
 332
 333 // VersionId is an option to set versionId parameter
 334 func VersionId(value string) Option {
 335         return addParam("versionId", value)
 336 }
 337
 338 // TagKey is an option to set tag key parameter
 339 func TagKey(value string) Option {
 340         return addParam("tag-key", value)
 341 }
 342
 343 // TagValue is an option to set tag value parameter
 344 func TagValue(value string) Option {
 345         return addParam("tag-value", value)
 346 }
 347
 348 // UploadIDMarker is an option to set upload-id-marker parameter
 349 func UploadIDMarker(value string) Option {
 350         return addParam("upload-id-marker", value)
 351 }
 352
 353 // MaxParts is an option to set max-parts parameter
 354 func MaxParts(value int) Option {
 355         return addParam("max-parts", strconv.Itoa(value))
 356 }
 357
 358 // PartNumberMarker is an option to set part-number-marker parameter
 359 func PartNumberMarker(value int) Option {
 360         return addParam("part-number-marker", strconv.Itoa(value))
 361 }
 362
 363 // Sequential is an option to set sequential parameter for InitiateMultipartUpload
 364 func Sequential() Option {
 365         return addParam("sequential", "")
 366 }
 367
 368 // ListType is an option to set List-type parameter for ListObjectsV2
 369 func ListType(value int) Option {
 370         return addParam("list-type", strconv.Itoa(value))
 371 }
 372
 373 // StartAfter is an option to set start-after parameter for ListObjectsV2
 374 func StartAfter(value string) Option {
 375         return addParam("start-after", value)
 376 }
 377
 378 // ContinuationToken is an option to set Continuation-token parameter for ListObjectsV2
 379 func ContinuationToken(value string) Option {
 380         if value == "" {
 381                 return addParam("continuation-token", nil)
 382         }
 383         return addParam("continuation-token", value)
 384 }
 385
 386 // FetchOwner is an option to set Fetch-owner parameter for ListObjectsV2
 387 func FetchOwner(value bool) Option {
 388         if value {
 389                 return addParam("fetch-owner", "true")
 390         }
 391         return addParam("fetch-owner", "false")
 392 }
 393
 394 // DeleteObjectsQuiet false:DeleteObjects in verbose mode; true:DeleteObjects in quite mode. Default is false.
 395 func DeleteObjectsQuiet(isQuiet bool) Option {
 396         return addArg(deleteObjectsQuiet, isQuiet)
 397 }
 398
 399 // StorageClass bucket storage class
 400 func StorageClass(value StorageClassType) Option {
 401         return addArg(storageClass, value)
 402 }
 403
 404 // RedundancyType bucket data redundancy type
 405 func RedundancyType(value DataRedundancyType) Option {
 406         return addArg(redundancyType, value)
 407 }
 408
 409 // Checkpoint configuration
 410 type cpConfig struct {
 411         IsEnable bool
 412         FilePath string
 413         DirPath  string
 414 }
 415
 416 // Checkpoint sets the isEnable flag and checkpoint file path for DownloadFile/UploadFile.
 417 func Checkpoint(isEnable bool, filePath string) Option {
 418         return addArg(checkpointConfig, &cpConfig{IsEnable: isEnable, FilePath: filePath})
 419 }
 420
 421 // CheckpointDir sets the isEnable flag and checkpoint dir path for DownloadFile/UploadFile.
 422 func CheckpointDir(isEnable bool, dirPath string) Option {
 423         return addArg(checkpointConfig, &cpConfig{IsEnable: isEnable, DirPath: dirPath})
 424 }
 425
 426 // Routines DownloadFile/UploadFile routine count
 427 func Routines(n int) Option {
 428         return addArg(routineNum, n)
 429 }
 430
 431 // InitCRC Init AppendObject CRC
 432 func InitCRC(initCRC uint64) Option {
 433         return addArg(initCRC64, initCRC)
 434 }
 435
 436 // Progress set progress listener
 437 func Progress(listener ProgressListener) Option {
 438         return addArg(progressListener, listener)
 439 }
 440
 441 // GetResponseHeader for get response http header
 442 func GetResponseHeader(respHeader *http.Header) Option {
 443         return addArg(responseHeader, respHeader)
 444 }
 445
 446 // ResponseContentType is an option to set response-content-type param
 447 func ResponseContentType(value string) Option {
 448         return addParam("response-content-type", value)
 449 }
 450
 451 // ResponseContentLanguage is an option to set response-content-language param
 452 func ResponseContentLanguage(value string) Option {
 453         return addParam("response-content-language", value)
 454 }
 455
 456 // ResponseExpires is an option to set response-expires param
 457 func ResponseExpires(value string) Option {
 458         return addParam("response-expires", value)
 459 }
 460
 461 // ResponseCacheControl is an option to set response-cache-control param
 462 func ResponseCacheControl(value string) Option {
 463         return addParam("response-cache-control", value)
 464 }
 465
 466 // ResponseContentDisposition is an option to set response-content-disposition param
 467 func ResponseContentDisposition(value string) Option {
 468         return addParam("response-content-disposition", value)
 469 }
 470
 471 // ResponseContentEncoding is an option to set response-content-encoding param
 472 func ResponseContentEncoding(value string) Option {
 473         return addParam("response-content-encoding", value)
 474 }
 475
 476 // Process is an option to set x-oss-process param
 477 func Process(value string) Option {
 478         return addParam("x-oss-process", value)
 479 }
 480
 481 // TrafficLimitParam is a option to set x-oss-traffic-limit
 482 func TrafficLimitParam(value int64) Option {
 483         return addParam("x-oss-traffic-limit", strconv.FormatInt(value, 10))
 484 }
 485
 486 // SetHeader Allow users to set personalized http headers
 487 func SetHeader(key string, value interface{}) Option {
 488         return setHeader(key, value)
 489 }
 490
 491 // AddParam Allow users to set personalized http params
 492 func AddParam(key string, value interface{}) Option {
 493         return addParam(key, value)
 494 }
 495
 496 func setHeader(key string, value interface{}) Option {
 497         return func(params map[string]optionValue) error {
 498                 if value == nil {
 499                         return nil
 500                 }
 501                 params[key] = optionValue{value, optionHTTP}
 502                 return nil
 503         }
 504 }
 505
 506 func addParam(key string, value interface{}) Option {
 507         return func(params map[string]optionValue) error {
 508                 if value == nil {
 509                         return nil
 510                 }
 511                 params[key] = optionValue{value, optionParam}
 512                 return nil
 513         }
 514 }
 515
 516 func addArg(key string, value interface{}) Option {
 517         return func(params map[string]optionValue) error {
 518                 if value == nil {
 519                         return nil
 520                 }
 521                 params[key] = optionValue{value, optionArg}
 522                 return nil
 523         }
 524 }
 525
 526 func handleOptions(headers map[string]string, options []Option) error {
 527         params := map[string]optionValue{}
 528         for _, option := range options {
 529                 if option != nil {
 530                         if err := option(params); err != nil {
 531                                 return err
 532                         }
 533                 }
 534         }
 535
 536         for k, v := range params {
 537                 if v.Type == optionHTTP {
 538                         headers[k] = v.Value.(string)
 539                 }
 540         }
 541         return nil
 542 }
 543
 544 func GetRawParams(options []Option) (map[string]interface{}, error) {
 545         // Option
 546         params := map[string]optionValue{}
 547         for _, option := range options {
 548                 if option != nil {
 549                         if err := option(params); err != nil {
 550                                 return nil, err
 551                         }
 552                 }
 553         }
 554
 555         paramsm := map[string]interface{}{}
 556         // Serialize
 557         for k, v := range params {
 558                 if v.Type == optionParam {
 559                         vs := params[k]
 560                         paramsm[k] = vs.Value.(string)
 561                 }
 562         }
 563
 564         return paramsm, nil
 565 }
 566
 567 func FindOption(options []Option, param string, defaultVal interface{}) (interface{}, error) {
 568         params := map[string]optionValue{}
 569         for _, option := range options {
 570                 if option != nil {
 571                         if err := option(params); err != nil {
 572                                 return nil, err
 573                         }
 574                 }
 575         }
 576
 577         if val, ok := params[param]; ok {
 578                 return val.Value, nil
 579         }
 580         return defaultVal, nil
 581 }
 582
 583 func IsOptionSet(options []Option, option string) (bool, interface{}, error) {
 584         params := map[string]optionValue{}
 585         for _, option := range options {
 586                 if option != nil {
 587                         if err := option(params); err != nil {
 588                                 return false, nil, err
 589                         }
 590                 }
 591         }
 592
 593         if val, ok := params[option]; ok {
 594                 return true, val.Value, nil
 595         }
 596         return false, nil, nil
 597 }
 598
 599 func DeleteOption(options []Option, strKey string) []Option {
 600         var outOption []Option
 601         params := map[string]optionValue{}
 602         for _, option := range options {
 603                 if option != nil {
 604                         option(params)
 605                         _, exist := params[strKey]
 606                         if !exist {
 607                                 outOption = append(outOption, option)
 608                         } else {
 609                                 delete(params, strKey)
 610                         }
 611                 }
 612         }
 613         return outOption
 614 }
 615
 616 func GetRequestId(header http.Header) string {
 617         return header.Get("x-oss-request-id")
 618 }
 619
 620 func GetVersionId(header http.Header) string {
 621         return header.Get("x-oss-version-id")
 622 }
 623
 624 func GetCopySrcVersionId(header http.Header) string {
 625         return header.Get("x-oss-copy-source-version-id")
 626 }
 627
 628 func GetDeleteMark(header http.Header) bool {
 629         value := header.Get("x-oss-delete-marker")
 630         if strings.ToUpper(value) == "TRUE" {
 631                 return true
 632         }
 633         return false
 634 }
 635
 636 func GetQosDelayTime(header http.Header) string {
 637         return header.Get("x-oss-qos-delay-time")
 638 }