forked from TrueCloudLab/frostfs-api-go
proto: publish sg lib, rewrite object
This commit is contained in:
Evgeniy Kulikov
parent
b646388840
commit
0fce8a6ba2
11 changed files with 1011 additions and 696 deletions
|
|
@ -34,8 +34,6 @@
|
|||
- [Link](#object.Link)
|
||||
- [Object](#object.Object)
|
||||
- [Range](#object.Range)
|
||||
- [StorageGroup](#object.StorageGroup)
|
||||
- [StorageGroup.Lifetime](#object.StorageGroup.Lifetime)
|
||||
- [SystemHeader](#object.SystemHeader)
|
||||
- [Tombstone](#object.Tombstone)
|
||||
- [Transform](#object.Transform)
|
||||
|
|
@ -369,7 +367,7 @@ in distributed system.
|
|||
| HomoHash | [bytes](#bytes) | | HomoHash is a homomorphic hash of original object 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 |
|
||||
| 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>
|
||||
|
|
@ -421,31 +419,6 @@ in distributed system.
|
|||
| 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>
|
||||
|
||||
### 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>
|
||||
|
||||
### Transform.Type
|
||||
|
|
|
|||
88
docs/storagegroup.md
Normal file
88
docs/storagegroup.md
Normal 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 |
|
||||
|
||||
|
|
@ -1,8 +1,6 @@
|
|||
package object
|
||||
|
||||
import (
|
||||
"github.com/nspcc-dev/neofs-proto/hash"
|
||||
)
|
||||
import "github.com/nspcc-dev/neofs-proto/storagegroup"
|
||||
|
||||
// IsLinking checks if object has children links to another objects.
|
||||
// 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.
|
||||
func (m Object) StorageGroup() (*StorageGroup, error) {
|
||||
func (m Object) StorageGroup() (*storagegroup.StorageGroup, error) {
|
||||
_, sgHdr := m.LastHeader(HeaderType(StorageGroupHdr))
|
||||
if sgHdr == nil {
|
||||
return nil, ErrHeaderNotFound
|
||||
|
|
@ -74,11 +72,6 @@ func (m Object) StorageGroup() (*StorageGroup, error) {
|
|||
|
||||
// SetStorageGroup sets storage group header in the object.
|
||||
// It will replace existing storage group header or add a new one.
|
||||
func (m *Object) SetStorageGroup(sg *StorageGroup) {
|
||||
m.SetHeader(&Header{Value: &Header_StorageGroup{StorageGroup: sg}})
|
||||
}
|
||||
|
||||
// Empty checks if storage group has some data for validation.
|
||||
func (m StorageGroup) Empty() bool {
|
||||
return m.ValidationDataSize == 0 && m.ValidationHash.Equal(hash.Hash{})
|
||||
func (m *Object) SetStorageGroup(group *storagegroup.StorageGroup) {
|
||||
m.SetHeader(&Header{Value: &Header_StorageGroup{StorageGroup: group}})
|
||||
}
|
||||
|
|
|
|||
43
object/sg.go
43
object/sg.go
|
|
@ -1,54 +1,31 @@
|
|||
package object
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"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
|
||||
// information.
|
||||
|
||||
type (
|
||||
// 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] }
|
||||
var _ storagegroup.Provider = (*Object)(nil)
|
||||
|
||||
// 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)
|
||||
sort.Sort(IDList(sgLinks))
|
||||
sort.Sort(storagegroup.IDList(sgLinks))
|
||||
return sgLinks
|
||||
}
|
||||
|
||||
// Zones returns validation zones of storage group.
|
||||
func (m *Object) Zones() []ZoneInfo {
|
||||
func (m *Object) Zones() []storagegroup.ZoneInfo {
|
||||
sgInfo, err := m.StorageGroup()
|
||||
if err != nil {
|
||||
return nil
|
||||
}
|
||||
return []ZoneInfo{
|
||||
return []storagegroup.ZoneInfo{
|
||||
{
|
||||
Hash: sgInfo.ValidationHash,
|
||||
Size: sgInfo.ValidationDataSize,
|
||||
|
|
@ -57,8 +34,8 @@ func (m *Object) Zones() []ZoneInfo {
|
|||
}
|
||||
|
||||
// IDInfo returns meta information about storage group.
|
||||
func (m *Object) IDInfo() *IdentificationInfo {
|
||||
return &IdentificationInfo{
|
||||
func (m *Object) IDInfo() *storagegroup.IdentificationInfo {
|
||||
return &storagegroup.IdentificationInfo{
|
||||
SGID: m.SystemHeader.ID,
|
||||
CID: m.SystemHeader.CID,
|
||||
OwnerID: m.SystemHeader.OwnerID,
|
||||
|
|
|
|||
|
|
@ -6,6 +6,7 @@ import (
|
|||
"testing"
|
||||
|
||||
"github.com/nspcc-dev/neofs-proto/hash"
|
||||
"github.com/nspcc-dev/neofs-proto/storagegroup"
|
||||
"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] })
|
||||
sort.Sort(IDList(idList))
|
||||
sort.Sort(storagegroup.IDList(idList))
|
||||
require.Equal(t, idList, obj.Group())
|
||||
})
|
||||
t.Run("identification method", func(t *testing.T) {
|
||||
|
|
@ -58,7 +59,7 @@ func TestObject_StorageGroup(t *testing.T) {
|
|||
Headers: []Header{
|
||||
{
|
||||
Value: &Header_StorageGroup{
|
||||
StorageGroup: &StorageGroup{
|
||||
StorageGroup: &storagegroup.StorageGroup{
|
||||
ValidationDataSize: sgSize,
|
||||
ValidationHash: sgHash,
|
||||
},
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@ import (
|
|||
proto "github.com/golang/protobuf/proto"
|
||||
refs "github.com/nspcc-dev/neofs-proto/refs"
|
||||
session "github.com/nspcc-dev/neofs-proto/session"
|
||||
storagegroup "github.com/nspcc-dev/neofs-proto/storagegroup"
|
||||
io "io"
|
||||
math "math"
|
||||
math_bits "math/bits"
|
||||
|
|
@ -101,37 +102,6 @@ func (Transform_Type) EnumDescriptor() ([]byte, []int) {
|
|||
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 {
|
||||
// Offset of the data range
|
||||
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"`
|
||||
}
|
||||
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() {}
|
||||
|
|
@ -396,7 +366,7 @@ func (m *Header) GetIntegrity() *IntegrityHeader {
|
|||
return nil
|
||||
}
|
||||
|
||||
func (m *Header) GetStorageGroup() *StorageGroup {
|
||||
func (m *Header) GetStorageGroup() *storagegroup.StorageGroup {
|
||||
if x, ok := m.GetValue().(*Header_StorageGroup); ok {
|
||||
return x.StorageGroup
|
||||
}
|
||||
|
|
@ -789,118 +759,9 @@ func (m *Object) GetPayload() []byte {
|
|||
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() {
|
||||
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.StorageGroup_Lifetime_Unit", StorageGroup_Lifetime_Unit_name, StorageGroup_Lifetime_Unit_value)
|
||||
proto.RegisterType((*Range)(nil), "object.Range")
|
||||
proto.RegisterType((*UserHeader)(nil), "object.UserHeader")
|
||||
proto.RegisterType((*Header)(nil), "object.Header")
|
||||
|
|
@ -911,77 +772,67 @@ func init() {
|
|||
proto.RegisterType((*Link)(nil), "object.Link")
|
||||
proto.RegisterType((*Transform)(nil), "object.Transform")
|
||||
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) }
|
||||
|
||||
var fileDescriptor_02021a1d39b1aee0 = []byte{
|
||||
// 996 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x55, 0xdf, 0x6e, 0xe3, 0xc4,
|
||||
0x17, 0xb6, 0x1d, 0x27, 0x71, 0x4e, 0xdd, 0xd6, 0x3b, 0xbf, 0xfd, 0x2d, 0x56, 0xd1, 0xb6, 0xc5,
|
||||
0xe2, 0x4f, 0x59, 0xa8, 0x2b, 0xda, 0x45, 0x2b, 0x90, 0x40, 0x34, 0x0d, 0x6c, 0x22, 0xca, 0xb6,
|
||||
0x9a, 0xb4, 0xbd, 0xe0, 0xce, 0x89, 0x27, 0xc9, 0xd0, 0x64, 0x26, 0xb2, 0x27, 0xbb, 0x1b, 0x1e,
|
||||
0x83, 0x1b, 0xb8, 0xe3, 0x75, 0xf6, 0x92, 0x3b, 0xd0, 0x5e, 0x44, 0x28, 0x3c, 0x00, 0x6f, 0x80,
|
||||
0xd0, 0x8c, 0xc7, 0x49, 0x9c, 0xad, 0xb8, 0x89, 0xe6, 0x9c, 0xef, 0xfb, 0x46, 0x27, 0xe7, 0x7c,
|
||||
0x67, 0x0c, 0x88, 0x77, 0x7e, 0x20, 0x5d, 0x71, 0x24, 0xa6, 0x63, 0x92, 0x86, 0xe3, 0x84, 0x0b,
|
||||
0x8e, 0x2a, 0x59, 0x6e, 0xc7, 0x4b, 0x48, 0x2f, 0x5d, 0x45, 0x76, 0xfe, 0x97, 0x92, 0x34, 0xa5,
|
||||
0x9c, 0x15, 0x92, 0x87, 0x7d, 0x2a, 0x06, 0x93, 0x4e, 0xd8, 0xe5, 0xa3, 0xa3, 0x3e, 0xef, 0xf3,
|
||||
0x23, 0x95, 0xee, 0x4c, 0x7a, 0x2a, 0x52, 0x81, 0x3a, 0x65, 0xf4, 0xe0, 0x09, 0x94, 0x71, 0xc4,
|
||||
0xfa, 0x04, 0x3d, 0x80, 0xca, 0x45, 0xaf, 0x97, 0x12, 0xe1, 0x9b, 0xfb, 0xe6, 0x81, 0x8d, 0x75,
|
||||
0x24, 0xf3, 0xe7, 0x84, 0xf5, 0xc5, 0xc0, 0xb7, 0xb2, 0x7c, 0x16, 0x05, 0x8f, 0x01, 0xae, 0x53,
|
||||
0x92, 0x34, 0x49, 0x14, 0x93, 0x04, 0x79, 0x50, 0xfa, 0x96, 0x4c, 0x95, 0xb4, 0x86, 0xe5, 0x11,
|
||||
0xdd, 0x87, 0xf2, 0x4d, 0x34, 0x9c, 0x10, 0x25, 0xab, 0xe1, 0x2c, 0x08, 0xfe, 0x29, 0x41, 0x45,
|
||||
0x4b, 0x02, 0xb0, 0xcf, 0x29, 0xbb, 0x55, 0x9a, 0x8d, 0x63, 0x37, 0xcc, 0xfe, 0x66, 0x28, 0x73,
|
||||
0x4d, 0x03, 0x2b, 0x0c, 0x7d, 0x04, 0x0e, 0x26, 0x31, 0x4d, 0x48, 0x57, 0xa8, 0x7b, 0x36, 0x8e,
|
||||
0x37, 0x43, 0xd9, 0x86, 0xf0, 0x34, 0x8e, 0x13, 0x92, 0xa6, 0x4d, 0x03, 0x2f, 0x08, 0xa8, 0x50,
|
||||
0x91, 0x5f, 0x52, 0x74, 0x94, 0x5f, 0xbb, 0x44, 0x9a, 0x06, 0x5e, 0xad, 0xfc, 0x13, 0xa8, 0x5d,
|
||||
0x25, 0x11, 0x4b, 0x7b, 0x3c, 0x19, 0xf9, 0xb6, 0x12, 0xdd, 0xcb, 0x45, 0x0b, 0xa0, 0x69, 0xe0,
|
||||
0x25, 0x4b, 0x49, 0xf8, 0xa8, 0x93, 0x0a, 0xce, 0x88, 0x5f, 0x5e, 0x93, 0xe4, 0x80, 0x92, 0xe4,
|
||||
0x01, 0xfa, 0x14, 0x2a, 0x37, 0x24, 0xa1, 0xbd, 0xa9, 0x5f, 0x51, 0xfc, 0xb7, 0x43, 0x3d, 0xbb,
|
||||
0x50, 0xa5, 0x69, 0x37, 0x12, 0x94, 0xb3, 0x45, 0x81, 0x9a, 0x8c, 0xde, 0x07, 0xa7, 0xc9, 0x47,
|
||||
0xbc, 0x19, 0xa5, 0x03, 0xbf, 0xba, 0x6f, 0x1e, 0xb8, 0x75, 0xe7, 0xf5, 0x6c, 0xcf, 0x96, 0xb1,
|
||||
0xfc, 0xeb, 0x39, 0x86, 0x1e, 0xc1, 0xf6, 0x65, 0x34, 0x1d, 0xf2, 0x28, 0x3e, 0x1b, 0x90, 0xee,
|
||||
0x6d, 0x3a, 0x19, 0xf9, 0x8e, 0xa4, 0x37, 0x0d, 0xbc, 0x0e, 0xa0, 0x27, 0x50, 0x6b, 0x31, 0x41,
|
||||
0xfa, 0x09, 0x15, 0x53, 0xbf, 0xa6, 0xaa, 0x79, 0x2b, 0xaf, 0x7e, 0x01, 0x2c, 0x2a, 0x59, 0x72,
|
||||
0xd1, 0xe7, 0xe0, 0xb6, 0x05, 0x4f, 0xa2, 0x3e, 0x79, 0x9a, 0xf0, 0xc9, 0xd8, 0x07, 0xa5, 0xbd,
|
||||
0x9f, 0x6b, 0x57, 0xb1, 0xa6, 0x81, 0x0b, 0xdc, 0x7a, 0x55, 0xbb, 0x21, 0x78, 0x67, 0xa5, 0x77,
|
||||
0xd2, 0x23, 0x5f, 0x8f, 0x79, 0x77, 0xa0, 0x2d, 0x97, 0x05, 0xc1, 0xdf, 0x26, 0xb8, 0xed, 0x69,
|
||||
0x2a, 0xc8, 0x48, 0x8f, 0xc8, 0x87, 0xea, 0x0d, 0x49, 0x64, 0xb7, 0x34, 0x31, 0x0f, 0xd1, 0xbb,
|
||||
0xb0, 0xa9, 0xff, 0x5e, 0xc1, 0xa3, 0xc5, 0x24, 0xda, 0x01, 0xab, 0xd5, 0x50, 0x86, 0x70, 0xeb,
|
||||
0xf0, 0x6a, 0xb6, 0x67, 0xbc, 0x9e, 0xed, 0x59, 0xad, 0x06, 0xb6, 0x5a, 0x0d, 0xf4, 0x21, 0x54,
|
||||
0x2f, 0x5e, 0x30, 0x92, 0xb4, 0x1a, 0x6a, 0xf8, 0x6e, 0x7d, 0x5b, 0x13, 0xf2, 0x34, 0xce, 0x0f,
|
||||
0xe8, 0x21, 0x94, 0xce, 0x5a, 0x0d, 0x35, 0x70, 0xb7, 0xbe, 0xa1, 0x69, 0x32, 0x85, 0xe5, 0x0f,
|
||||
0xfa, 0x0c, 0x6a, 0x67, 0x09, 0x89, 0x04, 0x89, 0x4f, 0x85, 0x9e, 0xf2, 0xff, 0xf3, 0xde, 0x28,
|
||||
0x80, 0x72, 0x76, 0xc9, 0x29, 0x13, 0x75, 0x5b, 0x6a, 0xf1, 0x92, 0x1d, 0x9c, 0xc2, 0x66, 0x81,
|
||||
0x81, 0x76, 0xc0, 0xb9, 0x66, 0xf4, 0xe5, 0x15, 0x1d, 0x11, 0xf5, 0x97, 0x4b, 0x78, 0x11, 0x2f,
|
||||
0x9b, 0x66, 0xad, 0x36, 0x8d, 0xc2, 0xf6, 0xda, 0xf0, 0xd0, 0x01, 0x6c, 0x67, 0xa7, 0x74, 0x61,
|
||||
0x0a, 0x79, 0x97, 0x8b, 0xd7, 0xd3, 0xe8, 0x63, 0xb8, 0x97, 0x9f, 0xdb, 0xb4, 0xcf, 0x22, 0x31,
|
||||
0x49, 0xb2, 0xbd, 0x75, 0xf1, 0x9b, 0x40, 0xf0, 0xab, 0x99, 0x6d, 0x2e, 0x7a, 0x0f, 0x6c, 0xf9,
|
||||
0xf2, 0xa8, 0x5b, 0xb7, 0x96, 0x2b, 0x20, 0xb1, 0xf0, 0x6a, 0x3a, 0x26, 0x58, 0xc1, 0xba, 0xfd,
|
||||
0xd6, 0x5d, 0xed, 0x0f, 0xae, 0xc0, 0x96, 0x4c, 0xb4, 0x01, 0xd5, 0x6b, 0x76, 0xcb, 0xf8, 0x0b,
|
||||
0xe6, 0x19, 0x08, 0xa0, 0x72, 0x19, 0x25, 0x84, 0x09, 0xcf, 0x44, 0x2e, 0x38, 0x97, 0x09, 0x79,
|
||||
0x4e, 0xf9, 0x24, 0xf5, 0x2c, 0xe4, 0x80, 0xfd, 0x8c, 0xbc, 0x14, 0x5e, 0x09, 0xd5, 0xa0, 0x7c,
|
||||
0x36, 0xa0, 0xc3, 0xd8, 0xb3, 0x91, 0x57, 0xf4, 0xa5, 0x57, 0x0e, 0x86, 0x2b, 0x3b, 0x8d, 0x1e,
|
||||
0x15, 0xaa, 0x7c, 0xf0, 0xc6, 0x6e, 0xaf, 0x94, 0x1a, 0x9c, 0xdc, 0x55, 0x4e, 0x0d, 0xca, 0xed,
|
||||
0xf1, 0x90, 0xca, 0x6a, 0x1c, 0xb0, 0x65, 0x1f, 0x3c, 0x4b, 0x26, 0xbf, 0xe3, 0x93, 0x61, 0xec,
|
||||
0x95, 0x82, 0x9f, 0x4c, 0xa8, 0x5c, 0xa8, 0x4b, 0xd1, 0x97, 0x45, 0xe7, 0xea, 0xb7, 0x6d, 0xb9,
|
||||
0x22, 0x2b, 0x98, 0x76, 0x41, 0xd1, 0xe9, 0x21, 0x54, 0xf5, 0x6c, 0x7c, 0x6b, 0xbf, 0x74, 0xb0,
|
||||
0x71, 0xbc, 0x95, 0x4b, 0x0b, 0xa2, 0x9c, 0x24, 0x37, 0x43, 0x5b, 0x3d, 0xb3, 0x37, 0xce, 0xc3,
|
||||
0xe0, 0x77, 0xab, 0xd8, 0x15, 0x14, 0x02, 0xba, 0x89, 0x86, 0x34, 0x56, 0x2e, 0x6b, 0x44, 0x22,
|
||||
0x6a, 0xd3, 0x1f, 0x89, 0xde, 0xa7, 0x3b, 0x10, 0xf4, 0x18, 0xb6, 0x96, 0x59, 0xf5, 0x00, 0x65,
|
||||
0x13, 0x74, 0xf5, 0x04, 0xd5, 0x23, 0x84, 0xd7, 0x38, 0xe8, 0x29, 0x38, 0x43, 0xda, 0x23, 0x42,
|
||||
0x1a, 0x37, 0x7b, 0x81, 0x1f, 0xde, 0xf5, 0x3e, 0x84, 0xe7, 0x9a, 0x54, 0x77, 0xe7, 0xb3, 0x3d,
|
||||
0x27, 0x8f, 0xf0, 0x42, 0xbc, 0xf3, 0xb3, 0x09, 0x8b, 0x34, 0xfa, 0x0a, 0xec, 0x09, 0xa3, 0x42,
|
||||
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,
|
||||
// 867 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x55, 0x4d, 0x73, 0xdb, 0x44,
|
||||
0x18, 0x96, 0x64, 0xf9, 0xeb, 0xb5, 0xd2, 0xa8, 0x4b, 0x29, 0x1a, 0x33, 0x38, 0x41, 0xc3, 0x47,
|
||||
0x28, 0x44, 0x19, 0x52, 0x98, 0x0e, 0x07, 0x18, 0xe2, 0x98, 0x41, 0x1e, 0x0a, 0xc9, 0x6c, 0x3e,
|
||||
0x0e, 0xdc, 0x64, 0x6b, 0x2d, 0x8b, 0xd8, 0xbb, 0x9e, 0xdd, 0x75, 0x5b, 0xdf, 0xf9, 0x05, 0x9c,
|
||||
0xb8, 0xf1, 0x77, 0x7a, 0xe4, 0xc8, 0xf4, 0x90, 0x61, 0xc2, 0x0f, 0xe0, 0x2f, 0x74, 0x76, 0x25,
|
||||
0xd9, 0x92, 0xdb, 0x8b, 0x67, 0xdf, 0xe7, 0x63, 0xfd, 0xea, 0xdd, 0x67, 0x25, 0x40, 0x6c, 0xf4,
|
||||
0x1b, 0x19, 0xcb, 0x23, 0xb9, 0x5a, 0x10, 0x11, 0x2c, 0x38, 0x93, 0x0c, 0x35, 0x32, 0xac, 0xeb,
|
||||
0x72, 0x32, 0x11, 0x65, 0xa6, 0xfb, 0x8e, 0x20, 0x42, 0xa4, 0x8c, 0x56, 0x40, 0x4f, 0x48, 0xc6,
|
||||
0xa3, 0x84, 0x24, 0x9c, 0x2d, 0x17, 0x15, 0xe6, 0x30, 0x49, 0xe5, 0x74, 0x39, 0x0a, 0xc6, 0x6c,
|
||||
0x7e, 0x94, 0xb0, 0x84, 0x1d, 0x69, 0x78, 0xb4, 0x9c, 0xe8, 0x4a, 0x17, 0x7a, 0x95, 0xc9, 0xfd,
|
||||
0x27, 0x50, 0xc7, 0x11, 0x4d, 0x08, 0x7a, 0x08, 0x8d, 0xb3, 0xc9, 0x44, 0x10, 0xe9, 0x99, 0xfb,
|
||||
0xe6, 0x81, 0x8d, 0xf3, 0x4a, 0xe1, 0x4f, 0x09, 0x4d, 0xe4, 0xd4, 0xb3, 0x32, 0x3c, 0xab, 0xfc,
|
||||
0xaf, 0x00, 0xae, 0x04, 0xe1, 0x21, 0x89, 0x62, 0xc2, 0x91, 0x0b, 0xb5, 0x9f, 0xc8, 0x4a, 0x5b,
|
||||
0xdb, 0x58, 0x2d, 0xd1, 0x03, 0xa8, 0x5f, 0x47, 0xb3, 0x25, 0xd1, 0xb6, 0x36, 0xce, 0x0a, 0xff,
|
||||
0x77, 0x1b, 0x1a, 0xb9, 0xc5, 0x07, 0xfb, 0x69, 0x4a, 0x6f, 0xb4, 0xa7, 0x73, 0xec, 0x04, 0xd9,
|
||||
0x00, 0x02, 0x85, 0x85, 0x06, 0xd6, 0x1c, 0xfa, 0x1c, 0x5a, 0x98, 0xc4, 0x29, 0x27, 0x63, 0xa9,
|
||||
0xf7, 0xe9, 0x1c, 0xef, 0x04, 0x6a, 0x40, 0xc1, 0x49, 0x1c, 0x73, 0x22, 0x44, 0x68, 0xe0, 0xb5,
|
||||
0x00, 0x55, 0x3a, 0xf2, 0x6a, 0x5a, 0x8e, 0x8a, 0x6d, 0x37, 0x4c, 0x68, 0xe0, 0x72, 0xe7, 0x5f,
|
||||
0x42, 0xfb, 0x92, 0x47, 0x54, 0x4c, 0x18, 0x9f, 0x7b, 0xb6, 0x36, 0xdd, 0x2f, 0x4c, 0x6b, 0x22,
|
||||
0x34, 0xf0, 0x46, 0xa5, 0x2d, 0x6c, 0x3e, 0x12, 0x92, 0x51, 0xe2, 0xd5, 0xb7, 0x2c, 0x05, 0xa1,
|
||||
0x2d, 0x45, 0x81, 0xbe, 0x86, 0xc6, 0x35, 0xe1, 0xe9, 0x64, 0xe5, 0x35, 0xb4, 0xfe, 0xfd, 0x20,
|
||||
0x3f, 0xd5, 0x40, 0xc3, 0xe9, 0x38, 0x92, 0x29, 0xa3, 0xeb, 0x06, 0x73, 0x31, 0xfa, 0x04, 0x5a,
|
||||
0x21, 0x9b, 0xb3, 0x30, 0x12, 0x53, 0xaf, 0xb9, 0x6f, 0x1e, 0x38, 0xfd, 0xd6, 0xab, 0xdb, 0x3d,
|
||||
0x5b, 0xd5, 0xea, 0xd1, 0x0b, 0x0e, 0x3d, 0x82, 0xdd, 0xf3, 0x68, 0x35, 0x63, 0x51, 0x7c, 0x3a,
|
||||
0x25, 0xe3, 0x1b, 0xb1, 0x9c, 0x7b, 0x2d, 0x25, 0x0f, 0x0d, 0xbc, 0x4d, 0xa0, 0x27, 0xd0, 0x1e,
|
||||
0x52, 0x49, 0x12, 0x9e, 0xca, 0x95, 0xd7, 0xd6, 0xdd, 0xbc, 0x57, 0x74, 0xbf, 0x26, 0xd6, 0x9d,
|
||||
0x6c, 0xb4, 0xe8, 0x7b, 0x70, 0x2e, 0xb2, 0xd4, 0xfd, 0xa8, 0x52, 0xe7, 0x81, 0xf6, 0x76, 0x83,
|
||||
0x72, 0x14, 0x83, 0xb2, 0x22, 0x34, 0x70, 0xc5, 0xd1, 0x6f, 0xe6, 0x99, 0xf0, 0x3f, 0x2c, 0x4d,
|
||||
0x50, 0x25, 0xe5, 0x87, 0x05, 0x1b, 0x4f, 0xf3, 0xe0, 0x65, 0x85, 0xff, 0xbf, 0x09, 0xce, 0xc5,
|
||||
0x4a, 0x48, 0x32, 0xcf, 0x0f, 0xca, 0x83, 0xe6, 0x35, 0xe1, 0x6a, 0x66, 0xb9, 0xb0, 0x28, 0xd1,
|
||||
0x47, 0xb0, 0x93, 0x3f, 0x64, 0x25, 0xa9, 0x55, 0x10, 0x75, 0xc1, 0x1a, 0x0e, 0x74, 0x2c, 0x9c,
|
||||
0x3e, 0xbc, 0xbc, 0xdd, 0x33, 0x5e, 0xdd, 0xee, 0x59, 0xc3, 0x01, 0xb6, 0x86, 0x03, 0xf4, 0x19,
|
||||
0x34, 0xcf, 0x9e, 0x53, 0xc2, 0x87, 0x03, 0x1d, 0x01, 0xa7, 0xbf, 0x9b, 0x0b, 0x0a, 0x18, 0x17,
|
||||
0x0b, 0xf4, 0x01, 0xd4, 0x4e, 0x87, 0x03, 0x7d, 0xec, 0x4e, 0xbf, 0x93, 0xcb, 0x14, 0x84, 0xd5,
|
||||
0x0f, 0xfa, 0x06, 0xda, 0xa7, 0x9c, 0x44, 0x92, 0xc4, 0x27, 0x32, 0x3f, 0xeb, 0x77, 0x8b, 0xe9,
|
||||
0x6a, 0x22, 0x65, 0xf4, 0x9c, 0xa5, 0x54, 0xf6, 0x6d, 0xe5, 0xc5, 0x1b, 0xb5, 0x7f, 0x02, 0x3b,
|
||||
0x15, 0x05, 0xea, 0x42, 0xeb, 0x8a, 0xa6, 0x2f, 0x2e, 0xd3, 0x39, 0xd1, 0x8f, 0x5c, 0xc3, 0xeb,
|
||||
0x7a, 0x33, 0x34, 0xab, 0x3c, 0xb4, 0x14, 0x76, 0xb7, 0x8e, 0x10, 0x1d, 0xc0, 0x6e, 0xb6, 0x12,
|
||||
0xeb, 0x68, 0xa8, 0xbd, 0x1c, 0xbc, 0x0d, 0xa3, 0x2f, 0xe0, 0x7e, 0xb1, 0xbe, 0x48, 0x13, 0x1a,
|
||||
0xc9, 0x25, 0xcf, 0x6e, 0xaf, 0x83, 0xdf, 0x24, 0xfc, 0xbf, 0xcc, 0xec, 0xfe, 0xa2, 0x8f, 0xc1,
|
||||
0x56, 0xef, 0x1f, 0xbd, 0xeb, 0xbd, 0xcd, 0x45, 0x50, 0x5c, 0x70, 0xb9, 0x5a, 0x10, 0xac, 0xe9,
|
||||
0x7c, 0xfc, 0xd6, 0xdb, 0xc6, 0xef, 0x5f, 0x82, 0xad, 0x94, 0xa8, 0x03, 0xcd, 0x2b, 0x7a, 0x43,
|
||||
0xd9, 0x73, 0xea, 0x1a, 0x08, 0xa0, 0x71, 0x1e, 0x71, 0x42, 0xa5, 0x6b, 0x22, 0x07, 0x5a, 0xe7,
|
||||
0x9c, 0x3c, 0x4b, 0xd9, 0x52, 0xb8, 0x16, 0x6a, 0x81, 0xfd, 0x0b, 0x79, 0x21, 0xdd, 0x1a, 0x6a,
|
||||
0x43, 0xfd, 0x74, 0x9a, 0xce, 0x62, 0xd7, 0x46, 0x6e, 0x35, 0x9d, 0x6e, 0xdd, 0x9f, 0x95, 0x6e,
|
||||
0x36, 0x7a, 0x54, 0xe9, 0xf2, 0xe1, 0x1b, 0x37, 0xbc, 0xd4, 0xaa, 0xff, 0xf8, 0x6d, 0xed, 0xb4,
|
||||
0xa1, 0x7e, 0xb1, 0x98, 0xa5, 0xaa, 0x9b, 0x16, 0xd8, 0x6a, 0x0e, 0xae, 0xa5, 0xc0, 0x9f, 0xd9,
|
||||
0x72, 0x16, 0xbb, 0x35, 0xff, 0x0f, 0x13, 0x1a, 0x67, 0x7a, 0x53, 0xf4, 0x5d, 0x35, 0xb9, 0xf9,
|
||||
0x1b, 0xee, 0x41, 0xf1, 0x9f, 0x65, 0x2e, 0x4f, 0x41, 0x35, 0xe9, 0x01, 0x34, 0xf3, 0xb3, 0xf1,
|
||||
0xac, 0xfd, 0xda, 0x41, 0xe7, 0xf8, 0x5e, 0x61, 0xad, 0x98, 0x0a, 0x91, 0xba, 0x19, 0x79, 0xd4,
|
||||
0xb3, 0x78, 0xe3, 0xa2, 0xec, 0x7f, 0xfb, 0xf2, 0xae, 0x67, 0xfe, 0x7d, 0xd7, 0x33, 0xff, 0xb9,
|
||||
0xeb, 0x99, 0xff, 0xde, 0xf5, 0xcc, 0x3f, 0xff, 0xeb, 0x19, 0xbf, 0x7e, 0x5a, 0xfa, 0x44, 0x50,
|
||||
0xb1, 0x18, 0x8f, 0x0f, 0x63, 0xf2, 0xec, 0x88, 0x12, 0x36, 0x11, 0x87, 0xd9, 0x07, 0x22, 0xfb,
|
||||
0xbb, 0x51, 0x43, 0x57, 0x8f, 0x5f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x40, 0x7d, 0xa2, 0x84, 0xb1,
|
||||
0x06, 0x00, 0x00,
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
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
|
||||
|
|
@ -2028,45 +1788,6 @@ func (m *Object) Size() (n int) {
|
|||
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) {
|
||||
return (math_bits.Len64(x|1) + 6) / 7
|
||||
}
|
||||
|
|
@ -2655,7 +2376,7 @@ func (m *Header) Unmarshal(dAtA []byte) error {
|
|||
if postIndex > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
v := &StorageGroup{}
|
||||
v := &storagegroup.StorageGroup{}
|
||||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
|
|
@ -3531,240 +3252,6 @@ func (m *Object) Unmarshal(dAtA []byte) error {
|
|||
}
|
||||
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) {
|
||||
l := len(dAtA)
|
||||
iNdEx := 0
|
||||
|
|
|
|||
|
|
@ -4,6 +4,7 @@ option go_package = "github.com/nspcc-dev/neofs-proto/object";
|
|||
|
||||
import "refs/types.proto";
|
||||
import "session/types.proto";
|
||||
import "storagegroup/types.proto";
|
||||
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
|
||||
|
||||
option (gogoproto.stable_marshaler_all) = true;
|
||||
|
|
@ -25,25 +26,25 @@ message UserHeader {
|
|||
message Header {
|
||||
oneof Value {
|
||||
// Link to other objects
|
||||
Link Link = 1;
|
||||
Link Link = 1;
|
||||
// Redirect not used yet
|
||||
refs.Address Redirect = 2;
|
||||
refs.Address Redirect = 2;
|
||||
// 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 Transform = 4;
|
||||
Transform Transform = 4;
|
||||
// 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
|
||||
session.VerificationHeader Verify = 6;
|
||||
session.VerificationHeader Verify = 6;
|
||||
// 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
|
||||
bytes PayloadChecksum = 8;
|
||||
bytes PayloadChecksum = 8;
|
||||
// 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 StorageGroup = 10;
|
||||
storagegroup.StorageGroup StorageGroup = 10;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -124,29 +125,3 @@ message Object {
|
|||
// Payload is an object's payload
|
||||
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
39
storagegroup/storage.go
Normal 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
97
storagegroup/types.go
Normal 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
663
storagegroup/types.pb.go
Normal 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
35
storagegroup/types.proto
Normal 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"];
|
||||
}
|
||||
Loading…
Reference in a new issue