forked from aliyun/aliyun-oss-go-sdk
-
Notifications
You must be signed in to change notification settings - Fork 0
/
type.go
1254 lines (1105 loc) · 53.9 KB
/
type.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
package oss
import (
"encoding/base64"
"encoding/xml"
"fmt"
"net/url"
"time"
)
// ListBucketsResult defines the result object from ListBuckets request
type ListBucketsResult struct {
XMLName xml.Name `xml:"ListAllMyBucketsResult"`
Prefix string `xml:"Prefix"` // The prefix in this query
Marker string `xml:"Marker"` // The marker filter
MaxKeys int `xml:"MaxKeys"` // The max entry count to return. This information is returned when IsTruncated is true.
IsTruncated bool `xml:"IsTruncated"` // Flag true means there's remaining buckets to return.
NextMarker string `xml:"NextMarker"` // The marker filter for the next list call
Owner Owner `xml:"Owner"` // The owner information
Buckets []BucketProperties `xml:"Buckets>Bucket"` // The bucket list
}
// BucketProperties defines bucket properties
type BucketProperties struct {
XMLName xml.Name `xml:"Bucket"`
Name string `xml:"Name"` // Bucket name
Location string `xml:"Location"` // Bucket datacenter
CreationDate time.Time `xml:"CreationDate"` // Bucket create time
StorageClass string `xml:"StorageClass"` // Bucket storage class
}
// GetBucketACLResult defines GetBucketACL request's result
type GetBucketACLResult struct {
XMLName xml.Name `xml:"AccessControlPolicy"`
ACL string `xml:"AccessControlList>Grant"` // Bucket ACL
Owner Owner `xml:"Owner"` // Bucket owner
}
// LifecycleConfiguration is the Bucket Lifecycle configuration
type LifecycleConfiguration struct {
XMLName xml.Name `xml:"LifecycleConfiguration"`
Rules []LifecycleRule `xml:"Rule"`
}
// LifecycleRule defines Lifecycle rules
type LifecycleRule struct {
XMLName xml.Name `xml:"Rule"`
ID string `xml:"ID,omitempty"` // The rule ID
Prefix string `xml:"Prefix"` // The object key prefix
Status string `xml:"Status"` // The rule status (enabled or not)
Tags []Tag `xml:"Tag,omitempty"` // the tags property
Expiration *LifecycleExpiration `xml:"Expiration,omitempty"` // The expiration property
Transitions []LifecycleTransition `xml:"Transition,omitempty"` // The transition property
AbortMultipartUpload *LifecycleAbortMultipartUpload `xml:"AbortMultipartUpload,omitempty"` // The AbortMultipartUpload property
NonVersionExpiration *LifecycleVersionExpiration `xml:"NoncurrentVersionExpiration,omitempty"`
// Deprecated: Use NonVersionTransitions instead.
NonVersionTransition *LifecycleVersionTransition `xml:"-"` // NonVersionTransition is not suggested to use
NonVersionTransitions []LifecycleVersionTransition `xml:"NoncurrentVersionTransition,omitempty"`
}
// LifecycleExpiration defines the rule's expiration property
type LifecycleExpiration struct {
XMLName xml.Name `xml:"Expiration"`
Days int `xml:"Days,omitempty"` // Relative expiration time: The expiration time in days after the last modified time
Date string `xml:"Date,omitempty"` // Absolute expiration time: The expiration time in date, not recommended
CreatedBeforeDate string `xml:"CreatedBeforeDate,omitempty"` // objects created before the date will be expired
ExpiredObjectDeleteMarker *bool `xml:"ExpiredObjectDeleteMarker,omitempty"` // Specifies whether the expired delete tag is automatically deleted
}
// LifecycleTransition defines the rule's transition propery
type LifecycleTransition struct {
XMLName xml.Name `xml:"Transition"`
Days int `xml:"Days,omitempty"` // Relative transition time: The transition time in days after the last modified time
CreatedBeforeDate string `xml:"CreatedBeforeDate,omitempty"` // objects created before the date will be expired
StorageClass StorageClassType `xml:"StorageClass,omitempty"` // Specifies the target storage type
}
// LifecycleAbortMultipartUpload defines the rule's abort multipart upload propery
type LifecycleAbortMultipartUpload struct {
XMLName xml.Name `xml:"AbortMultipartUpload"`
Days int `xml:"Days,omitempty"` // Relative expiration time: The expiration time in days after the last modified time
CreatedBeforeDate string `xml:"CreatedBeforeDate,omitempty"` // objects created before the date will be expired
}
// LifecycleVersionExpiration defines the rule's NoncurrentVersionExpiration propery
type LifecycleVersionExpiration struct {
XMLName xml.Name `xml:"NoncurrentVersionExpiration"`
NoncurrentDays int `xml:"NoncurrentDays,omitempty"` // How many days after the Object becomes a non-current version
}
// LifecycleVersionTransition defines the rule's NoncurrentVersionTransition propery
type LifecycleVersionTransition struct {
XMLName xml.Name `xml:"NoncurrentVersionTransition"`
NoncurrentDays int `xml:"NoncurrentDays,omitempty"` // How many days after the Object becomes a non-current version
StorageClass StorageClassType `xml:"StorageClass,omitempty"`
}
const iso8601DateFormat = "2006-01-02T15:04:05.000Z"
// BuildLifecycleRuleByDays builds a lifecycle rule objects will expiration in days after the last modified time
func BuildLifecycleRuleByDays(id, prefix string, status bool, days int) LifecycleRule {
var statusStr = "Enabled"
if !status {
statusStr = "Disabled"
}
return LifecycleRule{ID: id, Prefix: prefix, Status: statusStr,
Expiration: &LifecycleExpiration{Days: days}}
}
// BuildLifecycleRuleByDate builds a lifecycle rule objects will expiration in specified date
func BuildLifecycleRuleByDate(id, prefix string, status bool, year, month, day int) LifecycleRule {
var statusStr = "Enabled"
if !status {
statusStr = "Disabled"
}
date := time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC).Format(iso8601DateFormat)
return LifecycleRule{ID: id, Prefix: prefix, Status: statusStr,
Expiration: &LifecycleExpiration{Date: date}}
}
// ValidateLifecycleRule Determine if a lifecycle rule is valid, if it is invalid, it will return an error.
func verifyLifecycleRules(rules []LifecycleRule) error {
if len(rules) == 0 {
return fmt.Errorf("invalid rules, the length of rules is zero")
}
for k, rule := range rules {
if rule.Status != "Enabled" && rule.Status != "Disabled" {
return fmt.Errorf("invalid rule, the value of status must be Enabled or Disabled")
}
abortMPU := rule.AbortMultipartUpload
if abortMPU != nil {
if (abortMPU.Days != 0 && abortMPU.CreatedBeforeDate != "") || (abortMPU.Days == 0 && abortMPU.CreatedBeforeDate == "") {
return fmt.Errorf("invalid abort multipart upload lifecycle, must be set one of CreatedBeforeDate and Days")
}
}
transitions := rule.Transitions
if len(transitions) > 0 {
for _, transition := range transitions {
if (transition.Days != 0 && transition.CreatedBeforeDate != "") || (transition.Days == 0 && transition.CreatedBeforeDate == "") {
return fmt.Errorf("invalid transition lifecycle, must be set one of CreatedBeforeDate and Days")
}
}
}
// NonVersionTransition is not suggested to use
// to keep compatible
if rule.NonVersionTransition != nil && len(rule.NonVersionTransitions) > 0 {
return fmt.Errorf("NonVersionTransition and NonVersionTransitions cannot both have values")
} else if rule.NonVersionTransition != nil {
rules[k].NonVersionTransitions = append(rules[k].NonVersionTransitions, *rule.NonVersionTransition)
}
}
return nil
}
// GetBucketLifecycleResult defines GetBucketLifecycle's result object
type GetBucketLifecycleResult LifecycleConfiguration
// RefererXML defines Referer configuration
type RefererXML struct {
XMLName xml.Name `xml:"RefererConfiguration"`
AllowEmptyReferer bool `xml:"AllowEmptyReferer"` // Allow empty referrer
RefererList []string `xml:"RefererList>Referer"` // Referer whitelist
}
// GetBucketRefererResult defines result object for GetBucketReferer request
type GetBucketRefererResult RefererXML
// LoggingXML defines logging configuration
type LoggingXML struct {
XMLName xml.Name `xml:"BucketLoggingStatus"`
LoggingEnabled LoggingEnabled `xml:"LoggingEnabled"` // The logging configuration information
}
type loggingXMLEmpty struct {
XMLName xml.Name `xml:"BucketLoggingStatus"`
}
// LoggingEnabled defines the logging configuration information
type LoggingEnabled struct {
XMLName xml.Name `xml:"LoggingEnabled"`
TargetBucket string `xml:"TargetBucket"` // The bucket name for storing the log files
TargetPrefix string `xml:"TargetPrefix"` // The log file prefix
}
// GetBucketLoggingResult defines the result from GetBucketLogging request
type GetBucketLoggingResult LoggingXML
// WebsiteXML defines Website configuration
type WebsiteXML struct {
XMLName xml.Name `xml:"WebsiteConfiguration"`
IndexDocument IndexDocument `xml:"IndexDocument,omitempty"` // The index page
ErrorDocument ErrorDocument `xml:"ErrorDocument,omitempty"` // The error page
RoutingRules []RoutingRule `xml:"RoutingRules>RoutingRule,omitempty"` // The routing Rule list
}
// IndexDocument defines the index page info
type IndexDocument struct {
XMLName xml.Name `xml:"IndexDocument"`
Suffix string `xml:"Suffix"` // The file name for the index page
}
// ErrorDocument defines the 404 error page info
type ErrorDocument struct {
XMLName xml.Name `xml:"ErrorDocument"`
Key string `xml:"Key"` // 404 error file name
}
// RoutingRule defines the routing rules
type RoutingRule struct {
XMLName xml.Name `xml:"RoutingRule"`
RuleNumber int `xml:"RuleNumber,omitempty"` // The routing number
Condition Condition `xml:"Condition,omitempty"` // The routing condition
Redirect Redirect `xml:"Redirect,omitempty"` // The routing redirect
}
// Condition defines codition in the RoutingRule
type Condition struct {
XMLName xml.Name `xml:"Condition"`
KeyPrefixEquals string `xml:"KeyPrefixEquals,omitempty"` // Matching objcet prefix
HTTPErrorCodeReturnedEquals int `xml:"HttpErrorCodeReturnedEquals,omitempty"` // The rule is for Accessing to the specified object
IncludeHeader []IncludeHeader `xml:"IncludeHeader"` // The rule is for request which include header
}
// IncludeHeader defines includeHeader in the RoutingRule's Condition
type IncludeHeader struct {
XMLName xml.Name `xml:"IncludeHeader"`
Key string `xml:"Key,omitempty"` // The Include header key
Equals string `xml:"Equals,omitempty"` // The Include header value
}
// Redirect defines redirect in the RoutingRule
type Redirect struct {
XMLName xml.Name `xml:"Redirect"`
RedirectType string `xml:"RedirectType,omitempty"` // The redirect type, it have Mirror,External,Internal,AliCDN
PassQueryString *bool `xml:"PassQueryString"` // Whether to send the specified request's parameters, true or false
MirrorURL string `xml:"MirrorURL,omitempty"` // Mirror of the website address back to the source.
MirrorPassQueryString *bool `xml:"MirrorPassQueryString"` // To Mirror of the website Whether to send the specified request's parameters, true or false
MirrorFollowRedirect *bool `xml:"MirrorFollowRedirect"` // Redirect the location, if the mirror return 3XX
MirrorCheckMd5 *bool `xml:"MirrorCheckMd5"` // Check the mirror is MD5.
MirrorHeaders MirrorHeaders `xml:"MirrorHeaders,omitempty"` // Mirror headers
Protocol string `xml:"Protocol,omitempty"` // The redirect Protocol
HostName string `xml:"HostName,omitempty"` // The redirect HostName
ReplaceKeyPrefixWith string `xml:"ReplaceKeyPrefixWith,omitempty"` // object name'Prefix replace the value
HttpRedirectCode int `xml:"HttpRedirectCode,omitempty"` // THe redirect http code
ReplaceKeyWith string `xml:"ReplaceKeyWith,omitempty"` // object name replace the value
}
// MirrorHeaders defines MirrorHeaders in the Redirect
type MirrorHeaders struct {
XMLName xml.Name `xml:"MirrorHeaders"`
PassAll *bool `xml:"PassAll"` // Penetrating all of headers to source website.
Pass []string `xml:"Pass"` // Penetrating some of headers to source website.
Remove []string `xml:"Remove"` // Prohibit passthrough some of headers to source website
Set []MirrorHeaderSet `xml:"Set"` // Setting some of headers send to source website
}
// MirrorHeaderSet defines Set for Redirect's MirrorHeaders
type MirrorHeaderSet struct {
XMLName xml.Name `xml:"Set"`
Key string `xml:"Key,omitempty"` // The mirror header key
Value string `xml:"Value,omitempty"` // The mirror header value
}
// GetBucketWebsiteResult defines the result from GetBucketWebsite request.
type GetBucketWebsiteResult WebsiteXML
// CORSXML defines CORS configuration
type CORSXML struct {
XMLName xml.Name `xml:"CORSConfiguration"`
CORSRules []CORSRule `xml:"CORSRule"` // CORS rules
}
// CORSRule defines CORS rules
type CORSRule struct {
XMLName xml.Name `xml:"CORSRule"`
AllowedOrigin []string `xml:"AllowedOrigin"` // Allowed origins. By default it's wildcard '*'
AllowedMethod []string `xml:"AllowedMethod"` // Allowed methods
AllowedHeader []string `xml:"AllowedHeader"` // Allowed headers
ExposeHeader []string `xml:"ExposeHeader"` // Allowed response headers
MaxAgeSeconds int `xml:"MaxAgeSeconds"` // Max cache ages in seconds
}
// GetBucketCORSResult defines the result from GetBucketCORS request.
type GetBucketCORSResult CORSXML
// GetBucketInfoResult defines the result from GetBucketInfo request.
type GetBucketInfoResult struct {
XMLName xml.Name `xml:"BucketInfo"`
BucketInfo BucketInfo `xml:"Bucket"`
}
// BucketInfo defines Bucket information
type BucketInfo struct {
XMLName xml.Name `xml:"Bucket"`
Name string `xml:"Name"` // Bucket name
Location string `xml:"Location"` // Bucket datacenter
CreationDate time.Time `xml:"CreationDate"` // Bucket creation time
ExtranetEndpoint string `xml:"ExtranetEndpoint"` // Bucket external endpoint
IntranetEndpoint string `xml:"IntranetEndpoint"` // Bucket internal endpoint
ACL string `xml:"AccessControlList>Grant"` // Bucket ACL
RedundancyType string `xml:"DataRedundancyType"` // Bucket DataRedundancyType
Owner Owner `xml:"Owner"` // Bucket owner
StorageClass string `xml:"StorageClass"` // Bucket storage class
SseRule SSERule `xml:"ServerSideEncryptionRule"` // Bucket ServerSideEncryptionRule
Versioning string `xml:"Versioning"` // Bucket Versioning
}
type SSERule struct {
XMLName xml.Name `xml:"ServerSideEncryptionRule"` // Bucket ServerSideEncryptionRule
KMSMasterKeyID string `xml:"KMSMasterKeyID,omitempty"` // Bucket KMSMasterKeyID
SSEAlgorithm string `xml:"SSEAlgorithm,omitempty"` // Bucket SSEAlgorithm
KMSDataEncryption string `xml:"KMSDataEncryption,omitempty"` //Bucket KMSDataEncryption
}
// ListObjectsResult defines the result from ListObjects request
type ListObjectsResult struct {
XMLName xml.Name `xml:"ListBucketResult"`
Prefix string `xml:"Prefix"` // The object prefix
Marker string `xml:"Marker"` // The marker filter.
MaxKeys int `xml:"MaxKeys"` // Max keys to return
Delimiter string `xml:"Delimiter"` // The delimiter for grouping objects' name
IsTruncated bool `xml:"IsTruncated"` // Flag indicates if all results are returned (when it's false)
NextMarker string `xml:"NextMarker"` // The start point of the next query
Objects []ObjectProperties `xml:"Contents"` // Object list
CommonPrefixes []string `xml:"CommonPrefixes>Prefix"` // You can think of commonprefixes as "folders" whose names end with the delimiter
}
// ObjectProperties defines Objecct properties
type ObjectProperties struct {
XMLName xml.Name `xml:"Contents"`
Key string `xml:"Key"` // Object key
Type string `xml:"Type"` // Object type
Size int64 `xml:"Size"` // Object size
ETag string `xml:"ETag"` // Object ETag
Owner Owner `xml:"Owner"` // Object owner information
LastModified time.Time `xml:"LastModified"` // Object last modified time
StorageClass string `xml:"StorageClass"` // Object storage class (Standard, IA, Archive)
}
// ListObjectsResultV2 defines the result from ListObjectsV2 request
type ListObjectsResultV2 struct {
XMLName xml.Name `xml:"ListBucketResult"`
Prefix string `xml:"Prefix"` // The object prefix
StartAfter string `xml:"StartAfter"` // the input StartAfter
ContinuationToken string `xml:"ContinuationToken"` // the input ContinuationToken
MaxKeys int `xml:"MaxKeys"` // Max keys to return
Delimiter string `xml:"Delimiter"` // The delimiter for grouping objects' name
IsTruncated bool `xml:"IsTruncated"` // Flag indicates if all results are returned (when it's false)
NextContinuationToken string `xml:"NextContinuationToken"` // The start point of the next NextContinuationToken
Objects []ObjectProperties `xml:"Contents"` // Object list
CommonPrefixes []string `xml:"CommonPrefixes>Prefix"` // You can think of commonprefixes as "folders" whose names end with the delimiter
}
// ListObjectVersionsResult defines the result from ListObjectVersions request
type ListObjectVersionsResult struct {
XMLName xml.Name `xml:"ListVersionsResult"`
Name string `xml:"Name"` // The Bucket Name
Owner Owner `xml:"Owner"` // The owner of bucket
Prefix string `xml:"Prefix"` // The object prefix
KeyMarker string `xml:"KeyMarker"` // The start marker filter.
VersionIdMarker string `xml:"VersionIdMarker"` // The start VersionIdMarker filter.
MaxKeys int `xml:"MaxKeys"` // Max keys to return
Delimiter string `xml:"Delimiter"` // The delimiter for grouping objects' name
IsTruncated bool `xml:"IsTruncated"` // Flag indicates if all results are returned (when it's false)
NextKeyMarker string `xml:"NextKeyMarker"` // The start point of the next query
NextVersionIdMarker string `xml:"NextVersionIdMarker"` // The start point of the next query
CommonPrefixes []string `xml:"CommonPrefixes>Prefix"` // You can think of commonprefixes as "folders" whose names end with the delimiter
ObjectDeleteMarkers []ObjectDeleteMarkerProperties `xml:"DeleteMarker"` // DeleteMarker list
ObjectVersions []ObjectVersionProperties `xml:"Version"` // version list
}
type ObjectDeleteMarkerProperties struct {
XMLName xml.Name `xml:"DeleteMarker"`
Key string `xml:"Key"` // The Object Key
VersionId string `xml:"VersionId"` // The Object VersionId
IsLatest bool `xml:"IsLatest"` // is current version or not
LastModified time.Time `xml:"LastModified"` // Object last modified time
Owner Owner `xml:"Owner"` // bucket owner element
}
type ObjectVersionProperties struct {
XMLName xml.Name `xml:"Version"`
Key string `xml:"Key"` // The Object Key
VersionId string `xml:"VersionId"` // The Object VersionId
IsLatest bool `xml:"IsLatest"` // is latest version or not
LastModified time.Time `xml:"LastModified"` // Object last modified time
Type string `xml:"Type"` // Object type
Size int64 `xml:"Size"` // Object size
ETag string `xml:"ETag"` // Object ETag
StorageClass string `xml:"StorageClass"` // Object storage class (Standard, IA, Archive)
Owner Owner `xml:"Owner"` // bucket owner element
}
// Owner defines Bucket/Object's owner
type Owner struct {
XMLName xml.Name `xml:"Owner"`
ID string `xml:"ID"` // Owner ID
DisplayName string `xml:"DisplayName"` // Owner's display name
}
// CopyObjectResult defines result object of CopyObject
type CopyObjectResult struct {
XMLName xml.Name `xml:"CopyObjectResult"`
LastModified time.Time `xml:"LastModified"` // New object's last modified time.
ETag string `xml:"ETag"` // New object's ETag
}
// GetObjectACLResult defines result of GetObjectACL request
type GetObjectACLResult GetBucketACLResult
type deleteXML struct {
XMLName xml.Name `xml:"Delete"`
Objects []DeleteObject `xml:"Object"` // Objects to delete
Quiet bool `xml:"Quiet"` // Flag of quiet mode.
}
// DeleteObject defines the struct for deleting object
type DeleteObject struct {
XMLName xml.Name `xml:"Object"`
Key string `xml:"Key"` // Object name
VersionId string `xml:"VersionId,omitempty"` // Object VersionId
}
// DeleteObjectsResult defines result of DeleteObjects request
type DeleteObjectsResult struct {
XMLName xml.Name
DeletedObjects []string // Deleted object key list
}
// DeleteObjectsResult_inner defines result of DeleteObjects request
type DeleteObjectVersionsResult struct {
XMLName xml.Name `xml:"DeleteResult"`
DeletedObjectsDetail []DeletedKeyInfo `xml:"Deleted"` // Deleted object detail info
}
// DeleteKeyInfo defines object delete info
type DeletedKeyInfo struct {
XMLName xml.Name `xml:"Deleted"`
Key string `xml:"Key"` // Object key
VersionId string `xml:"VersionId"` // VersionId
DeleteMarker bool `xml:"DeleteMarker"` // Object DeleteMarker
DeleteMarkerVersionId string `xml:"DeleteMarkerVersionId"` // Object DeleteMarkerVersionId
}
// InitiateMultipartUploadResult defines result of InitiateMultipartUpload request
type InitiateMultipartUploadResult struct {
XMLName xml.Name `xml:"InitiateMultipartUploadResult"`
Bucket string `xml:"Bucket"` // Bucket name
Key string `xml:"Key"` // Object name to upload
UploadID string `xml:"UploadId"` // Generated UploadId
}
// UploadPart defines the upload/copy part
type UploadPart struct {
XMLName xml.Name `xml:"Part"`
PartNumber int `xml:"PartNumber"` // Part number
ETag string `xml:"ETag"` // ETag value of the part's data
}
type UploadParts []UploadPart
func (slice UploadParts) Len() int {
return len(slice)
}
func (slice UploadParts) Less(i, j int) bool {
return slice[i].PartNumber < slice[j].PartNumber
}
func (slice UploadParts) Swap(i, j int) {
slice[i], slice[j] = slice[j], slice[i]
}
// UploadPartCopyResult defines result object of multipart copy request.
type UploadPartCopyResult struct {
XMLName xml.Name `xml:"CopyPartResult"`
LastModified time.Time `xml:"LastModified"` // Last modified time
ETag string `xml:"ETag"` // ETag
}
type completeMultipartUploadXML struct {
XMLName xml.Name `xml:"CompleteMultipartUpload"`
Part []UploadPart `xml:"Part"`
}
// CompleteMultipartUploadResult defines result object of CompleteMultipartUploadRequest
type CompleteMultipartUploadResult struct {
XMLName xml.Name `xml:"CompleteMultipartUploadResult"`
Location string `xml:"Location"` // Object URL
Bucket string `xml:"Bucket"` // Bucket name
ETag string `xml:"ETag"` // Object ETag
Key string `xml:"Key"` // Object name
}
// ListUploadedPartsResult defines result object of ListUploadedParts
type ListUploadedPartsResult struct {
XMLName xml.Name `xml:"ListPartsResult"`
Bucket string `xml:"Bucket"` // Bucket name
Key string `xml:"Key"` // Object name
UploadID string `xml:"UploadId"` // Upload ID
NextPartNumberMarker string `xml:"NextPartNumberMarker"` // Next part number
MaxParts int `xml:"MaxParts"` // Max parts count
IsTruncated bool `xml:"IsTruncated"` // Flag indicates all entries returned.false: all entries returned.
UploadedParts []UploadedPart `xml:"Part"` // Uploaded parts
}
// UploadedPart defines uploaded part
type UploadedPart struct {
XMLName xml.Name `xml:"Part"`
PartNumber int `xml:"PartNumber"` // Part number
LastModified time.Time `xml:"LastModified"` // Last modified time
ETag string `xml:"ETag"` // ETag cache
Size int `xml:"Size"` // Part size
}
// ListMultipartUploadResult defines result object of ListMultipartUpload
type ListMultipartUploadResult struct {
XMLName xml.Name `xml:"ListMultipartUploadsResult"`
Bucket string `xml:"Bucket"` // Bucket name
Delimiter string `xml:"Delimiter"` // Delimiter for grouping object.
Prefix string `xml:"Prefix"` // Object prefix
KeyMarker string `xml:"KeyMarker"` // Object key marker
UploadIDMarker string `xml:"UploadIdMarker"` // UploadId marker
NextKeyMarker string `xml:"NextKeyMarker"` // Next key marker, if not all entries returned.
NextUploadIDMarker string `xml:"NextUploadIdMarker"` // Next uploadId marker, if not all entries returned.
MaxUploads int `xml:"MaxUploads"` // Max uploads to return
IsTruncated bool `xml:"IsTruncated"` // Flag indicates all entries are returned.
Uploads []UncompletedUpload `xml:"Upload"` // Ongoing uploads (not completed, not aborted)
CommonPrefixes []string `xml:"CommonPrefixes>Prefix"` // Common prefixes list.
}
// UncompletedUpload structure wraps an uncompleted upload task
type UncompletedUpload struct {
XMLName xml.Name `xml:"Upload"`
Key string `xml:"Key"` // Object name
UploadID string `xml:"UploadId"` // The UploadId
Initiated time.Time `xml:"Initiated"` // Initialization time in the format such as 2012-02-23T04:18:23.000Z
}
// ProcessObjectResult defines result object of ProcessObject
type ProcessObjectResult struct {
Bucket string `json:"bucket"`
FileSize int `json:"fileSize"`
Object string `json:"object"`
Status string `json:"status"`
}
// decodeDeleteObjectsResult decodes deleting objects result in URL encoding
func decodeDeleteObjectsResult(result *DeleteObjectVersionsResult) error {
var err error
for i := 0; i < len(result.DeletedObjectsDetail); i++ {
result.DeletedObjectsDetail[i].Key, err = url.QueryUnescape(result.DeletedObjectsDetail[i].Key)
if err != nil {
return err
}
}
return nil
}
// decodeListObjectsResult decodes list objects result in URL encoding
func decodeListObjectsResult(result *ListObjectsResult) error {
var err error
result.Prefix, err = url.QueryUnescape(result.Prefix)
if err != nil {
return err
}
result.Marker, err = url.QueryUnescape(result.Marker)
if err != nil {
return err
}
result.Delimiter, err = url.QueryUnescape(result.Delimiter)
if err != nil {
return err
}
result.NextMarker, err = url.QueryUnescape(result.NextMarker)
if err != nil {
return err
}
for i := 0; i < len(result.Objects); i++ {
result.Objects[i].Key, err = url.QueryUnescape(result.Objects[i].Key)
if err != nil {
return err
}
}
for i := 0; i < len(result.CommonPrefixes); i++ {
result.CommonPrefixes[i], err = url.QueryUnescape(result.CommonPrefixes[i])
if err != nil {
return err
}
}
return nil
}
// decodeListObjectsResult decodes list objects result in URL encoding
func decodeListObjectsResultV2(result *ListObjectsResultV2) error {
var err error
result.Prefix, err = url.QueryUnescape(result.Prefix)
if err != nil {
return err
}
result.StartAfter, err = url.QueryUnescape(result.StartAfter)
if err != nil {
return err
}
result.Delimiter, err = url.QueryUnescape(result.Delimiter)
if err != nil {
return err
}
result.NextContinuationToken, err = url.QueryUnescape(result.NextContinuationToken)
if err != nil {
return err
}
for i := 0; i < len(result.Objects); i++ {
result.Objects[i].Key, err = url.QueryUnescape(result.Objects[i].Key)
if err != nil {
return err
}
}
for i := 0; i < len(result.CommonPrefixes); i++ {
result.CommonPrefixes[i], err = url.QueryUnescape(result.CommonPrefixes[i])
if err != nil {
return err
}
}
return nil
}
// decodeListObjectVersionsResult decodes list version objects result in URL encoding
func decodeListObjectVersionsResult(result *ListObjectVersionsResult) error {
var err error
// decode:Delimiter
result.Delimiter, err = url.QueryUnescape(result.Delimiter)
if err != nil {
return err
}
// decode Prefix
result.Prefix, err = url.QueryUnescape(result.Prefix)
if err != nil {
return err
}
// decode KeyMarker
result.KeyMarker, err = url.QueryUnescape(result.KeyMarker)
if err != nil {
return err
}
// decode VersionIdMarker
result.VersionIdMarker, err = url.QueryUnescape(result.VersionIdMarker)
if err != nil {
return err
}
// decode NextKeyMarker
result.NextKeyMarker, err = url.QueryUnescape(result.NextKeyMarker)
if err != nil {
return err
}
// decode NextVersionIdMarker
result.NextVersionIdMarker, err = url.QueryUnescape(result.NextVersionIdMarker)
if err != nil {
return err
}
// decode CommonPrefixes
for i := 0; i < len(result.CommonPrefixes); i++ {
result.CommonPrefixes[i], err = url.QueryUnescape(result.CommonPrefixes[i])
if err != nil {
return err
}
}
// decode deleteMarker
for i := 0; i < len(result.ObjectDeleteMarkers); i++ {
result.ObjectDeleteMarkers[i].Key, err = url.QueryUnescape(result.ObjectDeleteMarkers[i].Key)
if err != nil {
return err
}
}
// decode ObjectVersions
for i := 0; i < len(result.ObjectVersions); i++ {
result.ObjectVersions[i].Key, err = url.QueryUnescape(result.ObjectVersions[i].Key)
if err != nil {
return err
}
}
return nil
}
// decodeListUploadedPartsResult decodes
func decodeListUploadedPartsResult(result *ListUploadedPartsResult) error {
var err error
result.Key, err = url.QueryUnescape(result.Key)
if err != nil {
return err
}
return nil
}
// decodeListMultipartUploadResult decodes list multipart upload result in URL encoding
func decodeListMultipartUploadResult(result *ListMultipartUploadResult) error {
var err error
result.Prefix, err = url.QueryUnescape(result.Prefix)
if err != nil {
return err
}
result.Delimiter, err = url.QueryUnescape(result.Delimiter)
if err != nil {
return err
}
result.KeyMarker, err = url.QueryUnescape(result.KeyMarker)
if err != nil {
return err
}
result.NextKeyMarker, err = url.QueryUnescape(result.NextKeyMarker)
if err != nil {
return err
}
for i := 0; i < len(result.Uploads); i++ {
result.Uploads[i].Key, err = url.QueryUnescape(result.Uploads[i].Key)
if err != nil {
return err
}
}
for i := 0; i < len(result.CommonPrefixes); i++ {
result.CommonPrefixes[i], err = url.QueryUnescape(result.CommonPrefixes[i])
if err != nil {
return err
}
}
return nil
}
// createBucketConfiguration defines the configuration for creating a bucket.
type createBucketConfiguration struct {
XMLName xml.Name `xml:"CreateBucketConfiguration"`
StorageClass StorageClassType `xml:"StorageClass,omitempty"`
DataRedundancyType DataRedundancyType `xml:"DataRedundancyType,omitempty"`
ObjectHashFunction ObjecthashFuncType `xml:"ObjectHashFunction,omitempty"`
}
// LiveChannelConfiguration defines the configuration for live-channel
type LiveChannelConfiguration struct {
XMLName xml.Name `xml:"LiveChannelConfiguration"`
Description string `xml:"Description,omitempty"` //Description of live-channel, up to 128 bytes
Status string `xml:"Status,omitempty"` //Specify the status of livechannel
Target LiveChannelTarget `xml:"Target"` //target configuration of live-channel
// use point instead of struct to avoid omit empty snapshot
Snapshot *LiveChannelSnapshot `xml:"Snapshot,omitempty"` //snapshot configuration of live-channel
}
// LiveChannelTarget target configuration of live-channel
type LiveChannelTarget struct {
XMLName xml.Name `xml:"Target"`
Type string `xml:"Type"` //the type of object, only supports HLS
FragDuration int `xml:"FragDuration,omitempty"` //the length of each ts object (in seconds), in the range [1,100]
FragCount int `xml:"FragCount,omitempty"` //the number of ts objects in the m3u8 object, in the range of [1,100]
PlaylistName string `xml:"PlaylistName,omitempty"` //the name of m3u8 object, which must end with ".m3u8" and the length range is [6,128]
}
// LiveChannelSnapshot snapshot configuration of live-channel
type LiveChannelSnapshot struct {
XMLName xml.Name `xml:"Snapshot"`
RoleName string `xml:"RoleName,omitempty"` //The role of snapshot operations, it sholud has write permission of DestBucket and the permission to send messages to the NotifyTopic.
DestBucket string `xml:"DestBucket,omitempty"` //Bucket the snapshots will be written to. should be the same owner as the source bucket.
NotifyTopic string `xml:"NotifyTopic,omitempty"` //Topics of MNS for notifying users of high frequency screenshot operation results
Interval int `xml:"Interval,omitempty"` //interval of snapshots, threre is no snapshot if no I-frame during the interval time
}
// CreateLiveChannelResult the result of crete live-channel
type CreateLiveChannelResult struct {
XMLName xml.Name `xml:"CreateLiveChannelResult"`
PublishUrls []string `xml:"PublishUrls>Url"` //push urls list
PlayUrls []string `xml:"PlayUrls>Url"` //play urls list
}
// LiveChannelStat the result of get live-channel state
type LiveChannelStat struct {
XMLName xml.Name `xml:"LiveChannelStat"`
Status string `xml:"Status"` //Current push status of live-channel: Disabled,Live,Idle
ConnectedTime time.Time `xml:"ConnectedTime"` //The time when the client starts pushing, format: ISO8601
RemoteAddr string `xml:"RemoteAddr"` //The ip address of the client
Video LiveChannelVideo `xml:"Video"` //Video stream information
Audio LiveChannelAudio `xml:"Audio"` //Audio stream information
}
// LiveChannelVideo video stream information
type LiveChannelVideo struct {
XMLName xml.Name `xml:"Video"`
Width int `xml:"Width"` //Width (unit: pixels)
Height int `xml:"Height"` //Height (unit: pixels)
FrameRate int `xml:"FrameRate"` //FramRate
Bandwidth int `xml:"Bandwidth"` //Bandwidth (unit: B/s)
}
// LiveChannelAudio audio stream information
type LiveChannelAudio struct {
XMLName xml.Name `xml:"Audio"`
SampleRate int `xml:"SampleRate"` //SampleRate
Bandwidth int `xml:"Bandwidth"` //Bandwidth (unit: B/s)
Codec string `xml:"Codec"` //Encoding forma
}
// LiveChannelHistory the result of GetLiveChannelHistory, at most return up to lastest 10 push records
type LiveChannelHistory struct {
XMLName xml.Name `xml:"LiveChannelHistory"`
Record []LiveRecord `xml:"LiveRecord"` //push records list
}
// LiveRecord push recode
type LiveRecord struct {
XMLName xml.Name `xml:"LiveRecord"`
StartTime time.Time `xml:"StartTime"` //StartTime, format: ISO8601
EndTime time.Time `xml:"EndTime"` //EndTime, format: ISO8601
RemoteAddr string `xml:"RemoteAddr"` //The ip address of remote client
}
// ListLiveChannelResult the result of ListLiveChannel
type ListLiveChannelResult struct {
XMLName xml.Name `xml:"ListLiveChannelResult"`
Prefix string `xml:"Prefix"` //Filter by the name start with the value of "Prefix"
Marker string `xml:"Marker"` //cursor from which starting list
MaxKeys int `xml:"MaxKeys"` //The maximum count returned. the default value is 100. it cannot be greater than 1000.
IsTruncated bool `xml:"IsTruncated"` //Indicates whether all results have been returned, "true" indicates partial results returned while "false" indicates all results have been returned
NextMarker string `xml:"NextMarker"` //NextMarker indicate the Marker value of the next request
LiveChannel []LiveChannelInfo `xml:"LiveChannel"` //The infomation of live-channel
}
// LiveChannelInfo the infomation of live-channel
type LiveChannelInfo struct {
XMLName xml.Name `xml:"LiveChannel"`
Name string `xml:"Name"` //The name of live-channel
Description string `xml:"Description"` //Description of live-channel
Status string `xml:"Status"` //Status: disabled or enabled
LastModified time.Time `xml:"LastModified"` //Last modification time, format: ISO8601
PublishUrls []string `xml:"PublishUrls>Url"` //push urls list
PlayUrls []string `xml:"PlayUrls>Url"` //play urls list
}
// Tag a tag for the object
type Tag struct {
XMLName xml.Name `xml:"Tag"`
Key string `xml:"Key"`
Value string `xml:"Value"`
}
// Tagging tagset for the object
type Tagging struct {
XMLName xml.Name `xml:"Tagging"`
Tags []Tag `xml:"TagSet>Tag,omitempty"`
}
// for GetObjectTagging return value
type GetObjectTaggingResult Tagging
// VersioningConfig for the bucket
type VersioningConfig struct {
XMLName xml.Name `xml:"VersioningConfiguration"`
Status string `xml:"Status"`
}
type GetBucketVersioningResult VersioningConfig
// Server Encryption rule for the bucket
type ServerEncryptionRule struct {
XMLName xml.Name `xml:"ServerSideEncryptionRule"`
SSEDefault SSEDefaultRule `xml:"ApplyServerSideEncryptionByDefault"`
}
// Server Encryption deafult rule for the bucket
type SSEDefaultRule struct {
XMLName xml.Name `xml:"ApplyServerSideEncryptionByDefault"`
SSEAlgorithm string `xml:"SSEAlgorithm,omitempty"`
KMSMasterKeyID string `xml:"KMSMasterKeyID,omitempty"`
KMSDataEncryption string `xml:"KMSDataEncryption,,omitempty"`
}
type GetBucketEncryptionResult ServerEncryptionRule
type GetBucketTaggingResult Tagging
type BucketStat struct {
XMLName xml.Name `xml:"BucketStat"`
Storage int64 `xml:"Storage"`
ObjectCount int64 `xml:"ObjectCount"`
MultipartUploadCount int64 `xml:"MultipartUploadCount"`
}
type GetBucketStatResult BucketStat
// RequestPaymentConfiguration define the request payment configuration
type RequestPaymentConfiguration struct {
XMLName xml.Name `xml:"RequestPaymentConfiguration"`
Payer string `xml:"Payer,omitempty"`
}
// BucketQoSConfiguration define QoS configuration
type BucketQoSConfiguration struct {
XMLName xml.Name `xml:"QoSConfiguration"`
TotalUploadBandwidth *int `xml:"TotalUploadBandwidth"` // Total upload bandwidth
IntranetUploadBandwidth *int `xml:"IntranetUploadBandwidth"` // Intranet upload bandwidth
ExtranetUploadBandwidth *int `xml:"ExtranetUploadBandwidth"` // Extranet upload bandwidth
TotalDownloadBandwidth *int `xml:"TotalDownloadBandwidth"` // Total download bandwidth
IntranetDownloadBandwidth *int `xml:"IntranetDownloadBandwidth"` // Intranet download bandwidth
ExtranetDownloadBandwidth *int `xml:"ExtranetDownloadBandwidth"` // Extranet download bandwidth
TotalQPS *int `xml:"TotalQps"` // Total Qps
IntranetQPS *int `xml:"IntranetQps"` // Intranet Qps
ExtranetQPS *int `xml:"ExtranetQps"` // Extranet Qps
}
// UserQoSConfiguration define QoS and Range configuration
type UserQoSConfiguration struct {
XMLName xml.Name `xml:"QoSConfiguration"`
Region string `xml:"Region,omitempty"` // Effective area of Qos configuration
BucketQoSConfiguration
}
//////////////////////////////////////////////////////////////
/////////////////// Select OBject ////////////////////////////
//////////////////////////////////////////////////////////////
type CsvMetaRequest struct {
XMLName xml.Name `xml:"CsvMetaRequest"`
InputSerialization InputSerialization `xml:"InputSerialization"`
OverwriteIfExists *bool `xml:"OverwriteIfExists,omitempty"`
}
// encodeBase64 encode base64 of the CreateSelectObjectMeta api request params
func (meta *CsvMetaRequest) encodeBase64() {
meta.InputSerialization.CSV.RecordDelimiter =
base64.StdEncoding.EncodeToString([]byte(meta.InputSerialization.CSV.RecordDelimiter))
meta.InputSerialization.CSV.FieldDelimiter =
base64.StdEncoding.EncodeToString([]byte(meta.InputSerialization.CSV.FieldDelimiter))
meta.InputSerialization.CSV.QuoteCharacter =
base64.StdEncoding.EncodeToString([]byte(meta.InputSerialization.CSV.QuoteCharacter))
}
type JsonMetaRequest struct {
XMLName xml.Name `xml:"JsonMetaRequest"`
InputSerialization InputSerialization `xml:"InputSerialization"`
OverwriteIfExists *bool `xml:"OverwriteIfExists,omitempty"`
}
type InputSerialization struct {
XMLName xml.Name `xml:"InputSerialization"`
CSV CSV `xml:CSV,omitempty`
JSON JSON `xml:JSON,omitempty`
CompressionType string `xml:"CompressionType,omitempty"`
}
type CSV struct {
XMLName xml.Name `xml:"CSV"`
RecordDelimiter string `xml:"RecordDelimiter,omitempty"`
FieldDelimiter string `xml:"FieldDelimiter,omitempty"`
QuoteCharacter string `xml:"QuoteCharacter,omitempty"`
}
type JSON struct {
XMLName xml.Name `xml:"JSON"`
JSONType string `xml:"Type,omitempty"`
}
// SelectRequest is for the SelectObject request params of json file
type SelectRequest struct {
XMLName xml.Name `xml:"SelectRequest"`
Expression string `xml:"Expression"`
InputSerializationSelect InputSerializationSelect `xml:"InputSerialization"`
OutputSerializationSelect OutputSerializationSelect `xml:"OutputSerialization"`
SelectOptions SelectOptions `xml:"Options,omitempty"`
}
type InputSerializationSelect struct {
XMLName xml.Name `xml:"InputSerialization"`
CsvBodyInput CSVSelectInput `xml:CSV,omitempty`
JsonBodyInput JSONSelectInput `xml:JSON,omitempty`
CompressionType string `xml:"CompressionType,omitempty"`
}
type CSVSelectInput struct {
XMLName xml.Name `xml:"CSV"`
FileHeaderInfo string `xml:"FileHeaderInfo,omitempty"`
RecordDelimiter string `xml:"RecordDelimiter,omitempty"`
FieldDelimiter string `xml:"FieldDelimiter,omitempty"`
QuoteCharacter string `xml:"QuoteCharacter,omitempty"`
CommentCharacter string `xml:"CommentCharacter,omitempty"`
Range string `xml:"Range,omitempty"`
SplitRange string
}
type JSONSelectInput struct {
XMLName xml.Name `xml:"JSON"`
JSONType string `xml:"Type,omitempty"`
Range string `xml:"Range,omitempty"`
ParseJSONNumberAsString *bool `xml:"ParseJsonNumberAsString"`
SplitRange string
}