potyarkin/frostfs-api-go
1
0
Fork 0
forked from TrueCloudLab/frostfs-api-go
Code Pull requests Activity

proto: publish sg lib, rewrite object

Browse source
This commit is contained in:
Evgeniy Kulikov 2019-12-02 17:56:06 +03:00
parent b646388840
commit 0fce8a6ba2
No known key found for this signature in database
GPG key ID: BF6AEE0A2A699BF2
11 changed files with 1011 additions and 696 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

42
docs/object.md
View file

@ -34,8 +34,6 @@
- [Link](#object.Link) - [Link](#object.Link)
- [Object](#object.Object) - [Object](#object.Object)
- [Range](#object.Range) - [Range](#object.Range)
- [StorageGroup](#object.StorageGroup)
- [StorageGroup.Lifetime](#object.StorageGroup.Lifetime)
- [SystemHeader](#object.SystemHeader) - [SystemHeader](#object.SystemHeader)
- [Tombstone](#object.Tombstone) - [Tombstone](#object.Tombstone)
- [Transform](#object.Transform) - [Transform](#object.Transform)
@ -369,7 +367,7 @@ in distributed system.
| HomoHash | [bytes](#bytes) | | HomoHash is a homomorphic hash of original object payload | | HomoHash | [bytes](#bytes) | | HomoHash is a homomorphic hash of original object payload |
| PayloadChecksum | [bytes](#bytes) | | PayloadChecksum of actual object's payload | | PayloadChecksum | [bytes](#bytes) | | PayloadChecksum of actual object's payload |
| Integrity | [IntegrityHeader](#object.IntegrityHeader) | | Integrity header with checksum of all above headers in the object | | Integrity | [IntegrityHeader](#object.IntegrityHeader) | | Integrity header with checksum of all above headers in the object |
| StorageGroup | [StorageGroup](#object.StorageGroup) | | StorageGroup contains meta information for the data audit | | StorageGroup | [storagegroup.StorageGroup](#storagegroup.StorageGroup) | | StorageGroup contains meta information for the data audit |
<a name="object.IntegrityHeader"></a> <a name="object.IntegrityHeader"></a>
@ -421,31 +419,6 @@ in distributed system.
| Length | [uint64](#uint64) | | Length of the data range | | Length | [uint64](#uint64) | | Length of the data range |
<a name="object.StorageGroup"></a>
### Message StorageGroup
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| ValidationDataSize | [uint64](#uint64) | | ValidationDataSize is size of the all object's payloads included into storage group |
| ValidationHash | [bytes](#bytes) | | ValidationHash is homomorphic hash of all object's payloads included into storage group |
| lifetime | [StorageGroup.Lifetime](#object.StorageGroup.Lifetime) | | Lifetime is time until storage group is valid |
<a name="object.StorageGroup.Lifetime"></a>
### Message StorageGroup.Lifetime
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| unit | [StorageGroup.Lifetime.Unit](#object.StorageGroup.Lifetime.Unit) | | Unit is lifetime type |
| Value | [int64](#int64) | | Value for lifetime |
<a name="object.SystemHeader"></a> <a name="object.SystemHeader"></a>
### Message SystemHeader ### Message SystemHeader
@ -514,19 +487,6 @@ in distributed system.
<a name="object.StorageGroup.Lifetime.Unit"></a>
### StorageGroup.Lifetime.Unit
| Name | Number | Description |
| ---- | ------ | ----------- |
| Unlimited | 0 | Unlimited set if storage group always valid |
| NeoFSEpoch | 1 | NeoFSEpoch set if storage group is valid until lifetime NeoFS epoch |
| UnixTime | 2 | UnixTime set if storage group is valid until lifetime unix timestamp |
<a name="object.Transform.Type"></a> <a name="object.Transform.Type"></a>
### Transform.Type ### Transform.Type

88
docs/storagegroup.md Normal file
View file

@ -0,0 +1,88 @@
# Protocol Documentation
<a name="top"></a>
## Table of Contents
- [storagegroup/types.proto](#storagegroup/types.proto)
- Messages
- [StorageGroup](#storagegroup.StorageGroup)
- [StorageGroup.Lifetime](#storagegroup.StorageGroup.Lifetime)
- [Scalar Value Types](#scalar-value-types)
<a name="storagegroup/types.proto"></a>
<p align="right"><a href="#top">Top</a></p>
## storagegroup/types.proto
<!-- end services -->
<a name="storagegroup.StorageGroup"></a>
### Message StorageGroup
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| ValidationDataSize | [uint64](#uint64) | | ValidationDataSize is size of the all object's payloads included into storage group |
| ValidationHash | [bytes](#bytes) | | ValidationHash is homomorphic hash of all object's payloads included into storage group |
| lifetime | [StorageGroup.Lifetime](#storagegroup.StorageGroup.Lifetime) | | Lifetime is time until storage group is valid |
<a name="storagegroup.StorageGroup.Lifetime"></a>
### Message StorageGroup.Lifetime
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| unit | [StorageGroup.Lifetime.Unit](#storagegroup.StorageGroup.Lifetime.Unit) | | Unit is lifetime type |
| Value | [int64](#int64) | | Value for lifetime |
<!-- end messages -->
<a name="storagegroup.StorageGroup.Lifetime.Unit"></a>
### StorageGroup.Lifetime.Unit
| Name | Number | Description |
| ---- | ------ | ----------- |
| Unlimited | 0 | Unlimited set if storage group always valid |
| NeoFSEpoch | 1 | NeoFSEpoch set if storage group is valid until lifetime NeoFS epoch |
| UnixTime | 2 | UnixTime set if storage group is valid until lifetime unix timestamp |
<!-- end enums -->
## Scalar Value Types
| .proto Type | Notes | C++ Type | Java Type | Python Type |
| ----------- | ----- | -------- | --------- | ----------- |
| <a name="double" /> double | | double | double | float |
| <a name="float" /> float | | float | float | float |
| <a name="int32" /> int32 | Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint32 instead. | int32 | int | int |
| <a name="int64" /> int64 | Uses variable-length encoding. Inefficient for encoding negative numbers – if your field is likely to have negative values, use sint64 instead. | int64 | long | int/long |
| <a name="uint32" /> uint32 | Uses variable-length encoding. | uint32 | int | int/long |
| <a name="uint64" /> uint64 | Uses variable-length encoding. | uint64 | long | int/long |
| <a name="sint32" /> sint32 | Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int32s. | int32 | int | int |
| <a name="sint64" /> sint64 | Uses variable-length encoding. Signed int value. These more efficiently encode negative numbers than regular int64s. | int64 | long | int/long |
| <a name="fixed32" /> fixed32 | Always four bytes. More efficient than uint32 if values are often greater than 2^28. | uint32 | int | int |
| <a name="fixed64" /> fixed64 | Always eight bytes. More efficient than uint64 if values are often greater than 2^56. | uint64 | long | int/long |
| <a name="sfixed32" /> sfixed32 | Always four bytes. | int32 | int | int |
| <a name="sfixed64" /> sfixed64 | Always eight bytes. | int64 | long | int/long |
| <a name="bool" /> bool | | bool | boolean | boolean |
| <a name="string" /> string | A string must always contain UTF-8 encoded or 7-bit ASCII text. | string | String | str/unicode |
| <a name="bytes" /> bytes | May contain any arbitrary sequence of bytes. | string | ByteString | str |

15
object/extensions.go
View file

@ -1,8 +1,6 @@
package object package object
import ( import "github.com/nspcc-dev/neofs-proto/storagegroup"
"github.com/nspcc-dev/neofs-proto/hash"
)
// IsLinking checks if object has children links to another objects. // IsLinking checks if object has children links to another objects.
// We have to check payload size because zero-object must have zero // We have to check payload size because zero-object must have zero
@ -64,7 +62,7 @@ func (m Object) IsTombstone() bool {
} }
// StorageGroup returns storage group structure if it is presented in extended headers. // StorageGroup returns storage group structure if it is presented in extended headers.
func (m Object) StorageGroup() (*StorageGroup, error) { func (m Object) StorageGroup() (*storagegroup.StorageGroup, error) {
_, sgHdr := m.LastHeader(HeaderType(StorageGroupHdr)) _, sgHdr := m.LastHeader(HeaderType(StorageGroupHdr))
if sgHdr == nil { if sgHdr == nil {
return nil, ErrHeaderNotFound return nil, ErrHeaderNotFound
@ -74,11 +72,6 @@ func (m Object) StorageGroup() (*StorageGroup, error) {
// SetStorageGroup sets storage group header in the object. // SetStorageGroup sets storage group header in the object.
// It will replace existing storage group header or add a new one. // It will replace existing storage group header or add a new one.
func (m *Object) SetStorageGroup(sg *StorageGroup) { func (m *Object) SetStorageGroup(group *storagegroup.StorageGroup) {
m.SetHeader(&Header{Value: &Header_StorageGroup{StorageGroup: sg}}) m.SetHeader(&Header{Value: &Header_StorageGroup{StorageGroup: group}})
}
// Empty checks if storage group has some data for validation.
func (m StorageGroup) Empty() bool {
return m.ValidationDataSize == 0 && m.ValidationHash.Equal(hash.Hash{})
} }

43
object/sg.go
View file

@ -1,54 +1,31 @@
package object package object
import ( import (
"bytes"
"sort" "sort"
"github.com/nspcc-dev/neofs-proto/refs"
"github.com/nspcc-dev/neofs-proto/storagegroup"
) )
// Here are defined getter functions for objects that contain storage group // Here are defined getter functions for objects that contain storage group
// information. // information.
type ( var _ storagegroup.Provider = (*Object)(nil)
// IDList is a slice of object ids, that can be sorted.
IDList []ID
// ZoneInfo provides validation info of storage group.
ZoneInfo struct {
Hash
Size uint64
}
// IdentificationInfo provides meta information about storage group.
IdentificationInfo struct {
SGID
CID
OwnerID
}
)
// Len returns amount of object ids in IDList.
func (s IDList) Len() int { return len(s) }
// Less returns byte comparision between IDList[i] and IDList[j].
func (s IDList) Less(i, j int) bool { return bytes.Compare(s[i].Bytes(), s[j].Bytes()) == -1 }
// Swap swaps element with i and j index in IDList.
func (s IDList) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
// Group returns slice of object ids that are part of a storage group. // Group returns slice of object ids that are part of a storage group.
func (m *Object) Group() []ID { func (m *Object) Group() []refs.ObjectID {
sgLinks := m.Links(Link_StorageGroup) sgLinks := m.Links(Link_StorageGroup)
sort.Sort(IDList(sgLinks)) sort.Sort(storagegroup.IDList(sgLinks))
return sgLinks return sgLinks
} }
// Zones returns validation zones of storage group. // Zones returns validation zones of storage group.
func (m *Object) Zones() []ZoneInfo { func (m *Object) Zones() []storagegroup.ZoneInfo {
sgInfo, err := m.StorageGroup() sgInfo, err := m.StorageGroup()
if err != nil { if err != nil {
return nil return nil
} }
return []ZoneInfo{ return []storagegroup.ZoneInfo{
{ {
Hash: sgInfo.ValidationHash, Hash: sgInfo.ValidationHash,
Size: sgInfo.ValidationDataSize, Size: sgInfo.ValidationDataSize,
@ -57,8 +34,8 @@ func (m *Object) Zones() []ZoneInfo {
} }
// IDInfo returns meta information about storage group. // IDInfo returns meta information about storage group.
func (m *Object) IDInfo() *IdentificationInfo { func (m *Object) IDInfo() *storagegroup.IdentificationInfo {
return &IdentificationInfo{ return &storagegroup.IdentificationInfo{
SGID: m.SystemHeader.ID, SGID: m.SystemHeader.ID,
CID: m.SystemHeader.CID, CID: m.SystemHeader.CID,
OwnerID: m.SystemHeader.OwnerID, OwnerID: m.SystemHeader.OwnerID,

5
object/sg_test.go
View file

@ -6,6 +6,7 @@ import (
"testing" "testing"
"github.com/nspcc-dev/neofs-proto/hash" "github.com/nspcc-dev/neofs-proto/hash"
"github.com/nspcc-dev/neofs-proto/storagegroup"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
@ -28,7 +29,7 @@ func TestObject_StorageGroup(t *testing.T) {
} }
rand.Shuffle(len(obj.Headers), func(i, j int) { obj.Headers[i], obj.Headers[j] = obj.Headers[j], obj.Headers[i] }) rand.Shuffle(len(obj.Headers), func(i, j int) { obj.Headers[i], obj.Headers[j] = obj.Headers[j], obj.Headers[i] })
sort.Sort(IDList(idList)) sort.Sort(storagegroup.IDList(idList))
require.Equal(t, idList, obj.Group()) require.Equal(t, idList, obj.Group())
}) })
t.Run("identification method", func(t *testing.T) { t.Run("identification method", func(t *testing.T) {
@ -58,7 +59,7 @@ func TestObject_StorageGroup(t *testing.T) {
Headers: []Header{ Headers: []Header{
{ {
Value: &Header_StorageGroup{ Value: &Header_StorageGroup{
StorageGroup: &StorageGroup{ StorageGroup: &storagegroup.StorageGroup{
ValidationDataSize: sgSize, ValidationDataSize: sgSize,
ValidationHash: sgHash, ValidationHash: sgHash,
}, },

633
object/types.pb.go
View file

@ -9,6 +9,7 @@ import (
proto "github.com/golang/protobuf/proto" proto "github.com/golang/protobuf/proto"
refs "github.com/nspcc-dev/neofs-proto/refs" refs "github.com/nspcc-dev/neofs-proto/refs"
session "github.com/nspcc-dev/neofs-proto/session" session "github.com/nspcc-dev/neofs-proto/session"
storagegroup "github.com/nspcc-dev/neofs-proto/storagegroup"
io "io" io "io"
math "math" math "math"
math_bits "math/bits" math_bits "math/bits"
@ -101,37 +102,6 @@ func (Transform_Type) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_02021a1d39b1aee0, []int{8, 0} return fileDescriptor_02021a1d39b1aee0, []int{8, 0}
} }
type StorageGroup_Lifetime_Unit int32
const (
// Unlimited set if storage group always valid
StorageGroup_Lifetime_Unlimited StorageGroup_Lifetime_Unit = 0
// NeoFSEpoch set if storage group is valid until lifetime NeoFS epoch
StorageGroup_Lifetime_NeoFSEpoch StorageGroup_Lifetime_Unit = 1
// UnixTime set if storage group is valid until lifetime unix timestamp
StorageGroup_Lifetime_UnixTime StorageGroup_Lifetime_Unit = 2
)
var StorageGroup_Lifetime_Unit_name = map[int32]string{
0: "Unlimited",
1: "NeoFSEpoch",
2: "UnixTime",
}
var StorageGroup_Lifetime_Unit_value = map[string]int32{
"Unlimited": 0,
"NeoFSEpoch": 1,
"UnixTime": 2,
}
func (x StorageGroup_Lifetime_Unit) String() string {
return proto.EnumName(StorageGroup_Lifetime_Unit_name, int32(x))
}
func (StorageGroup_Lifetime_Unit) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_02021a1d39b1aee0, []int{10, 0, 0}
}
type Range struct { type Range struct {
// Offset of the data range // Offset of the data range
Offset uint64 `protobuf:"varint,1,opt,name=Offset,proto3" json:"Offset,omitempty"` Offset uint64 `protobuf:"varint,1,opt,name=Offset,proto3" json:"Offset,omitempty"`
@ -319,7 +289,7 @@ type Header_Integrity struct {
Integrity *IntegrityHeader `protobuf:"bytes,9,opt,name=Integrity,proto3,oneof" json:"Integrity,omitempty"` Integrity *IntegrityHeader `protobuf:"bytes,9,opt,name=Integrity,proto3,oneof" json:"Integrity,omitempty"`
} }
type Header_StorageGroup struct { type Header_StorageGroup struct {
StorageGroup *StorageGroup `protobuf:"bytes,10,opt,name=StorageGroup,proto3,oneof" json:"StorageGroup,omitempty"` StorageGroup *storagegroup.StorageGroup `protobuf:"bytes,10,opt,name=StorageGroup,proto3,oneof" json:"StorageGroup,omitempty"`
} }
func (*Header_Link) isHeader_Value() {} func (*Header_Link) isHeader_Value() {}
@ -396,7 +366,7 @@ func (m *Header) GetIntegrity() *IntegrityHeader {
return nil return nil
} }
func (m *Header) GetStorageGroup() *StorageGroup { func (m *Header) GetStorageGroup() *storagegroup.StorageGroup {
if x, ok := m.GetValue().(*Header_StorageGroup); ok { if x, ok := m.GetValue().(*Header_StorageGroup); ok {
return x.StorageGroup return x.StorageGroup
} }
@ -789,118 +759,9 @@ func (m *Object) GetPayload() []byte {
return nil return nil
} }
type StorageGroup struct {
// ValidationDataSize is size of the all object's payloads included into storage group
ValidationDataSize uint64 `protobuf:"varint,1,opt,name=ValidationDataSize,proto3" json:"ValidationDataSize,omitempty"`
// ValidationHash is homomorphic hash of all object's payloads included into storage group
ValidationHash Hash `protobuf:"bytes,2,opt,name=ValidationHash,proto3,customtype=Hash" json:"ValidationHash"`
// Lifetime is time until storage group is valid
Lifetime *StorageGroup_Lifetime `protobuf:"bytes,3,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *StorageGroup) Reset() { *m = StorageGroup{} }
func (m *StorageGroup) String() string { return proto.CompactTextString(m) }
func (*StorageGroup) ProtoMessage() {}
func (*StorageGroup) Descriptor() ([]byte, []int) {
return fileDescriptor_02021a1d39b1aee0, []int{10}
}
func (m *StorageGroup) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *StorageGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
func (m *StorageGroup) XXX_Merge(src proto.Message) {
xxx_messageInfo_StorageGroup.Merge(m, src)
}
func (m *StorageGroup) XXX_Size() int {
return m.Size()
}
func (m *StorageGroup) XXX_DiscardUnknown() {
xxx_messageInfo_StorageGroup.DiscardUnknown(m)
}
var xxx_messageInfo_StorageGroup proto.InternalMessageInfo
func (m *StorageGroup) GetValidationDataSize() uint64 {
if m != nil {
return m.ValidationDataSize
}
return 0
}
func (m *StorageGroup) GetLifetime() *StorageGroup_Lifetime {
if m != nil {
return m.Lifetime
}
return nil
}
type StorageGroup_Lifetime struct {
// Unit is lifetime type
Unit StorageGroup_Lifetime_Unit `protobuf:"varint,1,opt,name=unit,proto3,enum=object.StorageGroup_Lifetime_Unit" json:"unit,omitempty"`
// Value for lifetime
Value int64 `protobuf:"varint,2,opt,name=Value,proto3" json:"Value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *StorageGroup_Lifetime) Reset() { *m = StorageGroup_Lifetime{} }
func (m *StorageGroup_Lifetime) String() string { return proto.CompactTextString(m) }
func (*StorageGroup_Lifetime) ProtoMessage() {}
func (*StorageGroup_Lifetime) Descriptor() ([]byte, []int) {
return fileDescriptor_02021a1d39b1aee0, []int{10, 0}
}
func (m *StorageGroup_Lifetime) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *StorageGroup_Lifetime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
func (m *StorageGroup_Lifetime) XXX_Merge(src proto.Message) {
xxx_messageInfo_StorageGroup_Lifetime.Merge(m, src)
}
func (m *StorageGroup_Lifetime) XXX_Size() int {
return m.Size()
}
func (m *StorageGroup_Lifetime) XXX_DiscardUnknown() {
xxx_messageInfo_StorageGroup_Lifetime.DiscardUnknown(m)
}
var xxx_messageInfo_StorageGroup_Lifetime proto.InternalMessageInfo
func (m *StorageGroup_Lifetime) GetUnit() StorageGroup_Lifetime_Unit {
if m != nil {
return m.Unit
}
return StorageGroup_Lifetime_Unlimited
}
func (m *StorageGroup_Lifetime) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
}
func init() { func init() {
proto.RegisterEnum("object.Link_Type", Link_Type_name, Link_Type_value) proto.RegisterEnum("object.Link_Type", Link_Type_name, Link_Type_value)
proto.RegisterEnum("object.Transform_Type", Transform_Type_name, Transform_Type_value) proto.RegisterEnum("object.Transform_Type", Transform_Type_name, Transform_Type_value)
proto.RegisterEnum("object.StorageGroup_Lifetime_Unit", StorageGroup_Lifetime_Unit_name, StorageGroup_Lifetime_Unit_value)
proto.RegisterType((*Range)(nil), "object.Range") proto.RegisterType((*Range)(nil), "object.Range")
proto.RegisterType((*UserHeader)(nil), "object.UserHeader") proto.RegisterType((*UserHeader)(nil), "object.UserHeader")
proto.RegisterType((*Header)(nil), "object.Header") proto.RegisterType((*Header)(nil), "object.Header")
@ -911,77 +772,67 @@ func init() {
proto.RegisterType((*Link)(nil), "object.Link") proto.RegisterType((*Link)(nil), "object.Link")
proto.RegisterType((*Transform)(nil), "object.Transform") proto.RegisterType((*Transform)(nil), "object.Transform")
proto.RegisterType((*Object)(nil), "object.Object") proto.RegisterType((*Object)(nil), "object.Object")
proto.RegisterType((*StorageGroup)(nil), "object.StorageGroup")
proto.RegisterType((*StorageGroup_Lifetime)(nil), "object.StorageGroup.Lifetime")
} }
func init() { proto.RegisterFile("object/types.proto", fileDescriptor_02021a1d39b1aee0) } func init() { proto.RegisterFile("object/types.proto", fileDescriptor_02021a1d39b1aee0) }
var fileDescriptor_02021a1d39b1aee0 = []byte{ var fileDescriptor_02021a1d39b1aee0 = []byte{
// 996 bytes of a gzipped FileDescriptorProto // 867 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x55, 0xdf, 0x6e, 0xe3, 0xc4, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x55, 0x4d, 0x73, 0xdb, 0x44,
0x17, 0xb6, 0x1d, 0x27, 0x71, 0x4e, 0xdd, 0xd6, 0x3b, 0xbf, 0xfd, 0x2d, 0x56, 0xd1, 0xb6, 0xc5, 0x18, 0x96, 0x64, 0xf9, 0xeb, 0xb5, 0xd2, 0xa8, 0x4b, 0x29, 0x1a, 0x33, 0x38, 0x41, 0xc3, 0x47,
0xe2, 0x4f, 0x59, 0xa8, 0x2b, 0xda, 0x45, 0x2b, 0x90, 0x40, 0x34, 0x0d, 0x6c, 0x22, 0xca, 0xb6, 0x28, 0x44, 0x19, 0x52, 0x98, 0x0e, 0x07, 0x18, 0xe2, 0x98, 0x41, 0x1e, 0x0a, 0xc9, 0x6c, 0x3e,
0x9a, 0xb4, 0xbd, 0xe0, 0xce, 0x89, 0x27, 0xc9, 0xd0, 0x64, 0x26, 0xb2, 0x27, 0xbb, 0x1b, 0x1e, 0x0e, 0xdc, 0x64, 0x6b, 0x2d, 0x8b, 0xd8, 0xbb, 0x9e, 0xdd, 0x75, 0x5b, 0xdf, 0xf9, 0x05, 0x9c,
0x83, 0x1b, 0xb8, 0xe3, 0x75, 0xf6, 0x92, 0x3b, 0xd0, 0x5e, 0x44, 0x28, 0x3c, 0x00, 0x6f, 0x80, 0xb8, 0xf1, 0x77, 0x7a, 0xe4, 0xc8, 0xf4, 0x90, 0x61, 0xc2, 0x0f, 0xe0, 0x2f, 0x74, 0x76, 0x25,
0xd0, 0x8c, 0xc7, 0x49, 0x9c, 0xad, 0xb8, 0x89, 0xe6, 0x9c, 0xef, 0xfb, 0x46, 0x27, 0xe7, 0x7c, 0xd9, 0x92, 0xdb, 0x8b, 0x67, 0xdf, 0xe7, 0x63, 0xfd, 0xea, 0xdd, 0x67, 0x25, 0x40, 0x6c, 0xf4,
0x67, 0x0c, 0x88, 0x77, 0x7e, 0x20, 0x5d, 0x71, 0x24, 0xa6, 0x63, 0x92, 0x86, 0xe3, 0x84, 0x0b, 0x1b, 0x19, 0xcb, 0x23, 0xb9, 0x5a, 0x10, 0x11, 0x2c, 0x38, 0x93, 0x0c, 0x35, 0x32, 0xac, 0xeb,
0x8e, 0x2a, 0x59, 0x6e, 0xc7, 0x4b, 0x48, 0x2f, 0x5d, 0x45, 0x76, 0xfe, 0x97, 0x92, 0x34, 0xa5, 0x72, 0x32, 0x11, 0x65, 0xa6, 0xfb, 0x8e, 0x20, 0x42, 0xa4, 0x8c, 0x56, 0x40, 0x4f, 0x48, 0xc6,
0x9c, 0x15, 0x92, 0x87, 0x7d, 0x2a, 0x06, 0x93, 0x4e, 0xd8, 0xe5, 0xa3, 0xa3, 0x3e, 0xef, 0xf3, 0xa3, 0x84, 0x24, 0x9c, 0x2d, 0x17, 0x15, 0xe6, 0x30, 0x49, 0xe5, 0x74, 0x39, 0x0a, 0xc6, 0x6c,
0x23, 0x95, 0xee, 0x4c, 0x7a, 0x2a, 0x52, 0x81, 0x3a, 0x65, 0xf4, 0xe0, 0x09, 0x94, 0x71, 0xc4, 0x7e, 0x94, 0xb0, 0x84, 0x1d, 0x69, 0x78, 0xb4, 0x9c, 0xe8, 0x4a, 0x17, 0x7a, 0x95, 0xc9, 0xfd,
0xfa, 0x04, 0x3d, 0x80, 0xca, 0x45, 0xaf, 0x97, 0x12, 0xe1, 0x9b, 0xfb, 0xe6, 0x81, 0x8d, 0x75, 0x27, 0x50, 0xc7, 0x11, 0x4d, 0x08, 0x7a, 0x08, 0x8d, 0xb3, 0xc9, 0x44, 0x10, 0xe9, 0x99, 0xfb,
0x24, 0xf3, 0xe7, 0x84, 0xf5, 0xc5, 0xc0, 0xb7, 0xb2, 0x7c, 0x16, 0x05, 0x8f, 0x01, 0xae, 0x53, 0xe6, 0x81, 0x8d, 0xf3, 0x4a, 0xe1, 0x4f, 0x09, 0x4d, 0xe4, 0xd4, 0xb3, 0x32, 0x3c, 0xab, 0xfc,
0x92, 0x34, 0x49, 0x14, 0x93, 0x04, 0x79, 0x50, 0xfa, 0x96, 0x4c, 0x95, 0xb4, 0x86, 0xe5, 0x11, 0xaf, 0x00, 0xae, 0x04, 0xe1, 0x21, 0x89, 0x62, 0xc2, 0x91, 0x0b, 0xb5, 0x9f, 0xc8, 0x4a, 0x5b,
0xdd, 0x87, 0xf2, 0x4d, 0x34, 0x9c, 0x10, 0x25, 0xab, 0xe1, 0x2c, 0x08, 0xfe, 0x29, 0x41, 0x45, 0xdb, 0x58, 0x2d, 0xd1, 0x03, 0xa8, 0x5f, 0x47, 0xb3, 0x25, 0xd1, 0xb6, 0x36, 0xce, 0x0a, 0xff,
0x4b, 0x02, 0xb0, 0xcf, 0x29, 0xbb, 0x55, 0x9a, 0x8d, 0x63, 0x37, 0xcc, 0xfe, 0x66, 0x28, 0x73, 0x77, 0x1b, 0x1a, 0xb9, 0xc5, 0x07, 0xfb, 0x69, 0x4a, 0x6f, 0xb4, 0xa7, 0x73, 0xec, 0x04, 0xd9,
0x4d, 0x03, 0x2b, 0x0c, 0x7d, 0x04, 0x0e, 0x26, 0x31, 0x4d, 0x48, 0x57, 0xa8, 0x7b, 0x36, 0x8e, 0x00, 0x02, 0x85, 0x85, 0x06, 0xd6, 0x1c, 0xfa, 0x1c, 0x5a, 0x98, 0xc4, 0x29, 0x27, 0x63, 0xa9,
0x37, 0x43, 0xd9, 0x86, 0xf0, 0x34, 0x8e, 0x13, 0x92, 0xa6, 0x4d, 0x03, 0x2f, 0x08, 0xa8, 0x50, 0xf7, 0xe9, 0x1c, 0xef, 0x04, 0x6a, 0x40, 0xc1, 0x49, 0x1c, 0x73, 0x22, 0x44, 0x68, 0xe0, 0xb5,
0x91, 0x5f, 0x52, 0x74, 0x94, 0x5f, 0xbb, 0x44, 0x9a, 0x06, 0x5e, 0xad, 0xfc, 0x13, 0xa8, 0x5d, 0x00, 0x55, 0x3a, 0xf2, 0x6a, 0x5a, 0x8e, 0x8a, 0x6d, 0x37, 0x4c, 0x68, 0xe0, 0x72, 0xe7, 0x5f,
0x25, 0x11, 0x4b, 0x7b, 0x3c, 0x19, 0xf9, 0xb6, 0x12, 0xdd, 0xcb, 0x45, 0x0b, 0xa0, 0x69, 0xe0, 0x42, 0xfb, 0x92, 0x47, 0x54, 0x4c, 0x18, 0x9f, 0x7b, 0xb6, 0x36, 0xdd, 0x2f, 0x4c, 0x6b, 0x22,
0x25, 0x4b, 0x49, 0xf8, 0xa8, 0x93, 0x0a, 0xce, 0x88, 0x5f, 0x5e, 0x93, 0xe4, 0x80, 0x92, 0xe4, 0x34, 0xf0, 0x46, 0xa5, 0x2d, 0x6c, 0x3e, 0x12, 0x92, 0x51, 0xe2, 0xd5, 0xb7, 0x2c, 0x05, 0xa1,
0x01, 0xfa, 0x14, 0x2a, 0x37, 0x24, 0xa1, 0xbd, 0xa9, 0x5f, 0x51, 0xfc, 0xb7, 0x43, 0x3d, 0xbb, 0x2d, 0x45, 0x81, 0xbe, 0x86, 0xc6, 0x35, 0xe1, 0xe9, 0x64, 0xe5, 0x35, 0xb4, 0xfe, 0xfd, 0x20,
0x50, 0xa5, 0x69, 0x37, 0x12, 0x94, 0xb3, 0x45, 0x81, 0x9a, 0x8c, 0xde, 0x07, 0xa7, 0xc9, 0x47, 0x3f, 0xd5, 0x40, 0xc3, 0xe9, 0x38, 0x92, 0x29, 0xa3, 0xeb, 0x06, 0x73, 0x31, 0xfa, 0x04, 0x5a,
0xbc, 0x19, 0xa5, 0x03, 0xbf, 0xba, 0x6f, 0x1e, 0xb8, 0x75, 0xe7, 0xf5, 0x6c, 0xcf, 0x96, 0xb1, 0x21, 0x9b, 0xb3, 0x30, 0x12, 0x53, 0xaf, 0xb9, 0x6f, 0x1e, 0x38, 0xfd, 0xd6, 0xab, 0xdb, 0x3d,
0xfc, 0xeb, 0x39, 0x86, 0x1e, 0xc1, 0xf6, 0x65, 0x34, 0x1d, 0xf2, 0x28, 0x3e, 0x1b, 0x90, 0xee, 0x5b, 0xd5, 0xea, 0xd1, 0x0b, 0x0e, 0x3d, 0x82, 0xdd, 0xf3, 0x68, 0x35, 0x63, 0x51, 0x7c, 0x3a,
0x6d, 0x3a, 0x19, 0xf9, 0x8e, 0xa4, 0x37, 0x0d, 0xbc, 0x0e, 0xa0, 0x27, 0x50, 0x6b, 0x31, 0x41, 0x25, 0xe3, 0x1b, 0xb1, 0x9c, 0x7b, 0x2d, 0x25, 0x0f, 0x0d, 0xbc, 0x4d, 0xa0, 0x27, 0xd0, 0x1e,
0xfa, 0x09, 0x15, 0x53, 0xbf, 0xa6, 0xaa, 0x79, 0x2b, 0xaf, 0x7e, 0x01, 0x2c, 0x2a, 0x59, 0x72, 0x52, 0x49, 0x12, 0x9e, 0xca, 0x95, 0xd7, 0xd6, 0xdd, 0xbc, 0x57, 0x74, 0xbf, 0x26, 0xd6, 0x9d,
0xd1, 0xe7, 0xe0, 0xb6, 0x05, 0x4f, 0xa2, 0x3e, 0x79, 0x9a, 0xf0, 0xc9, 0xd8, 0x07, 0xa5, 0xbd, 0x6c, 0xb4, 0xe8, 0x7b, 0x70, 0x2e, 0xb2, 0xd4, 0xfd, 0xa8, 0x52, 0xe7, 0x81, 0xf6, 0x76, 0x83,
0x9f, 0x6b, 0x57, 0xb1, 0xa6, 0x81, 0x0b, 0xdc, 0x7a, 0x55, 0xbb, 0x21, 0x78, 0x67, 0xa5, 0x77, 0x72, 0x14, 0x83, 0xb2, 0x22, 0x34, 0x70, 0xc5, 0xd1, 0x6f, 0xe6, 0x99, 0xf0, 0x3f, 0x2c, 0x4d,
0xd2, 0x23, 0x5f, 0x8f, 0x79, 0x77, 0xa0, 0x2d, 0x97, 0x05, 0xc1, 0xdf, 0x26, 0xb8, 0xed, 0x69, 0x50, 0x25, 0xe5, 0x87, 0x05, 0x1b, 0x4f, 0xf3, 0xe0, 0x65, 0x85, 0xff, 0xbf, 0x09, 0xce, 0xc5,
0x2a, 0xc8, 0x48, 0x8f, 0xc8, 0x87, 0xea, 0x0d, 0x49, 0x64, 0xb7, 0x34, 0x31, 0x0f, 0xd1, 0xbb, 0x4a, 0x48, 0x32, 0xcf, 0x0f, 0xca, 0x83, 0xe6, 0x35, 0xe1, 0x6a, 0x66, 0xb9, 0xb0, 0x28, 0xd1,
0xb0, 0xa9, 0xff, 0x5e, 0xc1, 0xa3, 0xc5, 0x24, 0xda, 0x01, 0xab, 0xd5, 0x50, 0x86, 0x70, 0xeb, 0x47, 0xb0, 0x93, 0x3f, 0x64, 0x25, 0xa9, 0x55, 0x10, 0x75, 0xc1, 0x1a, 0x0e, 0x74, 0x2c, 0x9c,
0xf0, 0x6a, 0xb6, 0x67, 0xbc, 0x9e, 0xed, 0x59, 0xad, 0x06, 0xb6, 0x5a, 0x0d, 0xf4, 0x21, 0x54, 0x3e, 0xbc, 0xbc, 0xdd, 0x33, 0x5e, 0xdd, 0xee, 0x59, 0xc3, 0x01, 0xb6, 0x86, 0x03, 0xf4, 0x19,
0x2f, 0x5e, 0x30, 0x92, 0xb4, 0x1a, 0x6a, 0xf8, 0x6e, 0x7d, 0x5b, 0x13, 0xf2, 0x34, 0xce, 0x0f, 0x34, 0xcf, 0x9e, 0x53, 0xc2, 0x87, 0x03, 0x1d, 0x01, 0xa7, 0xbf, 0x9b, 0x0b, 0x0a, 0x18, 0x17,
0xe8, 0x21, 0x94, 0xce, 0x5a, 0x0d, 0x35, 0x70, 0xb7, 0xbe, 0xa1, 0x69, 0x32, 0x85, 0xe5, 0x0f, 0x0b, 0xf4, 0x01, 0xd4, 0x4e, 0x87, 0x03, 0x7d, 0xec, 0x4e, 0xbf, 0x93, 0xcb, 0x14, 0x84, 0xd5,
0xfa, 0x0c, 0x6a, 0x67, 0x09, 0x89, 0x04, 0x89, 0x4f, 0x85, 0x9e, 0xf2, 0xff, 0xf3, 0xde, 0x28, 0x0f, 0xfa, 0x06, 0xda, 0xa7, 0x9c, 0x44, 0x92, 0xc4, 0x27, 0x32, 0x3f, 0xeb, 0x77, 0x8b, 0xe9,
0x80, 0x72, 0x76, 0xc9, 0x29, 0x13, 0x75, 0x5b, 0x6a, 0xf1, 0x92, 0x1d, 0x9c, 0xc2, 0x66, 0x81, 0x6a, 0x22, 0x65, 0xf4, 0x9c, 0xa5, 0x54, 0xf6, 0x6d, 0xe5, 0xc5, 0x1b, 0xb5, 0x7f, 0x02, 0x3b,
0x81, 0x76, 0xc0, 0xb9, 0x66, 0xf4, 0xe5, 0x15, 0x1d, 0x11, 0xf5, 0x97, 0x4b, 0x78, 0x11, 0x2f, 0x15, 0x05, 0xea, 0x42, 0xeb, 0x8a, 0xa6, 0x2f, 0x2e, 0xd3, 0x39, 0xd1, 0x8f, 0x5c, 0xc3, 0xeb,
0x9b, 0x66, 0xad, 0x36, 0x8d, 0xc2, 0xf6, 0xda, 0xf0, 0xd0, 0x01, 0x6c, 0x67, 0xa7, 0x74, 0x61, 0x7a, 0x33, 0x34, 0xab, 0x3c, 0xb4, 0x14, 0x76, 0xb7, 0x8e, 0x10, 0x1d, 0xc0, 0x6e, 0xb6, 0x12,
0x0a, 0x79, 0x97, 0x8b, 0xd7, 0xd3, 0xe8, 0x63, 0xb8, 0x97, 0x9f, 0xdb, 0xb4, 0xcf, 0x22, 0x31, 0xeb, 0x68, 0xa8, 0xbd, 0x1c, 0xbc, 0x0d, 0xa3, 0x2f, 0xe0, 0x7e, 0xb1, 0xbe, 0x48, 0x13, 0x1a,
0x49, 0xb2, 0xbd, 0x75, 0xf1, 0x9b, 0x40, 0xf0, 0xab, 0x99, 0x6d, 0x2e, 0x7a, 0x0f, 0x6c, 0xf9, 0xc9, 0x25, 0xcf, 0x6e, 0xaf, 0x83, 0xdf, 0x24, 0xfc, 0xbf, 0xcc, 0xec, 0xfe, 0xa2, 0x8f, 0xc1,
0xf2, 0xa8, 0x5b, 0xb7, 0x96, 0x2b, 0x20, 0xb1, 0xf0, 0x6a, 0x3a, 0x26, 0x58, 0xc1, 0xba, 0xfd, 0x56, 0xef, 0x1f, 0xbd, 0xeb, 0xbd, 0xcd, 0x45, 0x50, 0x5c, 0x70, 0xb9, 0x5a, 0x10, 0xac, 0xe9,
0xd6, 0x5d, 0xed, 0x0f, 0xae, 0xc0, 0x96, 0x4c, 0xb4, 0x01, 0xd5, 0x6b, 0x76, 0xcb, 0xf8, 0x0b, 0x7c, 0xfc, 0xd6, 0xdb, 0xc6, 0xef, 0x5f, 0x82, 0xad, 0x94, 0xa8, 0x03, 0xcd, 0x2b, 0x7a, 0x43,
0xe6, 0x19, 0x08, 0xa0, 0x72, 0x19, 0x25, 0x84, 0x09, 0xcf, 0x44, 0x2e, 0x38, 0x97, 0x09, 0x79, 0xd9, 0x73, 0xea, 0x1a, 0x08, 0xa0, 0x71, 0x1e, 0x71, 0x42, 0xa5, 0x6b, 0x22, 0x07, 0x5a, 0xe7,
0x4e, 0xf9, 0x24, 0xf5, 0x2c, 0xe4, 0x80, 0xfd, 0x8c, 0xbc, 0x14, 0x5e, 0x09, 0xd5, 0xa0, 0x7c, 0x9c, 0x3c, 0x4b, 0xd9, 0x52, 0xb8, 0x16, 0x6a, 0x81, 0xfd, 0x0b, 0x79, 0x21, 0xdd, 0x1a, 0x6a,
0x36, 0xa0, 0xc3, 0xd8, 0xb3, 0x91, 0x57, 0xf4, 0xa5, 0x57, 0x0e, 0x86, 0x2b, 0x3b, 0x8d, 0x1e, 0x43, 0xfd, 0x74, 0x9a, 0xce, 0x62, 0xd7, 0x46, 0x6e, 0x35, 0x9d, 0x6e, 0xdd, 0x9f, 0x95, 0x6e,
0x15, 0xaa, 0x7c, 0xf0, 0xc6, 0x6e, 0xaf, 0x94, 0x1a, 0x9c, 0xdc, 0x55, 0x4e, 0x0d, 0xca, 0xed, 0x36, 0x7a, 0x54, 0xe9, 0xf2, 0xe1, 0x1b, 0x37, 0xbc, 0xd4, 0xaa, 0xff, 0xf8, 0x6d, 0xed, 0xb4,
0xf1, 0x90, 0xca, 0x6a, 0x1c, 0xb0, 0x65, 0x1f, 0x3c, 0x4b, 0x26, 0xbf, 0xe3, 0x93, 0x61, 0xec, 0xa1, 0x7e, 0xb1, 0x98, 0xa5, 0xaa, 0x9b, 0x16, 0xd8, 0x6a, 0x0e, 0xae, 0xa5, 0xc0, 0x9f, 0xd9,
0x95, 0x82, 0x9f, 0x4c, 0xa8, 0x5c, 0xa8, 0x4b, 0xd1, 0x97, 0x45, 0xe7, 0xea, 0xb7, 0x6d, 0xb9, 0x72, 0x16, 0xbb, 0x35, 0xff, 0x0f, 0x13, 0x1a, 0x67, 0x7a, 0x53, 0xf4, 0x5d, 0x35, 0xb9, 0xf9,
0x22, 0x2b, 0x98, 0x76, 0x41, 0xd1, 0xe9, 0x21, 0x54, 0xf5, 0x6c, 0x7c, 0x6b, 0xbf, 0x74, 0xb0, 0x1b, 0xee, 0x41, 0xf1, 0x9f, 0x65, 0x2e, 0x4f, 0x41, 0x35, 0xe9, 0x01, 0x34, 0xf3, 0xb3, 0xf1,
0x71, 0xbc, 0x95, 0x4b, 0x0b, 0xa2, 0x9c, 0x24, 0x37, 0x43, 0x5b, 0x3d, 0xb3, 0x37, 0xce, 0xc3, 0xac, 0xfd, 0xda, 0x41, 0xe7, 0xf8, 0x5e, 0x61, 0xad, 0x98, 0x0a, 0x91, 0xba, 0x19, 0x79, 0xd4,
0xe0, 0x77, 0xab, 0xd8, 0x15, 0x14, 0x02, 0xba, 0x89, 0x86, 0x34, 0x56, 0x2e, 0x6b, 0x44, 0x22, 0xb3, 0x78, 0xe3, 0xa2, 0xec, 0x7f, 0xfb, 0xf2, 0xae, 0x67, 0xfe, 0x7d, 0xd7, 0x33, 0xff, 0xb9,
0x6a, 0xd3, 0x1f, 0x89, 0xde, 0xa7, 0x3b, 0x10, 0xf4, 0x18, 0xb6, 0x96, 0x59, 0xf5, 0x00, 0x65, 0xeb, 0x99, 0xff, 0xde, 0xf5, 0xcc, 0x3f, 0xff, 0xeb, 0x19, 0xbf, 0x7e, 0x5a, 0xfa, 0x44, 0x50,
0x13, 0x74, 0xf5, 0x04, 0xd5, 0x23, 0x84, 0xd7, 0x38, 0xe8, 0x29, 0x38, 0x43, 0xda, 0x23, 0x42, 0xb1, 0x18, 0x8f, 0x0f, 0x63, 0xf2, 0xec, 0x88, 0x12, 0x36, 0x11, 0x87, 0xd9, 0x07, 0x22, 0xfb,
0x1a, 0x37, 0x7b, 0x81, 0x1f, 0xde, 0xf5, 0x3e, 0x84, 0xe7, 0x9a, 0x54, 0x77, 0xe7, 0xb3, 0x3d, 0xbb, 0x51, 0x43, 0x57, 0x8f, 0x5f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x40, 0x7d, 0xa2, 0x84, 0xb1,
0x27, 0x8f, 0xf0, 0x42, 0xbc, 0xf3, 0xb3, 0x09, 0x8b, 0x34, 0xfa, 0x0a, 0xec, 0x09, 0xa3, 0x42, 0x06, 0x00, 0x00,
0x8f, 0x30, 0xf8, 0xcf, 0x1b, 0xc3, 0x6b, 0x46, 0x45, 0xdd, 0x99, 0xcf, 0xf6, 0x6c, 0x79, 0xc2,
0x4a, 0x59, 0xfc, 0x1a, 0x95, 0xf2, 0xaf, 0xd1, 0x09, 0x28, 0x0e, 0xda, 0x84, 0xda, 0x35, 0x1b,
0xd2, 0x11, 0x15, 0x24, 0xf6, 0x0c, 0xb4, 0x05, 0xf0, 0x8c, 0xf0, 0x6f, 0xda, 0x6a, 0xb3, 0x32,
0x0f, 0xe6, 0xdb, 0xe7, 0x59, 0xf5, 0x2f, 0x5e, 0xcd, 0x77, 0xcd, 0xdf, 0xe6, 0xbb, 0xe6, 0x1f,
0xf3, 0x5d, 0xf3, 0xcf, 0xf9, 0xae, 0xf9, 0xcb, 0x5f, 0xbb, 0xc6, 0xf7, 0x1f, 0xac, 0x7c, 0x76,
0x59, 0x3a, 0xee, 0x76, 0x0f, 0x63, 0xf2, 0xfc, 0x88, 0x11, 0xde, 0x4b, 0x0f, 0xb3, 0x8f, 0x6e,
0x56, 0x74, 0xa7, 0xa2, 0xa2, 0x93, 0x7f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xbb, 0x65, 0xf4, 0xeb,
0xeb, 0x07, 0x00, 0x00,
} }
func (m *Range) Marshal() (dAtA []byte, err error) { func (m *Range) Marshal() (dAtA []byte, err error) {
@ -1620,97 +1471,6 @@ func (m *Object) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
func (m *StorageGroup) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *StorageGroup) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *StorageGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Lifetime != nil {
{
size, err := m.Lifetime.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
}
{
size := m.ValidationHash.Size()
i -= size
if _, err := m.ValidationHash.MarshalTo(dAtA[i:]); err != nil {
return 0, err
}
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
if m.ValidationDataSize != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.ValidationDataSize))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *StorageGroup_Lifetime) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *StorageGroup_Lifetime) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *StorageGroup_Lifetime) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Value != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Value))
i--
dAtA[i] = 0x10
}
if m.Unit != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Unit))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
offset -= sovTypes(v) offset -= sovTypes(v)
base := offset base := offset
@ -2028,45 +1788,6 @@ func (m *Object) Size() (n int) {
return n return n
} }
func (m *StorageGroup) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.ValidationDataSize != 0 {
n += 1 + sovTypes(uint64(m.ValidationDataSize))
}
l = m.ValidationHash.Size()
n += 1 + l + sovTypes(uint64(l))
if m.Lifetime != nil {
l = m.Lifetime.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *StorageGroup_Lifetime) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Unit != 0 {
n += 1 + sovTypes(uint64(m.Unit))
}
if m.Value != 0 {
n += 1 + sovTypes(uint64(m.Value))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func sovTypes(x uint64) (n int) { func sovTypes(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7 return (math_bits.Len64(x|1) + 6) / 7
} }
@ -2655,7 +2376,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
if postIndex > l { if postIndex > l {
return io.ErrUnexpectedEOF return io.ErrUnexpectedEOF
} }
v := &StorageGroup{} v := &storagegroup.StorageGroup{}
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err return err
} }
@ -3531,240 +3252,6 @@ func (m *Object) Unmarshal(dAtA []byte) error {
} }
return nil return nil
} }
func (m *StorageGroup) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: StorageGroup: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: StorageGroup: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ValidationDataSize", wireType)
}
m.ValidationDataSize = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ValidationDataSize |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ValidationHash", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ValidationHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Lifetime", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Lifetime == nil {
m.Lifetime = &StorageGroup_Lifetime{}
}
if err := m.Lifetime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *StorageGroup_Lifetime) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Lifetime: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Lifetime: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType)
}
m.Unit = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Unit |= StorageGroup_Lifetime_Unit(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
}
m.Value = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Value |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipTypes(dAtA []byte) (n int, err error) { func skipTypes(dAtA []byte) (n int, err error) {
l := len(dAtA) l := len(dAtA)
iNdEx := 0 iNdEx := 0

47
object/types.proto
View file

@ -4,6 +4,7 @@ option go_package = "github.com/nspcc-dev/neofs-proto/object";
import "refs/types.proto"; import "refs/types.proto";
import "session/types.proto"; import "session/types.proto";
import "storagegroup/types.proto";
import "github.com/gogo/protobuf/gogoproto/gogo.proto"; import "github.com/gogo/protobuf/gogoproto/gogo.proto";
option (gogoproto.stable_marshaler_all) = true; option (gogoproto.stable_marshaler_all) = true;
@ -25,25 +26,25 @@ message UserHeader {
message Header { message Header {
oneof Value { oneof Value {
// Link to other objects // Link to other objects
Link Link = 1; Link Link = 1;
// Redirect not used yet // Redirect not used yet
refs.Address Redirect = 2; refs.Address Redirect = 2;
// UserHeader is a set of KV headers defined by user // UserHeader is a set of KV headers defined by user
UserHeader UserHeader = 3; UserHeader UserHeader = 3;
// Transform defines transform operation (e.g. payload split) // Transform defines transform operation (e.g. payload split)
Transform Transform = 4; Transform Transform = 4;
// Tombstone header that set up in deleted objects // Tombstone header that set up in deleted objects
Tombstone Tombstone = 5; Tombstone Tombstone = 5;
// Verify header that contains session public key and user's signature // Verify header that contains session public key and user's signature
session.VerificationHeader Verify = 6; session.VerificationHeader Verify = 6;
// HomoHash is a homomorphic hash of original object payload // HomoHash is a homomorphic hash of original object payload
bytes HomoHash = 7 [(gogoproto.customtype) = "Hash"]; bytes HomoHash = 7 [(gogoproto.customtype) = "Hash"];
// PayloadChecksum of actual object's payload // PayloadChecksum of actual object's payload
bytes PayloadChecksum = 8; bytes PayloadChecksum = 8;
// Integrity header with checksum of all above headers in the object // Integrity header with checksum of all above headers in the object
IntegrityHeader Integrity = 9; IntegrityHeader Integrity = 9;
// StorageGroup contains meta information for the data audit // StorageGroup contains meta information for the data audit
StorageGroup StorageGroup = 10; storagegroup.StorageGroup StorageGroup = 10;
} }
} }
@ -124,29 +125,3 @@ message Object {
// Payload is an object's payload // Payload is an object's payload
bytes Payload = 3; bytes Payload = 3;
} }
message StorageGroup {
// ValidationDataSize is size of the all object's payloads included into storage group
uint64 ValidationDataSize = 1;
// ValidationHash is homomorphic hash of all object's payloads included into storage group
bytes ValidationHash = 2 [(gogoproto.customtype) = "Hash", (gogoproto.nullable) = false];
message Lifetime {
enum Unit {
// Unlimited set if storage group always valid
Unlimited = 0;
// NeoFSEpoch set if storage group is valid until lifetime NeoFS epoch
NeoFSEpoch = 1;
// UnixTime set if storage group is valid until lifetime unix timestamp
UnixTime = 2;
}
// Unit is lifetime type
Unit unit = 1 [(gogoproto.customname) = "Unit"];
// Value for lifetime
int64 Value = 2;
}
// Lifetime is time until storage group is valid
Lifetime lifetime = 3 [(gogoproto.customname) = "Lifetime"];
}

39
storagegroup/storage.go Normal file
View file

@ -0,0 +1,39 @@
package storagegroup
import (
"context"
"github.com/nspcc-dev/neofs-proto/refs"
)
type (
// Store is a interface for storing users storage group
Store interface {
Lister
Receiver
Receptacle
}
// Lister defines list function that returns all storage groups
// created for the passed container
Lister interface {
List(ctx context.Context, cid refs.CID) ([]refs.SGID, error)
}
// Receiver defines get function that returns asked storage group
Receiver interface {
Get(ctx context.Context, cid refs.CID, sgid refs.SGID) (Provider, error)
}
// Receptacle defines put function that places storage group in the
// store.
Receptacle interface {
Put(ctx context.Context, sg Provider) error
}
// InfoReceiver defines GetSGInfo function that returns storage group
// that contains passed object ids.
InfoReceiver interface {
GetSGInfo(ctx context.Context, cid refs.CID, group []refs.ObjectID) (*StorageGroup, error)
}
)

97
storagegroup/types.go Normal file
View file

@ -0,0 +1,97 @@
package storagegroup
import (
"bytes"
"strconv"
"strings"
"github.com/gogo/protobuf/proto"
"github.com/mr-tron/base58"
"github.com/nspcc-dev/neofs-proto/hash"
"github.com/nspcc-dev/neofs-proto/refs"
)
type (
// Hash is alias of hash.Hash for proto definition.
Hash = hash.Hash
// Provider is an interface that defines storage group instance.
// There was different storage group implementation. Right now it
// is implemented as extended header in the object.
Provider interface {
// Group returns list of object ids of the storage group.
// This list **should be** sorted.
Group() []refs.ObjectID
IDInfo() *IdentificationInfo
Zones() []ZoneInfo
}
// ZoneInfo provides validation information of storage group.
ZoneInfo struct {
hash.Hash
Size uint64
}
// IdentificationInfo provides meta information about storage group.
IdentificationInfo struct {
CID refs.CID
SGID refs.SGID
OwnerID refs.OwnerID
}
// IDList is a slice of object ids, that can be sorted.
IDList []refs.ObjectID
)
var _ proto.Message = (*StorageGroup)(nil)
// String returns string representation of StorageGroup.
func (m *StorageGroup) String() string {
b := new(strings.Builder)
b.WriteString("<SG")
b.WriteString(" VDS=" + strconv.FormatUint(m.ValidationDataSize, 10))
data := base58.Encode(m.ValidationHash.Bytes())
b.WriteString(" Hash=" + data[:3] + "..." + data[len(data)-3:])
if m.Lifetime != nil {
b.WriteString(" Lifetime=(" + m.Lifetime.Unit.String() + " " + strconv.FormatInt(m.Lifetime.Value, 10) + ")")
}
b.WriteByte('>')
return b.String()
}
// Empty checks if storage group has some data for validation.
func (m StorageGroup) Empty() bool {
return m.ValidationDataSize == 0 && m.ValidationHash.Equal(hash.Hash{})
}
// Len returns amount of object ids in IDList.
func (s IDList) Len() int { return len(s) }
// Less returns byte comparision between IDList[i] and IDList[j].
func (s IDList) Less(i, j int) bool { return bytes.Compare(s[i].Bytes(), s[j].Bytes()) == -1 }
// Swap swaps element with i and j index in IDList.
func (s IDList) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
// CalculateSize combines length of all zones in storage group.
func CalculateSize(sg Provider) (size uint64) {
zoneList := sg.Zones()
for i := range zoneList {
size += zoneList[i].Size
}
return
}
// CalculateHash returns homomorphic sum of hashes
// fromm all zones in storage group.
func CalculateHash(sg Provider) (hash.Hash, error) {
var (
zones = sg.Zones()
hashes = make([]hash.Hash, len(zones))
)
for i := range zones {
hashes[i] = zones[i].Hash
}
return hash.Concat(hashes)
}

663
storagegroup/types.pb.go Normal file
View file

@ -0,0 +1,663 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: storagegroup/types.proto
package storagegroup
import (
fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/golang/protobuf/proto"
io "io"
math "math"
math_bits "math/bits"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type StorageGroup_Lifetime_Unit int32
const (
// Unlimited set if storage group always valid
StorageGroup_Lifetime_Unlimited StorageGroup_Lifetime_Unit = 0
// NeoFSEpoch set if storage group is valid until lifetime NeoFS epoch
StorageGroup_Lifetime_NeoFSEpoch StorageGroup_Lifetime_Unit = 1
// UnixTime set if storage group is valid until lifetime unix timestamp
StorageGroup_Lifetime_UnixTime StorageGroup_Lifetime_Unit = 2
)
var StorageGroup_Lifetime_Unit_name = map[int32]string{
0: "Unlimited",
1: "NeoFSEpoch",
2: "UnixTime",
}
var StorageGroup_Lifetime_Unit_value = map[string]int32{
"Unlimited": 0,
"NeoFSEpoch": 1,
"UnixTime": 2,
}
func (x StorageGroup_Lifetime_Unit) String() string {
return proto.EnumName(StorageGroup_Lifetime_Unit_name, int32(x))
}
func (StorageGroup_Lifetime_Unit) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_cfa54edc899249a8, []int{0, 0, 0}
}
type StorageGroup struct {
// ValidationDataSize is size of the all object's payloads included into storage group
ValidationDataSize uint64 `protobuf:"varint,1,opt,name=ValidationDataSize,proto3" json:"ValidationDataSize,omitempty"`
// ValidationHash is homomorphic hash of all object's payloads included into storage group
ValidationHash Hash `protobuf:"bytes,2,opt,name=ValidationHash,proto3,customtype=Hash" json:"ValidationHash"`
// Lifetime is time until storage group is valid
Lifetime *StorageGroup_Lifetime `protobuf:"bytes,3,opt,name=lifetime,proto3" json:"lifetime,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *StorageGroup) Reset() { *m = StorageGroup{} }
func (*StorageGroup) ProtoMessage() {}
func (*StorageGroup) Descriptor() ([]byte, []int) {
return fileDescriptor_cfa54edc899249a8, []int{0}
}
func (m *StorageGroup) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *StorageGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
func (m *StorageGroup) XXX_Merge(src proto.Message) {
xxx_messageInfo_StorageGroup.Merge(m, src)
}
func (m *StorageGroup) XXX_Size() int {
return m.Size()
}
func (m *StorageGroup) XXX_DiscardUnknown() {
xxx_messageInfo_StorageGroup.DiscardUnknown(m)
}
var xxx_messageInfo_StorageGroup proto.InternalMessageInfo
func (m *StorageGroup) GetValidationDataSize() uint64 {
if m != nil {
return m.ValidationDataSize
}
return 0
}
func (m *StorageGroup) GetLifetime() *StorageGroup_Lifetime {
if m != nil {
return m.Lifetime
}
return nil
}
type StorageGroup_Lifetime struct {
// Unit is lifetime type
Unit StorageGroup_Lifetime_Unit `protobuf:"varint,1,opt,name=unit,proto3,enum=storagegroup.StorageGroup_Lifetime_Unit" json:"unit,omitempty"`
// Value for lifetime
Value int64 `protobuf:"varint,2,opt,name=Value,proto3" json:"Value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *StorageGroup_Lifetime) Reset() { *m = StorageGroup_Lifetime{} }
func (m *StorageGroup_Lifetime) String() string { return proto.CompactTextString(m) }
func (*StorageGroup_Lifetime) ProtoMessage() {}
func (*StorageGroup_Lifetime) Descriptor() ([]byte, []int) {
return fileDescriptor_cfa54edc899249a8, []int{0, 0}
}
func (m *StorageGroup_Lifetime) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *StorageGroup_Lifetime) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
func (m *StorageGroup_Lifetime) XXX_Merge(src proto.Message) {
xxx_messageInfo_StorageGroup_Lifetime.Merge(m, src)
}
func (m *StorageGroup_Lifetime) XXX_Size() int {
return m.Size()
}
func (m *StorageGroup_Lifetime) XXX_DiscardUnknown() {
xxx_messageInfo_StorageGroup_Lifetime.DiscardUnknown(m)
}
var xxx_messageInfo_StorageGroup_Lifetime proto.InternalMessageInfo
func (m *StorageGroup_Lifetime) GetUnit() StorageGroup_Lifetime_Unit {
if m != nil {
return m.Unit
}
return StorageGroup_Lifetime_Unlimited
}
func (m *StorageGroup_Lifetime) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
}
func init() {
proto.RegisterEnum("storagegroup.StorageGroup_Lifetime_Unit", StorageGroup_Lifetime_Unit_name, StorageGroup_Lifetime_Unit_value)
proto.RegisterType((*StorageGroup)(nil), "storagegroup.StorageGroup")
proto.RegisterType((*StorageGroup_Lifetime)(nil), "storagegroup.StorageGroup.Lifetime")
}
func init() { proto.RegisterFile("storagegroup/types.proto", fileDescriptor_cfa54edc899249a8) }
var fileDescriptor_cfa54edc899249a8 = []byte{
// 353 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x51, 0x31, 0x4f, 0xc2, 0x40,
0x18, 0xed, 0x41, 0x35, 0xf5, 0xac, 0x84, 0x5c, 0x1c, 0x1a, 0x86, 0x96, 0xe0, 0xd2, 0x85, 0x36,
0x01, 0x27, 0xc7, 0xaa, 0xe8, 0xa0, 0x0e, 0x45, 0x18, 0xdc, 0x8e, 0x72, 0x94, 0x4b, 0xda, 0xbb,
0x86, 0x5e, 0x8d, 0xfa, 0x4b, 0x58, 0x4c, 0xfc, 0x39, 0x8c, 0x8e, 0xc6, 0xa1, 0x31, 0x75, 0xf2,
0x5f, 0x18, 0xae, 0x8a, 0x8d, 0x71, 0x70, 0xfb, 0xde, 0xfb, 0xde, 0xfb, 0xf2, 0xbd, 0x3c, 0x68,
0xa4, 0x82, 0x2f, 0x70, 0x48, 0xc2, 0x05, 0xcf, 0x12, 0x57, 0xdc, 0x27, 0x24, 0x75, 0x92, 0x05,
0x17, 0x1c, 0xe9, 0xd5, 0x4d, 0xab, 0x1b, 0x52, 0x31, 0xcf, 0x26, 0x4e, 0xc0, 0x63, 0x37, 0xe4,
0x21, 0x77, 0xa5, 0x68, 0x92, 0xcd, 0x24, 0x92, 0x40, 0x4e, 0xa5, 0xb9, 0xf3, 0x51, 0x83, 0xfa,
0xb0, 0xf4, 0x9f, 0xad, 0xfd, 0xc8, 0x81, 0x68, 0x8c, 0x23, 0x3a, 0xc5, 0x82, 0x72, 0x76, 0x82,
0x05, 0x1e, 0xd2, 0x07, 0x62, 0x80, 0x36, 0xb0, 0x55, 0xff, 0x8f, 0x0d, 0x3a, 0x84, 0x8d, 0x1f,
0xf6, 0x1c, 0xa7, 0x73, 0xa3, 0xd6, 0x06, 0xb6, 0xee, 0xe9, 0xab, 0xdc, 0x52, 0x5e, 0x73, 0x4b,
0x5d, 0x73, 0xfe, 0x2f, 0x0d, 0xba, 0x84, 0x5a, 0x44, 0x67, 0x44, 0xd0, 0x98, 0x18, 0xf5, 0x36,
0xb0, 0x77, 0x7b, 0x07, 0x4e, 0x35, 0x86, 0x53, 0xfd, 0xc9, 0xb9, 0xf8, 0x92, 0x7a, 0x7a, 0x91,
0x5b, 0xda, 0x37, 0xf2, 0x37, 0x27, 0x5a, 0x8f, 0x00, 0x6e, 0x68, 0x34, 0x80, 0x6a, 0xc6, 0xa8,
0x90, 0x3f, 0x37, 0x7a, 0xf6, 0x3f, 0xee, 0x3a, 0x23, 0x46, 0x85, 0xa7, 0x15, 0xb9, 0xa5, 0xae,
0x27, 0x5f, 0xfa, 0xd1, 0x3e, 0xdc, 0x1a, 0xe3, 0x28, 0x23, 0x32, 0x50, 0xdd, 0x2f, 0x41, 0xa7,
0x0f, 0xa5, 0x06, 0xed, 0xc1, 0x9d, 0x11, 0x8b, 0x68, 0x4c, 0x05, 0x99, 0x36, 0x15, 0xd4, 0x80,
0xf0, 0x8a, 0xf0, 0xc1, 0xf0, 0x34, 0xe1, 0xc1, 0xbc, 0x09, 0x90, 0x0e, 0xb5, 0x11, 0xa3, 0x77,
0xd7, 0x34, 0x26, 0xcd, 0xda, 0x91, 0xba, 0x7c, 0xb2, 0x14, 0xef, 0x78, 0x55, 0x98, 0xe0, 0xb9,
0x30, 0xc1, 0x4b, 0x61, 0x82, 0xb7, 0xc2, 0x04, 0xcb, 0x77, 0x53, 0xb9, 0xa9, 0x16, 0xc6, 0xd2,
0x24, 0x08, 0xba, 0x53, 0x72, 0xeb, 0x32, 0xc2, 0x67, 0x69, 0xb7, 0xac, 0xab, 0x1a, 0x60, 0xb2,
0x2d, 0xb9, 0xfe, 0x67, 0x00, 0x00, 0x00, 0xff, 0xff, 0x91, 0x55, 0xe3, 0x01, 0x10, 0x02, 0x00,
0x00,
}
func (m *StorageGroup) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *StorageGroup) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *StorageGroup) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Lifetime != nil {
{
size, err := m.Lifetime.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
}
{
size := m.ValidationHash.Size()
i -= size
if _, err := m.ValidationHash.MarshalTo(dAtA[i:]); err != nil {
return 0, err
}
i = encodeVarintTypes(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
if m.ValidationDataSize != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.ValidationDataSize))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *StorageGroup_Lifetime) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *StorageGroup_Lifetime) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *StorageGroup_Lifetime) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.XXX_unrecognized != nil {
i -= len(m.XXX_unrecognized)
copy(dAtA[i:], m.XXX_unrecognized)
}
if m.Value != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Value))
i--
dAtA[i] = 0x10
}
if m.Unit != 0 {
i = encodeVarintTypes(dAtA, i, uint64(m.Unit))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
offset -= sovTypes(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *StorageGroup) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.ValidationDataSize != 0 {
n += 1 + sovTypes(uint64(m.ValidationDataSize))
}
l = m.ValidationHash.Size()
n += 1 + l + sovTypes(uint64(l))
if m.Lifetime != nil {
l = m.Lifetime.Size()
n += 1 + l + sovTypes(uint64(l))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func (m *StorageGroup_Lifetime) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Unit != 0 {
n += 1 + sovTypes(uint64(m.Unit))
}
if m.Value != 0 {
n += 1 + sovTypes(uint64(m.Value))
}
if m.XXX_unrecognized != nil {
n += len(m.XXX_unrecognized)
}
return n
}
func sovTypes(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozTypes(x uint64) (n int) {
return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *StorageGroup) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: StorageGroup: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: StorageGroup: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ValidationDataSize", wireType)
}
m.ValidationDataSize = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ValidationDataSize |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ValidationHash", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ValidationHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Lifetime", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Lifetime == nil {
m.Lifetime = &StorageGroup_Lifetime{}
}
if err := m.Lifetime.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *StorageGroup_Lifetime) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Lifetime: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Lifetime: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType)
}
m.Unit = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Unit |= StorageGroup_Lifetime_Unit(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
}
m.Value = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Value |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipTypes(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowTypes
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowTypes
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
case 1:
iNdEx += 8
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowTypes
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if length < 0 {
return 0, ErrInvalidLengthTypes
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupTypes
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthTypes
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
)

35
storagegroup/types.proto Normal file
View file

@ -0,0 +1,35 @@
syntax = "proto3";
package storagegroup;
option go_package = "github.com/nspcc-dev/neofs-proto/storagegroup";
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
option (gogoproto.stable_marshaler_all) = true;
message StorageGroup {
option (gogoproto.goproto_stringer) = false;
// ValidationDataSize is size of the all object's payloads included into storage group
uint64 ValidationDataSize = 1;
// ValidationHash is homomorphic hash of all object's payloads included into storage group
bytes ValidationHash = 2 [(gogoproto.customtype) = "Hash", (gogoproto.nullable) = false];
message Lifetime {
enum Unit {
// Unlimited set if storage group always valid
Unlimited = 0;
// NeoFSEpoch set if storage group is valid until lifetime NeoFS epoch
NeoFSEpoch = 1;
// UnixTime set if storage group is valid until lifetime unix timestamp
UnixTime = 2;
}
// Unit is lifetime type
Unit unit = 1 [(gogoproto.customname) = "Unit"];
// Value for lifetime
int64 Value = 2;
}
// Lifetime is time until storage group is valid
Lifetime lifetime = 3 [(gogoproto.customname) = "Lifetime"];
}