JakeHillion/storj
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Integrate new Metainfo calls (server side) (#2682)

Browse Source
This commit is contained in:
Michal Niewrzal 2019-08-01 11:04:31 +02:00 committed by GitHub
parent 238e264a8f
commit 287fdf9936
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 729 additions and 532 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

485
pkg/pb/metainfo.pb.go
View File

@ -1661,17 +1661,15 @@ func (m *Object) GetRemoteSize() int64 {
}
type ObjectBeginRequest struct {
Bucket []byte `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
EncryptedPath []byte `protobuf:"bytes,2,opt,name=encrypted_path,json=encryptedPath,proto3" json:"encrypted_path,omitempty"`
Version int32 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"`
ExpiresAt time.Time `protobuf:"bytes,4,opt,name=expires_at,json=expiresAt,proto3,stdtime" json:"expires_at"`
EncryptedMetadataNonce Nonce `protobuf:"bytes,5,opt,name=encrypted_metadata_nonce,json=encryptedMetadataNonce,proto3,customtype=Nonce" json:"encrypted_metadata_nonce"`
EncryptedMetadata []byte `protobuf:"bytes,6,opt,name=encrypted_metadata,json=encryptedMetadata,proto3" json:"encrypted_metadata,omitempty"`
RedundancyScheme *RedundancyScheme `protobuf:"bytes,7,opt,name=redundancy_scheme,json=redundancyScheme,proto3" json:"redundancy_scheme,omitempty"`
EncryptionParameters *EncryptionParameters `protobuf:"bytes,8,opt,name=encryption_parameters,json=encryptionParameters,proto3" json:"encryption_parameters,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Bucket []byte `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
EncryptedPath []byte `protobuf:"bytes,2,opt,name=encrypted_path,json=encryptedPath,proto3" json:"encrypted_path,omitempty"`
Version int32 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"`
ExpiresAt time.Time `protobuf:"bytes,4,opt,name=expires_at,json=expiresAt,proto3,stdtime" json:"expires_at"`
RedundancyScheme *RedundancyScheme `protobuf:"bytes,7,opt,name=redundancy_scheme,json=redundancyScheme,proto3" json:"redundancy_scheme,omitempty"`
EncryptionParameters *EncryptionParameters `protobuf:"bytes,8,opt,name=encryption_parameters,json=encryptionParameters,proto3" json:"encryption_parameters,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ObjectBeginRequest) Reset() { *m = ObjectBeginRequest{} }
@ -1726,13 +1724,6 @@ func (m *ObjectBeginRequest) GetExpiresAt() time.Time {
return time.Time{}
}
func (m *ObjectBeginRequest) GetEncryptedMetadata() []byte {
if m != nil {
return m.EncryptedMetadata
}
return nil
}
func (m *ObjectBeginRequest) GetRedundancyScheme() *RedundancyScheme {
if m != nil {
return m.RedundancyScheme
@ -1819,10 +1810,12 @@ func (m *ObjectBeginResponse) GetEncryptionParameters() *EncryptionParameters {
}
type ObjectCommitRequest struct {
StreamId StreamID `protobuf:"bytes,1,opt,name=stream_id,json=streamId,proto3,customtype=StreamID" json:"stream_id"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
StreamId StreamID `protobuf:"bytes,1,opt,name=stream_id,json=streamId,proto3,customtype=StreamID" json:"stream_id"`
EncryptedMetadataNonce Nonce `protobuf:"bytes,2,opt,name=encrypted_metadata_nonce,json=encryptedMetadataNonce,proto3,customtype=Nonce" json:"encrypted_metadata_nonce"`
EncryptedMetadata []byte `protobuf:"bytes,3,opt,name=encrypted_metadata,json=encryptedMetadata,proto3" json:"encrypted_metadata,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *ObjectCommitRequest) Reset() { *m = ObjectCommitRequest{} }
@ -1849,6 +1842,13 @@ func (m *ObjectCommitRequest) XXX_DiscardUnknown() {
var xxx_messageInfo_ObjectCommitRequest proto.InternalMessageInfo
func (m *ObjectCommitRequest) GetEncryptedMetadata() []byte {
if m != nil {
return m.EncryptedMetadata
}
return nil
}
type ObjectCommitResponse struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
@ -1975,8 +1975,9 @@ type ObjectListRequest struct {
Bucket []byte `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
EncryptedPrefix []byte `protobuf:"bytes,2,opt,name=encrypted_prefix,json=encryptedPrefix,proto3" json:"encrypted_prefix,omitempty"`
EncryptedCursor []byte `protobuf:"bytes,3,opt,name=encrypted_cursor,json=encryptedCursor,proto3" json:"encrypted_cursor,omitempty"`
Limit int32 `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`
ObjectIncludes *ObjectListItemIncludes `protobuf:"bytes,5,opt,name=object_includes,json=objectIncludes,proto3" json:"object_includes,omitempty"`
Recursive bool `protobuf:"varint,4,opt,name=recursive,proto3" json:"recursive,omitempty"`
Limit int32 `protobuf:"varint,5,opt,name=limit,proto3" json:"limit,omitempty"`
ObjectIncludes *ObjectListItemIncludes `protobuf:"bytes,6,opt,name=object_includes,json=objectIncludes,proto3" json:"object_includes,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -2027,6 +2028,13 @@ func (m *ObjectListRequest) GetEncryptedCursor() []byte {
return nil
}
func (m *ObjectListRequest) GetRecursive() bool {
if m != nil {
return m.Recursive
}
return false
}
func (m *ObjectListRequest) GetLimit() int32 {
if m != nil {
return m.Limit
@ -2360,18 +2368,16 @@ var xxx_messageInfo_ObjectFinishDeleteResponse proto.InternalMessageInfo
// only for satellite use
type SatStreamID struct {
Bucket []byte `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
EncryptedPath []byte `protobuf:"bytes,2,opt,name=encrypted_path,json=encryptedPath,proto3" json:"encrypted_path,omitempty"`
Version int32 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"`
Redundancy *RedundancyScheme `protobuf:"bytes,4,opt,name=redundancy,proto3" json:"redundancy,omitempty"`
CreationDate time.Time `protobuf:"bytes,5,opt,name=creation_date,json=creationDate,proto3,stdtime" json:"creation_date"`
ExpirationDate time.Time `protobuf:"bytes,6,opt,name=expiration_date,json=expirationDate,proto3,stdtime" json:"expiration_date"`
EncryptedMetadataNonce Nonce `protobuf:"bytes,7,opt,name=encrypted_metadata_nonce,json=encryptedMetadataNonce,proto3,customtype=Nonce" json:"encrypted_metadata_nonce"`
EncryptedMetadata []byte `protobuf:"bytes,8,opt,name=encrypted_metadata,json=encryptedMetadata,proto3" json:"encrypted_metadata,omitempty"`
SatelliteSignature []byte `protobuf:"bytes,9,opt,name=satellite_signature,json=satelliteSignature,proto3" json:"satellite_signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Bucket []byte `protobuf:"bytes,1,opt,name=bucket,proto3" json:"bucket,omitempty"`
EncryptedPath []byte `protobuf:"bytes,2,opt,name=encrypted_path,json=encryptedPath,proto3" json:"encrypted_path,omitempty"`
Version int32 `protobuf:"varint,3,opt,name=version,proto3" json:"version,omitempty"`
Redundancy *RedundancyScheme `protobuf:"bytes,4,opt,name=redundancy,proto3" json:"redundancy,omitempty"`
CreationDate time.Time `protobuf:"bytes,5,opt,name=creation_date,json=creationDate,proto3,stdtime" json:"creation_date"`
ExpirationDate time.Time `protobuf:"bytes,6,opt,name=expiration_date,json=expirationDate,proto3,stdtime" json:"expiration_date"`
SatelliteSignature []byte `protobuf:"bytes,9,opt,name=satellite_signature,json=satelliteSignature,proto3" json:"satellite_signature,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *SatStreamID) Reset() { *m = SatStreamID{} }
@ -2440,13 +2446,6 @@ func (m *SatStreamID) GetExpirationDate() time.Time {
return time.Time{}
}
func (m *SatStreamID) GetEncryptedMetadata() []byte {
if m != nil {
return m.EncryptedMetadata
}
return nil
}
func (m *SatStreamID) GetSatelliteSignature() []byte {
if m != nil {
return m.SatelliteSignature
@ -3048,6 +3047,7 @@ func (m *SegmentBeginDeleteRequest) GetPosition() *SegmentPosition {
type SegmentBeginDeleteResponse struct {
SegmentId SegmentID `protobuf:"bytes,1,opt,name=segment_id,json=segmentId,proto3,customtype=SegmentID" json:"segment_id"`
AddressedLimits []*AddressedOrderLimit `protobuf:"bytes,2,rep,name=addressed_limits,json=addressedLimits,proto3" json:"addressed_limits,omitempty"`
PrivateKey PiecePrivateKey `protobuf:"bytes,3,opt,name=private_key,json=privateKey,proto3,customtype=PiecePrivateKey" json:"private_key"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -3380,8 +3380,12 @@ func (m *SegmentDownloadRequest) GetCursorPosition() *SegmentPosition {
type SegmentDownloadResponse struct {
SegmentId SegmentID `protobuf:"bytes,1,opt,name=segment_id,json=segmentId,proto3,customtype=SegmentID" json:"segment_id"`
AddressedLimits []*AddressedOrderLimit `protobuf:"bytes,2,rep,name=addressed_limits,json=addressedLimits,proto3" json:"addressed_limits,omitempty"`
EncryptedInlineData []byte `protobuf:"bytes,3,opt,name=encrypted_inline_data,json=encryptedInlineData,proto3" json:"encrypted_inline_data,omitempty"`
Next *SegmentPosition `protobuf:"bytes,4,opt,name=next,proto3" json:"next,omitempty"`
PrivateKey PiecePrivateKey `protobuf:"bytes,3,opt,name=private_key,json=privateKey,proto3,customtype=PiecePrivateKey" json:"private_key"`
EncryptedInlineData []byte `protobuf:"bytes,4,opt,name=encrypted_inline_data,json=encryptedInlineData,proto3" json:"encrypted_inline_data,omitempty"`
SegmentSize int64 `protobuf:"varint,5,opt,name=segment_size,json=segmentSize,proto3" json:"segment_size,omitempty"`
EncryptedKeyNonce Nonce `protobuf:"bytes,6,opt,name=encrypted_key_nonce,json=encryptedKeyNonce,proto3,customtype=Nonce" json:"encrypted_key_nonce"`
EncryptedKey []byte `protobuf:"bytes,7,opt,name=encrypted_key,json=encryptedKey,proto3" json:"encrypted_key,omitempty"`
Next *SegmentPosition `protobuf:"bytes,8,opt,name=next,proto3" json:"next,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
@ -3425,6 +3429,20 @@ func (m *SegmentDownloadResponse) GetEncryptedInlineData() []byte {
return nil
}
func (m *SegmentDownloadResponse) GetSegmentSize() int64 {
if m != nil {
return m.SegmentSize
}
return 0
}
func (m *SegmentDownloadResponse) GetEncryptedKey() []byte {
if m != nil {
return m.EncryptedKey
}
return nil
}
func (m *SegmentDownloadResponse) GetNext() *SegmentPosition {
if m != nil {
return m.Next
@ -3506,194 +3524,195 @@ func init() {
func init() { proto.RegisterFile("metainfo.proto", fileDescriptor_631e2f30a93cd64e) }
var fileDescriptor_631e2f30a93cd64e = []byte{
// 2984 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x4b, 0x6f, 0x23, 0xc7,
0xf1, 0xf7, 0xf0, 0xcd, 0x22, 0x45, 0x52, 0x2d, 0xad, 0x96, 0x4b, 0xad, 0x2c, 0x79, 0xd6, 0xbb,
0x96, 0x01, 0x9b, 0x6b, 0xc8, 0xff, 0x3f, 0x60, 0xc0, 0x36, 0x10, 0x49, 0x5c, 0xaf, 0x68, 0xaf,
0x1e, 0x1e, 0xf9, 0x15, 0xc3, 0xc1, 0x60, 0xa4, 0x69, 0x49, 0x93, 0x25, 0x67, 0x98, 0x99, 0xa1,
0xa3, 0xf5, 0x39, 0x40, 0x10, 0x38, 0x87, 0x1c, 0x7d, 0xf2, 0x25, 0xc8, 0x29, 0x9f, 0x20, 0x97,
0x5c, 0x13, 0x24, 0x41, 0x0e, 0x39, 0x26, 0x80, 0x13, 0xe4, 0x90, 0x2f, 0x90, 0x4b, 0x2e, 0x01,
0x82, 0x7e, 0xcd, 0xf4, 0xbc, 0x44, 0x71, 0x45, 0xed, 0xde, 0xa6, 0xbb, 0xaa, 0xab, 0xbb, 0x7f,
0xf5, 0xe8, 0xea, 0x9a, 0x86, 0xc6, 0x10, 0xfb, 0x86, 0x65, 0x9f, 0x38, 0xdd, 0x91, 0xeb, 0xf8,
0x0e, 0xaa, 0x88, 0x76, 0xa7, 0x85, 0xed, 0x63, 0xf7, 0xc9, 0xc8, 0xb7, 0x1c, 0x9b, 0xd1, 0x3a,
0x70, 0xea, 0x9c, 0x72, 0xbe, 0xce, 0xea, 0xa9, 0xe3, 0x9c, 0x0e, 0xf0, 0x7d, 0xda, 0x3a, 0x1a,
0x9f, 0xdc, 0xf7, 0xad, 0x21, 0xf6, 0x7c, 0x63, 0x38, 0x12, 0xcc, 0xb6, 0x63, 0x62, 0xfe, 0xdd,
0x1c, 0x39, 0x96, 0xed, 0x63, 0xd7, 0x3c, 0xe2, 0x1d, 0x75, 0xc7, 0x35, 0xb1, 0xeb, 0xb1, 0x96,
0xfa, 0xeb, 0x3c, 0x94, 0xb6, 0xc6, 0xc7, 0x8f, 0xb1, 0x8f, 0x10, 0x14, 0x6c, 0x63, 0x88, 0xdb,
0xca, 0x9a, 0xb2, 0x5e, 0xd7, 0xe8, 0x37, 0x7a, 0x0b, 0x6a, 0x23, 0xc3, 0x3f, 0xd3, 0x8f, 0xad,
0xd1, 0x19, 0x76, 0xdb, 0xb9, 0x35, 0x65, 0xbd, 0xb1, 0x71, 0xb3, 0x2b, 0x2d, 0x6f, 0x9b, 0x52,
0x0e, 0xc7, 0x96, 0x8f, 0x35, 0x20, 0xbc, 0xac, 0x03, 0x6d, 0x03, 0x1c, 0xbb, 0xd8, 0xf0, 0xb1,
0xa9, 0x1b, 0x7e, 0x3b, 0xbf, 0xa6, 0xac, 0xd7, 0x36, 0x3a, 0x5d, 0xb6, 0xf2, 0xae, 0x58, 0x79,
0xf7, 0x23, 0xb1, 0xf2, 0xad, 0xca, 0xef, 0xbf, 0x5b, 0x7d, 0xe1, 0x17, 0x7f, 0x5f, 0x55, 0xb4,
0x2a, 0x1f, 0xb7, 0xe9, 0xa3, 0x37, 0x60, 0xd1, 0xc4, 0x27, 0xc6, 0x78, 0xe0, 0xeb, 0x1e, 0x3e,
0x1d, 0x62, 0xdb, 0xd7, 0x3d, 0xeb, 0x2b, 0xdc, 0x2e, 0xac, 0x29, 0xeb, 0x79, 0x0d, 0x71, 0xda,
0x21, 0x23, 0x1d, 0x5a, 0x5f, 0x61, 0xf4, 0x29, 0xdc, 0x12, 0x23, 0x5c, 0x6c, 0x8e, 0x6d, 0xd3,
0xb0, 0x8f, 0x9f, 0xe8, 0xde, 0xf1, 0x19, 0x1e, 0xe2, 0x76, 0x91, 0xae, 0x62, 0xb9, 0x1b, 0x42,
0xa2, 0x05, 0x3c, 0x87, 0x94, 0x45, 0xbb, 0xc9, 0x47, 0xc7, 0x09, 0xc8, 0x84, 0x15, 0x21, 0x38,
0xdc, 0xbd, 0x3e, 0x32, 0x5c, 0x63, 0x88, 0x7d, 0xec, 0x7a, 0xed, 0x12, 0x15, 0xbe, 0x26, 0x63,
0xf3, 0x20, 0xf8, 0x3c, 0x08, 0xf8, 0xb4, 0x65, 0x2e, 0x26, 0x8d, 0x88, 0x56, 0x00, 0x46, 0x86,
0xeb, 0xdb, 0xd8, 0xd5, 0x2d, 0xb3, 0x5d, 0xa6, 0x9a, 0xa8, 0xf2, 0x9e, 0xbe, 0xa9, 0x5a, 0xd0,
0x60, 0xca, 0x7a, 0x64, 0x79, 0x7e, 0xdf, 0xc7, 0xc3, 0x54, 0xa5, 0x45, 0xa1, 0xcf, 0x3d, 0x15,
0xf4, 0xea, 0xbf, 0x73, 0xb0, 0xc0, 0xe6, 0xda, 0xa6, 0x7d, 0x1a, 0xfe, 0xd1, 0x18, 0x7b, 0xb3,
0xb6, 0x92, 0x2c, 0x05, 0xe7, 0x9f, 0x4e, 0xc1, 0x85, 0xeb, 0x54, 0x70, 0x71, 0xf6, 0x0a, 0x2e,
0xc5, 0x15, 0xfc, 0x3d, 0x58, 0x8c, 0x82, 0xee, 0x8d, 0x1c, 0xdb, 0xc3, 0x68, 0x1d, 0x4a, 0x47,
0xb4, 0x9f, 0xe2, 0x5e, 0xdb, 0x68, 0x75, 0x83, 0xd8, 0xc1, 0xf8, 0x35, 0x4e, 0x57, 0xef, 0x41,
0x8b, 0xf5, 0x3c, 0xc4, 0xfe, 0x05, 0x3a, 0x53, 0xdf, 0x85, 0x79, 0x89, 0x6f, 0xea, 0x69, 0x5e,
0x15, 0xd6, 0xd1, 0xc3, 0x03, 0x7c, 0xa1, 0x75, 0xa8, 0x4b, 0x62, 0x4f, 0x82, 0x95, 0x4d, 0xa6,
0xea, 0x62, 0x05, 0xc4, 0x98, 0x85, 0x80, 0x25, 0x28, 0x1d, 0x8f, 0x5d, 0xcf, 0x71, 0xb9, 0x08,
0xde, 0x42, 0x8b, 0x50, 0x1c, 0x58, 0x43, 0x8b, 0x99, 0x73, 0x51, 0x63, 0x0d, 0x74, 0x1b, 0xaa,
0xa6, 0xe5, 0xe2, 0x63, 0x02, 0x32, 0xb5, 0x99, 0xa2, 0x16, 0x76, 0xa8, 0x9f, 0x01, 0x92, 0x27,
0xe0, 0x7b, 0xec, 0x42, 0xd1, 0xf2, 0xf1, 0xd0, 0x6b, 0x2b, 0x6b, 0xf9, 0xf5, 0xda, 0x46, 0x3b,
0xbe, 0x45, 0xe1, 0x5a, 0x1a, 0x63, 0x23, 0x5b, 0x1a, 0x3a, 0x2e, 0xa6, 0x13, 0x57, 0x34, 0xfa,
0xad, 0x7e, 0x06, 0xcb, 0x8c, 0xf9, 0x10, 0xfb, 0x9b, 0xbe, 0xef, 0x5a, 0x47, 0x63, 0x32, 0xe3,
0x45, 0x3e, 0x72, 0x17, 0x1a, 0x46, 0xc8, 0x49, 0x94, 0x9f, 0xa3, 0xd4, 0x39, 0xa9, 0xb7, 0x6f,
0xaa, 0x2f, 0xc2, 0xed, 0x74, 0xc9, 0x1c, 0xb4, 0x9f, 0x28, 0xb0, 0xb0, 0x69, 0x9a, 0x2e, 0xf6,
0x3c, 0x6c, 0xee, 0x93, 0x48, 0xfe, 0x88, 0x22, 0xb1, 0x2e, 0xf0, 0x61, 0x8a, 0x43, 0x5d, 0x1e,
0xe5, 0x43, 0x16, 0x81, 0xd9, 0x36, 0x2c, 0x7a, 0xbe, 0xe3, 0x1a, 0xa7, 0x58, 0x27, 0xc7, 0x84,
0x6e, 0x30, 0x69, 0x3c, 0x4e, 0xcc, 0x77, 0xe9, 0xd9, 0xb1, 0xe7, 0x98, 0x98, 0x4f, 0xa3, 0x21,
0xce, 0x2e, 0xf5, 0xa9, 0xdf, 0xe6, 0x60, 0x89, 0x7b, 0xe5, 0xa7, 0xae, 0x15, 0xe8, 0x7f, 0x7f,
0x60, 0x12, 0x0d, 0x4a, 0x36, 0x54, 0x17, 0x16, 0x43, 0x40, 0x21, 0x8e, 0xcf, 0xb7, 0x4d, 0xbf,
0x51, 0x1b, 0xca, 0xdc, 0xed, 0xb9, 0xc7, 0x8b, 0x26, 0x7a, 0x1b, 0x20, 0x74, 0xef, 0xcb, 0xf8,
0xb5, 0xc4, 0x8e, 0xde, 0x86, 0xce, 0xd0, 0x38, 0x17, 0x6e, 0x8c, 0xcd, 0x68, 0x6c, 0x29, 0xd2,
0x99, 0x6e, 0x0e, 0x8d, 0xf3, 0x07, 0x82, 0x41, 0x0e, 0x30, 0x3d, 0x00, 0x7c, 0x3e, 0xb2, 0x5c,
0x83, 0x1a, 0x55, 0x69, 0x8a, 0xe8, 0x29, 0x8d, 0x53, 0xff, 0xa2, 0xc0, 0xcd, 0x28, 0x40, 0x4c,
0x81, 0x04, 0xa1, 0x1d, 0x68, 0x19, 0x42, 0x85, 0x3a, 0x55, 0x8a, 0x30, 0xc6, 0x95, 0xd0, 0x18,
0x53, 0x94, 0xac, 0x35, 0x83, 0x61, 0xb4, 0xed, 0xa1, 0x37, 0x61, 0xce, 0x75, 0x1c, 0x5f, 0x1f,
0x59, 0xf8, 0x18, 0x07, 0x36, 0xb5, 0xd5, 0x24, 0x4b, 0xfa, 0xeb, 0x77, 0xab, 0xe5, 0x03, 0xd2,
0xdf, 0xef, 0x69, 0x35, 0xc2, 0xc5, 0x1a, 0x26, 0x8d, 0xd6, 0xae, 0xf5, 0xa5, 0xe1, 0x63, 0xfd,
0x31, 0x7e, 0x42, 0x81, 0xaf, 0x6f, 0xdd, 0xe4, 0x43, 0x9a, 0x94, 0xeb, 0x80, 0xd1, 0x3f, 0xc0,
0x4f, 0x34, 0x18, 0x05, 0xdf, 0xea, 0x1f, 0xc2, 0x4d, 0x6d, 0x3b, 0x43, 0xb2, 0xa2, 0x59, 0xab,
0xfd, 0x35, 0x28, 0x73, 0x1d, 0x73, 0x9d, 0x23, 0x49, 0xe7, 0x07, 0xec, 0x4b, 0x13, 0x2c, 0xe8,
0x6d, 0x68, 0x3a, 0xae, 0x75, 0x6a, 0xd9, 0xc6, 0x40, 0xe0, 0x58, 0xa4, 0x38, 0xa6, 0x99, 0x7f,
0x43, 0xb0, 0x32, 0xec, 0xd4, 0x1d, 0x68, 0xc7, 0xf6, 0x12, 0x6a, 0x48, 0x5a, 0x86, 0x32, 0x71,
0x19, 0xaa, 0x01, 0xb7, 0xb8, 0xa4, 0x9e, 0xf3, 0x63, 0x7b, 0xe0, 0x18, 0xe6, 0xac, 0x71, 0x51,
0xff, 0xac, 0x40, 0x27, 0x31, 0xc7, 0x75, 0x58, 0x94, 0xb4, 0xf3, 0xdc, 0x64, 0x05, 0x3c, 0xbd,
0x29, 0xfd, 0x00, 0x6e, 0xf0, 0xfd, 0xf4, 0xed, 0x13, 0x67, 0xe6, 0x78, 0xbd, 0x17, 0x84, 0x27,
0x26, 0x3e, 0x55, 0xb5, 0x93, 0x37, 0xa8, 0xea, 0x81, 0xc1, 0x47, 0xce, 0xb9, 0xd9, 0x2d, 0xf4,
0x5b, 0x25, 0x30, 0xc3, 0xe8, 0xf1, 0x38, 0x5b, 0xb5, 0xc6, 0x14, 0x95, 0xbb, 0xbc, 0xa2, 0xfe,
0xa6, 0xc0, 0x12, 0x39, 0x12, 0xf9, 0x22, 0xbd, 0x4b, 0x20, 0xb0, 0x04, 0xa5, 0x91, 0x8b, 0x4f,
0xac, 0x73, 0x8e, 0x01, 0x6f, 0xa1, 0x55, 0xa8, 0x79, 0xbe, 0xe1, 0xfa, 0xba, 0x71, 0x42, 0xe0,
0xa7, 0xd6, 0xa2, 0x01, 0xed, 0xda, 0x24, 0x3d, 0x24, 0x39, 0xc2, 0xb6, 0xa9, 0x1f, 0xe1, 0x13,
0x72, 0xe0, 0x16, 0x58, 0x72, 0x84, 0x6d, 0x73, 0x8b, 0x76, 0x90, 0xd3, 0xde, 0xc5, 0x24, 0x1f,
0xb0, 0xbe, 0x64, 0x51, 0xbc, 0xa2, 0x85, 0x1d, 0x61, 0x86, 0x50, 0x92, 0x33, 0x84, 0x15, 0x00,
0x82, 0x94, 0x7e, 0x32, 0x30, 0x4e, 0x3d, 0x9a, 0x50, 0x97, 0xb5, 0x2a, 0xe9, 0x79, 0x8f, 0x74,
0xd0, 0x30, 0x1d, 0xdd, 0x5d, 0x88, 0xfe, 0x3b, 0xd1, 0x44, 0xe1, 0x5e, 0x08, 0x79, 0xc6, 0x88,
0xee, 0x84, 0xb4, 0xa1, 0x83, 0xa1, 0x20, 0x92, 0x76, 0x6a, 0x22, 0x8a, 0x64, 0x22, 0xd3, 0x39,
0xde, 0x32, 0x54, 0x2d, 0x4f, 0xe7, 0x28, 0xe7, 0xe9, 0x14, 0x15, 0xcb, 0x3b, 0xa0, 0x6d, 0xf5,
0x73, 0x62, 0x52, 0x29, 0x79, 0x09, 0xd9, 0xd4, 0x2a, 0xd4, 0x98, 0x96, 0x74, 0x29, 0x43, 0x01,
0xd6, 0xb5, 0x47, 0xf2, 0x94, 0x68, 0x82, 0x9a, 0x8b, 0x27, 0xa8, 0xcb, 0x24, 0xd6, 0xa5, 0x65,
0x26, 0xfb, 0x03, 0x53, 0x5d, 0x04, 0x74, 0xe0, 0x3a, 0x3f, 0xc4, 0xc7, 0xb2, 0x53, 0xab, 0x6f,
0xc1, 0x42, 0xa4, 0x97, 0xe7, 0x61, 0x2f, 0x41, 0x7d, 0xc4, 0xba, 0x75, 0xcf, 0x18, 0x08, 0x1b,
0xaa, 0xf1, 0xbe, 0x43, 0x63, 0xe0, 0xab, 0x3f, 0x2b, 0x43, 0x69, 0xff, 0x88, 0x34, 0x33, 0x6d,
0xed, 0x2e, 0x34, 0xc2, 0x63, 0x5e, 0xf2, 0xbb, 0xb9, 0xa0, 0xf7, 0x80, 0x3b, 0xe0, 0x97, 0xd8,
0xf5, 0xc2, 0x34, 0x51, 0x34, 0xd1, 0x7d, 0x28, 0x79, 0xbe, 0xe1, 0x8f, 0x3d, 0x6a, 0x6f, 0xe4,
0xda, 0x12, 0xa8, 0x99, 0x4d, 0xdd, 0x3d, 0xa4, 0x64, 0x8d, 0xb3, 0xa1, 0xd7, 0xa1, 0xea, 0xf9,
0x2e, 0x36, 0x86, 0x04, 0x9f, 0x22, 0x75, 0xa4, 0x16, 0x77, 0xa4, 0xca, 0x21, 0x25, 0xf4, 0x7b,
0x5a, 0x85, 0xb1, 0xf4, 0xcd, 0xd8, 0x65, 0xac, 0xf4, 0x74, 0xf7, 0xe0, 0x4d, 0x32, 0x27, 0x99,
0x9d, 0xc8, 0x28, 0x4f, 0x21, 0xa3, 0xc2, 0x86, 0x6d, 0x92, 0xb4, 0x8f, 0xa5, 0x27, 0x98, 0xca,
0xa8, 0x4c, 0xb3, 0x0e, 0x3e, 0x6e, 0xd3, 0x47, 0x0f, 0xa1, 0x1d, 0xa2, 0x4d, 0x70, 0x32, 0x0d,
0xdf, 0xd0, 0x6d, 0xc7, 0x3e, 0xc6, 0xed, 0x2a, 0x85, 0x62, 0x8e, 0x43, 0x51, 0xdc, 0x23, 0x9d,
0xda, 0x52, 0xc0, 0xbe, 0xcb, 0xb9, 0x69, 0x3f, 0x7a, 0x1d, 0x50, 0x52, 0x50, 0x1b, 0xa8, 0xea,
0xe6, 0x13, 0x63, 0xd0, 0x6b, 0x80, 0x4e, 0xac, 0xf3, 0x78, 0x22, 0x57, 0xa3, 0xa1, 0xb4, 0x45,
0x29, 0x72, 0x06, 0xb7, 0x03, 0xf3, 0xc9, 0xab, 0x61, 0x7d, 0x72, 0x0a, 0xd9, 0x72, 0xe3, 0x77,
0xc2, 0x8f, 0xe1, 0x46, 0xfa, 0x5d, 0x70, 0xee, 0x92, 0x77, 0xc1, 0x45, 0x9c, 0x71, 0x09, 0xf4,
0x1d, 0xdf, 0x18, 0xb0, 0x6d, 0x34, 0xe8, 0x36, 0xaa, 0xb4, 0x87, 0xae, 0x7f, 0x15, 0x6a, 0x96,
0x3d, 0xb0, 0x6c, 0xcc, 0xe8, 0x4d, 0x4a, 0x07, 0xd6, 0x25, 0x18, 0x5c, 0x3c, 0x74, 0x7c, 0xce,
0xd0, 0x62, 0x0c, 0xac, 0x8b, 0x30, 0xa8, 0x1f, 0x42, 0x89, 0x59, 0x2d, 0xaa, 0x41, 0xb9, 0xbf,
0xf7, 0xc9, 0xe6, 0xa3, 0x7e, 0xaf, 0xf5, 0x02, 0x9a, 0x83, 0xea, 0xc7, 0x07, 0x8f, 0xf6, 0x37,
0x7b, 0xfd, 0xbd, 0x87, 0x2d, 0x05, 0x35, 0x00, 0xb6, 0xf7, 0x77, 0x77, 0xfb, 0x1f, 0x7d, 0x44,
0xda, 0x39, 0x42, 0xe6, 0xed, 0x07, 0xbd, 0x56, 0x1e, 0xd5, 0xa1, 0xd2, 0x7b, 0xf0, 0xe8, 0x01,
0x25, 0x16, 0xd4, 0x3f, 0xe6, 0x01, 0x31, 0x87, 0xd8, 0xc2, 0xa7, 0x96, 0x2d, 0xdd, 0xd7, 0xae,
0xc7, 0x2f, 0xa3, 0xf6, 0x5a, 0x98, 0xbd, 0xbd, 0x16, 0xaf, 0x6e, 0xaf, 0xa5, 0x2c, 0x7b, 0x4d,
0xb5, 0xc0, 0xf2, 0x4c, 0x2d, 0xb0, 0x72, 0x15, 0x0b, 0x54, 0x7f, 0x9b, 0x83, 0x85, 0x88, 0x36,
0x79, 0x50, 0xbe, 0x36, 0x75, 0x46, 0xa2, 0x66, 0x61, 0x62, 0xd4, 0x4c, 0x05, 0xb0, 0x38, 0x53,
0x00, 0x4b, 0x57, 0x02, 0xb0, 0x27, 0xf0, 0x8b, 0x5c, 0x84, 0xa2, 0xdb, 0x54, 0x26, 0x6d, 0x53,
0x5d, 0x82, 0xc5, 0xa8, 0x14, 0x7e, 0xcb, 0x7f, 0x0c, 0x2d, 0xd6, 0x2f, 0x15, 0x71, 0xae, 0x4b,
0x35, 0xea, 0xbb, 0x30, 0x2f, 0x4d, 0x16, 0x56, 0x82, 0x1c, 0xda, 0x99, 0xac, 0x04, 0x31, 0x66,
0x8d, 0xd3, 0xd5, 0x7f, 0x2a, 0x62, 0x7c, 0xac, 0x8e, 0x93, 0xba, 0xda, 0x57, 0xa1, 0x25, 0xad,
0x56, 0xce, 0x12, 0x9b, 0xe1, 0x7a, 0x59, 0xba, 0x18, 0x61, 0xe5, 0x45, 0xa1, 0x7c, 0x8c, 0x75,
0x3b, 0x56, 0x1d, 0x2a, 0xc8, 0xb9, 0x5f, 0x1f, 0x9a, 0x6c, 0x8d, 0xba, 0x65, 0x1f, 0x0f, 0xc6,
0x26, 0x0e, 0x6b, 0x78, 0xb1, 0xcd, 0x88, 0x9a, 0x4f, 0x9f, 0xf3, 0x69, 0x0d, 0x36, 0x50, 0xb4,
0xd5, 0xcf, 0x44, 0xf0, 0xbb, 0x64, 0x29, 0x29, 0x2a, 0xf6, 0xa2, 0x52, 0xd2, 0xef, 0xf2, 0xd0,
0x88, 0x72, 0xa7, 0x68, 0x54, 0x99, 0xa0, 0xd1, 0x5c, 0x56, 0x4e, 0x93, 0xbf, 0x5c, 0x4e, 0x13,
0x4d, 0x52, 0x0a, 0x33, 0x48, 0x52, 0x8a, 0x33, 0x48, 0x52, 0x4a, 0xb3, 0x0f, 0xfa, 0xe5, 0xab,
0x07, 0xfd, 0x4a, 0x46, 0xd0, 0x57, 0xff, 0x0f, 0x96, 0xd2, 0xad, 0x09, 0x75, 0xa0, 0x12, 0x0c,
0x57, 0x58, 0xb2, 0x2e, 0xda, 0xaa, 0x07, 0x6d, 0x29, 0x10, 0x47, 0xab, 0xa9, 0xd7, 0xe6, 0xf2,
0xef, 0xc3, 0xad, 0x94, 0x49, 0xb9, 0x55, 0x4f, 0x19, 0xc3, 0x02, 0x59, 0xef, 0x59, 0xb6, 0xe5,
0x9d, 0x45, 0x77, 0x30, 0xa5, 0xac, 0xdb, 0xd0, 0x49, 0x93, 0xc5, 0xa3, 0xe2, 0xbf, 0xf2, 0x50,
0x3b, 0x34, 0x7c, 0x31, 0xee, 0xfa, 0x0e, 0xab, 0x2b, 0x15, 0x1f, 0xfb, 0x30, 0x47, 0x7d, 0x82,
0x1c, 0x37, 0xa6, 0xe1, 0xe3, 0xa9, 0x5c, 0xa1, 0x2e, 0x86, 0xf6, 0x0c, 0x1f, 0xa3, 0x5d, 0x68,
0x86, 0x25, 0x45, 0x26, 0x6c, 0x1a, 0x9f, 0x68, 0x84, 0x83, 0xa9, 0xb8, 0xe7, 0xe4, 0x18, 0xe8,
0x3e, 0x2c, 0x78, 0x86, 0x8f, 0x07, 0x03, 0x8b, 0x66, 0xac, 0xa7, 0xb6, 0xe1, 0x8f, 0x5d, 0x7e,
0x61, 0xd0, 0x50, 0x40, 0x3a, 0x14, 0x14, 0xf5, 0x1f, 0x39, 0x28, 0xf3, 0x84, 0x7e, 0x4a, 0x0b,
0x42, 0xff, 0x0f, 0x95, 0x91, 0xe3, 0x59, 0xbe, 0x88, 0x8a, 0xb5, 0x8d, 0x5b, 0x61, 0xf0, 0xe3,
0x32, 0x0f, 0x38, 0x83, 0x16, 0xb0, 0xa2, 0x77, 0x61, 0x21, 0xdc, 0xd1, 0x63, 0xfc, 0x84, 0xa3,
0x92, 0x4f, 0x43, 0x25, 0xdc, 0xe1, 0x07, 0xf8, 0x09, 0x03, 0xe4, 0x0e, 0xcc, 0x45, 0x86, 0xf3,
0xda, 0x45, 0x5d, 0xe6, 0x44, 0x5d, 0x58, 0x20, 0xe9, 0xba, 0x54, 0x96, 0xa6, 0xb0, 0xb1, 0x72,
0xf4, 0x3c, 0x21, 0x05, 0xf5, 0xe8, 0x1e, 0x81, 0x6d, 0x23, 0xc8, 0x5c, 0xb0, 0xa9, 0xf3, 0x0b,
0x81, 0x94, 0x76, 0x86, 0x0b, 0xee, 0x53, 0x1a, 0x1d, 0xf3, 0x0a, 0x94, 0x68, 0x2d, 0xd8, 0x6b,
0x97, 0xe9, 0x91, 0xd4, 0x0c, 0x37, 0x4f, 0x8b, 0x3c, 0x1a, 0x27, 0xab, 0x3b, 0x50, 0xa4, 0x1d,
0x68, 0x19, 0xaa, 0xac, 0x7a, 0x6c, 0x8f, 0x87, 0x14, 0xdf, 0xa2, 0x56, 0xa1, 0x1d, 0x7b, 0xe3,
0x21, 0x52, 0xa1, 0x60, 0x3b, 0x26, 0xe6, 0xf5, 0xa2, 0x06, 0xc7, 0xa1, 0xb4, 0xe7, 0x98, 0xb8,
0xdf, 0xd3, 0x28, 0x4d, 0xdd, 0x81, 0x66, 0x0c, 0x57, 0x72, 0x3f, 0x19, 0x19, 0xae, 0x4f, 0x44,
0x1e, 0xf1, 0x12, 0x6a, 0x51, 0xa3, 0x65, 0x85, 0x3d, 0xda, 0x43, 0xce, 0x6b, 0xcb, 0x36, 0xf1,
0xb9, 0xf8, 0x9b, 0x43, 0x1b, 0xea, 0x2f, 0x15, 0x58, 0xe0, 0xa2, 0x22, 0x77, 0x8c, 0x67, 0x63,
0x02, 0xf7, 0xa0, 0x39, 0x34, 0xce, 0x75, 0x5a, 0x38, 0x66, 0xc5, 0x36, 0x5e, 0xab, 0x9b, 0x1b,
0x1a, 0xe7, 0x61, 0x6d, 0x4d, 0xfd, 0x93, 0x02, 0x8b, 0xd1, 0x55, 0xf2, 0xb8, 0xf9, 0x06, 0x80,
0xb8, 0x9e, 0x06, 0xeb, 0x9c, 0xe7, 0xeb, 0xac, 0x8a, 0x6a, 0x64, 0x4f, 0xab, 0x72, 0xa6, 0x7e,
0x7a, 0x7d, 0x2f, 0x37, 0x8b, 0xfa, 0xde, 0x14, 0x85, 0xd8, 0x5f, 0xe5, 0x82, 0xed, 0x44, 0x53,
0xd9, 0xe9, 0xb7, 0x93, 0xe1, 0x44, 0xb9, 0xa7, 0x75, 0xa2, 0xfc, 0xe5, 0x9d, 0xa8, 0x90, 0xe5,
0x44, 0x0f, 0x61, 0x6e, 0x3c, 0x1a, 0x38, 0x86, 0xa9, 0xbb, 0xd8, 0x1b, 0x0f, 0x7c, 0xfe, 0x83,
0x40, 0x4d, 0x5a, 0x04, 0xc1, 0xe8, 0xe3, 0x11, 0xaf, 0xac, 0x8f, 0x07, 0xbe, 0x56, 0x1f, 0x4b,
0x2d, 0xf5, 0xa7, 0x61, 0xa1, 0x36, 0xc1, 0x7a, 0xb1, 0x13, 0xbd, 0x02, 0x65, 0xfa, 0xa3, 0x2d,
0xf8, 0x3d, 0x13, 0xf7, 0xa3, 0x12, 0x21, 0xf7, 0x4d, 0x74, 0x17, 0x0a, 0x67, 0x86, 0x77, 0xc6,
0x1f, 0x4b, 0xcc, 0x8b, 0x7f, 0x18, 0x74, 0xba, 0x1d, 0xc3, 0x3b, 0xd3, 0x28, 0x59, 0xfd, 0x6f,
0x0e, 0xea, 0xe4, 0x18, 0x14, 0x2a, 0x40, 0x1b, 0x71, 0xff, 0xa8, 0x6d, 0xdc, 0x90, 0xf6, 0x17,
0x9e, 0x98, 0x92, 0x93, 0xc4, 0x5c, 0x34, 0x97, 0xed, 0xa2, 0x79, 0xc9, 0x45, 0x93, 0x3f, 0x9c,
0x8a, 0x97, 0xf8, 0xe1, 0xf4, 0x21, 0xdc, 0x08, 0x7e, 0xd3, 0x48, 0xee, 0x45, 0xae, 0x60, 0x97,
0xb0, 0xf5, 0x05, 0x31, 0x36, 0xec, 0xf3, 0x92, 0x87, 0x6c, 0xf9, 0xa9, 0x0f, 0xd9, 0x8c, 0xd3,
0xa9, 0x92, 0x79, 0x3a, 0xdd, 0x0c, 0x7e, 0x5d, 0xc4, 0x6e, 0x6d, 0xdf, 0xe4, 0x02, 0x13, 0xd9,
0x35, 0x1e, 0x63, 0x16, 0x96, 0x9f, 0x6d, 0x10, 0x7b, 0x16, 0xe7, 0x58, 0xe6, 0xb9, 0x54, 0xcc,
0x3c, 0x97, 0x58, 0xd9, 0x38, 0x81, 0x0c, 0xc7, 0xcd, 0x09, 0x88, 0x29, 0x39, 0xf0, 0x72, 0x02,
0xb7, 0x2b, 0xa3, 0xa4, 0x7e, 0x13, 0xfe, 0x4d, 0x4b, 0x4b, 0x80, 0x9f, 0x63, 0x20, 0x57, 0x7f,
0x1e, 0x2e, 0x2d, 0x2d, 0x9f, 0x9e, 0x7e, 0x69, 0xef, 0x40, 0x99, 0x45, 0x3e, 0xb1, 0xa2, 0x8c,
0xd0, 0x17, 0x60, 0x40, 0x42, 0x9f, 0x18, 0x92, 0x88, 0x7a, 0x32, 0xd7, 0xb3, 0x8d, 0x7a, 0x2b,
0xb0, 0x9c, 0x8a, 0x0b, 0xb7, 0xa1, 0xaf, 0x15, 0x40, 0x9c, 0x2e, 0x97, 0x21, 0x2e, 0xb4, 0x9e,
0x2d, 0x68, 0xb2, 0xb2, 0x82, 0x7e, 0x79, 0x23, 0x6a, 0xb0, 0x11, 0x41, 0xaa, 0x13, 0x54, 0x1e,
0xf2, 0x52, 0xe5, 0x41, 0xfd, 0x3c, 0x48, 0x64, 0x22, 0xf5, 0x82, 0xfb, 0xd1, 0x7a, 0x41, 0x72,
0x9a, 0xcb, 0x14, 0x0c, 0xc2, 0x7c, 0x2b, 0x28, 0x18, 0xc8, 0x6e, 0xa0, 0x5c, 0xde, 0x0d, 0xbe,
0x56, 0x82, 0xbf, 0xa4, 0xb1, 0x1f, 0xd7, 0xd3, 0x46, 0xab, 0x19, 0x20, 0xa9, 0xfe, 0x27, 0x7c,
0x5c, 0x10, 0xff, 0xc5, 0xfd, 0x5c, 0x53, 0xab, 0xcc, 0x70, 0x97, 0xcf, 0x4e, 0xc3, 0x5f, 0x87,
0x82, 0x8d, 0xcf, 0x45, 0x25, 0xe5, 0x02, 0x10, 0x28, 0xdb, 0xc6, 0x6f, 0xe6, 0xa1, 0xb2, 0xcb,
0x59, 0xd0, 0x2e, 0xd4, 0xd9, 0xe3, 0x2f, 0xfe, 0x2c, 0x73, 0x25, 0xfe, 0x40, 0x29, 0xf2, 0x1e,
0xaf, 0xf3, 0x62, 0x16, 0x99, 0x43, 0xd7, 0x83, 0xea, 0x43, 0xec, 0x73, 0x59, 0x9d, 0x38, 0x73,
0x58, 0x5f, 0xec, 0x2c, 0xa7, 0xd2, 0xb8, 0x94, 0x5d, 0xa8, 0x33, 0x87, 0xcb, 0x5a, 0x54, 0x24,
0x4c, 0x25, 0x17, 0x15, 0x8b, 0xb0, 0x3b, 0x50, 0x23, 0xc6, 0xcb, 0x68, 0x1e, 0x5a, 0x4e, 0x7b,
0x83, 0x25, 0x64, 0xdd, 0x4e, 0x27, 0x72, 0x49, 0x98, 0x64, 0xaf, 0x5c, 0x90, 0xf4, 0x57, 0x12,
0xdd, 0x8d, 0x8f, 0x4a, 0xfd, 0x23, 0xda, 0xb9, 0x37, 0x89, 0x8d, 0x4f, 0xf3, 0x3e, 0xd4, 0xe8,
0x49, 0xc1, 0xff, 0x46, 0xde, 0x8e, 0x17, 0xd4, 0xe4, 0xfb, 0x4a, 0x67, 0x25, 0x83, 0x1a, 0x62,
0xc9, 0x12, 0x07, 0x2e, 0x2c, 0xc1, 0x1e, 0xc9, 0xc3, 0x65, 0x2c, 0xd3, 0x6a, 0xc5, 0x5c, 0xc1,
0x5c, 0x56, 0x27, 0xce, 0x9c, 0xae, 0xe0, 0x64, 0xbd, 0x97, 0x6b, 0x84, 0x11, 0x22, 0x1a, 0x49,
0xd4, 0x76, 0x3b, 0xb7, 0xd3, 0x89, 0x5c, 0xd2, 0x17, 0x30, 0x2f, 0x1d, 0xaa, 0x7c, 0x5d, 0x6a,
0x2a, 0x24, 0x51, 0xa3, 0xb9, 0x73, 0x21, 0x0f, 0x97, 0xae, 0x03, 0x92, 0xe3, 0x3f, 0x17, 0x9f,
0x18, 0x9a, 0x72, 0x76, 0x76, 0x5e, 0xbe, 0x98, 0x29, 0xd4, 0x0e, 0x9d, 0x57, 0xd4, 0x1f, 0x56,
0x12, 0xce, 0x1b, 0xd1, 0xf5, 0x8b, 0x59, 0x64, 0x2e, 0xee, 0x00, 0xe6, 0x98, 0xbe, 0x84, 0xbc,
0xe4, 0x80, 0xa8, 0xba, 0x57, 0x33, 0xe9, 0x21, 0xbe, 0x61, 0x0e, 0x25, 0xa4, 0x26, 0x0f, 0xf5,
0x44, 0x06, 0x2a, 0xe3, 0x9b, 0x99, 0x8b, 0x11, 0x7c, 0x25, 0xd8, 0x85, 0xf8, 0x3b, 0xe9, 0xbb,
0xcc, 0xc4, 0xf7, 0x82, 0xe4, 0xea, 0x08, 0x16, 0x64, 0xdc, 0xc5, 0x0c, 0xc9, 0xc1, 0x69, 0x2a,
0xbc, 0x3b, 0x81, 0x8b, 0xcf, 0xf1, 0x01, 0xd4, 0xe5, 0x27, 0x1a, 0xb2, 0xbb, 0x26, 0x73, 0x84,
0xce, 0x4a, 0x06, 0x95, 0x0b, 0xfb, 0x04, 0x9a, 0xe2, 0x3c, 0x12, 0x8b, 0x5d, 0x4b, 0x8c, 0x88,
0x9d, 0x9f, 0x9d, 0x97, 0x2e, 0xe0, 0xe0, 0x72, 0x3f, 0x85, 0x16, 0x0b, 0xd5, 0x9c, 0x61, 0x7f,
0x60, 0xa6, 0x08, 0x8e, 0xbd, 0xae, 0x4c, 0x11, 0x9c, 0x78, 0x5e, 0xf8, 0x7d, 0x68, 0x45, 0x4c,
0x8e, 0xf4, 0xbd, 0x74, 0xb1, 0xd5, 0x11, 0xc9, 0xea, 0x04, 0xc3, 0x23, 0x62, 0x0e, 0xa1, 0x21,
0x3d, 0xab, 0xa2, 0xef, 0x49, 0x12, 0xa3, 0xa2, 0xef, 0xb9, 0x3a, 0x6b, 0x19, 0x0c, 0xa1, 0x50,
0x1d, 0x50, 0x0c, 0x60, 0xd2, 0x7b, 0x67, 0x12, 0xc6, 0x44, 0xf8, 0xcb, 0x13, 0x61, 0xe6, 0x80,
0x44, 0x8c, 0x2d, 0x1d, 0x90, 0xf8, 0x03, 0xaf, 0x14, 0x40, 0x92, 0x2f, 0xb4, 0x3e, 0x81, 0xa6,
0x6c, 0x69, 0x31, 0x1d, 0xa6, 0xbf, 0x9b, 0x92, 0x75, 0x98, 0xf5, 0xf6, 0xe8, 0x0b, 0x98, 0x8f,
0x9e, 0x44, 0xa4, 0x33, 0xb2, 0xa0, 0xf4, 0xf7, 0x3d, 0x51, 0x27, 0xcf, 0x78, 0xa7, 0x43, 0x4e,
0x33, 0xe9, 0x45, 0x8e, 0xec, 0x1e, 0xc9, 0xe7, 0x3b, 0xb2, 0x7b, 0xa4, 0x3c, 0xe3, 0xd9, 0x2a,
0x7c, 0x9e, 0x1b, 0x1d, 0x1d, 0x95, 0xe8, 0x85, 0xfb, 0xcd, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff,
0x91, 0xea, 0xb2, 0xa0, 0xd3, 0x32, 0x00, 0x00,
// 3008 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x1a, 0x4b, 0x6f, 0x24, 0x47,
0x39, 0xf3, 0x1e, 0x7f, 0x33, 0x9e, 0x19, 0x97, 0xbd, 0xde, 0xd9, 0xf1, 0x3a, 0xf6, 0xf6, 0x66,
0x37, 0x8e, 0x94, 0xcc, 0x46, 0x0e, 0x48, 0x91, 0x92, 0x48, 0xd8, 0x9e, 0xcd, 0x7a, 0x92, 0xf5,
0x23, 0xed, 0xbc, 0x88, 0x82, 0x5a, 0x6d, 0x77, 0xd9, 0x6e, 0x76, 0xa6, 0x7b, 0xe8, 0xee, 0x59,
0xbc, 0x39, 0x71, 0x40, 0x42, 0x28, 0x1c, 0x38, 0x72, 0xca, 0x05, 0x71, 0xe2, 0x17, 0x44, 0x42,
0x5c, 0x41, 0x08, 0x71, 0x08, 0x37, 0x90, 0x02, 0xbf, 0x80, 0x0b, 0x67, 0x24, 0x54, 0xaf, 0xee,
0xea, 0xd7, 0x3c, 0xec, 0xf1, 0x4a, 0xb9, 0x75, 0x7f, 0xdf, 0x57, 0x5f, 0x55, 0x7d, 0xef, 0xfa,
0xaa, 0xa0, 0xd6, 0xc7, 0x9e, 0x6e, 0x5a, 0xa7, 0x76, 0x7b, 0xe0, 0xd8, 0x9e, 0x8d, 0xca, 0xe2,
0xbf, 0xd5, 0xc0, 0xd6, 0x89, 0xf3, 0x6c, 0xe0, 0x99, 0xb6, 0xc5, 0x70, 0x2d, 0x38, 0xb3, 0xcf,
0x38, 0x5d, 0x6b, 0xed, 0xcc, 0xb6, 0xcf, 0x7a, 0xf8, 0x01, 0xfd, 0x3b, 0x1e, 0x9e, 0x3e, 0xf0,
0xcc, 0x3e, 0x76, 0x3d, 0xbd, 0x3f, 0x10, 0xc4, 0x96, 0x6d, 0x60, 0xfe, 0x5d, 0x1f, 0xd8, 0xa6,
0xe5, 0x61, 0xc7, 0x38, 0xe6, 0x80, 0xaa, 0xed, 0x18, 0xd8, 0x71, 0xd9, 0x9f, 0xf2, 0xfb, 0x1c,
0x14, 0xb7, 0x87, 0x27, 0x4f, 0xb0, 0x87, 0x10, 0xe4, 0x2d, 0xbd, 0x8f, 0x9b, 0x99, 0xf5, 0xcc,
0x46, 0x55, 0xa5, 0xdf, 0xe8, 0x4d, 0xa8, 0x0c, 0x74, 0xef, 0x5c, 0x3b, 0x31, 0x07, 0xe7, 0xd8,
0x69, 0x66, 0xd7, 0x33, 0x1b, 0xb5, 0xcd, 0x9b, 0x6d, 0x69, 0x79, 0x3b, 0x14, 0x73, 0x34, 0x34,
0x3d, 0xac, 0x02, 0xa1, 0x65, 0x00, 0xb4, 0x03, 0x70, 0xe2, 0x60, 0xdd, 0xc3, 0x86, 0xa6, 0x7b,
0xcd, 0xdc, 0x7a, 0x66, 0xa3, 0xb2, 0xd9, 0x6a, 0xb3, 0x95, 0xb7, 0xc5, 0xca, 0xdb, 0x1f, 0x8a,
0x95, 0x6f, 0x97, 0xff, 0xfc, 0xed, 0xda, 0x0b, 0xbf, 0xfe, 0xd7, 0x5a, 0x46, 0x9d, 0xe3, 0xe3,
0xb6, 0x3c, 0xf4, 0x3a, 0x2c, 0x19, 0xf8, 0x54, 0x1f, 0xf6, 0x3c, 0xcd, 0xc5, 0x67, 0x7d, 0x6c,
0x79, 0x9a, 0x6b, 0x7e, 0x81, 0x9b, 0xf9, 0xf5, 0xcc, 0x46, 0x4e, 0x45, 0x1c, 0x77, 0xc4, 0x50,
0x47, 0xe6, 0x17, 0x18, 0x7d, 0x02, 0xb7, 0xc4, 0x08, 0x07, 0x1b, 0x43, 0xcb, 0xd0, 0xad, 0x93,
0x67, 0x9a, 0x7b, 0x72, 0x8e, 0xfb, 0xb8, 0x59, 0xa0, 0xab, 0x58, 0x69, 0x07, 0x22, 0x51, 0x7d,
0x9a, 0x23, 0x4a, 0xa2, 0xde, 0xe4, 0xa3, 0xa3, 0x08, 0x64, 0xc0, 0xaa, 0x60, 0x1c, 0xec, 0x5e,
0x1b, 0xe8, 0x8e, 0xde, 0xc7, 0x1e, 0x76, 0xdc, 0x66, 0x91, 0x32, 0x5f, 0x97, 0x65, 0xf3, 0xd0,
0xff, 0x3c, 0xf4, 0xe9, 0xd4, 0x15, 0xce, 0x26, 0x09, 0x89, 0x56, 0x01, 0x06, 0xba, 0xe3, 0x59,
0xd8, 0xd1, 0x4c, 0xa3, 0x59, 0xa2, 0x9a, 0x98, 0xe3, 0x90, 0xae, 0xa1, 0x98, 0x50, 0x63, 0xca,
0x7a, 0x6c, 0xba, 0x5e, 0xd7, 0xc3, 0xfd, 0x44, 0xa5, 0x85, 0x45, 0x9f, 0xbd, 0x94, 0xe8, 0x95,
0xff, 0x66, 0x61, 0x91, 0xcd, 0xb5, 0x43, 0x61, 0x2a, 0xfe, 0xc9, 0x10, 0xbb, 0xb3, 0xb6, 0x92,
0x34, 0x05, 0xe7, 0x2e, 0xa7, 0xe0, 0xfc, 0x75, 0x2a, 0xb8, 0x30, 0x7b, 0x05, 0x17, 0xa3, 0x0a,
0xfe, 0x01, 0x2c, 0x85, 0x85, 0xee, 0x0e, 0x6c, 0xcb, 0xc5, 0x68, 0x03, 0x8a, 0xc7, 0x14, 0x4e,
0xe5, 0x5e, 0xd9, 0x6c, 0xb4, 0xfd, 0xd8, 0xc1, 0xe8, 0x55, 0x8e, 0x57, 0xee, 0x43, 0x83, 0x41,
0x1e, 0x61, 0x6f, 0x84, 0xce, 0x94, 0x77, 0x60, 0x41, 0xa2, 0x9b, 0x7a, 0x9a, 0x57, 0x84, 0x75,
0x74, 0x70, 0x0f, 0x8f, 0xb4, 0x0e, 0x65, 0x59, 0xec, 0x49, 0x90, 0xb2, 0xc9, 0x14, 0x4d, 0xac,
0x80, 0x18, 0xb3, 0x60, 0xb0, 0x0c, 0xc5, 0x93, 0xa1, 0xe3, 0xda, 0x0e, 0x67, 0xc1, 0xff, 0xd0,
0x12, 0x14, 0x7a, 0x66, 0xdf, 0x64, 0xe6, 0x5c, 0x50, 0xd9, 0x0f, 0xba, 0x0d, 0x73, 0x86, 0xe9,
0xe0, 0x13, 0x22, 0x64, 0x6a, 0x33, 0x05, 0x35, 0x00, 0x28, 0x9f, 0x02, 0x92, 0x27, 0xe0, 0x7b,
0x6c, 0x43, 0xc1, 0xf4, 0x70, 0xdf, 0x6d, 0x66, 0xd6, 0x73, 0x1b, 0x95, 0xcd, 0x66, 0x74, 0x8b,
0xc2, 0xb5, 0x54, 0x46, 0x46, 0xb6, 0xd4, 0xb7, 0x1d, 0x4c, 0x27, 0x2e, 0xab, 0xf4, 0x5b, 0xf9,
0x14, 0x56, 0x18, 0xf1, 0x11, 0xf6, 0xb6, 0x3c, 0xcf, 0x31, 0x8f, 0x87, 0x64, 0xc6, 0x51, 0x3e,
0x72, 0x0f, 0x6a, 0x7a, 0x40, 0x49, 0x94, 0x9f, 0xa5, 0xd8, 0x79, 0x09, 0xda, 0x35, 0x94, 0x17,
0xe1, 0x76, 0x32, 0x67, 0x2e, 0xb4, 0x9f, 0x67, 0x60, 0x71, 0xcb, 0x30, 0x1c, 0xec, 0xba, 0xd8,
0x38, 0x20, 0x91, 0xfc, 0x31, 0x95, 0xc4, 0x86, 0x90, 0x0f, 0x53, 0x1c, 0x6a, 0xf3, 0x28, 0x1f,
0x90, 0x08, 0x99, 0xed, 0xc0, 0x92, 0xeb, 0xd9, 0x8e, 0x7e, 0x86, 0x35, 0x92, 0x26, 0x34, 0x9d,
0x71, 0xe3, 0x71, 0x62, 0xa1, 0x4d, 0x73, 0xc7, 0xbe, 0x6d, 0x60, 0x3e, 0x8d, 0x8a, 0x38, 0xb9,
0x04, 0x53, 0xbe, 0xca, 0xc2, 0x32, 0xf7, 0xca, 0x4f, 0x1c, 0xd3, 0xd7, 0xff, 0x41, 0xcf, 0x20,
0x1a, 0x94, 0x6c, 0xa8, 0x2a, 0x2c, 0x86, 0x08, 0x85, 0x38, 0x3e, 0xdf, 0x36, 0xfd, 0x46, 0x4d,
0x28, 0x71, 0xb7, 0xe7, 0x1e, 0x2f, 0x7e, 0xd1, 0x5b, 0x00, 0x81, 0x7b, 0x4f, 0xe2, 0xd7, 0x12,
0x39, 0x7a, 0x0b, 0x5a, 0x7d, 0xfd, 0x42, 0xb8, 0x31, 0x36, 0xc2, 0xb1, 0xa5, 0x40, 0x67, 0xba,
0xd9, 0xd7, 0x2f, 0x1e, 0x0a, 0x02, 0x39, 0xc0, 0x74, 0x00, 0xf0, 0xc5, 0xc0, 0x74, 0x74, 0x6a,
0x54, 0xc5, 0x29, 0xa2, 0xa7, 0x34, 0x4e, 0xf9, 0x26, 0x03, 0x37, 0xc3, 0x02, 0x62, 0x0a, 0x24,
0x12, 0xda, 0x85, 0x86, 0x2e, 0x54, 0xa8, 0x51, 0xa5, 0x08, 0x63, 0x5c, 0x0d, 0x8c, 0x31, 0x41,
0xc9, 0x6a, 0xdd, 0x1f, 0x46, 0xff, 0x5d, 0xf4, 0x06, 0xcc, 0x3b, 0xb6, 0xed, 0x69, 0x03, 0x13,
0x9f, 0x60, 0xdf, 0xa6, 0xb6, 0xeb, 0x64, 0x49, 0xff, 0xf8, 0x76, 0xad, 0x74, 0x48, 0xe0, 0xdd,
0x8e, 0x5a, 0x21, 0x54, 0xec, 0xc7, 0xa0, 0xd1, 0xda, 0x31, 0x9f, 0xea, 0x1e, 0xd6, 0x9e, 0xe0,
0x67, 0x54, 0xf0, 0xd5, 0xed, 0x9b, 0x7c, 0x48, 0x9d, 0x52, 0x1d, 0x32, 0xfc, 0xfb, 0xf8, 0x99,
0x0a, 0x03, 0xff, 0x5b, 0xf9, 0x4b, 0xb0, 0xa9, 0x1d, 0xbb, 0x4f, 0x56, 0x34, 0x6b, 0xb5, 0xbf,
0x0a, 0x25, 0xae, 0x63, 0xae, 0x73, 0x24, 0xe9, 0xfc, 0x90, 0x7d, 0xa9, 0x82, 0x04, 0xbd, 0x05,
0x75, 0xdb, 0x31, 0xcf, 0x4c, 0x4b, 0xef, 0x09, 0x39, 0x16, 0xa8, 0x1c, 0x93, 0xcc, 0xbf, 0x26,
0x48, 0x99, 0xec, 0x94, 0x5d, 0x68, 0x46, 0xf6, 0x12, 0x68, 0x48, 0x5a, 0x46, 0x66, 0xec, 0x32,
0x14, 0x1d, 0x6e, 0x71, 0x4e, 0x1d, 0xfb, 0xa7, 0x56, 0xcf, 0xd6, 0x8d, 0x59, 0xcb, 0x45, 0xf9,
0x5b, 0x06, 0x5a, 0xb1, 0x39, 0xae, 0xc3, 0xa2, 0xa4, 0x9d, 0x67, 0xc7, 0x2b, 0xe0, 0xf2, 0xa6,
0xf4, 0x23, 0xb8, 0xc1, 0xf7, 0xd3, 0xb5, 0x4e, 0xed, 0x99, 0xcb, 0xeb, 0x5d, 0x3f, 0x3c, 0x31,
0xf6, 0x89, 0xaa, 0x1d, 0xbf, 0x41, 0x45, 0xf3, 0x0d, 0x3e, 0x94, 0xe7, 0x66, 0xb7, 0xd0, 0xaf,
0x32, 0xbe, 0x19, 0x86, 0xd3, 0xe3, 0x6c, 0xd5, 0x1a, 0x51, 0x54, 0x76, 0x72, 0x45, 0xfd, 0x33,
0x03, 0xcb, 0x24, 0x25, 0xf2, 0x45, 0xba, 0x13, 0x48, 0x60, 0x19, 0x8a, 0x03, 0x07, 0x9f, 0x9a,
0x17, 0x5c, 0x06, 0xfc, 0x0f, 0xad, 0x41, 0xc5, 0xf5, 0x74, 0xc7, 0xd3, 0xf4, 0x53, 0x22, 0x7e,
0x6a, 0x2d, 0x2a, 0x50, 0xd0, 0x16, 0x81, 0x90, 0xe2, 0x08, 0x5b, 0x86, 0x76, 0x8c, 0x4f, 0x49,
0xc2, 0xcd, 0xb3, 0xe2, 0x08, 0x5b, 0xc6, 0x36, 0x05, 0x90, 0x6c, 0xef, 0x60, 0x52, 0x0f, 0x98,
0x4f, 0x59, 0x14, 0x2f, 0xab, 0x01, 0x20, 0xa8, 0x10, 0x8a, 0x72, 0x85, 0xb0, 0x0a, 0x40, 0x24,
0xa5, 0x9d, 0xf6, 0xf4, 0x33, 0x97, 0x16, 0xd4, 0x25, 0x75, 0x8e, 0x40, 0xde, 0x25, 0x00, 0x1a,
0xa6, 0xc3, 0xbb, 0x0b, 0xa4, 0xff, 0x76, 0xb8, 0x50, 0xb8, 0x1f, 0x88, 0x3c, 0x65, 0x44, 0x7b,
0x4c, 0xd9, 0xd0, 0xc2, 0x90, 0x17, 0x45, 0x3b, 0x35, 0x91, 0x8c, 0x64, 0x22, 0xd3, 0x39, 0xde,
0x0a, 0xcc, 0x99, 0xae, 0xc6, 0xa5, 0x9c, 0xa3, 0x53, 0x94, 0x4d, 0xf7, 0x90, 0xfe, 0x2b, 0x9f,
0x11, 0x93, 0x4a, 0xa8, 0x4b, 0xc8, 0xa6, 0xd6, 0xa0, 0xc2, 0xb4, 0xa4, 0x49, 0x15, 0x0a, 0x30,
0xd0, 0x3e, 0xa9, 0x53, 0xc2, 0x05, 0x6a, 0x36, 0x5a, 0xa0, 0xae, 0x90, 0x58, 0x97, 0x54, 0x99,
0x1c, 0xf4, 0x0c, 0x65, 0x09, 0xd0, 0xa1, 0x63, 0xff, 0x18, 0x9f, 0xc8, 0x4e, 0xad, 0xbc, 0x09,
0x8b, 0x21, 0x28, 0xaf, 0xc3, 0xee, 0x40, 0x75, 0xc0, 0xc0, 0x9a, 0xab, 0xf7, 0x84, 0x0d, 0x55,
0x38, 0xec, 0x48, 0xef, 0x79, 0xca, 0x2f, 0x4b, 0x50, 0x3c, 0x38, 0x26, 0xbf, 0xa9, 0xb6, 0x76,
0x0f, 0x6a, 0x41, 0x9a, 0x97, 0xfc, 0x6e, 0xde, 0x87, 0x1e, 0x72, 0x07, 0x7c, 0x8a, 0x1d, 0x37,
0x28, 0x13, 0xc5, 0x2f, 0x7a, 0x00, 0x45, 0xd7, 0xd3, 0xbd, 0xa1, 0x4b, 0xed, 0x8d, 0x1c, 0x5b,
0x7c, 0x35, 0xb3, 0xa9, 0xdb, 0x47, 0x14, 0xad, 0x72, 0x32, 0xf4, 0x1a, 0xcc, 0xb9, 0x9e, 0x83,
0xf5, 0x3e, 0x91, 0x4f, 0x81, 0x3a, 0x52, 0x83, 0x3b, 0x52, 0xf9, 0x88, 0x22, 0xba, 0x1d, 0xb5,
0xcc, 0x48, 0xba, 0x46, 0xe4, 0x30, 0x56, 0xbc, 0xdc, 0x39, 0x78, 0x8b, 0xcc, 0x49, 0x66, 0x27,
0x3c, 0x4a, 0x53, 0xf0, 0x28, 0xb3, 0x61, 0x5b, 0xa4, 0xec, 0x63, 0xe5, 0x09, 0xa6, 0x3c, 0xca,
0xd3, 0xac, 0x83, 0x8f, 0xdb, 0xf2, 0xd0, 0x23, 0x68, 0x06, 0xd2, 0x26, 0x72, 0x32, 0x74, 0x4f,
0xd7, 0x2c, 0xdb, 0x3a, 0xc1, 0xcd, 0x39, 0x2a, 0x8a, 0x79, 0x2e, 0x8a, 0xc2, 0x3e, 0x01, 0xaa,
0xcb, 0x3e, 0xf9, 0x1e, 0xa7, 0xa6, 0x70, 0xf4, 0x1a, 0xa0, 0x38, 0xa3, 0x26, 0x50, 0xd5, 0x2d,
0xc4, 0xc6, 0xa0, 0x57, 0x01, 0x9d, 0x9a, 0x17, 0xd1, 0x42, 0xae, 0x42, 0x43, 0x69, 0x83, 0x62,
0xe4, 0x0a, 0x6e, 0x17, 0x16, 0xe2, 0x47, 0xc3, 0xea, 0xf8, 0x12, 0xb2, 0xe1, 0x44, 0xcf, 0x84,
0x1f, 0xc1, 0x8d, 0xe4, 0xb3, 0xe0, 0xfc, 0x84, 0x67, 0xc1, 0x25, 0x9c, 0x72, 0x08, 0xf4, 0x6c,
0x4f, 0xef, 0xb1, 0x6d, 0xd4, 0xe8, 0x36, 0xe6, 0x28, 0x84, 0xae, 0x7f, 0x0d, 0x2a, 0xa6, 0xd5,
0x33, 0x2d, 0xcc, 0xf0, 0x75, 0x8a, 0x07, 0x06, 0x12, 0x04, 0x0e, 0xee, 0xdb, 0x1e, 0x27, 0x68,
0x30, 0x02, 0x06, 0x22, 0x04, 0xca, 0x07, 0x50, 0x64, 0x56, 0x8b, 0x2a, 0x50, 0xea, 0xee, 0x7f,
0xbc, 0xf5, 0xb8, 0xdb, 0x69, 0xbc, 0x80, 0xe6, 0x61, 0xee, 0xa3, 0xc3, 0xc7, 0x07, 0x5b, 0x9d,
0xee, 0xfe, 0xa3, 0x46, 0x06, 0xd5, 0x00, 0x76, 0x0e, 0xf6, 0xf6, 0xba, 0x1f, 0x7e, 0x48, 0xfe,
0xb3, 0x04, 0xcd, 0xff, 0x1f, 0x76, 0x1a, 0x39, 0x54, 0x85, 0x72, 0xe7, 0xe1, 0xe3, 0x87, 0x14,
0x99, 0x57, 0xfe, 0x9e, 0x05, 0xc4, 0x1c, 0x62, 0x1b, 0x9f, 0x99, 0x96, 0x74, 0x5e, 0xbb, 0x1e,
0xbf, 0x0c, 0xdb, 0x6b, 0xfe, 0x72, 0xf6, 0x9a, 0x68, 0x09, 0xa5, 0x99, 0x5a, 0x42, 0xf9, 0x2a,
0x96, 0xa0, 0xfc, 0x31, 0x0b, 0x8b, 0x21, 0xa9, 0xf2, 0xe0, 0x78, 0x6d, 0x62, 0x0d, 0x45, 0xaf,
0xfc, 0xd8, 0xe8, 0x95, 0x28, 0xc0, 0xc2, 0x4c, 0x05, 0x58, 0xbc, 0x92, 0x00, 0xff, 0x90, 0x11,
0x02, 0x0c, 0x9d, 0x48, 0xc2, 0xfb, 0xcc, 0x8c, 0xdd, 0xe7, 0xa8, 0xc0, 0x96, 0xbd, 0x7a, 0x60,
0xcb, 0xa5, 0x04, 0x36, 0x65, 0x19, 0x96, 0xc2, 0xab, 0xe7, 0xc7, 0xfc, 0x27, 0xd0, 0x60, 0x70,
0xa9, 0x8b, 0x73, 0x5d, 0x36, 0xa1, 0xbc, 0x03, 0x0b, 0xd2, 0x64, 0x41, 0x2b, 0xc8, 0xa6, 0xc0,
0x78, 0x2b, 0x88, 0x11, 0xab, 0x1c, 0xaf, 0xfc, 0x2c, 0x2b, 0xc6, 0x47, 0x1a, 0x39, 0x89, 0xab,
0x7d, 0x05, 0x1a, 0xd2, 0x6a, 0xe5, 0x32, 0xb1, 0x1e, 0xac, 0x97, 0xd5, 0x8b, 0x21, 0x52, 0xde,
0x15, 0xca, 0x45, 0x48, 0x77, 0x58, 0x7b, 0x28, 0x54, 0x1a, 0xe6, 0x53, 0x4b, 0xc3, 0x82, 0x5c,
0x1a, 0x76, 0xa1, 0xce, 0x76, 0xa0, 0x99, 0xd6, 0x49, 0x6f, 0x68, 0xe0, 0xc0, 0x16, 0x23, 0x5b,
0x15, 0x2d, 0xa1, 0x2e, 0xa7, 0x53, 0x6b, 0x6c, 0xa0, 0xf8, 0x57, 0x3e, 0x15, 0xb1, 0x71, 0xc2,
0x4e, 0x53, 0x98, 0xed, 0xa8, 0x4e, 0xd3, 0x9f, 0x72, 0x50, 0x0b, 0x53, 0x27, 0xe8, 0x3b, 0x33,
0x46, 0xdf, 0xd9, 0xb4, 0x92, 0x27, 0x37, 0x59, 0xc9, 0x13, 0xae, 0x61, 0xf2, 0x33, 0xa8, 0x61,
0x0a, 0x33, 0xa8, 0x61, 0x8a, 0xb3, 0xaf, 0x61, 0x4a, 0x57, 0x77, 0xf5, 0x72, 0x9a, 0xab, 0x7f,
0x0f, 0x96, 0x93, 0xad, 0x09, 0xb5, 0xa0, 0xec, 0x0f, 0xcf, 0xb0, 0x5a, 0x5e, 0xfc, 0x2b, 0x2e,
0x34, 0xa5, 0xfc, 0x10, 0x6e, 0xb6, 0x5e, 0x5b, 0x40, 0x78, 0x0f, 0x6e, 0x25, 0x4c, 0xca, 0xad,
0x7a, 0xba, 0xc8, 0x1a, 0xf0, 0x7a, 0xd7, 0xb4, 0x4c, 0xf7, 0x3c, 0xbc, 0x83, 0x29, 0x79, 0xdd,
0x86, 0x56, 0x12, 0x2f, 0x1e, 0x33, 0xff, 0x93, 0x85, 0xca, 0x91, 0xee, 0x89, 0x71, 0xd7, 0x97,
0x43, 0xaf, 0xd4, 0x9b, 0xec, 0xc2, 0x3c, 0xf5, 0x09, 0x92, 0x05, 0x0d, 0xdd, 0xc3, 0x53, 0xb9,
0x42, 0x55, 0x0c, 0xed, 0xe8, 0x1e, 0x46, 0x7b, 0x50, 0x0f, 0x3a, 0x8e, 0x8c, 0xd9, 0x34, 0x3e,
0x51, 0x0b, 0x06, 0x53, 0x76, 0x0f, 0x60, 0xd1, 0xd5, 0x3d, 0xdc, 0xeb, 0x99, 0xb4, 0xb0, 0x3c,
0xb3, 0x74, 0x6f, 0xe8, 0xf0, 0xba, 0x5e, 0x45, 0x3e, 0xea, 0x48, 0x60, 0x94, 0x7f, 0x67, 0xa1,
0xc4, 0xeb, 0xee, 0x69, 0xf3, 0xed, 0xf7, 0xa1, 0x3c, 0xb0, 0x5d, 0xd3, 0x13, 0xd1, 0xa9, 0xb2,
0x79, 0x2b, 0x08, 0x42, 0x9c, 0xe7, 0x21, 0x27, 0x50, 0x7d, 0x52, 0xf4, 0x0e, 0x2c, 0x06, 0xaa,
0x7b, 0x82, 0x9f, 0x71, 0xb7, 0xcd, 0x25, 0xb9, 0x6d, 0xe0, 0x82, 0xef, 0xe3, 0x67, 0xcc, 0x63,
0xef, 0xc2, 0x7c, 0x68, 0x38, 0x6f, 0x31, 0x54, 0x65, 0x4a, 0xd4, 0x86, 0x45, 0x52, 0x55, 0x4b,
0xdd, 0x63, 0xea, 0x98, 0xac, 0x6b, 0xbc, 0x40, 0x50, 0x7e, 0xdb, 0xb8, 0x43, 0xce, 0x26, 0x9b,
0x7e, 0x61, 0x83, 0x0d, 0x8d, 0xd7, 0xed, 0x74, 0x04, 0xbb, 0xdc, 0x09, 0x16, 0xdc, 0xa5, 0x38,
0x3a, 0xe6, 0x65, 0x28, 0xd2, 0x96, 0xad, 0xdb, 0x2c, 0xd1, 0xd4, 0x50, 0x0f, 0x36, 0x4f, 0x7b,
0x31, 0x2a, 0x47, 0x2b, 0xbb, 0x50, 0xa0, 0x00, 0x72, 0xe0, 0x67, 0x4d, 0x5e, 0x6b, 0xd8, 0xa7,
0xf2, 0x2d, 0xa8, 0x65, 0x0a, 0xd8, 0x1f, 0xf6, 0x91, 0x02, 0x79, 0xcb, 0x36, 0x44, 0xa5, 0x52,
0xe3, 0x72, 0x28, 0xee, 0xdb, 0x06, 0xee, 0x76, 0x54, 0x8a, 0x53, 0x76, 0xa1, 0x1e, 0x91, 0x2b,
0x39, 0x46, 0x90, 0x83, 0x3d, 0x61, 0x79, 0xcc, 0x3b, 0x9d, 0x05, 0x95, 0x9e, 0xfe, 0xf7, 0x29,
0x84, 0xe4, 0x4d, 0xd3, 0x32, 0xf0, 0x85, 0xb8, 0x74, 0xa1, 0x3f, 0xca, 0x6f, 0x33, 0xb0, 0xc8,
0x59, 0x85, 0x8e, 0x02, 0xcf, 0xc7, 0x04, 0xee, 0x43, 0xbd, 0xaf, 0x5f, 0x68, 0xb4, 0xbf, 0xcb,
0x7a, 0x62, 0xbc, 0xa5, 0x36, 0xdf, 0xd7, 0x2f, 0x82, 0x16, 0x98, 0xf2, 0xd7, 0x0c, 0x2c, 0x85,
0x57, 0xc9, 0xe3, 0xd7, 0xeb, 0x00, 0xe2, 0x14, 0xe9, 0xaf, 0x73, 0x81, 0xaf, 0x73, 0x4e, 0x34,
0x0d, 0x3b, 0xea, 0x1c, 0x27, 0xea, 0x26, 0xb7, 0xe1, 0xb2, 0xb3, 0x68, 0xc3, 0x4d, 0xd1, 0x2f,
0xfd, 0x5d, 0xd6, 0xdf, 0x4e, 0xb8, 0xd0, 0x9d, 0x7e, 0x3b, 0x29, 0x4e, 0x94, 0xbd, 0xac, 0x13,
0xe5, 0x26, 0x77, 0xa2, 0x7c, 0x9a, 0x13, 0x3d, 0x82, 0xf9, 0xe1, 0xa0, 0x67, 0xeb, 0x86, 0xe6,
0x60, 0x77, 0xd8, 0xf3, 0x78, 0x1f, 0x5f, 0x89, 0x5b, 0x04, 0x91, 0xd1, 0x47, 0x03, 0xde, 0x00,
0x1f, 0xf6, 0x3c, 0xb5, 0x3a, 0x94, 0xfe, 0x94, 0x5f, 0x04, 0xfd, 0xd4, 0x18, 0xe9, 0x68, 0x27,
0x7a, 0x19, 0x4a, 0xf4, 0x3e, 0xcc, 0xbf, 0x45, 0x89, 0xfa, 0x51, 0x91, 0xa0, 0xbb, 0x06, 0xba,
0x07, 0xf9, 0x73, 0xdd, 0x3d, 0xe7, 0x6f, 0x1a, 0x16, 0xc4, 0x55, 0x03, 0x9d, 0x6e, 0x57, 0x77,
0xcf, 0x55, 0x8a, 0x56, 0xfe, 0x97, 0x85, 0x2a, 0x49, 0x47, 0x42, 0x05, 0x68, 0x33, 0xea, 0x1f,
0x95, 0xcd, 0x1b, 0xd2, 0xfe, 0x82, 0xcc, 0x25, 0x39, 0x49, 0xc4, 0x45, 0xb3, 0xe9, 0x2e, 0x9a,
0x93, 0x5c, 0x34, 0x7e, 0x2f, 0x54, 0x98, 0xe0, 0x5e, 0xe8, 0x03, 0xb8, 0xe1, 0xdf, 0xa6, 0x48,
0xee, 0x45, 0xaa, 0xe2, 0x09, 0x6c, 0x7d, 0x51, 0x8c, 0x0d, 0x60, 0x6e, 0x3c, 0xd9, 0x95, 0x2e,
0x9d, 0xec, 0x52, 0xb2, 0x53, 0x39, 0x35, 0x3b, 0xdd, 0xf4, 0x6f, 0x18, 0x22, 0x67, 0xab, 0xdf,
0x64, 0x7d, 0x13, 0xd9, 0xd3, 0x9f, 0x60, 0x16, 0x96, 0x9f, 0x6f, 0x10, 0x7b, 0x1e, 0x79, 0x2c,
0x35, 0x2f, 0x15, 0x52, 0xf3, 0x12, 0xeb, 0xee, 0xc6, 0x24, 0xc3, 0xe5, 0x66, 0xfb, 0xc8, 0x84,
0x5a, 0x74, 0x25, 0x26, 0xb7, 0x2b, 0x4b, 0x49, 0xf9, 0x26, 0xb8, 0xf4, 0x4a, 0x2a, 0x44, 0xbf,
0x9b, 0x81, 0xfc, 0x57, 0xc1, 0xa6, 0x92, 0x2a, 0xe2, 0xe9, 0x37, 0xf5, 0x36, 0x94, 0x58, 0xcc,
0x14, 0x7b, 0x49, 0x09, 0x9a, 0xbe, 0xf4, 0x48, 0xd0, 0x14, 0x43, 0x62, 0xf1, 0x52, 0xa6, 0x7a,
0xbe, 0xf1, 0x72, 0x15, 0x56, 0x12, 0xe5, 0xc2, 0xad, 0xef, 0xcb, 0x0c, 0x20, 0x8e, 0x97, 0xdb,
0x0c, 0x23, 0xed, 0x6e, 0x1b, 0xea, 0xac, 0x6d, 0xa0, 0x4d, 0x6e, 0x7e, 0x35, 0x36, 0xc2, 0x2f,
0x92, 0xfc, 0xde, 0x41, 0x4e, 0xea, 0x1d, 0x28, 0x9f, 0xf9, 0x25, 0x50, 0xe8, 0xc4, 0xff, 0x20,
0x7c, 0xe2, 0x8f, 0x4f, 0x33, 0xc9, 0x91, 0x3f, 0xa8, 0xd4, 0xfc, 0x23, 0xbf, 0xec, 0x40, 0x99,
0xc9, 0x1d, 0xe8, 0xcb, 0x8c, 0x7f, 0x0d, 0x1a, 0xb9, 0x99, 0x9e, 0x36, 0xce, 0xcd, 0x40, 0x92,
0xca, 0xd7, 0xb9, 0xe0, 0x32, 0x35, 0x72, 0x87, 0xfd, 0xdd, 0xf4, 0xe5, 0xf4, 0x10, 0x9b, 0x4f,
0x2f, 0xfd, 0xef, 0x40, 0x35, 0xe1, 0x35, 0x4a, 0xc5, 0x95, 0xee, 0x2f, 0x52, 0xb2, 0x43, 0xf1,
0xb2, 0xd9, 0xa1, 0x94, 0x90, 0x1d, 0x5e, 0x83, 0xbc, 0x85, 0x2f, 0xc4, 0x45, 0xd0, 0x08, 0x2d,
0x52, 0xb2, 0xcd, 0xaf, 0x17, 0xa0, 0xbc, 0xc7, 0x49, 0xd0, 0x1e, 0x54, 0xd9, 0xf3, 0x34, 0xfe,
0x70, 0x74, 0x35, 0xfa, 0x84, 0x2a, 0xf4, 0x62, 0xb0, 0xf5, 0x62, 0x1a, 0x9a, 0xeb, 0xbe, 0x03,
0x73, 0x8f, 0xb0, 0xc7, 0x79, 0xb5, 0xa2, 0xc4, 0x41, 0x03, 0xb4, 0xb5, 0x92, 0x88, 0xe3, 0x5c,
0xf6, 0xa0, 0xca, 0x22, 0x46, 0xda, 0xa2, 0x42, 0x71, 0x36, 0xbe, 0xa8, 0x48, 0x72, 0xd9, 0x85,
0x0a, 0xf1, 0x3e, 0x86, 0x73, 0xd1, 0x4a, 0xd2, 0x2b, 0x31, 0xc1, 0xeb, 0x76, 0x32, 0x92, 0x73,
0xc2, 0xa4, 0x70, 0xe7, 0x8c, 0xa4, 0x7b, 0x53, 0x74, 0x2f, 0x3a, 0x2a, 0xf1, 0xce, 0xb6, 0x75,
0x7f, 0x1c, 0x19, 0x9f, 0xe6, 0x3d, 0xa8, 0xd0, 0x24, 0xc9, 0xef, 0x4b, 0x6f, 0x47, 0x7b, 0x7a,
0xf2, 0x51, 0xad, 0xb5, 0x9a, 0x82, 0x0d, 0x64, 0xc9, 0x6a, 0x26, 0xce, 0x2c, 0x46, 0x1e, 0x3a,
0x82, 0xc8, 0xb2, 0x4c, 0x6a, 0x66, 0x73, 0x05, 0x73, 0x5e, 0xad, 0x28, 0x71, 0xb2, 0x82, 0xe3,
0x0d, 0x69, 0xae, 0x11, 0x86, 0x08, 0x69, 0x24, 0xd6, 0x7c, 0x6e, 0xdd, 0x4e, 0x46, 0x72, 0x4e,
0x9f, 0xc3, 0x82, 0x54, 0x4f, 0xf0, 0x75, 0x29, 0x89, 0x22, 0x09, 0x1b, 0xcd, 0xdd, 0x91, 0x34,
0x9c, 0xbb, 0x06, 0x48, 0x4e, 0x60, 0x9c, 0x7d, 0x6c, 0x68, 0x42, 0xf2, 0x6f, 0xbd, 0x34, 0x9a,
0x28, 0xd0, 0x0e, 0x9d, 0x57, 0xb4, 0x5e, 0x56, 0x63, 0xce, 0x1b, 0xd2, 0xf5, 0x8b, 0x69, 0x68,
0xce, 0xee, 0x10, 0xe6, 0x99, 0xbe, 0x04, 0xbf, 0xf8, 0x80, 0xb0, 0xba, 0xd7, 0x52, 0xf1, 0x81,
0x7c, 0x83, 0xf2, 0x51, 0x70, 0x8d, 0x57, 0x25, 0xb1, 0xe2, 0x5b, 0x96, 0x6f, 0x6a, 0x19, 0x4a,
0xe4, 0x2b, 0x89, 0x5d, 0xb0, 0xbf, 0x9b, 0xbc, 0xcb, 0x54, 0xf9, 0x8e, 0xa8, 0x2b, 0x8f, 0x61,
0x51, 0x96, 0xbb, 0x98, 0x21, 0x3e, 0x38, 0x49, 0x85, 0xf7, 0xc6, 0x50, 0xf1, 0x39, 0xde, 0x87,
0xaa, 0xfc, 0x88, 0x44, 0x76, 0xd7, 0x78, 0x91, 0xd3, 0x5a, 0x4d, 0xc1, 0x72, 0x66, 0x1f, 0x43,
0x5d, 0x24, 0x54, 0xb1, 0xd8, 0xf5, 0xd8, 0x88, 0x48, 0x01, 0xd0, 0xba, 0x33, 0x82, 0x82, 0xf3,
0xfd, 0x04, 0x1a, 0x2c, 0x54, 0x73, 0x82, 0x83, 0x9e, 0x91, 0xc0, 0x38, 0xf2, 0xfe, 0x33, 0x81,
0x71, 0xec, 0x01, 0xe4, 0x0f, 0xa1, 0x11, 0x32, 0x39, 0x02, 0xbb, 0x33, 0xda, 0xea, 0x08, 0x67,
0x65, 0x8c, 0xe1, 0x11, 0x36, 0x47, 0x50, 0x93, 0x1e, 0x7e, 0xd1, 0x17, 0x2f, 0xb1, 0x51, 0xe1,
0x17, 0x67, 0xad, 0xf5, 0x14, 0x82, 0x80, 0xa9, 0x06, 0x28, 0x22, 0x60, 0x02, 0xbd, 0x3b, 0x4e,
0xc6, 0x84, 0xf9, 0x4b, 0x63, 0xc5, 0xcc, 0x05, 0x12, 0x32, 0xb6, 0x64, 0x81, 0x44, 0x9f, 0xa0,
0x25, 0x08, 0x24, 0xfe, 0x86, 0xec, 0x63, 0xa8, 0xcb, 0x96, 0x16, 0xd1, 0x61, 0xf2, 0xcb, 0x2e,
0x59, 0x87, 0x69, 0xaf, 0xa3, 0x3e, 0x87, 0x85, 0x70, 0x26, 0x22, 0xc0, 0xd0, 0x82, 0x92, 0x5f,
0x20, 0x85, 0x9d, 0x3c, 0xe5, 0x25, 0x11, 0xc9, 0x66, 0xd2, 0x9b, 0x21, 0xd9, 0x3d, 0xe2, 0x0f,
0x8c, 0x64, 0xf7, 0x48, 0x78, 0x68, 0xb4, 0x9d, 0xff, 0x2c, 0x3b, 0x38, 0x3e, 0x2e, 0xd2, 0x5e,
0xc3, 0x1b, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x61, 0x2a, 0x98, 0xbe, 0x75, 0x33, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.

34
pkg/pb/metainfo.proto
View File

@ -258,9 +258,6 @@ message ObjectBeginRequest {
google.protobuf.Timestamp expires_at = 4 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
bytes encrypted_metadata_nonce = 5 [(gogoproto.customtype) = "Nonce", (gogoproto.nullable) = false];
bytes encrypted_metadata = 6; // TODO: set maximum size limit
pointerdb.RedundancyScheme redundancy_scheme = 7; // can be zero
encryption.EncryptionParameters encryption_parameters = 8; // can be zero
}
@ -278,6 +275,9 @@ message ObjectBeginResponse {
message ObjectCommitRequest {
bytes stream_id = 1 [(gogoproto.customtype) = "StreamID", (gogoproto.nullable) = false];
bytes encrypted_metadata_nonce = 2 [(gogoproto.customtype) = "Nonce", (gogoproto.nullable) = false];
bytes encrypted_metadata = 3; // TODO: set maximum size limit
}
message ObjectCommitResponse {
@ -297,9 +297,12 @@ message ObjectListRequest {
bytes bucket = 1;
bytes encrypted_prefix = 2;
bytes encrypted_cursor = 3;
int32 limit = 4;
bool recursive = 4;
int32 limit = 5;
ObjectListItemIncludes object_includes = 6;
ObjectListItemIncludes object_includes = 5;
}
message ObjectListResponse {
@ -352,9 +355,6 @@ message SatStreamID {
google.protobuf.Timestamp creation_date = 5 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
google.protobuf.Timestamp expiration_date = 6 [(gogoproto.stdtime) = true, (gogoproto.nullable) = false];
bytes encrypted_metadata_nonce = 7 [(gogoproto.customtype) = "Nonce", (gogoproto.nullable) = false];
bytes encrypted_metadata = 8;
bytes satellite_signature = 9;
}
@ -450,8 +450,9 @@ message SegmentBeginDeleteRequest {
}
message SegmentBeginDeleteResponse {
bytes segment_id = 1 [(gogoproto.customtype) = "SegmentID", (gogoproto.nullable) = false];
repeated AddressedOrderLimit addressed_limits = 2;
bytes segment_id = 1 [(gogoproto.customtype) = "SegmentID", (gogoproto.nullable) = false];
repeated AddressedOrderLimit addressed_limits = 2;
bytes private_key = 3 [(gogoproto.customtype) = "PiecePrivateKey", (gogoproto.nullable) = false];
}
message SegmentFinishDeleteRequest {
@ -488,8 +489,15 @@ message SegmentDownloadRequest {
}
message SegmentDownloadResponse {
bytes segment_id = 1 [(gogoproto.customtype) = "SegmentID", (gogoproto.nullable) = false];
bytes segment_id = 1 [(gogoproto.customtype) = "SegmentID", (gogoproto.nullable) = false];
repeated AddressedOrderLimit addressed_limits = 2;
bytes encrypted_inline_data = 3;
SegmentPosition next = 4; // can be nil
bytes private_key = 3 [(gogoproto.customtype) = "PiecePrivateKey", (gogoproto.nullable) = false];
bytes encrypted_inline_data = 4;
int64 segment_size = 5;
bytes encrypted_key_nonce = 6 [(gogoproto.customtype) = "Nonce", (gogoproto.nullable) = false];
bytes encrypted_key = 7;
SegmentPosition next = 8; // can be nil
}

19
pkg/storj/object.go
View File

@ -34,6 +34,25 @@ type Object struct {
Stream
}
// ObjectInfo contains information about a specific object
type ObjectInfo struct {
Version uint32
Bucket string
Path Path
IsPrefix bool
StreamID StreamID
Metadata []byte
ContentType string
Created time.Time
Modified time.Time
Expires time.Time
Stream
}
// Stream is information about an object stream
type Stream struct {
// Size is the total size of the stream in bytes

1
pkg/storj/object_list_item.go
View File

@ -17,4 +17,5 @@ type ObjectListItem struct {
ExpiresAt time.Time
EncryptedMetadataNonce Nonce
EncryptedMetadata []byte
IsPrefix bool
}

10
pkg/storj/segment.go
View File

@ -17,6 +17,16 @@ type SegmentListItem struct {
// SegmentDownloadInfo represents segment download information inline/remote
type SegmentDownloadInfo struct {
SegmentID SegmentID
Size int64
EncryptedInlineData []byte
Next SegmentPosition
PiecePrivateKey PiecePrivateKey
SegmentEncryption SegmentEncryption
}
// SegmentEncryption represents segment encryption key and nonce
type SegmentEncryption struct {
EncryptedKeyNonce Nonce
EncryptedKey EncryptedPrivateKey
}

124
proto.lock
View File

@ -2349,26 +2349,6 @@
}
]
},
{
"id": 5,
"name": "encrypted_metadata_nonce",
"type": "bytes",
"options": [
{
"name": "(gogoproto.customtype)",
"value": "Nonce"
},
{
"name": "(gogoproto.nullable)",
"value": "false"
}
]
},
{
"id": 6,
"name": "encrypted_metadata",
"type": "bytes"
},
{
"id": 7,
"name": "redundancy_scheme",
@ -2443,6 +2423,26 @@
"value": "false"
}
]
},
{
"id": 2,
"name": "encrypted_metadata_nonce",
"type": "bytes",
"options": [
{
"name": "(gogoproto.customtype)",
"value": "Nonce"
},
{
"name": "(gogoproto.nullable)",
"value": "false"
}
]
},
{
"id": 3,
"name": "encrypted_metadata",
"type": "bytes"
}
]
},
@ -2499,11 +2499,16 @@
},
{
"id": 4,
"name": "recursive",
"type": "bool"
},
{
"id": 5,
"name": "limit",
"type": "int32"
},
{
"id": 5,
"id": 6,
"name": "object_includes",
"type": "ObjectListItemIncludes"
}
@ -2736,26 +2741,6 @@
}
]
},
{
"id": 7,
"name": "encrypted_metadata_nonce",
"type": "bytes",
"options": [
{
"name": "(gogoproto.customtype)",
"value": "Nonce"
},
{
"name": "(gogoproto.nullable)",
"value": "false"
}
]
},
{
"id": 8,
"name": "encrypted_metadata",
"type": "bytes"
},
{
"id": 9,
"name": "satellite_signature",
@ -3171,6 +3156,21 @@
"name": "addressed_limits",
"type": "AddressedOrderLimit",
"is_repeated": true
},
{
"id": 3,
"name": "private_key",
"type": "bytes",
"options": [
{
"name": "(gogoproto.customtype)",
"value": "PiecePrivateKey"
},
{
"name": "(gogoproto.nullable)",
"value": "false"
}
]
}
]
},
@ -3330,11 +3330,51 @@
},
{
"id": 3,
"name": "private_key",
"type": "bytes",
"options": [
{
"name": "(gogoproto.customtype)",
"value": "PiecePrivateKey"
},
{
"name": "(gogoproto.nullable)",
"value": "false"
}
]
},
{
"id": 4,
"name": "encrypted_inline_data",
"type": "bytes"
},
{
"id": 4,
"id": 5,
"name": "segment_size",
"type": "int64"
},
{
"id": 6,
"name": "encrypted_key_nonce",
"type": "bytes",
"options": [
{
"name": "(gogoproto.customtype)",
"value": "Nonce"
},
{
"name": "(gogoproto.nullable)",
"value": "false"
}
]
},
{
"id": 7,
"name": "encrypted_key",
"type": "bytes"
},
{
"id": 8,
"name": "next",
"type": "SegmentPosition"
}

278
satellite/metainfo/metainfo.go
View File

@ -117,18 +117,9 @@ func (endpoint *Endpoint) SegmentInfoOld(ctx context.Context, req *pb.SegmentInf
return nil, status.Errorf(codes.InvalidArgument, err.Error())
}
path, err := CreatePath(ctx, keyInfo.ProjectID, req.Segment, req.Bucket, req.Path)
pointer, _, err := endpoint.getPointer(ctx, keyInfo.ProjectID, req.Segment, req.Bucket, req.Path)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, err.Error())
}
// TODO refactor to use []byte directly
pointer, err := endpoint.metainfo.Get(ctx, path)
if err != nil {
if storage.ErrKeyNotFound.Has(err) {
return nil, status.Errorf(codes.NotFound, err.Error())
}
return nil, status.Errorf(codes.Internal, err.Error())
return nil, err
}
return &pb.SegmentInfoResponseOld{Pointer: pointer}, nil
@ -347,18 +338,9 @@ func (endpoint *Endpoint) DownloadSegmentOld(ctx context.Context, req *pb.Segmen
return nil, status.Errorf(codes.ResourceExhausted, "Exceeded Usage Limit")
}
path, err := CreatePath(ctx, keyInfo.ProjectID, req.Segment, req.Bucket, req.Path)
pointer, _, err := endpoint.getPointer(ctx, keyInfo.ProjectID, req.Segment, req.Bucket, req.Path)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, err.Error())
}
// TODO refactor to use []byte directly
pointer, err := endpoint.metainfo.Get(ctx, path)
if err != nil {
if storage.ErrKeyNotFound.Has(err) {
return nil, status.Errorf(codes.NotFound, err.Error())
}
return nil, status.Errorf(codes.Internal, err.Error())
return nil, err
}
if pointer.Type == pb.Pointer_INLINE {
@ -944,6 +926,9 @@ func (endpoint *Endpoint) BeginObject(ctx context.Context, req *pb.ObjectBeginRe
// take bucket RS values if not set in request
pbRS := req.RedundancyScheme
if pbRS.Type == 0 {
pbRS.Type = pb.RedundancyScheme_SchemeType(bucket.DefaultRedundancyScheme.Algorithm)
}
if pbRS.ErasureShareSize == 0 {
pbRS.ErasureShareSize = bucket.DefaultRedundancyScheme.ShareSize
}
@ -969,14 +954,12 @@ func (endpoint *Endpoint) BeginObject(ctx context.Context, req *pb.ObjectBeginRe
}
streamID, err := endpoint.packStreamID(ctx, &pb.SatStreamID{
Bucket: req.Bucket,
EncryptedPath: req.EncryptedPath,
Version: req.Version,
Redundancy: pbRS,
CreationDate: time.Now(),
ExpirationDate: req.ExpiresAt,
EncryptedMetadataNonce: req.EncryptedMetadataNonce,
EncryptedMetadata: req.EncryptedMetadata,
Bucket: req.Bucket,
EncryptedPath: req.EncryptedPath,
Version: req.Version,
Redundancy: pbRS,
CreationDate: time.Now(),
ExpirationDate: req.ExpiresAt,
})
if err != nil {
return nil, status.Errorf(codes.Internal, err.Error())
@ -1011,7 +994,7 @@ func (endpoint *Endpoint) CommitObject(ctx context.Context, req *pb.ObjectCommit
return nil, status.Errorf(codes.InvalidArgument, "stream ID expired")
}
_, err = endpoint.validateAuth(ctx, macaroon.Action{
keyInfo, err := endpoint.validateAuth(ctx, macaroon.Action{
Op: macaroon.ActionWrite,
Bucket: streamID.Bucket,
EncryptedPath: streamID.EncryptedPath,
@ -1021,7 +1004,47 @@ func (endpoint *Endpoint) CommitObject(ctx context.Context, req *pb.ObjectCommit
return nil, status.Errorf(codes.Unauthenticated, err.Error())
}
// we don't need to do anything for shim implementation
segmentIndex := int64(0)
var lastSegmentPointer *pb.Pointer
var lastSegmentPath string
for {
path, err := CreatePath(ctx, keyInfo.ProjectID, segmentIndex, streamID.Bucket, streamID.EncryptedPath)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, "unable to create segment path: %v", err.Error())
}
pointer, err := endpoint.metainfo.Get(ctx, path)
if err != nil {
if storage.ErrKeyNotFound.Has(err) {
break
}
return nil, status.Errorf(codes.Internal, "unable to create get segment: %v", err.Error())
}
lastSegmentPointer = pointer
lastSegmentPath = path
segmentIndex++
}
if lastSegmentPointer == nil {
return nil, status.Errorf(codes.NotFound, "unable to find object: %s/%s", streamID.Bucket, streamID.EncryptedPath)
}
lastSegmentPointer.Metadata = req.EncryptedMetadata
err = endpoint.metainfo.Delete(ctx, lastSegmentPath)
if err != nil {
return nil, status.Errorf(codes.Internal, err.Error())
}
lastSegmentPath, err = CreatePath(ctx, keyInfo.ProjectID, -1, streamID.Bucket, streamID.EncryptedPath)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, err.Error())
}
err = endpoint.metainfo.Put(ctx, lastSegmentPath, lastSegmentPointer)
if err != nil {
return nil, status.Errorf(codes.Internal, err.Error())
}
return &pb.ObjectCommitResponse{}, nil
}
@ -1045,16 +1068,14 @@ func (endpoint *Endpoint) GetObject(ctx context.Context, req *pb.ObjectGetReques
return nil, status.Errorf(codes.InvalidArgument, err.Error())
}
path, err := CreatePath(ctx, keyInfo.ProjectID, -1, req.Bucket, req.EncryptedPath)
pointer, _, err := endpoint.getPointer(ctx, keyInfo.ProjectID, -1, req.Bucket, req.EncryptedPath)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, err.Error())
return nil, err
}
pointer, err := endpoint.metainfo.Get(ctx, path)
streamMeta := &pb.StreamMeta{}
err = proto.Unmarshal(pointer.Metadata, streamMeta)
if err != nil {
if storage.ErrKeyNotFound.Has(err) {
return nil, status.Errorf(codes.NotFound, err.Error())
}
return nil, status.Errorf(codes.Internal, err.Error())
}
@ -1076,6 +1097,14 @@ func (endpoint *Endpoint) GetObject(ctx context.Context, req *pb.ObjectGetReques
ExpiresAt: pointer.ExpirationDate,
CreatedAt: pointer.CreationDate,
EncryptedMetadata: pointer.Metadata,
EncryptionParameters: &pb.EncryptionParameters{
CipherSuite: pb.CipherSuite(streamMeta.EncryptionType),
BlockSize: int64(streamMeta.EncryptionBlockSize),
},
}
if pointer.Remote != nil {
object.RedundancyScheme = pointer.Remote.Redundancy
}
return &pb.ObjectGetResponse{
@ -1110,7 +1139,7 @@ func (endpoint *Endpoint) ListObjects(ctx context.Context, req *pb.ObjectListReq
metaflags := meta.All
// TODO use flags
// TODO find out how EncryptedCursor -> startAfter/endAfter
segments, more, err := endpoint.metainfo.List(ctx, prefix, "", "", false, req.Limit, metaflags)
segments, more, err := endpoint.metainfo.List(ctx, prefix, string(req.EncryptedCursor), "", req.Recursive, req.Limit, metaflags)
if err != nil {
return nil, status.Errorf(codes.Internal, err.Error())
}
@ -1118,10 +1147,12 @@ func (endpoint *Endpoint) ListObjects(ctx context.Context, req *pb.ObjectListReq
items := make([]*pb.ObjectListItem, len(segments))
for i, segment := range segments {
items[i] = &pb.ObjectListItem{
EncryptedPath: []byte(segment.Path),
EncryptedMetadata: segment.Pointer.Metadata,
CreatedAt: segment.Pointer.CreationDate,
ExpiresAt: segment.Pointer.ExpirationDate,
EncryptedPath: []byte(segment.Path),
}
if segment.Pointer != nil {
items[i].EncryptedMetadata = segment.Pointer.Metadata
items[i].CreatedAt = segment.Pointer.CreationDate
items[i].ExpiresAt = segment.Pointer.ExpirationDate
}
}
@ -1135,7 +1166,7 @@ func (endpoint *Endpoint) ListObjects(ctx context.Context, req *pb.ObjectListReq
func (endpoint *Endpoint) BeginDeleteObject(ctx context.Context, req *pb.ObjectBeginDeleteRequest) (resp *pb.ObjectBeginDeleteResponse, err error) {
defer mon.Task()(&ctx)(&err)
_, err = endpoint.validateAuth(ctx, macaroon.Action{
keyInfo, err := endpoint.validateAuth(ctx, macaroon.Action{
Op: macaroon.ActionDelete,
Bucket: req.Bucket,
EncryptedPath: req.EncryptedPath,
@ -1172,6 +1203,11 @@ func (endpoint *Endpoint) BeginDeleteObject(ctx context.Context, req *pb.ObjectB
return nil, status.Errorf(codes.Internal, err.Error())
}
_, _, err = endpoint.getPointer(ctx, keyInfo.ProjectID, -1, satStreamID.Bucket, satStreamID.EncryptedPath)
if err != nil {
return nil, err
}
return &pb.ObjectBeginDeleteResponse{
StreamId: streamID,
}, nil
@ -1232,6 +1268,10 @@ func (endpoint *Endpoint) BeginSegment(ctx context.Context, req *pb.SegmentBegin
// no need to validate streamID fields because it was validated during BeginObject
if req.Position.Index < 0 {
return nil, status.Errorf(codes.InvalidArgument, "segment index must be greater then 0")
}
exceeded, limit, err := endpoint.projectUsage.ExceedsStorageUsage(ctx, keyInfo.ProjectID)
if err != nil {
endpoint.log.Error("retrieving project storage totals", zap.Error(err))
@ -1268,9 +1308,9 @@ func (endpoint *Endpoint) BeginSegment(ctx context.Context, req *pb.SegmentBegin
segmentID, err := endpoint.packSegmentID(ctx, &pb.SatSegmentID{
StreamId: streamID,
Index: req.Position.Index,
OriginalOrderLimits: addressedLimits,
RootPieceId: rootPieceID,
Index: req.Position.Index,
CreationDate: time.Now(),
})
@ -1302,11 +1342,6 @@ func (endpoint *Endpoint) CommitSegment(ctx context.Context, req *pb.SegmentComm
return nil, status.Errorf(codes.Unauthenticated, err.Error())
}
if len(segmentID.OriginalOrderLimits) < len(req.UploadResult) {
return nil, status.Errorf(codes.InvalidArgument, "invalid number of upload results: wanted max %d got %d",
len(segmentID.OriginalOrderLimits), len(req.UploadResult))
}
pieces := make([]*pb.RemotePiece, len(req.UploadResult))
for i, result := range req.UploadResult {
pieces[i] = &pb.RemotePiece{
@ -1330,10 +1365,6 @@ func (endpoint *Endpoint) CommitSegment(ctx context.Context, req *pb.SegmentComm
ExpirationDate: streamID.ExpirationDate,
}
if segmentID.Index == lastSegment {
pointer.Metadata = streamID.EncryptedMetadata
}
orderLimits := make([]*pb.OrderLimit, len(segmentID.OriginalOrderLimits))
for i, orderLimit := range segmentID.OriginalOrderLimits {
orderLimits[i] = orderLimit.Limit
@ -1365,6 +1396,11 @@ func (endpoint *Endpoint) CommitSegment(ctx context.Context, req *pb.SegmentComm
return nil, status.Errorf(codes.ResourceExhausted, "Exceeded Usage Limit")
}
// clear hashes so we don't store them
for _, piece := range pointer.GetRemote().GetRemotePieces() {
piece.Hash = nil
}
inlineUsed, remoteUsed := calculateSpaceUsed(pointer)
// ToDo: Replace with hash & signature validation
@ -1410,6 +1446,10 @@ func (endpoint *Endpoint) MakeInlineSegment(ctx context.Context, req *pb.Segment
return nil, status.Errorf(codes.Unauthenticated, err.Error())
}
if req.Position.Index < 0 {
return nil, status.Errorf(codes.InvalidArgument, "segment index must be greater then 0")
}
path, err := CreatePath(ctx, keyInfo.ProjectID, int64(req.Position.Index), streamID.Bucket, streamID.EncryptedPath)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, err.Error())
@ -1442,10 +1482,6 @@ func (endpoint *Endpoint) MakeInlineSegment(ctx context.Context, req *pb.Segment
InlineSegment: req.EncryptedInlineData,
}
if req.Position.Index == lastSegment {
pointer.Metadata = streamID.EncryptedMetadata
}
err = endpoint.metainfo.Put(ctx, path, pointer)
if err != nil {
return nil, status.Errorf(codes.Internal, err.Error())
@ -1456,11 +1492,6 @@ func (endpoint *Endpoint) MakeInlineSegment(ctx context.Context, req *pb.Segment
return nil, status.Errorf(codes.Internal, err.Error())
}
pointer, err = endpoint.metainfo.Get(ctx, path)
if err != nil {
return nil, status.Errorf(codes.Internal, err.Error())
}
return &pb.SegmentMakeInlineResponse{}, nil
}
@ -1483,23 +1514,16 @@ func (endpoint *Endpoint) BeginDeleteSegment(ctx context.Context, req *pb.Segmen
return nil, status.Errorf(codes.Unauthenticated, err.Error())
}
path, err := CreatePath(ctx, keyInfo.ProjectID, int64(req.Position.Index), streamID.Bucket, streamID.EncryptedPath)
pointer, _, err := endpoint.getPointer(ctx, keyInfo.ProjectID, int64(req.Position.Index), streamID.Bucket, streamID.EncryptedPath)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, err.Error())
}
pointer, err := endpoint.metainfo.Get(ctx, path)
if err != nil {
if storage.ErrKeyNotFound.Has(err) {
return nil, status.Errorf(codes.NotFound, err.Error())
}
return nil, status.Errorf(codes.Internal, err.Error())
return nil, err
}
var limits []*pb.AddressedOrderLimit
var privateKey storj.PiecePrivateKey
if pointer.Type == pb.Pointer_REMOTE && pointer.Remote != nil {
bucketID := createBucketID(keyInfo.ProjectID, streamID.Bucket)
limits, _, err = endpoint.orders.CreateDeleteOrderLimits(ctx, bucketID, pointer)
limits, privateKey, err = endpoint.orders.CreateDeleteOrderLimits(ctx, bucketID, pointer)
if err != nil {
return nil, status.Errorf(codes.Internal, err.Error())
}
@ -1515,6 +1539,7 @@ func (endpoint *Endpoint) BeginDeleteSegment(ctx context.Context, req *pb.Segmen
return &pb.SegmentBeginDeleteResponse{
SegmentId: segmentID,
AddressedLimits: limits,
PrivateKey: privateKey,
}, nil
}
@ -1539,17 +1564,9 @@ func (endpoint *Endpoint) FinishDeleteSegment(ctx context.Context, req *pb.Segme
return nil, status.Errorf(codes.Unauthenticated, err.Error())
}
path, err := CreatePath(ctx, keyInfo.ProjectID, int64(segmentID.Index), streamID.Bucket, streamID.EncryptedPath)
pointer, path, err := endpoint.getPointer(ctx, keyInfo.ProjectID, int64(segmentID.Index), streamID.Bucket, streamID.EncryptedPath)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, err.Error())
}
pointer, err := endpoint.metainfo.Get(ctx, path)
if err != nil {
if storage.ErrKeyNotFound.Has(err) {
return nil, status.Errorf(codes.NotFound, err.Error())
}
return nil, status.Errorf(codes.Internal, err.Error())
return nil, err
}
for _, piece := range pointer.GetRemote().GetRemotePieces() {
@ -1666,21 +1683,40 @@ func (endpoint *Endpoint) DownloadSegment(ctx context.Context, req *pb.SegmentDo
return nil, status.Errorf(codes.ResourceExhausted, "Exceeded Usage Limit")
}
path, err := CreatePath(ctx, keyInfo.ProjectID, int64(req.CursorPosition.Index), streamID.Bucket, streamID.EncryptedPath)
pointer, _, err := endpoint.getPointer(ctx, keyInfo.ProjectID, int64(req.CursorPosition.Index), streamID.Bucket, streamID.EncryptedPath)
if err != nil {
return nil, status.Errorf(codes.InvalidArgument, err.Error())
}
pointer, err := endpoint.metainfo.Get(ctx, path)
if err != nil {
if storage.ErrKeyNotFound.Has(err) {
return nil, status.Errorf(codes.NotFound, err.Error())
}
return nil, status.Errorf(codes.Internal, err.Error())
return nil, err
}
segmentID, err := endpoint.packSegmentID(ctx, &pb.SatSegmentID{})
var encryptedKeyNonce storj.Nonce
var encryptedKey []byte
if len(pointer.Metadata) != 0 {
var segmentMeta *pb.SegmentMeta
if req.CursorPosition.Index == lastSegment {
streamMeta := &pb.StreamMeta{}
err = proto.Unmarshal(pointer.Metadata, streamMeta)
if err != nil {
return nil, status.Errorf(codes.Internal, err.Error())
}
segmentMeta = streamMeta.LastSegmentMeta
} else {
err = proto.Unmarshal(pointer.Metadata, segmentMeta)
if err != nil {
return nil, status.Errorf(codes.Internal, err.Error())
}
}
if segmentMeta != nil {
encryptedKeyNonce, err = storj.NonceFromBytes(segmentMeta.KeyNonce)
if err != nil {
return nil, status.Errorf(codes.Internal, "unable to get encryption key nonce from metadata: %v", err.Error())
}
encryptedKey = segmentMeta.EncryptedKey
}
}
if pointer.Type == pb.Pointer_INLINE {
err := endpoint.orders.UpdateGetInlineOrder(ctx, keyInfo.ProjectID, streamID.Bucket, int64(len(pointer.InlineSegment)))
if err != nil {
@ -1688,23 +1724,75 @@ func (endpoint *Endpoint) DownloadSegment(ctx context.Context, req *pb.SegmentDo
}
return &pb.SegmentDownloadResponse{
SegmentId: segmentID,
SegmentSize: pointer.SegmentSize,
EncryptedInlineData: pointer.InlineSegment,
EncryptedKeyNonce: encryptedKeyNonce,
EncryptedKey: encryptedKey,
}, nil
} else if pointer.Type == pb.Pointer_REMOTE && pointer.Remote != nil {
limits, _, err := endpoint.orders.CreateGetOrderLimits(ctx, bucketID, pointer)
limits, privateKey, err := endpoint.orders.CreateGetOrderLimits(ctx, bucketID, pointer)
if err != nil {
return nil, status.Errorf(codes.Internal, err.Error())
}
limits = sortLimits(limits, pointer)
// workaround to avoid sending nil values on top level
for i := range limits {
if limits[i] == nil {
limits[i] = &pb.AddressedOrderLimit{}
}
}
return &pb.SegmentDownloadResponse{
SegmentId: segmentID,
AddressedLimits: limits,
PrivateKey: privateKey,
SegmentSize: pointer.SegmentSize,
EncryptedKeyNonce: encryptedKeyNonce,
EncryptedKey: encryptedKey,
}, nil
}
return &pb.SegmentDownloadResponse{}, status.Errorf(codes.Internal, "invalid type of pointer")
}
func (endpoint *Endpoint) getPointer(ctx context.Context, projectID uuid.UUID, segmentIndex int64, bucket, encryptedPath []byte) (*pb.Pointer, string, error) {
path, err := CreatePath(ctx, projectID, segmentIndex, bucket, encryptedPath)
if err != nil {
return nil, "", status.Errorf(codes.InvalidArgument, err.Error())
}
pointer, err := endpoint.metainfo.Get(ctx, path)
if err != nil {
if storage.ErrKeyNotFound.Has(err) {
return nil, "", status.Errorf(codes.NotFound, err.Error())
}
return nil, "", status.Errorf(codes.Internal, err.Error())
}
return pointer, path, nil
}
// sortLimits sorts order limits and fill missing ones with nil values
func sortLimits(limits []*pb.AddressedOrderLimit, pointer *pb.Pointer) []*pb.AddressedOrderLimit {
sorted := make([]*pb.AddressedOrderLimit, pointer.GetRemote().GetRedundancy().GetTotal())
for _, piece := range pointer.GetRemote().GetRemotePieces() {
sorted[piece.GetPieceNum()] = getLimitByStorageNodeID(limits, piece.NodeId)
}
return sorted
}
func getLimitByStorageNodeID(limits []*pb.AddressedOrderLimit, storageNodeID storj.NodeID) *pb.AddressedOrderLimit {
for _, limit := range limits {
if limit.GetLimit().StorageNodeId == storageNodeID {
return limit
}
}
return nil
}
func (endpoint *Endpoint) packStreamID(ctx context.Context, satStreamID *pb.SatStreamID) (streamID storj.StreamID, err error) {
defer mon.Task()(&ctx)(&err)

152
satellite/metainfo/metainfo_test.go
View File

@ -875,69 +875,6 @@ func TestBucketNameValidation(t *testing.T) {
})
}
func TestBeginCommitObject(t *testing.T) {
testplanet.Run(t, testplanet.Config{
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 1,
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
apiKey := planet.Uplinks[0].APIKey[planet.Satellites[0].ID()]
uplink := planet.Uplinks[0]
config := uplink.GetConfig(planet.Satellites[0])
metainfoService := planet.Satellites[0].Metainfo.Service
projects, err := planet.Satellites[0].DB.Console().Projects().GetAll(ctx)
require.NoError(t, err)
projectID := projects[0].ID
bucket := storj.Bucket{
Name: "initial-bucket",
ProjectID: projectID,
PathCipher: config.GetEncryptionParameters().CipherSuite,
}
_, err = metainfoService.CreateBucket(ctx, bucket)
require.NoError(t, err)
metainfoClient, err := planet.Uplinks[0].DialMetainfo(ctx, planet.Satellites[0], apiKey)
require.NoError(t, err)
defer ctx.Check(metainfoClient.Close)
streamID, err := metainfoClient.BeginObject(ctx, metainfo.BeginObjectParams{
Bucket: []byte(bucket.Name),
EncryptedPath: []byte("encrypted-path"),
Redundancy: storj.RedundancyScheme{},
EncryptionParameters: storj.EncryptionParameters{},
ExpiresAt: time.Time{},
EncryptedMetadataNonce: testrand.Nonce(),
EncryptedMetadata: testrand.Bytes(memory.KiB),
})
require.NoError(t, err)
err = metainfoClient.CommitObject(ctx, streamID)
require.NoError(t, err)
})
}
func TestBeginFinishDeleteObject(t *testing.T) {
testplanet.Run(t, testplanet.Config{
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 1,
}, func(t *testing.T, ctx *testcontext.Context, planet *testplanet.Planet) {
apiKey := planet.Uplinks[0].APIKey[planet.Satellites[0].ID()]
metainfoClient, err := planet.Uplinks[0].DialMetainfo(ctx, planet.Satellites[0], apiKey)
require.NoError(t, err)
defer ctx.Check(metainfoClient.Close)
streamID, err := metainfoClient.BeginDeleteObject(ctx, metainfo.BeginDeleteObjectParams{
Bucket: []byte("initial-bucket"),
EncryptedPath: []byte("encrypted-path"),
})
require.NoError(t, err)
err = metainfoClient.FinishDeleteObject(ctx, streamID)
require.NoError(t, err)
})
}
func TestListGetObjects(t *testing.T) {
testplanet.Run(t, testplanet.Config{
SatelliteCount: 1, StorageNodeCount: 0, UplinkCount: 1,
@ -967,14 +904,14 @@ func TestListGetObjects(t *testing.T) {
require.NotEmpty(t, item.EncryptedPath)
require.True(t, item.CreatedAt.Before(time.Now()))
object, streamID, err := metainfoClient.GetObject(ctx, metainfo.GetObjectParams{
object, err := metainfoClient.GetObject(ctx, metainfo.GetObjectParams{
Bucket: []byte(expectedBucketName),
EncryptedPath: item.EncryptedPath,
})
require.NoError(t, err)
require.Equal(t, item.EncryptedPath, []byte(object.Path))
require.NotEmpty(t, streamID)
require.NotEmpty(t, object.StreamID)
}
items, _, err = metainfoClient.ListObjects(ctx, metainfo.ListObjectsParams{
@ -1023,10 +960,8 @@ func TestBeginCommitListSegment(t *testing.T) {
OptimalShares: 3,
TotalShares: 4,
},
EncryptionParameters: storj.EncryptionParameters{},
ExpiresAt: time.Now().UTC().Add(24 * time.Hour),
EncryptedMetadataNonce: testrand.Nonce(),
EncryptedMetadata: testrand.Bytes(memory.KiB),
EncryptionParameters: storj.EncryptionParameters{},
ExpiresAt: time.Now().UTC().Add(24 * time.Hour),
}
streamID, err := metainfoClient.BeginObject(ctx, params)
require.NoError(t, err)
@ -1034,7 +969,7 @@ func TestBeginCommitListSegment(t *testing.T) {
segmentID, limits, _, err := metainfoClient.BeginSegment(ctx, metainfo.BeginSegmentParams{
StreamID: streamID,
Position: storj.SegmentPosition{
Index: -1,
Index: 0,
},
MaxOderLimit: memory.MiB.Int64(),
})
@ -1052,8 +987,9 @@ func TestBeginCommitListSegment(t *testing.T) {
},
}
}
err = metainfoClient.CommitSegment2(ctx, metainfo.CommitSegmentParams{
SegmentID: segmentID,
err = metainfoClient.CommitSegmentNew(ctx, metainfo.CommitSegmentParams{
SegmentID: segmentID,
SizeEncryptedData: memory.MiB.Int64(),
UploadResult: []*pb.SegmentPieceUploadResult{
makeResult(0),
@ -1063,7 +999,9 @@ func TestBeginCommitListSegment(t *testing.T) {
})
require.NoError(t, err)
err = metainfoClient.CommitObject(ctx, streamID)
err = metainfoClient.CommitObject(ctx, metainfo.CommitObjectParams{
StreamID: streamID,
})
require.NoError(t, err)
objects, _, err := metainfoClient.ListObjects(ctx, metainfo.ListObjectsParams{
@ -1073,17 +1011,16 @@ func TestBeginCommitListSegment(t *testing.T) {
require.Len(t, objects, 1)
require.Equal(t, params.EncryptedPath, objects[0].EncryptedPath)
require.Equal(t, params.EncryptedMetadata, objects[0].EncryptedMetadata)
require.Equal(t, params.ExpiresAt, objects[0].ExpiresAt)
_, streamID, err = metainfoClient.GetObject(ctx, metainfo.GetObjectParams{
object, err := metainfoClient.GetObject(ctx, metainfo.GetObjectParams{
Bucket: []byte(bucket.Name),
EncryptedPath: objects[0].EncryptedPath,
})
require.NoError(t, err)
segments, _, err := metainfoClient.ListSegments2(ctx, metainfo.ListSegmentsParams{
StreamID: streamID,
segments, _, err := metainfoClient.ListSegmentsNew(ctx, metainfo.ListSegmentsParams{
StreamID: object.StreamID,
})
require.NoError(t, err)
require.Len(t, segments, 1)
@ -1138,15 +1075,13 @@ func TestInlineSegment(t *testing.T) {
OptimalShares: 3,
TotalShares: 4,
},
EncryptionParameters: storj.EncryptionParameters{},
ExpiresAt: time.Now().UTC().Add(24 * time.Hour),
EncryptedMetadataNonce: testrand.Nonce(),
EncryptedMetadata: testrand.Bytes(memory.KiB),
EncryptionParameters: storj.EncryptionParameters{},
ExpiresAt: time.Now().UTC().Add(24 * time.Hour),
}
streamID, err := metainfoClient.BeginObject(ctx, params)
require.NoError(t, err)
segments := []int32{0, 1, 2, 3, 4, 5, -1}
segments := []int32{0, 1, 2, 3, 4, 5, 6}
segmentsData := make([][]byte, len(segments))
for i, segment := range segments {
segmentsData[i] = testrand.Bytes(memory.KiB)
@ -1160,7 +1095,9 @@ func TestInlineSegment(t *testing.T) {
require.NoError(t, err)
}
err = metainfoClient.CommitObject(ctx, streamID)
err = metainfoClient.CommitObject(ctx, metainfo.CommitObjectParams{
StreamID: streamID,
})
require.NoError(t, err)
objects, _, err := metainfoClient.ListObjects(ctx, metainfo.ListObjectsParams{
@ -1170,10 +1107,9 @@ func TestInlineSegment(t *testing.T) {
require.Len(t, objects, 1)
require.Equal(t, params.EncryptedPath, objects[0].EncryptedPath)
require.Equal(t, params.EncryptedMetadata, objects[0].EncryptedMetadata)
require.Equal(t, params.ExpiresAt, objects[0].ExpiresAt)
_, streamID, err = metainfoClient.GetObject(ctx, metainfo.GetObjectParams{
object, err := metainfoClient.GetObject(ctx, metainfo.GetObjectParams{
Bucket: params.Bucket,
EncryptedPath: params.EncryptedPath,
})
@ -1192,8 +1128,8 @@ func TestInlineSegment(t *testing.T) {
{Index: 0, Result: len(segments), More: false, Limit: len(segments)},
{Index: 0, Result: len(segments) - 1, More: true, Limit: len(segments) - 1},
} {
items, more, err := metainfoClient.ListSegments2(ctx, metainfo.ListSegmentsParams{
StreamID: streamID,
items, more, err := metainfoClient.ListSegmentsNew(ctx, metainfo.ListSegmentsParams{
StreamID: object.StreamID,
CursorPosition: storj.SegmentPosition{
Index: test.Index,
},
@ -1206,11 +1142,17 @@ func TestInlineSegment(t *testing.T) {
}
{ // test download inline segments
for i, segment := range segments {
items, _, err := metainfoClient.ListSegmentsNew(ctx, metainfo.ListSegmentsParams{
StreamID: object.StreamID,
})
require.NoError(t, err)
require.Equal(t, len(segments), len(items))
for i, item := range items {
info, limits, err := metainfoClient.DownloadSegment(ctx, metainfo.DownloadSegmentParams{
StreamID: streamID,
StreamID: object.StreamID,
Position: storj.SegmentPosition{
Index: segment,
Index: item.Position.Index,
},
})
require.NoError(t, err)
@ -1226,12 +1168,12 @@ func TestInlineSegment(t *testing.T) {
})
require.NoError(t, err)
items, _, err := metainfoClient.ListSegments2(ctx, metainfo.ListSegmentsParams{
items, _, err := metainfoClient.ListSegmentsNew(ctx, metainfo.ListSegmentsParams{
StreamID: streamID,
})
require.NoError(t, err)
for _, item := range items {
segmentID, limits, err := metainfoClient.BeginDeleteSegment(ctx, metainfo.BeginDeleteSegmentParams{
segmentID, limits, _, err := metainfoClient.BeginDeleteSegment(ctx, metainfo.BeginDeleteSegmentParams{
StreamID: streamID,
Position: storj.SegmentPosition{
Index: item.Position.Index,
@ -1246,7 +1188,7 @@ func TestInlineSegment(t *testing.T) {
require.NoError(t, err)
}
items, _, err = metainfoClient.ListSegments2(ctx, metainfo.ListSegmentsParams{
items, _, err = metainfoClient.ListSegmentsNew(ctx, metainfo.ListSegmentsParams{
StreamID: streamID,
})
require.NoError(t, err)
@ -1284,20 +1226,20 @@ func TestRemoteSegment(t *testing.T) {
// List segments
// Download segment
_, streamID, err := metainfoClient.GetObject(ctx, metainfo.GetObjectParams{
object, err := metainfoClient.GetObject(ctx, metainfo.GetObjectParams{
Bucket: []byte(expectedBucketName),
EncryptedPath: items[0].EncryptedPath,
})
require.NoError(t, err)
segments, _, err := metainfoClient.ListSegments2(ctx, metainfo.ListSegmentsParams{
StreamID: streamID,
segments, _, err := metainfoClient.ListSegmentsNew(ctx, metainfo.ListSegmentsParams{
StreamID: object.StreamID,
})
require.NoError(t, err)
require.Len(t, segments, 1)
_, limits, err := metainfoClient.DownloadSegment(ctx, metainfo.DownloadSegmentParams{
StreamID: streamID,
StreamID: object.StreamID,
Position: storj.SegmentPosition{
Index: segments[0].Position.Index,
},
@ -1318,13 +1260,13 @@ func TestRemoteSegment(t *testing.T) {
})
require.NoError(t, err)
segments, _, err := metainfoClient.ListSegments2(ctx, metainfo.ListSegmentsParams{
segments, _, err := metainfoClient.ListSegmentsNew(ctx, metainfo.ListSegmentsParams{
StreamID: streamID,
})
require.NoError(t, err)
for _, segment := range segments {
segmentID, limits, err := metainfoClient.BeginDeleteSegment(ctx, metainfo.BeginDeleteSegmentParams{
segmentID, limits, _, err := metainfoClient.BeginDeleteSegment(ctx, metainfo.BeginDeleteSegmentParams{
StreamID: streamID,
Position: storj.SegmentPosition{
Index: segment.Position.Index,
@ -1363,11 +1305,13 @@ func TestIDs(t *testing.T) {
{
streamID := testrand.StreamID(256)
err = metainfoClient.CommitObject(ctx, streamID)
err = metainfoClient.CommitObject(ctx, metainfo.CommitObjectParams{
StreamID: streamID,
})
require.Error(t, err) // invalid streamID
segmentID := testrand.SegmentID(512)
err = metainfoClient.CommitSegment2(ctx, metainfo.CommitSegmentParams{
err = metainfoClient.CommitSegmentNew(ctx, metainfo.CommitSegmentParams{
SegmentID: segmentID,
})
require.Error(t, err) // invalid segmentID
@ -1387,7 +1331,9 @@ func TestIDs(t *testing.T) {
streamID, err := storj.StreamIDFromBytes(encodedStreamID)
require.NoError(t, err)
err = metainfoClient.CommitObject(ctx, streamID)
err = metainfoClient.CommitObject(ctx, metainfo.CommitObjectParams{
StreamID: streamID,
})
require.Error(t, err)
}
@ -1403,7 +1349,7 @@ func TestIDs(t *testing.T) {
segmentID, err := storj.SegmentIDFromBytes(encodedSegmentID)
require.NoError(t, err)
err = metainfoClient.CommitSegment2(ctx, metainfo.CommitSegmentParams{
err = metainfoClient.CommitSegmentNew(ctx, metainfo.CommitSegmentParams{
SegmentID: segmentID,
})
require.Error(t, err)

12
uplink/eestream/encode.go
View File

@ -19,6 +19,7 @@ import (
"storj.io/storj/pkg/encryption"
"storj.io/storj/pkg/pb"
"storj.io/storj/pkg/ranger"
"storj.io/storj/pkg/storj"
)
// ErasureScheme represents the general format of any erasure scheme algorithm.
@ -106,6 +107,17 @@ func NewRedundancyStrategyFromProto(scheme *pb.RedundancyScheme) (RedundancyStra
return NewRedundancyStrategy(es, int(scheme.GetRepairThreshold()), int(scheme.GetSuccessThreshold()))
}
// NewRedundancyStrategyFromStorj creates new RedundancyStrategy from the given
// storj.RedundancyScheme.
func NewRedundancyStrategyFromStorj(scheme storj.RedundancyScheme) (RedundancyStrategy, error) {
fc, err := infectious.NewFEC(int(scheme.RequiredShares), int(scheme.TotalShares))
if err != nil {
return RedundancyStrategy{}, Error.Wrap(err)
}
es := NewRSScheme(fc, int(scheme.ShareSize))
return NewRedundancyStrategy(es, int(scheme.RepairShares), int(scheme.OptimalShares))
}
// RepairThreshold is the number of available erasure pieces below which
// the data must be repaired to avoid loss
func (rs *RedundancyStrategy) RepairThreshold() int {

146
uplink/metainfo/client.go
View File

@ -4,6 +4,7 @@
package metainfo
import (
"bytes"
"context"
"time"
@ -366,14 +367,12 @@ func convertProtoToBucket(pbBucket *pb.Bucket) (bucket storj.Bucket, err error)
// BeginObjectParams parmaters for BeginObject method
type BeginObjectParams struct {
Bucket []byte
EncryptedPath []byte
Version int32
Redundancy storj.RedundancyScheme
EncryptionParameters storj.EncryptionParameters
ExpiresAt time.Time
EncryptedMetadataNonce storj.Nonce
EncryptedMetadata []byte
Bucket []byte
EncryptedPath []byte
Version int32
Redundancy storj.RedundancyScheme
EncryptionParameters storj.EncryptionParameters
ExpiresAt time.Time
}
// BeginObject begins object creation
@ -381,12 +380,10 @@ func (client *Client) BeginObject(ctx context.Context, params BeginObjectParams)
defer mon.Task()(&ctx)(&err)
response, err := client.client.BeginObject(ctx, &pb.ObjectBeginRequest{
Bucket: params.Bucket,
EncryptedPath: params.EncryptedPath,
Version: params.Version,
ExpiresAt: params.ExpiresAt,
EncryptedMetadataNonce: params.EncryptedMetadataNonce,
EncryptedMetadata: params.EncryptedMetadata,
Bucket: params.Bucket,
EncryptedPath: params.EncryptedPath,
Version: params.Version,
ExpiresAt: params.ExpiresAt,
RedundancyScheme: &pb.RedundancyScheme{
Type: pb.RedundancyScheme_SchemeType(params.Redundancy.Algorithm),
ErasureShareSize: params.Redundancy.ShareSize,
@ -407,12 +404,22 @@ func (client *Client) BeginObject(ctx context.Context, params BeginObjectParams)
return response.StreamId, nil
}
// CommitObjectParams parmaters for CommitObject method
type CommitObjectParams struct {
StreamID storj.StreamID
EncryptedMetadataNonce storj.Nonce
EncryptedMetadata []byte
}
// CommitObject commits created object
func (client *Client) CommitObject(ctx context.Context, streamID storj.StreamID) (err error) {
func (client *Client) CommitObject(ctx context.Context, params CommitObjectParams) (err error) {
defer mon.Task()(&ctx)(&err)
_, err = client.client.CommitObject(ctx, &pb.ObjectCommitRequest{
StreamId: streamID,
StreamId: params.StreamID,
EncryptedMetadataNonce: params.EncryptedMetadataNonce,
EncryptedMetadata: params.EncryptedMetadata,
})
return Error.Wrap(err)
}
@ -425,7 +432,7 @@ type GetObjectParams struct {
}
// GetObject gets single object
func (client *Client) GetObject(ctx context.Context, params GetObjectParams) (_ storj.Object, _ storj.StreamID, err error) {
func (client *Client) GetObject(ctx context.Context, params GetObjectParams) (_ storj.ObjectInfo, err error) {
defer mon.Task()(&ctx)(&err)
response, err := client.client.GetObject(ctx, &pb.ObjectGetRequest{
@ -433,21 +440,46 @@ func (client *Client) GetObject(ctx context.Context, params GetObjectParams) (_
EncryptedPath: params.EncryptedPath,
Version: params.Version,
})
if err != nil {
return storj.Object{}, storj.StreamID{}, Error.Wrap(err)
if status.Code(err) == codes.NotFound {
return storj.ObjectInfo{}, storj.ErrObjectNotFound.Wrap(err)
}
return storj.ObjectInfo{}, Error.Wrap(err)
}
object := storj.Object{
Bucket: storj.Bucket{
Name: string(response.Object.Bucket),
object := storj.ObjectInfo{
Bucket: string(response.Object.Bucket),
Path: storj.Path(response.Object.EncryptedPath),
StreamID: response.Object.StreamId,
Created: response.Object.CreatedAt,
Modified: response.Object.CreatedAt,
Expires: response.Object.ExpiresAt,
Metadata: response.Object.EncryptedMetadata,
Stream: storj.Stream{
Size: response.Object.TotalSize,
EncryptionParameters: storj.EncryptionParameters{
CipherSuite: storj.CipherSuite(response.Object.EncryptionParameters.CipherSuite),
BlockSize: int32(response.Object.EncryptionParameters.BlockSize),
},
},
Path: storj.Path(response.Object.EncryptedPath),
Created: response.Object.CreatedAt,
Expires: response.Object.ExpiresAt,
// TODO custom type for response object or modify storj.Object
}
return object, response.Object.StreamId, nil
pbRS := response.Object.RedundancyScheme
if pbRS != nil {
object.Stream.RedundancyScheme = storj.RedundancyScheme{
Algorithm: storj.RedundancyAlgorithm(pbRS.Type),
ShareSize: pbRS.ErasureShareSize,
RequiredShares: int16(pbRS.MinReq),
RepairShares: int16(pbRS.RepairThreshold),
OptimalShares: int16(pbRS.SuccessThreshold),
TotalShares: int16(pbRS.Total),
}
}
return object, nil
}
// BeginDeleteObjectParams parameters for BeginDeleteObject method
@ -467,6 +499,9 @@ func (client *Client) BeginDeleteObject(ctx context.Context, params BeginDeleteO
Version: params.Version,
})
if err != nil {
if status.Code(err) == codes.NotFound {
return storj.StreamID{}, storj.ErrObjectNotFound.Wrap(err)
}
return storj.StreamID{}, Error.Wrap(err)
}
@ -490,6 +525,7 @@ type ListObjectsParams struct {
EncryptedCursor []byte
Limit int32
IncludeMetadata bool
Recursive bool
}
// ListObjects lists objects according to specific parameters
@ -504,6 +540,7 @@ func (client *Client) ListObjects(ctx context.Context, params ListObjectsParams)
ObjectIncludes: &pb.ObjectListItemIncludes{
Metadata: params.IncludeMetadata,
},
Recursive: params.Recursive,
})
if err != nil {
return []storj.ObjectListItem{}, false, Error.Wrap(err)
@ -511,6 +548,12 @@ func (client *Client) ListObjects(ctx context.Context, params ListObjectsParams)
objects := make([]storj.ObjectListItem, len(response.Items))
for i, object := range response.Items {
encryptedPath := object.EncryptedPath
isPrefix := false
if !params.Recursive && len(encryptedPath) != 0 && encryptedPath[len(encryptedPath)-1] == '/' && !bytes.Equal(encryptedPath, params.EncryptedPrefix) {
isPrefix = true
}
objects[i] = storj.ObjectListItem{
EncryptedPath: object.EncryptedPath,
Version: object.Version,
@ -520,6 +563,8 @@ func (client *Client) ListObjects(ctx context.Context, params ListObjectsParams)
ExpiresAt: object.ExpiresAt,
EncryptedMetadataNonce: object.EncryptedMetadataNonce,
EncryptedMetadata: object.EncryptedMetadata,
IsPrefix: isPrefix,
}
}
@ -555,22 +600,21 @@ func (client *Client) BeginSegment(ctx context.Context, params BeginSegmentParam
// CommitSegmentParams parameters for CommitSegment method
type CommitSegmentParams struct {
SegmentID storj.SegmentID
EncryptedKeyNonce storj.Nonce
EncryptedKey []byte
Encryption storj.SegmentEncryption
SizeEncryptedData int64
// TODO find better way for this
UploadResult []*pb.SegmentPieceUploadResult
}
// CommitSegment2 commits segment after upload
func (client *Client) CommitSegment2(ctx context.Context, params CommitSegmentParams) (err error) {
// TODO method name will be changed when new methods will be fully integrated with client side
// CommitSegmentNew commits segment after upload
func (client *Client) CommitSegmentNew(ctx context.Context, params CommitSegmentParams) (err error) {
defer mon.Task()(&ctx)(&err)
_, err = client.client.CommitSegment(ctx, &pb.SegmentCommitRequest{
SegmentId: params.SegmentID,
EncryptedKeyNonce: params.EncryptedKeyNonce,
EncryptedKey: params.EncryptedKey,
SegmentId: params.SegmentID,
EncryptedKeyNonce: params.Encryption.EncryptedKeyNonce,
EncryptedKey: params.Encryption.EncryptedKey,
SizeEncryptedData: params.SizeEncryptedData,
UploadResult: params.UploadResult,
})
@ -585,8 +629,7 @@ func (client *Client) CommitSegment2(ctx context.Context, params CommitSegmentPa
type MakeInlineSegmentParams struct {
StreamID storj.StreamID
Position storj.SegmentPosition
EncryptedKeyNonce storj.Nonce
EncryptedKey []byte
Encryption storj.SegmentEncryption
EncryptedInlineData []byte
}
@ -600,8 +643,8 @@ func (client *Client) MakeInlineSegment(ctx context.Context, params MakeInlineSe
PartNumber: params.Position.PartNumber,
Index: params.Position.Index,
},
EncryptedKeyNonce: params.EncryptedKeyNonce,
EncryptedKey: params.EncryptedKey,
EncryptedKeyNonce: params.Encryption.EncryptedKeyNonce,
EncryptedKey: params.Encryption.EncryptedKey,
EncryptedInlineData: params.EncryptedInlineData,
})
if err != nil {
@ -618,7 +661,7 @@ type BeginDeleteSegmentParams struct {
}
// BeginDeleteSegment begins segment upload process
func (client *Client) BeginDeleteSegment(ctx context.Context, params BeginDeleteSegmentParams) (_ storj.SegmentID, limits []*pb.AddressedOrderLimit, err error) {
func (client *Client) BeginDeleteSegment(ctx context.Context, params BeginDeleteSegmentParams) (_ storj.SegmentID, limits []*pb.AddressedOrderLimit, _ storj.PiecePrivateKey, err error) {
defer mon.Task()(&ctx)(&err)
response, err := client.client.BeginDeleteSegment(ctx, &pb.SegmentBeginDeleteRequest{
@ -629,16 +672,16 @@ func (client *Client) BeginDeleteSegment(ctx context.Context, params BeginDelete
},
})
if err != nil {
return storj.SegmentID{}, nil, Error.Wrap(err)
return storj.SegmentID{}, nil, storj.PiecePrivateKey{}, Error.Wrap(err)
}
return response.SegmentId, response.AddressedLimits, nil
return response.SegmentId, response.AddressedLimits, response.PrivateKey, nil
}
// FinishDeleteSegmentParams parameters for FinishDeleteSegment method
type FinishDeleteSegmentParams struct {
SegmentID storj.SegmentID
// TODO find better way to pass this
DeleteResults []*pb.SegmentPieceDeleteResult
}
@ -676,7 +719,13 @@ func (client *Client) DownloadSegment(ctx context.Context, params DownloadSegmen
info := storj.SegmentDownloadInfo{
SegmentID: response.SegmentId,
Size: response.SegmentSize,
EncryptedInlineData: response.EncryptedInlineData,
PiecePrivateKey: response.PrivateKey,
SegmentEncryption: storj.SegmentEncryption{
EncryptedKeyNonce: response.EncryptedKeyNonce,
EncryptedKey: response.EncryptedKey,
},
}
if response.Next != nil {
info.Next = storj.SegmentPosition{
@ -685,6 +734,12 @@ func (client *Client) DownloadSegment(ctx context.Context, params DownloadSegmen
}
}
for i := range response.AddressedLimits {
if response.AddressedLimits[i].Limit == nil {
response.AddressedLimits[i] = nil
}
}
return info, response.AddressedLimits, nil
}
@ -695,9 +750,8 @@ type ListSegmentsParams struct {
Limit int32
}
// ListSegments2 lists object segments
func (client *Client) ListSegments2(ctx context.Context, params ListSegmentsParams) (_ []storj.SegmentListItem, more bool, err error) {
// TODO method name will be changed when new methods will be fully integrated with client side
// ListSegmentsNew lists object segments
func (client *Client) ListSegmentsNew(ctx context.Context, params ListSegmentsParams) (_ []storj.SegmentListItem, more bool, err error) {
defer mon.Task()(&ctx)(&err)
response, err := client.client.ListSegments(ctx, &pb.SegmentListRequest{