realloc/frostfs-api-go
1
0
Fork 0
forked from TrueCloudLab/frostfs-api-go
Code Issues Pull requests Projects Releases Packages Wiki Activity

Remove v1 code

Browse source
This commit is contained in:
Alex Vanin 2020-08-12 09:37:59 +03:00 • committed by Stanislav Bogatyrev
parent ed7879a89e
commit 0a5d0ff1a2
140 changed files with 0 additions and 45161 deletions
Download patch file Download diff file Expand all files Collapse all files

39
storagegroup/storage.go
View file

@ -1,39 +0,0 @@
package storagegroup
import (
"context"
"github.com/nspcc-dev/neofs-api-go/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
View file

@ -1,97 +0,0 @@
package storagegroup
import (
"bytes"
"strconv"
"strings"
"github.com/gogo/protobuf/proto"
"github.com/mr-tron/base58"
"github.com/nspcc-dev/neofs-api-go/hash"
"github.com/nspcc-dev/neofs-api-go/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)
}

664
storagegroup/types.pb.go
View file

@ -1,664 +0,0 @@
// 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{
// 377 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x51, 0x31, 0x6b, 0xdb, 0x40,
0x14, 0xd6, 0xc9, 0x6a, 0x51, 0xaf, 0xaa, 0x31, 0x47, 0x29, 0xc2, 0x83, 0x64, 0xdc, 0x45, 0x8b,
0x4e, 0x60, 0x77, 0xea, 0x56, 0xd1, 0xba, 0x2d, 0x24, 0x21, 0xc8, 0xb1, 0x87, 0x40, 0x86, 0xb3,
0x7c, 0x96, 0x0f, 0x24, 0x9d, 0xb0, 0x4e, 0x21, 0xc9, 0x2f, 0xf1, 0x12, 0xc8, 0x9c, 0x5f, 0xe2,
0x31, 0x63, 0xc8, 0x20, 0x82, 0x32, 0xe5, 0x5f, 0x04, 0x9f, 0x13, 0x47, 0x09, 0x19, 0xb2, 0xbd,
0xef, 0x7b, 0xdf, 0xf7, 0xde, 0xfb, 0x78, 0xd0, 0xcc, 0x05, 0x5f, 0x90, 0x88, 0x46, 0x0b, 0x5e,
0x64, 0x9e, 0x38, 0xcd, 0x68, 0x8e, 0xb3, 0x05, 0x17, 0x1c, 0x19, 0xf5, 0x4e, 0xdb, 0x8d, 0x98,
0x98, 0x17, 0x13, 0x1c, 0xf2, 0xc4, 0x8b, 0x78, 0xc4, 0x3d, 0x29, 0x9a, 0x14, 0x33, 0x89, 0x24,
0x90, 0xd5, 0xc6, 0xdc, 0xbd, 0x57, 0xa1, 0x31, 0xdc, 0xf8, 0xff, 0xae, 0xfd, 0x08, 0x43, 0x34,
0x26, 0x31, 0x9b, 0x12, 0xc1, 0x78, 0xfa, 0x9b, 0x08, 0x32, 0x64, 0x67, 0xd4, 0x04, 0x1d, 0xe0,
0x68, 0xc1, 0x1b, 0x1d, 0xf4, 0x03, 0x36, 0x9f, 0xd9, 0x7f, 0x24, 0x9f, 0x9b, 0x6a, 0x07, 0x38,
0x86, 0x6f, 0xac, 0x4a, 0x5b, 0xb9, 0x29, 0x6d, 0x6d, 0xcd, 0x05, 0xaf, 0x34, 0x68, 0x17, 0xea,
0x31, 0x9b, 0x51, 0xc1, 0x12, 0x6a, 0x36, 0x3a, 0xc0, 0xf9, 0xdc, 0xfb, 0x8e, 0xeb, 0x31, 0x70,
0xfd, 0x26, 0xbc, 0xf3, 0x28, 0xf5, 0x8d, 0xaa, 0xb4, 0xf5, 0x27, 0x14, 0x6c, 0x47, 0xb4, 0xcf,
0x01, 0xdc, 0xd2, 0x68, 0x00, 0xb5, 0x22, 0x65, 0x42, 0xde, 0xdc, 0xec, 0x39, 0xef, 0x98, 0x8b,
0x47, 0x29, 0x13, 0xbe, 0x5e, 0x95, 0xb6, 0xb6, 0xae, 0x02, 0xe9, 0x47, 0x5f, 0xe1, 0x87, 0x31,
0x89, 0x0b, 0x2a, 0x03, 0x35, 0x82, 0x0d, 0xe8, 0xf6, 0xa1, 0xd4, 0xa0, 0x2f, 0xf0, 0xd3, 0x28,
0x8d, 0x59, 0xc2, 0x04, 0x9d, 0xb6, 0x14, 0xd4, 0x84, 0x70, 0x8f, 0xf2, 0xc1, 0xf0, 0x4f, 0xc6,
0xc3, 0x79, 0x0b, 0x20, 0x03, 0xea, 0xa3, 0x94, 0x9d, 0x1c, 0xb0, 0x84, 0xb6, 0xd4, 0x9f, 0xda,
0xf2, 0xc2, 0x56, 0xfc, 0xa3, 0x55, 0x65, 0x81, 0xab, 0xca, 0x02, 0xd7, 0x95, 0x05, 0x6e, 0x2b,
0x0b, 0x2c, 0xef, 0x2c, 0xe5, 0x10, 0xd7, 0x1e, 0x96, 0xe6, 0x59, 0x18, 0xba, 0x53, 0x7a, 0xec,
0xa5, 0x94, 0xcf, 0x72, 0x97, 0x64, 0xcc, 0x8d, 0xb8, 0x57, 0x4f, 0x70, 0xa9, 0x7e, 0x93, 0x8b,
0xf0, 0xaf, 0xfd, 0xff, 0x2f, 0xd2, 0x4c, 0x3e, 0xca, 0x8f, 0xf6, 0x1f, 0x02, 0x00, 0x00, 0xff,
0xff, 0xf8, 0x32, 0x27, 0x9d, 0x2a, 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")
)

36
storagegroup/types.proto
View file

@ -1,36 +0,0 @@
syntax = "proto3";
package storagegroup;
option go_package = "github.com/nspcc-dev/neofs-api-go/storagegroup";
option csharp_namespace = "NeoFS.API.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"];
}