syncthing/lib/protocol/bep.pb.go

6843 lines
168 KiB
Go
Raw Normal View History

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: lib/protocol/bep.proto
package protocol
import (
fmt "fmt"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
_ "github.com/syncthing/syncthing/proto/ext"
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.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type MessageType int32
const (
MessageTypeClusterConfig MessageType = 0
MessageTypeIndex MessageType = 1
MessageTypeIndexUpdate MessageType = 2
MessageTypeRequest MessageType = 3
MessageTypeResponse MessageType = 4
MessageTypeDownloadProgress MessageType = 5
MessageTypePing MessageType = 6
MessageTypeClose MessageType = 7
)
var MessageType_name = map[int32]string{
0: "MESSAGE_TYPE_CLUSTER_CONFIG",
1: "MESSAGE_TYPE_INDEX",
2: "MESSAGE_TYPE_INDEX_UPDATE",
3: "MESSAGE_TYPE_REQUEST",
4: "MESSAGE_TYPE_RESPONSE",
5: "MESSAGE_TYPE_DOWNLOAD_PROGRESS",
6: "MESSAGE_TYPE_PING",
7: "MESSAGE_TYPE_CLOSE",
}
var MessageType_value = map[string]int32{
"MESSAGE_TYPE_CLUSTER_CONFIG": 0,
"MESSAGE_TYPE_INDEX": 1,
"MESSAGE_TYPE_INDEX_UPDATE": 2,
"MESSAGE_TYPE_REQUEST": 3,
"MESSAGE_TYPE_RESPONSE": 4,
"MESSAGE_TYPE_DOWNLOAD_PROGRESS": 5,
"MESSAGE_TYPE_PING": 6,
"MESSAGE_TYPE_CLOSE": 7,
}
func (x MessageType) String() string {
return proto.EnumName(MessageType_name, int32(x))
}
func (MessageType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{0}
}
type MessageCompression int32
const (
MessageCompressionNone MessageCompression = 0
MessageCompressionLZ4 MessageCompression = 1
)
var MessageCompression_name = map[int32]string{
0: "MESSAGE_COMPRESSION_NONE",
1: "MESSAGE_COMPRESSION_LZ4",
}
var MessageCompression_value = map[string]int32{
"MESSAGE_COMPRESSION_NONE": 0,
"MESSAGE_COMPRESSION_LZ4": 1,
}
func (x MessageCompression) String() string {
return proto.EnumName(MessageCompression_name, int32(x))
}
func (MessageCompression) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{1}
}
type Compression int32
const (
CompressionMetadata Compression = 0
CompressionNever Compression = 1
CompressionAlways Compression = 2
)
var Compression_name = map[int32]string{
0: "COMPRESSION_METADATA",
1: "COMPRESSION_NEVER",
2: "COMPRESSION_ALWAYS",
}
var Compression_value = map[string]int32{
"COMPRESSION_METADATA": 0,
"COMPRESSION_NEVER": 1,
"COMPRESSION_ALWAYS": 2,
}
func (x Compression) String() string {
return proto.EnumName(Compression_name, int32(x))
}
func (Compression) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{2}
}
type FileInfoType int32
const (
FileInfoTypeFile FileInfoType = 0
FileInfoTypeDirectory FileInfoType = 1
FileInfoTypeSymlinkFile FileInfoType = 2 // Deprecated: Do not use.
FileInfoTypeSymlinkDirectory FileInfoType = 3 // Deprecated: Do not use.
FileInfoTypeSymlink FileInfoType = 4
)
var FileInfoType_name = map[int32]string{
0: "FILE_INFO_TYPE_FILE",
1: "FILE_INFO_TYPE_DIRECTORY",
2: "FILE_INFO_TYPE_SYMLINK_FILE",
3: "FILE_INFO_TYPE_SYMLINK_DIRECTORY",
4: "FILE_INFO_TYPE_SYMLINK",
}
var FileInfoType_value = map[string]int32{
"FILE_INFO_TYPE_FILE": 0,
"FILE_INFO_TYPE_DIRECTORY": 1,
"FILE_INFO_TYPE_SYMLINK_FILE": 2,
"FILE_INFO_TYPE_SYMLINK_DIRECTORY": 3,
"FILE_INFO_TYPE_SYMLINK": 4,
}
func (x FileInfoType) String() string {
return proto.EnumName(FileInfoType_name, int32(x))
}
func (FileInfoType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{3}
}
type ErrorCode int32
const (
ErrorCodeNoError ErrorCode = 0
ErrorCodeGeneric ErrorCode = 1
ErrorCodeNoSuchFile ErrorCode = 2
ErrorCodeInvalidFile ErrorCode = 3
)
var ErrorCode_name = map[int32]string{
0: "ERROR_CODE_NO_ERROR",
1: "ERROR_CODE_GENERIC",
2: "ERROR_CODE_NO_SUCH_FILE",
3: "ERROR_CODE_INVALID_FILE",
}
var ErrorCode_value = map[string]int32{
"ERROR_CODE_NO_ERROR": 0,
"ERROR_CODE_GENERIC": 1,
"ERROR_CODE_NO_SUCH_FILE": 2,
"ERROR_CODE_INVALID_FILE": 3,
}
func (x ErrorCode) String() string {
return proto.EnumName(ErrorCode_name, int32(x))
}
func (ErrorCode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{4}
}
type FileDownloadProgressUpdateType int32
const (
FileDownloadProgressUpdateTypeAppend FileDownloadProgressUpdateType = 0
FileDownloadProgressUpdateTypeForget FileDownloadProgressUpdateType = 1
)
var FileDownloadProgressUpdateType_name = map[int32]string{
0: "FILE_DOWNLOAD_PROGRESS_UPDATE_TYPE_APPEND",
1: "FILE_DOWNLOAD_PROGRESS_UPDATE_TYPE_FORGET",
}
var FileDownloadProgressUpdateType_value = map[string]int32{
"FILE_DOWNLOAD_PROGRESS_UPDATE_TYPE_APPEND": 0,
"FILE_DOWNLOAD_PROGRESS_UPDATE_TYPE_FORGET": 1,
}
func (x FileDownloadProgressUpdateType) String() string {
return proto.EnumName(FileDownloadProgressUpdateType_name, int32(x))
}
func (FileDownloadProgressUpdateType) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{5}
}
type Hello struct {
DeviceName string `protobuf:"bytes,1,opt,name=device_name,json=deviceName,proto3" json:"deviceName" xml:"deviceName"`
ClientName string `protobuf:"bytes,2,opt,name=client_name,json=clientName,proto3" json:"clientName" xml:"clientName"`
ClientVersion string `protobuf:"bytes,3,opt,name=client_version,json=clientVersion,proto3" json:"clientVersion" xml:"clientVersion"`
}
func (m *Hello) Reset() { *m = Hello{} }
func (m *Hello) String() string { return proto.CompactTextString(m) }
func (*Hello) ProtoMessage() {}
func (*Hello) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{0}
}
func (m *Hello) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Hello) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Hello.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Hello) XXX_Merge(src proto.Message) {
xxx_messageInfo_Hello.Merge(m, src)
}
func (m *Hello) XXX_Size() int {
return m.ProtoSize()
}
func (m *Hello) XXX_DiscardUnknown() {
xxx_messageInfo_Hello.DiscardUnknown(m)
}
var xxx_messageInfo_Hello proto.InternalMessageInfo
type Header struct {
Type MessageType `protobuf:"varint,1,opt,name=type,proto3,enum=protocol.MessageType" json:"type" xml:"type"`
Compression MessageCompression `protobuf:"varint,2,opt,name=compression,proto3,enum=protocol.MessageCompression" json:"compression" xml:"compression"`
}
func (m *Header) Reset() { *m = Header{} }
func (m *Header) String() string { return proto.CompactTextString(m) }
func (*Header) ProtoMessage() {}
func (*Header) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{1}
}
func (m *Header) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Header.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Header) XXX_Merge(src proto.Message) {
xxx_messageInfo_Header.Merge(m, src)
}
func (m *Header) XXX_Size() int {
return m.ProtoSize()
}
func (m *Header) XXX_DiscardUnknown() {
xxx_messageInfo_Header.DiscardUnknown(m)
}
var xxx_messageInfo_Header proto.InternalMessageInfo
type ClusterConfig struct {
2023-05-23 12:53:48 +00:00
Folders []Folder `protobuf:"bytes,1,rep,name=folders,proto3" json:"folders" xml:"folder"`
Secondary bool `protobuf:"varint,2,opt,name=secondary,proto3" json:"secondary" xml:"secondary"`
}
func (m *ClusterConfig) Reset() { *m = ClusterConfig{} }
func (m *ClusterConfig) String() string { return proto.CompactTextString(m) }
func (*ClusterConfig) ProtoMessage() {}
func (*ClusterConfig) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{2}
}
func (m *ClusterConfig) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *ClusterConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_ClusterConfig.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *ClusterConfig) XXX_Merge(src proto.Message) {
xxx_messageInfo_ClusterConfig.Merge(m, src)
}
func (m *ClusterConfig) XXX_Size() int {
return m.ProtoSize()
}
func (m *ClusterConfig) XXX_DiscardUnknown() {
xxx_messageInfo_ClusterConfig.DiscardUnknown(m)
}
var xxx_messageInfo_ClusterConfig proto.InternalMessageInfo
type Folder struct {
ID string `protobuf:"bytes,1,opt,name=id,proto3" json:"id" xml:"id"`
Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label" xml:"label"`
ReadOnly bool `protobuf:"varint,3,opt,name=read_only,json=readOnly,proto3" json:"readOnly" xml:"readOnly"`
IgnorePermissions bool `protobuf:"varint,4,opt,name=ignore_permissions,json=ignorePermissions,proto3" json:"ignorePermissions" xml:"ignorePermissions"`
IgnoreDelete bool `protobuf:"varint,5,opt,name=ignore_delete,json=ignoreDelete,proto3" json:"ignoreDelete" xml:"ignoreDelete"`
DisableTempIndexes bool `protobuf:"varint,6,opt,name=disable_temp_indexes,json=disableTempIndexes,proto3" json:"disableTempIndexes" xml:"disableTempIndexes"`
Paused bool `protobuf:"varint,7,opt,name=paused,proto3" json:"paused" xml:"paused"`
Devices []Device `protobuf:"bytes,16,rep,name=devices,proto3" json:"devices" xml:"device"`
}
func (m *Folder) Reset() { *m = Folder{} }
func (m *Folder) String() string { return proto.CompactTextString(m) }
func (*Folder) ProtoMessage() {}
func (*Folder) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{3}
}
func (m *Folder) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Folder) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Folder.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Folder) XXX_Merge(src proto.Message) {
xxx_messageInfo_Folder.Merge(m, src)
}
func (m *Folder) XXX_Size() int {
return m.ProtoSize()
}
func (m *Folder) XXX_DiscardUnknown() {
xxx_messageInfo_Folder.DiscardUnknown(m)
}
var xxx_messageInfo_Folder proto.InternalMessageInfo
type Device struct {
ID DeviceID `protobuf:"bytes,1,opt,name=id,proto3,customtype=DeviceID" json:"id" xml:"id"`
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name" xml:"name"`
Addresses []string `protobuf:"bytes,3,rep,name=addresses,proto3" json:"addresses" xml:"address"`
Compression Compression `protobuf:"varint,4,opt,name=compression,proto3,enum=protocol.Compression" json:"compression" xml:"compression"`
CertName string `protobuf:"bytes,5,opt,name=cert_name,json=certName,proto3" json:"certName" xml:"certName"`
MaxSequence int64 `protobuf:"varint,6,opt,name=max_sequence,json=maxSequence,proto3" json:"maxSequence" xml:"maxSequence"`
Introducer bool `protobuf:"varint,7,opt,name=introducer,proto3" json:"introducer" xml:"introducer"`
IndexID IndexID `protobuf:"varint,8,opt,name=index_id,json=indexId,proto3,customtype=IndexID" json:"indexId" xml:"indexId"`
SkipIntroductionRemovals bool `protobuf:"varint,9,opt,name=skip_introduction_removals,json=skipIntroductionRemovals,proto3" json:"skipIntroductionRemovals" xml:"skipIntroductionRemovals"`
EncryptionPasswordToken []byte `protobuf:"bytes,10,opt,name=encryption_password_token,json=encryptionPasswordToken,proto3" json:"encryptionPasswordToken" xml:"encryptionPasswordToken"`
}
func (m *Device) Reset() { *m = Device{} }
func (m *Device) String() string { return proto.CompactTextString(m) }
func (*Device) ProtoMessage() {}
func (*Device) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{4}
}
func (m *Device) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Device) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Device.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Device) XXX_Merge(src proto.Message) {
xxx_messageInfo_Device.Merge(m, src)
}
func (m *Device) XXX_Size() int {
return m.ProtoSize()
}
func (m *Device) XXX_DiscardUnknown() {
xxx_messageInfo_Device.DiscardUnknown(m)
}
var xxx_messageInfo_Device proto.InternalMessageInfo
type Index struct {
Folder string `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder" xml:"folder"`
Files []FileInfo `protobuf:"bytes,2,rep,name=files,proto3" json:"files" xml:"file"`
}
func (m *Index) Reset() { *m = Index{} }
func (m *Index) String() string { return proto.CompactTextString(m) }
func (*Index) ProtoMessage() {}
func (*Index) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{5}
}
func (m *Index) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Index) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Index.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Index) XXX_Merge(src proto.Message) {
xxx_messageInfo_Index.Merge(m, src)
}
func (m *Index) XXX_Size() int {
return m.ProtoSize()
}
func (m *Index) XXX_DiscardUnknown() {
xxx_messageInfo_Index.DiscardUnknown(m)
}
var xxx_messageInfo_Index proto.InternalMessageInfo
type IndexUpdate struct {
Folder string `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder" xml:"folder"`
Files []FileInfo `protobuf:"bytes,2,rep,name=files,proto3" json:"files" xml:"file"`
}
func (m *IndexUpdate) Reset() { *m = IndexUpdate{} }
func (m *IndexUpdate) String() string { return proto.CompactTextString(m) }
func (*IndexUpdate) ProtoMessage() {}
func (*IndexUpdate) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{6}
}
func (m *IndexUpdate) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *IndexUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_IndexUpdate.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *IndexUpdate) XXX_Merge(src proto.Message) {
xxx_messageInfo_IndexUpdate.Merge(m, src)
}
func (m *IndexUpdate) XXX_Size() int {
return m.ProtoSize()
}
func (m *IndexUpdate) XXX_DiscardUnknown() {
xxx_messageInfo_IndexUpdate.DiscardUnknown(m)
}
var xxx_messageInfo_IndexUpdate proto.InternalMessageInfo
type FileInfo struct {
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name" xml:"name"`
Size int64 `protobuf:"varint,3,opt,name=size,proto3" json:"size" xml:"size"`
ModifiedS int64 `protobuf:"varint,5,opt,name=modified_s,json=modifiedS,proto3" json:"modifiedS" xml:"modifiedS"`
ModifiedBy ShortID `protobuf:"varint,12,opt,name=modified_by,json=modifiedBy,proto3,customtype=ShortID" json:"modifiedBy" xml:"modifiedBy"`
Version Vector `protobuf:"bytes,9,opt,name=version,proto3" json:"version" xml:"version"`
Sequence int64 `protobuf:"varint,10,opt,name=sequence,proto3" json:"sequence" xml:"sequence"`
Blocks []BlockInfo `protobuf:"bytes,16,rep,name=blocks,proto3" json:"blocks" xml:"block"`
SymlinkTarget string `protobuf:"bytes,17,opt,name=symlink_target,json=symlinkTarget,proto3" json:"symlinkTarget" xml:"symlinkTarget"`
BlocksHash []byte `protobuf:"bytes,18,opt,name=blocks_hash,json=blocksHash,proto3" json:"blocksHash" xml:"blocksHash"`
Encrypted []byte `protobuf:"bytes,19,opt,name=encrypted,proto3" json:"encrypted" xml:"encrypted"`
Type FileInfoType `protobuf:"varint,2,opt,name=type,proto3,enum=protocol.FileInfoType" json:"type" xml:"type"`
Permissions uint32 `protobuf:"varint,4,opt,name=permissions,proto3" json:"permissions" xml:"permissions"`
ModifiedNs int `protobuf:"varint,11,opt,name=modified_ns,json=modifiedNs,proto3,casttype=int" json:"modifiedNs" xml:"modifiedNs"`
RawBlockSize int `protobuf:"varint,13,opt,name=block_size,json=blockSize,proto3,casttype=int" json:"blockSize" xml:"blockSize"`
Platform PlatformData `protobuf:"bytes,14,opt,name=platform,proto3" json:"platform" xml:"platform"`
// The local_flags fields stores flags that are relevant to the local
// host only. It is not part of the protocol, doesn't get sent or
// received (we make sure to zero it), nonetheless we need it on our
// struct and to be able to serialize it to/from the database.
LocalFlags uint32 `protobuf:"varint,1000,opt,name=local_flags,json=localFlags,proto3" json:"localFlags" xml:"localFlags"`
// The version_hash is an implementation detail and not part of the wire
// format.
VersionHash []byte `protobuf:"bytes,1001,opt,name=version_hash,json=versionHash,proto3" json:"versionHash" xml:"versionHash"`
// The time when the inode was last changed (i.e., permissions, xattrs
// etc changed). This is host-local, not sent over the wire.
InodeChangeNs int64 `protobuf:"varint,1002,opt,name=inode_change_ns,json=inodeChangeNs,proto3" json:"inodeChangeNs" xml:"inodeChangeNs"`
// The size of the data appended to the encrypted file on disk. This is
// host-local, not sent over the wire.
EncryptionTrailerSize int `protobuf:"varint,1003,opt,name=encryption_trailer_size,json=encryptionTrailerSize,proto3,casttype=int" json:"encryptionTrailerSize" xml:"encryptionTrailerSize"`
Deleted bool `protobuf:"varint,6,opt,name=deleted,proto3" json:"deleted" xml:"deleted"`
RawInvalid bool `protobuf:"varint,7,opt,name=invalid,proto3" json:"invalid" xml:"invalid"`
NoPermissions bool `protobuf:"varint,8,opt,name=no_permissions,json=noPermissions,proto3" json:"noPermissions" xml:"noPermissions"`
}
func (m *FileInfo) Reset() { *m = FileInfo{} }
func (*FileInfo) ProtoMessage() {}
func (*FileInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{7}
}
func (m *FileInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *FileInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_FileInfo.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *FileInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_FileInfo.Merge(m, src)
}
func (m *FileInfo) XXX_Size() int {
return m.ProtoSize()
}
func (m *FileInfo) XXX_DiscardUnknown() {
xxx_messageInfo_FileInfo.DiscardUnknown(m)
}
var xxx_messageInfo_FileInfo proto.InternalMessageInfo
type BlockInfo struct {
Hash []byte `protobuf:"bytes,3,opt,name=hash,proto3" json:"hash" xml:"hash"`
Offset int64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset" xml:"offset"`
Size int `protobuf:"varint,2,opt,name=size,proto3,casttype=int" json:"size" xml:"size"`
WeakHash uint32 `protobuf:"varint,4,opt,name=weak_hash,json=weakHash,proto3" json:"weakHash" xml:"weakHash"`
}
func (m *BlockInfo) Reset() { *m = BlockInfo{} }
func (*BlockInfo) ProtoMessage() {}
func (*BlockInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{8}
}
func (m *BlockInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *BlockInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_BlockInfo.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *BlockInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_BlockInfo.Merge(m, src)
}
func (m *BlockInfo) XXX_Size() int {
return m.ProtoSize()
}
func (m *BlockInfo) XXX_DiscardUnknown() {
xxx_messageInfo_BlockInfo.DiscardUnknown(m)
}
var xxx_messageInfo_BlockInfo proto.InternalMessageInfo
type Vector struct {
Counters []Counter `protobuf:"bytes,1,rep,name=counters,proto3" json:"counters" xml:"counter"`
}
func (m *Vector) Reset() { *m = Vector{} }
func (m *Vector) String() string { return proto.CompactTextString(m) }
func (*Vector) ProtoMessage() {}
func (*Vector) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{9}
}
func (m *Vector) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Vector) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Vector.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Vector) XXX_Merge(src proto.Message) {
xxx_messageInfo_Vector.Merge(m, src)
}
func (m *Vector) XXX_Size() int {
return m.ProtoSize()
}
func (m *Vector) XXX_DiscardUnknown() {
xxx_messageInfo_Vector.DiscardUnknown(m)
}
var xxx_messageInfo_Vector proto.InternalMessageInfo
type Counter struct {
ID ShortID `protobuf:"varint,1,opt,name=id,proto3,customtype=ShortID" json:"id" xml:"id"`
Value uint64 `protobuf:"varint,2,opt,name=value,proto3" json:"value" xml:"value"`
}
func (m *Counter) Reset() { *m = Counter{} }
func (m *Counter) String() string { return proto.CompactTextString(m) }
func (*Counter) ProtoMessage() {}
func (*Counter) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{10}
}
func (m *Counter) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Counter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Counter.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Counter) XXX_Merge(src proto.Message) {
xxx_messageInfo_Counter.Merge(m, src)
}
func (m *Counter) XXX_Size() int {
return m.ProtoSize()
}
func (m *Counter) XXX_DiscardUnknown() {
xxx_messageInfo_Counter.DiscardUnknown(m)
}
var xxx_messageInfo_Counter proto.InternalMessageInfo
type PlatformData struct {
Unix *UnixData `protobuf:"bytes,1,opt,name=unix,proto3" json:"unix" xml:"unix"`
Windows *WindowsData `protobuf:"bytes,2,opt,name=windows,proto3" json:"windows" xml:"windows"`
Linux *XattrData `protobuf:"bytes,3,opt,name=linux,proto3" json:"linux" xml:"linux"`
Darwin *XattrData `protobuf:"bytes,4,opt,name=darwin,proto3" json:"darwin" xml:"darwin"`
FreeBSD *XattrData `protobuf:"bytes,5,opt,name=freebsd,proto3" json:"freebsd" xml:"freebsd"`
NetBSD *XattrData `protobuf:"bytes,6,opt,name=netbsd,proto3" json:"netbsd" xml:"netbsd"`
}
func (m *PlatformData) Reset() { *m = PlatformData{} }
func (m *PlatformData) String() string { return proto.CompactTextString(m) }
func (*PlatformData) ProtoMessage() {}
func (*PlatformData) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{11}
}
func (m *PlatformData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *PlatformData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_PlatformData.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *PlatformData) XXX_Merge(src proto.Message) {
xxx_messageInfo_PlatformData.Merge(m, src)
}
func (m *PlatformData) XXX_Size() int {
return m.ProtoSize()
}
func (m *PlatformData) XXX_DiscardUnknown() {
xxx_messageInfo_PlatformData.DiscardUnknown(m)
}
var xxx_messageInfo_PlatformData proto.InternalMessageInfo
type UnixData struct {
// The owner name and group name are set when known (i.e., could be
// resolved on the source device), while the UID and GID are always set
// as they come directly from the stat() call.
OwnerName string `protobuf:"bytes,1,opt,name=owner_name,json=ownerName,proto3" json:"ownerName" xml:"ownerName"`
GroupName string `protobuf:"bytes,2,opt,name=group_name,json=groupName,proto3" json:"groupName" xml:"groupName"`
UID int `protobuf:"varint,3,opt,name=uid,proto3,casttype=int" json:"uid" xml:"uid"`
GID int `protobuf:"varint,4,opt,name=gid,proto3,casttype=int" json:"gid" xml:"gid"`
}
func (m *UnixData) Reset() { *m = UnixData{} }
func (m *UnixData) String() string { return proto.CompactTextString(m) }
func (*UnixData) ProtoMessage() {}
func (*UnixData) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{12}
}
func (m *UnixData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *UnixData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_UnixData.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *UnixData) XXX_Merge(src proto.Message) {
xxx_messageInfo_UnixData.Merge(m, src)
}
func (m *UnixData) XXX_Size() int {
return m.ProtoSize()
}
func (m *UnixData) XXX_DiscardUnknown() {
xxx_messageInfo_UnixData.DiscardUnknown(m)
}
var xxx_messageInfo_UnixData proto.InternalMessageInfo
type WindowsData struct {
// Windows file objects have a single owner, which may be a user or a
// group. We keep the name of that account, and a flag to indicate what
// type it is.
OwnerName string `protobuf:"bytes,1,opt,name=owner_name,json=ownerName,proto3" json:"ownerName" xml:"ownerName"`
OwnerIsGroup bool `protobuf:"varint,2,opt,name=owner_is_group,json=ownerIsGroup,proto3" json:"ownerIsGroup" xml:"ownerIsGroup"`
}
func (m *WindowsData) Reset() { *m = WindowsData{} }
func (m *WindowsData) String() string { return proto.CompactTextString(m) }
func (*WindowsData) ProtoMessage() {}
func (*WindowsData) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{13}
}
func (m *WindowsData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *WindowsData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_WindowsData.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *WindowsData) XXX_Merge(src proto.Message) {
xxx_messageInfo_WindowsData.Merge(m, src)
}
func (m *WindowsData) XXX_Size() int {
return m.ProtoSize()
}
func (m *WindowsData) XXX_DiscardUnknown() {
xxx_messageInfo_WindowsData.DiscardUnknown(m)
}
var xxx_messageInfo_WindowsData proto.InternalMessageInfo
type XattrData struct {
Xattrs []Xattr `protobuf:"bytes,1,rep,name=xattrs,proto3" json:"xattrs" xml:"xattr"`
}
func (m *XattrData) Reset() { *m = XattrData{} }
func (m *XattrData) String() string { return proto.CompactTextString(m) }
func (*XattrData) ProtoMessage() {}
func (*XattrData) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{14}
}
func (m *XattrData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *XattrData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_XattrData.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *XattrData) XXX_Merge(src proto.Message) {
xxx_messageInfo_XattrData.Merge(m, src)
}
func (m *XattrData) XXX_Size() int {
return m.ProtoSize()
}
func (m *XattrData) XXX_DiscardUnknown() {
xxx_messageInfo_XattrData.DiscardUnknown(m)
}
var xxx_messageInfo_XattrData proto.InternalMessageInfo
type Xattr struct {
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name" xml:"name"`
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value" xml:"value"`
}
func (m *Xattr) Reset() { *m = Xattr{} }
func (m *Xattr) String() string { return proto.CompactTextString(m) }
func (*Xattr) ProtoMessage() {}
func (*Xattr) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{15}
}
func (m *Xattr) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Xattr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Xattr.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Xattr) XXX_Merge(src proto.Message) {
xxx_messageInfo_Xattr.Merge(m, src)
}
func (m *Xattr) XXX_Size() int {
return m.ProtoSize()
}
func (m *Xattr) XXX_DiscardUnknown() {
xxx_messageInfo_Xattr.DiscardUnknown(m)
}
var xxx_messageInfo_Xattr proto.InternalMessageInfo
type Request struct {
ID int `protobuf:"varint,1,opt,name=id,proto3,casttype=int" json:"id" xml:"id"`
Folder string `protobuf:"bytes,2,opt,name=folder,proto3" json:"folder" xml:"folder"`
Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name" xml:"name"`
Offset int64 `protobuf:"varint,4,opt,name=offset,proto3" json:"offset" xml:"offset"`
Size int `protobuf:"varint,5,opt,name=size,proto3,casttype=int" json:"size" xml:"size"`
Hash []byte `protobuf:"bytes,6,opt,name=hash,proto3" json:"hash" xml:"hash"`
FromTemporary bool `protobuf:"varint,7,opt,name=from_temporary,json=fromTemporary,proto3" json:"fromTemporary" xml:"fromTemporary"`
WeakHash uint32 `protobuf:"varint,8,opt,name=weak_hash,json=weakHash,proto3" json:"weakHash" xml:"weakHash"`
BlockNo int `protobuf:"varint,9,opt,name=block_no,json=blockNo,proto3,casttype=int" json:"blockNo" xml:"blockNo"`
}
func (m *Request) Reset() { *m = Request{} }
func (m *Request) String() string { return proto.CompactTextString(m) }
func (*Request) ProtoMessage() {}
func (*Request) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{16}
}
func (m *Request) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Request.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Request) XXX_Merge(src proto.Message) {
xxx_messageInfo_Request.Merge(m, src)
}
func (m *Request) XXX_Size() int {
return m.ProtoSize()
}
func (m *Request) XXX_DiscardUnknown() {
xxx_messageInfo_Request.DiscardUnknown(m)
}
var xxx_messageInfo_Request proto.InternalMessageInfo
type Response struct {
ID int `protobuf:"varint,1,opt,name=id,proto3,casttype=int" json:"id" xml:"id"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data" xml:"data"`
Code ErrorCode `protobuf:"varint,3,opt,name=code,proto3,enum=protocol.ErrorCode" json:"code" xml:"code"`
}
func (m *Response) Reset() { *m = Response{} }
func (m *Response) String() string { return proto.CompactTextString(m) }
func (*Response) ProtoMessage() {}
func (*Response) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{17}
}
func (m *Response) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Response.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Response) XXX_Merge(src proto.Message) {
xxx_messageInfo_Response.Merge(m, src)
}
func (m *Response) XXX_Size() int {
return m.ProtoSize()
}
func (m *Response) XXX_DiscardUnknown() {
xxx_messageInfo_Response.DiscardUnknown(m)
}
var xxx_messageInfo_Response proto.InternalMessageInfo
type DownloadProgress struct {
Folder string `protobuf:"bytes,1,opt,name=folder,proto3" json:"folder" xml:"folder"`
Updates []FileDownloadProgressUpdate `protobuf:"bytes,2,rep,name=updates,proto3" json:"updates" xml:"update"`
}
func (m *DownloadProgress) Reset() { *m = DownloadProgress{} }
func (m *DownloadProgress) String() string { return proto.CompactTextString(m) }
func (*DownloadProgress) ProtoMessage() {}
func (*DownloadProgress) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{18}
}
func (m *DownloadProgress) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *DownloadProgress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_DownloadProgress.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *DownloadProgress) XXX_Merge(src proto.Message) {
xxx_messageInfo_DownloadProgress.Merge(m, src)
}
func (m *DownloadProgress) XXX_Size() int {
return m.ProtoSize()
}
func (m *DownloadProgress) XXX_DiscardUnknown() {
xxx_messageInfo_DownloadProgress.DiscardUnknown(m)
}
var xxx_messageInfo_DownloadProgress proto.InternalMessageInfo
type FileDownloadProgressUpdate struct {
UpdateType FileDownloadProgressUpdateType `protobuf:"varint,1,opt,name=update_type,json=updateType,proto3,enum=protocol.FileDownloadProgressUpdateType" json:"updateType" xml:"updateType"`
Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name" xml:"name"`
Version Vector `protobuf:"bytes,3,opt,name=version,proto3" json:"version" xml:"version"`
BlockIndexes []int `protobuf:"varint,4,rep,name=block_indexes,json=blockIndexes,proto3,casttype=int" json:"blockIndexes" xml:"blockIndexe"`
BlockSize int `protobuf:"varint,5,opt,name=block_size,json=blockSize,proto3,casttype=int" json:"blockSize" xml:"blockSize"`
}
func (m *FileDownloadProgressUpdate) Reset() { *m = FileDownloadProgressUpdate{} }
func (m *FileDownloadProgressUpdate) String() string { return proto.CompactTextString(m) }
func (*FileDownloadProgressUpdate) ProtoMessage() {}
func (*FileDownloadProgressUpdate) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{19}
}
func (m *FileDownloadProgressUpdate) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *FileDownloadProgressUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_FileDownloadProgressUpdate.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *FileDownloadProgressUpdate) XXX_Merge(src proto.Message) {
xxx_messageInfo_FileDownloadProgressUpdate.Merge(m, src)
}
func (m *FileDownloadProgressUpdate) XXX_Size() int {
return m.ProtoSize()
}
func (m *FileDownloadProgressUpdate) XXX_DiscardUnknown() {
xxx_messageInfo_FileDownloadProgressUpdate.DiscardUnknown(m)
}
var xxx_messageInfo_FileDownloadProgressUpdate proto.InternalMessageInfo
type Ping struct {
}
func (m *Ping) Reset() { *m = Ping{} }
func (m *Ping) String() string { return proto.CompactTextString(m) }
func (*Ping) ProtoMessage() {}
func (*Ping) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{20}
}
func (m *Ping) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Ping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Ping.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Ping) XXX_Merge(src proto.Message) {
xxx_messageInfo_Ping.Merge(m, src)
}
func (m *Ping) XXX_Size() int {
return m.ProtoSize()
}
func (m *Ping) XXX_DiscardUnknown() {
xxx_messageInfo_Ping.DiscardUnknown(m)
}
var xxx_messageInfo_Ping proto.InternalMessageInfo
type Close struct {
Reason string `protobuf:"bytes,1,opt,name=reason,proto3" json:"reason" xml:"reason"`
}
func (m *Close) Reset() { *m = Close{} }
func (m *Close) String() string { return proto.CompactTextString(m) }
func (*Close) ProtoMessage() {}
func (*Close) Descriptor() ([]byte, []int) {
return fileDescriptor_311ef540e10d9705, []int{21}
}
func (m *Close) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Close) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Close.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Close) XXX_Merge(src proto.Message) {
xxx_messageInfo_Close.Merge(m, src)
}
func (m *Close) XXX_Size() int {
return m.ProtoSize()
}
func (m *Close) XXX_DiscardUnknown() {
xxx_messageInfo_Close.DiscardUnknown(m)
}
var xxx_messageInfo_Close proto.InternalMessageInfo
func init() {
proto.RegisterEnum("protocol.MessageType", MessageType_name, MessageType_value)
proto.RegisterEnum("protocol.MessageCompression", MessageCompression_name, MessageCompression_value)
proto.RegisterEnum("protocol.Compression", Compression_name, Compression_value)
proto.RegisterEnum("protocol.FileInfoType", FileInfoType_name, FileInfoType_value)
proto.RegisterEnum("protocol.ErrorCode", ErrorCode_name, ErrorCode_value)
proto.RegisterEnum("protocol.FileDownloadProgressUpdateType", FileDownloadProgressUpdateType_name, FileDownloadProgressUpdateType_value)
proto.RegisterType((*Hello)(nil), "protocol.Hello")
proto.RegisterType((*Header)(nil), "protocol.Header")
proto.RegisterType((*ClusterConfig)(nil), "protocol.ClusterConfig")
proto.RegisterType((*Folder)(nil), "protocol.Folder")
proto.RegisterType((*Device)(nil), "protocol.Device")
proto.RegisterType((*Index)(nil), "protocol.Index")
proto.RegisterType((*IndexUpdate)(nil), "protocol.IndexUpdate")
proto.RegisterType((*FileInfo)(nil), "protocol.FileInfo")
proto.RegisterType((*BlockInfo)(nil), "protocol.BlockInfo")
proto.RegisterType((*Vector)(nil), "protocol.Vector")
proto.RegisterType((*Counter)(nil), "protocol.Counter")
proto.RegisterType((*PlatformData)(nil), "protocol.PlatformData")
proto.RegisterType((*UnixData)(nil), "protocol.UnixData")
proto.RegisterType((*WindowsData)(nil), "protocol.WindowsData")
proto.RegisterType((*XattrData)(nil), "protocol.XattrData")
proto.RegisterType((*Xattr)(nil), "protocol.Xattr")
proto.RegisterType((*Request)(nil), "protocol.Request")
proto.RegisterType((*Response)(nil), "protocol.Response")
proto.RegisterType((*DownloadProgress)(nil), "protocol.DownloadProgress")
proto.RegisterType((*FileDownloadProgressUpdate)(nil), "protocol.FileDownloadProgressUpdate")
proto.RegisterType((*Ping)(nil), "protocol.Ping")
proto.RegisterType((*Close)(nil), "protocol.Close")
}
func init() { proto.RegisterFile("lib/protocol/bep.proto", fileDescriptor_311ef540e10d9705) }
var fileDescriptor_311ef540e10d9705 = []byte{
2023-05-23 12:53:48 +00:00
// 3183 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x5a, 0x4b, 0x6c, 0x1b, 0xc7,
0xf9, 0x17, 0xc5, 0x87, 0xa8, 0xd1, 0xc3, 0xd4, 0xf8, 0xc5, 0xd0, 0xb6, 0x96, 0xff, 0x89, 0xf3,
0xaf, 0xa2, 0x34, 0x76, 0xa2, 0x3c, 0x9a, 0xc6, 0xa9, 0x03, 0x51, 0xa4, 0x64, 0xc6, 0x32, 0xa9,
0x0c, 0x65, 0x3b, 0x36, 0x50, 0x10, 0x2b, 0xee, 0x88, 0x5a, 0x98, 0xdc, 0x65, 0x77, 0xa9, 0x57,
0xd0, 0x4b, 0x1b, 0x20, 0x08, 0x74, 0x28, 0x8a, 0x9c, 0x8a, 0x22, 0x42, 0x83, 0x5e, 0x7a, 0x2b,
0xd0, 0x43, 0x2f, 0x39, 0xf5, 0xe8, 0xa3, 0x11, 0xa0, 0x40, 0xd1, 0xc3, 0x02, 0xb1, 0x2f, 0x2d,
0x7b, 0xd3, 0xb1, 0xa7, 0x62, 0xbe, 0x99, 0x9d, 0x9d, 0xd5, 0x23, 0x95, 0x93, 0x43, 0x4f, 0xe6,
0xf7, 0xfb, 0x7e, 0xdf, 0xb7, 0xb3, 0x33, 0xdf, 0x6b, 0x56, 0x46, 0x17, 0x3a, 0xf6, 0xda, 0xf5,
0x9e, 0xe7, 0xf6, 0xdd, 0x96, 0xdb, 0xb9, 0xbe, 0xc6, 0x7a, 0xd7, 0x40, 0xc0, 0xd9, 0x10, 0x2b,
0x8c, 0xb2, 0x9d, 0xbe, 0x00, 0x0b, 0x2f, 0x7a, 0xac, 0xe7, 0xfa, 0x82, 0xbe, 0xb6, 0xb9, 0x7e,
0xbd, 0xed, 0xb6, 0x5d, 0x10, 0xe0, 0x97, 0x20, 0x91, 0xa7, 0x09, 0x94, 0xbe, 0xc5, 0x3a, 0x1d,
0x17, 0x2f, 0xa0, 0x31, 0x8b, 0x6d, 0xd9, 0x2d, 0xd6, 0x74, 0xcc, 0x2e, 0xcb, 0x27, 0x8a, 0x89,
0x99, 0xd1, 0x12, 0x19, 0x04, 0x06, 0x12, 0x70, 0xcd, 0xec, 0xb2, 0x83, 0xc0, 0xc8, 0xed, 0x74,
0x3b, 0xef, 0x92, 0x08, 0x22, 0x54, 0xd3, 0x73, 0x27, 0xad, 0x8e, 0xcd, 0x9c, 0xbe, 0x70, 0x32,
0x1c, 0x39, 0x11, 0x70, 0xcc, 0x49, 0x04, 0x11, 0xaa, 0xe9, 0x71, 0x1d, 0x4d, 0x4a, 0x27, 0x5b,
0xcc, 0xf3, 0x6d, 0xd7, 0xc9, 0x27, 0xc1, 0xcf, 0xcc, 0x20, 0x30, 0x26, 0x84, 0xe6, 0x9e, 0x50,
0x1c, 0x04, 0xc6, 0x59, 0xcd, 0x95, 0x44, 0x09, 0x8d, 0xb3, 0xc8, 0x9f, 0x12, 0x28, 0x73, 0x8b,
0x99, 0x16, 0xf3, 0xf0, 0x3c, 0x4a, 0xf5, 0x77, 0x7b, 0xe2, 0xf5, 0x26, 0xe7, 0xce, 0x5f, 0x0b,
0x37, 0xee, 0xda, 0x1d, 0xe6, 0xfb, 0x66, 0x9b, 0xad, 0xee, 0xf6, 0x58, 0xe9, 0xc2, 0x20, 0x30,
0x80, 0x76, 0x10, 0x18, 0x08, 0xfc, 0x73, 0x81, 0x50, 0xc0, 0xb0, 0x85, 0xc6, 0x5a, 0x6e, 0xb7,
0xe7, 0x31, 0x1f, 0xd6, 0x36, 0x0c, 0x9e, 0x2e, 0x1f, 0xf1, 0xb4, 0x10, 0x71, 0x4a, 0x57, 0x07,
0x81, 0xa1, 0x1b, 0x1d, 0x04, 0xc6, 0x94, 0x58, 0x77, 0x84, 0x11, 0xaa, 0x33, 0xc8, 0x17, 0x09,
0x34, 0xb1, 0xd0, 0xd9, 0xf4, 0xfb, 0xcc, 0x5b, 0x70, 0x9d, 0x75, 0xbb, 0x8d, 0x6f, 0xa3, 0x91,
0x75, 0xb7, 0x63, 0x31, 0xcf, 0xcf, 0x27, 0x8a, 0xc9, 0x99, 0xb1, 0xb9, 0x5c, 0xf4, 0xcc, 0x45,
0x50, 0x94, 0x8c, 0xc7, 0x81, 0x31, 0x34, 0x08, 0x8c, 0x90, 0x78, 0x10, 0x18, 0xe3, 0xf0, 0x1c,
0x21, 0x13, 0x1a, 0x2a, 0xf0, 0x4d, 0x34, 0xea, 0xb3, 0x96, 0xeb, 0x58, 0xa6, 0xb7, 0x0b, 0xaf,
0x90, 0x2d, 0x15, 0x07, 0x81, 0x11, 0x81, 0x07, 0x81, 0x71, 0x06, 0x4c, 0x15, 0x42, 0x68, 0xa4,
0x25, 0x5f, 0xa5, 0x50, 0x46, 0x3c, 0x14, 0x5f, 0x43, 0xc3, 0xb6, 0x25, 0xe3, 0x65, 0xfa, 0x69,
0x60, 0x0c, 0x57, 0xcb, 0x83, 0xc0, 0x18, 0xb6, 0xad, 0x83, 0xc0, 0xc8, 0x82, 0x0b, 0xdb, 0x22,
0x9f, 0x3f, 0xb9, 0x3a, 0x5c, 0x2d, 0xd3, 0x61, 0xdb, 0xc2, 0xd7, 0x50, 0xba, 0x63, 0xae, 0xb1,
0x8e, 0x8c, 0x8e, 0xfc, 0x20, 0x30, 0x04, 0x70, 0x10, 0x18, 0x63, 0xc0, 0x07, 0x89, 0x50, 0x81,
0xe2, 0x1b, 0x68, 0xd4, 0x63, 0xa6, 0xd5, 0x74, 0x9d, 0xce, 0x2e, 0x44, 0x42, 0xb6, 0x34, 0x3d,
0x08, 0x8c, 0x2c, 0x07, 0xeb, 0x4e, 0x87, 0xaf, 0x74, 0x12, 0xcc, 0x42, 0x80, 0x50, 0xa5, 0xc3,
0x4d, 0x84, 0xed, 0xb6, 0xe3, 0x7a, 0xac, 0xd9, 0x63, 0x5e, 0xd7, 0x86, 0xbd, 0xf5, 0xf3, 0x29,
0xf0, 0xf2, 0xda, 0x20, 0x30, 0xa6, 0x84, 0x76, 0x25, 0x52, 0x1e, 0x04, 0xc6, 0x45, 0xb1, 0xea,
0xc3, 0x1a, 0x42, 0x8f, 0xb2, 0xf1, 0x6d, 0x34, 0x21, 0x1f, 0x60, 0xb1, 0x0e, 0xeb, 0xb3, 0x7c,
0x1a, 0x7c, 0xff, 0xff, 0x20, 0x30, 0xc6, 0x85, 0xa2, 0x0c, 0xf8, 0x41, 0x60, 0x60, 0xcd, 0xad,
0x00, 0x09, 0x8d, 0x71, 0xb0, 0x85, 0xce, 0x59, 0xb6, 0x6f, 0xae, 0x75, 0x58, 0xb3, 0xcf, 0xba,
0xbd, 0xa6, 0xed, 0x58, 0x6c, 0x87, 0xf9, 0xf9, 0x0c, 0xf8, 0x9c, 0x1b, 0x04, 0x06, 0x96, 0xfa,
0x55, 0xd6, 0xed, 0x55, 0x85, 0xf6, 0x20, 0x30, 0xf2, 0x22, 0x29, 0x8f, 0xa8, 0x08, 0x3d, 0x86,
0x8f, 0xe7, 0x50, 0xa6, 0x67, 0x6e, 0xfa, 0xcc, 0xca, 0x8f, 0x80, 0xdf, 0xc2, 0x20, 0x30, 0x24,
0xa2, 0x02, 0x46, 0x88, 0x84, 0x4a, 0x9c, 0x07, 0x9f, 0x48, 0x73, 0x3f, 0x9f, 0x3b, 0x1c, 0x7c,
0x65, 0x50, 0x44, 0xc1, 0x27, 0x89, 0xca, 0x97, 0x90, 0x09, 0x0d, 0x15, 0xe4, 0x2f, 0x19, 0x94,
0x11, 0x46, 0xb8, 0xa4, 0x82, 0x67, 0xbc, 0x34, 0xc7, 0x1d, 0xfc, 0x3d, 0x30, 0xb2, 0x42, 0x57,
0x2d, 0x9f, 0x14, 0x4c, 0x9f, 0x3d, 0xb9, 0x9a, 0xd0, 0x02, 0x6a, 0x16, 0xa5, 0xb4, 0x6a, 0x03,
0xc9, 0xeb, 0x88, 0x3a, 0x23, 0x92, 0xd7, 0x81, 0x0a, 0x03, 0x18, 0x7e, 0x0f, 0x8d, 0x9a, 0x96,
0xc5, 0x93, 0x8c, 0xf9, 0xf9, 0x64, 0x31, 0xc9, 0x63, 0x96, 0xc7, 0xbd, 0x02, 0x0f, 0x02, 0x63,
0x02, 0xac, 0x24, 0x42, 0x68, 0xa4, 0xc3, 0x3f, 0x8d, 0xa7, 0x7e, 0xea, 0x70, 0x11, 0xf9, 0x7e,
0x39, 0xcf, 0x23, 0xbd, 0xc5, 0x3c, 0x59, 0x3b, 0xd3, 0x22, 0xa1, 0x78, 0xa4, 0x73, 0x50, 0x56,
0x4e, 0x11, 0xe9, 0x21, 0x40, 0xa8, 0xd2, 0xe1, 0x25, 0x34, 0xde, 0x35, 0x77, 0x9a, 0x3e, 0xfb,
0xd9, 0x26, 0x73, 0x5a, 0x0c, 0x62, 0x26, 0x29, 0x56, 0xd1, 0x35, 0x77, 0x1a, 0x12, 0x56, 0xab,
0xd0, 0x30, 0x42, 0x75, 0x06, 0x2e, 0x21, 0x64, 0x3b, 0x7d, 0xcf, 0xb5, 0x36, 0x5b, 0xcc, 0x93,
0x21, 0x02, 0x25, 0x3c, 0x42, 0x55, 0x09, 0x8f, 0x20, 0x42, 0x35, 0x3d, 0x6e, 0xa3, 0x2c, 0xc4,
0x6e, 0xd3, 0xb6, 0xf2, 0xd9, 0x62, 0x62, 0x26, 0x55, 0x5a, 0x96, 0x87, 0x3b, 0x02, 0x51, 0x08,
0x67, 0x1b, 0xfe, 0xe4, 0x31, 0x03, 0xec, 0xaa, 0xa5, 0x76, 0x5f, 0xca, 0xbc, 0x6e, 0x84, 0xb4,
0xdf, 0x46, 0x3f, 0x69, 0xc8, 0xc7, 0x3f, 0x47, 0x05, 0xff, 0x91, 0xcd, 0x33, 0x45, 0x3c, 0xbb,
0x6f, 0xbb, 0x4e, 0xd3, 0x63, 0x5d, 0x77, 0xcb, 0xec, 0xf8, 0xf9, 0x51, 0x58, 0xfc, 0xcd, 0x41,
0x60, 0xe4, 0x39, 0xab, 0xaa, 0x91, 0xa8, 0xe4, 0x1c, 0x04, 0xc6, 0xb4, 0xa8, 0x73, 0x27, 0x10,
0x08, 0x3d, 0xd1, 0x16, 0xef, 0xa0, 0x17, 0x98, 0xd3, 0xf2, 0x76, 0x7b, 0xf0, 0xd8, 0x9e, 0xe9,
0xfb, 0xdb, 0xae, 0x67, 0x35, 0xfb, 0xee, 0x23, 0xe6, 0xe4, 0x11, 0x04, 0xf5, 0x7b, 0x83, 0xc0,
0xb8, 0x18, 0x91, 0x56, 0x24, 0x67, 0x95, 0x53, 0x0e, 0x02, 0xe3, 0x0a, 0x3c, 0xfb, 0x04, 0x3d,
0xa1, 0x27, 0x59, 0x92, 0x5f, 0x26, 0x50, 0x1a, 0x36, 0x83, 0x67, 0xb3, 0x28, 0xea, 0xb2, 0x04,
0x43, 0x36, 0x0b, 0xe4, 0x48, 0xf9, 0x97, 0x38, 0xae, 0xa0, 0xf4, 0xba, 0xdd, 0x61, 0x7e, 0x7e,
0x18, 0x72, 0x19, 0x6b, 0x8d, 0xc4, 0xee, 0xb0, 0xaa, 0xb3, 0xee, 0x96, 0x2e, 0xc9, 0x6c, 0x16,
0x44, 0x95, 0x4b, 0x5c, 0x22, 0x54, 0x80, 0xe4, 0xb3, 0x04, 0x1a, 0x83, 0x45, 0xdc, 0xed, 0x59,
0x66, 0x9f, 0xfd, 0x2f, 0x97, 0xf2, 0xe9, 0x04, 0xca, 0x86, 0x06, 0xaa, 0x20, 0x24, 0x4e, 0x51,
0x10, 0x66, 0x51, 0xca, 0xb7, 0x3f, 0x66, 0xd0, 0x58, 0x92, 0x82, 0xcb, 0x65, 0xc5, 0xe5, 0x02,
0xa1, 0x80, 0xe1, 0xf7, 0x11, 0xea, 0xba, 0x96, 0xbd, 0x6e, 0x33, 0xab, 0xe9, 0x43, 0x82, 0x26,
0x45, 0xd7, 0x0c, 0xd1, 0x86, 0xea, 0x9a, 0x0a, 0x21, 0x34, 0xd2, 0xf2, 0xfa, 0xa1, 0x1c, 0xac,
0xed, 0xe6, 0xc7, 0x21, 0x33, 0xde, 0x0b, 0x33, 0xa3, 0xb1, 0xe1, 0x7a, 0x7d, 0x48, 0x07, 0xf5,
0x98, 0xd2, 0xae, 0x4a, 0xb5, 0x08, 0x22, 0x3c, 0x13, 0x24, 0x99, 0x6a, 0x54, 0xbc, 0x8c, 0x46,
0xc2, 0x89, 0x89, 0x47, 0x7e, 0xac, 0x48, 0xdf, 0x63, 0xad, 0xbe, 0xeb, 0x95, 0x8a, 0x61, 0x91,
0xde, 0x52, 0x13, 0x94, 0x48, 0xb8, 0xad, 0x70, 0x76, 0x0a, 0x35, 0xf8, 0x5d, 0x94, 0x55, 0xc5,
0x04, 0xc1, 0xbb, 0x42, 0x31, 0xf2, 0xa3, 0x4a, 0x32, 0x29, 0x07, 0x84, 0xb0, 0x8c, 0x28, 0x1d,
0xfe, 0x00, 0x65, 0xd6, 0x3a, 0x6e, 0xeb, 0x51, 0xd8, 0x2d, 0xce, 0x46, 0x0b, 0x29, 0x71, 0x1c,
0xce, 0xf5, 0x8a, 0x5c, 0x8b, 0xa4, 0xaa, 0xf6, 0x0f, 0x22, 0xa1, 0x12, 0xe6, 0xe3, 0xa0, 0xbf,
0xdb, 0xed, 0xd8, 0xce, 0xa3, 0x66, 0xdf, 0xf4, 0xda, 0xac, 0x9f, 0x9f, 0x8a, 0xc6, 0x41, 0xa9,
0x59, 0x05, 0x85, 0x1a, 0x07, 0x63, 0x28, 0xa1, 0x71, 0x16, 0x1f, 0x52, 0x85, 0xeb, 0xe6, 0x86,
0xe9, 0x6f, 0xe4, 0x31, 0xe4, 0x29, 0x54, 0x38, 0x01, 0xdf, 0x32, 0xfd, 0x0d, 0xb5, 0xed, 0x11,
0x44, 0xa8, 0xa6, 0xe7, 0x03, 0x94, 0xcc, 0x4d, 0x66, 0xe5, 0xcf, 0x82, 0x0b, 0x08, 0x05, 0x05,
0xaa, 0x50, 0x50, 0x08, 0xa1, 0x91, 0x16, 0x97, 0xe4, 0x20, 0x2a, 0xc6, 0xc7, 0x0b, 0x47, 0xc3,
0xfe, 0x14, 0x93, 0xe8, 0x22, 0x1a, 0x3b, 0x3c, 0xd5, 0x4c, 0x88, 0x8a, 0xdf, 0x8b, 0xcd, 0x33,
0xa2, 0xe2, 0xf7, 0xf4, 0x49, 0x46, 0x67, 0xe0, 0x0f, 0xb4, 0xb0, 0x74, 0xfc, 0xfc, 0x58, 0x31,
0x31, 0x93, 0x2e, 0xbd, 0xac, 0xc7, 0x61, 0xcd, 0x3f, 0x12, 0x87, 0x35, 0x9f, 0xfc, 0x3b, 0x30,
0x92, 0xb6, 0xd3, 0xa7, 0x1a, 0x0d, 0xaf, 0x23, 0xb1, 0x4b, 0x4d, 0xc8, 0xaa, 0x09, 0x70, 0xb5,
0xf4, 0x34, 0x30, 0xc6, 0xa9, 0xb9, 0x0d, 0x47, 0xdf, 0xb0, 0x3f, 0x66, 0x7c, 0xa3, 0xd6, 0x42,
0x41, 0x6d, 0x94, 0x42, 0x42, 0xc7, 0x9f, 0x3f, 0xb9, 0x1a, 0x33, 0xa3, 0x91, 0x11, 0xbe, 0x87,
0xb2, 0xbd, 0x8e, 0xd9, 0x5f, 0x77, 0xbd, 0x6e, 0x7e, 0x12, 0x82, 0x5d, 0xdb, 0xc3, 0x15, 0xa9,
0x29, 0x9b, 0x7d, 0xb3, 0x44, 0x64, 0x98, 0x29, 0xbe, 0x8a, 0xdc, 0x10, 0x20, 0x54, 0xe9, 0x70,
0x19, 0x8d, 0x75, 0xdc, 0x96, 0xd9, 0x69, 0xae, 0x77, 0xcc, 0xb6, 0x9f, 0xff, 0xc7, 0x08, 0x6c,
0x2a, 0x44, 0x07, 0xe0, 0x8b, 0x1c, 0x56, 0x9b, 0x11, 0x41, 0x84, 0x6a, 0x7a, 0x7c, 0x0b, 0x8d,
0xcb, 0x34, 0x12, 0x31, 0xf6, 0xcf, 0x11, 0x88, 0x10, 0x38, 0x1b, 0xa9, 0x90, 0x51, 0x36, 0xa5,
0x67, 0x9f, 0x08, 0x33, 0x9d, 0x81, 0x3f, 0x44, 0x67, 0x6c, 0xc7, 0xb5, 0x58, 0xb3, 0xb5, 0x61,
0x3a, 0x6d, 0xc6, 0xcf, 0x67, 0x30, 0x02, 0xd9, 0x08, 0xf1, 0x0f, 0xba, 0x05, 0x50, 0xc1, 0x19,
0x9d, 0x95, 0xdd, 0x53, 0x43, 0x09, 0x8d, 0xb3, 0xf0, 0x0e, 0xd2, 0xda, 0x4a, 0xb3, 0xef, 0x99,
0x76, 0x87, 0x79, 0xe2, 0xbc, 0xfe, 0x35, 0x02, 0x07, 0xf6, 0xfe, 0x20, 0x30, 0xce, 0x47, 0x9c,
0x55, 0x41, 0x91, 0x87, 0x75, 0xe9, 0x50, 0xcb, 0xd2, 0xb4, 0x2a, 0x22, 0x8e, 0x37, 0xc6, 0x6f,
0xf3, 0x29, 0x92, 0x4f, 0xba, 0x96, 0x1c, 0x69, 0x2f, 0x8b, 0x79, 0x11, 0x20, 0x55, 0x8a, 0xa4,
0x0c, 0x03, 0x23, 0xfc, 0xc2, 0x14, 0x8d, 0xd8, 0xce, 0x96, 0xd9, 0xb1, 0xc3, 0x91, 0xf5, 0x9d,
0xa7, 0x81, 0x81, 0xa8, 0xb9, 0x5d, 0x15, 0xa8, 0x98, 0x20, 0xe0, 0xa7, 0x36, 0x41, 0x80, 0xcc,
0x27, 0x08, 0x8d, 0x49, 0x43, 0x1e, 0x2f, 0x2b, 0x8e, 0x1b, 0xbb, 0x15, 0x64, 0xc1, 0x35, 0x6c,
0xab, 0xe3, 0xc6, 0x6f, 0x04, 0x62, 0x5b, 0x63, 0x28, 0xa1, 0x71, 0xd6, 0xbb, 0xa9, 0xdf, 0x7c,
0x69, 0x0c, 0x91, 0x6f, 0x12, 0x68, 0x54, 0x95, 0x38, 0xde, 0x5d, 0xe0, 0xfc, 0x93, 0x70, 0xfc,
0x90, 0xcd, 0x1b, 0xe2, 0xdc, 0x45, 0x36, 0x6f, 0xc0, 0x81, 0x03, 0xc6, 0xbb, 0xa7, 0xbb, 0xbe,
0xee, 0xb3, 0x3e, 0xf4, 0xad, 0xa4, 0xe8, 0x9e, 0x02, 0x51, 0xdd, 0x53, 0x88, 0x84, 0x4a, 0x1c,
0xbf, 0x2e, 0xbb, 0xd7, 0x30, 0x1c, 0xdb, 0x95, 0xe3, 0xbb, 0x57, 0x78, 0x28, 0xa2, 0x89, 0xdd,
0x40, 0xa3, 0xdb, 0xcc, 0x7c, 0x24, 0xe2, 0x52, 0x94, 0x0c, 0xa8, 0xeb, 0x1c, 0x94, 0x31, 0x29,
0xb2, 0x23, 0x04, 0x08, 0x55, 0x3a, 0xf9, 0x8e, 0x0f, 0x51, 0x46, 0xb4, 0x13, 0xbc, 0x82, 0xb2,
0x2d, 0x77, 0xd3, 0xe9, 0x47, 0x97, 0xd2, 0x29, 0x7d, 0x1a, 0x06, 0x4d, 0xe9, 0xff, 0xc2, 0x04,
0x0c, 0xa9, 0xea, 0x8c, 0x24, 0xc0, 0xc7, 0x58, 0xa9, 0x22, 0x9f, 0x24, 0xd0, 0x88, 0x34, 0xc4,
0xb7, 0xd4, 0xe5, 0x20, 0x55, 0x7a, 0xe7, 0x50, 0x97, 0xfc, 0xf6, 0x8b, 0xa6, 0xde, 0x21, 0xe5,
0x9d, 0x73, 0xcb, 0xec, 0x6c, 0x8a, 0x8d, 0x4a, 0x89, 0x3b, 0x27, 0x00, 0xaa, 0xe9, 0x80, 0x44,
0xa8, 0x40, 0xc9, 0x27, 0x29, 0x34, 0xae, 0x17, 0x11, 0x5e, 0xae, 0x37, 0x1d, 0x7b, 0x07, 0x16,
0x13, 0x9b, 0x52, 0xee, 0x3a, 0xf6, 0x0e, 0x94, 0x99, 0xc2, 0xe3, 0xc0, 0x48, 0xf0, 0x03, 0xe0,
0x3c, 0x75, 0x00, 0x5c, 0x20, 0x14, 0x30, 0xfc, 0x21, 0x1a, 0xd9, 0xb6, 0x1d, 0xcb, 0xdd, 0xf6,
0x61, 0x19, 0x63, 0xfa, 0xcd, 0xe1, 0xbe, 0x50, 0x80, 0xa7, 0xa2, 0xf4, 0x14, 0xb2, 0xd5, 0x76,
0x49, 0x99, 0xd0, 0x50, 0x83, 0x97, 0x50, 0xba, 0x63, 0x3b, 0x9b, 0x3b, 0x10, 0x60, 0xb1, 0x36,
0xfb, 0x91, 0xd9, 0xef, 0x7b, 0xe0, 0xee, 0xb2, 0x74, 0x27, 0x98, 0xd1, 0x25, 0x9b, 0x4b, 0xfc,
0x92, 0xcd, 0xff, 0xc5, 0xb7, 0x51, 0xc6, 0x32, 0xbd, 0x6d, 0x5b, 0x5c, 0x6a, 0x4e, 0xf0, 0x34,
0x2d, 0x3d, 0x49, 0x6a, 0x74, 0xc1, 0x03, 0x91, 0x50, 0x89, 0x63, 0x86, 0x46, 0xd6, 0x3d, 0xc6,
0xd6, 0x7c, 0x0b, 0x86, 0xa4, 0x13, 0xbc, 0xbd, 0xcd, 0xbd, 0xf1, 0x6b, 0xc0, 0xa2, 0xc7, 0x58,
0xa9, 0x01, 0xd7, 0x00, 0x69, 0xa6, 0xde, 0x58, 0xca, 0x70, 0x0d, 0x90, 0x34, 0x1a, 0x92, 0x70,
0x13, 0x65, 0x1c, 0xd6, 0xe7, 0x4f, 0xc9, 0x9c, 0xfc, 0x94, 0x39, 0xf9, 0x94, 0x4c, 0x8d, 0xf5,
0xc5, 0x43, 0xa4, 0x91, 0x5a, 0xbd, 0x10, 0xf9, 0x23, 0x24, 0x87, 0x4a, 0x06, 0xf9, 0x74, 0x18,
0x65, 0xc3, 0xf3, 0xe5, 0xc3, 0x9f, 0xbb, 0xed, 0x30, 0x4f, 0xff, 0x3c, 0x06, 0x1d, 0x1f, 0x50,
0x79, 0x3d, 0x13, 0x8d, 0x4c, 0x21, 0x84, 0x46, 0x5a, 0xee, 0xa0, 0xed, 0xb9, 0x9b, 0x3d, 0xfd,
0xd3, 0x18, 0x38, 0x00, 0x34, 0xe6, 0x40, 0x21, 0x84, 0x46, 0x5a, 0x7c, 0x03, 0x25, 0x37, 0x6d,
0x0b, 0x8e, 0x3a, 0x5d, 0x7a, 0xf9, 0x69, 0x60, 0x24, 0xef, 0x42, 0x06, 0x70, 0xf4, 0x20, 0x30,
0x46, 0x45, 0xc0, 0xd9, 0x96, 0xd6, 0x3e, 0x39, 0x83, 0x72, 0x3d, 0x37, 0x6e, 0xdb, 0x16, 0x9c,
0xae, 0x34, 0x5e, 0x12, 0xc6, 0x6d, 0xcd, 0xb8, 0x1d, 0x37, 0x5e, 0xe2, 0xc6, 0x1c, 0xfb, 0x22,
0x81, 0xc6, 0xb4, 0x08, 0xfd, 0xfe, 0x7b, 0xb1, 0x8c, 0x26, 0x85, 0x03, 0xdb, 0x6f, 0xc2, 0x0b,
0xca, 0x6f, 0x50, 0xf0, 0xd9, 0x04, 0x34, 0x55, 0x7f, 0x89, 0xe3, 0xea, 0xb3, 0x89, 0x0e, 0x12,
0x1a, 0xe3, 0x90, 0x06, 0x1a, 0x55, 0x07, 0x8e, 0x17, 0x51, 0x66, 0x87, 0x0b, 0x61, 0x41, 0x3a,
0x73, 0x28, 0x2a, 0xa2, 0xb1, 0x53, 0xd0, 0x54, 0x42, 0x80, 0x48, 0xa8, 0x84, 0x49, 0x0b, 0xa5,
0x81, 0xff, 0x5c, 0xb7, 0x89, 0x58, 0x9d, 0x19, 0xff, 0xef, 0x75, 0xe6, 0x17, 0x29, 0x34, 0x42,
0xf9, 0xd0, 0xec, 0xf7, 0xf1, 0x5b, 0xaa, 0xda, 0xa5, 0x4b, 0x2f, 0x9d, 0x54, 0xde, 0xa2, 0xd3,
0x09, 0xbf, 0x7e, 0x44, 0x97, 0xae, 0xe1, 0x53, 0x5f, 0xba, 0xc2, 0x57, 0x4a, 0x9e, 0xe2, 0x95,
0xa2, 0xb6, 0x94, 0x7a, 0xee, 0xb6, 0x94, 0x3e, 0x7d, 0x5b, 0x0a, 0x3b, 0x65, 0xe6, 0x14, 0x9d,
0xb2, 0x8e, 0x26, 0xd7, 0x3d, 0xb7, 0x0b, 0xdf, 0xc8, 0x5c, 0xcf, 0xf4, 0x76, 0xe5, 0x54, 0x00,
0xad, 0x9b, 0x6b, 0x56, 0x43, 0x85, 0x6a, 0xdd, 0x31, 0x94, 0xd0, 0x38, 0x2b, 0xde, 0x13, 0xb3,
0xcf, 0xd7, 0x13, 0xf1, 0x4d, 0x94, 0x15, 0x13, 0xaf, 0xe3, 0xc2, 0xb5, 0x2b, 0x5d, 0x7a, 0x91,
0x97, 0x32, 0xc0, 0x6a, 0xae, 0x2a, 0x65, 0x52, 0x56, 0xaf, 0x1d, 0x12, 0xc8, 0x1f, 0x13, 0x28,
0x4b, 0x99, 0xdf, 0x73, 0x1d, 0x9f, 0x7d, 0xd7, 0x20, 0x98, 0x45, 0x29, 0xcb, 0xec, 0x9b, 0x32,
0xec, 0x60, 0xf7, 0xb8, 0xac, 0x76, 0x8f, 0x0b, 0x84, 0x02, 0x86, 0xdf, 0x47, 0xa9, 0x96, 0x6b,
0x89, 0xc3, 0x9f, 0xd4, 0x8b, 0x66, 0xc5, 0xf3, 0x5c, 0x6f, 0xc1, 0xb5, 0xe4, 0xb5, 0x83, 0x93,
0x94, 0x03, 0x2e, 0x10, 0x0a, 0x18, 0xf9, 0x43, 0x02, 0xe5, 0xca, 0xee, 0xb6, 0xd3, 0x71, 0x4d,
0x6b, 0xc5, 0x73, 0xdb, 0x1e, 0xf3, 0xfd, 0xef, 0x74, 0xf7, 0x6f, 0xa2, 0x91, 0x4d, 0xf8, 0x72,
0x10, 0xde, 0xfe, 0xaf, 0xc6, 0xaf, 0x41, 0x87, 0x1f, 0x22, 0x3e, 0x33, 0x44, 0x1f, 0x1a, 0xa5,
0xb1, 0xf2, 0x2f, 0x64, 0x42, 0x43, 0x05, 0xf9, 0x7d, 0x12, 0x15, 0x4e, 0x76, 0x84, 0xbb, 0x68,
0x4c, 0x30, 0x9b, 0xda, 0xdf, 0x04, 0x66, 0x4e, 0xb3, 0x06, 0xb8, 0x9c, 0xc1, 0xa5, 0x60, 0x53,
0xc9, 0xea, 0x52, 0x10, 0x41, 0x84, 0x6a, 0xfa, 0xe7, 0xfa, 0x4e, 0xa9, 0x5d, 0xe5, 0x93, 0xdf,
0xff, 0x2a, 0xdf, 0x40, 0x13, 0x22, 0x44, 0xc3, 0x0f, 0xca, 0xa9, 0x62, 0x72, 0x26, 0x5d, 0xba,
0xc6, 0xab, 0xed, 0x9a, 0x18, 0x56, 0xc3, 0x4f, 0xc9, 0x53, 0x51, 0xb0, 0x0a, 0x30, 0x8c, 0xb6,
0xdc, 0x10, 0x8d, 0x71, 0xf1, 0x62, 0xec, 0xa6, 0x27, 0x52, 0xfd, 0x07, 0xa7, 0xbc, 0xd9, 0x69,
0x37, 0x39, 0x92, 0x41, 0xa9, 0x15, 0xdb, 0x69, 0x93, 0x1b, 0x28, 0xbd, 0xd0, 0x71, 0x7d, 0xa8,
0x38, 0x1e, 0x33, 0x7d, 0xd7, 0xd1, 0x43, 0x49, 0x20, 0xea, 0xa8, 0x85, 0x48, 0xa8, 0xc4, 0x67,
0xbf, 0x4a, 0xa2, 0x31, 0xed, 0x4f, 0x38, 0xf8, 0x27, 0xe8, 0xd2, 0x9d, 0x4a, 0xa3, 0x31, 0xbf,
0x54, 0x69, 0xae, 0x3e, 0x58, 0xa9, 0x34, 0x17, 0x96, 0xef, 0x36, 0x56, 0x2b, 0xb4, 0xb9, 0x50,
0xaf, 0x2d, 0x56, 0x97, 0x72, 0x43, 0x85, 0xcb, 0x7b, 0xfb, 0xc5, 0xbc, 0x66, 0x11, 0xff, 0x5b,
0xcb, 0x0f, 0x11, 0x8e, 0x99, 0x57, 0x6b, 0xe5, 0xca, 0x47, 0xb9, 0x44, 0xe1, 0xdc, 0xde, 0x7e,
0x31, 0xa7, 0x59, 0x89, 0x4f, 0x70, 0x3f, 0x46, 0x2f, 0x1c, 0x65, 0x37, 0xef, 0xae, 0x94, 0xe7,
0x57, 0x2b, 0xb9, 0xe1, 0x42, 0x61, 0x6f, 0xbf, 0x78, 0xe1, 0xb0, 0x91, 0x0c, 0xc1, 0xd7, 0xd0,
0xb9, 0x98, 0x29, 0xad, 0x7c, 0x78, 0xb7, 0xd2, 0x58, 0xcd, 0x25, 0x0b, 0x17, 0xf6, 0xf6, 0x8b,
0x58, 0xb3, 0x0a, 0xdb, 0xc4, 0x1c, 0x3a, 0x7f, 0xc8, 0xa2, 0xb1, 0x52, 0xaf, 0x35, 0x2a, 0xb9,
0x54, 0xe1, 0xe2, 0xde, 0x7e, 0xf1, 0x6c, 0xcc, 0x44, 0x56, 0x95, 0x05, 0x34, 0x1d, 0xb3, 0x29,
0xd7, 0xef, 0xd7, 0x96, 0xeb, 0xf3, 0xe5, 0xe6, 0x0a, 0xad, 0x2f, 0xd1, 0x4a, 0xa3, 0x91, 0x4b,
0x17, 0x8c, 0xbd, 0xfd, 0xe2, 0x25, 0xcd, 0xf8, 0x48, 0x86, 0xcf, 0xa2, 0xa9, 0x98, 0x93, 0x95,
0x6a, 0x6d, 0x29, 0x97, 0x29, 0x9c, 0xdd, 0xdb, 0x2f, 0x9e, 0xd1, 0xec, 0xf8, 0x59, 0x1e, 0xd9,
0xbf, 0x85, 0xe5, 0x7a, 0xa3, 0x92, 0x1b, 0x39, 0xb2, 0x7f, 0x70, 0xe0, 0xb3, 0xbf, 0x4b, 0x20,
0x7c, 0xf4, 0xaf, 0x66, 0xf8, 0x1d, 0x94, 0x0f, 0x9d, 0x2c, 0xd4, 0xef, 0xac, 0xf0, 0x75, 0x56,
0xeb, 0xb5, 0x66, 0xad, 0x5e, 0xab, 0xe4, 0x86, 0x62, 0xbb, 0xaa, 0x59, 0xd5, 0x5c, 0x87, 0xe1,
0x3a, 0xba, 0x78, 0x9c, 0xe5, 0xf2, 0xc3, 0x37, 0x73, 0x89, 0xc2, 0xdc, 0xde, 0x7e, 0xf1, 0xfc,
0x51, 0xc3, 0xe5, 0x87, 0x6f, 0x7e, 0xfd, 0xab, 0x97, 0x8e, 0x57, 0xcc, 0xf2, 0x01, 0x48, 0x5f,
0xda, 0xeb, 0xe8, 0x9c, 0xee, 0xf8, 0x4e, 0x65, 0x75, 0xbe, 0x3c, 0xbf, 0x3a, 0x9f, 0x1b, 0x12,
0x67, 0xa0, 0x51, 0xef, 0xb0, 0xbe, 0x09, 0x65, 0xf7, 0x15, 0x34, 0x15, 0x7b, 0x8b, 0xca, 0xbd,
0x0a, 0x0d, 0x23, 0x4a, 0x5f, 0x3f, 0xdb, 0x62, 0x1e, 0x7e, 0x15, 0x61, 0x9d, 0x3c, 0xbf, 0x7c,
0x7f, 0xfe, 0x41, 0x23, 0x37, 0x5c, 0x38, 0xbf, 0xb7, 0x5f, 0x9c, 0xd2, 0xd8, 0xf3, 0x9d, 0x6d,
0x73, 0xd7, 0x9f, 0xfd, 0xf3, 0x30, 0x1a, 0xd7, 0xbf, 0x1b, 0xe1, 0x57, 0xd1, 0xd9, 0xc5, 0xea,
0x32, 0x8f, 0xc4, 0xc5, 0xba, 0x38, 0x01, 0x2e, 0xe6, 0x86, 0xc4, 0xe3, 0x74, 0x2a, 0xff, 0x8d,
0x7f, 0x84, 0xf2, 0x87, 0xe8, 0xe5, 0x2a, 0xad, 0x2c, 0xac, 0xd6, 0xe9, 0x83, 0x5c, 0xa2, 0xf0,
0x02, 0xdf, 0x30, 0xdd, 0xa6, 0x6c, 0x7b, 0x50, 0x82, 0x76, 0xf1, 0x4d, 0x74, 0xe9, 0x90, 0x61,
0xe3, 0xc1, 0x9d, 0xe5, 0x6a, 0xed, 0xb6, 0x78, 0xde, 0x70, 0xe1, 0xca, 0xde, 0x7e, 0xf1, 0xa2,
0x6e, 0xdb, 0x10, 0x9f, 0xe2, 0x38, 0x94, 0x4d, 0xe0, 0x5b, 0xa8, 0x78, 0x82, 0x7d, 0xb4, 0x80,
0x64, 0x81, 0xec, 0xed, 0x17, 0x2f, 0x1f, 0xe3, 0x44, 0xad, 0x23, 0x9b, 0xc0, 0x6f, 0xa0, 0x0b,
0xc7, 0x7b, 0x0a, 0xf3, 0xe2, 0x18, 0xfb, 0xd9, 0xbf, 0x26, 0xd0, 0xa8, 0xea, 0x7a, 0x7c, 0xd3,
0x2a, 0x94, 0xd6, 0x79, 0x91, 0x28, 0x57, 0x9a, 0xb5, 0x7a, 0x13, 0xa4, 0x70, 0xd3, 0x14, 0xaf,
0xe6, 0xc2, 0x4f, 0x1e, 0xe3, 0x1a, 0x7d, 0xa9, 0x52, 0xab, 0xd0, 0xea, 0x42, 0x78, 0xa2, 0x8a,
0xbd, 0xc4, 0x1c, 0xe6, 0xd9, 0x2d, 0xfc, 0x26, 0xba, 0x18, 0x77, 0xde, 0xb8, 0xbb, 0x70, 0x2b,
0xdc, 0x25, 0x58, 0xa0, 0xf6, 0x80, 0xc6, 0x66, 0x6b, 0x03, 0x0e, 0xe6, 0xad, 0x98, 0x55, 0xb5,
0x76, 0x6f, 0x7e, 0xb9, 0x5a, 0x16, 0x56, 0xc9, 0x42, 0x7e, 0x6f, 0xbf, 0x78, 0x4e, 0x59, 0xc9,
0x0f, 0x1c, 0xdc, 0x6c, 0xf6, 0xeb, 0x04, 0x9a, 0xfe, 0xf6, 0xe6, 0x85, 0xef, 0xa3, 0x97, 0x61,
0xbf, 0x8e, 0x94, 0x02, 0x59, 0xb7, 0xc4, 0x1e, 0xce, 0xaf, 0xac, 0x54, 0x6a, 0xe5, 0xdc, 0x50,
0x61, 0x66, 0x6f, 0xbf, 0x78, 0xf5, 0xdb, 0x5d, 0xce, 0xf7, 0x7a, 0xcc, 0xb1, 0x4e, 0xe9, 0x78,
0xb1, 0x4e, 0x97, 0x2a, 0xab, 0xb9, 0xc4, 0x69, 0x1c, 0x2f, 0xba, 0x5e, 0x9b, 0xf5, 0x4b, 0x77,
0x1e, 0x7f, 0x33, 0x3d, 0xf4, 0xe4, 0x9b, 0xe9, 0xa1, 0xc7, 0x4f, 0xa7, 0x13, 0x4f, 0x9e, 0x4e,
0x27, 0x7e, 0xfd, 0x6c, 0x7a, 0xe8, 0xcb, 0x67, 0xd3, 0x89, 0x27, 0xcf, 0xa6, 0x87, 0xfe, 0xf6,
0x6c, 0x7a, 0xe8, 0xe1, 0x2b, 0x6d, 0xbb, 0xbf, 0xb1, 0xb9, 0x76, 0xad, 0xe5, 0x76, 0xaf, 0xfb,
0xbb, 0x4e, 0xab, 0xbf, 0x61, 0x3b, 0x6d, 0xed, 0x97, 0xfe, 0xbf, 0x27, 0xd6, 0x32, 0xf0, 0xeb,
0x8d, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0xa2, 0xde, 0xa7, 0x53, 0x54, 0x21, 0x00, 0x00,
}
func (m *Hello) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Hello) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Hello) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.ClientVersion) > 0 {
i -= len(m.ClientVersion)
copy(dAtA[i:], m.ClientVersion)
i = encodeVarintBep(dAtA, i, uint64(len(m.ClientVersion)))
i--
dAtA[i] = 0x1a
}
if len(m.ClientName) > 0 {
i -= len(m.ClientName)
copy(dAtA[i:], m.ClientName)
i = encodeVarintBep(dAtA, i, uint64(len(m.ClientName)))
i--
dAtA[i] = 0x12
}
if len(m.DeviceName) > 0 {
i -= len(m.DeviceName)
copy(dAtA[i:], m.DeviceName)
i = encodeVarintBep(dAtA, i, uint64(len(m.DeviceName)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *Header) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Header) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Compression != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Compression))
i--
dAtA[i] = 0x10
}
if m.Type != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Type))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *ClusterConfig) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *ClusterConfig) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *ClusterConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
2023-05-23 12:53:48 +00:00
if m.Secondary {
i--
if m.Secondary {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x10
}
if len(m.Folders) > 0 {
for iNdEx := len(m.Folders) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Folders[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func (m *Folder) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Folder) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Folder) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Devices) > 0 {
for iNdEx := len(m.Devices) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Devices[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1
i--
dAtA[i] = 0x82
}
}
if m.Paused {
i--
if m.Paused {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x38
}
if m.DisableTempIndexes {
i--
if m.DisableTempIndexes {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x30
}
if m.IgnoreDelete {
i--
if m.IgnoreDelete {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x28
}
if m.IgnorePermissions {
i--
if m.IgnorePermissions {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x20
}
if m.ReadOnly {
i--
if m.ReadOnly {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x18
}
if len(m.Label) > 0 {
i -= len(m.Label)
copy(dAtA[i:], m.Label)
i = encodeVarintBep(dAtA, i, uint64(len(m.Label)))
i--
dAtA[i] = 0x12
}
if len(m.ID) > 0 {
i -= len(m.ID)
copy(dAtA[i:], m.ID)
i = encodeVarintBep(dAtA, i, uint64(len(m.ID)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *Device) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Device) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Device) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.EncryptionPasswordToken) > 0 {
i -= len(m.EncryptionPasswordToken)
copy(dAtA[i:], m.EncryptionPasswordToken)
i = encodeVarintBep(dAtA, i, uint64(len(m.EncryptionPasswordToken)))
i--
dAtA[i] = 0x52
}
if m.SkipIntroductionRemovals {
i--
if m.SkipIntroductionRemovals {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x48
}
if m.IndexID != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.IndexID))
i--
dAtA[i] = 0x40
}
if m.Introducer {
i--
if m.Introducer {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x38
}
if m.MaxSequence != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.MaxSequence))
i--
dAtA[i] = 0x30
}
if len(m.CertName) > 0 {
i -= len(m.CertName)
copy(dAtA[i:], m.CertName)
i = encodeVarintBep(dAtA, i, uint64(len(m.CertName)))
i--
dAtA[i] = 0x2a
}
if m.Compression != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Compression))
i--
dAtA[i] = 0x20
}
if len(m.Addresses) > 0 {
for iNdEx := len(m.Addresses) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.Addresses[iNdEx])
copy(dAtA[i:], m.Addresses[iNdEx])
i = encodeVarintBep(dAtA, i, uint64(len(m.Addresses[iNdEx])))
i--
dAtA[i] = 0x1a
}
}
if len(m.Name) > 0 {
i -= len(m.Name)
copy(dAtA[i:], m.Name)
i = encodeVarintBep(dAtA, i, uint64(len(m.Name)))
i--
dAtA[i] = 0x12
}
{
size := m.ID.ProtoSize()
i -= size
if _, err := m.ID.MarshalTo(dAtA[i:]); err != nil {
return 0, err
}
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil
}
func (m *Index) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Index) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Index) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Files) > 0 {
for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Files[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
}
if len(m.Folder) > 0 {
i -= len(m.Folder)
copy(dAtA[i:], m.Folder)
i = encodeVarintBep(dAtA, i, uint64(len(m.Folder)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *IndexUpdate) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *IndexUpdate) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *IndexUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Files) > 0 {
for iNdEx := len(m.Files) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Files[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
}
if len(m.Folder) > 0 {
i -= len(m.Folder)
copy(dAtA[i:], m.Folder)
i = encodeVarintBep(dAtA, i, uint64(len(m.Folder)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *FileInfo) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *FileInfo) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *FileInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.EncryptionTrailerSize != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.EncryptionTrailerSize))
i--
dAtA[i] = 0x3e
i--
dAtA[i] = 0xd8
}
if m.InodeChangeNs != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.InodeChangeNs))
i--
dAtA[i] = 0x3e
i--
dAtA[i] = 0xd0
}
if len(m.VersionHash) > 0 {
i -= len(m.VersionHash)
copy(dAtA[i:], m.VersionHash)
i = encodeVarintBep(dAtA, i, uint64(len(m.VersionHash)))
i--
dAtA[i] = 0x3e
i--
dAtA[i] = 0xca
}
if m.LocalFlags != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.LocalFlags))
i--
dAtA[i] = 0x3e
i--
dAtA[i] = 0xc0
}
if len(m.Encrypted) > 0 {
i -= len(m.Encrypted)
copy(dAtA[i:], m.Encrypted)
i = encodeVarintBep(dAtA, i, uint64(len(m.Encrypted)))
i--
dAtA[i] = 0x1
i--
dAtA[i] = 0x9a
}
lib/db: Deduplicate block lists in database (fixes #5898) (#6283) * lib/db: Deduplicate block lists in database (fixes #5898) This moves the block list in the database out from being just a field on the FileInfo to being an object of its own. When putting a FileInfo we marshal the block list separately and store it keyed by the sha256 of the marshalled block list. When getting, if we are not doing a "truncated" get, we do an extra read and unmarshal for the block list. Old block lists are cleared out by a periodic GC sweep. The alternative would be to use refcounting, but: - There is a larger risk of getting that wrong and either dropping a block list in error or keeping them around forever. - It's tricky with our current database, as we don't have dirty reads. This means that if we update two FileInfos with identical block lists in the same transaction we can't just do read/modify/write for the ref counters as we wouldn't see our own first update. See above about tracking this and risks about getting it wrong. GC uses a bloom filter for keys to avoid heavy RAM usage. GC can't run concurrently with FileInfo updates so there is a new lock around those operation at the lowlevel. The end result is a much more compact database, especially for setups with many peers where files get duplicated many times. This is per-key-class stats for a large database I'm currently working with, under the current schema: ``` 0x00: 9138161 items, 870876 KB keys + 7397482 KB data, 95 B + 809 B avg, 1637651 B max 0x01: 185656 items, 10388 KB keys + 1790909 KB data, 55 B + 9646 B avg, 924525 B max 0x02: 916890 items, 84795 KB keys + 3667 KB data, 92 B + 4 B avg, 192 B max 0x03: 384 items, 27 KB keys + 5 KB data, 72 B + 15 B avg, 87 B max 0x04: 1109 items, 17 KB keys + 17 KB data, 15 B + 15 B avg, 69 B max 0x06: 383 items, 3 KB keys + 0 KB data, 9 B + 2 B avg, 18 B max 0x07: 510 items, 4 KB keys + 12 KB data, 9 B + 24 B avg, 41 B max 0x08: 1349 items, 12 KB keys + 10 KB data, 9 B + 8 B avg, 17 B max 0x09: 194 items, 0 KB keys + 123 KB data, 5 B + 634 B avg, 11484 B max 0x0a: 3 items, 0 KB keys + 0 KB data, 14 B + 7 B avg, 30 B max 0x0b: 181836 items, 2363 KB keys + 10694 KB data, 13 B + 58 B avg, 173 B max Total 10426475 items, 968490 KB keys + 9202925 KB data. ``` Note 7.4 GB of data in class 00, total size 9.2 GB. After running the migration we get this instead: ``` 0x00: 9138161 items, 870876 KB keys + 2611392 KB data, 95 B + 285 B avg, 4788 B max 0x01: 185656 items, 10388 KB keys + 1790909 KB data, 55 B + 9646 B avg, 924525 B max 0x02: 916890 items, 84795 KB keys + 3667 KB data, 92 B + 4 B avg, 192 B max 0x03: 384 items, 27 KB keys + 5 KB data, 72 B + 15 B avg, 87 B max 0x04: 1109 items, 17 KB keys + 17 KB data, 15 B + 15 B avg, 69 B max 0x06: 383 items, 3 KB keys + 0 KB data, 9 B + 2 B avg, 18 B max 0x07: 510 items, 4 KB keys + 12 KB data, 9 B + 24 B avg, 41 B max 0x09: 194 items, 0 KB keys + 123 KB data, 5 B + 634 B avg, 11484 B max 0x0a: 3 items, 0 KB keys + 0 KB data, 14 B + 17 B avg, 51 B max 0x0b: 181836 items, 2363 KB keys + 10694 KB data, 13 B + 58 B avg, 173 B max 0x0d: 44282 items, 1461 KB keys + 61081 KB data, 33 B + 1379 B avg, 1637399 B max Total 10469408 items, 969939 KB keys + 4477905 KB data. ``` Class 00 is now down to 2.6 GB, with just 61 MB added in class 0d. There will be some additional reads in some cases which theoretically hurts performance, but this will be more than compensated for by smaller writes and better compaction. On my own home setup which just has three devices and a handful of folders the difference is smaller in absolute numbers of course, but still less than half the old size: ``` 0x00: 297122 items, 20894 KB keys + 306860 KB data, 70 B + 1032 B avg, 103237 B max 0x01: 115299 items, 7738 KB keys + 17542 KB data, 67 B + 152 B avg, 419 B max 0x02: 1430537 items, 121223 KB keys + 5722 KB data, 84 B + 4 B avg, 253 B max ... Total 1947412 items, 151268 KB keys + 337485 KB data. ``` to: ``` 0x00: 297122 items, 20894 KB keys + 37038 KB data, 70 B + 124 B avg, 520 B max 0x01: 115299 items, 7738 KB keys + 17542 KB data, 67 B + 152 B avg, 419 B max 0x02: 1430537 items, 121223 KB keys + 5722 KB data, 84 B + 4 B avg, 253 B max ... 0x0d: 18041 items, 595 KB keys + 71964 KB data, 33 B + 3988 B avg, 101109 B max Total 1965447 items, 151863 KB keys + 139628 KB data. ``` * wip * wip * wip * wip
2020-01-24 07:35:44 +00:00
if len(m.BlocksHash) > 0 {
i -= len(m.BlocksHash)
copy(dAtA[i:], m.BlocksHash)
i = encodeVarintBep(dAtA, i, uint64(len(m.BlocksHash)))
i--
dAtA[i] = 0x1
i--
dAtA[i] = 0x92
}
if len(m.SymlinkTarget) > 0 {
i -= len(m.SymlinkTarget)
copy(dAtA[i:], m.SymlinkTarget)
i = encodeVarintBep(dAtA, i, uint64(len(m.SymlinkTarget)))
i--
dAtA[i] = 0x1
i--
dAtA[i] = 0x8a
}
if len(m.Blocks) > 0 {
for iNdEx := len(m.Blocks) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Blocks[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1
i--
dAtA[i] = 0x82
}
}
{
size, err := m.Platform.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x72
if m.RawBlockSize != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.RawBlockSize))
i--
dAtA[i] = 0x68
}
if m.ModifiedBy != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.ModifiedBy))
i--
dAtA[i] = 0x60
}
if m.ModifiedNs != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.ModifiedNs))
i--
dAtA[i] = 0x58
}
if m.Sequence != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Sequence))
i--
dAtA[i] = 0x50
}
{
size, err := m.Version.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x4a
if m.NoPermissions {
i--
if m.NoPermissions {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x40
}
if m.RawInvalid {
i--
if m.RawInvalid {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x38
}
if m.Deleted {
i--
if m.Deleted {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x30
}
if m.ModifiedS != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.ModifiedS))
i--
dAtA[i] = 0x28
}
if m.Permissions != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Permissions))
i--
dAtA[i] = 0x20
}
if m.Size != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Size))
i--
dAtA[i] = 0x18
}
if m.Type != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Type))
i--
dAtA[i] = 0x10
}
if len(m.Name) > 0 {
i -= len(m.Name)
copy(dAtA[i:], m.Name)
i = encodeVarintBep(dAtA, i, uint64(len(m.Name)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *BlockInfo) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *BlockInfo) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *BlockInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.WeakHash != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.WeakHash))
i--
dAtA[i] = 0x20
}
if len(m.Hash) > 0 {
i -= len(m.Hash)
copy(dAtA[i:], m.Hash)
i = encodeVarintBep(dAtA, i, uint64(len(m.Hash)))
i--
dAtA[i] = 0x1a
}
if m.Size != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Size))
i--
dAtA[i] = 0x10
}
if m.Offset != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Offset))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *Vector) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Vector) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Vector) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Counters) > 0 {
for iNdEx := len(m.Counters) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Counters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func (m *Counter) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Counter) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Counter) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Value != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Value))
i--
dAtA[i] = 0x10
}
if m.ID != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.ID))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *PlatformData) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *PlatformData) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *PlatformData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.NetBSD != nil {
{
size, err := m.NetBSD.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x32
}
if m.FreeBSD != nil {
{
size, err := m.FreeBSD.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x2a
}
if m.Darwin != nil {
{
size, err := m.Darwin.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
}
if m.Linux != nil {
{
size, err := m.Linux.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
}
if m.Windows != nil {
{
size, err := m.Windows.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
if m.Unix != nil {
{
size, err := m.Unix.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *UnixData) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *UnixData) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *UnixData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.GID != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.GID))
i--
dAtA[i] = 0x20
}
if m.UID != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.UID))
i--
dAtA[i] = 0x18
}
if len(m.GroupName) > 0 {
i -= len(m.GroupName)
copy(dAtA[i:], m.GroupName)
i = encodeVarintBep(dAtA, i, uint64(len(m.GroupName)))
i--
dAtA[i] = 0x12
}
if len(m.OwnerName) > 0 {
i -= len(m.OwnerName)
copy(dAtA[i:], m.OwnerName)
i = encodeVarintBep(dAtA, i, uint64(len(m.OwnerName)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *WindowsData) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *WindowsData) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *WindowsData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.OwnerIsGroup {
i--
if m.OwnerIsGroup {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x10
}
if len(m.OwnerName) > 0 {
i -= len(m.OwnerName)
copy(dAtA[i:], m.OwnerName)
i = encodeVarintBep(dAtA, i, uint64(len(m.OwnerName)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *XattrData) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *XattrData) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *XattrData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Xattrs) > 0 {
for iNdEx := len(m.Xattrs) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Xattrs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func (m *Xattr) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Xattr) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Xattr) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Value) > 0 {
i -= len(m.Value)
copy(dAtA[i:], m.Value)
i = encodeVarintBep(dAtA, i, uint64(len(m.Value)))
i--
dAtA[i] = 0x12
}
if len(m.Name) > 0 {
i -= len(m.Name)
copy(dAtA[i:], m.Name)
i = encodeVarintBep(dAtA, i, uint64(len(m.Name)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *Request) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Request) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.BlockNo != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.BlockNo))
i--
dAtA[i] = 0x48
}
if m.WeakHash != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.WeakHash))
i--
dAtA[i] = 0x40
}
if m.FromTemporary {
i--
if m.FromTemporary {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x38
}
if len(m.Hash) > 0 {
i -= len(m.Hash)
copy(dAtA[i:], m.Hash)
i = encodeVarintBep(dAtA, i, uint64(len(m.Hash)))
i--
dAtA[i] = 0x32
}
if m.Size != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Size))
i--
dAtA[i] = 0x28
}
if m.Offset != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Offset))
i--
dAtA[i] = 0x20
}
if len(m.Name) > 0 {
i -= len(m.Name)
copy(dAtA[i:], m.Name)
i = encodeVarintBep(dAtA, i, uint64(len(m.Name)))
i--
dAtA[i] = 0x1a
}
if len(m.Folder) > 0 {
i -= len(m.Folder)
copy(dAtA[i:], m.Folder)
i = encodeVarintBep(dAtA, i, uint64(len(m.Folder)))
i--
dAtA[i] = 0x12
}
if m.ID != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.ID))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *Response) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Response) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Code != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.Code))
i--
dAtA[i] = 0x18
}
if len(m.Data) > 0 {
i -= len(m.Data)
copy(dAtA[i:], m.Data)
i = encodeVarintBep(dAtA, i, uint64(len(m.Data)))
i--
dAtA[i] = 0x12
}
if m.ID != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.ID))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *DownloadProgress) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *DownloadProgress) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *DownloadProgress) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Updates) > 0 {
for iNdEx := len(m.Updates) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Updates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
}
if len(m.Folder) > 0 {
i -= len(m.Folder)
copy(dAtA[i:], m.Folder)
i = encodeVarintBep(dAtA, i, uint64(len(m.Folder)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *FileDownloadProgressUpdate) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *FileDownloadProgressUpdate) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *FileDownloadProgressUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.BlockSize != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.BlockSize))
i--
dAtA[i] = 0x28
}
if len(m.BlockIndexes) > 0 {
for iNdEx := len(m.BlockIndexes) - 1; iNdEx >= 0; iNdEx-- {
i = encodeVarintBep(dAtA, i, uint64(m.BlockIndexes[iNdEx]))
i--
dAtA[i] = 0x20
}
}
{
size, err := m.Version.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintBep(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
if len(m.Name) > 0 {
i -= len(m.Name)
copy(dAtA[i:], m.Name)
i = encodeVarintBep(dAtA, i, uint64(len(m.Name)))
i--
dAtA[i] = 0x12
}
if m.UpdateType != 0 {
i = encodeVarintBep(dAtA, i, uint64(m.UpdateType))
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *Ping) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Ping) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Ping) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
return len(dAtA) - i, nil
}
func (m *Close) Marshal() (dAtA []byte, err error) {
size := m.ProtoSize()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Close) MarshalTo(dAtA []byte) (int, error) {
size := m.ProtoSize()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Close) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Reason) > 0 {
i -= len(m.Reason)
copy(dAtA[i:], m.Reason)
i = encodeVarintBep(dAtA, i, uint64(len(m.Reason)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func encodeVarintBep(dAtA []byte, offset int, v uint64) int {
offset -= sovBep(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *Hello) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.DeviceName)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
l = len(m.ClientName)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
l = len(m.ClientVersion)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
return n
}
func (m *Header) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Type != 0 {
n += 1 + sovBep(uint64(m.Type))
}
if m.Compression != 0 {
n += 1 + sovBep(uint64(m.Compression))
}
return n
}
func (m *ClusterConfig) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.Folders) > 0 {
for _, e := range m.Folders {
l = e.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
}
2023-05-23 12:53:48 +00:00
if m.Secondary {
n += 2
}
return n
}
func (m *Folder) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.ID)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
l = len(m.Label)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if m.ReadOnly {
n += 2
}
if m.IgnorePermissions {
n += 2
}
if m.IgnoreDelete {
n += 2
}
if m.DisableTempIndexes {
n += 2
}
if m.Paused {
n += 2
}
if len(m.Devices) > 0 {
for _, e := range m.Devices {
l = e.ProtoSize()
n += 2 + l + sovBep(uint64(l))
}
}
return n
}
func (m *Device) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = m.ID.ProtoSize()
n += 1 + l + sovBep(uint64(l))
l = len(m.Name)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if len(m.Addresses) > 0 {
for _, s := range m.Addresses {
l = len(s)
n += 1 + l + sovBep(uint64(l))
}
}
if m.Compression != 0 {
n += 1 + sovBep(uint64(m.Compression))
}
l = len(m.CertName)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if m.MaxSequence != 0 {
n += 1 + sovBep(uint64(m.MaxSequence))
}
if m.Introducer {
n += 2
}
if m.IndexID != 0 {
n += 1 + sovBep(uint64(m.IndexID))
}
if m.SkipIntroductionRemovals {
n += 2
}
l = len(m.EncryptionPasswordToken)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
return n
}
func (m *Index) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Folder)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if len(m.Files) > 0 {
for _, e := range m.Files {
l = e.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
}
return n
}
func (m *IndexUpdate) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Folder)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if len(m.Files) > 0 {
for _, e := range m.Files {
l = e.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
}
return n
}
func (m *FileInfo) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Name)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if m.Type != 0 {
n += 1 + sovBep(uint64(m.Type))
}
if m.Size != 0 {
n += 1 + sovBep(uint64(m.Size))
}
if m.Permissions != 0 {
n += 1 + sovBep(uint64(m.Permissions))
}
if m.ModifiedS != 0 {
n += 1 + sovBep(uint64(m.ModifiedS))
}
if m.Deleted {
n += 2
}
if m.RawInvalid {
n += 2
}
if m.NoPermissions {
n += 2
}
l = m.Version.ProtoSize()
n += 1 + l + sovBep(uint64(l))
if m.Sequence != 0 {
n += 1 + sovBep(uint64(m.Sequence))
}
if m.ModifiedNs != 0 {
n += 1 + sovBep(uint64(m.ModifiedNs))
}
if m.ModifiedBy != 0 {
n += 1 + sovBep(uint64(m.ModifiedBy))
}
if m.RawBlockSize != 0 {
n += 1 + sovBep(uint64(m.RawBlockSize))
}
l = m.Platform.ProtoSize()
n += 1 + l + sovBep(uint64(l))
if len(m.Blocks) > 0 {
for _, e := range m.Blocks {
l = e.ProtoSize()
n += 2 + l + sovBep(uint64(l))
}
}
l = len(m.SymlinkTarget)
if l > 0 {
n += 2 + l + sovBep(uint64(l))
}
lib/db: Deduplicate block lists in database (fixes #5898) (#6283) * lib/db: Deduplicate block lists in database (fixes #5898) This moves the block list in the database out from being just a field on the FileInfo to being an object of its own. When putting a FileInfo we marshal the block list separately and store it keyed by the sha256 of the marshalled block list. When getting, if we are not doing a "truncated" get, we do an extra read and unmarshal for the block list. Old block lists are cleared out by a periodic GC sweep. The alternative would be to use refcounting, but: - There is a larger risk of getting that wrong and either dropping a block list in error or keeping them around forever. - It's tricky with our current database, as we don't have dirty reads. This means that if we update two FileInfos with identical block lists in the same transaction we can't just do read/modify/write for the ref counters as we wouldn't see our own first update. See above about tracking this and risks about getting it wrong. GC uses a bloom filter for keys to avoid heavy RAM usage. GC can't run concurrently with FileInfo updates so there is a new lock around those operation at the lowlevel. The end result is a much more compact database, especially for setups with many peers where files get duplicated many times. This is per-key-class stats for a large database I'm currently working with, under the current schema: ``` 0x00: 9138161 items, 870876 KB keys + 7397482 KB data, 95 B + 809 B avg, 1637651 B max 0x01: 185656 items, 10388 KB keys + 1790909 KB data, 55 B + 9646 B avg, 924525 B max 0x02: 916890 items, 84795 KB keys + 3667 KB data, 92 B + 4 B avg, 192 B max 0x03: 384 items, 27 KB keys + 5 KB data, 72 B + 15 B avg, 87 B max 0x04: 1109 items, 17 KB keys + 17 KB data, 15 B + 15 B avg, 69 B max 0x06: 383 items, 3 KB keys + 0 KB data, 9 B + 2 B avg, 18 B max 0x07: 510 items, 4 KB keys + 12 KB data, 9 B + 24 B avg, 41 B max 0x08: 1349 items, 12 KB keys + 10 KB data, 9 B + 8 B avg, 17 B max 0x09: 194 items, 0 KB keys + 123 KB data, 5 B + 634 B avg, 11484 B max 0x0a: 3 items, 0 KB keys + 0 KB data, 14 B + 7 B avg, 30 B max 0x0b: 181836 items, 2363 KB keys + 10694 KB data, 13 B + 58 B avg, 173 B max Total 10426475 items, 968490 KB keys + 9202925 KB data. ``` Note 7.4 GB of data in class 00, total size 9.2 GB. After running the migration we get this instead: ``` 0x00: 9138161 items, 870876 KB keys + 2611392 KB data, 95 B + 285 B avg, 4788 B max 0x01: 185656 items, 10388 KB keys + 1790909 KB data, 55 B + 9646 B avg, 924525 B max 0x02: 916890 items, 84795 KB keys + 3667 KB data, 92 B + 4 B avg, 192 B max 0x03: 384 items, 27 KB keys + 5 KB data, 72 B + 15 B avg, 87 B max 0x04: 1109 items, 17 KB keys + 17 KB data, 15 B + 15 B avg, 69 B max 0x06: 383 items, 3 KB keys + 0 KB data, 9 B + 2 B avg, 18 B max 0x07: 510 items, 4 KB keys + 12 KB data, 9 B + 24 B avg, 41 B max 0x09: 194 items, 0 KB keys + 123 KB data, 5 B + 634 B avg, 11484 B max 0x0a: 3 items, 0 KB keys + 0 KB data, 14 B + 17 B avg, 51 B max 0x0b: 181836 items, 2363 KB keys + 10694 KB data, 13 B + 58 B avg, 173 B max 0x0d: 44282 items, 1461 KB keys + 61081 KB data, 33 B + 1379 B avg, 1637399 B max Total 10469408 items, 969939 KB keys + 4477905 KB data. ``` Class 00 is now down to 2.6 GB, with just 61 MB added in class 0d. There will be some additional reads in some cases which theoretically hurts performance, but this will be more than compensated for by smaller writes and better compaction. On my own home setup which just has three devices and a handful of folders the difference is smaller in absolute numbers of course, but still less than half the old size: ``` 0x00: 297122 items, 20894 KB keys + 306860 KB data, 70 B + 1032 B avg, 103237 B max 0x01: 115299 items, 7738 KB keys + 17542 KB data, 67 B + 152 B avg, 419 B max 0x02: 1430537 items, 121223 KB keys + 5722 KB data, 84 B + 4 B avg, 253 B max ... Total 1947412 items, 151268 KB keys + 337485 KB data. ``` to: ``` 0x00: 297122 items, 20894 KB keys + 37038 KB data, 70 B + 124 B avg, 520 B max 0x01: 115299 items, 7738 KB keys + 17542 KB data, 67 B + 152 B avg, 419 B max 0x02: 1430537 items, 121223 KB keys + 5722 KB data, 84 B + 4 B avg, 253 B max ... 0x0d: 18041 items, 595 KB keys + 71964 KB data, 33 B + 3988 B avg, 101109 B max Total 1965447 items, 151863 KB keys + 139628 KB data. ``` * wip * wip * wip * wip
2020-01-24 07:35:44 +00:00
l = len(m.BlocksHash)
if l > 0 {
n += 2 + l + sovBep(uint64(l))
}
l = len(m.Encrypted)
if l > 0 {
n += 2 + l + sovBep(uint64(l))
}
if m.LocalFlags != 0 {
n += 2 + sovBep(uint64(m.LocalFlags))
}
l = len(m.VersionHash)
if l > 0 {
n += 2 + l + sovBep(uint64(l))
}
if m.InodeChangeNs != 0 {
n += 2 + sovBep(uint64(m.InodeChangeNs))
}
if m.EncryptionTrailerSize != 0 {
n += 2 + sovBep(uint64(m.EncryptionTrailerSize))
}
return n
}
func (m *BlockInfo) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Offset != 0 {
n += 1 + sovBep(uint64(m.Offset))
}
if m.Size != 0 {
n += 1 + sovBep(uint64(m.Size))
}
l = len(m.Hash)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if m.WeakHash != 0 {
n += 1 + sovBep(uint64(m.WeakHash))
}
return n
}
func (m *Vector) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.Counters) > 0 {
for _, e := range m.Counters {
l = e.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
}
return n
}
func (m *Counter) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.ID != 0 {
n += 1 + sovBep(uint64(m.ID))
}
if m.Value != 0 {
n += 1 + sovBep(uint64(m.Value))
}
return n
}
func (m *PlatformData) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Unix != nil {
l = m.Unix.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
if m.Windows != nil {
l = m.Windows.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
if m.Linux != nil {
l = m.Linux.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
if m.Darwin != nil {
l = m.Darwin.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
if m.FreeBSD != nil {
l = m.FreeBSD.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
if m.NetBSD != nil {
l = m.NetBSD.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
return n
}
func (m *UnixData) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.OwnerName)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
l = len(m.GroupName)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if m.UID != 0 {
n += 1 + sovBep(uint64(m.UID))
}
if m.GID != 0 {
n += 1 + sovBep(uint64(m.GID))
}
return n
}
func (m *WindowsData) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.OwnerName)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if m.OwnerIsGroup {
n += 2
}
return n
}
func (m *XattrData) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.Xattrs) > 0 {
for _, e := range m.Xattrs {
l = e.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
}
return n
}
func (m *Xattr) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Name)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
l = len(m.Value)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
return n
}
func (m *Request) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.ID != 0 {
n += 1 + sovBep(uint64(m.ID))
}
l = len(m.Folder)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
l = len(m.Name)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if m.Offset != 0 {
n += 1 + sovBep(uint64(m.Offset))
}
if m.Size != 0 {
n += 1 + sovBep(uint64(m.Size))
}
l = len(m.Hash)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if m.FromTemporary {
n += 2
}
if m.WeakHash != 0 {
n += 1 + sovBep(uint64(m.WeakHash))
}
if m.BlockNo != 0 {
n += 1 + sovBep(uint64(m.BlockNo))
}
return n
}
func (m *Response) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.ID != 0 {
n += 1 + sovBep(uint64(m.ID))
}
l = len(m.Data)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if m.Code != 0 {
n += 1 + sovBep(uint64(m.Code))
}
return n
}
func (m *DownloadProgress) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Folder)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
if len(m.Updates) > 0 {
for _, e := range m.Updates {
l = e.ProtoSize()
n += 1 + l + sovBep(uint64(l))
}
}
return n
}
func (m *FileDownloadProgressUpdate) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.UpdateType != 0 {
n += 1 + sovBep(uint64(m.UpdateType))
}
l = len(m.Name)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
l = m.Version.ProtoSize()
n += 1 + l + sovBep(uint64(l))
if len(m.BlockIndexes) > 0 {
for _, e := range m.BlockIndexes {
n += 1 + sovBep(uint64(e))
}
}
if m.BlockSize != 0 {
n += 1 + sovBep(uint64(m.BlockSize))
}
return n
}
func (m *Ping) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
return n
}
func (m *Close) ProtoSize() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Reason)
if l > 0 {
n += 1 + l + sovBep(uint64(l))
}
return n
}
func sovBep(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozBep(x uint64) (n int) {
return sovBep(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Hello) 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 ErrIntOverflowBep
}
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: Hello: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Hello: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field DeviceName", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.DeviceName = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ClientName", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ClientName = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ClientVersion", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ClientVersion = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Header) 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 ErrIntOverflowBep
}
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: Header: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
m.Type = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Type |= MessageType(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Compression", wireType)
}
m.Compression = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Compression |= MessageCompression(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *ClusterConfig) 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 ErrIntOverflowBep
}
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: ClusterConfig: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ClusterConfig: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Folders", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Folders = append(m.Folders, Folder{})
if err := m.Folders[len(m.Folders)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
2023-05-23 12:53:48 +00:00
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Secondary", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Secondary = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Folder) 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 ErrIntOverflowBep
}
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: Folder: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Folder: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.ID = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Label = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ReadOnly", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.ReadOnly = bool(v != 0)
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field IgnorePermissions", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.IgnorePermissions = bool(v != 0)
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field IgnoreDelete", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.IgnoreDelete = bool(v != 0)
case 6:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field DisableTempIndexes", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.DisableTempIndexes = bool(v != 0)
case 7:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Paused", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Paused = bool(v != 0)
case 16:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Devices", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Devices = append(m.Devices, Device{})
if err := m.Devices[len(m.Devices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Device) 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 ErrIntOverflowBep
}
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: Device: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Device: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Addresses", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Addresses = append(m.Addresses, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Compression", wireType)
}
m.Compression = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Compression |= Compression(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field CertName", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.CertName = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 6:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field MaxSequence", wireType)
}
m.MaxSequence = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.MaxSequence |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 7:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Introducer", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Introducer = bool(v != 0)
case 8:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field IndexID", wireType)
}
m.IndexID = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.IndexID |= IndexID(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 9:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field SkipIntroductionRemovals", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.SkipIntroductionRemovals = bool(v != 0)
case 10:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field EncryptionPasswordToken", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.EncryptionPasswordToken = append(m.EncryptionPasswordToken[:0], dAtA[iNdEx:postIndex]...)
if m.EncryptionPasswordToken == nil {
m.EncryptionPasswordToken = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Index) 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 ErrIntOverflowBep
}
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: Index: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Index: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Folder", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Folder = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Files = append(m.Files, FileInfo{})
if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *IndexUpdate) 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 ErrIntOverflowBep
}
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: IndexUpdate: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: IndexUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Folder", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Folder = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Files", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Files = append(m.Files, FileInfo{})
if err := m.Files[len(m.Files)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *FileInfo) 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 ErrIntOverflowBep
}
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: FileInfo: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: FileInfo: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
m.Type = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Type |= FileInfoType(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Size", wireType)
}
m.Size = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Size |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
}
m.Permissions = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Permissions |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ModifiedS", wireType)
}
m.ModifiedS = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ModifiedS |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 6:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Deleted", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Deleted = bool(v != 0)
case 7:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field RawInvalid", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.RawInvalid = bool(v != 0)
case 8:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field NoPermissions", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.NoPermissions = bool(v != 0)
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 10:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
}
m.Sequence = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Sequence |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 11:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ModifiedNs", wireType)
}
m.ModifiedNs = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ModifiedNs |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 12:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ModifiedBy", wireType)
}
m.ModifiedBy = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ModifiedBy |= ShortID(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 13:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field RawBlockSize", wireType)
}
m.RawBlockSize = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.RawBlockSize |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 14:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Platform.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 16:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Blocks", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Blocks = append(m.Blocks, BlockInfo{})
if err := m.Blocks[len(m.Blocks)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 17:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SymlinkTarget", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.SymlinkTarget = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
lib/db: Deduplicate block lists in database (fixes #5898) (#6283) * lib/db: Deduplicate block lists in database (fixes #5898) This moves the block list in the database out from being just a field on the FileInfo to being an object of its own. When putting a FileInfo we marshal the block list separately and store it keyed by the sha256 of the marshalled block list. When getting, if we are not doing a "truncated" get, we do an extra read and unmarshal for the block list. Old block lists are cleared out by a periodic GC sweep. The alternative would be to use refcounting, but: - There is a larger risk of getting that wrong and either dropping a block list in error or keeping them around forever. - It's tricky with our current database, as we don't have dirty reads. This means that if we update two FileInfos with identical block lists in the same transaction we can't just do read/modify/write for the ref counters as we wouldn't see our own first update. See above about tracking this and risks about getting it wrong. GC uses a bloom filter for keys to avoid heavy RAM usage. GC can't run concurrently with FileInfo updates so there is a new lock around those operation at the lowlevel. The end result is a much more compact database, especially for setups with many peers where files get duplicated many times. This is per-key-class stats for a large database I'm currently working with, under the current schema: ``` 0x00: 9138161 items, 870876 KB keys + 7397482 KB data, 95 B + 809 B avg, 1637651 B max 0x01: 185656 items, 10388 KB keys + 1790909 KB data, 55 B + 9646 B avg, 924525 B max 0x02: 916890 items, 84795 KB keys + 3667 KB data, 92 B + 4 B avg, 192 B max 0x03: 384 items, 27 KB keys + 5 KB data, 72 B + 15 B avg, 87 B max 0x04: 1109 items, 17 KB keys + 17 KB data, 15 B + 15 B avg, 69 B max 0x06: 383 items, 3 KB keys + 0 KB data, 9 B + 2 B avg, 18 B max 0x07: 510 items, 4 KB keys + 12 KB data, 9 B + 24 B avg, 41 B max 0x08: 1349 items, 12 KB keys + 10 KB data, 9 B + 8 B avg, 17 B max 0x09: 194 items, 0 KB keys + 123 KB data, 5 B + 634 B avg, 11484 B max 0x0a: 3 items, 0 KB keys + 0 KB data, 14 B + 7 B avg, 30 B max 0x0b: 181836 items, 2363 KB keys + 10694 KB data, 13 B + 58 B avg, 173 B max Total 10426475 items, 968490 KB keys + 9202925 KB data. ``` Note 7.4 GB of data in class 00, total size 9.2 GB. After running the migration we get this instead: ``` 0x00: 9138161 items, 870876 KB keys + 2611392 KB data, 95 B + 285 B avg, 4788 B max 0x01: 185656 items, 10388 KB keys + 1790909 KB data, 55 B + 9646 B avg, 924525 B max 0x02: 916890 items, 84795 KB keys + 3667 KB data, 92 B + 4 B avg, 192 B max 0x03: 384 items, 27 KB keys + 5 KB data, 72 B + 15 B avg, 87 B max 0x04: 1109 items, 17 KB keys + 17 KB data, 15 B + 15 B avg, 69 B max 0x06: 383 items, 3 KB keys + 0 KB data, 9 B + 2 B avg, 18 B max 0x07: 510 items, 4 KB keys + 12 KB data, 9 B + 24 B avg, 41 B max 0x09: 194 items, 0 KB keys + 123 KB data, 5 B + 634 B avg, 11484 B max 0x0a: 3 items, 0 KB keys + 0 KB data, 14 B + 17 B avg, 51 B max 0x0b: 181836 items, 2363 KB keys + 10694 KB data, 13 B + 58 B avg, 173 B max 0x0d: 44282 items, 1461 KB keys + 61081 KB data, 33 B + 1379 B avg, 1637399 B max Total 10469408 items, 969939 KB keys + 4477905 KB data. ``` Class 00 is now down to 2.6 GB, with just 61 MB added in class 0d. There will be some additional reads in some cases which theoretically hurts performance, but this will be more than compensated for by smaller writes and better compaction. On my own home setup which just has three devices and a handful of folders the difference is smaller in absolute numbers of course, but still less than half the old size: ``` 0x00: 297122 items, 20894 KB keys + 306860 KB data, 70 B + 1032 B avg, 103237 B max 0x01: 115299 items, 7738 KB keys + 17542 KB data, 67 B + 152 B avg, 419 B max 0x02: 1430537 items, 121223 KB keys + 5722 KB data, 84 B + 4 B avg, 253 B max ... Total 1947412 items, 151268 KB keys + 337485 KB data. ``` to: ``` 0x00: 297122 items, 20894 KB keys + 37038 KB data, 70 B + 124 B avg, 520 B max 0x01: 115299 items, 7738 KB keys + 17542 KB data, 67 B + 152 B avg, 419 B max 0x02: 1430537 items, 121223 KB keys + 5722 KB data, 84 B + 4 B avg, 253 B max ... 0x0d: 18041 items, 595 KB keys + 71964 KB data, 33 B + 3988 B avg, 101109 B max Total 1965447 items, 151863 KB keys + 139628 KB data. ``` * wip * wip * wip * wip
2020-01-24 07:35:44 +00:00
case 18:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BlocksHash", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.BlocksHash = append(m.BlocksHash[:0], dAtA[iNdEx:postIndex]...)
if m.BlocksHash == nil {
m.BlocksHash = []byte{}
}
iNdEx = postIndex
case 19:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Encrypted", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Encrypted = append(m.Encrypted[:0], dAtA[iNdEx:postIndex]...)
if m.Encrypted == nil {
m.Encrypted = []byte{}
}
iNdEx = postIndex
case 1000:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field LocalFlags", wireType)
}
m.LocalFlags = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.LocalFlags |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 1001:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field VersionHash", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.VersionHash = append(m.VersionHash[:0], dAtA[iNdEx:postIndex]...)
if m.VersionHash == nil {
m.VersionHash = []byte{}
}
iNdEx = postIndex
case 1002:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field InodeChangeNs", wireType)
}
m.InodeChangeNs = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.InodeChangeNs |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 1003:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field EncryptionTrailerSize", wireType)
}
m.EncryptionTrailerSize = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.EncryptionTrailerSize |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *BlockInfo) 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 ErrIntOverflowBep
}
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: BlockInfo: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: BlockInfo: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
}
m.Offset = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Offset |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Size", wireType)
}
m.Size = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Size |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
if m.Hash == nil {
m.Hash = []byte{}
}
iNdEx = postIndex
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field WeakHash", wireType)
}
m.WeakHash = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.WeakHash |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Vector) 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 ErrIntOverflowBep
}
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: Vector: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Vector: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Counters", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Counters = append(m.Counters, Counter{})
if err := m.Counters[len(m.Counters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Counter) 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 ErrIntOverflowBep
}
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: Counter: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Counter: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
}
m.ID = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ID |= ShortID(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 ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Value |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *PlatformData) 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 ErrIntOverflowBep
}
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: PlatformData: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: PlatformData: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Unix", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Unix == nil {
m.Unix = &UnixData{}
}
if err := m.Unix.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Windows", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Windows == nil {
m.Windows = &WindowsData{}
}
if err := m.Windows.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Linux", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Linux == nil {
m.Linux = &XattrData{}
}
if err := m.Linux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Darwin", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Darwin == nil {
m.Darwin = &XattrData{}
}
if err := m.Darwin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field FreeBSD", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.FreeBSD == nil {
m.FreeBSD = &XattrData{}
}
if err := m.FreeBSD.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field NetBSD", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.NetBSD == nil {
m.NetBSD = &XattrData{}
}
if err := m.NetBSD.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *UnixData) 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 ErrIntOverflowBep
}
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: UnixData: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: UnixData: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field OwnerName", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.OwnerName = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field GroupName", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.GroupName = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field UID", wireType)
}
m.UID = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.UID |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field GID", wireType)
}
m.GID = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.GID |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *WindowsData) 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 ErrIntOverflowBep
}
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: WindowsData: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: WindowsData: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field OwnerName", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.OwnerName = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field OwnerIsGroup", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.OwnerIsGroup = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *XattrData) 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 ErrIntOverflowBep
}
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: XattrData: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: XattrData: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Xattrs", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Xattrs = append(m.Xattrs, Xattr{})
if err := m.Xattrs[len(m.Xattrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Xattr) 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 ErrIntOverflowBep
}
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: Xattr: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Xattr: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
if m.Value == nil {
m.Value = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Request) 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 ErrIntOverflowBep
}
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: Request: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
}
m.ID = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ID |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Folder", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Folder = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
}
m.Offset = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Offset |= int64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Size", wireType)
}
m.Size = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Size |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
if m.Hash == nil {
m.Hash = []byte{}
}
iNdEx = postIndex
case 7:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field FromTemporary", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.FromTemporary = bool(v != 0)
case 8:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field WeakHash", wireType)
}
m.WeakHash = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.WeakHash |= uint32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 9:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field BlockNo", wireType)
}
m.BlockNo = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.BlockNo |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Response) 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 ErrIntOverflowBep
}
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: Response: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
}
m.ID = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.ID |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
if m.Data == nil {
m.Data = []byte{}
}
iNdEx = postIndex
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
}
m.Code = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Code |= ErrorCode(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *DownloadProgress) 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 ErrIntOverflowBep
}
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: DownloadProgress: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: DownloadProgress: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Folder", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Folder = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Updates", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Updates = append(m.Updates, FileDownloadProgressUpdate{})
if err := m.Updates[len(m.Updates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *FileDownloadProgressUpdate) 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 ErrIntOverflowBep
}
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: FileDownloadProgressUpdate: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: FileDownloadProgressUpdate: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field UpdateType", wireType)
}
m.UpdateType = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.UpdateType |= FileDownloadProgressUpdateType(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Name = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType == 0 {
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.BlockIndexes = append(m.BlockIndexes, v)
} else if wireType == 2 {
var packedLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
packedLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if packedLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + packedLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
var elementCount int
var count int
for _, integer := range dAtA[iNdEx:postIndex] {
if integer < 128 {
count++
}
}
elementCount = count
if elementCount != 0 && len(m.BlockIndexes) == 0 {
m.BlockIndexes = make([]int, 0, elementCount)
}
for iNdEx < postIndex {
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.BlockIndexes = append(m.BlockIndexes, v)
}
} else {
return fmt.Errorf("proto: wrong wireType = %d for field BlockIndexes", wireType)
}
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field BlockSize", wireType)
}
m.BlockSize = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.BlockSize |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Ping) 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 ErrIntOverflowBep
}
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: Ping: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Ping: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Close) 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 ErrIntOverflowBep
}
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: Close: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Close: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowBep
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthBep
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthBep
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Reason = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipBep(dAtA[iNdEx:])
if err != nil {
return err
}
2021-05-19 11:30:20 +00:00
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthBep
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipBep(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, ErrIntOverflowBep
}
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, ErrIntOverflowBep
}
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, ErrIntOverflowBep
}
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, ErrInvalidLengthBep
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupBep
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthBep
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthBep = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowBep = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupBep = fmt.Errorf("proto: unexpected end of group")
)