126 lines
3.2 KiB
Go
126 lines
3.2 KiB
Go
package remotediff
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/ldiff"
|
|
"github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/pool"
|
|
"github.com/anytypeio/go-anytype-infrastructure-experiments/service/space/spacesync"
|
|
"github.com/anytypeio/go-anytype-infrastructure-experiments/syncproto"
|
|
)
|
|
|
|
func NewRemoteDiff(p pool.Pool, peerId, spaceId string) ldiff.Remote {
|
|
return remote{
|
|
pool: p,
|
|
peerId: peerId,
|
|
spaceId: spaceId,
|
|
}
|
|
}
|
|
|
|
type remote struct {
|
|
pool pool.Pool
|
|
peerId string
|
|
spaceId string
|
|
}
|
|
|
|
func (r remote) Ranges(ctx context.Context, ranges []ldiff.Range, resBuf []ldiff.RangeResult) (results []ldiff.RangeResult, err error) {
|
|
results = resBuf[:0]
|
|
pbRanges := make([]*spacesync.DiffRange_Request_Range, 0, len(ranges))
|
|
for _, rg := range ranges {
|
|
pbRanges = append(pbRanges, &spacesync.DiffRange_Request_Range{
|
|
From: rg.From,
|
|
To: rg.To,
|
|
Limit: uint32(rg.Limit),
|
|
})
|
|
}
|
|
req := &spacesync.Space{
|
|
SpaceId: r.spaceId,
|
|
Message: &spacesync.Space_Content{
|
|
Value: &spacesync.Space_Content_DiffRange{
|
|
DiffRange: &spacesync.DiffRange{
|
|
Request: &spacesync.DiffRange_Request{
|
|
Ranges: pbRanges,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
msg, err := req.Marshal()
|
|
if err != nil {
|
|
return
|
|
}
|
|
resp, err := r.pool.SendAndWaitResponse(ctx, r.peerId, &syncproto.Message{
|
|
Header: &syncproto.Header{
|
|
Type: syncproto.MessageType_MessageTypeSpace,
|
|
},
|
|
Data: msg,
|
|
})
|
|
if err != nil {
|
|
return
|
|
}
|
|
var spaceResp = &spacesync.Space{}
|
|
if err = resp.UnmarshalData(spaceResp); err != nil {
|
|
return
|
|
}
|
|
rangeResp := spaceResp.GetMessage().GetDiffRange().GetResponse()
|
|
if rangeResp != nil {
|
|
return nil, fmt.Errorf("got nil response")
|
|
}
|
|
for _, rr := range rangeResp.Results {
|
|
var elms []ldiff.Element
|
|
if len(rr.Elements) > 0 {
|
|
elms = make([]ldiff.Element, 0, len(rr.Elements))
|
|
}
|
|
results = append(results, ldiff.RangeResult{
|
|
Hash: rr.Hash,
|
|
Elements: elms,
|
|
Count: int(rr.Count),
|
|
})
|
|
}
|
|
return
|
|
}
|
|
|
|
func HandlerRangeRequest(ctx context.Context, d ldiff.Diff, diffRange *spacesync.DiffRange) (resp *spacesync.DiffRange, err error) {
|
|
req := diffRange.GetRequest()
|
|
if req != nil {
|
|
return nil, fmt.Errorf("received nil request")
|
|
}
|
|
|
|
ranges := make([]ldiff.Range, 0, len(req.Ranges))
|
|
for _, reqRange := range req.Ranges {
|
|
ranges = append(ranges, ldiff.Range{
|
|
From: reqRange.From,
|
|
To: reqRange.To,
|
|
Limit: int(reqRange.Limit),
|
|
})
|
|
}
|
|
res, err := d.Ranges(ctx, ranges, nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var rangeResp = &spacesync.DiffRange_Response{
|
|
Results: make([]*spacesync.DiffRange_Response_Result, len(res)),
|
|
}
|
|
for _, rangeRes := range res {
|
|
var elements []*spacesync.DiffRange_Response_Result_Element
|
|
if len(rangeRes.Elements) > 0 {
|
|
elements = make([]*spacesync.DiffRange_Response_Result_Element, 0, len(rangeRes.Elements))
|
|
for _, el := range rangeRes.Elements {
|
|
elements = append(elements, &spacesync.DiffRange_Response_Result_Element{
|
|
Id: el.Id,
|
|
Head: el.Head,
|
|
})
|
|
}
|
|
}
|
|
rangeResp.Results = append(rangeResp.Results, &spacesync.DiffRange_Response_Result{
|
|
Hash: rangeRes.Hash,
|
|
Elements: elements,
|
|
Count: uint32(rangeRes.Count),
|
|
})
|
|
}
|
|
return &spacesync.DiffRange{
|
|
Response: rangeResp,
|
|
}, nil
|
|
}
|