diff --git a/Makefile b/Makefile index aad9273a..8d0d2cb3 100644 --- a/Makefile +++ b/Makefile @@ -18,19 +18,23 @@ protos-go: # Uncomment if needed @$(eval ROOT_PKG := pkg) @$(eval GOGO_START := GOGO_NO_UNDERSCORE=1 GOGO_EXPORT_ONEOF_INTERFACE=1) + @$(eval P_TREE_STORAGE_PATH_PB := $(ROOT_PKG)/acl/treestorage/treepb) @$(eval P_ACL_CHANGES_PATH_PB := $(ROOT_PKG)/acl/aclchanges/aclpb) + @$(eval P_PLAINTEXT_CHANGES_PATH_PB := $(ROOT_PKG)/acl/testutils/testchanges/testchangepb) @$(eval P_SYNC_CHANGES_PATH_PB := syncproto) - @$(eval P_TEST_CHANGES_PATH_PB := $(ROOT_PKG)/acl/testutils/testchanges) @$(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_ACL_CHANGES := M$(P_ACL_CHANGES_PATH_PB)/protos/aclchanges.proto=github.com/anytypeio/go-anytype-infrastructure-experiments/$(P_ACL_CHANGES_PATH_PB)) + @$(eval P_TREE_CHANGES := M$(P_TREE_STORAGE_PATH_PB)/protos/tree.proto=github.com/anytypeio/go-anytype-infrastructure-experiments/$(P_TREE_STORAGE_PATH_PB)) # use if needed $(eval PKGMAP := $$(P_TIMESTAMP),$$(P_STRUCT)) $(GOGO_START) protoc --gogofaster_out=:. $(P_ACL_CHANGES_PATH_PB)/protos/*.proto; mv $(P_ACL_CHANGES_PATH_PB)/protos/*.go $(P_ACL_CHANGES_PATH_PB) - $(GOGO_START) protoc --gogofaster_out=:. $(P_TEST_CHANGES_PATH_PB)/proto/*.proto - $(eval PKGMAP := $$(P_ACL_CHANGES)) - $(GOGO_START) protoc --gogofaster_out=$(PKGMAP),plugins=grpc:. $(P_SYNC_CHANGES_PATH_PB)/proto/*.proto + $(GOGO_START) protoc --gogofaster_out=:. $(P_TREE_STORAGE_PATH_PB)/protos/*.proto; mv $(P_TREE_STORAGE_PATH_PB)/protos/*.go $(P_TREE_STORAGE_PATH_PB) + $(GOGO_START) protoc --gogofaster_out=:. $(P_PLAINTEXT_CHANGES_PATH_PB)/protos/*.proto; mv $(P_PLAINTEXT_CHANGES_PATH_PB)/protos/*.go $(P_PLAINTEXT_CHANGES_PATH_PB) + $(eval PKGMAP := $$(P_ACL_CHANGES),$$(P_TREE_CHANGES)) + $(GOGO_START) protoc --gogofaster_out=$(PKGMAP):. $(P_SYNC_CHANGES_PATH_PB)/proto/*.proto + $(GOGO_START) protoc --gogofaster_out=$(PKGMAP):. --go-drpc_out=protolib=github.com/gogo/protobuf:. service/space/spacesync/protos/*.proto build: @$(eval FLAGS := $$(shell govvv -flags -pkg github.com/anytypeio/go-anytype-infrastructure-experiments/app)) - go build -o bin/anytype-node -ldflags "$(FLAGS)" cmd/node/node.go \ No newline at end of file + go build -v -o bin/anytype-node -ldflags "$(FLAGS)" cmd/node/node.go \ No newline at end of file diff --git a/cmd/node/node.go b/cmd/node/node.go index e4f39327..d6ded226 100644 --- a/cmd/node/node.go +++ b/cmd/node/node.go @@ -9,13 +9,13 @@ import ( "github.com/anytypeio/go-anytype-infrastructure-experiments/config" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/account" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/api" - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/document" + "github.com/anytypeio/go-anytype-infrastructure-experiments/service/configuration" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/dialer" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/pool" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/rpc/server" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/secure" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/node" - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/storage" + "github.com/anytypeio/go-anytype-infrastructure-experiments/service/sync/document" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/sync/message" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/sync/requesthandler" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/treecache" @@ -97,9 +97,8 @@ func Bootstrap(a *app.App) { Register(secure.New()). Register(server.New()). Register(dialer.New()). - Register(pool.NewPool()). - Register(storage.New()). - //Register(&example.Example{}) + Register(pool.New()). + Register(configuration.New()). Register(document.New()). Register(message.New()). Register(requesthandler.New()). diff --git a/go.mod b/go.mod index e27f9d45..47537c53 100644 --- a/go.mod +++ b/go.mod @@ -47,7 +47,7 @@ require ( github.com/pmezard/go-difflib v1.0.0 // indirect github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 // indirect github.com/spaolacci/murmur3 v1.1.0 // indirect - github.com/zeebo/errs v1.2.2 // indirect + github.com/zeebo/errs v1.3.0 // indirect go.uber.org/atomic v1.9.0 // indirect go.uber.org/multierr v1.8.0 // indirect golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4 // indirect diff --git a/go.sum b/go.sum index 84667305..ba61ef8a 100644 --- a/go.sum +++ b/go.sum @@ -119,6 +119,8 @@ github.com/zeebo/blake3 v0.2.3 h1:TFoLXsjeXqRNFxSbk35Dk4YtszE/MQQGK10BH4ptoTg= github.com/zeebo/blake3 v0.2.3/go.mod h1:mjJjZpnsyIVtVgTOSpJ9vmRE4wgDeyt2HU3qXvvKCaQ= github.com/zeebo/errs v1.2.2 h1:5NFypMTuSdoySVTqlNs1dEoU21QVamMQJxW/Fii5O7g= github.com/zeebo/errs v1.2.2/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4= +github.com/zeebo/errs v1.3.0 h1:hmiaKqgYZzcVgRL1Vkc1Mn2914BbzB0IBxs+ebeutGs= +github.com/zeebo/errs v1.3.0/go.mod h1:sgbWHsvVuTPHcqJJGQ1WhI5KbWlHYz+2+2C/LSEtCw4= github.com/zeebo/pcg v1.0.1 h1:lyqfGeWiv4ahac6ttHs+I5hwtH/+1mrhlCtVNQM2kHo= github.com/zeebo/pcg v1.0.1/go.mod h1:09F0S9iiKrwn9rlI5yjLkmrug154/YRW6KnnXVDM/l4= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= diff --git a/pkg/acl/aclchanges/aclpb/aclchanges.pb.go b/pkg/acl/aclchanges/aclpb/aclchanges.pb.go index d42f22ba..a6d2fca5 100644 --- a/pkg/acl/aclchanges/aclpb/aclchanges.pb.go +++ b/pkg/acl/aclchanges/aclpb/aclchanges.pb.go @@ -218,13 +218,13 @@ func (m *ACLChange) GetIdentity() string { type ACLChange_ACLContentValue struct { // Types that are valid to be assigned to Value: // - // *ACLChange_ACLContent_Value_UserAdd - // *ACLChange_ACLContent_Value_UserRemove - // *ACLChange_ACLContent_Value_UserPermissionChange - // *ACLChange_ACLContent_Value_UserInvite - // *ACLChange_ACLContent_Value_UserJoin - // *ACLChange_ACLContent_Value_UserConfirm - Value isACLChange_ACLContent_Value_Value `protobuf_oneof:"value"` + // *ACLChange_ACLContentValue_UserAdd + // *ACLChange_ACLContentValue_UserRemove + // *ACLChange_ACLContentValue_UserPermissionChange + // *ACLChange_ACLContentValue_UserInvite + // *ACLChange_ACLContentValue_UserJoin + // *ACLChange_ACLContentValue_UserConfirm + Value isACLChange_ACLContentValue_Value `protobuf_oneof:"value"` } func (m *ACLChange_ACLContentValue) Reset() { *m = ACLChange_ACLContentValue{} } @@ -260,39 +260,39 @@ func (m *ACLChange_ACLContentValue) XXX_DiscardUnknown() { var xxx_messageInfo_ACLChange_ACLContentValue proto.InternalMessageInfo -type isACLChange_ACLContent_Value_Value interface { - isACLChange_ACLContent_Value_Value() +type isACLChange_ACLContentValue_Value interface { + isACLChange_ACLContentValue_Value() MarshalTo([]byte) (int, error) Size() int } -type ACLChange_ACLContent_Value_UserAdd struct { +type ACLChange_ACLContentValue_UserAdd struct { UserAdd *ACLChange_UserAdd `protobuf:"bytes,1,opt,name=userAdd,proto3,oneof" json:"userAdd,omitempty"` } -type ACLChange_ACLContent_Value_UserRemove struct { +type ACLChange_ACLContentValue_UserRemove struct { UserRemove *ACLChange_UserRemove `protobuf:"bytes,2,opt,name=userRemove,proto3,oneof" json:"userRemove,omitempty"` } -type ACLChange_ACLContent_Value_UserPermissionChange struct { +type ACLChange_ACLContentValue_UserPermissionChange struct { UserPermissionChange *ACLChange_UserPermissionChange `protobuf:"bytes,3,opt,name=userPermissionChange,proto3,oneof" json:"userPermissionChange,omitempty"` } -type ACLChange_ACLContent_Value_UserInvite struct { +type ACLChange_ACLContentValue_UserInvite struct { UserInvite *ACLChange_UserInvite `protobuf:"bytes,4,opt,name=userInvite,proto3,oneof" json:"userInvite,omitempty"` } -type ACLChange_ACLContent_Value_UserJoin struct { +type ACLChange_ACLContentValue_UserJoin struct { UserJoin *ACLChange_UserJoin `protobuf:"bytes,5,opt,name=userJoin,proto3,oneof" json:"userJoin,omitempty"` } -type ACLChange_ACLContent_Value_UserConfirm struct { +type ACLChange_ACLContentValue_UserConfirm struct { UserConfirm *ACLChange_UserConfirm `protobuf:"bytes,6,opt,name=userConfirm,proto3,oneof" json:"userConfirm,omitempty"` } -func (*ACLChange_ACLContent_Value_UserAdd) isACLChange_ACLContent_Value_Value() {} -func (*ACLChange_ACLContent_Value_UserRemove) isACLChange_ACLContent_Value_Value() {} -func (*ACLChange_ACLContent_Value_UserPermissionChange) isACLChange_ACLContent_Value_Value() {} -func (*ACLChange_ACLContent_Value_UserInvite) isACLChange_ACLContent_Value_Value() {} -func (*ACLChange_ACLContent_Value_UserJoin) isACLChange_ACLContent_Value_Value() {} -func (*ACLChange_ACLContent_Value_UserConfirm) isACLChange_ACLContent_Value_Value() {} +func (*ACLChange_ACLContentValue_UserAdd) isACLChange_ACLContentValue_Value() {} +func (*ACLChange_ACLContentValue_UserRemove) isACLChange_ACLContentValue_Value() {} +func (*ACLChange_ACLContentValue_UserPermissionChange) isACLChange_ACLContentValue_Value() {} +func (*ACLChange_ACLContentValue_UserInvite) isACLChange_ACLContentValue_Value() {} +func (*ACLChange_ACLContentValue_UserJoin) isACLChange_ACLContentValue_Value() {} +func (*ACLChange_ACLContentValue_UserConfirm) isACLChange_ACLContentValue_Value() {} -func (m *ACLChange_ACLContentValue) GetValue() isACLChange_ACLContent_Value_Value { +func (m *ACLChange_ACLContentValue) GetValue() isACLChange_ACLContentValue_Value { if m != nil { return m.Value } @@ -300,42 +300,42 @@ func (m *ACLChange_ACLContentValue) GetValue() isACLChange_ACLContent_Value_Valu } func (m *ACLChange_ACLContentValue) GetUserAdd() *ACLChange_UserAdd { - if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserAdd); ok { + if x, ok := m.GetValue().(*ACLChange_ACLContentValue_UserAdd); ok { return x.UserAdd } return nil } func (m *ACLChange_ACLContentValue) GetUserRemove() *ACLChange_UserRemove { - if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserRemove); ok { + if x, ok := m.GetValue().(*ACLChange_ACLContentValue_UserRemove); ok { return x.UserRemove } return nil } func (m *ACLChange_ACLContentValue) GetUserPermissionChange() *ACLChange_UserPermissionChange { - if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserPermissionChange); ok { + if x, ok := m.GetValue().(*ACLChange_ACLContentValue_UserPermissionChange); ok { return x.UserPermissionChange } return nil } func (m *ACLChange_ACLContentValue) GetUserInvite() *ACLChange_UserInvite { - if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserInvite); ok { + if x, ok := m.GetValue().(*ACLChange_ACLContentValue_UserInvite); ok { return x.UserInvite } return nil } func (m *ACLChange_ACLContentValue) GetUserJoin() *ACLChange_UserJoin { - if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserJoin); ok { + if x, ok := m.GetValue().(*ACLChange_ACLContentValue_UserJoin); ok { return x.UserJoin } return nil } func (m *ACLChange_ACLContentValue) GetUserConfirm() *ACLChange_UserConfirm { - if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserConfirm); ok { + if x, ok := m.GetValue().(*ACLChange_ACLContentValue_UserConfirm); ok { return x.UserConfirm } return nil @@ -344,12 +344,12 @@ func (m *ACLChange_ACLContentValue) GetUserConfirm() *ACLChange_UserConfirm { // XXX_OneofWrappers is for the internal use of the proto package. func (*ACLChange_ACLContentValue) XXX_OneofWrappers() []interface{} { return []interface{}{ - (*ACLChange_ACLContent_Value_UserAdd)(nil), - (*ACLChange_ACLContent_Value_UserRemove)(nil), - (*ACLChange_ACLContent_Value_UserPermissionChange)(nil), - (*ACLChange_ACLContent_Value_UserInvite)(nil), - (*ACLChange_ACLContent_Value_UserJoin)(nil), - (*ACLChange_ACLContent_Value_UserConfirm)(nil), + (*ACLChange_ACLContentValue_UserAdd)(nil), + (*ACLChange_ACLContentValue_UserRemove)(nil), + (*ACLChange_ACLContentValue_UserPermissionChange)(nil), + (*ACLChange_ACLContentValue_UserInvite)(nil), + (*ACLChange_ACLContentValue_UserJoin)(nil), + (*ACLChange_ACLContentValue_UserConfirm)(nil), } } @@ -1271,12 +1271,12 @@ func (m *ACLChange_ACLContentValue) MarshalToSizedBuffer(dAtA []byte) (int, erro return len(dAtA) - i, nil } -func (m *ACLChange_ACLContent_Value_UserAdd) MarshalTo(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserAdd) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ACLChange_ACLContent_Value_UserAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.UserAdd != nil { { @@ -1292,12 +1292,12 @@ func (m *ACLChange_ACLContent_Value_UserAdd) MarshalToSizedBuffer(dAtA []byte) ( } return len(dAtA) - i, nil } -func (m *ACLChange_ACLContent_Value_UserRemove) MarshalTo(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserRemove) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ACLChange_ACLContent_Value_UserRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.UserRemove != nil { { @@ -1313,12 +1313,12 @@ func (m *ACLChange_ACLContent_Value_UserRemove) MarshalToSizedBuffer(dAtA []byte } return len(dAtA) - i, nil } -func (m *ACLChange_ACLContent_Value_UserPermissionChange) MarshalTo(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserPermissionChange) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ACLChange_ACLContent_Value_UserPermissionChange) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserPermissionChange) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.UserPermissionChange != nil { { @@ -1334,12 +1334,12 @@ func (m *ACLChange_ACLContent_Value_UserPermissionChange) MarshalToSizedBuffer(d } return len(dAtA) - i, nil } -func (m *ACLChange_ACLContent_Value_UserInvite) MarshalTo(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserInvite) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ACLChange_ACLContent_Value_UserInvite) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserInvite) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.UserInvite != nil { { @@ -1355,12 +1355,12 @@ func (m *ACLChange_ACLContent_Value_UserInvite) MarshalToSizedBuffer(dAtA []byte } return len(dAtA) - i, nil } -func (m *ACLChange_ACLContent_Value_UserJoin) MarshalTo(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserJoin) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ACLChange_ACLContent_Value_UserJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.UserJoin != nil { { @@ -1376,12 +1376,12 @@ func (m *ACLChange_ACLContent_Value_UserJoin) MarshalToSizedBuffer(dAtA []byte) } return len(dAtA) - i, nil } -func (m *ACLChange_ACLContent_Value_UserConfirm) MarshalTo(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserConfirm) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *ACLChange_ACLContent_Value_UserConfirm) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *ACLChange_ACLContentValue_UserConfirm) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.UserConfirm != nil { { @@ -2039,7 +2039,7 @@ func (m *ACLChange_ACLContentValue) Size() (n int) { return n } -func (m *ACLChange_ACLContent_Value_UserAdd) Size() (n int) { +func (m *ACLChange_ACLContentValue_UserAdd) Size() (n int) { if m == nil { return 0 } @@ -2051,7 +2051,7 @@ func (m *ACLChange_ACLContent_Value_UserAdd) Size() (n int) { } return n } -func (m *ACLChange_ACLContent_Value_UserRemove) Size() (n int) { +func (m *ACLChange_ACLContentValue_UserRemove) Size() (n int) { if m == nil { return 0 } @@ -2063,7 +2063,7 @@ func (m *ACLChange_ACLContent_Value_UserRemove) Size() (n int) { } return n } -func (m *ACLChange_ACLContent_Value_UserPermissionChange) Size() (n int) { +func (m *ACLChange_ACLContentValue_UserPermissionChange) Size() (n int) { if m == nil { return 0 } @@ -2075,7 +2075,7 @@ func (m *ACLChange_ACLContent_Value_UserPermissionChange) Size() (n int) { } return n } -func (m *ACLChange_ACLContent_Value_UserInvite) Size() (n int) { +func (m *ACLChange_ACLContentValue_UserInvite) Size() (n int) { if m == nil { return 0 } @@ -2087,7 +2087,7 @@ func (m *ACLChange_ACLContent_Value_UserInvite) Size() (n int) { } return n } -func (m *ACLChange_ACLContent_Value_UserJoin) Size() (n int) { +func (m *ACLChange_ACLContentValue_UserJoin) Size() (n int) { if m == nil { return 0 } @@ -2099,7 +2099,7 @@ func (m *ACLChange_ACLContent_Value_UserJoin) Size() (n int) { } return n } -func (m *ACLChange_ACLContent_Value_UserConfirm) Size() (n int) { +func (m *ACLChange_ACLContentValue_UserConfirm) Size() (n int) { if m == nil { return 0 } @@ -2871,7 +2871,7 @@ func (m *ACLChange_ACLContentValue) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &ACLChange_ACLContent_Value_UserAdd{v} + m.Value = &ACLChange_ACLContentValue_UserAdd{v} iNdEx = postIndex case 2: if wireType != 2 { @@ -2906,7 +2906,7 @@ func (m *ACLChange_ACLContentValue) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &ACLChange_ACLContent_Value_UserRemove{v} + m.Value = &ACLChange_ACLContentValue_UserRemove{v} iNdEx = postIndex case 3: if wireType != 2 { @@ -2941,7 +2941,7 @@ func (m *ACLChange_ACLContentValue) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &ACLChange_ACLContent_Value_UserPermissionChange{v} + m.Value = &ACLChange_ACLContentValue_UserPermissionChange{v} iNdEx = postIndex case 4: if wireType != 2 { @@ -2976,7 +2976,7 @@ func (m *ACLChange_ACLContentValue) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &ACLChange_ACLContent_Value_UserInvite{v} + m.Value = &ACLChange_ACLContentValue_UserInvite{v} iNdEx = postIndex case 5: if wireType != 2 { @@ -3011,7 +3011,7 @@ func (m *ACLChange_ACLContentValue) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &ACLChange_ACLContent_Value_UserJoin{v} + m.Value = &ACLChange_ACLContentValue_UserJoin{v} iNdEx = postIndex case 6: if wireType != 2 { @@ -3046,7 +3046,7 @@ func (m *ACLChange_ACLContentValue) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &ACLChange_ACLContent_Value_UserConfirm{v} + m.Value = &ACLChange_ACLContentValue_UserConfirm{v} iNdEx = postIndex default: iNdEx = preIndex diff --git a/pkg/ocache/ocache.go b/pkg/ocache/ocache.go index b0460ca6..5e10508a 100644 --- a/pkg/ocache/ocache.go +++ b/pkg/ocache/ocache.go @@ -69,10 +69,13 @@ type Object interface { } type ObjectLocker interface { - Object Locked() bool } +type ObjectLastUsage interface { + LastUsage() time.Time +} + type entry struct { id string lastUsage time.Time @@ -99,7 +102,7 @@ type OCache interface { // When 'loadFunc' returns a non-nil error, an object will not be stored to cache Get(ctx context.Context, id string) (value Object, err error) // Pick returns value if it's presents in cache (will not call loadFunc) - Pick(id string) (value Object, err error) + Pick(ctx context.Context, id string) (value Object, err error) // Add adds new object to cache // Returns error when object exists Add(id string, value Object) (err error) @@ -166,13 +169,18 @@ func (c *oCache) Get(ctx context.Context, id string) (value Object, err error) { return e.value, e.loadErr } -func (c *oCache) Pick(id string) (value Object, err error) { +func (c *oCache) Pick(ctx context.Context, id string) (value Object, err error) { c.mu.Lock() val, ok := c.data[id] c.mu.Unlock() if !ok { return nil, ErrNotExists } + select { + case <-ctx.Done(): + return nil, ctx.Err() + case <-val.load: + } <-val.load return val.value, val.loadErr } @@ -307,7 +315,11 @@ func (c *oCache) GC() { deadline := c.timeNow().Add(-c.ttl) var toClose []*entry for k, e := range c.data { - if !e.locked() && e.refCount <= 0 && e.lastUsage.Before(deadline) { + lu := e.lastUsage + if lug, ok := e.value.(ObjectLastUsage); ok { + lu = lug.LastUsage() + } + if !e.locked() && e.refCount <= 0 && lu.Before(deadline) { delete(c.data, k) toClose = append(toClose, e) } diff --git a/service/configuration/configuration.go b/service/configuration/configuration.go index 5701eca6..c242d79d 100644 --- a/service/configuration/configuration.go +++ b/service/configuration/configuration.go @@ -40,7 +40,7 @@ func (c *configuration) AllPeers(ctx context.Context, spaceId string) (peers []p nodeIds := c.NodeIds(spaceId) peers = make([]peer.Peer, 0, len(nodeIds)) for _, id := range nodeIds { - p, e := c.pool.DialAndAddPeer(ctx, id) + p, e := c.pool.Get(ctx, id) if e == nil { peers = append(peers, p) } @@ -53,7 +53,7 @@ func (c *configuration) AllPeers(ctx context.Context, spaceId string) (peers []p func (c *configuration) OnePeer(ctx context.Context, spaceId string) (p peer.Peer, err error) { nodeIds := c.NodeIds(spaceId) - return c.pool.GetOrDialOneOf(ctx, nodeIds) + return c.pool.GetOneOf(ctx, nodeIds) } func (c *configuration) NodeIds(spaceId string) []string { diff --git a/service/net/dialer/dialer.go b/service/net/dialer/dialer.go index b90bf872..ade01444 100644 --- a/service/net/dialer/dialer.go +++ b/service/net/dialer/dialer.go @@ -7,7 +7,6 @@ import ( "github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger" "github.com/anytypeio/go-anytype-infrastructure-experiments/config" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/peer" - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/rpc" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/secure" "github.com/libp2p/go-libp2p-core/sec" "go.uber.org/zap" @@ -60,7 +59,7 @@ func (d *dialer) UpdateAddrs(addrs map[string][]string) { d.mu.Unlock() } -func (d *dialer) Dial(ctx context.Context, peerId string) (peer peer.Peer, err error) { +func (d *dialer) Dial(ctx context.Context, peerId string) (p peer.Peer, err error) { d.mu.RLock() defer d.mu.RUnlock() addrs, ok := d.peerAddrs[peerId] @@ -68,11 +67,11 @@ func (d *dialer) Dial(ctx context.Context, peerId string) (peer peer.Peer, err e return nil, ErrArrdsNotFound } var ( - stream drpc.Stream - sc sec.SecureConn + conn drpc.Conn + sc sec.SecureConn ) for _, addr := range addrs { - stream, sc, err = d.makeStream(ctx, addr) + conn, sc, err = d.handshake(ctx, addr) if err != nil { log.Info("can't connect to host", zap.String("addr", addr)) } else { @@ -83,10 +82,10 @@ func (d *dialer) Dial(ctx context.Context, peerId string) (peer peer.Peer, err e if err != nil { return } - return rpc.PeerFromStream(sc, stream, false), nil + return peer.NewPeer(sc, conn), nil } -func (d *dialer) makeStream(ctx context.Context, addr string) (stream drpc.Stream, sc sec.SecureConn, err error) { +func (d *dialer) handshake(ctx context.Context, addr string) (conn drpc.Conn, sc sec.SecureConn, err error) { tcpConn, err := net.Dial("tcp", addr) if err != nil { return @@ -96,9 +95,6 @@ func (d *dialer) makeStream(ctx context.Context, addr string) (stream drpc.Strea return } log.Info("connected with remote host", zap.String("serverPeer", sc.RemotePeer().String()), zap.String("per", sc.LocalPeer().String())) - stream, err = drpcconn.New(sc).NewStream(ctx, "", rpc.Encoding) - if err != nil { - return - } - return stream, sc, err + conn = drpcconn.New(sc) + return conn, sc, err } diff --git a/service/net/peer/peer.go b/service/net/peer/peer.go index 331b0982..d73dc596 100644 --- a/service/net/peer/peer.go +++ b/service/net/peer/peer.go @@ -2,34 +2,58 @@ package peer import ( "context" - "github.com/anytypeio/go-anytype-infrastructure-experiments/syncproto" + "github.com/libp2p/go-libp2p-core/sec" + "storj.io/drpc" + "sync/atomic" "time" ) -type Dir uint - -const ( - // DirInbound indicates peer created connection - DirInbound Dir = iota - // DirOutbound indicates that our host created connection - DirOutbound -) - -type Info struct { - Id string - Dir Dir - LastActiveUnix int64 -} - -func (i Info) LastActive() time.Time { - return time.Unix(i.LastActiveUnix, 0) +func NewPeer(sc sec.SecureConn, conn drpc.Conn) Peer { + return &peer{ + id: sc.RemotePeer().String(), + lastUsage: time.Now().Unix(), + sc: sc, + Conn: conn, + } } type Peer interface { Id() string - Info() Info - Recv() (*syncproto.Message, error) - Send(msg *syncproto.Message) (err error) - Context() context.Context - Close() error + LastUsage() time.Time + UpdateLastUsage() + drpc.Conn +} + +type peer struct { + id string + lastUsage int64 + sc sec.SecureConn + drpc.Conn +} + +func (p *peer) Id() string { + return p.id +} + +func (p *peer) LastUsage() time.Time { + select { + case <-p.Closed(): + return time.Unix(0, 0) + default: + } + return time.Unix(atomic.LoadInt64(&p.lastUsage), 0) +} + +func (p *peer) Invoke(ctx context.Context, rpc string, enc drpc.Encoding, in, out drpc.Message) error { + defer p.UpdateLastUsage() + return p.Conn.Invoke(ctx, rpc, enc, in, out) +} + +func (p *peer) NewStream(ctx context.Context, rpc string, enc drpc.Encoding) (drpc.Stream, error) { + defer p.UpdateLastUsage() + return p.Conn.NewStream(ctx, rpc, enc) +} + +func (p *peer) UpdateLastUsage() { + atomic.StoreInt64(&p.lastUsage, time.Now().Unix()) } diff --git a/service/net/pool/handler/reply.go b/service/net/pool/handler/reply.go deleted file mode 100644 index 21dda1dd..00000000 --- a/service/net/pool/handler/reply.go +++ /dev/null @@ -1,32 +0,0 @@ -package handler - -import ( - "context" - "github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger" - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/pool" - "github.com/gogo/protobuf/proto" - "go.uber.org/zap" -) - -var log = logger.NewNamed("replyHandler") - -type ReplyHandler interface { - Handle(ctx context.Context, req []byte) (rep proto.Marshaler, err error) -} - -type Reply struct { - ReplyHandler -} - -func (r Reply) Handle(ctx context.Context, msg *pool.Message) error { - rep, e := r.ReplyHandler.Handle(ctx, msg.GetData()) - if msg.GetHeader().RequestId == 0 { - if e != nil { - log.Error("handler returned error", zap.Error(e)) - } else if rep != nil { - log.Debug("sender didn't expect a reply, but the handler made") - } - return nil - } - return msg.ReplyType(msg.GetHeader().GetType(), rep) -} diff --git a/service/net/pool/message.go b/service/net/pool/message.go deleted file mode 100644 index 15a76f2e..00000000 --- a/service/net/pool/message.go +++ /dev/null @@ -1,136 +0,0 @@ -package pool - -import ( - "fmt" - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/peer" - "github.com/anytypeio/go-anytype-infrastructure-experiments/syncproto" - "github.com/gogo/protobuf/proto" - "go.uber.org/zap" - "gopkg.in/mgo.v2/bson" -) - -type Message struct { - *syncproto.Message - peer peer.Peer -} - -func (m *Message) Peer() peer.Peer { - return m.peer -} - -func (m *Message) Reply(data []byte) (err error) { - rep := &syncproto.Message{ - Header: &syncproto.Header{ - TraceId: m.GetHeader().TraceId, - ReplyId: m.GetHeader().RequestId, - Type: syncproto.MessageType_MessageTypeSync, - }, - Data: data, - } - return m.peer.Send(rep) -} - -func (m *Message) ReplyType(tp syncproto.MessageType, data proto.Marshaler) (err error) { - dataBytes, err := data.Marshal() - if err != nil { - return err - } - rep := &syncproto.Message{ - Header: &syncproto.Header{ - TraceId: m.GetHeader().TraceId, - ReplyId: m.GetHeader().RequestId, - Type: tp, - }, - Data: dataBytes, - } - return m.peer.Send(rep) -} - -func (m *Message) Ack() (err error) { - ack := &syncproto.System{ - Ack: &syncproto.System_Ack{}, - } - data, err := ack.Marshal() - if err != nil { - return - } - rep := &syncproto.Message{ - Header: &syncproto.Header{ - TraceId: m.GetHeader().TraceId, - ReplyId: m.GetHeader().RequestId, - Type: syncproto.MessageType_MessageTypeSystem, - DebugInfo: "Ack", - }, - Data: data, - } - err = m.peer.Send(rep) - if err != nil { - log.With( - zap.String("peerId", m.peer.Id()), - zap.String("header", rep.GetHeader().String())). - Error("failed sending ack to peer", zap.Error(err)) - } else { - log.With( - zap.String("peerId", m.peer.Id()), - zap.String("header", rep.GetHeader().String())). - Debug("sent ack to peer") - } - return -} - -func (m *Message) AckError(code syncproto.System_Error_Code, description string) (err error) { - ack := &syncproto.System{ - Ack: &syncproto.System_Ack{ - Error: &syncproto.System_Error{ - Code: code, - Description: description, - }, - }, - } - data, err := ack.Marshal() - if err != nil { - return - } - rep := &syncproto.Message{ - Header: &syncproto.Header{ - TraceId: []byte(bson.NewObjectId()), - ReplyId: m.GetHeader().RequestId, - Type: syncproto.MessageType_MessageTypeSystem, - DebugInfo: "AckError", - }, - Data: data, - } - if err != nil { - log.With( - zap.String("peerId", m.peer.Id()), - zap.String("header", rep.GetHeader().String())). - Error("failed sending ackError to peer", zap.Error(err)) - } else { - log.With( - zap.String("peerId", m.peer.Id()), - zap.String("header", rep.GetHeader().String())). - Debug("sent ackError to peer") - } - return m.peer.Send(rep) -} - -func (m *Message) IsAck() (err error) { - if tp := m.GetHeader().GetType(); tp != syncproto.MessageType_MessageTypeSystem { - return fmt.Errorf("unexpected message type in response: %v, want System", tp) - } - sys := &syncproto.System{} - if err = sys.Unmarshal(m.GetData()); err != nil { - return - } - if ack := sys.Ack; ack != nil { - if ack.Error != nil { - return fmt.Errorf("response error: code=%d; descriptipon=%s", ack.Error.Code, ack.Error.Description) - } - return nil - } - return fmt.Errorf("received not ack response") -} - -func (m *Message) UnmarshalData(msg proto.Unmarshaler) error { - return msg.Unmarshal(m.Data) -} diff --git a/service/net/pool/peer.go b/service/net/pool/peer.go deleted file mode 100644 index 6a7a96d0..00000000 --- a/service/net/pool/peer.go +++ /dev/null @@ -1,28 +0,0 @@ -package pool - -import ( - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/peer" - "github.com/anytypeio/go-anytype-infrastructure-experiments/util/slice" -) - -type peerEntry struct { - peer peer.Peer - groupIds []string - ready chan struct{} -} - -func (pe *peerEntry) addGroup(groupId string) (ok bool) { - if slice.FindPos(pe.groupIds, groupId) != -1 { - return false - } - pe.groupIds = append(pe.groupIds, groupId) - return true -} - -func (pe *peerEntry) removeGroup(groupId string) (ok bool) { - if slice.FindPos(pe.groupIds, groupId) == -1 { - return false - } - pe.groupIds = slice.Remove(pe.groupIds, groupId) - return true -} diff --git a/service/net/pool/pool.go b/service/net/pool/pool.go index f9d122d7..cbd0973a 100644 --- a/service/net/pool/pool.go +++ b/service/net/pool/pool.go @@ -3,72 +3,47 @@ package pool import ( "context" "errors" - "fmt" "github.com/anytypeio/go-anytype-infrastructure-experiments/app" "github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger" + "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/ocache" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/dialer" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/peer" - "github.com/anytypeio/go-anytype-infrastructure-experiments/syncproto" - "github.com/anytypeio/go-anytype-infrastructure-experiments/util/slice" - "go.uber.org/zap" "math/rand" - "sync" - "sync/atomic" ) const ( - CName = "sync/peerPool" - maxSimultaneousOperationsPerStream = 10 + CName = "net.pool" ) -var log = logger.NewNamed("peerPool") +var log = logger.NewNamed(CName) var ( - ErrPoolClosed = errors.New("peer pool is closed") - ErrPeerNotFound = errors.New("peer not found") + ErrUnableToConnect = errors.New("unable to connect") ) -func NewPool() Pool { - return &pool{closed: true} +func New() Pool { + return &pool{} } -type Handler func(ctx context.Context, msg *Message) (err error) - +// Pool creates and caches outgoing connection type Pool interface { - AddAndReadPeer(peer peer.Peer) (err error) - AddHandler(msgType syncproto.MessageType, h Handler) - AddPeerIdToGroup(peerId, groupId string) (err error) - RemovePeerIdFromGroup(peerId, groupId string) (err error) - DialAndAddPeer(ctx context.Context, id string) (peer.Peer, error) - GetOrDialOneOf(ctx context.Context, peerIds []string) (peer.Peer, error) - - SendAndWait(ctx context.Context, peerId string, msg *syncproto.Message) (err error) - SendAndWaitResponse(ctx context.Context, id string, s *syncproto.Message) (resp *Message, err error) - Broadcast(ctx context.Context, groupId string, msg *syncproto.Message) (err error) + // Get lookups to peer in existing connections or creates and cache new one + Get(ctx context.Context, id string) (peer.Peer, error) + // GetOneOf searches at least one existing connection in cache or creates a new one from a randomly selected id from given list + GetOneOf(ctx context.Context, peerIds []string) (peer.Peer, error) app.ComponentRunnable } type pool struct { - peersById map[string]*peerEntry - waiters *waiters - handlers map[syncproto.MessageType][]Handler - peersIdsByGroup map[string][]string - - dialer dialer.Dialer - - closed bool - mu sync.RWMutex - wg *sync.WaitGroup + cache ocache.OCache } func (p *pool) Init(ctx context.Context, a *app.App) (err error) { - p.peersById = map[string]*peerEntry{} - p.handlers = map[syncproto.MessageType][]Handler{} - p.peersIdsByGroup = map[string][]string{} - p.waiters = &waiters{waiters: map[uint64]*waiter{}} - p.dialer = a.MustComponent(dialer.CName).(dialer.Dialer) - p.wg = &sync.WaitGroup{} + dialer := a.MustComponent(dialer.CName).(dialer.Dialer) + p.cache = ocache.New(func(ctx context.Context, id string) (value ocache.Object, err error) { + return dialer.Dial(ctx, id) + }) return nil } @@ -77,320 +52,49 @@ func (p *pool) Name() (name string) { } func (p *pool) Run(ctx context.Context) (err error) { - p.closed = false return nil } -func (p *pool) AddHandler(msgType syncproto.MessageType, h Handler) { - p.mu.Lock() - defer p.mu.Unlock() - if !p.closed { - // unable to add handler after Run - return - } - p.handlers[msgType] = append(p.handlers[msgType], h) -} - -func (p *pool) DialAndAddPeer(ctx context.Context, peerId string) (peer.Peer, error) { - p.mu.Lock() - defer p.mu.Unlock() - if p.closed { - return nil, ErrPoolClosed - } - return p.dialAndAdd(ctx, peerId) -} - -func (p *pool) dialAndAdd(ctx context.Context, peerId string) (peer.Peer, error) { - if peer, ok := p.peersById[peerId]; ok { - return peer.peer, nil - } - peer, err := p.dialer.Dial(ctx, peerId) +func (p *pool) Get(ctx context.Context, id string) (peer.Peer, error) { + v, err := p.cache.Get(ctx, id) if err != nil { return nil, err } - p.peersById[peer.Id()] = &peerEntry{ - peer: peer, - } - p.wg.Add(1) - go p.readPeerLoop(peer) - return peer, nil -} - -func (p *pool) AddAndReadPeer(peer peer.Peer) (err error) { - p.mu.Lock() - if p.closed { - p.mu.Unlock() - return ErrPoolClosed - } - p.peersById[peer.Id()] = &peerEntry{ - peer: peer, - } - p.wg.Add(1) - p.mu.Unlock() - return p.readPeerLoop(peer) -} - -func (p *pool) AddPeerIdToGroup(peerId, groupId string) (err error) { - p.mu.Lock() - defer p.mu.Unlock() - peer, ok := p.peersById[peerId] - if !ok { - return ErrPeerNotFound - } - if slice.FindPos(peer.groupIds, groupId) != -1 { - return nil - } - peer.addGroup(groupId) - p.peersIdsByGroup[groupId] = append(p.peersIdsByGroup[groupId], peerId) - return -} - -func (p *pool) RemovePeerIdFromGroup(peerId, groupId string) (err error) { - p.mu.Lock() - defer p.mu.Unlock() - peer, ok := p.peersById[peerId] - if !ok { - return ErrPeerNotFound - } - if slice.FindPos(peer.groupIds, groupId) == -1 { - return nil - } - peer.removeGroup(groupId) - p.peersIdsByGroup[groupId] = slice.Remove(p.peersIdsByGroup[groupId], peerId) - return -} - -func (p *pool) SendAndWait(ctx context.Context, peerId string, msg *syncproto.Message) (err error) { - resp, err := p.SendAndWaitResponse(ctx, peerId, msg) - if err != nil { - return - } - return resp.IsAck() -} - -func (p *pool) SendAndWaitResponse(ctx context.Context, peerId string, msg *syncproto.Message) (resp *Message, err error) { - defer func() { - if err != nil { - log.With( - zap.String("peerId", peerId), - zap.String("header", msg.GetHeader().String())). - Error("failed sending message to peer", zap.Error(err)) - } else { - log.With( - zap.String("peerId", peerId), - zap.String("header", msg.GetHeader().String())). - Debug("sent message to peer") - } - }() - - p.mu.RLock() - peer := p.peersById[peerId] - p.mu.RUnlock() - if peer == nil { - err = ErrPeerNotFound - return - } - - repId := p.waiters.NewReplyId() - msg.GetHeader().RequestId = repId - ch := make(chan Reply, 1) - - p.waiters.Add(repId, &waiter{ch: ch}) - defer p.waiters.Remove(repId) - - if err = peer.peer.Send(msg); err != nil { - return - } + pr := v.(peer.Peer) select { - case rep := <-ch: - if rep.Error != nil { - err = rep.Error - return - } - resp = rep.Message - return - case <-ctx.Done(): - log.Debug("context done in SendAndWait") - err = ctx.Err() + case <-pr.Closed(): + default: + return pr, nil } - return + p.cache.Remove(id) + return p.Get(ctx, id) } -func (p *pool) GetOrDialOneOf(ctx context.Context, peerIds []string) (peer.Peer, error) { - p.mu.RLock() - if p.closed { - p.mu.RUnlock() - return nil, ErrPoolClosed - } +func (p *pool) GetOneOf(ctx context.Context, peerIds []string) (peer.Peer, error) { + // finding existing connection for _, peerId := range peerIds { - peer, ok := p.peersById[peerId] - if ok { - p.mu.RUnlock() - return peer.peer, nil + if v, err := p.cache.Pick(ctx, peerId); err == nil { + pr := v.(peer.Peer) + select { + case <-pr.Closed(): + default: + return pr, nil + } } } - p.mu.RUnlock() + // shuffle ids for better consistency rand.Shuffle(len(peerIds), func(i, j int) { peerIds[i], peerIds[j] = peerIds[j], peerIds[i] }) - p.mu.Lock() - defer p.mu.Unlock() - var lastErr error + // connecting for _, peerId := range peerIds { - peer, err := p.dialAndAdd(ctx, peerId) - if err != nil { - lastErr = err - continue - } else { - return peer, nil - } - } - return nil, lastErr -} - -func (p *pool) Broadcast(ctx context.Context, groupId string, msg *syncproto.Message) (err error) { - //TODO implement me - panic("implement me") -} - -func (p *pool) readPeerLoop(peer peer.Peer) (err error) { - defer p.wg.Done() - - limiter := make(chan struct{}, maxSimultaneousOperationsPerStream) - for i := 0; i < maxSimultaneousOperationsPerStream; i++ { - limiter <- struct{}{} - } -Loop: - for { - msg, err := peer.Recv() - if err != nil { - log.Debug("peer receive error", zap.Error(err), zap.String("peerId", peer.Id())) - break - } - select { - case <-limiter: - case <-peer.Context().Done(): - break Loop - } - go func() { - defer func() { - limiter <- struct{}{} - }() - p.handleMessage(peer, msg) - }() - } - if err = p.removePeer(peer.Id()); err != nil { - log.Error("remove peer error", zap.String("peerId", peer.Id()), zap.Error(err)) - } - return -} - -func (p *pool) removePeer(peerId string) (err error) { - p.mu.Lock() - defer p.mu.Unlock() - _, ok := p.peersById[peerId] - if !ok { - return ErrPeerNotFound - } - delete(p.peersById, peerId) - return -} - -func (p *pool) handleMessage(peer peer.Peer, msg *syncproto.Message) { - log.With(zap.String("peerId", peer.Id()), zap.String("header", msg.GetHeader().String())). - Debug("received message from peer") - replyId := msg.GetHeader().GetReplyId() - if replyId != 0 { - if !p.waiters.Send(replyId, Reply{ - PeerInfo: peer.Info(), - Message: &Message{ - Message: msg, - peer: peer, - }, - }) { - log.Debug("received reply with unknown (or expired) replyId", zap.Uint64("replyId", replyId), zap.String("header", msg.GetHeader().String())) - } - return - } - handlers := p.handlers[msg.GetHeader().GetType()] - if len(handlers) == 0 { - log.With(zap.String("peerId", peer.Id())).Debug("no handlers for such message") - return - } - - message := &Message{Message: msg, peer: peer} - - for _, h := range handlers { - if err := h(peer.Context(), message); err != nil { - log.Error("handle message error", zap.Error(err)) + if v, err := p.cache.Get(ctx, peerId); err == nil { + return v.(peer.Peer), nil } } + return nil, ErrUnableToConnect } func (p *pool) Close(ctx context.Context) (err error) { - p.mu.Lock() - for _, peer := range p.peersById { - peer.peer.Close() - } - wg := p.wg - p.mu.Unlock() - if wg != nil { - wg.Wait() - } - return nil -} - -type waiter struct { - sent int - ch chan<- Reply -} - -type waiters struct { - waiters map[uint64]*waiter - replySeq uint64 - mu sync.Mutex -} - -func (w *waiters) Send(replyId uint64, r Reply) (ok bool) { - w.mu.Lock() - wait := w.waiters[replyId] - if wait == nil { - w.mu.Unlock() - return false - } - wait.sent++ - var lastMessage = wait.sent == cap(wait.ch) - if lastMessage { - delete(w.waiters, replyId) - } - w.mu.Unlock() - wait.ch <- r - if lastMessage { - close(wait.ch) - } - return true -} - -func (w *waiters) Add(replyId uint64, wait *waiter) { - w.mu.Lock() - w.waiters[replyId] = wait - w.mu.Unlock() -} - -func (w *waiters) Remove(id uint64) error { - w.mu.Lock() - defer w.mu.Unlock() - if _, ok := w.waiters[id]; ok { - delete(w.waiters, id) - return nil - } - return fmt.Errorf("waiter not found") -} - -func (w *waiters) NewReplyId() uint64 { - res := atomic.AddUint64(&w.replySeq, 1) - if res == 0 { - return w.NewReplyId() - } - return res + return p.cache.Close() } diff --git a/service/net/pool/pool_test.go b/service/net/pool/pool_test.go new file mode 100644 index 00000000..efc51d38 --- /dev/null +++ b/service/net/pool/pool_test.go @@ -0,0 +1,213 @@ +package pool + +import ( + "context" + "errors" + "fmt" + "github.com/anytypeio/go-anytype-infrastructure-experiments/app" + "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/dialer" + "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/peer" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "storj.io/drpc" + "testing" + "time" +) + +var ctx = context.Background() + +func TestPool_Get(t *testing.T) { + t.Run("dial error", func(t *testing.T) { + fx := newFixture(t) + defer fx.Finish() + var expErr = errors.New("dial error") + fx.Dialer.dial = func(ctx context.Context, peerId string) (peer peer.Peer, err error) { + return nil, expErr + } + p, err := fx.Get(ctx, "1") + assert.Nil(t, p) + assert.EqualError(t, err, expErr.Error()) + }) + t.Run("dial and cached", func(t *testing.T) { + fx := newFixture(t) + defer fx.Finish() + fx.Dialer.dial = func(ctx context.Context, peerId string) (peer peer.Peer, err error) { + return newTestPeer("1"), nil + } + p, err := fx.Get(ctx, "1") + assert.NoError(t, err) + assert.NotNil(t, p) + fx.Dialer.dial = nil + p, err = fx.Get(ctx, "1") + assert.NoError(t, err) + assert.NotNil(t, p) + }) + t.Run("retry for closed", func(t *testing.T) { + fx := newFixture(t) + defer fx.Finish() + tp := newTestPeer("1") + fx.Dialer.dial = func(ctx context.Context, peerId string) (peer peer.Peer, err error) { + return tp, nil + } + p, err := fx.Get(ctx, "1") + assert.NoError(t, err) + assert.NotNil(t, p) + p.Close() + tp2 := newTestPeer("1") + fx.Dialer.dial = func(ctx context.Context, peerId string) (peer peer.Peer, err error) { + return tp2, nil + } + p, err = fx.Get(ctx, "1") + assert.NoError(t, err) + assert.Equal(t, p, tp2) + }) +} + +func TestPool_GetOneOf(t *testing.T) { + addToCache := func(t *testing.T, fx *fixture, tp *testPeer) { + fx.Dialer.dial = func(ctx context.Context, peerId string) (peer peer.Peer, err error) { + return tp, nil + } + gp, err := fx.Get(ctx, tp.Id()) + require.NoError(t, err) + require.Equal(t, gp, tp) + } + + t.Run("from cache", func(t *testing.T) { + fx := newFixture(t) + defer fx.Finish() + tp1 := newTestPeer("1") + addToCache(t, fx, tp1) + p, err := fx.GetOneOf(ctx, []string{"3", "2", "1"}) + require.NoError(t, err) + assert.Equal(t, tp1, p) + }) + t.Run("from cache - skip closed", func(t *testing.T) { + fx := newFixture(t) + defer fx.Finish() + tp2 := newTestPeer("2") + addToCache(t, fx, tp2) + tp2.Close() + tp1 := newTestPeer("1") + addToCache(t, fx, tp1) + p, err := fx.GetOneOf(ctx, []string{"3", "2", "1"}) + require.NoError(t, err) + assert.Equal(t, tp1, p) + }) + t.Run("dial", func(t *testing.T) { + fx := newFixture(t) + defer fx.Finish() + var called bool + fx.Dialer.dial = func(ctx context.Context, peerId string) (peer peer.Peer, err error) { + if called { + return nil, fmt.Errorf("not expected call") + } + called = true + return newTestPeer(peerId), nil + } + p, err := fx.GetOneOf(ctx, []string{"3", "2", "1"}) + require.NoError(t, err) + assert.NotNil(t, p) + }) + t.Run("unable to connect", func(t *testing.T) { + fx := newFixture(t) + defer fx.Finish() + fx.Dialer.dial = func(ctx context.Context, peerId string) (peer peer.Peer, err error) { + return nil, fmt.Errorf("persistent error") + } + p, err := fx.GetOneOf(ctx, []string{"3", "2", "1"}) + assert.Equal(t, ErrUnableToConnect, err) + assert.Nil(t, p) + }) +} + +func newFixture(t *testing.T) *fixture { + fx := &fixture{ + Pool: New(), + Dialer: &dialerMock{}, + } + a := new(app.App) + a.Register(fx.Pool) + a.Register(fx.Dialer) + require.NoError(t, a.Start(context.Background())) + fx.a = a + fx.t = t + return fx +} + +func (fx *fixture) Finish() { + require.NoError(fx.t, fx.a.Close(context.Background())) +} + +type fixture struct { + Pool + Dialer *dialerMock + a *app.App + t *testing.T +} + +var _ dialer.Dialer = (*dialerMock)(nil) + +type dialerMock struct { + dial func(ctx context.Context, peerId string) (peer peer.Peer, err error) +} + +func (d *dialerMock) Dial(ctx context.Context, peerId string) (peer peer.Peer, err error) { + return d.dial(ctx, peerId) +} + +func (d *dialerMock) UpdateAddrs(addrs map[string][]string) { + return +} + +func (d *dialerMock) Init(ctx context.Context, a *app.App) (err error) { + return +} + +func (d *dialerMock) Name() (name string) { + return dialer.CName +} + +func newTestPeer(id string) *testPeer { + return &testPeer{ + id: id, + closed: make(chan struct{}), + } +} + +type testPeer struct { + id string + closed chan struct{} +} + +func (t *testPeer) Id() string { + return t.id +} + +func (t *testPeer) LastUsage() time.Time { + return time.Now() +} + +func (t *testPeer) UpdateLastUsage() {} + +func (t *testPeer) Close() error { + select { + case <-t.closed: + return fmt.Errorf("already closed") + default: + close(t.closed) + } + return nil +} + +func (t *testPeer) Closed() <-chan struct{} { + return t.closed +} + +func (t *testPeer) Invoke(ctx context.Context, rpc string, enc drpc.Encoding, in, out drpc.Message) error { + return fmt.Errorf("call Invoke on test peer") +} + +func (t *testPeer) NewStream(ctx context.Context, rpc string, enc drpc.Encoding) (drpc.Stream, error) { + return nil, fmt.Errorf("call NewStream on test peer") +} diff --git a/service/net/pool/request.go b/service/net/pool/request.go deleted file mode 100644 index 8584f0dd..00000000 --- a/service/net/pool/request.go +++ /dev/null @@ -1,45 +0,0 @@ -package pool - -import "context" - -// 1. message for one peerId with ack -// pool.SendAndWait(ctx context,.C -// 2. message for many peers without ack (or group) - -type Request struct { - groupId string - oneOf []string - all []string - tryDial bool - needReply bool - pool *pool -} - -func (r *Request) GroupId(groupId string) *Request { - r.groupId = groupId - return r -} - -func (r *Request) All(peerIds ...string) *Request { - r.all = peerIds - return r -} - -func (r *Request) OneOf(peerIds ...string) *Request { - r.oneOf = peerIds - return r -} - -func (r *Request) TryDial(is bool) *Request { - r.tryDial = is - return r -} - -func (r *Request) NeedReply(is bool) *Request { - r.needReply = is - return r -} - -func (r *Request) Exec(ctx context.Context, msg *Message) *Results { - return nil -} diff --git a/service/net/pool/result.go b/service/net/pool/result.go deleted file mode 100644 index 94f1ac93..00000000 --- a/service/net/pool/result.go +++ /dev/null @@ -1,53 +0,0 @@ -package pool - -import ( - "context" - "fmt" - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/peer" -) - -// Results of request collects replies and errors -// Must be closed after usage r.Close() -type Results struct { - ctx context.Context - cancel func() - waiterId uint64 - ch chan Reply - pool *pool -} - -// Iterate iterates over replies -// if callback will return a non-nil error then iteration stops -func (r *Results) Iterate(callback func(r Reply) (err error)) (err error) { - if r.ctx == nil || r.ch == nil { - return fmt.Errorf("results not initialized") - } - for { - select { - case <-r.ctx.Done(): - return r.ctx.Err() - case m, ok := <-r.ch: - if ok { - if err = callback(m); err != nil { - return err - } - } else { - return - } - } - } -} - -// Close cancels iteration and unregister reply handler in the pool -// Required to call to avoid memory leaks -func (r *Results) Close() (err error) { - r.cancel() - return r.pool.waiters.Remove(r.waiterId) -} - -// Reply presents the result of request executing can be error or result message -type Reply struct { - PeerInfo peer.Info - Error error - Message *Message -} diff --git a/service/net/rpc/encoding.go b/service/net/rpc/encoding.go deleted file mode 100644 index eb983b9d..00000000 --- a/service/net/rpc/encoding.go +++ /dev/null @@ -1,18 +0,0 @@ -package rpc - -import ( - "github.com/gogo/protobuf/proto" - "storj.io/drpc" -) - -var Encoding = enc{} - -type enc struct{} - -func (e enc) Marshal(msg drpc.Message) ([]byte, error) { - return msg.(proto.Marshaler).Marshal() -} - -func (e enc) Unmarshal(buf []byte, msg drpc.Message) error { - return msg.(proto.Unmarshaler).Unmarshal(buf) -} diff --git a/service/net/rpc/server/drpcserver.go b/service/net/rpc/server/drpcserver.go index 684b6d40..1af9af7b 100644 --- a/service/net/rpc/server/drpcserver.go +++ b/service/net/rpc/server/drpcserver.go @@ -6,11 +6,11 @@ import ( "github.com/anytypeio/go-anytype-infrastructure-experiments/app/logger" "github.com/anytypeio/go-anytype-infrastructure-experiments/config" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/pool" - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/rpc" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/secure" "go.uber.org/zap" "net" "storj.io/drpc" + "storj.io/drpc/drpcmux" "storj.io/drpc/drpcserver" "strings" "time" @@ -21,11 +21,12 @@ const CName = "net/drpcserver" var log = logger.NewNamed(CName) func New() DRPCServer { - return &drpcServer{} + return &drpcServer{Mux: drpcmux.New()} } type DRPCServer interface { app.ComponentRunnable + drpc.Mux } type drpcServer struct { @@ -35,6 +36,7 @@ type drpcServer struct { listeners []secure.ContextListener pool pool.Pool cancel func() + *drpcmux.Mux } func (s *drpcServer) Init(ctx context.Context, a *app.App) (err error) { @@ -49,9 +51,7 @@ func (s *drpcServer) Name() (name string) { } func (s *drpcServer) Run(ctx context.Context) (err error) { - s.drpcServer = drpcserver.New(s) - - s.drpcServer = drpcserver.New(mux) + s.drpcServer = drpcserver.New(s.Mux) ctx, s.cancel = context.WithCancel(ctx) for _, addr := range s.config.ListenAddrs { tcpList, err := net.Listen("tcp", addr) @@ -111,16 +111,6 @@ func (s *drpcServer) serveConn(ctx context.Context, conn net.Conn) { } } -func (s *drpcServer) HandleRPC(stream drpc.Stream, _ string) (err error) { - ctx := stream.Context() - sc, err := secure.CtxSecureConn(ctx) - if err != nil { - return - } - log.With(zap.String("peer", sc.RemotePeer().String())).Debug("stream opened") - return s.pool.AddAndReadPeer(rpc.PeerFromStream(sc, stream, true)) -} - func (s *drpcServer) Close(ctx context.Context) (err error) { if s.cancel != nil { s.cancel() diff --git a/service/net/rpc/stream.go b/service/net/rpc/stream.go deleted file mode 100644 index c05691da..00000000 --- a/service/net/rpc/stream.go +++ /dev/null @@ -1,55 +0,0 @@ -package rpc - -import ( - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/peer" - "github.com/anytypeio/go-anytype-infrastructure-experiments/syncproto" - "github.com/libp2p/go-libp2p-core/sec" - "storj.io/drpc" - "sync/atomic" - "time" -) - -func PeerFromStream(sc sec.SecureConn, stream drpc.Stream, incoming bool) peer.Peer { - dp := &drpcPeer{ - sc: sc, - Stream: stream, - } - dp.info.Id = sc.RemotePeer().String() - if incoming { - dp.info.Dir = peer.DirInbound - } else { - dp.info.Dir = peer.DirOutbound - } - return dp -} - -type drpcPeer struct { - sc sec.SecureConn - info peer.Info - drpc.Stream -} - -func (d *drpcPeer) Id() string { - return d.info.Id -} - -func (d *drpcPeer) Info() peer.Info { - return d.info -} - -func (d *drpcPeer) Recv() (msg *syncproto.Message, err error) { - msg = &syncproto.Message{} - if err = d.Stream.MsgRecv(msg, Encoding); err != nil { - return - } - atomic.StoreInt64(&d.info.LastActiveUnix, time.Now().Unix()) - return -} - -func (d *drpcPeer) Send(msg *syncproto.Message) (err error) { - if err = d.Stream.MsgSend(msg, Encoding); err != nil { - return - } - atomic.StoreInt64(&d.info.LastActiveUnix, time.Now().Unix()) - return -} diff --git a/service/space/service.go b/service/space/service.go index 5e61366d..183b5425 100644 --- a/service/space/service.go +++ b/service/space/service.go @@ -9,10 +9,9 @@ import ( "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/ocache" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/configuration" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/pool" - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/pool/handler" + "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/rpc/server" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/space/spacesync" - "github.com/anytypeio/go-anytype-infrastructure-experiments/syncproto" - "github.com/gogo/protobuf/proto" + "storj.io/drpc/drpcerr" "time" ) @@ -25,7 +24,7 @@ func New() Service { } type Service interface { - handler.ReplyHandler + spacesync.DRPCSpaceServer app.ComponentRunnable } @@ -42,7 +41,7 @@ func (s *service) Init(ctx context.Context, a *app.App) (err error) { s.confService = a.MustComponent(configuration.CName).(configuration.Service) ttlSec := time.Second * time.Duration(s.conf.GCTTL) s.cache = ocache.New(s.loadSpace, ocache.WithTTL(ttlSec), ocache.WithGCPeriod(time.Minute)) - s.pool.AddHandler(syncproto.MessageType_MessageTypeSpace, handler.Reply{ReplyHandler: s}.Handle) + spacesync.DRPCRegisterSpace(a.MustComponent(server.CName).(server.DRPCServer), s) return nil } @@ -72,19 +71,8 @@ func (s *service) get(ctx context.Context, id string) (Space, error) { return obj.(Space), nil } -func (s *service) Handle(ctx context.Context, data []byte) (resp proto.Marshaler, err error) { - var spaceReq = &spacesync.Space{} - if err = spaceReq.Unmarshal(data); err != nil { - return - } - if spaceReq.SpaceId != "" { - sp, e := s.get(ctx, spaceReq.SpaceId) - if e != nil { - return nil, e - } - return sp.Handle(ctx, spaceReq) - } - return nil, fmt.Errorf("unexpected space message") +func (s *service) HeadSync(ctx context.Context, request *spacesync.HeadSyncRequest) (*spacesync.HeadSyncResponse, error) { + return nil, drpcerr.WithCode(fmt.Errorf("check"), 42) } func (s *service) Close(ctx context.Context) (err error) { diff --git a/service/space/space.go b/service/space/space.go index 182aef30..169fd408 100644 --- a/service/space/space.go +++ b/service/space/space.go @@ -6,7 +6,6 @@ import ( "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/ldiff" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/configuration" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/space/remotediff" - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/space/spacesync" "go.uber.org/zap" "math/rand" "sync" @@ -15,10 +14,11 @@ import ( type Space interface { Id() string - Handle(ctx context.Context, msg *spacesync.Space) (repl *spacesync.Space, err error) Close() error } +// + type space struct { id string conf configuration.Configuration @@ -64,28 +64,6 @@ func (s *space) testFill() { s.diff.Set(els...) } -func (s *space) Handle(ctx context.Context, msg *spacesync.Space) (repl *spacesync.Space, err error) { - if diffRange := msg.GetMessage().GetDiffRange(); diffRange != nil { - resp, er := remotediff.HandlerRangeRequest(ctx, s.diff, diffRange) - if er != nil { - return nil, er - } - return &spacesync.Space{SpaceId: s.id, Message: &spacesync.Space_Content{ - Value: &spacesync.Space_Content_DiffRange{ - DiffRange: resp, - }, - }}, nil - } - - /// - - /// - - /// - - return nil, fmt.Errorf("unexpected request") -} - func (s *space) syncLoop() { defer close(s.syncLoopDone) doSync := func() { diff --git a/service/space/spacesync/protos/spacesync.proto b/service/space/spacesync/protos/spacesync.proto index 8d46ca0a..f0b68b11 100644 --- a/service/space/spacesync/protos/spacesync.proto +++ b/service/space/spacesync/protos/spacesync.proto @@ -1,42 +1,44 @@ syntax = "proto3"; -package anytype; +package anySpace; option go_package = "service/space/spacesync"; -message Space { - string spaceId = 1; - - Content message = 2; - - message Content { - oneof value { - DiffRange diffRange = 1; - - } - } +enum ErrCodes { + Unexpected = 0; } -message DiffRange { - Request request = 1; - Response response = 2; +service Space { + // HeadSync compares all objects and their hashes in a space + rpc HeadSync(HeadSyncRequest) returns (HeadSyncResponse); +} - message Request { - repeated Range ranges = 1; - message Range { - uint64 from = 1; - uint64 to = 2; - uint32 limit = 3; - } - } - message Response { - repeated Result results = 1; - message Result { - bytes hash = 1; - repeated Element elements = 2; - uint32 count = 3; - message Element { - string id = 1; - string head = 2; - } - } - } -} \ No newline at end of file + +// HeadSyncRange presenting a request for one range +message HeadSyncRange { + uint64 from = 1; + uint64 to = 2; + uint32 limit = 3; +} + +// HeadSyncResult presenting a response for one range +message HeadSyncResult { + bytes hash = 1; + repeated HeadSyncResultElement elements = 2; + uint32 count = 3; +} + +// HeadSyncResultElement presenting state of one object +message HeadSyncResultElement { + string id = 1; + string head = 2; +} + +// HeadSyncRequest is a request for HeadSync +message HeadSyncRequest { + string spaceId = 1; + repeated HeadSyncRange ranges = 2; +} + +// HeadSyncResponse is a response for HeadSync +message HeadSyncResponse { + repeated HeadSyncResult results = 1; +} diff --git a/service/space/spacesync/spacesync.pb.go b/service/space/spacesync/spacesync.pb.go index af6fd478..92772dc4 100644 --- a/service/space/spacesync/spacesync.pb.go +++ b/service/space/spacesync/spacesync.pb.go @@ -22,245 +22,47 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package -type Space struct { - SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"` - Message *Space_Content `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` +type ErrCodes int32 + +const ( + ErrCodes_Unexpected ErrCodes = 0 +) + +var ErrCodes_name = map[int32]string{ + 0: "Unexpected", } -func (m *Space) Reset() { *m = Space{} } -func (m *Space) String() string { return proto.CompactTextString(m) } -func (*Space) ProtoMessage() {} -func (*Space) Descriptor() ([]byte, []int) { +var ErrCodes_value = map[string]int32{ + "Unexpected": 0, +} + +func (x ErrCodes) String() string { + return proto.EnumName(ErrCodes_name, int32(x)) +} + +func (ErrCodes) EnumDescriptor() ([]byte, []int) { return fileDescriptor_11d78c2fb7c80384, []int{0} } -func (m *Space) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Space) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Space.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 *Space) XXX_Merge(src proto.Message) { - xxx_messageInfo_Space.Merge(m, src) -} -func (m *Space) XXX_Size() int { - return m.Size() -} -func (m *Space) XXX_DiscardUnknown() { - xxx_messageInfo_Space.DiscardUnknown(m) -} -var xxx_messageInfo_Space proto.InternalMessageInfo - -func (m *Space) GetSpaceId() string { - if m != nil { - return m.SpaceId - } - return "" -} - -func (m *Space) GetMessage() *Space_Content { - if m != nil { - return m.Message - } - return nil -} - -type Space_Content struct { - // Types that are valid to be assigned to Value: - // - // *Space_Content_DiffRange - Value isSpace_Content_Value `protobuf_oneof:"value"` -} - -func (m *Space_Content) Reset() { *m = Space_Content{} } -func (m *Space_Content) String() string { return proto.CompactTextString(m) } -func (*Space_Content) ProtoMessage() {} -func (*Space_Content) Descriptor() ([]byte, []int) { - return fileDescriptor_11d78c2fb7c80384, []int{0, 0} -} -func (m *Space_Content) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *Space_Content) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_Space_Content.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 *Space_Content) XXX_Merge(src proto.Message) { - xxx_messageInfo_Space_Content.Merge(m, src) -} -func (m *Space_Content) XXX_Size() int { - return m.Size() -} -func (m *Space_Content) XXX_DiscardUnknown() { - xxx_messageInfo_Space_Content.DiscardUnknown(m) -} - -var xxx_messageInfo_Space_Content proto.InternalMessageInfo - -type isSpace_Content_Value interface { - isSpace_Content_Value() - MarshalTo([]byte) (int, error) - Size() int -} - -type Space_Content_DiffRange struct { - DiffRange *DiffRange `protobuf:"bytes,1,opt,name=diffRange,proto3,oneof" json:"diffRange,omitempty"` -} - -func (*Space_Content_DiffRange) isSpace_Content_Value() {} - -func (m *Space_Content) GetValue() isSpace_Content_Value { - if m != nil { - return m.Value - } - return nil -} - -func (m *Space_Content) GetDiffRange() *DiffRange { - if x, ok := m.GetValue().(*Space_Content_DiffRange); ok { - return x.DiffRange - } - return nil -} - -// XXX_OneofWrappers is for the internal use of the proto package. -func (*Space_Content) XXX_OneofWrappers() []interface{} { - return []interface{}{ - (*Space_Content_DiffRange)(nil), - } -} - -type DiffRange struct { - Request *DiffRange_Request `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"` - Response *DiffRange_Response `protobuf:"bytes,2,opt,name=response,proto3" json:"response,omitempty"` -} - -func (m *DiffRange) Reset() { *m = DiffRange{} } -func (m *DiffRange) String() string { return proto.CompactTextString(m) } -func (*DiffRange) ProtoMessage() {} -func (*DiffRange) Descriptor() ([]byte, []int) { - return fileDescriptor_11d78c2fb7c80384, []int{1} -} -func (m *DiffRange) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DiffRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DiffRange.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 *DiffRange) XXX_Merge(src proto.Message) { - xxx_messageInfo_DiffRange.Merge(m, src) -} -func (m *DiffRange) XXX_Size() int { - return m.Size() -} -func (m *DiffRange) XXX_DiscardUnknown() { - xxx_messageInfo_DiffRange.DiscardUnknown(m) -} - -var xxx_messageInfo_DiffRange proto.InternalMessageInfo - -func (m *DiffRange) GetRequest() *DiffRange_Request { - if m != nil { - return m.Request - } - return nil -} - -func (m *DiffRange) GetResponse() *DiffRange_Response { - if m != nil { - return m.Response - } - return nil -} - -type DiffRange_Request struct { - Ranges []*DiffRange_Request_Range `protobuf:"bytes,1,rep,name=ranges,proto3" json:"ranges,omitempty"` -} - -func (m *DiffRange_Request) Reset() { *m = DiffRange_Request{} } -func (m *DiffRange_Request) String() string { return proto.CompactTextString(m) } -func (*DiffRange_Request) ProtoMessage() {} -func (*DiffRange_Request) Descriptor() ([]byte, []int) { - return fileDescriptor_11d78c2fb7c80384, []int{1, 0} -} -func (m *DiffRange_Request) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DiffRange_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DiffRange_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 *DiffRange_Request) XXX_Merge(src proto.Message) { - xxx_messageInfo_DiffRange_Request.Merge(m, src) -} -func (m *DiffRange_Request) XXX_Size() int { - return m.Size() -} -func (m *DiffRange_Request) XXX_DiscardUnknown() { - xxx_messageInfo_DiffRange_Request.DiscardUnknown(m) -} - -var xxx_messageInfo_DiffRange_Request proto.InternalMessageInfo - -func (m *DiffRange_Request) GetRanges() []*DiffRange_Request_Range { - if m != nil { - return m.Ranges - } - return nil -} - -type DiffRange_Request_Range struct { +// HeadSyncRange presenting a request for one range +type HeadSyncRange struct { From uint64 `protobuf:"varint,1,opt,name=from,proto3" json:"from,omitempty"` To uint64 `protobuf:"varint,2,opt,name=to,proto3" json:"to,omitempty"` Limit uint32 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"` } -func (m *DiffRange_Request_Range) Reset() { *m = DiffRange_Request_Range{} } -func (m *DiffRange_Request_Range) String() string { return proto.CompactTextString(m) } -func (*DiffRange_Request_Range) ProtoMessage() {} -func (*DiffRange_Request_Range) Descriptor() ([]byte, []int) { - return fileDescriptor_11d78c2fb7c80384, []int{1, 0, 0} +func (m *HeadSyncRange) Reset() { *m = HeadSyncRange{} } +func (m *HeadSyncRange) String() string { return proto.CompactTextString(m) } +func (*HeadSyncRange) ProtoMessage() {} +func (*HeadSyncRange) Descriptor() ([]byte, []int) { + return fileDescriptor_11d78c2fb7c80384, []int{0} } -func (m *DiffRange_Request_Range) XXX_Unmarshal(b []byte) error { +func (m *HeadSyncRange) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *DiffRange_Request_Range) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *HeadSyncRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_DiffRange_Request_Range.Marshal(b, m, deterministic) + return xxx_messageInfo_HeadSyncRange.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -270,55 +72,58 @@ func (m *DiffRange_Request_Range) XXX_Marshal(b []byte, deterministic bool) ([]b return b[:n], nil } } -func (m *DiffRange_Request_Range) XXX_Merge(src proto.Message) { - xxx_messageInfo_DiffRange_Request_Range.Merge(m, src) +func (m *HeadSyncRange) XXX_Merge(src proto.Message) { + xxx_messageInfo_HeadSyncRange.Merge(m, src) } -func (m *DiffRange_Request_Range) XXX_Size() int { +func (m *HeadSyncRange) XXX_Size() int { return m.Size() } -func (m *DiffRange_Request_Range) XXX_DiscardUnknown() { - xxx_messageInfo_DiffRange_Request_Range.DiscardUnknown(m) +func (m *HeadSyncRange) XXX_DiscardUnknown() { + xxx_messageInfo_HeadSyncRange.DiscardUnknown(m) } -var xxx_messageInfo_DiffRange_Request_Range proto.InternalMessageInfo +var xxx_messageInfo_HeadSyncRange proto.InternalMessageInfo -func (m *DiffRange_Request_Range) GetFrom() uint64 { +func (m *HeadSyncRange) GetFrom() uint64 { if m != nil { return m.From } return 0 } -func (m *DiffRange_Request_Range) GetTo() uint64 { +func (m *HeadSyncRange) GetTo() uint64 { if m != nil { return m.To } return 0 } -func (m *DiffRange_Request_Range) GetLimit() uint32 { +func (m *HeadSyncRange) GetLimit() uint32 { if m != nil { return m.Limit } return 0 } -type DiffRange_Response struct { - Results []*DiffRange_Response_Result `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"` +// HeadSyncResult presenting a response for one range +type HeadSyncResult struct { + Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` + Elements []*HeadSyncResultElement `protobuf:"bytes,2,rep,name=elements,proto3" json:"elements,omitempty"` + Count uint32 `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"` } -func (m *DiffRange_Response) Reset() { *m = DiffRange_Response{} } -func (m *DiffRange_Response) String() string { return proto.CompactTextString(m) } -func (*DiffRange_Response) ProtoMessage() {} -func (*DiffRange_Response) Descriptor() ([]byte, []int) { - return fileDescriptor_11d78c2fb7c80384, []int{1, 1} +func (m *HeadSyncResult) Reset() { *m = HeadSyncResult{} } +func (m *HeadSyncResult) String() string { return proto.CompactTextString(m) } +func (*HeadSyncResult) ProtoMessage() {} +func (*HeadSyncResult) Descriptor() ([]byte, []int) { + return fileDescriptor_11d78c2fb7c80384, []int{1} } -func (m *DiffRange_Response) XXX_Unmarshal(b []byte) error { +func (m *HeadSyncResult) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *DiffRange_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *HeadSyncResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_DiffRange_Response.Marshal(b, m, deterministic) + return xxx_messageInfo_HeadSyncResult.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -328,102 +133,57 @@ func (m *DiffRange_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, return b[:n], nil } } -func (m *DiffRange_Response) XXX_Merge(src proto.Message) { - xxx_messageInfo_DiffRange_Response.Merge(m, src) +func (m *HeadSyncResult) XXX_Merge(src proto.Message) { + xxx_messageInfo_HeadSyncResult.Merge(m, src) } -func (m *DiffRange_Response) XXX_Size() int { +func (m *HeadSyncResult) XXX_Size() int { return m.Size() } -func (m *DiffRange_Response) XXX_DiscardUnknown() { - xxx_messageInfo_DiffRange_Response.DiscardUnknown(m) +func (m *HeadSyncResult) XXX_DiscardUnknown() { + xxx_messageInfo_HeadSyncResult.DiscardUnknown(m) } -var xxx_messageInfo_DiffRange_Response proto.InternalMessageInfo +var xxx_messageInfo_HeadSyncResult proto.InternalMessageInfo -func (m *DiffRange_Response) GetResults() []*DiffRange_Response_Result { - if m != nil { - return m.Results - } - return nil -} - -type DiffRange_Response_Result struct { - Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` - Elements []*DiffRange_Response_Result_Element `protobuf:"bytes,2,rep,name=elements,proto3" json:"elements,omitempty"` - Count uint32 `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"` -} - -func (m *DiffRange_Response_Result) Reset() { *m = DiffRange_Response_Result{} } -func (m *DiffRange_Response_Result) String() string { return proto.CompactTextString(m) } -func (*DiffRange_Response_Result) ProtoMessage() {} -func (*DiffRange_Response_Result) Descriptor() ([]byte, []int) { - return fileDescriptor_11d78c2fb7c80384, []int{1, 1, 0} -} -func (m *DiffRange_Response_Result) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *DiffRange_Response_Result) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_DiffRange_Response_Result.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 *DiffRange_Response_Result) XXX_Merge(src proto.Message) { - xxx_messageInfo_DiffRange_Response_Result.Merge(m, src) -} -func (m *DiffRange_Response_Result) XXX_Size() int { - return m.Size() -} -func (m *DiffRange_Response_Result) XXX_DiscardUnknown() { - xxx_messageInfo_DiffRange_Response_Result.DiscardUnknown(m) -} - -var xxx_messageInfo_DiffRange_Response_Result proto.InternalMessageInfo - -func (m *DiffRange_Response_Result) GetHash() []byte { +func (m *HeadSyncResult) GetHash() []byte { if m != nil { return m.Hash } return nil } -func (m *DiffRange_Response_Result) GetElements() []*DiffRange_Response_Result_Element { +func (m *HeadSyncResult) GetElements() []*HeadSyncResultElement { if m != nil { return m.Elements } return nil } -func (m *DiffRange_Response_Result) GetCount() uint32 { +func (m *HeadSyncResult) GetCount() uint32 { if m != nil { return m.Count } return 0 } -type DiffRange_Response_Result_Element struct { +// HeadSyncResultElement presenting state of one object +type HeadSyncResultElement struct { Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` Head string `protobuf:"bytes,2,opt,name=head,proto3" json:"head,omitempty"` } -func (m *DiffRange_Response_Result_Element) Reset() { *m = DiffRange_Response_Result_Element{} } -func (m *DiffRange_Response_Result_Element) String() string { return proto.CompactTextString(m) } -func (*DiffRange_Response_Result_Element) ProtoMessage() {} -func (*DiffRange_Response_Result_Element) Descriptor() ([]byte, []int) { - return fileDescriptor_11d78c2fb7c80384, []int{1, 1, 0, 0} +func (m *HeadSyncResultElement) Reset() { *m = HeadSyncResultElement{} } +func (m *HeadSyncResultElement) String() string { return proto.CompactTextString(m) } +func (*HeadSyncResultElement) ProtoMessage() {} +func (*HeadSyncResultElement) Descriptor() ([]byte, []int) { + return fileDescriptor_11d78c2fb7c80384, []int{2} } -func (m *DiffRange_Response_Result_Element) XXX_Unmarshal(b []byte) error { +func (m *HeadSyncResultElement) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *DiffRange_Response_Result_Element) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *HeadSyncResultElement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_DiffRange_Response_Result_Element.Marshal(b, m, deterministic) + return xxx_messageInfo_HeadSyncResultElement.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -433,41 +193,137 @@ func (m *DiffRange_Response_Result_Element) XXX_Marshal(b []byte, deterministic return b[:n], nil } } -func (m *DiffRange_Response_Result_Element) XXX_Merge(src proto.Message) { - xxx_messageInfo_DiffRange_Response_Result_Element.Merge(m, src) +func (m *HeadSyncResultElement) XXX_Merge(src proto.Message) { + xxx_messageInfo_HeadSyncResultElement.Merge(m, src) } -func (m *DiffRange_Response_Result_Element) XXX_Size() int { +func (m *HeadSyncResultElement) XXX_Size() int { return m.Size() } -func (m *DiffRange_Response_Result_Element) XXX_DiscardUnknown() { - xxx_messageInfo_DiffRange_Response_Result_Element.DiscardUnknown(m) +func (m *HeadSyncResultElement) XXX_DiscardUnknown() { + xxx_messageInfo_HeadSyncResultElement.DiscardUnknown(m) } -var xxx_messageInfo_DiffRange_Response_Result_Element proto.InternalMessageInfo +var xxx_messageInfo_HeadSyncResultElement proto.InternalMessageInfo -func (m *DiffRange_Response_Result_Element) GetId() string { +func (m *HeadSyncResultElement) GetId() string { if m != nil { return m.Id } return "" } -func (m *DiffRange_Response_Result_Element) GetHead() string { +func (m *HeadSyncResultElement) GetHead() string { if m != nil { return m.Head } return "" } +// HeadSyncRequest is a request for HeadSync +type HeadSyncRequest struct { + SpaceId string `protobuf:"bytes,1,opt,name=spaceId,proto3" json:"spaceId,omitempty"` + Ranges []*HeadSyncRange `protobuf:"bytes,2,rep,name=ranges,proto3" json:"ranges,omitempty"` +} + +func (m *HeadSyncRequest) Reset() { *m = HeadSyncRequest{} } +func (m *HeadSyncRequest) String() string { return proto.CompactTextString(m) } +func (*HeadSyncRequest) ProtoMessage() {} +func (*HeadSyncRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_11d78c2fb7c80384, []int{3} +} +func (m *HeadSyncRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HeadSyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_HeadSyncRequest.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 *HeadSyncRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_HeadSyncRequest.Merge(m, src) +} +func (m *HeadSyncRequest) XXX_Size() int { + return m.Size() +} +func (m *HeadSyncRequest) XXX_DiscardUnknown() { + xxx_messageInfo_HeadSyncRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_HeadSyncRequest proto.InternalMessageInfo + +func (m *HeadSyncRequest) GetSpaceId() string { + if m != nil { + return m.SpaceId + } + return "" +} + +func (m *HeadSyncRequest) GetRanges() []*HeadSyncRange { + if m != nil { + return m.Ranges + } + return nil +} + +// HeadSyncResponse is a response for HeadSync +type HeadSyncResponse struct { + Results []*HeadSyncResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"` +} + +func (m *HeadSyncResponse) Reset() { *m = HeadSyncResponse{} } +func (m *HeadSyncResponse) String() string { return proto.CompactTextString(m) } +func (*HeadSyncResponse) ProtoMessage() {} +func (*HeadSyncResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_11d78c2fb7c80384, []int{4} +} +func (m *HeadSyncResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *HeadSyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_HeadSyncResponse.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 *HeadSyncResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_HeadSyncResponse.Merge(m, src) +} +func (m *HeadSyncResponse) XXX_Size() int { + return m.Size() +} +func (m *HeadSyncResponse) XXX_DiscardUnknown() { + xxx_messageInfo_HeadSyncResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_HeadSyncResponse proto.InternalMessageInfo + +func (m *HeadSyncResponse) GetResults() []*HeadSyncResult { + if m != nil { + return m.Results + } + return nil +} + func init() { - proto.RegisterType((*Space)(nil), "anytype.Space") - proto.RegisterType((*Space_Content)(nil), "anytype.Space.Content") - proto.RegisterType((*DiffRange)(nil), "anytype.DiffRange") - proto.RegisterType((*DiffRange_Request)(nil), "anytype.DiffRange.Request") - proto.RegisterType((*DiffRange_Request_Range)(nil), "anytype.DiffRange.Request.Range") - proto.RegisterType((*DiffRange_Response)(nil), "anytype.DiffRange.Response") - proto.RegisterType((*DiffRange_Response_Result)(nil), "anytype.DiffRange.Response.Result") - proto.RegisterType((*DiffRange_Response_Result_Element)(nil), "anytype.DiffRange.Response.Result.Element") + proto.RegisterEnum("anySpace.ErrCodes", ErrCodes_name, ErrCodes_value) + proto.RegisterType((*HeadSyncRange)(nil), "anySpace.HeadSyncRange") + proto.RegisterType((*HeadSyncResult)(nil), "anySpace.HeadSyncResult") + proto.RegisterType((*HeadSyncResultElement)(nil), "anySpace.HeadSyncResultElement") + proto.RegisterType((*HeadSyncRequest)(nil), "anySpace.HeadSyncRequest") + proto.RegisterType((*HeadSyncResponse)(nil), "anySpace.HeadSyncResponse") } func init() { @@ -475,37 +331,34 @@ func init() { } var fileDescriptor_11d78c2fb7c80384 = []byte{ - // 428 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0xbf, 0x8e, 0xd4, 0x30, - 0x10, 0xc6, 0xd7, 0xd9, 0x3f, 0xde, 0xcc, 0x02, 0x85, 0x85, 0x20, 0x0a, 0x52, 0x14, 0x6d, 0x15, - 0x21, 0xe1, 0x83, 0x80, 0x04, 0x05, 0x0d, 0x07, 0x9c, 0xa0, 0x35, 0x1d, 0x5d, 0xd8, 0x78, 0xef, - 0x22, 0x25, 0x76, 0x88, 0x9d, 0x93, 0xf6, 0x05, 0xa8, 0xe9, 0x79, 0x02, 0xde, 0x84, 0xf2, 0x4a, - 0x4a, 0xb4, 0xfb, 0x0a, 0x54, 0x54, 0x28, 0x93, 0x38, 0x57, 0xc0, 0x42, 0x13, 0xcd, 0x8c, 0x7f, - 0xdf, 0x97, 0x6f, 0x2c, 0x03, 0x37, 0xb2, 0xb9, 0x2c, 0x36, 0xf2, 0xc4, 0xd4, 0x99, 0xfb, 0x9a, - 0x9d, 0xda, 0x9c, 0xd4, 0x8d, 0xb6, 0xda, 0x5c, 0x0f, 0x38, 0x0e, 0x18, 0xcd, 0xd4, 0xce, 0xee, - 0x6a, 0xb9, 0xfe, 0x42, 0x60, 0xfe, 0xae, 0x3b, 0x64, 0x01, 0x50, 0xa4, 0xde, 0xe6, 0x01, 0x89, - 0x49, 0xe2, 0x0b, 0xd7, 0xb2, 0x87, 0x40, 0x2b, 0x69, 0x4c, 0x76, 0x2e, 0x03, 0x2f, 0x26, 0xc9, - 0x2a, 0xbd, 0xc3, 0x07, 0x39, 0x47, 0x29, 0x7f, 0xa9, 0x95, 0x95, 0xca, 0x0a, 0x87, 0x85, 0x67, - 0x40, 0x87, 0x19, 0x4b, 0xc1, 0xcf, 0x8b, 0xed, 0x56, 0x64, 0xea, 0x5c, 0xa2, 0xf1, 0x2a, 0x65, - 0xa3, 0xfc, 0x95, 0x3b, 0x79, 0x33, 0x11, 0xd7, 0xd8, 0x29, 0x85, 0xf9, 0x65, 0x56, 0xb6, 0x72, - 0xfd, 0x6b, 0x0a, 0xfe, 0xc8, 0xb0, 0x27, 0x40, 0x1b, 0xf9, 0xb1, 0x95, 0xc6, 0x0e, 0x46, 0xe1, - 0x9f, 0x46, 0x5c, 0xf4, 0x84, 0x70, 0x28, 0x7b, 0x0a, 0xcb, 0x46, 0x9a, 0x5a, 0x2b, 0xe3, 0xe2, - 0xdf, 0xfb, 0xab, 0xac, 0x47, 0xc4, 0x08, 0x87, 0x9f, 0x08, 0xd0, 0xc1, 0x8d, 0x3d, 0x83, 0x45, - 0xd3, 0x71, 0x26, 0x20, 0xf1, 0x34, 0x59, 0xa5, 0xf1, 0xf1, 0x3f, 0x73, 0xec, 0xc4, 0xc0, 0x87, - 0x2f, 0x60, 0xde, 0xa7, 0x67, 0x30, 0xdb, 0x36, 0xba, 0xc2, 0xe8, 0x33, 0x81, 0x35, 0xbb, 0x05, - 0x9e, 0xd5, 0x98, 0x6a, 0x26, 0x3c, 0xab, 0xd9, 0x6d, 0x98, 0x97, 0x45, 0x55, 0xd8, 0x60, 0x1a, - 0x93, 0xe4, 0xa6, 0xe8, 0x9b, 0xf0, 0x27, 0x81, 0xa5, 0xcb, 0xc7, 0x9e, 0x77, 0x97, 0x60, 0xda, - 0xd2, 0xba, 0x28, 0xeb, 0x7f, 0x6c, 0xd3, 0x15, 0x6d, 0x89, 0x97, 0x81, 0x92, 0xf0, 0x2b, 0x81, - 0x45, 0x3f, 0xeb, 0xf2, 0x5c, 0x64, 0xe6, 0x02, 0xf3, 0xdc, 0x10, 0x58, 0xb3, 0x33, 0x58, 0xca, - 0x52, 0x56, 0x52, 0x59, 0x13, 0x78, 0xe8, 0x7e, 0xff, 0xff, 0xee, 0xfc, 0x75, 0x2f, 0x11, 0xa3, - 0xb6, 0xdb, 0x63, 0xa3, 0x5b, 0x35, 0xee, 0x81, 0x4d, 0xf8, 0x00, 0xe8, 0x80, 0x76, 0x8b, 0x17, - 0xee, 0x9d, 0x79, 0x45, 0x8e, 0x61, 0x64, 0x96, 0xe3, 0x55, 0xf8, 0x02, 0xeb, 0xd3, 0x47, 0xdf, - 0xf6, 0x11, 0xb9, 0xda, 0x47, 0xe4, 0xc7, 0x3e, 0x22, 0x9f, 0x0f, 0xd1, 0xe4, 0xea, 0x10, 0x4d, - 0xbe, 0x1f, 0xa2, 0xc9, 0xfb, 0xbb, 0x47, 0x5e, 0xfb, 0x87, 0x05, 0xbe, 0xee, 0xc7, 0xbf, 0x03, - 0x00, 0x00, 0xff, 0xff, 0x12, 0x5a, 0x4f, 0xd6, 0x0f, 0x03, 0x00, 0x00, + // 369 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x92, 0xbf, 0x6e, 0xe2, 0x40, + 0x10, 0xc6, 0x6d, 0xf3, 0xcf, 0xcc, 0x1d, 0x1c, 0x5a, 0xdd, 0x09, 0x1f, 0x85, 0x0f, 0xb9, 0x42, + 0x57, 0x18, 0x85, 0x94, 0x54, 0x49, 0x44, 0x14, 0x52, 0x2e, 0x4a, 0x13, 0xa5, 0x71, 0xec, 0x49, + 0xb0, 0x04, 0xbb, 0x8e, 0x77, 0x49, 0xc2, 0x5b, 0xe4, 0xb1, 0x52, 0x52, 0xa6, 0x8c, 0xe0, 0x45, + 0x22, 0x0f, 0x31, 0x24, 0x92, 0x69, 0xac, 0x99, 0xf1, 0x7c, 0xdf, 0xfc, 0x76, 0x34, 0xe0, 0x2b, + 0x4c, 0x1f, 0xe3, 0x10, 0xfb, 0x2a, 0x09, 0xf2, 0xaf, 0x5a, 0x8a, 0xb0, 0x9f, 0xa4, 0x52, 0x4b, + 0xb5, 0x2f, 0xf8, 0x54, 0x60, 0x76, 0x20, 0x96, 0x93, 0xac, 0xe6, 0x8d, 0xa1, 0x71, 0x81, 0x41, + 0x34, 0x59, 0x8a, 0x90, 0x07, 0xe2, 0x1e, 0x19, 0x83, 0xf2, 0x5d, 0x2a, 0xe7, 0x8e, 0xd9, 0x35, + 0x7b, 0x65, 0x4e, 0x31, 0x6b, 0x82, 0xa5, 0xa5, 0x63, 0x51, 0xc5, 0xd2, 0x92, 0xfd, 0x86, 0xca, + 0x2c, 0x9e, 0xc7, 0xda, 0x29, 0x75, 0xcd, 0x5e, 0x83, 0x6f, 0x13, 0xef, 0x09, 0x9a, 0x3b, 0x2b, + 0x54, 0x8b, 0x99, 0xce, 0xbc, 0xa6, 0x81, 0x9a, 0x92, 0xd7, 0x4f, 0x4e, 0x31, 0x1b, 0x82, 0x8d, + 0x33, 0x9c, 0xa3, 0xd0, 0xca, 0xb1, 0xba, 0xa5, 0xde, 0x8f, 0xc1, 0x3f, 0x3f, 0xa7, 0xf1, 0xbf, + 0xeb, 0x47, 0xdb, 0x3e, 0xbe, 0x13, 0x64, 0x83, 0x43, 0xb9, 0x10, 0xbb, 0xc1, 0x94, 0x78, 0x43, + 0xf8, 0x53, 0x28, 0xcc, 0xb8, 0xe3, 0x88, 0xa6, 0xd7, 0xb9, 0x15, 0x47, 0xc4, 0x83, 0x41, 0x44, + 0x2f, 0xa9, 0x73, 0x8a, 0xbd, 0x1b, 0xf8, 0xb5, 0x17, 0x3f, 0x2c, 0x50, 0x69, 0xe6, 0x40, 0x8d, + 0x16, 0x36, 0xce, 0xb5, 0x79, 0xca, 0xfa, 0x50, 0x4d, 0xb3, 0x2d, 0xe5, 0xe8, 0xed, 0x02, 0xf4, + 0xec, 0x3f, 0xff, 0x6c, 0xf3, 0xce, 0xa1, 0xf5, 0x05, 0x2d, 0x91, 0x42, 0x21, 0x1b, 0x40, 0x2d, + 0x25, 0x4c, 0xe5, 0x98, 0xe4, 0xe2, 0x1c, 0x5a, 0x00, 0xcf, 0x1b, 0xff, 0x77, 0xc0, 0x1e, 0xa5, + 0xe9, 0x99, 0x8c, 0x50, 0xb1, 0x26, 0xc0, 0x95, 0xc0, 0xe7, 0x04, 0x43, 0x8d, 0x51, 0xcb, 0x18, + 0x5c, 0x42, 0x85, 0xc4, 0xec, 0x04, 0xec, 0x5c, 0xcf, 0xfe, 0x16, 0x79, 0xd2, 0xf3, 0x3a, 0x9d, + 0xc2, 0x71, 0xc4, 0x76, 0x7a, 0xf4, 0xba, 0x76, 0xcd, 0xd5, 0xda, 0x35, 0xdf, 0xd7, 0xae, 0xf9, + 0xb2, 0x71, 0x8d, 0xd5, 0xc6, 0x35, 0xde, 0x36, 0xae, 0x71, 0xdd, 0x3e, 0x70, 0x62, 0xb7, 0x55, + 0x3a, 0xa9, 0xe3, 0x8f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x09, 0x7e, 0xc8, 0x77, 0x84, 0x02, 0x00, + 0x00, } -func (m *Space) Marshal() (dAtA []byte, err error) { +func (m *HeadSyncRange) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -515,191 +368,12 @@ func (m *Space) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *Space) MarshalTo(dAtA []byte) (int, error) { +func (m *HeadSyncRange) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Space) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Message != nil { - { - size, err := m.Message.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintSpacesync(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if len(m.SpaceId) > 0 { - i -= len(m.SpaceId) - copy(dAtA[i:], m.SpaceId) - i = encodeVarintSpacesync(dAtA, i, uint64(len(m.SpaceId))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *Space_Content) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *Space_Content) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Space_Content) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Value != nil { - { - size := m.Value.Size() - i -= size - if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil { - return 0, err - } - } - } - return len(dAtA) - i, nil -} - -func (m *Space_Content_DiffRange) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *Space_Content_DiffRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - if m.DiffRange != nil { - { - size, err := m.DiffRange.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintSpacesync(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} -func (m *DiffRange) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *DiffRange) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DiffRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.Response != nil { - { - size, err := m.Response.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintSpacesync(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if m.Request != nil { - { - size, err := m.Request.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintSpacesync(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *DiffRange_Request) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *DiffRange_Request) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DiffRange_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Ranges) > 0 { - for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintSpacesync(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } - return len(dAtA) - i, nil -} - -func (m *DiffRange_Request_Range) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *DiffRange_Request_Range) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DiffRange_Request_Range) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *HeadSyncRange) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -722,7 +396,7 @@ func (m *DiffRange_Request_Range) MarshalToSizedBuffer(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *DiffRange_Response) Marshal() (dAtA []byte, err error) { +func (m *HeadSyncResult) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -732,49 +406,12 @@ func (m *DiffRange_Response) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *DiffRange_Response) MarshalTo(dAtA []byte) (int, error) { +func (m *HeadSyncResult) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DiffRange_Response) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.Results) > 0 { - for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.Results[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintSpacesync(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0xa - } - } - return len(dAtA) - i, nil -} - -func (m *DiffRange_Response_Result) Marshal() (dAtA []byte, err error) { - size := m.Size() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBuffer(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *DiffRange_Response_Result) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *DiffRange_Response_Result) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *HeadSyncResult) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -808,7 +445,7 @@ func (m *DiffRange_Response_Result) MarshalToSizedBuffer(dAtA []byte) (int, erro return len(dAtA) - i, nil } -func (m *DiffRange_Response_Result_Element) Marshal() (dAtA []byte, err error) { +func (m *HeadSyncResultElement) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -818,12 +455,12 @@ func (m *DiffRange_Response_Result_Element) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *DiffRange_Response_Result_Element) MarshalTo(dAtA []byte) (int, error) { +func (m *HeadSyncResultElement) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *DiffRange_Response_Result_Element) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *HeadSyncResultElement) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -845,6 +482,87 @@ func (m *DiffRange_Response_Result_Element) MarshalToSizedBuffer(dAtA []byte) (i return len(dAtA) - i, nil } +func (m *HeadSyncRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HeadSyncRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HeadSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Ranges) > 0 { + for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSpacesync(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.SpaceId) > 0 { + i -= len(m.SpaceId) + copy(dAtA[i:], m.SpaceId) + i = encodeVarintSpacesync(dAtA, i, uint64(len(m.SpaceId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *HeadSyncResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *HeadSyncResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *HeadSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.Results) > 0 { + for iNdEx := len(m.Results) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Results[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintSpacesync(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + } + return len(dAtA) - i, nil +} + func encodeVarintSpacesync(dAtA []byte, offset int, v uint64) int { offset -= sovSpacesync(v) base := offset @@ -856,80 +574,7 @@ func encodeVarintSpacesync(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } -func (m *Space) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.SpaceId) - if l > 0 { - n += 1 + l + sovSpacesync(uint64(l)) - } - if m.Message != nil { - l = m.Message.Size() - n += 1 + l + sovSpacesync(uint64(l)) - } - return n -} - -func (m *Space_Content) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Value != nil { - n += m.Value.Size() - } - return n -} - -func (m *Space_Content_DiffRange) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DiffRange != nil { - l = m.DiffRange.Size() - n += 1 + l + sovSpacesync(uint64(l)) - } - return n -} -func (m *DiffRange) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.Request != nil { - l = m.Request.Size() - n += 1 + l + sovSpacesync(uint64(l)) - } - if m.Response != nil { - l = m.Response.Size() - n += 1 + l + sovSpacesync(uint64(l)) - } - return n -} - -func (m *DiffRange_Request) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Ranges) > 0 { - for _, e := range m.Ranges { - l = e.Size() - n += 1 + l + sovSpacesync(uint64(l)) - } - } - return n -} - -func (m *DiffRange_Request_Range) Size() (n int) { +func (m *HeadSyncRange) Size() (n int) { if m == nil { return 0 } @@ -947,22 +592,7 @@ func (m *DiffRange_Request_Range) Size() (n int) { return n } -func (m *DiffRange_Response) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if len(m.Results) > 0 { - for _, e := range m.Results { - l = e.Size() - n += 1 + l + sovSpacesync(uint64(l)) - } - } - return n -} - -func (m *DiffRange_Response_Result) Size() (n int) { +func (m *HeadSyncResult) Size() (n int) { if m == nil { return 0 } @@ -984,7 +614,7 @@ func (m *DiffRange_Response_Result) Size() (n int) { return n } -func (m *DiffRange_Response_Result_Element) Size() (n int) { +func (m *HeadSyncResultElement) Size() (n int) { if m == nil { return 0 } @@ -1001,13 +631,47 @@ func (m *DiffRange_Response_Result_Element) Size() (n int) { return n } +func (m *HeadSyncRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.SpaceId) + if l > 0 { + n += 1 + l + sovSpacesync(uint64(l)) + } + if len(m.Ranges) > 0 { + for _, e := range m.Ranges { + l = e.Size() + n += 1 + l + sovSpacesync(uint64(l)) + } + } + return n +} + +func (m *HeadSyncResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.Results) > 0 { + for _, e := range m.Results { + l = e.Size() + n += 1 + l + sovSpacesync(uint64(l)) + } + } + return n +} + func sovSpacesync(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } func sozSpacesync(x uint64) (n int) { return sovSpacesync(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } -func (m *Space) Unmarshal(dAtA []byte) error { +func (m *HeadSyncRange) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1030,419 +694,10 @@ func (m *Space) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Space: wiretype end group for non-group") + return fmt.Errorf("proto: HeadSyncRange: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Space: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SpaceId", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSpacesync - } - 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 ErrInvalidLengthSpacesync - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthSpacesync - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.SpaceId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSpacesync - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthSpacesync - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthSpacesync - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Message == nil { - m.Message = &Space_Content{} - } - if err := m.Message.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipSpacesync(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthSpacesync - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *Space_Content) 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 ErrIntOverflowSpacesync - } - 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: Content: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Content: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DiffRange", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSpacesync - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthSpacesync - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthSpacesync - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - v := &DiffRange{} - if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Value = &Space_Content_DiffRange{v} - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipSpacesync(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthSpacesync - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DiffRange) 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 ErrIntOverflowSpacesync - } - 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: DiffRange: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DiffRange: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSpacesync - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthSpacesync - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthSpacesync - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Request == nil { - m.Request = &DiffRange_Request{} - } - if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Response", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSpacesync - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthSpacesync - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthSpacesync - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Response == nil { - m.Response = &DiffRange_Response{} - } - if err := m.Response.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipSpacesync(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthSpacesync - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DiffRange_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 ErrIntOverflowSpacesync - } - 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 != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSpacesync - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthSpacesync - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthSpacesync - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Ranges = append(m.Ranges, &DiffRange_Request_Range{}) - if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipSpacesync(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthSpacesync - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DiffRange_Request_Range) 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 ErrIntOverflowSpacesync - } - 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: Range: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Range: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: HeadSyncRange: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -1523,7 +778,7 @@ func (m *DiffRange_Request_Range) Unmarshal(dAtA []byte) error { } return nil } -func (m *DiffRange_Response) Unmarshal(dAtA []byte) error { +func (m *HeadSyncResult) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1546,94 +801,10 @@ func (m *DiffRange_Response) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Response: wiretype end group for non-group") + return fmt.Errorf("proto: HeadSyncResult: 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 != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Results", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowSpacesync - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthSpacesync - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthSpacesync - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Results = append(m.Results, &DiffRange_Response_Result{}) - if err := m.Results[len(m.Results)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipSpacesync(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthSpacesync - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *DiffRange_Response_Result) 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 ErrIntOverflowSpacesync - } - 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: Result: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: Result: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: HeadSyncResult: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -1699,7 +870,7 @@ func (m *DiffRange_Response_Result) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Elements = append(m.Elements, &DiffRange_Response_Result_Element{}) + m.Elements = append(m.Elements, &HeadSyncResultElement{}) if err := m.Elements[len(m.Elements)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } @@ -1744,7 +915,7 @@ func (m *DiffRange_Response_Result) Unmarshal(dAtA []byte) error { } return nil } -func (m *DiffRange_Response_Result_Element) Unmarshal(dAtA []byte) error { +func (m *HeadSyncResultElement) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1767,10 +938,10 @@ func (m *DiffRange_Response_Result_Element) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: Element: wiretype end group for non-group") + return fmt.Errorf("proto: HeadSyncResultElement: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: Element: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: HeadSyncResultElement: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -1858,6 +1029,206 @@ func (m *DiffRange_Response_Result_Element) Unmarshal(dAtA []byte) error { } return nil } +func (m *HeadSyncRequest) 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 ErrIntOverflowSpacesync + } + 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: HeadSyncRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HeadSyncRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SpaceId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSpacesync + } + 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 ErrInvalidLengthSpacesync + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthSpacesync + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.SpaceId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSpacesync + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSpacesync + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSpacesync + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Ranges = append(m.Ranges, &HeadSyncRange{}) + if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSpacesync(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSpacesync + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *HeadSyncResponse) 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 ErrIntOverflowSpacesync + } + 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: HeadSyncResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: HeadSyncResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Results", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowSpacesync + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthSpacesync + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthSpacesync + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Results = append(m.Results, &HeadSyncResult{}) + if err := m.Results[len(m.Results)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipSpacesync(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthSpacesync + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipSpacesync(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/service/space/spacesync/spacesync_drpc.pb.go b/service/space/spacesync/spacesync_drpc.pb.go new file mode 100644 index 00000000..a083c7e3 --- /dev/null +++ b/service/space/spacesync/spacesync_drpc.pb.go @@ -0,0 +1,113 @@ +// Code generated by protoc-gen-go-drpc. DO NOT EDIT. +// protoc-gen-go-drpc version: v0.0.32 +// source: service/space/spacesync/protos/spacesync.proto + +package spacesync + +import ( + bytes "bytes" + context "context" + errors "errors" + jsonpb "github.com/gogo/protobuf/jsonpb" + proto "github.com/gogo/protobuf/proto" + drpc "storj.io/drpc" + drpcerr "storj.io/drpc/drpcerr" +) + +type drpcEncoding_File_service_space_spacesync_protos_spacesync_proto struct{} + +func (drpcEncoding_File_service_space_spacesync_protos_spacesync_proto) Marshal(msg drpc.Message) ([]byte, error) { + return proto.Marshal(msg.(proto.Message)) +} + +func (drpcEncoding_File_service_space_spacesync_protos_spacesync_proto) Unmarshal(buf []byte, msg drpc.Message) error { + return proto.Unmarshal(buf, msg.(proto.Message)) +} + +func (drpcEncoding_File_service_space_spacesync_protos_spacesync_proto) JSONMarshal(msg drpc.Message) ([]byte, error) { + var buf bytes.Buffer + err := new(jsonpb.Marshaler).Marshal(&buf, msg.(proto.Message)) + if err != nil { + return nil, err + } + return buf.Bytes(), nil +} + +func (drpcEncoding_File_service_space_spacesync_protos_spacesync_proto) JSONUnmarshal(buf []byte, msg drpc.Message) error { + return jsonpb.Unmarshal(bytes.NewReader(buf), msg.(proto.Message)) +} + +type DRPCSpaceClient interface { + DRPCConn() drpc.Conn + + HeadSync(ctx context.Context, in *HeadSyncRequest) (*HeadSyncResponse, error) +} + +type drpcSpaceClient struct { + cc drpc.Conn +} + +func NewDRPCSpaceClient(cc drpc.Conn) DRPCSpaceClient { + return &drpcSpaceClient{cc} +} + +func (c *drpcSpaceClient) DRPCConn() drpc.Conn { return c.cc } + +func (c *drpcSpaceClient) HeadSync(ctx context.Context, in *HeadSyncRequest) (*HeadSyncResponse, error) { + out := new(HeadSyncResponse) + err := c.cc.Invoke(ctx, "/anySpace.Space/HeadSync", drpcEncoding_File_service_space_spacesync_protos_spacesync_proto{}, in, out) + if err != nil { + return nil, err + } + return out, nil +} + +type DRPCSpaceServer interface { + HeadSync(context.Context, *HeadSyncRequest) (*HeadSyncResponse, error) +} + +type DRPCSpaceUnimplementedServer struct{} + +func (s *DRPCSpaceUnimplementedServer) HeadSync(context.Context, *HeadSyncRequest) (*HeadSyncResponse, error) { + return nil, drpcerr.WithCode(errors.New("Unimplemented"), drpcerr.Unimplemented) +} + +type DRPCSpaceDescription struct{} + +func (DRPCSpaceDescription) NumMethods() int { return 1 } + +func (DRPCSpaceDescription) Method(n int) (string, drpc.Encoding, drpc.Receiver, interface{}, bool) { + switch n { + case 0: + return "/anySpace.Space/HeadSync", drpcEncoding_File_service_space_spacesync_protos_spacesync_proto{}, + func(srv interface{}, ctx context.Context, in1, in2 interface{}) (drpc.Message, error) { + return srv.(DRPCSpaceServer). + HeadSync( + ctx, + in1.(*HeadSyncRequest), + ) + }, DRPCSpaceServer.HeadSync, true + default: + return "", nil, nil, nil, false + } +} + +func DRPCRegisterSpace(mux drpc.Mux, impl DRPCSpaceServer) error { + return mux.Register(impl, DRPCSpaceDescription{}) +} + +type DRPCSpace_HeadSyncStream interface { + drpc.Stream + SendAndClose(*HeadSyncResponse) error +} + +type drpcSpace_HeadSyncStream struct { + drpc.Stream +} + +func (x *drpcSpace_HeadSyncStream) SendAndClose(m *HeadSyncResponse) error { + if err := x.MsgSend(m, drpcEncoding_File_service_space_spacesync_protos_spacesync_proto{}); err != nil { + return err + } + return x.CloseSend() +} diff --git a/syncproto/sync.pb.go b/syncproto/sync.pb.go index e8df4661..8fe415ab 100644 --- a/syncproto/sync.pb.go +++ b/syncproto/sync.pb.go @@ -503,10 +503,10 @@ func (m *Sync) GetMessage() *Sync_ContentValue { type Sync_ContentValue struct { // Types that are valid to be assigned to Value: - // *Sync_Content_Value_HeadUpdate - // *Sync_Content_Value_FullSyncRequest - // *Sync_Content_Value_FullSyncResponse - Value isSync_Content_Value_Value `protobuf_oneof:"value"` + // *Sync_ContentValue_HeadUpdate + // *Sync_ContentValue_FullSyncRequest + // *Sync_ContentValue_FullSyncResponse + Value isSync_ContentValue_Value `protobuf_oneof:"value"` } func (m *Sync_ContentValue) Reset() { *m = Sync_ContentValue{} } @@ -542,27 +542,27 @@ func (m *Sync_ContentValue) XXX_DiscardUnknown() { var xxx_messageInfo_Sync_ContentValue proto.InternalMessageInfo -type isSync_Content_Value_Value interface { - isSync_Content_Value_Value() +type isSync_ContentValue_Value interface { + isSync_ContentValue_Value() MarshalTo([]byte) (int, error) Size() int } -type Sync_Content_Value_HeadUpdate struct { +type Sync_ContentValue_HeadUpdate struct { HeadUpdate *Sync_HeadUpdate `protobuf:"bytes,1,opt,name=headUpdate,proto3,oneof" json:"headUpdate,omitempty"` } -type Sync_Content_Value_FullSyncRequest struct { +type Sync_ContentValue_FullSyncRequest struct { FullSyncRequest *Sync_Full_Request `protobuf:"bytes,2,opt,name=fullSyncRequest,proto3,oneof" json:"fullSyncRequest,omitempty"` } -type Sync_Content_Value_FullSyncResponse struct { +type Sync_ContentValue_FullSyncResponse struct { FullSyncResponse *Sync_Full_Response `protobuf:"bytes,3,opt,name=fullSyncResponse,proto3,oneof" json:"fullSyncResponse,omitempty"` } -func (*Sync_Content_Value_HeadUpdate) isSync_Content_Value_Value() {} -func (*Sync_Content_Value_FullSyncRequest) isSync_Content_Value_Value() {} -func (*Sync_Content_Value_FullSyncResponse) isSync_Content_Value_Value() {} +func (*Sync_ContentValue_HeadUpdate) isSync_ContentValue_Value() {} +func (*Sync_ContentValue_FullSyncRequest) isSync_ContentValue_Value() {} +func (*Sync_ContentValue_FullSyncResponse) isSync_ContentValue_Value() {} -func (m *Sync_ContentValue) GetValue() isSync_Content_Value_Value { +func (m *Sync_ContentValue) GetValue() isSync_ContentValue_Value { if m != nil { return m.Value } @@ -570,21 +570,21 @@ func (m *Sync_ContentValue) GetValue() isSync_Content_Value_Value { } func (m *Sync_ContentValue) GetHeadUpdate() *Sync_HeadUpdate { - if x, ok := m.GetValue().(*Sync_Content_Value_HeadUpdate); ok { + if x, ok := m.GetValue().(*Sync_ContentValue_HeadUpdate); ok { return x.HeadUpdate } return nil } func (m *Sync_ContentValue) GetFullSyncRequest() *Sync_Full_Request { - if x, ok := m.GetValue().(*Sync_Content_Value_FullSyncRequest); ok { + if x, ok := m.GetValue().(*Sync_ContentValue_FullSyncRequest); ok { return x.FullSyncRequest } return nil } func (m *Sync_ContentValue) GetFullSyncResponse() *Sync_Full_Response { - if x, ok := m.GetValue().(*Sync_Content_Value_FullSyncResponse); ok { + if x, ok := m.GetValue().(*Sync_ContentValue_FullSyncResponse); ok { return x.FullSyncResponse } return nil @@ -593,9 +593,9 @@ func (m *Sync_ContentValue) GetFullSyncResponse() *Sync_Full_Response { // XXX_OneofWrappers is for the internal use of the proto package. func (*Sync_ContentValue) XXX_OneofWrappers() []interface{} { return []interface{}{ - (*Sync_Content_Value_HeadUpdate)(nil), - (*Sync_Content_Value_FullSyncRequest)(nil), - (*Sync_Content_Value_FullSyncResponse)(nil), + (*Sync_ContentValue_HeadUpdate)(nil), + (*Sync_ContentValue_FullSyncRequest)(nil), + (*Sync_ContentValue_FullSyncResponse)(nil), } } @@ -1293,12 +1293,12 @@ func (m *Sync_ContentValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *Sync_Content_Value_HeadUpdate) MarshalTo(dAtA []byte) (int, error) { +func (m *Sync_ContentValue_HeadUpdate) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Sync_Content_Value_HeadUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Sync_ContentValue_HeadUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.HeadUpdate != nil { { @@ -1314,12 +1314,12 @@ func (m *Sync_Content_Value_HeadUpdate) MarshalToSizedBuffer(dAtA []byte) (int, } return len(dAtA) - i, nil } -func (m *Sync_Content_Value_FullSyncRequest) MarshalTo(dAtA []byte) (int, error) { +func (m *Sync_ContentValue_FullSyncRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Sync_Content_Value_FullSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Sync_ContentValue_FullSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.FullSyncRequest != nil { { @@ -1335,12 +1335,12 @@ func (m *Sync_Content_Value_FullSyncRequest) MarshalToSizedBuffer(dAtA []byte) ( } return len(dAtA) - i, nil } -func (m *Sync_Content_Value_FullSyncResponse) MarshalTo(dAtA []byte) (int, error) { +func (m *Sync_ContentValue_FullSyncResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *Sync_Content_Value_FullSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *Sync_ContentValue_FullSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) if m.FullSyncResponse != nil { { @@ -1759,7 +1759,7 @@ func (m *Sync_ContentValue) Size() (n int) { return n } -func (m *Sync_Content_Value_HeadUpdate) Size() (n int) { +func (m *Sync_ContentValue_HeadUpdate) Size() (n int) { if m == nil { return 0 } @@ -1771,7 +1771,7 @@ func (m *Sync_Content_Value_HeadUpdate) Size() (n int) { } return n } -func (m *Sync_Content_Value_FullSyncRequest) Size() (n int) { +func (m *Sync_ContentValue_FullSyncRequest) Size() (n int) { if m == nil { return 0 } @@ -1783,7 +1783,7 @@ func (m *Sync_Content_Value_FullSyncRequest) Size() (n int) { } return n } -func (m *Sync_Content_Value_FullSyncResponse) Size() (n int) { +func (m *Sync_ContentValue_FullSyncResponse) Size() (n int) { if m == nil { return 0 } @@ -2884,7 +2884,7 @@ func (m *Sync_ContentValue) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &Sync_Content_Value_HeadUpdate{v} + m.Value = &Sync_ContentValue_HeadUpdate{v} iNdEx = postIndex case 2: if wireType != 2 { @@ -2919,7 +2919,7 @@ func (m *Sync_ContentValue) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &Sync_Content_Value_FullSyncRequest{v} + m.Value = &Sync_ContentValue_FullSyncRequest{v} iNdEx = postIndex case 3: if wireType != 2 { @@ -2954,7 +2954,7 @@ func (m *Sync_ContentValue) Unmarshal(dAtA []byte) error { if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } - m.Value = &Sync_Content_Value_FullSyncResponse{v} + m.Value = &Sync_ContentValue_FullSyncResponse{v} iNdEx = postIndex default: iNdEx = preIndex