benjamyn/any-sync
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rework threadbuilder for new change format

Browse Source
This commit is contained in:
mcrakhman 2022-06-30 18:52:20 +02:00 committed by Mikhail Iudin
parent 53a9bb5fc5
commit 4ac1f633d4
No known key found for this signature in database
GPG Key ID: FAAAA8BAABDFF1C0
19 changed files with 1407 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Makefile
View File

@ -16,7 +16,8 @@ protos-go:
@echo 'Generating protobuf packages (Go)...' @echo 'Generating protobuf packages (Go)...'
$(eval P_TIMESTAMP := Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types) $(eval P_TIMESTAMP := Mgoogle/protobuf/timestamp.proto=github.com/gogo/protobuf/types)
$(eval P_STRUCT := Mgoogle/protobuf/struct.proto=github.com/gogo/protobuf/types) $(eval P_STRUCT := Mgoogle/protobuf/struct.proto=github.com/gogo/protobuf/types)
@$(eval P_PROTOS := Mdata/pb/protos/aclchanges.proto=github.com/anytypeio/go-anytype-infrastructure-experiments/data/pb) @$(eval P_ACL_CHANGES := Mdata/pb/protos/aclchanges.proto=github.com/anytypeio/go-anytype-infrastructure-experiments/data/pb)
@$(eval P_PLAINTEXT_CHANGES := Mdata/pb/protos/plaintextchanges.proto=github.com/anytypeio/go-anytype-infrastructure-experiments/data/pb)
$(eval PKGMAP := $$(P_TIMESTAMP),$$(P_STRUCT),$$(P_PROTOS)) $(eval PKGMAP := $$(P_TIMESTAMP),$$(P_STRUCT),$$(P_ACL_CHANGES),$$(P_PLAINTEXT_CHANGES))
GOGO_NO_UNDERSCORE=1 GOGO_EXPORT_ONEOF_INTERFACE=1 protoc --gogofaster_out=$(PKGMAP):./data/pb data/pb/protos/*.*; mv data/pb/data/pb/protos/*.go data/pb; rm -rf data/pb/data GOGO_NO_UNDERSCORE=1 GOGO_EXPORT_ONEOF_INTERFACE=1 protoc --gogofaster_out=$(PKGMAP):./data/pb data/pb/protos/*.*; mv data/pb/data/pb/protos/*.go data/pb; rm -rf data/pb/data

7
data/aclstate.go
View File

@ -4,10 +4,11 @@ import (
"bytes" "bytes"
"errors" "errors"
"fmt" "fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pb"
"github.com/textileio/go-threads/crypto/symmetric"
"hash/fnv" "hash/fnv"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/pb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels"
"github.com/textileio/go-threads/crypto/symmetric"
) )
var ErrNoSuchUser = errors.New("no such user") var ErrNoSuchUser = errors.New("no such user")

3
data/aclstatebuilder.go
View File

@ -2,8 +2,9 @@ package data
import ( import (
"fmt" "fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/pb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels" "github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pb"
) )
type ACLStateBuilder struct { type ACLStateBuilder struct {

2
data/aclstatebuilder_test.go
View File

@ -1,9 +1,9 @@
package data package data
import ( import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/pb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadbuilder" "github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadbuilder"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels" "github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pb"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"testing" "testing"
) )

4
data/acltreebuilder.go
View File

@ -3,8 +3,8 @@ package data
import ( import (
"context" "context"
"fmt" "fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/pb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels" "github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/slice" "github.com/anytypeio/go-anytype-infrastructure-experiments/util/slice"
"github.com/gogo/protobuf/proto" "github.com/gogo/protobuf/proto"
"github.com/textileio/go-threads/core/thread" "github.com/textileio/go-threads/core/thread"
@ -41,7 +41,7 @@ func (tb *ACLTreeBuilder) loadChange(id string) (ch *Change, err error) {
ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
defer cancel() defer cancel()
record, err := tb.thread.GetRecord(ctx, id) record, err := tb.thread.GetChange(ctx, id)
if err != nil { if err != nil {
return nil, err return nil, err
} }

2
data/change.go
View File

@ -3,7 +3,7 @@ package data
import ( import (
"fmt" "fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pb" "github.com/anytypeio/go-anytype-infrastructure-experiments/data/pb"
"github.com/gogo/protobuf/proto" "github.com/gogo/protobuf/proto"
"github.com/textileio/go-threads/crypto/symmetric" "github.com/textileio/go-threads/crypto/symmetric"
) )

305
data/pb/aclchanges.pb.go
View File

@ -64,7 +64,6 @@ type ACLChange struct {
CurrentReadKeyHash uint64 `protobuf:"varint,6,opt,name=currentReadKeyHash,proto3" json:"currentReadKeyHash,omitempty"` CurrentReadKeyHash uint64 `protobuf:"varint,6,opt,name=currentReadKeyHash,proto3" json:"currentReadKeyHash,omitempty"`
Timestamp int64 `protobuf:"varint,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"` Timestamp int64 `protobuf:"varint,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
Identity string `protobuf:"bytes,8,opt,name=identity,proto3" json:"identity,omitempty"` Identity string `protobuf:"bytes,8,opt,name=identity,proto3" json:"identity,omitempty"`
LogHeads map[string]string `protobuf:"bytes,9,rep,name=logHeads,proto3" json:"logHeads,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
} }
func (m *ACLChange) Reset() { *m = ACLChange{} } func (m *ACLChange) Reset() { *m = ACLChange{} }
@ -156,13 +155,6 @@ func (m *ACLChange) GetIdentity() string {
return "" return ""
} }
func (m *ACLChange) GetLogHeads() map[string]string {
if m != nil {
return m.LogHeads
}
return nil
}
type ACLChangeACLContentValue struct { type ACLChangeACLContentValue struct {
// Types that are valid to be assigned to Value: // Types that are valid to be assigned to Value:
// *ACLChangeACLContentValueValueOfUserAdd // *ACLChangeACLContentValueValueOfUserAdd
@ -178,7 +170,7 @@ func (m *ACLChangeACLContentValue) Reset() { *m = ACLChangeACLContentVal
func (m *ACLChangeACLContentValue) String() string { return proto.CompactTextString(m) } func (m *ACLChangeACLContentValue) String() string { return proto.CompactTextString(m) }
func (*ACLChangeACLContentValue) ProtoMessage() {} func (*ACLChangeACLContentValue) ProtoMessage() {}
func (*ACLChangeACLContentValue) Descriptor() ([]byte, []int) { func (*ACLChangeACLContentValue) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 1} return fileDescriptor_5a15109171a9dc49, []int{0, 0}
} }
func (m *ACLChangeACLContentValue) XXX_Unmarshal(b []byte) error { func (m *ACLChangeACLContentValue) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -309,7 +301,7 @@ func (m *ACLChangeACLData) Reset() { *m = ACLChangeACLData{} }
func (m *ACLChangeACLData) String() string { return proto.CompactTextString(m) } func (m *ACLChangeACLData) String() string { return proto.CompactTextString(m) }
func (*ACLChangeACLData) ProtoMessage() {} func (*ACLChangeACLData) ProtoMessage() {}
func (*ACLChangeACLData) Descriptor() ([]byte, []int) { func (*ACLChangeACLData) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 2} return fileDescriptor_5a15109171a9dc49, []int{0, 1}
} }
func (m *ACLChangeACLData) XXX_Unmarshal(b []byte) error { func (m *ACLChangeACLData) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -361,7 +353,7 @@ func (m *ACLChangeACLSnapshot) Reset() { *m = ACLChangeACLSnapshot{} }
func (m *ACLChangeACLSnapshot) String() string { return proto.CompactTextString(m) } func (m *ACLChangeACLSnapshot) String() string { return proto.CompactTextString(m) }
func (*ACLChangeACLSnapshot) ProtoMessage() {} func (*ACLChangeACLSnapshot) ProtoMessage() {}
func (*ACLChangeACLSnapshot) Descriptor() ([]byte, []int) { func (*ACLChangeACLSnapshot) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 3} return fileDescriptor_5a15109171a9dc49, []int{0, 2}
} }
func (m *ACLChangeACLSnapshot) XXX_Unmarshal(b []byte) error { func (m *ACLChangeACLSnapshot) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -407,7 +399,7 @@ func (m *ACLChangeACLState) Reset() { *m = ACLChangeACLState{} }
func (m *ACLChangeACLState) String() string { return proto.CompactTextString(m) } func (m *ACLChangeACLState) String() string { return proto.CompactTextString(m) }
func (*ACLChangeACLState) ProtoMessage() {} func (*ACLChangeACLState) ProtoMessage() {}
func (*ACLChangeACLState) Descriptor() ([]byte, []int) { func (*ACLChangeACLState) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 4} return fileDescriptor_5a15109171a9dc49, []int{0, 3}
} }
func (m *ACLChangeACLState) XXX_Unmarshal(b []byte) error { func (m *ACLChangeACLState) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -469,7 +461,7 @@ func (m *ACLChangeUserState) Reset() { *m = ACLChangeUserState{} }
func (m *ACLChangeUserState) String() string { return proto.CompactTextString(m) } func (m *ACLChangeUserState) String() string { return proto.CompactTextString(m) }
func (*ACLChangeUserState) ProtoMessage() {} func (*ACLChangeUserState) ProtoMessage() {}
func (*ACLChangeUserState) Descriptor() ([]byte, []int) { func (*ACLChangeUserState) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 5} return fileDescriptor_5a15109171a9dc49, []int{0, 4}
} }
func (m *ACLChangeUserState) XXX_Unmarshal(b []byte) error { func (m *ACLChangeUserState) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -545,7 +537,7 @@ func (m *ACLChangeUserAdd) Reset() { *m = ACLChangeUserAdd{} }
func (m *ACLChangeUserAdd) String() string { return proto.CompactTextString(m) } func (m *ACLChangeUserAdd) String() string { return proto.CompactTextString(m) }
func (*ACLChangeUserAdd) ProtoMessage() {} func (*ACLChangeUserAdd) ProtoMessage() {}
func (*ACLChangeUserAdd) Descriptor() ([]byte, []int) { func (*ACLChangeUserAdd) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 6} return fileDescriptor_5a15109171a9dc49, []int{0, 5}
} }
func (m *ACLChangeUserAdd) XXX_Unmarshal(b []byte) error { func (m *ACLChangeUserAdd) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -612,7 +604,7 @@ func (m *ACLChangeUserConfirm) Reset() { *m = ACLChangeUserConfirm{} }
func (m *ACLChangeUserConfirm) String() string { return proto.CompactTextString(m) } func (m *ACLChangeUserConfirm) String() string { return proto.CompactTextString(m) }
func (*ACLChangeUserConfirm) ProtoMessage() {} func (*ACLChangeUserConfirm) ProtoMessage() {}
func (*ACLChangeUserConfirm) Descriptor() ([]byte, []int) { func (*ACLChangeUserConfirm) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 7} return fileDescriptor_5a15109171a9dc49, []int{0, 6}
} }
func (m *ACLChangeUserConfirm) XXX_Unmarshal(b []byte) error { func (m *ACLChangeUserConfirm) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -666,7 +658,7 @@ func (m *ACLChangeUserInvite) Reset() { *m = ACLChangeUserInvite{} }
func (m *ACLChangeUserInvite) String() string { return proto.CompactTextString(m) } func (m *ACLChangeUserInvite) String() string { return proto.CompactTextString(m) }
func (*ACLChangeUserInvite) ProtoMessage() {} func (*ACLChangeUserInvite) ProtoMessage() {}
func (*ACLChangeUserInvite) Descriptor() ([]byte, []int) { func (*ACLChangeUserInvite) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 8} return fileDescriptor_5a15109171a9dc49, []int{0, 7}
} }
func (m *ACLChangeUserInvite) XXX_Unmarshal(b []byte) error { func (m *ACLChangeUserInvite) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -735,7 +727,7 @@ func (m *ACLChangeUserJoin) Reset() { *m = ACLChangeUserJoin{} }
func (m *ACLChangeUserJoin) String() string { return proto.CompactTextString(m) } func (m *ACLChangeUserJoin) String() string { return proto.CompactTextString(m) }
func (*ACLChangeUserJoin) ProtoMessage() {} func (*ACLChangeUserJoin) ProtoMessage() {}
func (*ACLChangeUserJoin) Descriptor() ([]byte, []int) { func (*ACLChangeUserJoin) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 9} return fileDescriptor_5a15109171a9dc49, []int{0, 8}
} }
func (m *ACLChangeUserJoin) XXX_Unmarshal(b []byte) error { func (m *ACLChangeUserJoin) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -808,7 +800,7 @@ func (m *ACLChangeUserRemove) Reset() { *m = ACLChangeUserRemove{} }
func (m *ACLChangeUserRemove) String() string { return proto.CompactTextString(m) } func (m *ACLChangeUserRemove) String() string { return proto.CompactTextString(m) }
func (*ACLChangeUserRemove) ProtoMessage() {} func (*ACLChangeUserRemove) ProtoMessage() {}
func (*ACLChangeUserRemove) Descriptor() ([]byte, []int) { func (*ACLChangeUserRemove) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 10} return fileDescriptor_5a15109171a9dc49, []int{0, 9}
} }
func (m *ACLChangeUserRemove) XXX_Unmarshal(b []byte) error { func (m *ACLChangeUserRemove) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -861,7 +853,7 @@ func (m *ACLChangeReadKeyReplace) Reset() { *m = ACLChangeReadKeyReplace
func (m *ACLChangeReadKeyReplace) String() string { return proto.CompactTextString(m) } func (m *ACLChangeReadKeyReplace) String() string { return proto.CompactTextString(m) }
func (*ACLChangeReadKeyReplace) ProtoMessage() {} func (*ACLChangeReadKeyReplace) ProtoMessage() {}
func (*ACLChangeReadKeyReplace) Descriptor() ([]byte, []int) { func (*ACLChangeReadKeyReplace) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 11} return fileDescriptor_5a15109171a9dc49, []int{0, 10}
} }
func (m *ACLChangeReadKeyReplace) XXX_Unmarshal(b []byte) error { func (m *ACLChangeReadKeyReplace) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -920,7 +912,7 @@ func (m *ACLChangeUserPermissionChange) Reset() { *m = ACLChangeUserPerm
func (m *ACLChangeUserPermissionChange) String() string { return proto.CompactTextString(m) } func (m *ACLChangeUserPermissionChange) String() string { return proto.CompactTextString(m) }
func (*ACLChangeUserPermissionChange) ProtoMessage() {} func (*ACLChangeUserPermissionChange) ProtoMessage() {}
func (*ACLChangeUserPermissionChange) Descriptor() ([]byte, []int) { func (*ACLChangeUserPermissionChange) Descriptor() ([]byte, []int) {
return fileDescriptor_5a15109171a9dc49, []int{0, 12} return fileDescriptor_5a15109171a9dc49, []int{0, 11}
} }
func (m *ACLChangeUserPermissionChange) XXX_Unmarshal(b []byte) error { func (m *ACLChangeUserPermissionChange) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -966,7 +958,6 @@ func (m *ACLChangeUserPermissionChange) GetPermissions() ACLChangeUserPermission
func init() { func init() {
proto.RegisterEnum("anytype.ACLChangeUserPermissions", ACLChangeUserPermissions_name, ACLChangeUserPermissions_value) proto.RegisterEnum("anytype.ACLChangeUserPermissions", ACLChangeUserPermissions_name, ACLChangeUserPermissions_value)
proto.RegisterType((*ACLChange)(nil), "anytype.ACLChange") proto.RegisterType((*ACLChange)(nil), "anytype.ACLChange")
proto.RegisterMapType((map[string]string)(nil), "anytype.ACLChange.LogHeadsEntry")
proto.RegisterType((*ACLChangeACLContentValue)(nil), "anytype.ACLChange.ACLContentValue") proto.RegisterType((*ACLChangeACLContentValue)(nil), "anytype.ACLChange.ACLContentValue")
proto.RegisterType((*ACLChangeACLData)(nil), "anytype.ACLChange.ACLData") proto.RegisterType((*ACLChangeACLData)(nil), "anytype.ACLChange.ACLData")
proto.RegisterType((*ACLChangeACLSnapshot)(nil), "anytype.ACLChange.ACLSnapshot") proto.RegisterType((*ACLChangeACLSnapshot)(nil), "anytype.ACLChange.ACLSnapshot")
@ -985,66 +976,64 @@ func init() {
func init() { proto.RegisterFile("data/pb/protos/aclchanges.proto", fileDescriptor_5a15109171a9dc49) } func init() { proto.RegisterFile("data/pb/protos/aclchanges.proto", fileDescriptor_5a15109171a9dc49) }
var fileDescriptor_5a15109171a9dc49 = []byte{ var fileDescriptor_5a15109171a9dc49 = []byte{
// 938 bytes of a gzipped FileDescriptorProto // 898 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xdd, 0x6e, 0xe3, 0x44, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x4d, 0x6f, 0xe3, 0x44,
0x14, 0xce, 0x24, 0x6d, 0x1d, 0x1f, 0xa7, 0x6d, 0x18, 0x15, 0xc9, 0xf2, 0x16, 0x63, 0xaa, 0x15, 0x18, 0xf6, 0x24, 0x6d, 0x1d, 0xbf, 0x0e, 0x6d, 0x18, 0xf5, 0x60, 0x79, 0x8b, 0x09, 0x15, 0x82,
0x58, 0x08, 0xa5, 0x52, 0x16, 0xf1, 0xbb, 0x12, 0x34, 0x5d, 0x20, 0xa1, 0x7b, 0xb1, 0x9a, 0x15, 0x08, 0xa1, 0x54, 0xca, 0x22, 0xbe, 0x84, 0x04, 0x4d, 0x17, 0x48, 0x28, 0x87, 0xd5, 0xac, 0x00,
0x20, 0x90, 0xb8, 0x98, 0xda, 0x43, 0x6b, 0x91, 0xd8, 0x96, 0x67, 0x52, 0x91, 0x1b, 0xde, 0x00, 0x81, 0xc4, 0x61, 0x6a, 0x0f, 0x5b, 0x8b, 0xc4, 0xb6, 0x3c, 0x93, 0x0a, 0x5f, 0xf8, 0x07, 0x08,
0xc1, 0x53, 0xf0, 0x00, 0xbc, 0x00, 0xb7, 0x5c, 0xee, 0x05, 0x42, 0x5c, 0xa2, 0xf6, 0x45, 0xd0, 0xfe, 0x07, 0x37, 0xfe, 0x00, 0x57, 0x8e, 0x7b, 0x40, 0x88, 0x23, 0x6a, 0xff, 0x08, 0x9a, 0x0f,
0xfc, 0xd8, 0x71, 0x52, 0xa7, 0x48, 0x68, 0x25, 0xc4, 0xdd, 0xcc, 0x37, 0xdf, 0x99, 0x39, 0x3f, 0x3b, 0x4e, 0x6a, 0x17, 0x09, 0x55, 0x42, 0xdc, 0x66, 0x9e, 0x79, 0xde, 0xf1, 0xf3, 0x7e, 0x8e,
0xdf, 0x39, 0x36, 0xbc, 0x1c, 0x53, 0x41, 0x8f, 0xf3, 0xf3, 0xe3, 0xbc, 0xc8, 0x44, 0xc6, 0x8f, 0xe1, 0xc5, 0x88, 0x0a, 0x7a, 0x92, 0x5d, 0x9c, 0x64, 0x79, 0x2a, 0x52, 0x7e, 0x42, 0xc3, 0x45,
0x69, 0x34, 0x8d, 0x2e, 0x69, 0x7a, 0xc1, 0xf8, 0x40, 0x21, 0xd8, 0xa2, 0xe9, 0x42, 0x2c, 0x72, 0x78, 0x49, 0x93, 0xa7, 0x8c, 0x8f, 0x15, 0x82, 0x6d, 0x9a, 0x14, 0xa2, 0xc8, 0xd8, 0xf1, 0xcf,
0x76, 0xf4, 0xf3, 0x8b, 0x60, 0x9f, 0x9c, 0x3e, 0x3e, 0x55, 0xa7, 0x38, 0x00, 0x47, 0x14, 0x8c, 0x87, 0xe0, 0x9c, 0x9e, 0x7d, 0x7a, 0xa6, 0x4e, 0xf1, 0x10, 0x5c, 0x91, 0x33, 0x36, 0x63, 0x34,
0x8d, 0x19, 0x8d, 0x27, 0x31, 0x77, 0x51, 0xd0, 0x09, 0x6d, 0x52, 0x87, 0xb0, 0x0f, 0x40, 0xa3, 0x9a, 0x47, 0xdc, 0x43, 0xc3, 0xee, 0xc8, 0x21, 0x75, 0x08, 0x07, 0x00, 0x34, 0x5c, 0x94, 0x84,
0x69, 0x49, 0x68, 0x2b, 0x42, 0x0d, 0xc1, 0xaf, 0xc2, 0x1e, 0x4f, 0x69, 0xce, 0x2f, 0x33, 0x31, 0x8e, 0x22, 0xd4, 0x10, 0xfc, 0x0a, 0xec, 0xf3, 0x84, 0x66, 0xfc, 0x32, 0x15, 0x53, 0xca, 0xd9,
0xa2, 0x9c, 0x4d, 0x62, 0xb7, 0x13, 0xa0, 0xd0, 0x26, 0x6b, 0x28, 0x7e, 0x13, 0x2c, 0x1a, 0x4d, 0x3c, 0xf2, 0xba, 0x43, 0x34, 0x72, 0xc8, 0x16, 0x8a, 0xdf, 0x00, 0x9b, 0x86, 0x8b, 0x47, 0x54,
0x1f, 0x51, 0x41, 0xdd, 0xad, 0x00, 0x85, 0xce, 0xd0, 0x1b, 0x18, 0x97, 0x06, 0x95, 0x3b, 0x72, 0x50, 0x6f, 0x67, 0x88, 0x46, 0xee, 0xc4, 0x1f, 0x1b, 0x49, 0xe3, 0x4a, 0x8e, 0x5c, 0x49, 0x06,
0x25, 0x19, 0xa4, 0xa4, 0x4a, 0xff, 0x4c, 0x1c, 0xca, 0x72, 0x3b, 0x40, 0x61, 0x8f, 0xd4, 0x21, 0x29, 0xa9, 0x52, 0x9f, 0xf1, 0x43, 0x59, 0xee, 0x0e, 0xd1, 0xa8, 0x4f, 0xea, 0x10, 0x1e, 0x03,
0x3c, 0x00, 0x1c, 0xcd, 0x8b, 0x82, 0xa5, 0x82, 0x30, 0x1a, 0x9f, 0xb1, 0xc5, 0x98, 0xf2, 0x4b, 0x0e, 0x57, 0x79, 0xce, 0x12, 0x41, 0x18, 0x8d, 0xce, 0x59, 0x31, 0xa3, 0xfc, 0xd2, 0xdb, 0x1b,
0x77, 0x27, 0x40, 0xe1, 0x16, 0x69, 0x38, 0xc1, 0x87, 0x60, 0x8b, 0x64, 0xc6, 0xb8, 0xa0, 0xb3, 0xa2, 0xd1, 0x0e, 0x69, 0x38, 0xc1, 0x47, 0xe0, 0x88, 0x78, 0xc9, 0xb8, 0xa0, 0xcb, 0xcc, 0xb3,
0xdc, 0xb5, 0x02, 0x14, 0x76, 0xc8, 0x12, 0xc0, 0x1e, 0x74, 0x93, 0x98, 0xa5, 0x22, 0x11, 0x0b, 0x87, 0x68, 0xd4, 0x25, 0x6b, 0x00, 0xfb, 0xd0, 0x8b, 0x23, 0x96, 0x88, 0x58, 0x14, 0x5e, 0x4f,
0xb7, 0xab, 0xe2, 0xa8, 0xf6, 0xf8, 0x21, 0x74, 0xa7, 0xd9, 0x85, 0x8c, 0x9b, 0xbb, 0x76, 0xd0, 0xf9, 0x51, 0xed, 0xfd, 0x5f, 0xba, 0x70, 0x20, 0xa5, 0xa6, 0x89, 0x60, 0x89, 0xf8, 0x9c, 0x2e,
0x09, 0x9d, 0x61, 0xd0, 0x10, 0xc2, 0x63, 0x43, 0xf9, 0x28, 0x15, 0xc5, 0x82, 0x54, 0x16, 0xde, 0x56, 0x0c, 0xbf, 0x09, 0xf6, 0x8a, 0xb3, 0xfc, 0x34, 0x8a, 0x3c, 0xd4, 0xea, 0xd5, 0x67, 0x9a,
0xfb, 0xb0, 0xbb, 0x72, 0x84, 0xfb, 0xd0, 0xf9, 0x96, 0x2d, 0x5c, 0xa4, 0x5e, 0x91, 0x4b, 0x7c, 0x31, 0xb3, 0x48, 0x49, 0xc6, 0xef, 0x03, 0xc8, 0x25, 0x61, 0xcb, 0xf4, 0x8a, 0x79, 0x1d, 0x65,
0x00, 0xdb, 0x57, 0x74, 0x3a, 0x67, 0x6e, 0x5b, 0x61, 0x7a, 0xf3, 0x5e, 0xfb, 0x1d, 0xe4, 0xfd, 0xfa, 0x42, 0x8b, 0xa9, 0x26, 0xcd, 0x2c, 0x52, 0x33, 0xc1, 0x5f, 0xc3, 0xa1, 0xdc, 0x3d, 0x66,
0xd2, 0x81, 0x7d, 0xf9, 0x44, 0x96, 0x0a, 0x96, 0x8a, 0xcf, 0x25, 0x8e, 0xdf, 0x02, 0x6b, 0xce, 0xf9, 0x32, 0xe6, 0x3c, 0x4e, 0x13, 0x6d, 0xa0, 0x82, 0xef, 0x4e, 0x5e, 0x6d, 0xb9, 0x6a, 0x9b,
0x59, 0x71, 0x12, 0xc7, 0xea, 0x8e, 0xe6, 0x84, 0x7e, 0xa6, 0x19, 0xe3, 0x16, 0x29, 0xc9, 0xf8, 0x3e, 0xb3, 0x48, 0xe3, 0x35, 0xa5, 0xbe, 0x79, 0x72, 0x15, 0x0b, 0x66, 0x12, 0xd6, 0xa6, 0x4f,
0x03, 0x00, 0xb9, 0x24, 0x6c, 0x96, 0x5d, 0xe9, 0xa7, 0x9c, 0xe1, 0x4b, 0x1b, 0x4c, 0x35, 0x69, 0x93, 0x4a, 0x7d, 0x7a, 0x87, 0xdf, 0x81, 0x9e, 0xdc, 0x7d, 0x92, 0xc6, 0x89, 0xca, 0x9a, 0x3b,
0xdc, 0x22, 0x35, 0x13, 0xfc, 0x35, 0x1c, 0xc8, 0xdd, 0x13, 0x56, 0xcc, 0x12, 0xce, 0x93, 0x2c, 0x79, 0xd0, 0x62, 0x2e, 0x29, 0x33, 0x8b, 0x54, 0x74, 0x3c, 0x05, 0x57, 0xae, 0xcf, 0xd2, 0xe4,
0xd5, 0x06, 0xaa, 0xee, 0xce, 0xf0, 0xb5, 0x0d, 0x57, 0xad, 0xd3, 0xc7, 0x2d, 0xd2, 0x78, 0x4d, 0x9b, 0x38, 0x5f, 0xaa, 0x54, 0xba, 0x93, 0xa0, 0xc5, 0xda, 0xb0, 0x66, 0x16, 0xa9, 0x1b, 0x4d,
0xe9, 0xdf, 0x24, 0xbd, 0x4a, 0x04, 0x33, 0x5a, 0xd9, 0xe4, 0x9f, 0x26, 0x95, 0xfe, 0xe9, 0x1d, 0x6d, 0xd8, 0xbd, 0x92, 0x09, 0xf2, 0x7f, 0x44, 0x60, 0x9b, 0xaa, 0xc2, 0x1f, 0x80, 0x4b, 0xc3,
0x7e, 0x17, 0xba, 0x72, 0xf7, 0x69, 0x96, 0xa4, 0x4a, 0x30, 0xce, 0xf0, 0xde, 0x06, 0x73, 0x49, 0xc5, 0x13, 0x53, 0x97, 0x26, 0x61, 0x41, 0x73, 0x19, 0x96, 0x2c, 0x52, 0x37, 0xc1, 0x53, 0xd5,
0x19, 0xb7, 0x48, 0x45, 0xc7, 0x23, 0x70, 0xe4, 0xfa, 0x34, 0x4b, 0xbf, 0x49, 0x8a, 0x99, 0x52, 0x0c, 0xa6, 0x02, 0x54, 0x33, 0xb8, 0x93, 0xe3, 0xe6, 0x0b, 0xea, 0x65, 0x42, 0x6a, 0x56, 0xfe,
0x91, 0x33, 0xf4, 0x37, 0x58, 0x1b, 0xd6, 0xb8, 0x45, 0xea, 0x46, 0x23, 0xcb, 0x54, 0xd1, 0xfb, 0x47, 0xe0, 0xd6, 0xee, 0xc7, 0x6f, 0x41, 0x4f, 0x7e, 0x41, 0x50, 0xc1, 0x8c, 0xa2, 0x07, 0x2d,
0x11, 0x81, 0x65, 0x04, 0x8d, 0x3f, 0x04, 0x87, 0x46, 0xd3, 0xa7, 0xa6, 0x25, 0x4c, 0xc1, 0xfc, 0x8a, 0x24, 0x85, 0x54, 0x64, 0xff, 0x87, 0x0e, 0xf4, 0x4a, 0x18, 0xbf, 0x0c, 0xcf, 0xe5, 0xeb,
0xe6, 0x0e, 0x28, 0x59, 0xa4, 0x6e, 0x82, 0x47, 0xaa, 0x0f, 0x8d, 0x02, 0x54, 0x1f, 0x3a, 0xc3, 0x22, 0x67, 0xba, 0x93, 0x77, 0xc8, 0x26, 0x88, 0xdf, 0xd3, 0x59, 0x55, 0x26, 0xdc, 0xc8, 0x3f,
0xa3, 0xe6, 0x0b, 0xea, 0x32, 0x21, 0x35, 0x2b, 0xef, 0x63, 0x70, 0x6a, 0xf7, 0xe3, 0xb7, 0xa1, 0x6a, 0x09, 0xac, 0xfe, 0x5c, 0x8d, 0x8f, 0xa7, 0x60, 0xc7, 0x2a, 0xb9, 0xdc, 0xeb, 0x2a, 0xd3,
0x2b, 0x5f, 0x10, 0x54, 0x30, 0xe3, 0xd1, 0xbd, 0x0d, 0x1e, 0x49, 0x0a, 0xa9, 0xc8, 0xde, 0x0f, 0xd1, 0x1d, 0x42, 0xc7, 0xba, 0x0e, 0xf8, 0x87, 0x89, 0xc8, 0x0b, 0x52, 0x1a, 0xfa, 0x5f, 0x42,
0x6d, 0xe8, 0x96, 0x30, 0xbe, 0x0f, 0xbb, 0xc5, 0xb2, 0xbf, 0x98, 0x1e, 0x22, 0x5b, 0x64, 0x15, 0xbf, 0x7e, 0x80, 0x07, 0xd0, 0xfd, 0x96, 0x15, 0xca, 0x71, 0x87, 0xc8, 0x25, 0x7e, 0x68, 0x32,
0xc4, 0x0f, 0x75, 0x55, 0x95, 0x09, 0x37, 0xee, 0x1f, 0x6e, 0x48, 0xac, 0x7e, 0xae, 0xc6, 0xc7, 0xf7, 0x0f, 0x4d, 0xa1, 0x6f, 0x21, 0x9a, 0xfb, 0x6e, 0xe7, 0x6d, 0xe4, 0xdf, 0x20, 0x70, 0x2a,
0x23, 0xb0, 0x12, 0x55, 0x5c, 0xee, 0x76, 0x94, 0x69, 0x78, 0x87, 0xa3, 0x03, 0xad, 0x03, 0xd3, 0xe1, 0x1b, 0x8d, 0x8c, 0x36, 0x1b, 0x59, 0x06, 0x8b, 0x25, 0x61, 0x5e, 0x64, 0x22, 0x4e, 0x93,
0x81, 0xa5, 0xa1, 0xf7, 0x25, 0xf4, 0xea, 0x07, 0x0d, 0xfd, 0xf7, 0xa0, 0xde, 0x7f, 0xff, 0x24, 0x73, 0x56, 0xa8, 0x4f, 0xf5, 0xc9, 0x26, 0x88, 0x5f, 0x87, 0xe7, 0x0d, 0xc0, 0x22, 0x33, 0x40,
0xba, 0x7a, 0x7b, 0xde, 0x20, 0xb0, 0x2b, 0xc7, 0x57, 0x66, 0x08, 0x5a, 0x9b, 0x21, 0xf7, 0x61, 0xb4, 0xe3, 0x7d, 0x72, 0xfb, 0x00, 0x3f, 0x02, 0x37, 0xab, 0x9a, 0x88, 0xab, 0x8e, 0xd9, 0x6f,
0x97, 0xa5, 0x51, 0xb1, 0xc8, 0x45, 0x92, 0xa5, 0x67, 0x6c, 0xa1, 0x9e, 0xea, 0x91, 0x55, 0x10, 0x2c, 0x8d, 0xcd, 0x36, 0xe4, 0xa4, 0x6e, 0x26, 0xc7, 0xdd, 0x9c, 0x9b, 0x1a, 0x66, 0x91, 0x6a,
0xbf, 0x01, 0x2f, 0x18, 0x80, 0xc5, 0x66, 0x76, 0xe9, 0xc0, 0x7b, 0xe4, 0xf6, 0x01, 0x7e, 0x04, 0x9c, 0x1e, 0xa9, 0x43, 0xfe, 0xaf, 0x08, 0x6c, 0x33, 0x4f, 0xfe, 0x9f, 0x3e, 0xfa, 0x1f, 0x83,
0x4e, 0x5e, 0x35, 0x11, 0x57, 0x1d, 0xb3, 0xd7, 0x28, 0x8d, 0xd5, 0x36, 0xe4, 0xa4, 0x6e, 0x26, 0x5b, 0x6b, 0xdc, 0x3b, 0x9d, 0x38, 0x02, 0xc7, 0x0c, 0xcc, 0x79, 0xa4, 0x1c, 0x70, 0xc8, 0x1a,
0x27, 0xed, 0x84, 0x1b, 0x0d, 0xb3, 0x58, 0x35, 0x4e, 0x97, 0xd4, 0x21, 0xef, 0x57, 0x04, 0x96, 0xf0, 0xff, 0x40, 0x00, 0xeb, 0x52, 0xc0, 0x23, 0x38, 0xa0, 0x61, 0xc8, 0x32, 0xf1, 0x78, 0x75,
0x99, 0x27, 0xff, 0xcf, 0x18, 0xbd, 0x4f, 0xc0, 0xa9, 0x35, 0xee, 0x9d, 0x41, 0x1c, 0x82, 0x6d, 0xb1, 0x88, 0xc3, 0x73, 0x53, 0x56, 0x7d, 0xb2, 0x0d, 0xe3, 0xd7, 0x60, 0x60, 0x9c, 0x5b, 0x53,
0x06, 0xe6, 0x24, 0x36, 0xf3, 0x78, 0x09, 0x78, 0x7f, 0x20, 0x80, 0xa5, 0x14, 0x70, 0x08, 0xfb, 0x75, 0x78, 0x6e, 0xe1, 0xff, 0x49, 0x84, 0x7e, 0x47, 0xd0, 0x2b, 0x27, 0xe3, 0x3d, 0x24, 0xb9,
0x34, 0x8a, 0x58, 0x2e, 0x9e, 0xcc, 0xcf, 0xa7, 0x49, 0x74, 0x66, 0x64, 0xd5, 0x23, 0xeb, 0x30, 0x0a, 0xcc, 0x93, 0xf8, 0x69, 0x42, 0xc5, 0x2a, 0xd7, 0xaf, 0x44, 0x15, 0x98, 0x0a, 0x96, 0x6f,
0x7e, 0x1d, 0xfa, 0x26, 0xb8, 0x25, 0x55, 0xa7, 0xe7, 0x16, 0xfe, 0x9f, 0x64, 0xe8, 0x77, 0x04, 0xe9, 0x7a, 0x84, 0x6b, 0xa5, 0xf3, 0x48, 0x79, 0xe1, 0x90, 0x86, 0x93, 0xe6, 0xe0, 0xec, 0xb6,
0xdd, 0x72, 0x32, 0x3e, 0x87, 0x22, 0x57, 0x89, 0x79, 0x9a, 0x5c, 0xa4, 0x54, 0xcc, 0x0b, 0xfd, 0x04, 0xc7, 0x5f, 0xe9, 0x74, 0x99, 0x07, 0xec, 0x2e, 0xbf, 0xce, 0xe1, 0xc0, 0x0c, 0x2e, 0xc2,
0x95, 0xa8, 0x12, 0x53, 0xc1, 0xf2, 0x33, 0xbe, 0x1c, 0xe1, 0xda, 0xd3, 0x49, 0xac, 0xa2, 0xb0, 0xb2, 0x05, 0x0d, 0xab, 0x89, 0xf3, 0x52, 0x43, 0x28, 0xc9, 0x06, 0x93, 0x6c, 0x5b, 0xfa, 0xdf,
0x49, 0xc3, 0x49, 0x73, 0x72, 0xb6, 0x37, 0x24, 0xc7, 0x9b, 0xeb, 0x72, 0x99, 0x0f, 0xd8, 0x5d, 0xc3, 0xfe, 0x26, 0xe5, 0x1e, 0x42, 0xba, 0xae, 0xa0, 0xca, 0x3f, 0x13, 0xd3, 0x5b, 0xb8, 0xff,
0x71, 0x9d, 0xc1, 0xbe, 0x19, 0x5c, 0x84, 0xe5, 0x53, 0x1a, 0x55, 0x13, 0xe7, 0x95, 0x86, 0x54, 0x1d, 0x1c, 0x36, 0x3d, 0xbd, 0x77, 0xaa, 0xd8, 0xaa, 0xa3, 0xce, 0xbf, 0xaa, 0xa3, 0xe3, 0x53,
0x92, 0x15, 0x26, 0x59, 0xb7, 0xf4, 0xbe, 0x87, 0xbd, 0x55, 0xca, 0x73, 0x48, 0xe9, 0x52, 0x41, 0x38, 0xd8, 0x3a, 0xc7, 0x0e, 0xec, 0x9e, 0x46, 0xcb, 0x38, 0x19, 0x58, 0x18, 0x60, 0xef, 0x8b,
0x55, 0x7c, 0x26, 0xa7, 0xb7, 0x70, 0xef, 0x3b, 0x38, 0x68, 0xfa, 0xf4, 0xde, 0xe9, 0xc5, 0x9a, 0x3c, 0x16, 0x2c, 0x1f, 0x20, 0xb9, 0x96, 0x72, 0x59, 0x3e, 0xe8, 0x60, 0x17, 0x6c, 0x9d, 0xa2,
0x8e, 0xda, 0xff, 0x4a, 0x47, 0x47, 0x27, 0xb0, 0xbf, 0x76, 0x8e, 0x6d, 0xd8, 0x3e, 0x89, 0x67, 0x68, 0xd0, 0x9d, 0x1e, 0xfd, 0x76, 0x1d, 0xa0, 0x67, 0xd7, 0x01, 0xfa, 0xeb, 0x3a, 0x40, 0x3f,
0x49, 0xda, 0x6f, 0x61, 0x80, 0x9d, 0x2f, 0x8a, 0x44, 0xb0, 0xa2, 0x8f, 0xe4, 0x5a, 0xba, 0xcb, 0xdd, 0x04, 0xd6, 0xb3, 0x9b, 0xc0, 0xfa, 0xf3, 0x26, 0xb0, 0xbe, 0xea, 0x64, 0x17, 0x17, 0x7b,
0x8a, 0x7e, 0x1b, 0x3b, 0x60, 0xe9, 0x12, 0xc5, 0xfd, 0xce, 0xe8, 0xf0, 0xb7, 0x6b, 0x1f, 0x3d, 0xea, 0xdf, 0xf2, 0xe1, 0xdf, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x2f, 0x29, 0xef, 0x7e, 0x0a,
0xbb, 0xf6, 0xd1, 0x5f, 0xd7, 0x3e, 0xfa, 0xe9, 0xc6, 0x6f, 0x3d, 0xbb, 0xf1, 0x5b, 0x7f, 0xde, 0x00, 0x00,
0xf8, 0xad, 0xaf, 0xda, 0xf9, 0xf9, 0xf9, 0x8e, 0xfa, 0xad, 0x7d, 0xf0, 0x77, 0x00, 0x00, 0x00,
0xff, 0xff, 0x14, 0x6d, 0x36, 0xcd, 0xf9, 0x0a, 0x00, 0x00,
} }
func (m *ACLChange) Marshal() (dAtA []byte, err error) { func (m *ACLChange) Marshal() (dAtA []byte, err error) {
@ -1067,25 +1056,6 @@ func (m *ACLChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
if len(m.LogHeads) > 0 {
for k := range m.LogHeads {
v := m.LogHeads[k]
baseI := i
i -= len(v)
copy(dAtA[i:], v)
i = encodeVarintAclchanges(dAtA, i, uint64(len(v)))
i--
dAtA[i] = 0x12
i -= len(k)
copy(dAtA[i:], k)
i = encodeVarintAclchanges(dAtA, i, uint64(len(k)))
i--
dAtA[i] = 0xa
i = encodeVarintAclchanges(dAtA, i, uint64(baseI-i))
i--
dAtA[i] = 0x4a
}
}
if len(m.Identity) > 0 { if len(m.Identity) > 0 {
i -= len(m.Identity) i -= len(m.Identity)
copy(dAtA[i:], m.Identity) copy(dAtA[i:], m.Identity)
@ -1907,14 +1877,6 @@ func (m *ACLChange) Size() (n int) {
if l > 0 { if l > 0 {
n += 1 + l + sovAclchanges(uint64(l)) n += 1 + l + sovAclchanges(uint64(l))
} }
if len(m.LogHeads) > 0 {
for k, v := range m.LogHeads {
_ = k
_ = v
mapEntrySize := 1 + len(k) + sovAclchanges(uint64(len(k))) + 1 + len(v) + sovAclchanges(uint64(len(v)))
n += mapEntrySize + 1 + sovAclchanges(uint64(mapEntrySize))
}
}
return n return n
} }
@ -2525,133 +2487,6 @@ func (m *ACLChange) Unmarshal(dAtA []byte) error {
} }
m.Identity = string(dAtA[iNdEx:postIndex]) m.Identity = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex iNdEx = postIndex
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field LogHeads", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAclchanges
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthAclchanges
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthAclchanges
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.LogHeads == nil {
m.LogHeads = make(map[string]string)
}
var mapkey string
var mapvalue string
for iNdEx < postIndex {
entryPreIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAclchanges
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
if fieldNum == 1 {
var stringLenmapkey uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAclchanges
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapkey |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapkey := int(stringLenmapkey)
if intStringLenmapkey < 0 {
return ErrInvalidLengthAclchanges
}
postStringIndexmapkey := iNdEx + intStringLenmapkey
if postStringIndexmapkey < 0 {
return ErrInvalidLengthAclchanges
}
if postStringIndexmapkey > l {
return io.ErrUnexpectedEOF
}
mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
iNdEx = postStringIndexmapkey
} else if fieldNum == 2 {
var stringLenmapvalue uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowAclchanges
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLenmapvalue |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLenmapvalue := int(stringLenmapvalue)
if intStringLenmapvalue < 0 {
return ErrInvalidLengthAclchanges
}
postStringIndexmapvalue := iNdEx + intStringLenmapvalue
if postStringIndexmapvalue < 0 {
return ErrInvalidLengthAclchanges
}
if postStringIndexmapvalue > l {
return io.ErrUnexpectedEOF
}
mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
iNdEx = postStringIndexmapvalue
} else {
iNdEx = entryPreIndex
skippy, err := skipAclchanges(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthAclchanges
}
if (iNdEx + skippy) > postIndex {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
m.LogHeads[mapkey] = mapvalue
iNdEx = postIndex
default: default:
iNdEx = preIndex iNdEx = preIndex
skippy, err := skipAclchanges(dAtA[iNdEx:]) skippy, err := skipAclchanges(dAtA[iNdEx:])

1088
data/pb/plaintextchanges.pb.go Normal file
View File

File diff suppressed because it is too large Load Diff

1
data/pb/protos/aclchanges.proto
View File

@ -13,7 +13,6 @@ message ACLChange {
uint64 currentReadKeyHash = 6; uint64 currentReadKeyHash = 6;
int64 timestamp = 7; int64 timestamp = 7;
string identity = 8; string identity = 8;
map<string, string> logHeads = 9;
message ACLContentValue { message ACLContentValue {
oneof value { oneof value {

24
data/pb/protos/plaintextchanges.proto Normal file
View File

@ -0,0 +1,24 @@
syntax = "proto3";
package anytype;
option go_package = "pb";
message PlainTextChange {
message Content {
oneof value {
TextAppend textAppend = 1;
}
}
message TextAppend {
string text = 1;
}
message Snapshot {
string text = 1;
}
message Data {
repeated Content content = 1;
Snapshot snapshot = 2;
}
}

16
data/threadbuilder/invalidsnapshotexample.yml
View File

@ -1,10 +1,8 @@
thread: thread:
author: A author: A
logs: changes:
- id: A.1
identity: A
records:
- id: A.1.1 - id: A.1.1
identity: A
aclSnapshot: aclSnapshot:
userStates: userStates:
- identity: A - identity: A
@ -31,6 +29,7 @@ logs:
encryptedReadKeys: [key.Read.1] encryptedReadKeys: [key.Read.1]
readKey: key.Read.1 readKey: key.Read.1
- id: A.1.2 - id: A.1.2
identity: A
aclSnapshot: aclSnapshot:
userStates: userStates:
- identity: A - identity: A
@ -56,6 +55,7 @@ logs:
encryptedReadKeys: [key.Read.1] encryptedReadKeys: [key.Read.1]
readKey: key.Read.1 readKey: key.Read.1
- id: A.1.3 - id: A.1.3
identity: A
aclChanges: aclChanges:
- userAdd: - userAdd:
identity: E identity: E
@ -63,10 +63,8 @@ logs:
encryptionKey: key.Enc.E encryptionKey: key.Enc.E
encryptedReadKeys: [key.Read.1] encryptedReadKeys: [key.Read.1]
readKey: key.Read.1 readKey: key.Read.1
- id: B.1
identity: B
records:
- id: B.1.1 - id: B.1.1
identity: B
aclChanges: aclChanges:
- userAdd: - userAdd:
identity: C identity: C
@ -75,6 +73,7 @@ logs:
encryptedReadKeys: [ key.Read.1 ] encryptedReadKeys: [ key.Read.1 ]
readKey: key.Read.1 readKey: key.Read.1
- id: B.1.2 - id: B.1.2
identity: B
aclChanges: aclChanges:
- userAdd: - userAdd:
identity: F identity: F
@ -120,3 +119,6 @@ graph:
baseSnapshot: A.1.2 baseSnapshot: A.1.2
aclHeads: [A.1.2] aclHeads: [A.1.2]
treeHeads: [A.1.2] treeHeads: [A.1.2]
heads:
- A.1.3
- B.1.2

5
data/threadbuilder/keychain.go
View File

@ -1,10 +1,11 @@
package threadbuilder package threadbuilder
import ( import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels"
"github.com/textileio/go-threads/crypto/symmetric"
"hash/fnv" "hash/fnv"
"strings" "strings"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels"
"github.com/textileio/go-threads/crypto/symmetric"
) )
type SymKey struct { type SymKey struct {

201
data/threadbuilder/threadbuilder.go
View File

@ -3,43 +3,36 @@ package threadbuilder
import ( import (
"context" "context"
"fmt" "fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/lib/core/smartblock"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/lib/pb/model"
"github.com/gogo/protobuf/proto"
"io/ioutil" "io/ioutil"
"sort"
"github.com/gogo/protobuf/proto"
"gopkg.in/yaml.v3"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/pb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels"
) )
type threadRecord struct { const plainTextDocType uint16 = 1
type threadChange struct {
*pb.ACLChange *pb.ACLChange
id string id string
logId string
readKey *SymKey readKey *SymKey
signKey threadmodels.SigningPrivKey signKey threadmodels.SigningPrivKey
prevRecord *threadRecord changesData *pb.PlainTextChangeData
changesData *pb.ACLChangeChangeData
}
type threadLog struct {
id string
owner string
records []*threadRecord
} }
type ThreadBuilder struct { type ThreadBuilder struct {
threadId string threadId string
logs map[string]*threadLog allChanges map[string]*threadChange
allRecords map[string]*threadRecord heads []string
keychain *Keychain keychain *Keychain
} }
func NewThreadBuilder(keychain *Keychain) *ThreadBuilder { func NewThreadBuilder(keychain *Keychain) *ThreadBuilder {
return &ThreadBuilder{ return &ThreadBuilder{
logs: make(map[string]*threadLog), allChanges: make(map[string]*threadChange),
allRecords: make(map[string]*threadRecord),
keychain: keychain, keychain: keychain,
} }
} }
@ -70,27 +63,13 @@ func (t *ThreadBuilder) GetKeychain() *Keychain {
return t.keychain return t.keychain
} }
func (t *ThreadBuilder) GetLogs() ([]threadmodels.ThreadLog, error) { // writer can create docs -> id can create writer permissions
var logs []threadmodels.ThreadLog // by id we can check who created
for _, l := range t.logs { // at the same time this guy can add some random folks which are not in space
logs = append(logs, threadmodels.ThreadLog{ // but we should compare this against space in the future
ID: l.id,
Head: l.records[len(l.records)-1].id,
Counter: int64(len(l.records)),
})
}
sort.Slice(logs, func(i, j int) bool {
return logs[i].ID < logs[j].ID
})
return logs, nil
}
func (t *ThreadBuilder) GetRecord(ctx context.Context, recordID string) (*threadmodels.ThreadRecord, error) { func (t *ThreadBuilder) GetChange(ctx context.Context, recordID string) (*threadmodels.RawChange, error) {
rec := t.allRecords[recordID] rec := t.allChanges[recordID]
prevId := ""
if rec.prevRecord != nil {
prevId = rec.prevRecord.id
}
var encrypted []byte var encrypted []byte
if rec.changesData != nil { if rec.changesData != nil {
@ -117,19 +96,15 @@ func (t *ThreadBuilder) GetRecord(ctx context.Context, recordID string) (*thread
panic("should be able to sign final acl message!") panic("should be able to sign final acl message!")
} }
transformedRec := &threadmodels.ThreadRecord{ transformedRec := &threadmodels.RawChange{
PrevId: prevId,
Id: rec.id,
LogId: rec.logId,
Signed: &threadmodels.SignedPayload{
Payload: aclMarshaled, Payload: aclMarshaled,
Signature: signature, Signature: signature,
}, Id: recordID,
} }
return transformedRec, nil return transformedRec, nil
} }
func (t *ThreadBuilder) PushRecord(payload proto.Marshaler) (id string, err error) { func (t *ThreadBuilder) PushChange(payload proto.Marshaler) (id string, err error) {
panic("implement me") panic("implement me")
} }
@ -139,63 +114,49 @@ func (t *ThreadBuilder) Parse(thread *YMLThread) {
// the same thing is happening for the encryption keys // the same thing is happening for the encryption keys
t.keychain.ParseKeys(&thread.Keys) t.keychain.ParseKeys(&thread.Keys)
t.threadId = t.parseThreadId(thread.Description) t.threadId = t.parseThreadId(thread.Description)
for _, l := range thread.Logs { for _, ch := range thread.Changes {
newLog := &threadLog{ newChange := &threadChange{
id: l.Id, id: ch.Id,
owner: t.keychain.GetIdentity(l.Identity),
} }
var records []*threadRecord k := t.keychain.GetKey(ch.ReadKey).(*SymKey)
for _, r := range l.Records { newChange.readKey = k
newRecord := &threadRecord{ newChange.signKey = t.keychain.SigningKeys[ch.Identity]
id: r.Id,
logId: newLog.id,
}
if len(records) > 0 {
newRecord.prevRecord = records[len(records)-1]
}
k := t.keychain.GetKey(r.ReadKey).(*SymKey)
newRecord.readKey = k
newRecord.signKey = t.keychain.SigningKeys[l.Identity]
aclChange := &pb.ACLChange{} aclChange := &pb.ACLChange{}
aclChange.Identity = newLog.owner aclChange.Identity = newChange.Identity
if len(r.AclChanges) > 0 || r.AclSnapshot != nil { if len(ch.AclChanges) > 0 || ch.AclSnapshot != nil {
aclChange.AclData = &pb.ACLChangeACLData{} aclChange.AclData = &pb.ACLChangeACLData{}
if r.AclSnapshot != nil { if ch.AclSnapshot != nil {
aclChange.AclData.AclSnapshot = t.parseACLSnapshot(r.AclSnapshot) aclChange.AclData.AclSnapshot = t.parseACLSnapshot(ch.AclSnapshot)
} }
if r.AclChanges != nil { if ch.AclChanges != nil {
var aclChangeContents []*pb.ACLChangeACLContentValue var aclChangeContents []*pb.ACLChangeACLContentValue
for _, ch := range r.AclChanges { for _, ch := range ch.AclChanges {
aclChangeContent := t.parseACLChange(ch) aclChangeContent := t.parseACLChange(ch)
aclChangeContents = append(aclChangeContents, aclChangeContent) aclChangeContents = append(aclChangeContents, aclChangeContent)
} }
aclChange.AclData.AclContent = aclChangeContents aclChange.AclData.AclContent = aclChangeContents
} }
} }
if len(r.Changes) > 0 || r.Snapshot != nil { if len(ch.Changes) > 0 || ch.Snapshot != nil {
newRecord.changesData = &pb.ACLChangeChangeData{} newChange.changesData = &pb.PlainTextChangeData{}
if r.Snapshot != nil { if ch.Snapshot != nil {
newRecord.changesData.Snapshot = t.parseChangeSnapshot(r.Snapshot) newChange.changesData.Snapshot = t.parseChangeSnapshot(ch.Snapshot)
} }
if len(r.Changes) > 0 { if len(ch.Changes) > 0 {
var changeContents []*pb.ChangeContent var changeContents []*pb.PlainTextChangeContent
for _, ch := range r.Changes { for _, ch := range ch.Changes {
aclChangeContent := t.parseDocumentChange(ch) aclChangeContent := t.parseDocumentChange(ch)
changeContents = append(changeContents, aclChangeContent) changeContents = append(changeContents, aclChangeContent)
} }
newRecord.changesData.Content = changeContents newChange.changesData.Content = changeContents
} }
} }
aclChange.CurrentReadKeyHash = k.Hash aclChange.CurrentReadKeyHash = k.Hash
newRecord.ACLChange = aclChange newChange.ACLChange = aclChange
t.allRecords[newRecord.id] = newRecord t.allChanges[newChange.id] = newChange
records = append(records, newRecord)
}
newLog.records = records
t.logs[newLog.id] = newLog
} }
t.parseGraph(thread) t.parseGraph(thread)
t.parseHeads(thread)
} }
func (t *ThreadBuilder) parseThreadId(description *ThreadDescription) string { func (t *ThreadBuilder) parseThreadId(description *ThreadDescription) string {
@ -203,7 +164,7 @@ func (t *ThreadBuilder) parseThreadId(description *ThreadDescription) string {
panic("no author in thread") panic("no author in thread")
} }
key := t.keychain.SigningKeys[description.Author] key := t.keychain.SigningKeys[description.Author]
id, err := threadmodels.CreateACLThreadID(key.GetPublic(), smartblock.SmartBlockTypeWorkspace) id, err := threadmodels.CreateACLThreadID(key.GetPublic(), plainTextDocType)
if err != nil { if err != nil {
panic(err) panic(err)
} }
@ -211,16 +172,9 @@ func (t *ThreadBuilder) parseThreadId(description *ThreadDescription) string {
return id.String() return id.String()
} }
func (t *ThreadBuilder) parseChangeSnapshot(s *ChangeSnapshot) *pb.ChangeSnapshot { func (t *ThreadBuilder) parseChangeSnapshot(s *PlainTextSnapshot) *pb.PlainTextChangeSnapshot {
data := &model.SmartBlockSnapshotBase{} return &pb.PlainTextChangeSnapshot{
var blocks []*model.Block Text: s.Text,
for _, b := range s.Blocks {
modelBlock := &model.Block{Id: b.Id, ChildrenIds: b.ChildrenIds}
blocks = append(blocks, modelBlock)
}
data.Blocks = blocks
return &pb.ChangeSnapshot{
Data: data,
} }
} }
@ -244,18 +198,16 @@ func (t *ThreadBuilder) parseACLSnapshot(s *ACLSnapshot) *pb.ACLChangeACLSnapsho
} }
} }
func (t *ThreadBuilder) parseDocumentChange(ch *DocumentChange) (convCh *pb.ChangeContent) { func (t *ThreadBuilder) parseDocumentChange(ch *PlainTextChange) (convCh *pb.PlainTextChangeContent) {
switch { switch {
case ch.BlockAdd != nil: case ch.TextAppend != nil:
blockAdd := ch.BlockAdd convCh = &pb.PlainTextChangeContent{
Value: &pb.PlainTextChangeContentValueOfTextAppend{
convCh = &pb.ChangeContent{ TextAppend: &pb.PlainTextChangeTextAppend{
Value: &pb.ChangeContentValueOfBlockCreate{ Text: ch.TextAppend.Text,
BlockCreate: &pb.ChangeBlockCreate{ },
TargetId: blockAdd.TargetId, },
Position: model.Block_Inner, }
Blocks: []*model.Block{&model.Block{Id: blockAdd.Id}},
}}}
} }
if convCh == nil { if convCh == nil {
panic("cannot have empty document change") panic("cannot have empty document change")
@ -410,25 +362,24 @@ func (t *ThreadBuilder) convertPermission(perm string) pb.ACLChangeUserPermissio
} }
} }
func (t *ThreadBuilder) traverseFromHeads(f func(t *threadRecord) error) error { func (t *ThreadBuilder) traverseFromHeads(f func(t *threadChange) error) error {
allLogs, err := t.GetLogs() uniqMap := map[string]struct{}{}
if err != nil { stack := t.heads
for len(stack) > 0 {
id := stack[len(stack)-1]
stack = stack[:len(stack)-1]
if _, exists := uniqMap[id]; exists {
continue
}
ch := t.allChanges[id]
uniqMap[id] = struct{}{}
if err := f(ch); err != nil {
return err return err
} }
for _, log := range allLogs { for _, prev := range ch.ACLChange.TreeHeadIds {
head := t.allRecords[log.Head] stack = append(stack, prev)
err = f(head)
if err != nil {
return err
}
for head.prevRecord != nil {
head = head.prevRecord
err = f(head)
if err != nil {
return err
}
} }
} }
return nil return nil
@ -436,9 +387,13 @@ func (t *ThreadBuilder) traverseFromHeads(f func(t *threadRecord) error) error {
func (t *ThreadBuilder) parseGraph(thread *YMLThread) { func (t *ThreadBuilder) parseGraph(thread *YMLThread) {
for _, node := range thread.Graph { for _, node := range thread.Graph {
rec := t.allRecords[node.Id] rec := t.allChanges[node.Id]
rec.AclHeadIds = node.ACLHeads rec.AclHeadIds = node.ACLHeads
rec.TreeHeadIds = node.TreeHeads rec.TreeHeadIds = node.TreeHeads
rec.SnapshotBaseId = node.BaseSnapshot rec.SnapshotBaseId = node.BaseSnapshot
} }
} }
func (t *ThreadBuilder) parseHeads(thread *YMLThread) {
t.heads = thread.Heads
}

4
data/threadbuilder/threadbuildergraph_nix.go
View File

@ -30,7 +30,7 @@ func (t *ThreadBuilder) Graph() (string, error) {
graph.SetDir(true) graph.SetDir(true)
var nodes = make(map[string]struct{}) var nodes = make(map[string]struct{})
var addNodes = func(r *threadRecord) error { var addNodes = func(r *threadChange) error {
// TODO: revisit function after checking // TODO: revisit function after checking
style := "solid" style := "solid"
@ -105,7 +105,7 @@ func (t *ThreadBuilder) Graph() (string, error) {
return nil return nil
} }
var addLinks = func(t *threadRecord) error { var addLinks = func(t *threadChange) error {
for _, prevId := range t.AclHeadIds { for _, prevId := range t.AclHeadIds {
err := createEdge(t.id, prevId, EdgeParameters{ err := createEdge(t.id, prevId, EdgeParameters{
style: "dashed", style: "dashed",

27
data/threadbuilder/ymlentities.go
View File

@ -20,11 +20,8 @@ type ACLSnapshot struct {
} `yaml:"userStates"` } `yaml:"userStates"`
} }
type ChangeSnapshot struct { type PlainTextSnapshot struct {
Blocks []struct { Text string `yaml:"text"`
Id string `yaml:"id"`
ChildrenIds []string `yaml:"childrenIds"`
} `yaml:"blocks"`
} }
type ACLChange struct { type ACLChange struct {
@ -67,29 +64,25 @@ type ACLChange struct {
} }
} }
type DocumentChange struct { type PlainTextChange struct {
BlockAdd *struct { TextAppend *struct {
Id string `yaml:"id"` Text string `yaml:"text"`
TargetId string `yaml:"targetId"`
} `yaml:"blockAdd"` } `yaml:"blockAdd"`
} }
type YMLThread struct { type YMLThread struct {
Description *ThreadDescription `yaml:"thread"` Description *ThreadDescription `yaml:"thread"`
Logs []struct { Changes []struct {
Id string `yaml:"id"` Id string `yaml:"id"`
Identity string `yaml:"identity"` Identity string `yaml:"identity"`
Records []struct {
Id string `yaml:"id"`
AclSnapshot *ACLSnapshot `yaml:"aclSnapshot"` AclSnapshot *ACLSnapshot `yaml:"aclSnapshot"`
Snapshot *ChangeSnapshot `yaml:"snapshot"` Snapshot *PlainTextSnapshot `yaml:"snapshot"`
AclChanges []*ACLChange `yaml:"aclChanges"` AclChanges []*ACLChange `yaml:"aclChanges"`
Changes []*DocumentChange `yaml:"changes"` Changes []*PlainTextChange `yaml:"changes"`
ReadKey string `yaml:"readKey"` ReadKey string `yaml:"readKey"`
} `yaml:"records"` } `yaml:"changes"`
} `yaml:"logs"`
Keys Keys `yaml:"keys"` Keys Keys `yaml:"keys"`
@ -100,4 +93,6 @@ type YMLThread struct {
ACLHeads []string `yaml:"aclHeads"` ACLHeads []string `yaml:"aclHeads"`
TreeHeads []string `yaml:"treeHeads"` TreeHeads []string `yaml:"treeHeads"`
} `yaml:"graph"` } `yaml:"graph"`
Heads []string `yaml:"heads"`
} }

22
data/threadmodels/models.go
View File

@ -2,33 +2,17 @@ package threadmodels
import ( import (
"context" "context"
"github.com/gogo/protobuf/proto" "github.com/gogo/protobuf/proto"
) )
type Thread interface { type Thread interface {
ID() string ID() string
GetLogs() ([]ThreadLog, error) GetChange(ctx context.Context, recordID string) (*RawChange, error)
GetRecord(ctx context.Context, recordID string) (*ThreadRecord, error) PushChange(payload proto.Marshaler) (id string, err error)
PushRecord(payload proto.Marshaler) (id string, err error)
// SubscribeForRecords()
} }
type SignedPayload struct { type RawChange struct {
Payload []byte Payload []byte
Signature []byte Signature []byte
}
type ThreadRecord struct {
PrevId string
Id string Id string
LogId string
Signed *SignedPayload
}
type ThreadLog struct {
ID string
Head string
Counter int64
} }

12
data/threadmodels/threadid.go
View File

@ -4,12 +4,12 @@ import (
"crypto/rand" "crypto/rand"
"encoding/binary" "encoding/binary"
"fmt" "fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/lib/core/smartblock"
"github.com/textileio/go-threads/core/thread"
"hash/fnv" "hash/fnv"
"github.com/textileio/go-threads/core/thread"
) )
func CreateACLThreadID(k SigningPubKey, blockType smartblock.SmartBlockType) (thread.ID, error) { func CreateACLThreadID(k SigningPubKey, docType uint16) (thread.ID, error) {
rndlen := 32 rndlen := 32
buf := make([]byte, 8+rndlen) buf := make([]byte, 8+rndlen)
@ -31,7 +31,7 @@ func CreateACLThreadID(k SigningPubKey, blockType smartblock.SmartBlockType) (th
// putting hash of the pubkey in the beginning // putting hash of the pubkey in the beginning
binary.LittleEndian.PutUint64(buf[:8], res) binary.LittleEndian.PutUint64(buf[:8], res)
return threadIDFromBytes(blockType, buf) return threadIDFromBytes(docType, buf)
} }
func VerifyACLThreadID(k SigningPubKey, threadId thread.ID) (bool, error) { func VerifyACLThreadID(k SigningPubKey, threadId thread.ID) (bool, error) {
@ -52,7 +52,7 @@ func VerifyACLThreadID(k SigningPubKey, threadId thread.ID) (bool, error) {
} }
func threadIDFromBytes( func threadIDFromBytes(
blockType smartblock.SmartBlockType, docType uint16,
b []byte) (thread.ID, error) { b []byte) (thread.ID, error) {
blen := len(b) blen := len(b)
@ -60,7 +60,7 @@ func threadIDFromBytes(
buf := make([]byte, 2*binary.MaxVarintLen64+blen) buf := make([]byte, 2*binary.MaxVarintLen64+blen)
n := binary.PutUvarint(buf, thread.V1) n := binary.PutUvarint(buf, thread.V1)
n += binary.PutUvarint(buf[n:], uint64(thread.AccessControlled)) n += binary.PutUvarint(buf[n:], uint64(thread.AccessControlled))
n += binary.PutUvarint(buf[n:], uint64(blockType)) n += binary.PutUvarint(buf[n:], uint64(docType))
cn := copy(buf[n:], b) cn := copy(buf[n:], b)
if cn != blen { if cn != blen {

4
data/treebuilder.go
View File

@ -4,8 +4,8 @@ import (
"context" "context"
"errors" "errors"
"fmt" "fmt"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/pb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels" "github.com/anytypeio/go-anytype-infrastructure-experiments/data/threadmodels"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pb"
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/lib/logging" "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/lib/logging"
"github.com/anytypeio/go-anytype-infrastructure-experiments/util/slice" "github.com/anytypeio/go-anytype-infrastructure-experiments/util/slice"
"github.com/gogo/protobuf/proto" "github.com/gogo/protobuf/proto"
@ -48,7 +48,7 @@ func (tb *TreeBuilder) loadChange(id string) (ch *Change, err error) {
ctx, cancel := context.WithTimeout(context.Background(), time.Second*30) ctx, cancel := context.WithTimeout(context.Background(), time.Second*30)
defer cancel() defer cancel()
record, err := tb.thread.GetRecord(ctx, id) record, err := tb.thread.GetChange(ctx, id)
if err != nil { if err != nil {
return nil, err return nil, err
} }

2
go.mod
View File

@ -4,6 +4,8 @@ go 1.18
require ( require (
github.com/textileio/go-threads v1.0.2-0.20210304072541-d0f91da84404 github.com/textileio/go-threads v1.0.2-0.20210304072541-d0f91da84404
gopkg.in/yaml.v2 v2.4.0 // indirect
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c
) )
replace github.com/textileio/go-threads => github.com/anytypeio/go-threads v1.1.0-rc1.0.20220223104843-a67245cee80e replace github.com/textileio/go-threads => github.com/anytypeio/go-threads v1.1.0-rc1.0.20220223104843-a67245cee80e