anyproto/any-sync
1
0
Fork 0
mirror of https://github.com/anyproto/any-sync.git synced 2025-06-12 02:30:41 +09:00
Code Activity

Fix replyId update and add goroutine in handleMessage

Browse source
This commit is contained in:
mcrakhman 2022-08-05 21:05:47 +02:00 • committed by Mikhail Iudin
parent 1c81926f35
commit 1a892b05cf
No known key found for this signature in database
GPG key ID: FAAAA8BAABDFF1C0
8 changed files with 158 additions and 101 deletions
Download patch file Download diff file Expand all files Collapse all files

4
service/api/service.go
View file

@ -98,7 +98,7 @@ func (s *service) createDocument(w http.ResponseWriter, req *http.Request) {
query = req.URL.Query()
text = query.Get("text")
)
timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*5)
timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*30)
treeId, err := s.documentService.CreateDocument(timeoutCtx, fmt.Sprintf("created document with id: %s", text))
cancel()
if err != nil {
@ -114,7 +114,7 @@ func (s *service) appendDocument(w http.ResponseWriter, req *http.Request) {
text = query.Get("text")
treeId = query.Get("treeId")
)
timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*5)
timeoutCtx, cancel := context.WithTimeout(context.Background(), time.Second*30)
err := s.documentService.UpdateDocument(timeoutCtx, treeId, text)
cancel()
if err != nil {

2
service/net/pool/message.go
View file

@ -3,6 +3,7 @@ package pool
import (
"github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/peer"
"github.com/anytypeio/go-anytype-infrastructure-experiments/syncproto"
"go.uber.org/zap"
"gopkg.in/mgo.v2/bson"
)
@ -43,6 +44,7 @@ func (m *Message) Ack() (err error) {
},
Data: data,
}
log.With(zap.String("header", rep.Header.String())).Info("sending ack to peer")
return m.peer.Send(rep)
}

40
service/net/pool/pool.go
View file

@ -15,7 +15,10 @@ import (
"sync/atomic"
)
const CName = "sync/peerPool"
const (
CName = "sync/peerPool"
maxSimultaneousOperationsPerStream = 10
)
var log = logger.NewNamed("peerPool")
@ -45,7 +48,7 @@ type Pool interface {
type pool struct {
peersById map[string]*peerEntry
waiters waiters
waiters *waiters
handlers map[syncproto.MessageType][]Handler
peersIdsByGroup map[string][]string
@ -60,7 +63,7 @@ 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.waiters = &waiters{waiters: map[uint64]*waiter{}}
p.dialer = a.MustComponent(dialer.CName).(dialer.Dialer)
p.wg = &sync.WaitGroup{}
return nil
@ -160,6 +163,7 @@ func (p *pool) SendAndWait(ctx context.Context, peerId string, msg *syncproto.Me
repId := p.waiters.NewReplyId()
msg.GetHeader().RequestId = repId
ch := make(chan Reply, 1)
log.With(zap.Uint64("reply id", repId)).Debug("adding waiter for reply id")
p.waiters.Add(repId, &waiter{ch: ch})
defer p.waiters.Remove(repId)
if err = peer.peer.Send(msg); err != nil {
@ -172,24 +176,41 @@ func (p *pool) SendAndWait(ctx context.Context, peerId string, msg *syncproto.Me
}
return nil
case <-ctx.Done():
log.Debug("context error happened in send and wait")
return ctx.Err()
}
}
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()))
@ -209,7 +230,8 @@ func (p *pool) removePeer(peerId string) (err error) {
}
func (p *pool) handleMessage(peer peer.Peer, msg *syncproto.Message) {
log.With(zap.String("peerId", peer.Id())).Debug("received message from peer")
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{
@ -219,7 +241,7 @@ func (p *pool) handleMessage(peer peer.Peer, msg *syncproto.Message) {
peer: peer,
},
}) {
log.Debug("received reply with unknown (or expired) replyId", zap.Uint64("replyId", replyId))
log.Debug("received reply with unknown (or expired) replyId", zap.Uint64("replyId", replyId), zap.String("header", msg.GetHeader().String()))
}
return
}
@ -262,7 +284,7 @@ type waiters struct {
mu sync.Mutex
}
func (w waiters) Send(replyId uint64, r Reply) (ok bool) {
func (w *waiters) Send(replyId uint64, r Reply) (ok bool) {
w.mu.Lock()
wait := w.waiters[replyId]
if wait == nil {
@ -282,13 +304,13 @@ func (w waiters) Send(replyId uint64, r Reply) (ok bool) {
return true
}
func (w waiters) Add(replyId uint64, wait *waiter) {
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 {
func (w *waiters) Remove(id uint64) error {
w.mu.Lock()
defer w.mu.Unlock()
if _, ok := w.waiters[id]; ok {
@ -298,7 +320,7 @@ func (w waiters) Remove(id uint64) error {
return fmt.Errorf("waiter not found")
}
func (w waiters) NewReplyId() uint64 {
func (w *waiters) NewReplyId() uint64 {
res := atomic.AddUint64(&w.replySeq, 1)
if res == 0 {
return w.NewReplyId()

45
service/sync/message/service.go
View file

@ -63,6 +63,9 @@ func (s *service) HandleMessage(ctx context.Context, msg *pool.Message) (err err
if err != nil {
log.With(zap.String("peerId", msg.Peer().Id()), zap.Error(err)).
Error("could not ack message")
} else {
log.With(zap.String("peerId", msg.Peer().Id()), zap.Int("type", int(msg.Header.Type))).
Debug("ack returned")
}
syncMsg := &syncproto.Sync{}
err = proto.Unmarshal(msg.Data, syncMsg)
@ -70,7 +73,7 @@ func (s *service) HandleMessage(ctx context.Context, msg *pool.Message) (err err
return err
}
timeoutCtx, cancel := context.WithTimeout(ctx, time.Second*5)
timeoutCtx, cancel := context.WithTimeout(ctx, time.Second*30)
defer cancel()
return s.requestHandler.HandleSyncMessage(timeoutCtx, msg.Peer().Id(), syncMsg)
}
@ -95,50 +98,26 @@ func (s *service) SendMessage(ctx context.Context, peerId string, msg *syncproto
Header: &syncproto.Header{Type: syncproto.MessageType_MessageTypeSync},
Data: marshalled,
})
if err != nil {
log.With(
zap.String("peerId", peerId),
zap.String("message", msgType(msg)),
zap.Error(err)).
Error("failed to send message to peer")
Debug("failed to send message to peer")
} else {
log.With(
zap.String("peerId", peerId),
zap.String("message", msgType(msg))).
Debug("message send to peer completed")
}
return err
}
func (s *service) SendToSpace(ctx context.Context, spaceId string, msg *syncproto.Sync) error {
// dial manually to all peers
for _, rp := range s.nodes {
if er := s.pool.DialAndAddPeer(context.Background(), rp.PeerId); er != nil {
log.Info("can't dial to peer", zap.Error(er))
} else {
log.Info("connected with peer", zap.String("peerId", rp.PeerId))
s.SendMessage(ctx, rp.PeerId, msg)
}
}
marshalled, err := proto.Marshal(msg)
if err != nil {
return err
}
// TODO: use Broadcast method here when it is ready
for _, n := range s.nodes {
log.With(
zap.String("peerId", n.PeerId),
zap.String("message", msgType(msg))).
Debug("sending message to peer")
err := s.pool.SendAndWait(ctx, n.PeerId, &syncproto.Message{
Header: &syncproto.Header{Type: syncproto.MessageType_MessageTypeSync},
Data: marshalled,
})
if err != nil {
log.With(
zap.String("peerId", n.PeerId),
zap.String("message", msgType(msg)),
zap.Error(err)).
Error("failed to send message to peer")
}
}
return nil
}

2
service/sync/requesthandler/requesthandler.go
View file

@ -164,7 +164,7 @@ func (r *requestHandler) HandleFullSyncRequest(ctx context.Context, senderId str
TreeId: request.TreeId,
TreeHeader: request.TreeHeader,
}
return r.messageService.SendToSpace(ctx, "", syncproto.WrapHeadUpdate(newUpdate))
return r.messageService.SendToSpace(ctx, "def", syncproto.WrapHeadUpdate(newUpdate))
}
func (r *requestHandler) HandleFullSyncResponse(ctx context.Context, senderId string, response *syncproto.SyncFullResponse) (err error) {

1
service/treecache/service.go
View file

@ -15,6 +15,7 @@ import (
const CName = "treecache"
// TODO: add context
type ACLTreeFunc = func(tree acltree.ACLTree) error
type ChangeBuildFunc = func(builder acltree.ChangeBuilder) error

1
syncproto/proto/sync.proto
View file

@ -15,6 +15,7 @@ message Header {
uint64 requestId = 2;
uint64 replyId = 3;
MessageType type = 4;
string debugInfo = 5;
}
enum MessageType {

162
syncproto/sync.pb.go
View file

@ -134,6 +134,7 @@ type Header struct {
RequestId uint64 `protobuf:"varint,2,opt,name=requestId,proto3" json:"requestId,omitempty"`
ReplyId uint64 `protobuf:"varint,3,opt,name=replyId,proto3" json:"replyId,omitempty"`
Type MessageType `protobuf:"varint,4,opt,name=type,proto3,enum=anytype.MessageType" json:"type,omitempty"`
DebugInfo string `protobuf:"bytes,5,opt,name=debugInfo,proto3" json:"debugInfo,omitempty"`
}
func (m *Header) Reset() { *m = Header{} }
@ -197,6 +198,13 @@ func (m *Header) GetType() MessageType {
return MessageType_MessageTypeSystem
}
func (m *Header) GetDebugInfo() string {
if m != nil {
return m.DebugInfo
}
return ""
}
type System struct {
Handshake *SystemHandshake `protobuf:"bytes,1,opt,name=handshake,proto3" json:"handshake,omitempty"`
Ping *SystemPing `protobuf:"bytes,2,opt,name=ping,proto3" json:"ping,omitempty"`
@ -1020,61 +1028,62 @@ func init() {
func init() { proto.RegisterFile("syncproto/proto/sync.proto", fileDescriptor_4b28dfdd48a89166) }
var fileDescriptor_4b28dfdd48a89166 = []byte{
// 851 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x41, 0x8f, 0xdb, 0x44,
0x14, 0xb6, 0x13, 0x27, 0x6e, 0x5e, 0xa2, 0xac, 0x99, 0xb6, 0x60, 0xdc, 0x2a, 0x8a, 0xac, 0x02,
0x51, 0xa9, 0xbc, 0x55, 0xa0, 0x42, 0xe2, 0xd6, 0x2e, 0xbb, 0x4a, 0x44, 0x49, 0xa2, 0x49, 0xb2,
0x48, 0x5c, 0xaa, 0x59, 0x7b, 0x48, 0xa2, 0x78, 0xc7, 0xc6, 0xe3, 0x00, 0xb9, 0x73, 0xe2, 0xd4,
0x1f, 0x83, 0x04, 0xe2, 0x17, 0x70, 0xec, 0x91, 0x23, 0xda, 0x95, 0xf8, 0x11, 0x70, 0xa9, 0x66,
0xc6, 0x4e, 0xbc, 0x6e, 0xfa, 0x03, 0x7a, 0xd8, 0xcd, 0xbc, 0xef, 0x7d, 0xdf, 0x9b, 0xef, 0x8d,
0x3d, 0x2f, 0x01, 0x87, 0x6f, 0x99, 0x1f, 0x27, 0x51, 0x1a, 0x1d, 0xab, 0xff, 0x22, 0xf6, 0xe4,
0x12, 0x99, 0x84, 0x6d, 0xd3, 0x6d, 0x4c, 0x9d, 0xc7, 0xf1, 0x7a, 0x71, 0x4c, 0xfc, 0x50, 0xfc,
0xf9, 0x4b, 0xc2, 0x16, 0x94, 0x8b, 0x65, 0x7c, 0xa1, 0x34, 0xbc, 0x80, 0x2b, 0xa9, 0xf3, 0x28,
0x57, 0xa4, 0x09, 0xa5, 0x3c, 0x8d, 0x12, 0xb2, 0xa0, 0x72, 0xbd, 0xd7, 0x88, 0x48, 0xb1, 0xdd,
0x33, 0x30, 0xbf, 0xa1, 0x9c, 0x93, 0x05, 0x45, 0x9f, 0x40, 0x7d, 0x49, 0x49, 0x40, 0x13, 0x5b,
0xef, 0xea, 0xbd, 0x66, 0xff, 0xc8, 0xcb, 0x4c, 0x78, 0x03, 0x09, 0xe3, 0x2c, 0x8d, 0x10, 0x18,
0x01, 0x49, 0x89, 0x5d, 0xe9, 0xea, 0xbd, 0x16, 0x96, 0x6b, 0xf7, 0x17, 0x1d, 0xea, 0x8a, 0x86,
0x6c, 0x30, 0xd3, 0x84, 0xf8, 0x74, 0x18, 0xc8, 0x42, 0x2d, 0x9c, 0x87, 0xe8, 0x3e, 0x34, 0x12,
0xfa, 0xc3, 0x86, 0xf2, 0x74, 0x18, 0x48, 0xb5, 0x81, 0xf7, 0x80, 0xd0, 0x25, 0x34, 0x0e, 0xb7,
0xc3, 0xc0, 0xae, 0xca, 0x5c, 0x1e, 0xa2, 0x1e, 0x18, 0xc2, 0x87, 0x6d, 0x74, 0xf5, 0x5e, 0xbb,
0x7f, 0x67, 0xe7, 0x2b, 0x73, 0x3e, 0xdb, 0xc6, 0x14, 0x4b, 0x86, 0xfb, 0x5b, 0x15, 0xea, 0xd3,
0x2d, 0x4f, 0xe9, 0x25, 0xfa, 0x02, 0x1a, 0x4b, 0xc2, 0x02, 0xbe, 0x24, 0x6b, 0x9a, 0x75, 0xf4,
0xe1, 0x4e, 0xa9, 0x38, 0xde, 0x20, 0x27, 0xe0, 0x3d, 0x57, 0xec, 0x16, 0xaf, 0xd8, 0x42, 0x1a,
0x6c, 0x16, 0x76, 0xcb, 0x34, 0x93, 0x15, 0x5b, 0x60, 0xc9, 0x40, 0x1f, 0x41, 0x95, 0xf8, 0x6b,
0xe9, 0xb6, 0xd9, 0xbf, 0x5d, 0x26, 0x3e, 0xf5, 0xd7, 0x58, 0xe4, 0x9d, 0x27, 0xd0, 0x18, 0x14,
0xaa, 0x1f, 0xc9, 0x93, 0xf7, 0xa3, 0xf0, 0x9c, 0x26, 0x7c, 0x15, 0x31, 0x69, 0xae, 0x81, 0xcb,
0xb0, 0xe3, 0x82, 0x21, 0xf6, 0x42, 0x0e, 0xdc, 0xda, 0xb0, 0xd5, 0xcf, 0xb3, 0xd5, 0xa5, 0xea,
0xc3, 0xc0, 0xbb, 0xd8, 0xe9, 0x43, 0xf5, 0xa9, 0xbf, 0x46, 0x9f, 0x42, 0x8d, 0x26, 0x49, 0x94,
0x64, 0x9e, 0xef, 0x96, 0xad, 0x9c, 0x8a, 0x24, 0x56, 0x1c, 0xe7, 0xa5, 0x0e, 0x35, 0x09, 0x20,
0x0f, 0x0c, 0x3f, 0x0a, 0x54, 0xd5, 0x76, 0xdf, 0x39, 0xa8, 0xf2, 0x4e, 0xa2, 0x80, 0x62, 0xc9,
0x43, 0x5d, 0x68, 0x06, 0x94, 0xfb, 0xc9, 0x2a, 0x4e, 0x85, 0xef, 0x8a, 0xf4, 0x5d, 0x84, 0xdc,
0x27, 0x60, 0x08, 0x3e, 0x6a, 0x82, 0x39, 0x1f, 0x7d, 0x3d, 0x1a, 0x7f, 0x3b, 0xb2, 0x34, 0xd4,
0x85, 0xfb, 0xf3, 0xd1, 0x74, 0x3e, 0x99, 0x8c, 0xf1, 0xec, 0xf4, 0xab, 0x17, 0x13, 0x3c, 0x9e,
0x8d, 0x4f, 0xc6, 0xcf, 0x5f, 0x9c, 0x9f, 0xe2, 0xe9, 0x70, 0x3c, 0xb2, 0xc0, 0xfd, 0xb5, 0x02,
0xad, 0xe9, 0xe6, 0x62, 0x57, 0x07, 0x3d, 0x87, 0x36, 0x57, 0xf1, 0x05, 0x9d, 0xc6, 0xc4, 0xcf,
0x9f, 0xe0, 0x83, 0xbd, 0xc7, 0x02, 0x3d, 0x0f, 0x32, 0x2e, 0x2e, 0x69, 0x11, 0x06, 0x6b, 0xc3,
0x4a, 0xf5, 0xd4, 0x49, 0x7d, 0x7c, 0xb8, 0xde, 0xbc, 0xc4, 0xc6, 0x6f, 0xe8, 0x9d, 0x87, 0xd0,
0xbe, 0xb9, 0xab, 0x78, 0x7f, 0x79, 0xbc, 0x7f, 0xef, 0x1b, 0x38, 0x0f, 0x9d, 0x47, 0x60, 0x95,
0x2b, 0xbe, 0x9d, 0xed, 0xfe, 0x57, 0x07, 0x63, 0xba, 0x65, 0xfe, 0xdb, 0x29, 0xe8, 0x73, 0x30,
0x2f, 0xd5, 0xbb, 0x9f, 0xf5, 0x51, 0x7c, 0x76, 0xcc, 0xf7, 0x4e, 0x22, 0x96, 0x52, 0x96, 0x9e,
0x93, 0x70, 0x43, 0x71, 0x4e, 0x75, 0xfe, 0xd5, 0xa1, 0x55, 0xcc, 0xa0, 0x2f, 0x01, 0xc4, 0x95,
0x9e, 0xc7, 0x01, 0x49, 0xf3, 0x13, 0xb6, 0x6f, 0x56, 0x1a, 0xec, 0xf2, 0x03, 0x0d, 0x17, 0xd8,
0xe8, 0x0c, 0x8e, 0xbe, 0xdf, 0x84, 0xa1, 0x20, 0x61, 0x75, 0x85, 0x0f, 0x5b, 0x39, 0xdb, 0x84,
0xa1, 0x97, 0x31, 0x06, 0x1a, 0x2e, 0x8b, 0xd0, 0x10, 0xac, 0x3d, 0xc4, 0xe3, 0x88, 0x71, 0x9a,
0x5d, 0xa8, 0x7b, 0x07, 0x0b, 0x29, 0xca, 0x40, 0xc3, 0x6f, 0xc8, 0x9e, 0x99, 0x50, 0xfb, 0x51,
0xf4, 0xe5, 0xfc, 0xa9, 0x03, 0xec, 0x8d, 0xa3, 0x3b, 0x50, 0x13, 0xc6, 0xb9, 0xad, 0x77, 0xab,
0xbd, 0x06, 0x56, 0x01, 0xea, 0x81, 0x99, 0x0d, 0x4e, 0xbb, 0xd2, 0xad, 0xf6, 0x9a, 0xfd, 0xb6,
0x47, 0xfc, 0xd0, 0xc3, 0xe4, 0xa7, 0x13, 0x09, 0xe3, 0x3c, 0x8d, 0xde, 0x87, 0xba, 0x98, 0x98,
0xd9, 0x5c, 0x6a, 0xe0, 0x2c, 0x42, 0x2e, 0xb4, 0x38, 0x23, 0x31, 0x5f, 0x46, 0xe9, 0x84, 0xa4,
0x4b, 0xdb, 0x90, 0xe5, 0x6f, 0x60, 0xe8, 0x31, 0x80, 0x60, 0xab, 0xd1, 0x68, 0xd7, 0x64, 0x63,
0x96, 0x27, 0x07, 0xf0, 0x6c, 0x87, 0xe3, 0x02, 0xc7, 0xf9, 0xbf, 0x02, 0x86, 0xe8, 0xd5, 0xf9,
0x5d, 0x07, 0x33, 0x3f, 0xa5, 0x77, 0xab, 0x85, 0x3f, 0x74, 0xb8, 0x95, 0x3f, 0x95, 0x77, 0xcb,
0xfa, 0xc3, 0x73, 0x68, 0x16, 0xbe, 0x55, 0xd0, 0x5d, 0x78, 0xaf, 0x10, 0xaa, 0xb9, 0x68, 0x69,
0xe8, 0x1e, 0x7c, 0x50, 0x84, 0x0b, 0xa3, 0xc3, 0xd2, 0xd1, 0x6d, 0x38, 0xba, 0xa1, 0x61, 0xbe,
0x55, 0x79, 0xf6, 0xe0, 0xaf, 0xab, 0x8e, 0xfe, 0xea, 0xaa, 0xa3, 0xff, 0x73, 0xd5, 0xd1, 0x5f,
0x5e, 0x77, 0xb4, 0x57, 0xd7, 0x1d, 0xed, 0xef, 0xeb, 0x8e, 0xf6, 0x1d, 0x1c, 0xef, 0x7e, 0x07,
0x5c, 0xd4, 0xe5, 0xc7, 0x67, 0xaf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x41, 0xe9, 0x79, 0xe5, 0x1b,
0x08, 0x00, 0x00,
// 868 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xd1, 0x8e, 0xda, 0x46,
0x14, 0x65, 0xc0, 0x40, 0xb8, 0x20, 0xd6, 0x9d, 0x24, 0xad, 0xeb, 0x44, 0x08, 0xa1, 0xb4, 0x45,
0x69, 0xe4, 0x8d, 0x68, 0xa3, 0x4a, 0x7d, 0x4b, 0xb6, 0xbb, 0x02, 0x35, 0x05, 0x34, 0xc0, 0x56,
0xea, 0x4b, 0x34, 0xd8, 0x13, 0x40, 0x78, 0xc7, 0xae, 0xc7, 0xb4, 0xe5, 0x17, 0xfa, 0x94, 0x6f,
0xe8, 0x37, 0x54, 0x6a, 0xd5, 0x2f, 0xe8, 0x63, 0x1e, 0xfb, 0x58, 0xed, 0x4a, 0xfd, 0x88, 0xf6,
0xa5, 0x9a, 0x19, 0x1b, 0x7b, 0x9d, 0xcd, 0x07, 0xe4, 0x01, 0x98, 0x7b, 0xee, 0x39, 0xd7, 0xe7,
0xce, 0x30, 0x17, 0xc0, 0x16, 0x7b, 0xee, 0x86, 0x51, 0x10, 0x07, 0xc7, 0xfa, 0x5d, 0xc6, 0x8e,
0x5a, 0xe2, 0x3a, 0xe5, 0xfb, 0x78, 0x1f, 0x32, 0xfb, 0x71, 0xb8, 0x5d, 0x1d, 0x53, 0xd7, 0x97,
0x2f, 0x77, 0x4d, 0xf9, 0x8a, 0x09, 0xb9, 0x0c, 0x97, 0x5a, 0x23, 0x72, 0xb8, 0x96, 0xda, 0x8f,
0x52, 0x45, 0x1c, 0x31, 0x26, 0xe2, 0x20, 0xa2, 0x2b, 0xa6, 0xd6, 0x99, 0x46, 0x46, 0x9a, 0xdd,
0x3b, 0x83, 0xfa, 0x37, 0x4c, 0x08, 0xba, 0x62, 0xf8, 0x13, 0xa8, 0xad, 0x19, 0xf5, 0x58, 0x64,
0xa1, 0x2e, 0xea, 0x37, 0x07, 0x47, 0x4e, 0x62, 0xc2, 0x19, 0x2a, 0x98, 0x24, 0x69, 0x8c, 0xc1,
0xf0, 0x68, 0x4c, 0xad, 0x72, 0x17, 0xf5, 0x5b, 0x44, 0xad, 0x7b, 0xbf, 0x20, 0xa8, 0x69, 0x1a,
0xb6, 0xa0, 0x1e, 0x47, 0xd4, 0x65, 0x23, 0x4f, 0x15, 0x6a, 0x91, 0x34, 0xc4, 0xf7, 0xa1, 0x11,
0xb1, 0xef, 0x77, 0x4c, 0xc4, 0x23, 0x4f, 0xa9, 0x0d, 0x92, 0x01, 0x52, 0x17, 0xb1, 0xd0, 0xdf,
0x8f, 0x3c, 0xab, 0xa2, 0x72, 0x69, 0x88, 0xfb, 0x60, 0x48, 0x1f, 0x96, 0xd1, 0x45, 0xfd, 0xf6,
0xe0, 0xce, 0xc1, 0x57, 0xe2, 0x7c, 0xbe, 0x0f, 0x19, 0x51, 0x0c, 0xf9, 0x04, 0x8f, 0x2d, 0x77,
0xab, 0x11, 0x7f, 0x19, 0x58, 0xd5, 0x2e, 0xea, 0x37, 0x48, 0x06, 0xf4, 0x7e, 0xad, 0x40, 0x6d,
0xb6, 0x17, 0x31, 0xbb, 0xc0, 0x5f, 0x40, 0x63, 0x4d, 0xb9, 0x27, 0xd6, 0x74, 0xcb, 0x92, 0x7e,
0x3f, 0x3c, 0xd4, 0xd5, 0x1c, 0x67, 0x98, 0x12, 0x48, 0xc6, 0x95, 0x5e, 0xc2, 0x0d, 0x5f, 0x29,
0xfb, 0xcd, 0x9c, 0x97, 0x44, 0x33, 0xdd, 0xf0, 0x15, 0x51, 0x0c, 0xfc, 0x11, 0x54, 0xa8, 0xbb,
0x55, 0xbd, 0x34, 0x07, 0xb7, 0x8b, 0xc4, 0xa7, 0xee, 0x96, 0xc8, 0xbc, 0xfd, 0x04, 0x1a, 0xc3,
0x5c, 0xf5, 0x23, 0x75, 0x2e, 0x6e, 0xe0, 0x9f, 0xb3, 0x48, 0x6c, 0x02, 0xae, 0xcc, 0x35, 0x48,
0x11, 0xb6, 0x7b, 0x60, 0xc8, 0x67, 0x61, 0x1b, 0x6e, 0xed, 0xf8, 0xe6, 0xa7, 0xf9, 0xe6, 0x42,
0xf7, 0x61, 0x90, 0x43, 0x6c, 0x0f, 0xa0, 0xf2, 0xd4, 0xdd, 0xe2, 0x4f, 0xa1, 0xca, 0xa2, 0x28,
0x88, 0x12, 0xcf, 0x77, 0x8b, 0x56, 0x4e, 0x65, 0x92, 0x68, 0x8e, 0xfd, 0x0a, 0x41, 0x55, 0x01,
0xd8, 0x01, 0xc3, 0x0d, 0x3c, 0x5d, 0xb5, 0x3d, 0xb0, 0x6f, 0x54, 0x39, 0x27, 0x81, 0xc7, 0x88,
0xe2, 0xe1, 0x2e, 0x34, 0x3d, 0x26, 0xdc, 0x68, 0x13, 0xc6, 0xd2, 0x77, 0x59, 0xf9, 0xce, 0x43,
0xbd, 0x27, 0x60, 0x48, 0x3e, 0x6e, 0x42, 0x7d, 0x31, 0xfe, 0x7a, 0x3c, 0xf9, 0x76, 0x6c, 0x96,
0x70, 0x17, 0xee, 0x2f, 0xc6, 0xb3, 0xc5, 0x74, 0x3a, 0x21, 0xf3, 0xd3, 0xaf, 0x5e, 0x4c, 0xc9,
0x64, 0x3e, 0x39, 0x99, 0x3c, 0x7f, 0x71, 0x7e, 0x4a, 0x66, 0xa3, 0xc9, 0xd8, 0x84, 0xde, 0xcf,
0x65, 0x68, 0xcd, 0x76, 0xcb, 0x43, 0x1d, 0xfc, 0x1c, 0xda, 0x42, 0xc7, 0x4b, 0x36, 0x0b, 0xa9,
0x9b, 0x9e, 0xe0, 0x83, 0xcc, 0x63, 0x8e, 0x9e, 0x06, 0x09, 0x97, 0x14, 0xb4, 0x98, 0x80, 0xb9,
0xe3, 0x85, 0x7a, 0x7a, 0xa7, 0x3e, 0xbe, 0xb9, 0xde, 0xa2, 0xc0, 0x26, 0x6f, 0xe8, 0xed, 0x87,
0xd0, 0xbe, 0xfe, 0x54, 0xf9, 0xed, 0x16, 0x61, 0x76, 0x2b, 0x1a, 0x24, 0x0d, 0xed, 0x47, 0x60,
0x16, 0x2b, 0xbe, 0x9d, 0xdd, 0xfb, 0xb7, 0x06, 0xc6, 0x6c, 0xcf, 0xdd, 0xb7, 0x53, 0xf0, 0xe7,
0x50, 0xbf, 0xd0, 0x37, 0x23, 0xe9, 0x23, 0x7f, 0x76, 0xdc, 0x75, 0x4e, 0x02, 0x1e, 0x33, 0x1e,
0x9f, 0x53, 0x7f, 0xc7, 0x48, 0x4a, 0xb5, 0xff, 0x41, 0xd0, 0xca, 0x67, 0xf0, 0x97, 0x00, 0xf2,
0xc2, 0x2f, 0x42, 0x8f, 0xc6, 0xe9, 0x0e, 0x5b, 0xd7, 0x2b, 0x0d, 0x0f, 0xf9, 0x61, 0x89, 0xe4,
0xd8, 0xf8, 0x0c, 0x8e, 0x5e, 0xee, 0x7c, 0x5f, 0x92, 0x88, 0xbe, 0xe0, 0x37, 0x5b, 0x39, 0xdb,
0xf9, 0xbe, 0x93, 0x30, 0x86, 0x25, 0x52, 0x14, 0xe1, 0x11, 0x98, 0x19, 0x24, 0xc2, 0x80, 0x0b,
0x96, 0x5c, 0xa8, 0x7b, 0x37, 0x16, 0xd2, 0x94, 0x61, 0x89, 0xbc, 0x21, 0x7b, 0x56, 0x87, 0xea,
0x0f, 0xb2, 0x2f, 0xfb, 0x0f, 0x04, 0x90, 0x19, 0xc7, 0x77, 0xa0, 0x2a, 0x8d, 0x0b, 0x0b, 0x75,
0x2b, 0xfd, 0x06, 0xd1, 0x01, 0xee, 0x43, 0x3d, 0x19, 0xab, 0x56, 0xb9, 0x5b, 0xe9, 0x37, 0x07,
0x6d, 0x87, 0xba, 0xbe, 0x43, 0xe8, 0x8f, 0x27, 0x0a, 0x26, 0x69, 0x1a, 0xbf, 0x0f, 0x35, 0x39,
0x4f, 0x93, 0xa9, 0xd5, 0x20, 0x49, 0x84, 0x7b, 0xd0, 0x12, 0x9c, 0x86, 0x62, 0x1d, 0xc4, 0x53,
0x1a, 0xaf, 0x2d, 0x43, 0x95, 0xbf, 0x86, 0xe1, 0xc7, 0x00, 0x92, 0xad, 0x07, 0xa7, 0x9a, 0x57,
0xcd, 0x81, 0xe9, 0xa8, 0xf1, 0x3c, 0x3f, 0xe0, 0x24, 0xc7, 0xb1, 0xff, 0x2b, 0x83, 0x21, 0x7b,
0xb5, 0x7f, 0x43, 0x50, 0x4f, 0x77, 0xe9, 0xdd, 0x6a, 0xe1, 0x77, 0x04, 0xb7, 0xd2, 0x53, 0x79,
0xb7, 0xac, 0x3f, 0x3c, 0x87, 0x66, 0xee, 0x37, 0x07, 0xdf, 0x85, 0xf7, 0x72, 0xa1, 0x9e, 0x8b,
0x66, 0x09, 0xdf, 0x83, 0x0f, 0xf2, 0x70, 0x6e, 0x74, 0x98, 0x08, 0xdf, 0x86, 0xa3, 0x6b, 0x1a,
0xee, 0x9a, 0xe5, 0x67, 0x0f, 0xfe, 0xbc, 0xec, 0xa0, 0xd7, 0x97, 0x1d, 0xf4, 0xf7, 0x65, 0x07,
0xbd, 0xba, 0xea, 0x94, 0x5e, 0x5f, 0x75, 0x4a, 0x7f, 0x5d, 0x75, 0x4a, 0xdf, 0xc1, 0xf1, 0xe1,
0x5f, 0xc2, 0xb2, 0xa6, 0x3e, 0x3e, 0xfb, 0x3f, 0x00, 0x00, 0xff, 0xff, 0x7a, 0xad, 0xe7, 0x46,
0x39, 0x08, 0x00, 0x00,
}
func (m *Message) Marshal() (dAtA []byte, err error) {
@ -1139,6 +1148,13 @@ func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.DebugInfo) > 0 {
i -= len(m.DebugInfo)
copy(dAtA[i:], m.DebugInfo)
i = encodeVarintSync(dAtA, i, uint64(len(m.DebugInfo)))
i--
dAtA[i] = 0x2a
}
if m.Type != 0 {
i = encodeVarintSync(dAtA, i, uint64(m.Type))
i--
@ -1887,6 +1903,10 @@ func (m *Header) Size() (n int) {
if m.Type != 0 {
n += 1 + sovSync(uint64(m.Type))
}
l = len(m.DebugInfo)
if l > 0 {
n += 1 + l + sovSync(uint64(l))
}
return n
}
@ -2433,6 +2453,38 @@ func (m *Header) Unmarshal(dAtA []byte) error {
break
}
}
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field DebugInfo", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowSync
}
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 ErrInvalidLengthSync
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthSync
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.DebugInfo = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipSync(dAtA[iNdEx:])