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
|
package s3api
import (
"net/http"
"github.com/seaweedfs/seaweedfs/weed/pb/filer_pb"
"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
)
// CopySizeCalculator handles size calculations for different copy scenarios
type CopySizeCalculator struct {
srcSize int64
srcEncrypted bool
dstEncrypted bool
srcType EncryptionType
dstType EncryptionType
isCompressed bool
}
// EncryptionType represents different encryption types
type EncryptionType int
const (
EncryptionTypeNone EncryptionType = iota
EncryptionTypeSSEC
EncryptionTypeSSEKMS
EncryptionTypeSSES3
)
// NewCopySizeCalculator creates a new size calculator for copy operations
func NewCopySizeCalculator(entry *filer_pb.Entry, r *http.Request) *CopySizeCalculator {
calc := &CopySizeCalculator{
srcSize: int64(entry.Attributes.FileSize),
isCompressed: isCompressedEntry(entry),
}
// Determine source encryption type
calc.srcType, calc.srcEncrypted = getSourceEncryptionType(entry.Extended)
// Determine destination encryption type
calc.dstType, calc.dstEncrypted = getDestinationEncryptionType(r)
return calc
}
// CalculateTargetSize calculates the expected size of the target object
func (calc *CopySizeCalculator) CalculateTargetSize() int64 {
// For compressed objects, size calculation is complex
if calc.isCompressed {
return -1 // Indicates unknown size
}
switch {
case !calc.srcEncrypted && !calc.dstEncrypted:
// Plain → Plain: no size change
return calc.srcSize
case !calc.srcEncrypted && calc.dstEncrypted:
// Plain → Encrypted: no overhead since IV is in metadata
return calc.srcSize
case calc.srcEncrypted && !calc.dstEncrypted:
// Encrypted → Plain: no overhead since IV is in metadata
return calc.srcSize
case calc.srcEncrypted && calc.dstEncrypted:
// Encrypted → Encrypted: no overhead since IV is in metadata
return calc.srcSize
default:
return calc.srcSize
}
}
// CalculateActualSize calculates the actual unencrypted size of the content
func (calc *CopySizeCalculator) CalculateActualSize() int64 {
// With IV in metadata, encrypted and unencrypted sizes are the same
return calc.srcSize
}
// CalculateEncryptedSize calculates the encrypted size for the given encryption type
func (calc *CopySizeCalculator) CalculateEncryptedSize(encType EncryptionType) int64 {
// With IV in metadata, encrypted size equals actual size
return calc.CalculateActualSize()
}
// getSourceEncryptionType determines the encryption type of the source object
func getSourceEncryptionType(metadata map[string][]byte) (EncryptionType, bool) {
if IsSSECEncrypted(metadata) {
return EncryptionTypeSSEC, true
}
if IsSSEKMSEncrypted(metadata) {
return EncryptionTypeSSEKMS, true
}
if IsSSES3EncryptedInternal(metadata) {
return EncryptionTypeSSES3, true
}
return EncryptionTypeNone, false
}
// getDestinationEncryptionType determines the encryption type for the destination
func getDestinationEncryptionType(r *http.Request) (EncryptionType, bool) {
if IsSSECRequest(r) {
return EncryptionTypeSSEC, true
}
if IsSSEKMSRequest(r) {
return EncryptionTypeSSEKMS, true
}
if IsSSES3RequestInternal(r) {
return EncryptionTypeSSES3, true
}
return EncryptionTypeNone, false
}
// isCompressedEntry checks if the entry represents a compressed object
func isCompressedEntry(entry *filer_pb.Entry) bool {
// Check for compression indicators in metadata
if compressionType, exists := entry.Extended["compression"]; exists {
return string(compressionType) != ""
}
// Check MIME type for compressed formats
mimeType := entry.Attributes.Mime
compressedMimeTypes := []string{
"application/gzip",
"application/x-gzip",
"application/zip",
"application/x-compress",
"application/x-compressed",
}
for _, compressedType := range compressedMimeTypes {
if mimeType == compressedType {
return true
}
}
return false
}
// SizeTransitionInfo provides detailed information about size changes during copy
type SizeTransitionInfo struct {
SourceSize int64
TargetSize int64
ActualSize int64
SizeChange int64
SourceType EncryptionType
TargetType EncryptionType
IsCompressed bool
RequiresResize bool
}
// GetSizeTransitionInfo returns detailed size transition information
func (calc *CopySizeCalculator) GetSizeTransitionInfo() *SizeTransitionInfo {
targetSize := calc.CalculateTargetSize()
actualSize := calc.CalculateActualSize()
info := &SizeTransitionInfo{
SourceSize: calc.srcSize,
TargetSize: targetSize,
ActualSize: actualSize,
SizeChange: targetSize - calc.srcSize,
SourceType: calc.srcType,
TargetType: calc.dstType,
IsCompressed: calc.isCompressed,
RequiresResize: targetSize != calc.srcSize,
}
return info
}
// String returns a string representation of the encryption type
func (e EncryptionType) String() string {
switch e {
case EncryptionTypeNone:
return "None"
case EncryptionTypeSSEC:
return s3_constants.SSETypeC
case EncryptionTypeSSEKMS:
return s3_constants.SSETypeKMS
case EncryptionTypeSSES3:
return s3_constants.SSETypeS3
default:
return "Unknown"
}
}
// OptimizedSizeCalculation provides size calculations optimized for different scenarios
type OptimizedSizeCalculation struct {
Strategy UnifiedCopyStrategy
SourceSize int64
TargetSize int64
ActualContentSize int64
EncryptionOverhead int64
CanPreallocate bool
RequiresStreaming bool
}
// CalculateOptimizedSizes calculates sizes optimized for the copy strategy
func CalculateOptimizedSizes(entry *filer_pb.Entry, r *http.Request, strategy UnifiedCopyStrategy) *OptimizedSizeCalculation {
calc := NewCopySizeCalculator(entry, r)
info := calc.GetSizeTransitionInfo()
result := &OptimizedSizeCalculation{
Strategy: strategy,
SourceSize: info.SourceSize,
TargetSize: info.TargetSize,
ActualContentSize: info.ActualSize,
CanPreallocate: !info.IsCompressed && info.TargetSize > 0,
RequiresStreaming: info.IsCompressed || info.TargetSize < 0,
}
// Calculate encryption overhead for the target
// With IV in metadata, all encryption overhead is 0
result.EncryptionOverhead = 0
// Adjust based on strategy
switch strategy {
case CopyStrategyDirect:
// Direct copy: no size change
result.TargetSize = result.SourceSize
result.CanPreallocate = true
case CopyStrategyKeyRotation:
// Key rotation: size might change slightly due to different IVs
if info.SourceType == EncryptionTypeSSEC && info.TargetType == EncryptionTypeSSEC {
// SSE-C key rotation: same overhead
result.TargetSize = result.SourceSize
}
result.CanPreallocate = true
case CopyStrategyEncrypt, CopyStrategyDecrypt, CopyStrategyReencrypt:
// Size changes based on encryption transition
result.TargetSize = info.TargetSize
result.CanPreallocate = !info.IsCompressed
}
return result
}
|
